@tyvm/knowhow 0.0.1

package/autodoc/plugins/figma.mdx

@@ -0,0 +1,45 @@
+# Figma Plugin Executive Summary
+
+## Overview
+
+The Figma Plugin is designed to enhance user interactions by integrating Figma file data into chat environments. It detects and resolves Figma file URLs from user prompts, fetches relevant data from these files, and provides enriched context to the chat. Additionally, it generates embeddings based on the extracted Figma data, which can be used for various downstream applications such as search, recommendation, and more.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **URL Extraction**: The plugin identifies Figma file URLs embedded within user prompts.
+- **Data Fetching**: It retrieves detailed information from the specified Figma files, including images, components, styles, and more.
+- **Error Handling**: The plugin gracefully handles errors during data fetching, ensuring robust performance.
+
+### Context Enrichment
+
+- **Image Descriptions**: By leveraging AI (e.g., GPT Vision), the plugin generates descriptive text for images found within Figma files. This provides users with a richer understanding of the visual content.
+- **Structured Data**: The plugin formats and presents Figma data in a structured manner, making it easier for users to comprehend and utilize the information.
+
+### Embedding Generation
+
+- **Minimal Embeddings**: The plugin creates minimal embeddings from the Figma data, which include:
+  - **ID**: Unique identifier for the Figma file.
+  - **Text**: A JSON string representation of the Figma data.
+  - **Metadata**: Additional metadata associated with the Figma file.
+
+These embeddings can be used for various purposes, such as improving search relevance, enhancing recommendations, and more.
+
+## Environment Variables
+
+To function correctly, the Figma Plugin requires the following environment variable to be set:
+
+- **FIGMA_API_KEY**: This is the personal access token used to authenticate requests to the Figma API. It must be set in the environment where the plugin is running.
+
+## Usage
+
+The Figma Plugin can be integrated into chat applications to provide users with enhanced interactions involving Figma files. Here’s how it can be used:
+
+1. **Detect Figma URLs**: The plugin scans user prompts for Figma file URLs.
+2. **Fetch Figma Data**: It retrieves data from the identified Figma files, including images and other relevant components.
+3. **Generate Descriptions**: Using AI, the plugin generates descriptive text for images within the Figma files.
+4. **Embed Data**: It creates minimal embeddings from the Figma data, which can be used for various downstream applications.
+5. **Enrich Chat Context**: The plugin adds enriched context to the chat, providing users with detailed information about the Figma files.
+
+By integrating this plugin, chat applications can offer users a more interactive and informative experience when dealing with Figma files.

package/autodoc/plugins/github.mdx

@@ -0,0 +1,40 @@
+# GitHub Plugin Executive Summary
+
+## Overview
+
+The GitHub Plugin is designed to enhance chat interactions by detecting and resolving GitHub pull request URLs within user prompts. It provides additional context by embedding detailed information about the changes in the pull requests. This plugin is particularly useful for teams and individuals who frequently discuss code changes and need quick access to the specifics of those changes.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **Pull Request URL Detection**: The plugin scans user prompts for GitHub pull request URLs. It uses a regex pattern to identify URLs that match the format `https://github.com/{owner}/{repo}/pull/{pull_number}`.
+- **Diff Retrieval**: Once a pull request URL is detected, the plugin retrieves the diff associated with that pull request. This includes all the changes made in the pull request, formatted as a diff.
+
+### Contextual Enhancements
+
+- **Parsed Diffs**: The plugin parses the diffs to filter out large changes, ensuring that only manageable and relevant changes are included. This helps in focusing on the most significant parts of the pull request.
+- **Formatted Output**: The diffs are formatted in a readable manner, often in Markdown, making it easy to understand the changes directly within the chat interface.
+
+### Embeddings
+
+- **Minimal Embeddings**: The plugin generates minimal embeddings for the detected pull request URLs. Each embedding includes:
+  - **ID**: The URL of the pull request.
+  - **Text**: A JSON string representation of the parsed diff.
+  - **Metadata**: Additional metadata, if any, associated with the diff.
+
+## Environment Variables
+
+To function correctly, the GitHub Plugin requires the following environment variable to be set:
+
+- **GITHUB_TOKEN**: This is a personal access token used to authenticate with the GitHub API. It must be set in the environment where the plugin is running. The token should have sufficient permissions to read pull request data from the repositories of interest.
+
+## Usage
+
+The GitHub Plugin can be used in various scenarios, including:
+
+- **Code Reviews**: Automatically expand pull request URLs in chat to show the changes, facilitating quick reviews and discussions.
+- **Team Collaboration**: Enhance team communication by providing immediate context about code changes without leaving the chat interface.
+- **Automated Reporting**: Generate summaries of pull request changes for reporting purposes or automated notifications.
+
+By integrating this plugin, users can streamline their workflow, reduce context-switching, and improve the efficiency of code-related discussions.

package/autodoc/plugins/jira.mdx

@@ -0,0 +1,46 @@
+# Jira Plugin Executive Summary
+
+## Overview
+
+The Jira Plugin is designed to enhance chat interactions by detecting and resolving Jira issue URLs within user prompts. It provides additional context to chats by embedding detailed information about the referenced Jira issues. This plugin is particularly useful for teams that rely on Jira for project management and need to quickly access and share issue details within their communication channels.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **URL Extraction**: The plugin scans user prompts for Jira issue URLs based on a predefined pattern.
+- **Issue Retrieval**: It fetches detailed information about the identified Jira issues using the Jira API.
+- **Error Handling**: The plugin gracefully handles errors during the issue retrieval process, ensuring that the chat experience remains smooth even if some issues cannot be fetched.
+
+### Contextual Enhancements
+
+- **Issue Embedding**: The plugin generates embeddings for the detected Jira issues, which include the issue ID, a JSON representation of the issue details, and metadata.
+- **Chat Augmentation**: It enriches chat conversations by providing a structured summary of the Jira issues, including the issue key, summary, URL, and description.
+
+### Embedding Generation
+
+- **Minimal Embedding**: The plugin creates minimal embeddings that encapsulate essential information about each Jira issue. These embeddings can be used to provide quick references or to integrate with other systems that require issue data.
+
+## Environment Variables
+
+To function correctly, the Jira Plugin requires the following environment variables to be set:
+
+- **JIRA_HOST**: The host URL of the Jira instance.
+- **JIRA_USER**: The username for authenticating with the Jira API.
+- **JIRA_PASSWORD**: The password for authenticating with the Jira API.
+
+These environment variables ensure secure and authenticated access to the Jira instance, allowing the plugin to fetch issue details as needed.
+
+## Usage
+
+The Jira Plugin can be integrated into chat systems to automatically detect and resolve Jira issue URLs. When a user includes a Jira issue URL in their message, the plugin will:
+
+1. Extract the URL and identify the corresponding Jira issue.
+2. Fetch detailed information about the issue from the Jira API.
+3. Embed the issue details into the chat, providing a concise summary that includes the issue key, summary, URL, and description.
+
+This functionality allows team members to quickly access and share relevant Jira issue information without leaving their chat environment, thereby improving productivity and collaboration.
+
+## Conclusion
+
+The Jira Plugin is a powerful tool for teams that use Jira for project management. By automatically detecting and resolving Jira issue URLs and embedding detailed issue information into chats, it enhances communication and ensures that team members have quick access to the information they need. Setting the required environment variables ensures secure and seamless integration with your Jira instance.

package/autodoc/plugins/language.mdx

@@ -0,0 +1,37 @@
+# Language Plugin Executive Summary
+
+## Overview
+
+The Language Plugin is designed to enhance user interactions by detecting specific terms within user prompts and providing additional context to enrich the conversation. This plugin integrates with various other plugins and sources to gather relevant information, ensuring that responses are well-informed and contextually accurate.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **Term Detection**: The plugin scans user prompts for specific terms defined in a language configuration file.
+- **Contextual Expansion**: Upon detecting these terms, the plugin retrieves relevant information from various sources, including files and other integrated plugins.
+
+### Context Addition
+
+- **File Content Retrieval**: The plugin reads and includes content from specified files that are relevant to the detected terms.
+- **Textual Data Inclusion**: It also incorporates predefined textual data associated with the detected terms.
+- **Plugin Integration**: The plugin can call other integrated plugins (e.g., GitHub, Asana, Jira, Linear) to fetch additional context, ensuring a comprehensive response.
+
+### Embeddings Generation
+
+- **Contextual Embeddings**: Although the primary function is to add context, the plugin can generate embeddings based on the user prompt and the gathered contextual information. These embeddings can be used to further refine responses or for other analytical purposes.
+
+## Environment Variables
+
+To function correctly, the Language Plugin requires the following environment variables to be set:
+
+- **`process.env.CONFIG_PATH`**: Path to the main configuration file.
+- **`process.env.LANGUAGE_CONFIG_PATH`**: Path to the language-specific configuration file.
+
+These environment variables ensure that the plugin can access the necessary configuration files to detect terms and gather relevant context.
+
+## Usage
+
+The Language Plugin can be used in any application where enhanced, contextually aware responses are needed. It is particularly useful in customer support, virtual assistants, and any interactive system where understanding and responding to user queries accurately is crucial.
+
+By integrating with other plugins and sources, the Language Plugin ensures that responses are not only relevant but also enriched with additional information, providing a more comprehensive and satisfying user experience.

package/autodoc/plugins/linear.mdx

@@ -0,0 +1,35 @@
+# Linear Plugin Executive Summary
+
+## Overview
+
+The Linear Plugin is designed to enhance chat interactions by detecting and resolving Linear issue URLs within user prompts. It provides additional context to chats by embedding detailed information about the referenced Linear issues. This plugin is particularly useful for teams using Linear for project management, as it allows seamless integration of issue tracking data into chat environments.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **URL Extraction**: The plugin scans user prompts for Linear issue URLs. It uses a regex pattern to identify URLs that match the Linear issue format.
+- **Issue Data Retrieval**: For each detected URL, the plugin fetches detailed information about the corresponding Linear issue, including its identifier, title, URL, and description.
+
+### Contextual Enhancements
+
+- **Issue Embedding**: The plugin generates embeddings for each detected Linear issue. These embeddings include:
+  - **ID**: The URL of the issue.
+  - **Text**: A formatted string containing the issue's identifier, title, URL, and description.
+  - **Metadata**: Additional metadata (currently empty but can be extended).
+
+### Embedding Generation
+
+- **Minimal Embedding**: The plugin creates minimal embeddings that encapsulate essential information about each Linear issue. These embeddings can be used to enrich chat interactions with relevant issue details, making it easier for team members to discuss and resolve issues directly within the chat environment.
+
+## Environment Variables
+
+To function correctly, the Linear Plugin requires the following environment variable to be set:
+
+- **LINEAR_API_KEY**: This API key is used to authenticate requests to the Linear API. Ensure that this environment variable is set with a valid Linear API key before using the plugin.
+
+## Usage
+
+The Linear Plugin can be integrated into chat applications to provide real-time issue tracking and context. When a user includes a Linear issue URL in their message, the plugin automatically detects the URL, retrieves the issue details, and embeds the information into the chat. This allows team members to quickly access and discuss relevant issue details without leaving the chat environment.
+
+By leveraging the Linear Plugin, teams can improve their workflow efficiency, enhance communication, and maintain better visibility over their project management tasks directly within their chat applications.

package/autodoc/plugins/notion.mdx

@@ -0,0 +1,38 @@
+# Notion Plugin Executive Summary
+
+## Overview
+
+The Notion Plugin is designed to enhance chat interactions by integrating Notion content directly into conversations. It detects Notion URLs within user inputs, retrieves the corresponding Notion pages and their child blocks, and generates embeddings that can be used to provide additional context in chats. This plugin is particularly useful for users who frequently reference Notion documents and wish to seamlessly incorporate their content into discussions.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **URL Extraction**: The plugin scans user inputs for Notion URLs using a regular expression pattern. It identifies and extracts URLs that point to Notion pages.
+- **Page Retrieval**: For each detected URL, the plugin retrieves the corresponding Notion page and its child blocks. This includes handling nested blocks up to a specified depth.
+
+### Contextual Enhancements
+
+- **Content Embedding**: The plugin generates embeddings from the retrieved Notion pages and their child blocks. These embeddings include the text content and metadata, which can be used to enrich chat interactions with relevant information from Notion.
+- **Hierarchical Data Handling**: The plugin processes hierarchical data structures within Notion pages, ensuring that nested blocks and child pages are included in the embeddings.
+
+### Embedding Generation
+
+- **Minimal Embeddings**: The plugin creates minimal embeddings that encapsulate the essential content and metadata of Notion pages and blocks. These embeddings are structured to facilitate easy integration into chat systems.
+- **Comprehensive Data**: The embeddings include text content extracted from various block types within Notion, ensuring a comprehensive representation of the page's information.
+
+## Environment Variables
+
+To function correctly, the Notion Plugin requires the following environment variable to be set:
+
+- **NOTION_TOKEN**: This token is used to authenticate requests to the Notion API. It must be set in the environment where the plugin is running.
+
+## Usage
+
+The Notion Plugin can be used in various scenarios where integrating Notion content into chat interactions is beneficial. For example:
+
+- **Customer Support**: Support agents can quickly reference and share relevant Notion documentation with customers during chat sessions.
+- **Team Collaboration**: Team members can embed and discuss specific Notion pages within chat platforms, facilitating more informed and context-rich conversations.
+- **Knowledge Management**: Users can pull in detailed information from Notion pages to answer questions or provide explanations in chat environments.
+
+By leveraging the Notion Plugin, users can enhance their chat interactions with rich, contextual information from their Notion workspace, improving communication efficiency and effectiveness.

package/autodoc/plugins/plugins.mdx

@@ -0,0 +1,59 @@
+# Plugin Service Executive Summary
+
+## Overview
+
+The Plugin Service is a comprehensive system designed to enhance chat interactions by detecting and resolving various types of inputs, adding contextual information, and generating embeddings. This service integrates multiple specialized plugins, each contributing unique functionalities to improve user experience and productivity.
+
+## Input Detection and Resolution
+
+The Plugin Service is capable of detecting and resolving a wide range of inputs through its diverse set of plugins. Each plugin is tailored to handle specific types of data and interactions:
+
+- **VimPlugin**: Enhances text editing capabilities with Vim-like commands.
+- **GitHubPlugin**: Manages GitHub repositories, issues, and pull requests.
+- **AsanaPlugin**: Integrates with Asana for task and project management.
+- **LinearPlugin**: Connects with Linear for issue tracking and project management.
+- **JiraPlugin**: Interfaces with Jira for comprehensive project tracking.
+- **NotionPlugin**: Syncs with Notion for note-taking and project organization.
+- **DownloaderPlugin**: Facilitates downloading of files and resources.
+- **FigmaPlugin**: Integrates with Figma for design collaboration.
+- **LanguagePlugin**: Provides language processing capabilities.
+- **EmbeddingPlugin**: Generates embeddings for various types of data.
+
+## Contextual Enhancements
+
+The Plugin Service adds valuable context to chat interactions by leveraging the capabilities of its integrated plugins. For example:
+
+- **GitHubPlugin** can provide context about recent commits, open issues, and pull requests.
+- **AsanaPlugin** and **LinearPlugin** can offer insights into task statuses and project timelines.
+- **JiraPlugin** can deliver updates on project progress and issue resolutions.
+- **NotionPlugin** can share notes and project documentation.
+- **FigmaPlugin** can present design updates and feedback.
+
+These contextual enhancements ensure that users have access to relevant information directly within their chat environment, streamlining workflows and improving decision-making.
+
+## Embedding Generation
+
+The Plugin Service supports the generation of embeddings through the **EmbeddingPlugin**. Embeddings are vector representations of data that can be used for various purposes, such as:
+
+- **Text Embeddings**: Representing textual data in a numerical format for natural language processing tasks.
+- **Image Embeddings**: Converting visual data into vectors for image recognition and analysis.
+- **Custom Embeddings**: Generating embeddings for domain-specific data to enhance search and recommendation systems.
+
+These embeddings enable advanced data processing and machine learning applications, making the Plugin Service a powerful tool for data-driven tasks.
+
+## Environment Variables
+
+To ensure the proper functioning of the Plugin Service, certain environment variables need to be set. These variables are used to configure the plugins and provide necessary credentials and settings. The required environment variables include:
+
+- **GITHUB_TOKEN**: Required for the **GitHubPlugin** to authenticate and interact with GitHub APIs.
+- **ASANA_TOKEN**: Required for the **AsanaPlugin** to access Asana's API.
+- **LINEAR_API_KEY**: Required for the **LinearPlugin** to connect with Linear's services.
+- **JIRA_API_TOKEN**: Required for the **JiraPlugin** to authenticate with Jira.
+- **NOTION_API_KEY**: Required for the **NotionPlugin** to interact with Notion's API.
+- **FIGMA_API_KEY**: Required for the **FigmaPlugin** to access Figma's API.
+
+These environment variables should be set in the system where the Plugin Service is deployed to ensure seamless integration and functionality.
+
+## Conclusion
+
+The Plugin Service is a versatile and powerful system that enhances chat interactions by detecting and resolving various inputs, adding contextual information, and generating embeddings. By integrating with multiple specialized plugins, it provides a comprehensive solution for improving productivity and user experience in chat environments. Proper configuration of environment variables is essential for the optimal performance of the service.

package/autodoc/plugins/types.mdx

@@ -0,0 +1,51 @@
+# Executive Summary: Chat Enhancement Plugin
+
+## Overview
+
+The Chat Enhancement Plugin is designed to augment chat interactions by detecting and resolving specific types of user inputs, adding valuable context to conversations, and generating various types of embeddings. This plugin is particularly useful for applications that require advanced text processing, contextual understanding, and semantic embedding capabilities.
+
+## Key Features
+
+### Input Detection and Resolution
+
+The plugin is capable of detecting and resolving a wide range of user inputs. This includes, but is not limited to:
+
+- **Natural Language Queries:** The plugin can interpret and respond to user questions and commands.
+- **Contextual Prompts:** It can understand and provide relevant information based on the context of the conversation.
+- **Data Extraction:** The plugin can identify and extract key pieces of information from user inputs.
+
+### Contextual Enhancements
+
+One of the standout features of this plugin is its ability to add extra context to chats. This includes:
+
+- **Contextual Responses:** The plugin can generate responses that are contextually relevant to the ongoing conversation.
+- **Information Augmentation:** It can provide additional information that enhances the user's understanding of the topic being discussed.
+- **Dynamic Context Updates:** The plugin can dynamically update the context as the conversation progresses, ensuring that responses remain relevant.
+
+### Embedding Generation
+
+The plugin supports the generation of various types of embeddings, which are essential for tasks such as semantic search, recommendation systems, and more. The types of embeddings it can generate include:
+
+- **Minimal Embeddings:** These are lightweight embeddings that capture the essential semantics of the user input.
+- **Contextual Embeddings:** These embeddings take into account the context of the conversation, providing a richer representation of the input.
+
+## Environment Variables
+
+To ensure the plugin functions correctly, certain environment variables need to be set. These variables are used to configure the plugin and provide necessary credentials or settings. The required environment variables include:
+
+- **API_KEY:** This variable should be set to the API key provided by the service the plugin interacts with. It is essential for authenticating requests.
+- **ENVIRONMENT:** This variable specifies the environment in which the plugin is running (e.g., 'development', 'production') and can affect how the plugin behaves.
+
+## Usage
+
+The Chat Enhancement Plugin can be integrated into various applications to improve user interactions. It is particularly useful for:
+
+- **Customer Support Systems:** Enhancing automated responses and providing relevant information to customer queries.
+- **Virtual Assistants:** Improving the contextual understanding and response generation of virtual assistants.
+- **Content Recommendation:** Generating embeddings that can be used to recommend relevant content based on user inputs.
+
+By leveraging this plugin, developers can create more intelligent and responsive chat systems that provide a better user experience.
+
+---
+
+This executive summary provides a high-level overview of the Chat Enhancement Plugin, focusing on its key features, required environment variables, and potential use cases. For detailed implementation and integration instructions, please refer to the full documentation.

package/autodoc/plugins/vim.mdx

@@ -0,0 +1,39 @@
+# Vim Plugin Executive Summary
+
+## Overview
+
+The Vim Plugin is designed to enhance the functionality of chat applications by detecting and resolving Vim swap files. It provides additional context to chats by identifying which files are currently open in Vim and retrieving their contents. This plugin is particularly useful for developers who frequently use Vim as their text editor and need to keep track of their open files within a collaborative environment.
+
+## Key Features
+
+### Input Detection and Resolution
+
+- **Vim Swap Files**: The plugin scans the file system for Vim swap files (`*.swp`). These files are temporary files created by Vim to store changes made to a file that is currently being edited.
+- **Source Path Resolution**: For each detected swap file, the plugin attempts to resolve the original source file path. It checks both the standard file path and the hidden dot file path to ensure accurate resolution.
+
+### Context Addition to Chats
+
+- **File Status**: The plugin provides detailed information about the status of each file, including whether the file exists, if it is a directory, or if it is too large to be processed.
+- **File Contents**: For existing files, the plugin reads and returns the file contents, adding valuable context to chats about what files are currently being edited in Vim.
+
+### Embeddings
+
+- **Empty Embeddings**: Currently, the plugin's `embed` function returns an empty array. This indicates that the plugin does not generate any specific embeddings for the detected files at this time.
+
+## Environment Variables
+
+The following environment variables are required for the plugin to function correctly:
+
+- **None**: The current implementation of the Vim Plugin does not require any environment variables to be set. All necessary configurations and paths are handled internally within the plugin.
+
+## Usage
+
+The Vim Plugin can be integrated into chat applications to provide real-time updates on files being edited in Vim. This can be particularly useful in collaborative development environments where team members need to stay informed about each other's work. By detecting Vim swap files and resolving their source paths, the plugin ensures that users have access to the most up-to-date information about their open files.
+
+### Example Use Cases
+
+- **Collaborative Coding**: Team members can see which files are currently being edited in Vim, helping to avoid conflicts and improve coordination.
+- **Code Reviews**: Reviewers can access the latest changes made to files directly from the chat, streamlining the review process.
+- **Debugging Sessions**: Developers can quickly identify which files are being modified during debugging, making it easier to track changes and resolve issues.
+
+In summary, the Vim Plugin enhances chat applications by providing real-time insights into files being edited in Vim, adding valuable context to collaborative development efforts.

package/autodoc/tools/addInternalTools.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to add new internal tools (functions) to its existing set of tools. It also enables the AI to call multiple tools in parallel by adding a special function (`multi_tool_use.parallel`) that can execute several tools at the same time and return their results together.

package/autodoc/tools/agentCall.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to receive a name and user input, then use a service to process or respond to that input.

package/autodoc/tools/asana/definitions.mdx

@@ -0,0 +1,10 @@
+This function set allows an AI agent to manage tasks in Asana. It can:
+
+1. **Create tasks** in a project.
+2. **Update existing tasks** with new information.
+3. **Search for tasks** using keywords.
+4. **List all projects** in Asana.
+5. **Find specific tasks** by their ID.
+6. **Retrieve tasks assigned to the user** that are not completed.
+7. **Get subtasks** for a specific task.
+8. **Create subtasks** under a parent task.

package/autodoc/tools/asana/index.mdx

@@ -0,0 +1,12 @@
+This function enables an AI agent to interact with Asana, a project management tool. Specifically, it allows the AI to:
+
+1. **Create Tasks**: Add new tasks to a project.
+2. **Update Tasks**: Modify existing tasks.
+3. **Search Tasks**: Find tasks based on a search term.
+4. **Find Specific Tasks**: Retrieve details of a specific task by its ID.
+5. **Get Subtasks**: List subtasks of a given task.
+6. **Create Subtasks**: Add subtasks to an existing task.
+7. **List My Tasks**: Retrieve tasks assigned to the AI's user.
+8. **List Projects**: Get a list of all projects in the workspace.
+
+This makes the AI capable of managing tasks and projects within Asana.

package/autodoc/tools/askHuman.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to ask a human a question. It displays the question in a formatted way and then waits for the human to respond.

package/autodoc/tools/callPlugin.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to use a specific plugin to process user input. It takes the name of the plugin and the user's input, then calls the plugin to get a result.

package/autodoc/tools/embeddingSearch.mdx

@@ -0,0 +1 @@
+This function helps an AI agent find files related to a user's goal by searching for keywords. It uses a plugin to perform the search and returns the results.

package/autodoc/tools/execCommand.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to run commands in the system's command line and get the results.

package/autodoc/tools/fileSearch.mdx

@@ -0,0 +1 @@
+This function helps an AI agent find files on a computer that contain a specific search term in their names. It converts the search term to lowercase, creates a search command, and runs it to locate matching files.

package/autodoc/tools/finalAnswer.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to complete its task and give the final answer back to the user.

package/autodoc/tools/github/definitions.mdx

@@ -0,0 +1,6 @@
+This function allows an AI agent to:
+
+1. **Fetch a pull request** from GitHub using a URL.
+2. **Get build statuses** for a pull request using a URL.
+3. **Retrieve run logs** for a specific GitHub Actions run by providing the run ID, repository owner, and repository name.
+4. **Fetch build failure logs** for a pull request using a URL.

package/autodoc/tools/github/index.mdx

@@ -0,0 +1,8 @@
+This function enables an AI agent to:
+
+1. **Fetch Pull Request Details**: Retrieve information about a specific pull request from a GitHub repository.
+2. **Get Build Statuses**: Obtain the build statuses (e.g., success, failure) for the pull request.
+3. **Retrieve Run Logs**: Fetch the logs of a specific GitHub Actions run.
+4. **Get Failure Logs**: Identify and retrieve logs related to failed build checks for a pull request, highlighting errors and failures.
+
+In short, it helps the AI agent monitor and diagnose issues in pull request builds on GitHub.

package/autodoc/tools/index.mdx

@@ -0,0 +1,14 @@
+This function allows an AI agent to perform a variety of tasks such as:
+
+- Adding internal tools
+- Calling plugins
+- Searching text and embeddings
+- Executing commands
+- Providing final answers
+- Indexing data
+- Linting, modifying, patching, reading, scanning, and writing files
+- Using vision tools
+- Integrating with Asana and GitHub
+- Searching files
+
+In short, it equips the AI with a wide range of capabilities for handling files, executing tasks, and integrating with other tools and platforms.

package/autodoc/tools/lintFile.mdx

@@ -0,0 +1,7 @@
+This function allows an AI agent to check a file for coding errors or style issues (linting) based on the file's extension. It does this by:
+
+1. Getting configuration settings.
+2. Determining the file's extension.
+3. Finding the appropriate linting command for that extension.
+4. Running the linting command on the file.
+5. Returning and logging the results of the linting process.

package/autodoc/tools/list.mdx

@@ -0,0 +1,16 @@
+This function provides an AI agent with a variety of tools to perform different tasks. Here's a simple breakdown of what each tool enables the AI to do:
+
+1. **embeddingSearch**: Find files related to a user's goal using fuzzy search.
+2. **execCommand**: Run commands in the system's terminal.
+3. **finalAnswer**: Send the final response to the user.
+4. **callPlugin**: Use additional plugins for extra context or information.
+5. **visionTool**: Analyze images and answer questions about them.
+6. **readFile**: Read the contents of a file.
+7. **readBlocks**: Read specific parts of a file.
+8. **patchFile**: Modify or create files using patches.
+9. **lintFile**: Check a file for errors based on its type.
+10. **textSearch**: Search for exact text matches in files.
+11. **fileSearch**: Search for files by their paths.
+12. **askHuman**: Ask a human a question and get a response.
+
+Additionally, it includes tools for working with GitHub and Asana.

package/autodoc/tools/modifyFile.mdx

@@ -0,0 +1,7 @@
+This function allows an AI agent to:
+
+1. **Read and Modify Files**: It can read the content of a file and update specific parts of it based on provided instructions (`fileBlocks`).
+2. **Track Changes**: It keeps track of the original content and the new content after modifications.
+3. **Generate Diffs**: It creates a diff (a summary of changes) between the original and modified content.
+4. **Linting**: It checks the modified file for any coding style or syntax issues.
+5. **Provide Feedback**: It returns a summary of changes and linting results, asking for confirmation if the changes are correct.

package/autodoc/tools/patch.mdx

@@ -0,0 +1,9 @@
+This function enables an AI agent to apply a patch to a file, ensuring the patch is correctly formatted and valid. It does the following:
+
+1. **Parse the Patch**: Breaks down the patch into manageable parts (hunks).
+2. **Validate and Fix Hunks**: Ensures each part of the patch is valid and fixes any issues.
+3. **Apply the Patch**: Applies the validated and fixed patch to the original file content.
+4. **Handle Errors**: Saves any errors encountered during the process for debugging.
+5. **Lint the File**: Checks the updated file for any coding standard issues.
+
+In short, it helps the AI agent to safely and correctly update files using patches.

package/autodoc/tools/readBlocks.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to read specific parts (blocks) of a file. It takes a file path and a list of block numbers, reads the file, and returns only the blocks that match the given numbers.

package/autodoc/tools/readFile.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to read a file from the filesystem, break its content into smaller chunks (blocks) of a specified size, and return these chunks as an array. If the file does not exist, it suggests possible related files. This helps the AI handle large files efficiently and manage cases where the file might be missing.

package/autodoc/tools/scanFile.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to read and return a specific range of lines from a text file, including a few lines before and after the specified range for context.

package/autodoc/tools/textSearch.mdx

@@ -0,0 +1,6 @@
+This function allows an AI agent to search for a text term in two ways:
+
+1. **Primary Method**: It uses a command-line tool (`ag`) to search for the term.
+2. **Fallback Method**: If the tool isn't available, it searches through pre-configured text embeddings to find matches.
+
+In simple terms, it helps the AI find information either using a fast tool or a backup method if the tool fails.

package/autodoc/tools/types/fileblock.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to handle parts of a file by breaking it into blocks. Each block has a number, optional starting line, and some content. This helps the AI manage and process large files in smaller, more manageable pieces.

package/autodoc/tools/visionTool.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to analyze an image and answer a question about it.

package/autodoc/tools/writeFile.mdx

@@ -0,0 +1 @@
+This function allows an AI agent to save text to a file on the computer. If successful, it confirms the file was written; if there's an error, it returns the error message.

package/jest.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts?$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },
+  testEnvironment: 'node',
+  testRegex: '/tests/.*\.(test|spec)?\.(ts|tsx|js)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  modulePathIgnorePatterns: ["ts_build"]
+};