@tyvm/knowhow 0.0.1

package/src/agents/tools/language/definitions.ts

@@ -0,0 +1,97 @@
+import { Plugins } from "../../../plugins/plugins";
+export const definitions = [
+  {
+    type: "function",
+    function: {
+      name: "addLanguageTerm",
+      description:
+        "Add a new language term to the language config, which can help load context for given terms in the future.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          term: {
+            type: "string",
+            description:
+              "The trigger word(s) that should load the given context",
+          },
+          sources: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                kind: {
+                  type: "string",
+                  description: `The type of datasource, options are "file", "url", "text" or the name of a plugin: ${Plugins.listPlugins()}
+                  For files you must use the full relative path. For plugins you must use the name of the plugin associated with the data.
+                  Always use a plugin as the kind, if a plugin name is in the url.
+                  `,
+                },
+                data: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                  },
+                  description:
+                    "An array of strings that will be loaded when a language term is used in a user prompt. If the kind was a plugin, then we'll call the plugin with each string as input. Strings of the same kind should be grouped together in one array of data.",
+                },
+              },
+              required: ["kind", "data"],
+            },
+            description: "The sources to be loaded for the given term",
+          },
+        },
+        required: ["term"],
+      },
+      returns: {
+        type: "string",
+        description: "The response from the human.",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "getAllLanguageTerms",
+      description:
+        "Retrieves all language terms from the language configuration.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "array",
+        items: {
+          type: "string",
+        },
+        description: "An array of all language terms in the configuration.",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "lookupLanguageTerm",
+      description:
+        "Looks up a specific language term and calls the language plugin with it.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          term: {
+            type: "string",
+            description: "The language term to look up",
+          },
+        },
+        required: ["term"],
+      },
+      returns: {
+        type: "any",
+        description:
+          "The result of calling the language plugin with the specified term.",
+      },
+    },
+  },
+];

package/src/agents/tools/language/index.ts

@@ -0,0 +1,19 @@
+import { Plugins } from "../../../plugins/plugins";
+import { getLanguageConfig, updateLanguageConfig } from "../../../config";
+import { IDatasource } from "../../../types";
+
+export async function addLanguageTerm(term: string, sources: IDatasource[]) {
+  const language = await getLanguageConfig();
+  language[term] = { sources };
+  await updateLanguageConfig(language);
+}
+
+export async function getAllLanguageTerms() {
+  const language = await getLanguageConfig();
+  return Object.keys(language);
+}
+
+export async function lookupLanguageTerm(term: string) {
+  const language = await getLanguageConfig();
+  return Plugins.call("language", term);
+}

package/src/agents/tools/lintFile.ts

@@ -0,0 +1,17 @@
+import { getConfig } from "../../config";
+import { execCommand } from ".";
+export async function lintFile(filePath: string) {
+  const config = await getConfig();
+  const extension = filePath.split(".").pop();
+  let lintResult = "";
+  if (config.lintCommands && config.lintCommands[extension]) {
+    let lintCommand = config.lintCommands[extension];
+    if (lintCommand.includes("$1")) {
+      lintCommand = lintCommand.replace("$1", filePath);
+    }
+    lintResult = await execCommand(`${lintCommand}`);
+    console.log("Lint Result:", lintResult);
+    return lintResult;
+  }
+  return "";
+}

package/src/agents/tools/list.ts

@@ -0,0 +1,514 @@
+import { Tool } from "../../clients/types";
+import { ChatCompletionTool } from "openai/resources/chat";
+import { Plugins } from "../../plugins/plugins";
+
+const pluginNames = Plugins.listPlugins().join(", ");
+import * as github from "./github/definitions";
+import * as asana from "./asana/definitions";
+import * as language from "./language/definitions";
+import { googleSearchDefinition } from './googleSearch';
+import { Agents } from "../../services/AgentService";
+
+export const includedTools = [
+  {
+    type: "function",
+    function: {
+      name: "embeddingSearch",
+      description:
+        "Fuzzy search with cosine similarity for files related to the user's goal. Uses embeddings. Use textSearch for exact matches. Use fileSearch for file paths.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          keyword: {
+            type: "string",
+            description:
+              "The code, keyword or phrase to search for via embedding search",
+          },
+        },
+        required: ["keyword"],
+      },
+      returns: {
+        type: "string",
+        description: "A string containing a JSON of all the matched files",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "execCommand",
+      description:
+        "Execute a command in the system's command line interface. Use this to run tests and things in the terminal",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          command: {
+            type: "string",
+            description: "The command to execute",
+          },
+        },
+        required: ["command"],
+      },
+      returns: {
+        type: "object",
+        properties: {
+          stdout: {
+            type: "string",
+            description: "The standard output of the executed command",
+          },
+          stderr: {
+            type: "string",
+            description: "The standard error output of the executed command",
+          },
+        },
+        description:
+          "The result of the command execution, including any output and errors",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "finalAnswer",
+      description:
+        "Finalize the AI's task and return the answer to the user. You are required to call this at the end to send the response to the user",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          answer: {
+            type: "string",
+            description:
+              "The AI's answer to be displayed to the user as the full explanation of the task and what was done",
+          },
+        },
+        required: ["answer"],
+      },
+      returns: {
+        type: "string",
+        description:
+          "The final answer string that will be displayed to the user",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "callPlugin",
+      description: `Call a specified plugin with given input. Plugins provide additional context from supported URLs or words. This is a read-only operation. Currently available plugins: ${pluginNames}`,
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          pluginName: {
+            type: "string",
+            description: "The name of the plugin to be called",
+          },
+          userInput: {
+            type: "string",
+            description: "The input to pass to the plugin",
+          },
+        },
+        required: ["pluginName", "userInput"],
+      },
+      returns: {
+        type: "string",
+        description: "The result of the plugin call",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "visionTool",
+      description: "Ask the vision API a question about an image url",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          imageUrl: {
+            type: "string",
+            description: "The url of the image to load",
+          },
+          question: {
+            type: "string",
+            description: "The prompt related to the image",
+          },
+        },
+        required: ["imageUrl", "question"],
+      },
+      returns: {
+        type: "string",
+        description:
+          "The results of the vision API call as an answer to the prompt question",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "readFile",
+      description:
+        "Read the contents of a file and return them as an array of blocks",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to be read",
+          },
+        },
+        required: ["filePath"],
+      },
+      returns: {
+        type: "string",
+        description: "The file contents in diff format",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "readBlocks",
+      description:
+        "Read specific blocks from a file based on block numbers. Blocks are numbered blocks of text, containing a few lines of content",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description:
+              "The path to the file from which blocks are to be read",
+          },
+          blockNumbers: {
+            type: "array",
+            items: {
+              type: "number",
+            },
+            description: "An array of block numbers to be read from the file",
+          },
+        },
+        required: ["filePath", "blockNumbers"],
+      },
+      returns: {
+        type: "array",
+        description:
+          "An array of file blocks corresponding to the specified block numbers",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "patchFile",
+      description:
+        "Modify file with patch. Can also create new files. Use GNU diffutils syntax with - in front of removals and + in front of additions. Always check your work after applying a patch to ensure the patch did what you expected. Think step by step while constructing the patch, of which lines your will add and remove. Make sure that your patch is maintaining proper syntax. Do not modify lines unrelated to the goal. Patches should contain 3 to 6 lines of context before and after changes. No omissions of lines for removals are allowed. Use multiple small patches over one large patch that affects multiple places in the file.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to be patched",
+          },
+          patch: {
+            type: "string",
+            description: "The patch to apply in unified diff format",
+          },
+        },
+        required: ["filePath", "patch"],
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "lintFile",
+      description:
+        "Lint a file based on the file extension using predefined linting commands from the configuration.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to be linted.",
+          },
+        },
+        required: ["filePath"],
+      },
+      returns: {
+        type: "string",
+        description:
+          "The result of the linting process or an empty string if no lint command is configured for the file extension.",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "textSearch",
+      description:
+        "Exact Search. Search for exact matches of text across files. Use embeddingSearch for fuzzy search. Use fileSearch for file paths",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          searchTerm: {
+            type: "string",
+            description: "The text string to search for across files",
+          },
+        },
+        required: ["searchTerm"],
+      },
+      returns: {
+        type: "string",
+        description: "The result of the text search, including any matches",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "fileSearch",
+      description: "Search for files where the filepath includes a searchTerm",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          searchTerm: {
+            type: "string",
+            description: "a string to search for in file paths",
+          },
+        },
+        required: ["searchTerm"],
+      },
+      returns: {
+        type: "string",
+        description: "The result of the file search, including any matches",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "askHuman",
+      description: "Ask a human a question and get a response.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          question: {
+            type: "string",
+            description: "The question to ask the human. Can be in markdown",
+          },
+        },
+        required: ["question"],
+      },
+      returns: {
+        type: "string",
+        description: "The response from the human.",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "writeFileChunk",
+      description:
+        "Update or create files by writing in smaller chunks. Suitable for larger files, this tool allows incremental writing by calling it multiple times.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description:
+              "The path to the file where the content will be written",
+          },
+          content: {
+            type: "string",
+            description: "The chunk of content to write to the file",
+          },
+          isContinuing: {
+            type: "boolean",
+            description:
+              "Flag indicating whether to append the content to an existing file (`true`) or start a new file (`false`)",
+          },
+          isDone: {
+            type: "boolean",
+            description:
+              "Flag indicating whether this is the final chunk of content",
+          },
+        },
+        required: ["filePath", "content", "isContinuing", "isDone"],
+      },
+      returns: {
+        type: "string",
+        description:
+          "A message indicating the status of the file writing process",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "createAiCompletion",
+      description: "Create a completion using the knowhow ai client",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          provider: {
+            type: "string",
+            description:
+              "The AI provider to use (e.g., 'openai', 'anthropic'). Use listAllModels to figure out which provider to use if you don't know",
+          },
+          options: {
+            type: "object",
+            description: "The completion options",
+            properties: {
+              model: { type: "string", description: "The model to use" },
+              messages: {
+                type: "array",
+                description: "The messages for the completion",
+                items: {
+                  type: "object",
+                  properties: {
+                    role: { type: "string" },
+                    content: { type: "string" },
+                  },
+                },
+              },
+              max_tokens: {
+                type: "number",
+                description: "Maximum number of tokens to generate",
+              },
+            },
+            required: ["model", "messages"],
+          },
+        },
+        required: ["provider"],
+      },
+      returns: {
+        type: "object",
+        description: "The completion response from the AI provider",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "listAllModels",
+      description: "List all available models using the knowhow ai client",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "object",
+        description: "A dictionary of all available models for each provider",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "listAllProviders",
+      description: "List all available providers using the knowhow ai client",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "array",
+        description: "An array of all available providers",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "createEmbedding",
+      description: "Create an embedding using the knowhow ai client",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          provider: {
+            type: "string",
+            description:
+              "The AI provider to use (e.g., 'openai', 'anthropic'). Use listAllModels to figure out which provider to use if you don't know",
+          },
+          options: {
+            type: "object",
+            description: "The embedding options",
+            properties: {
+              input: { type: "string", description: "The text to embed" },
+              model: { type: "string", description: "The model to use (optional)" },
+            },
+            required: ["input"],
+          },
+        },
+        required: ["provider", "options"],
+      },
+      returns: {
+        type: "object",
+        description: "The embedding response from the AI provider",
+      },
+    },
+  },
+
+  googleSearchDefinition,
+  {
+    type: "function",
+    function: {
+      name: "loadWebpage",
+      description:
+        "Load a webpage using a stealth browser to avoid bot detection. Can return either text content with console logs or a screenshot.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          url: {
+            type: "string",
+            description: "The URL of the webpage to load",
+          },
+          mode: {
+            type: "string",
+            description: "The mode for content extraction: 'text' for text content with console logs, 'screenshot' for a base64 encoded screenshot",
+            enum: ["text", "screenshot"],
+          },
+          waitForSelector: {
+            type: "string",
+            description: "Optional CSS selector to wait for before extracting content",
+          },
+          timeout: {
+            type: "number",
+            description: "Timeout in milliseconds for page loading (default: 30000)",
+          },
+        },
+        required: ["url"],
+      },
+      returns: {
+        type: "string",
+        description: "The webpage content as text with console logs, or a base64 encoded screenshot",
+      },
+    },
+  },
+  ...asana.definitions,
+  ...github.definitions,
+  ...language.definitions,
+] as Tool[];