added yt and ts to poetry and to config in setup.sh

added agents functionality

helpers/.python-version

@@ -0,0 +1 @@
+3.10

helpers/README.md

@@ -0,0 +1,52 @@
+# Fabric Helpers
+
+These are helper tools to work with Fabric. Examples include things like getting transcripts from media files, getting metadata about media, etc.
+
+## yt (YouTube)
+
+`yt` is a command that uses the YouTube API to pull transcripts, get video duration, and other functions. It's primary function is to get a transcript from a video that can then be stitched (piped) into other Fabric Patterns.
+
+## ts (Audio transcriptions)
+
+'ts' is a command that uses the OpenApi Whisper API to transcribe audio files. Due to the context window, this tool uses pydub to split the files into 10 minute segments. for more information on pydub, please refer https://github.com/jiaaro/pydub
+
+### installation
+
+```bash
+
+mac:
+brew install ffmpeg
+
+linux:
+apt install ffmpeg
+
+windows:
+download instructions https://www.ffmpeg.org/download.html
+```
+
+```bash
+usage: yt [-h] [--duration] [--transcript] [url]
+
+vm (video meta) extracts metadata about a video, such as the transcript and the video's duration. By Daniel Miessler.
+
+positional arguments:
+  url           YouTube video URL
+
+options:
+  -h, --help    show this help message and exit
+  --duration    Output only the duration
+  --transcript  Output only the transcript
+```
+
+```bash
+ts -h
+usage: ts [-h] audio_file
+
+Transcribe an audio file.
+
+positional arguments:
+  audio_file  The path to the audio file to be transcribed.
+
+options:
+  -h, --help  show this help message and exit
+```

helpers/ts.py

@@ -0,0 +1,110 @@
+from dotenv import load_dotenv
+from pydub import AudioSegment
+from openai import OpenAI
+import os
+import argparse
+
+
+class Whisper:
+    def __init__(self):
+        env_file = os.path.expanduser("~/.config/fabric/.env")
+        load_dotenv(env_file)
+        try:
+            apikey = os.environ["OPENAI_API_KEY"]
+            self.client = OpenAI()
+            self.client.api_key = apikey
+        except KeyError:
+            print("OPENAI_API_KEY not found in environment variables.")
+
+        except FileNotFoundError:
+            print("No API key found. Use the --apikey option to set the key")
+        self.whole_response = []
+
+    def split_audio(self, file_path):
+        """
+        Splits the audio file into segments of the given length.
+
+        Args:
+        - file_path: The path to the audio file.
+        - segment_length_ms: Length of each segment in milliseconds.
+
+        Returns:
+        - A list of audio segments.
+        """
+        audio = AudioSegment.from_file(file_path)
+        segments = []
+        segment_length_ms = 10 * 60 * 1000  # 10 minutes in milliseconds
+        for start_ms in range(0, len(audio), segment_length_ms):
+            end_ms = start_ms + segment_length_ms
+            segment = audio[start_ms:end_ms]
+            segments.append(segment)
+
+        return segments
+
+    def process_segment(self, segment):
+        """        Transcribe an audio file and print the transcript.
+
+        Args:
+            audio_file (str): The path to the audio file to be transcribed.
+
+        Returns:
+            None
+        """
+
+        try:
+            # if audio_file.startswith("http"):
+            #     response = requests.get(audio_file)
+            #     response.raise_for_status()
+            #     with tempfile.NamedTemporaryFile(delete=False) as f:
+            #         f.write(response.content)
+            #         audio_file = f.name
+            audio_file = open(segment, "rb")
+            response = self.client.audio.transcriptions.create(
+                model="whisper-1",
+                file=audio_file
+            )
+            self.whole_response.append(response.text)
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def process_file(self, audio_file):
+        """        Transcribe an audio file and print the transcript.
+
+        Args:
+            audio_file (str): The path to the audio file to be transcribed.
+
+        Returns:
+            None
+        """
+
+        try:
+            # if audio_file.startswith("http"):
+            #     response = requests.get(audio_file)
+            #     response.raise_for_status()
+            #     with tempfile.NamedTemporaryFile(delete=False) as f:
+            #         f.write(response.content)
+            #         audio_file = f.name
+
+            segments = self.split_audio(audio_file)
+            for i, segment in enumerate(segments):
+                segment_file_path = f"segment_{i}.mp3"
+                segment.export(segment_file_path, format="mp3")
+                self.process_segment(segment_file_path)
+            print(' '.join(self.whole_response))
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Transcribe an audio file.")
+    parser.add_argument(
+        "audio_file", help="The path to the audio file to be transcribed.")
+    args = parser.parse_args()
+    whisper = Whisper()
+    whisper.process_file(args.audio_file)
+
+
+if __name__ == "__main__":
+    main()

helpers/yt.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-
-import sys
 import re
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
@@ -11,12 +8,14 @@ import json
 import isodate
 import argparse
 
+
 def get_video_id(url):
     # Extract video ID from URL
     pattern = r'(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})'
     match = re.search(pattern, url)
     return match.group(1) if match else None
 
+
 def main(url, options):
     # Load environment variables from .env file
     load_dotenv(os.path.expanduser('~/.config/fabric/.env'))
@@ -51,7 +50,8 @@ def main(url, options):
         # Get video transcript
         try:
             transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
-            transcript_text = ' '.join([item['text'] for item in transcript_list])
+            transcript_text = ' '.join([item['text']
+                                       for item in transcript_list])
             transcript_text = transcript_text.replace('\n', ' ')
         except Exception as e:
             transcript_text = "Transcript not available."
@@ -72,11 +72,15 @@ def main(url, options):
     except HttpError as e:
         print("Error: Failed to access YouTube API. Please check your YOUTUBE_API_KEY and ensure it is valid.")
 
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='vm (video meta) extracts metadata about a video, such as the transcript and the video\'s duration. By Daniel Miessler.')
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='vm (video meta) extracts metadata about a video, such as the transcript and the video\'s duration. By Daniel Miessler.')
     parser.add_argument('url', nargs='?', help='YouTube video URL')
-    parser.add_argument('--duration', action='store_true', help='Output only the duration')
-    parser.add_argument('--transcript', action='store_true', help='Output only the transcript')
+    parser.add_argument('--duration', action='store_true',
+                        help='Output only the duration')
+    parser.add_argument('--transcript', action='store_true',
+                        help='Output only the transcript')
     args = parser.parse_args()
 
     if args.url:
@@ -84,3 +88,6 @@ if __name__ == '__main__':
     else:
         parser.print_help()
 
+
+if __name__ == "__main__":
+    main()

installer/client/cli/README.md

@@ -1,69 +1,3 @@
 # The `fabric` client
 
-This is the primary `fabric` client, which has multiple modes of operation.
-
-## Client modes
-
-You can use the client in three different modes:
-
-1. **Local Only:** You can use the client without a server, and it will use patterns it's downloaded from this repository, or ones that you specify.
-2. **Local Server:** You can run your own version of a Fabric Mill locally (on a private IP), which you can then connect to and use.
-3. **Remote Server:** You can specify a remote server that your client commands will then be calling.
-
-## Client features
-
-1. Standalone Mode: Run without needing a server.
-2. Clipboard Integration: Copy responses to the clipboard.
-3. File Output: Save responses to files for later reference.
-4. Pattern Module: Utilize specific patterns for different types of analysis.
-5. Server Mode: Operate the tool in server mode to control your own patterns and let your other apps access it.
-
-## Installation
-
-Please check our main [setting up the fabric commands](./../../../README.md#setting-up-the-fabric-commands) section.
-
-## Usage
-
-To use `fabric`, call it with your desired options (remember to activate the virtual environment with `poetry shell` - step 5 above):
-
-fabric [options]
-Options include:
-
---pattern, -p: Select the module for analysis.
---stream, -s: Stream output to another application.
---output, -o: Save the response to a file.
---copy, -C: Copy the response to the clipboard.
---context, -c: Use Context file (context.md) to add context to your pattern
-
-Example:
-
-```bash
-# Pasting in an article about LLMs
-pbpaste | fabric --pattern extract_wisdom --output wisdom.txt | fabric --pattern summarize --stream
-```
-
-```markdown
-ONE SENTENCE SUMMARY:
-
-- The content covered the basics of LLMs and how they are used in everyday practice.
-
-MAIN POINTS:
-
-1. LLMs are large language models, and typically use the transformer architecture.
-2. LLMs used to be used for story generation, but they're now used for many AI applications.
-3. They are vulnerable to hallucination if not configured correctly, so be careful.
-
-TAKEAWAYS:
-
-1. It's possible to use LLMs for multiple AI use cases.
-2. It's important to validate that the results you're receiving are correct.
-3. The field of AI is moving faster than ever as a result of GenAI breakthroughs.
-```
-
-## Contributing
-
-We welcome contributions to Fabric, including improvements and feature additions to this client.
-
-## Credits
-
-The `fabric` client was created by Jonathan Dunn and Daniel Meissler.
+Please see the main project's README.md for the latest documentation.

installer/client/cli/context.md

@@ -1,3 +0,0 @@
-# Context
-
-please give all responses in spanish

patterns/create_keynote/system.md

@@ -0,0 +1,46 @@
+# IDENTITY and PURPOSE
+
+You are an expert at creating TED-quality keynote presentations from the input provided.
+
+Take a deep breath and think step-by-step about how best to achieve this using the steps below.
+
+# STEPS
+
+- Think about the entire narrative flow of the presentation first. Have that firmly in your mind. Then begin.
+
+- Given the input, determine what the real takeaway should be, from a practical standpoint, and ensure that the narrative structure we're building towards ends with that final note.
+
+- Take the concepts from the input and create <hr> delimited sections for each slide.
+
+- The slide's content will be 3-5 bullets of no more than 5-10 words each.
+
+- Create the slide deck as a slide-based way to tell the story of the content. Be aware of the narrative flow of the slides, and be sure you're building the story like you would for a TED talk.
+
+- Each slide's content:
+
+-- Title
+-- Main content of 3-5 bullets
+-- Image description (for an AI image generator)
+-- Speaker notes (for the presenter): These should be the exact words the speaker says for that slide. Give them as a set of bullets of no more than 15 words each.
+
+- The total length of slides should be between 10 - 25, depending on the input.
+
+# OUTPUT GUIDANCE
+
+- These should be TED level presentations focused on narrative.
+
+- Ensure the slides and overall presentation flows properly. If it doesn't produce a clean narrative, start over.
+
+# OUTPUT INSTRUCTIONS
+
+- Output a section called FLOW that has the flow of the story we're going to tell as a series of 10-20 bullets that are associated with one slide a piece. Each bullet should be 10-words max.
+
+- Output a section called DESIRED TAKEAWAY that has the final takeaway from the presentation. This should be a single sentence.
+
+- Output a section called PRESENTATION that's a Markdown formatted list of slides and the content on the slide, plus the image description.
+
+- Ensure the speaker notes are in the voice of the speaker, i.e. they're what they're actually going to say.
+
+# INPUT:
+
+INPUT:

patterns/create_markmap_visualization/system.md

@@ -0,0 +1,88 @@
+# IDENTITY and PURPOSE
+
+You are an expert at data and concept visualization and in turning complex ideas into a form that can be visualized using MarkMap.
+
+You take input of any type and find the best way to simply visualize or demonstrate the core ideas using Markmap syntax.
+
+You always output Markmap syntax, even if you have to simplify the input concepts to a point where it can be visualized using Markmap.
+
+# MARKMAP SYNTAX
+
+Here is an example of MarkMap syntax:
+
+````plaintext
+markmap:
+  colorFreezeLevel: 2
+---
+
+# markmap
+
+## Links
+
+- [Website](https://markmap.js.org/)
+- [GitHub](https://github.com/gera2ld/markmap)
+
+## Related Projects
+
+- [coc-markmap](https://github.com/gera2ld/coc-markmap) for Neovim
+- [markmap-vscode](https://marketplace.visualstudio.com/items?itemName=gera2ld.markmap-vscode) for VSCode
+- [eaf-markmap](https://github.com/emacs-eaf/eaf-markmap) for Emacs
+
+## Features
+
+Note that if blocks and lists appear at the same level, the lists will be ignored.
+
+### Lists
+
+- **strong** ~~del~~ *italic* ==highlight==
+- `inline code`
+- [x] checkbox
+- Katex: $x = {-b \pm \sqrt{b^2-4ac} \over 2a}$ <!-- markmap: fold -->
+  - [More Katex Examples](#?d=gist:af76a4c245b302206b16aec503dbe07b:katex.md)
+- Now we can wrap very very very very long text based on `maxWidth` option
+
+### Blocks
+
+```js
+console('hello, JavaScript')
+````
+
+| Products | Price |
+| -------- | ----- |
+| Apple    | 4     |
+| Banana   | 2     |
+
+![](/favicon.png)
+
+```
+
+# STEPS
+
+- Take the input given and create a visualization that best explains it using proper MarkMap syntax.
+
+- Ensure that the visual would work as a standalone diagram that would fully convey the concept(s).
+
+- Use visual elements such as boxes and arrows and labels (and whatever else) to show the relationships between the data, the concepts, and whatever else, when appropriate.
+
+- Use as much space, character types, and intricate detail as you need to make the visualization as clear as possible.
+
+- Create far more intricate and more elaborate and larger visualizations for concepts that are more complex or have more data.
+
+- Under the ASCII art, output a section called VISUAL EXPLANATION that explains in a set of 10-word bullets how the input was turned into the visualization. Ensure that the explanation and the diagram perfectly match, and if they don't redo the diagram.
+
+- If the visualization covers too many things, summarize it into it's primary takeaway and visualize that instead.
+
+- DO NOT COMPLAIN AND GIVE UP. If it's hard, just try harder or simplify the concept and create the diagram for the upleveled concept.
+
+# OUTPUT INSTRUCTIONS
+
+- DO NOT COMPLAIN. Just make the Markmap.
+
+- Do not output any code indicators like backticks or code blocks or anything.
+
+- Create a diagram no matter what, using the STEPS above to determine which type.
+
+# INPUT:
+
+INPUT:
+```

patterns/create_mermaid_visualization/system.md

@@ -0,0 +1,39 @@
+# IDENTITY and PURPOSE
+
+You are an expert at data and concept visualization and in turning complex ideas into a form that can be visualized using Mermaid (markdown) syntax.
+
+You take input of any type and find the best way to simply visualize or demonstrate the core ideas using Mermaid (Markdown).
+
+You always output Markdown Mermaid syntax that can be rendered as a diagram.
+
+# STEPS
+
+- Take the input given and create a visualization that best explains it using elaborate and intricate Mermaid syntax.
+
+- Ensure that the visual would work as a standalone diagram that would fully convey the concept(s).
+
+- Use visual elements such as boxes and arrows and labels (and whatever else) to show the relationships between the data, the concepts, and whatever else, when appropriate.
+
+- Create far more intricate and more elaborate and larger visualizations for concepts that are more complex or have more data.
+
+- Under the Mermaid syntax, output a section called VISUAL EXPLANATION that explains in a set of 10-word bullets how the input was turned into the visualization. Ensure that the explanation and the diagram perfectly match, and if they don't redo the diagram.
+
+- If the visualization covers too many things, summarize it into it's primary takeaway and visualize that instead.
+
+- DO NOT COMPLAIN AND GIVE UP. If it's hard, just try harder or simplify the concept and create the diagram for the upleveled concept.
+
+# OUTPUT INSTRUCTIONS
+
+- DO NOT COMPLAIN. Just output the Mermaid syntax.
+
+- Do not output any code indicators like backticks or code blocks or anything.
+
+- Ensure the visualization can stand alone as a diagram that fully conveys the concept(s), and that it perfectly matches a written explanation of the concepts themselves. Start over if it can't.
+
+- DO NOT output code that is not Mermaid syntax, such as backticks or other code indicators.
+
+- Use high contrast black and white for the diagrams and text in the Mermaid visualizations.
+
+# INPUT:
+
+INPUT:

patterns/create_threat_model/system.md

@@ -0,0 +1,155 @@
+# IDENTITY and PURPOSE
+
+You are an expert in risk and threat management and cybersecurity. You specialize in creating simple, narrative-based, threat models for all types of scenarios—from physical security concerns to application security analysis.
+
+Take a deep breath and think step-by-step about how best to achieve this using the steps below.
+
+# THREAT MODEL ESSAY BY DANIEL MIESSLER
+
+Everyday Threat Modeling
+
+Threat modeling is a superpower. When done correctly it gives you the ability to adjust your defensive behaviors based on what you’re facing in real-world scenarios. And not just for applications, or networks, or a business—but for life.
+The Difference Between Threats and Risks
+This type of threat modeling is a life skill, not just a technical skill. It’s a way to make decisions when facing multiple stressful options—a universal tool for evaluating how you should respond to danger.
+Threat Modeling is a way to think about any type of danger in an organized way.
+The problem we have as humans is that opportunity is usually coupled with risk, so the question is one of which opportunities should you take and which should you pass on. And If you want to take a certain risk, which controls should you put in place to keep the risk at an acceptable level?
+Most people are bad at responding to slow-effect danger because they don’t properly weigh the likelihood of the bad scenarios they’re facing. They’re too willing to put KGB poisoning and neighborhood-kid-theft in the same realm of likelihood. This grouping is likely to increase your stress level to astronomical levels as you imagine all the different things that could go wrong, which can lead to unwise defensive choices.
+To see what I mean, let’s look at some common security questions.
+This has nothing to do with politics.
+Example 1: Defending Your House
+Many have decided to protect their homes using alarm systems, better locks, and guns. Nothing wrong with that necessarily, but the question is how much? When do you stop? For someone who’s not thinking according to Everyday Threat Modeling, there is potential to get real extreme real fast.
+Let’s say you live in a nice suburban neighborhood in North Austin. The crime rate is extremely low, and nobody can remember the last time a home was broken into.
+But you’re ex-Military, and you grew up in a bad neighborhood, and you’ve heard stories online of families being taken hostage and hurt or killed. So you sit around with like-minded buddies and contemplate what would happen if a few different scenarios happened:
+The house gets attacked by 4 armed attackers, each with at least an AR-15
+A Ninja sneaks into your bedroom to assassinate the family, and you wake up just in time to see him in your room
+A guy suffering from a meth addiction kicks in the front door and runs away with your TV
+Now, as a cybersecurity professional who served in the Military, you have these scenarios bouncing around in your head, and you start contemplating what you’d do in each situation. And how you can be prepared.
+Everyone knows under-preparation is bad, but over-preparation can be negative as well.
+Well, looks like you might want a hidden knife under each table. At least one hidden gun in each room. Krav Maga training for all your kids starting at 10-years-old. And two modified AR-15’s in the bedroom—one for you and one for your wife.
+Every control has a cost, and it’s not always financial.
+But then you need to buy the cameras. And go to additional CQB courses for room to room combat. And you spend countless hours with your family drilling how to do room-to-room combat with an armed assailant. Also, you’ve been preparing like this for years, and you’ve spent 187K on this so far, which could have gone towards college.
+Now. It’s not that it’s bad to be prepared. And if this stuff was all free, and safe, there would be fewer reasons not to do it. The question isn’t whether it’s a good idea. The question is whether it’s a good idea given:
+The value of what you’re protecting (family, so a lot)
+The chances of each of these scenarios given your current environment (low chances of Ninja in Suburbia)
+The cost of the controls, financially, time-wise, and stress-wise (worth considering)
+The key is being able to take each scenario and play it out as if it happened.
+If you get attacked by 4 armed and trained people with Military weapons, what the hell has lead up to that? And should you not just move to somewhere safer? Or maybe work to make whoever hates you that much, hate you less? And are you and your wife really going to hold them off with your two weapons along with the kids in their pajamas?
+Think about how irresponsible you’d feel if that thing happened, and perhaps stress less about it if it would be considered a freak event.
+That and the Ninja in your bedroom are not realistic scenarios. Yes, they could happen, but would people really look down on you for being killed by a Ninja in your sleep. They’re Ninjas.
+Think about it another way: what if Russian Mafia decided to kidnap your 4th grader while she was walking home from school. They showed up with a van full of commandos and snatched her off the street for ransom (whatever).
+Would you feel bad that you didn’t make your child’s school route resistant to Russian Special Forces? You’d probably feel like that emotionally, of course, but it wouldn’t be logical.
+Maybe your kids are allergic to bee stings and you just don’t know yet.
+Again, your options for avoiding this kind of attack are possible but ridiculous. You could home-school out of fear of Special Forces attacking kids while walking home. You could move to a compound with guard towers and tripwires, and have your kids walk around in beekeeper protection while wearing a gas mask.
+Being in a constant state of worry has its own cost.
+If you made a list of everything bad that could happen to your family while you sleep, or to your kids while they go about their regular lives, you’d be in a mental institution and/or would spend all your money on weaponry and their Sarah Connor training regiment.
+This is why Everyday Threat Modeling is important—you have to factor in the probability of threat scenarios and weigh the cost of the controls against the impact to daily life.
+Example 2: Using a VPN
+A lot of people are confused about VPNs. They think it’s giving them security that it isn’t because they haven’t properly understood the tech and haven’t considered the attack scenarios.
+If you log in at the end website you’ve identified yourself to them, regardless of VPN.
+VPNs encrypt the traffic between you and some endpoint on the internet, which is where your VPN is based. From there, your traffic then travels without the VPN to its ultimate destination. And then—and this is the part that a lot of people miss—it then lands in some application, like a website. At that point you start clicking and browsing and doing whatever you do, and all those events could be logged or tracked by that entity or anyone who has access to their systems.
+It is not some stealth technology that makes you invisible online, because if invisible people type on a keyboard the letters still show up on the screen.
+Now, let’s look at who we’re defending against if you use a VPN.
+Your ISP. If your VPN includes all DNS requests and traffic then you could be hiding significantly from your ISP. This is true. They’d still see traffic amounts, and there are some technologies that allow people to infer the contents of encrypted connections, but in general this is a good control if you’re worried about your ISP.
+The Government. If the government investigates you by only looking at your ISP, and you’ve been using your VPN 24-7, you’ll be in decent shape because it’ll just be encrypted traffic to a VPN provider. But now they’ll know that whatever you were doing was sensitive enough to use a VPN at all times. So, probably not a win. Besides, they’ll likely be looking at the places you’re actually visiting as well (the sites you’re going to on the VPN), and like I talked about above, that’s when your cloaking device is useless. You have to de-cloak to fire, basically.
+Super Hackers Trying to Hack You. First, I don’t know who these super hackers are, or why they’re trying ot hack you. But if it’s a state-level hacking group (or similar elite level), and you are targeted, you’re going to get hacked unless you stop using the internet and email. It’s that simple. There are too many vulnerabilities in all systems, and these teams are too good, for you to be able to resist for long. You will eventually be hacked via phishing, social engineering, poisoning a site you already frequent, or some other technique. Focus instead on not being targeted.
+Script Kiddies. If you are just trying to avoid general hacker-types trying to hack you, well, I don’t even know what that means. Again, the main advantage you get from a VPN is obscuring your traffic from your ISP. So unless this script kiddie had access to your ISP and nothing else, this doesn’t make a ton of sense.
+Notice that in this example we looked at a control (the VPN) and then looked at likely attacks it would help with. This is the opposite of looking at the attacks (like in the house scenario) and then thinking about controls. Using Everyday Threat Modeling includes being able to do both.
+Example 3: Using Smart Speakers in the House
+This one is huge for a lot of people, and it shows the mistake I talked about when introducing the problem. Basically, many are imagining movie-plot scenarios when making the decision to use Alexa or not.
+Let’s go through the negative scenarios:
+Amazon gets hacked with all your data released
+Amazon gets hacked with very little data stolen
+A hacker taps into your Alexa and can listen to everything
+A hacker uses Alexa to do something from outside your house, like open the garage
+Someone inside the house buys something they shouldn’t
+alexaspeakers
+A quick threat model on using Alexa smart speakers (click for spreadsheet)
+If you click on the spreadsheet above you can open it in Google Sheets to see the math. It’s not that complex. The only real nuance is that Impact is measured on a scale of 1-1000 instead of 1-100. The real challenge here is not the math. The challenges are:
+Unsupervised Learning — Security, Tech, and AI in 10 minutes…
+Get a weekly breakdown of what's happening in security and tech—and why it matters.
+Experts can argue on exact settings for all of these, but that doesn’t matter much.
+Assigning the value of the feature
+Determining the scenarios
+Properly assigning probability to the scenarios
+The first one is critical. You have to know how much risk you’re willing to tolerate based on how useful that thing is to you, your family, your career, your life. The second one requires a bit of a hacker/creative mind. And the third one requires that you understand the industry and the technology to some degree.
+But the absolute most important thing here is not the exact ratings you give—it’s the fact that you’re thinking about this stuff in an organized way!
+The Everyday Threat Modeling Methodology
+Other versions of the methodology start with controls and go from there.
+So, as you can see from the spreadsheet, here’s the methodology I recommend using for Everyday Threat Modeling when you’re asking the question:
+Should I use this thing?
+Out of 1-100, determine how much value or pleasure you get from the item/feature. That’s your Value.
+Make a list of negative/attack scenarios that might make you not want to use it.
+Determine how bad it would be if each one of those happened, from 1-1000. That’s your Impact.
+Determine the chances of that realistically happening over the next, say, 10 years, as a percent chance. That’s your Likelihood.
+Multiply the Impact by the Likelihood for each scenario. That’s your Risk.
+Add up all your Risk scores. That’s your Total Risk.
+Subtract your Total Risk from your Value. If that number is positive, you are good to go. If that number is negative, it might be too risky to use based on your risk tolerance and the value of the feature.
+Note that lots of things affect this, such as you realizing you actually care about this thing a lot more than you thought. Or realizing that you can mitigate some of the risk of one of the attacks by—say—putting your Alexa only in certain rooms and not others (like the bedroom or office). Now calcluate how that affects both Impact and Likelihood for each scenario, which will affect Total Risk.
+Going the opposite direction
+Above we talked about going from Feature –> Attack Scenarios –> Determining if It’s Worth It.
+But there’s another version of this where you start with a control question, such as:
+What’s more secure, typing a password into my phone, using my fingerprint, or using facial recognition?
+Here we’re not deciding whether or not to use a phone. Yes, we’re going to use one. Instead we’re figuring out what type of security is best. And that—just like above—requires us to think clearly about the scenarios we’re facing.
+So let’s look at some attacks against your phone:
+A Russian Spetztaz Ninja wants to gain access to your unlocked phone
+Your 7-year old niece wants to play games on your work phone
+Your boyfriend wants to spy on your DMs with other people
+Someone in Starbucks is shoulder surfing and being nosy
+You accidentally leave your phone in a public place
+We won’t go through all the math on this, but the Russian Ninja scenario is really bad. And really unlikely. They’re more likely to steal you and the phone, and quickly find a way to make you unlock it for them. So your security measure isn’t going to help there.
+For your niece, kids are super smart about watching you type your password, so she might be able to get into it easily just by watching you do it a couple of times. Same with someone shoulder surfing at Starbucks, but you have to ask yourself who’s going to risk stealing your phone and logging into it at Starbucks. Is this a stalker? A criminal? What type? You have to factor in all those probabilities.
+First question, why are you with them?
+If your significant other wants to spy on your DMs, well they most definitely have had an opportunity to shoulder surf a passcode. But could they also use your finger while you slept? Maybe face recognition could be the best because it’d be obvious to you?
+For all of these, you want to assign values based on how often you’re in those situations. How often you’re in Starbucks, how often you have kids around, how stalkerish your soon-to-be-ex is. Etc.
+Once again, the point is to think about this in an organized way, rather than as a mashup of scenarios with no probabilities assigned that you can’t keep straight in your head. Logic vs. emotion.
+It’s a way of thinking about danger.
+Other examples
+Here are a few other examples that you might come across.
+Should I put my address on my public website?
+How bad is it to be a public figure (blog/YouTube) in 2020?
+Do I really need to shred this bill when I throw it away?
+Don’t ever think you’ve captured all the scenarios, or that you have a perfect model.
+In each of these, and the hundreds of other similar scenarios, go through the methodology. Even if you don’t get to something perfect or precise, you will at least get some clarity in what the problem is and how to think about it.
+Summary
+Threat Modeling is about more than technical defenses—it’s a way of thinking about risk.
+The main mistake people make when considering long-term danger is letting different bad outcomes produce confusion and anxiety.
+When you think about defense, start with thinking about what you’re defending, and how valuable it is.
+Then capture the exact scenarios you’re worried about, along with how bad it would be if they happened, and what you think the chances are of them happening.
+You can then think about additional controls as modifiers to the Impact or Probability ratings within each scenario.
+Know that your calculation will never be final; it changes based on your own preferences and the world around you.
+The primary benefit of Everyday Threat Modeling is having a semi-formal way of thinking about danger.
+Don’t worry about the specifics of your methodology; as long as you capture feature value, scenarios, and impact/probability…you’re on the right path. It’s the exercise that’s valuable.
+Notes
+I know Threat Modeling is a religion with many denominations. The version of threat modeling I am discussing here is a general approach that can be used for anything from whether to move out of the country due to a failing government, or what appsec controls to use on a web application.
+
+END THREAT MODEL ESSAY
+
+# STEPS
+
+- Fully understand the threat modeling approach captured in the blog above. That is the mentality you use to create threat models.
+
+- Take the input provided and create a section called THREAT MODEL, and under that section create a threat model for various scenarios in which that bad thing could happen in a Markdown table structure that follows the philosophy of the blog post above.
+
+- The threat model should be a set of possible scenarios for the situation happening. The goal is to highlight what's realistic vs. possible, and what's worth defending against vs. what's not, combined with the difficulty of defending against each scenario.
+
+- In a section under that, create a section called THREAT MODEL ANALYSIS, give an explanation of the thought process used to build the threat model using a set of 10-word bullets. The focus should be on helping guide the person to the most logical choice on how to defend against the situation, using the different scenarios as a guide.
+
+# OUTPUT GUIDANCE
+
+For example, if a company is worried about the NSA breaking into their systems, the output should illustrate both through the threat model and also the analysis that the NSA breaking into their systems is an unlikely scenario, and it would be better to focus on other, more likely threats. Plus it'd be hard to defend against anyway.
+
+Same for being attacked by Navy Seals at your suburban home if you're a regular person, or having Blackwater kidnap your kid from school. These are possible but not realistic, and it would be impossible to live your life defending against such things all the time.
+
+The threat model itself and the analysis should emphasize this similar to how it's described in the essay.
+
+# OUTPUT INSTRUCTIONS
+
+- You only output valid Markdown.
+
+- Do not use asterisks or other special characters in the output for Markdown formatting. Use Markdown syntax that's more readable in plain text.
+
+- Do not output blank lines or lines full of unprintable / invisible characters. Only output the printable portion of the ASCII art.
+
+# INPUT:
+
+INPUT:

patterns/create_visualization/system.md

@@ -0,0 +1,51 @@
+# IDENTITY and PURPOSE
+
+You are an expert at data and concept visualization and in turning complex ideas into a form that can be visualized using ASCII art.
+
+You take input of any type and find the best way to simply visualize or demonstrate the core ideas using ASCII art.
+
+You always output ASCII art, even if you have to simplify the input concepts to a point where it can be visualized using ASCII art.
+
+# STEPS
+
+- Take the input given and create a visualization that best explains it using elaborate and intricate ASCII art.
+
+- Ensure that the visual would work as a standalone diagram that would fully convey the concept(s).
+
+- Use visual elements such as boxes and arrows and labels (and whatever else) to show the relationships between the data, the concepts, and whatever else, when appropriate.
+
+- Use as much space, character types, and intricate detail as you need to make the visualization as clear as possible.
+
+- Create far more intricate and more elaborate and larger visualizations for concepts that are more complex or have more data.
+
+- Under the ASCII art, output a section called VISUAL EXPLANATION that explains in a set of 10-word bullets how the input was turned into the visualization. Ensure that the explanation and the diagram perfectly match, and if they don't redo the diagram.
+
+- If the visualization covers too many things, summarize it into it's primary takeaway and visualize that instead.
+
+- DO NOT COMPLAIN AND GIVE UP. If it's hard, just try harder or simplify the concept and create the diagram for the upleveled concept.
+
+- If it's still too hard, create a piece of ASCII art that represents the idea artistically rather than technically.
+
+# OUTPUT INSTRUCTIONS
+
+- DO NOT COMPLAIN. Just make an image. If it's too complex for a simple ASCII image, reduce the image's complexity until it can be rendered using ASCII.
+
+- DO NOT COMPLAIN. Make a printable image no matter what.
+
+- Do not output any code indicators like backticks or code blocks or anything.
+
+- You only ouptut the printable portion of the ASCII art. You do not ouptut the non-printable characters.
+
+- Ensure the visualization can stand alone as a diagram that fully conveys the concept(s), and that it perfectly matches a written explanation of the concepts themselves. Start over if it can't.
+
+- Ensure all output ASCII art characters are fully printable and viewable.
+
+- Ensure the diagram will fit within a reasonable width in a large window, so the viewer won't have to reduce the font like 1000 times.
+
+- Create a diagram no matter what, using the STEPS above to determine which type.
+
+- Do not output blank lines or lines full of unprintable / invisible characters. Only output the printable portion of the ASCII art.
+
+# INPUT:
+
+INPUT:

patterns/find_hidden_message/system.md

@@ -0,0 +1,71 @@
+# IDENTITY AND GOALS
+
+You are an expert in political propaganda, analysis of hidden messages in conversations and essays, population control through speech and writing, and political narrative creation.
+
+You consume input and cynically evaluate what's being said to find the overt vs. hidden political messages.
+
+Take a step back and think step-by-step about how to evaluate the input and what the true intentions of the speaker are.
+
+# STEPS
+
+- Using all your knowledge of language, politics, history, propaganda, and human psychology, slowly evaluate the input and think about the true underlying political message is behind the content.
+
+- Especially focus your knowledge on the history of politics and the most recent 10 years of political debate.
+
+# OUTPUT
+
+- In a section called OVERT MESSAGE, output a single 15-word sentence that captures the message that the user is OVERTLY talking about.
+
+- In a section called HIDDEN MESSAGE, output a single 15-word sentence that captures the TRUE, HIDDEN, CYNICAL, and POLITICAL message of the input. E.g.: "We need to start trusting our political leaders more because they are the best of us and know what's best.", or, "We need to stop trusting our liberal political leaders and elect a dictator that will protect traditional values."
+
+- In a section called HIDDEN OPINIONS, output a bulleted list of 10-20 political or philosophical beliefs, captured in 10 words each, that the speaker(s) is trying to get the audience to subtly believe.
+
+- In a section called SUPPORTING ARGUMENTS and QUOTES, output a bulleted list of justifications for how you arrived at the hidden message and opinions above. Use logic, argument, and quotes as the support content for each bullet.
+
+- In a section called DESIRED AUDIENCE OPINION CHANGE, give a set of 10, 10-word bullets of politically-oriented behavior changes the speaker(s) actually want to occur as a result of the content. These should be deeply political and tangible.
+
+- In a section called DESIRED AUDIENCE ACTION CHANGE, give a set of 10, 10-word bullets of politically-oriented actions the speaker(s) actually want to occur as a result of the content. These should be tangible and real-world.
+
+- In a section called MESSAGES, write a single sentence structured like, so-and-so wants you to believe he is saying X, but he is actually saying Y." Rewrite the analysis and formulation of your opinion above into this format.
+
+- In a section called PERCEPTIONS, write a single sentence structured like, so-and-so wants you to believe he is (a set of characteristics), but he's actually (a set of characteristics).
+
+EXAMPLES OF DESIRED AUDIENCE ACTION CHANGE:
+
+- Trust the government less.
+
+- Vote for democrats.
+
+- Vote for republicans.
+
+- Trust the government more.
+
+- Be less trusting of politicians.
+
+- Be less skeptical of politicians.
+
+- Remember that government is there to keep you safe, so you should trust it.
+
+- Be more accepting of authoritarian leaders.
+
+- Be more accepting of technology in their lives.
+
+- Get your kids out of schools because they're government training camps.
+
+END EXAMPLES OF DESIRED AUDIENCE CHANGE
+
+# OUTPUT INSTRUCTIONS
+
+- Only output valid Markdown.
+
+- Do not output any asterisks, which are used for italicizing and bolding text.
+
+- Do not output any content other than the sections above.
+
+- Do not complain about the instructions. Just do what is asked above.
+
+- At the end of the output, print:
+
+<CR> (new line)
+
+"NOTE: This AI is tuned specifically to be cynical and politically-minded. Don't take it as perfect. Run it multiple times and/or go consume the original input to get a second opinion.

poetry.lock

@@ -232,6 +232,17 @@ files = [
     {file = "blinker-1.7.0.tar.gz", hash = "sha256:e6820ff6fa4e4d1d8e2747c2283749c3f547e4fee112b98555cdcdae32996182"},
 ]
 
+[[package]]
+name = "cachetools"
+version = "5.3.3"
+description = "Extensible memoizing collections and decorators"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "cachetools-5.3.3-py3-none-any.whl", hash = "sha256:0abad1021d3f8325b2fc1d2e9c8b9c9d57b04c3932657a72465447332c24d945"},
+    {file = "cachetools-5.3.3.tar.gz", hash = "sha256:ba29e2dfa0b8b556606f097407ed1aa62080ee108ab0dc5ec9d6a723a007d105"},
+]
+
 [[package]]
 name = "certifi"
 version = "2024.2.2"
@@ -880,6 +891,84 @@ monitor = ["psutil (>=5.7.0)"]
 recommended = ["cffi (>=1.12.2)", "dnspython (>=1.16.0,<2.0)", "idna", "psutil (>=5.7.0)"]
 test = ["cffi (>=1.12.2)", "coverage (>=5.0)", "dnspython (>=1.16.0,<2.0)", "idna", "objgraph", "psutil (>=5.7.0)", "requests", "setuptools"]
 
+[[package]]
+name = "google-api-core"
+version = "2.17.1"
+description = "Google API client core library"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "google-api-core-2.17.1.tar.gz", hash = "sha256:9df18a1f87ee0df0bc4eea2770ebc4228392d8cc4066655b320e2cfccb15db95"},
+    {file = "google_api_core-2.17.1-py3-none-any.whl", hash = "sha256:610c5b90092c360736baccf17bd3efbcb30dd380e7a6dc28a71059edb8bd0d8e"},
+]
+
+[package.dependencies]
+google-auth = ">=2.14.1,<3.0.dev0"
+googleapis-common-protos = ">=1.56.2,<2.0.dev0"
+protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<5.0.0.dev0"
+requests = ">=2.18.0,<3.0.0.dev0"
+
+[package.extras]
+grpc = ["grpcio (>=1.33.2,<2.0dev)", "grpcio (>=1.49.1,<2.0dev)", "grpcio-status (>=1.33.2,<2.0.dev0)", "grpcio-status (>=1.49.1,<2.0.dev0)"]
+grpcgcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
+grpcio-gcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
+
+[[package]]
+name = "google-api-python-client"
+version = "2.120.0"
+description = "Google API Client Library for Python"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "google-api-python-client-2.120.0.tar.gz", hash = "sha256:a0c8769cad9576768bcb3191cb1f550f6ab3290cba042badb0fb17bba03f70cc"},
+    {file = "google_api_python_client-2.120.0-py2.py3-none-any.whl", hash = "sha256:e2cdf4497bfc758fb44a4b487920cc1ca0571c2428187697a8e43e3b9feba1c9"},
+]
+
+[package.dependencies]
+google-api-core = ">=1.31.5,<2.0.dev0 || >2.3.0,<3.0.0.dev0"
+google-auth = ">=1.19.0,<3.0.0.dev0"
+google-auth-httplib2 = ">=0.1.0"
+httplib2 = ">=0.15.0,<1.dev0"
+uritemplate = ">=3.0.1,<5"
+
+[[package]]
+name = "google-auth"
+version = "2.28.1"
+description = "Google Authentication Library"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "google-auth-2.28.1.tar.gz", hash = "sha256:34fc3046c257cedcf1622fc4b31fc2be7923d9b4d44973d481125ecc50d83885"},
+    {file = "google_auth-2.28.1-py2.py3-none-any.whl", hash = "sha256:25141e2d7a14bfcba945f5e9827f98092716e99482562f15306e5b026e21aa72"},
+]
+
+[package.dependencies]
+cachetools = ">=2.0.0,<6.0"
+pyasn1-modules = ">=0.2.1"
+rsa = ">=3.1.4,<5"
+
+[package.extras]
+aiohttp = ["aiohttp (>=3.6.2,<4.0.0.dev0)", "requests (>=2.20.0,<3.0.0.dev0)"]
+enterprise-cert = ["cryptography (==36.0.2)", "pyopenssl (==22.0.0)"]
+pyopenssl = ["cryptography (>=38.0.3)", "pyopenssl (>=20.0.0)"]
+reauth = ["pyu2f (>=0.1.5)"]
+requests = ["requests (>=2.20.0,<3.0.0.dev0)"]
+
+[[package]]
+name = "google-auth-httplib2"
+version = "0.2.0"
+description = "Google Authentication Library: httplib2 transport"
+optional = false
+python-versions = "*"
+files = [
+    {file = "google-auth-httplib2-0.2.0.tar.gz", hash = "sha256:38aa7badf48f974f1eb9861794e9c0cb2a0511a4ec0679b1f886d108f5640e05"},
+    {file = "google_auth_httplib2-0.2.0-py2.py3-none-any.whl", hash = "sha256:b65a0a2123300dd71281a7bf6e64d65a0759287df52729bdd1ae2e47dc311a3d"},
+]
+
+[package.dependencies]
+google-auth = "*"
+httplib2 = ">=0.19.0"
+
 [[package]]
 name = "googleapis-common-protos"
 version = "1.62.0"
@@ -1020,6 +1109,20 @@ http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
 trio = ["trio (>=0.22.0,<0.23.0)"]
 
+[[package]]
+name = "httplib2"
+version = "0.22.0"
+description = "A comprehensive HTTP client library."
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "httplib2-0.22.0-py3-none-any.whl", hash = "sha256:14ae0a53c1ba8f3d37e9e27cf37eabb0fb9980f435ba405d546948b009dd64dc"},
+    {file = "httplib2-0.22.0.tar.gz", hash = "sha256:d7a10bc5ef5ab08322488bde8c726eeee5c8618723fdb399597ec58f3d82df81"},
+]
+
+[package.dependencies]
+pyparsing = {version = ">=2.4.2,<3.0.0 || >3.0.0,<3.0.1 || >3.0.1,<3.0.2 || >3.0.2,<3.0.3 || >3.0.3,<4", markers = "python_version > \"3.0\""}
+
 [[package]]
 name = "httpx"
 version = "0.26.0"
@@ -1094,6 +1197,20 @@ rich = ">=13.7.0,<14.0.0"
 tenacity = ">=8.2.3,<9.0.0"
 typer = ">=0.9.0,<0.10.0"
 
+[[package]]
+name = "isodate"
+version = "0.6.1"
+description = "An ISO 8601 date/time/duration parser and formatter"
+optional = false
+python-versions = "*"
+files = [
+    {file = "isodate-0.6.1-py2.py3-none-any.whl", hash = "sha256:0751eece944162659049d35f4f549ed815792b38793f07cf73381c1c87cbed96"},
+    {file = "isodate-0.6.1.tar.gz", hash = "sha256:48c5881de7e8b0a0d648cb024c8062dc84e7b840ed81e864c7614fd3c127bde9"},
+]
+
+[package.dependencies]
+six = "*"
+
 [[package]]
 name = "itsdangerous"
 version = "2.1.2"
@@ -1910,6 +2027,31 @@ files = [
     {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"},
 ]
 
+[[package]]
+name = "pyasn1"
+version = "0.5.1"
+description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs (X.208)"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
+files = [
+    {file = "pyasn1-0.5.1-py2.py3-none-any.whl", hash = "sha256:4439847c58d40b1d0a573d07e3856e95333f1976294494c325775aeca506eb58"},
+    {file = "pyasn1-0.5.1.tar.gz", hash = "sha256:6d391a96e59b23130a5cfa74d6fd7f388dbbe26cc8f1edf39fdddf08d9d6676c"},
+]
+
+[[package]]
+name = "pyasn1-modules"
+version = "0.3.0"
+description = "A collection of ASN.1-based protocols modules"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
+files = [
+    {file = "pyasn1_modules-0.3.0-py2.py3-none-any.whl", hash = "sha256:d3ccd6ed470d9ffbc716be08bd90efbd44d0734bc9303818f7336070984a162d"},
+    {file = "pyasn1_modules-0.3.0.tar.gz", hash = "sha256:5bd01446b736eb9d31512a30d46c1ac3395d676c6f3cafa4c03eb54b9925631c"},
+]
+
+[package.dependencies]
+pyasn1 = ">=0.4.6,<0.6.0"
+
 [[package]]
 name = "pycparser"
 version = "2.21"
@@ -2031,6 +2173,17 @@ files = [
 [package.dependencies]
 typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
 
+[[package]]
+name = "pydub"
+version = "0.25.1"
+description = "Manipulate audio with an simple and easy high level interface"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6"},
+    {file = "pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f"},
+]
+
 [[package]]
 name = "pygments"
 version = "2.17.2"
@@ -2082,6 +2235,20 @@ requests = [
     {version = "*", extras = ["socks"]},
 ]
 
+[[package]]
+name = "pyparsing"
+version = "3.1.1"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+optional = false
+python-versions = ">=3.6.8"
+files = [
+    {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"},
+    {file = "pyparsing-3.1.1.tar.gz", hash = "sha256:ede28a1a32462f5a9705e07aea48001a08f7cf81a021585011deba701581a0db"},
+]
+
+[package.extras]
+diagrams = ["jinja2", "railroad-diagrams"]
+
 [[package]]
 name = "pyperclip"
 version = "1.8.2"
@@ -2496,6 +2663,20 @@ pygments = ">=2.13.0,<3.0.0"
 [package.extras]
 jupyter = ["ipywidgets (>=7.5.1,<9)"]
 
+[[package]]
+name = "rsa"
+version = "4.9"
+description = "Pure-Python RSA implementation"
+optional = false
+python-versions = ">=3.6,<4"
+files = [
+    {file = "rsa-4.9-py3-none-any.whl", hash = "sha256:90260d9058e514786967344d0ef75fa8727eed8a7d2e43ce9f4bcf1b536174f7"},
+    {file = "rsa-4.9.tar.gz", hash = "sha256:e38464a49c6c85d7f1351b0126661487a7e0a14a50f1675ec50eb34d4f20ef21"},
+]
+
+[package.dependencies]
+pyasn1 = ">=0.1.3"
+
 [[package]]
 name = "setuptools"
 version = "69.0.3"
@@ -2888,6 +3069,17 @@ tsv = ["pandas"]
 wikipedia = ["wikipedia"]
 xlsx = ["networkx", "openpyxl", "pandas", "xlrd"]
 
+[[package]]
+name = "uritemplate"
+version = "4.1.1"
+description = "Implementation of RFC 6570 URI Templates"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "uritemplate-4.1.1-py2.py3-none-any.whl", hash = "sha256:830c08b8d99bdd312ea4ead05994a38e8936266f84b9a7878232db50b044e02e"},
+    {file = "uritemplate-4.1.1.tar.gz", hash = "sha256:4346edfc5c3b79f694bccd6d6099a322bbeb628dbf2cd86eea55a456ce5124f0"},
+]
+
 [[package]]
 name = "urllib3"
 version = "2.2.0"
@@ -3134,6 +3326,20 @@ files = [
 idna = ">=2.0"
 multidict = ">=4.0"
 
+[[package]]
+name = "youtube-transcript-api"
+version = "0.6.2"
+description = "This is an python API which allows you to get the transcripts/subtitles for a given YouTube video. It also works for automatically generated subtitles, supports translating subtitles and it does not require a headless browser, like other selenium based solutions do!"
+optional = false
+python-versions = "*"
+files = [
+    {file = "youtube_transcript_api-0.6.2-py3-none-any.whl", hash = "sha256:019dbf265c6a68a0591c513fff25ed5a116ce6525832aefdfb34d4df5567121c"},
+    {file = "youtube_transcript_api-0.6.2.tar.gz", hash = "sha256:cad223d7620633cec44f657646bffc8bbc5598bd8e70b1ad2fa8277dec305eb7"},
+]
+
+[package.dependencies]
+requests = "*"
+
 [[package]]
 name = "zipp"
 version = "3.17.0"
@@ -3223,4 +3429,4 @@ testing = ["coverage (>=5.0.3)", "zope.event", "zope.testing"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.10"
-content-hash = "4c9548c2661fa9496befbc063ce95d295c310d59fca454be4391abd494a87948"
+content-hash = "0fabc492abefedf556f97db35a35c83a8292f86b437b60dbd442010cb1e3b9a0"

pyproject.toml

@@ -18,6 +18,10 @@ unstructured = "0.10.25"
 pyowm = "3.3.0"
 tools = "^0.1.9"
 langchain-community = "^0.0.24"
+google-api-python-client = "^2.120.0"
+isodate = "^0.6.1"
+youtube-transcript-api = "^0.6.2"
+pydub = "^0.25.1"
 
 [tool.poetry.group.cli.dependencies]
 pyyaml = "^6.0.1"
@@ -56,3 +60,5 @@ build-backend = "poetry.core.masonry.api"
 fabric = 'installer:cli'
 fabric-api = 'installer:run_api_server'
 fabric-webui = 'installer:run_webui_server'
+ts = 'helpers.ts:main'
+yt = 'helpers.yt:main'

setup.sh

@@ -12,8 +12,8 @@ echo "Installing python dependencies"
 poetry install
 
 # List of commands to check and add or update alias for
-commands=("fabric" "fabric-api" "fabric-webui")
-
+# Add 'yt' and 'ts' to the list of commands
+commands=("fabric" "fabric-api" "fabric-webui" "ts", "yt")
 
 # List of shell configuration files to update
 config_files=("$HOME/.bashrc" "$HOME/.zshrc" "$HOME/.bash_profile")
@@ -69,4 +69,3 @@ if [ ${#source_commands[@]} -ne 0 ]; then
 else
   echo "No configuration files were updated. No need to source."
 fi
-