@tyvm/knowhow 0.0.1

package/src/agents/base/prompt.ts

@@ -0,0 +1,26 @@
+export const BASE_PROMPT = `
+#Knowhow Codebase Agent.
+You use the tools to read and write code, to help the developer implement features faster.
+
+# Completing your work
+
+You always call finalAnswer once you have finished implementing or answering what is requested.
+As an agent you will receive multiple rounds of input until you call finalAnswer.
+You are not able to request feedback from the user, so proceed with your plans and the developer will contact you afterwards if they need more help.
+
+## Modification Guidelines
+
+After modifying files, you will read them to ensure they look correct before calling finalAnswer.
+You always check your modifications for syntax errors or bugs.
+You always use writeFileChunk for small files, and for larger files you use the patchFile tool, if available, to make the smallest modifications required to files, rather than outputting the entire file.
+You think step by step about the blocks of code you're modifying.
+You may use the execCommand tool to navigate the filesystem and to create new folders if needed.
+You may use the execCommand tool to use git to view which changes have been made so far via git diff and git status.
+
+# PLUGINS REMINDER:
+
+Plugins are used to automatically expand user input with more context.
+The additional context could be from embeddings, files, pull requests, tickets etc.
+Do not assume the plugin information contains all the information you require to accomplish a task.
+Be sure to consider tools that you may use to supplement what the plugins initially provided.
+`;

package/src/agents/configurable/ConfigAgent.ts

@@ -0,0 +1,23 @@
+import { BaseAgent } from "../base/base";
+import { Message } from "../../clients/types";
+import { Assistant, Config } from "../../types";
+
+export class ConfigAgent extends BaseAgent {
+  name: string;
+  description: string;
+
+  constructor(private config: Assistant) {
+    super();
+    this.name = config.name;
+    this.setModelPreferences([
+      { model: config.model, provider: config.provider },
+    ]);
+  }
+
+  async getInitialMessages(userInput: string) {
+    return [
+      { role: "system", content: this.config.instructions },
+      { role: "user", content: userInput },
+    ] as Message[];
+  }
+}

package/src/agents/developer/developer.ts

@@ -0,0 +1,69 @@
+import { Models } from "../../ai";
+import { Message } from "../../clients/types";
+import { BaseAgent } from "../base/base";
+import { BASE_PROMPT } from "../base/prompt";
+export class DeveloperAgent extends BaseAgent {
+  name = "Developer";
+  description = `This agent manages requests and uses tools and delegation via agentCall to accomplish things`;
+
+  constructor() {
+    super();
+    this.disableTool("patchFile");
+    this.disableTool("openFileInVim");
+    this.disableTool("sendVimInput");
+    this.disableTool("saveVimFile");
+
+    this.setModelPreferences([
+      {
+        model: Models.google.Gemini_20_Flash,
+        provider: "google",
+      },
+    ]);
+  }
+
+  async getInitialMessages(userInput: string) {
+    return [
+      {
+        role: "system",
+        content: `
+        ${BASE_PROMPT}
+
+        Specialization: Developer,  ${this.description}
+
+        # Description
+        You are a helpful developer assistant that is capable of using tools to assist the user.
+        You delegate some tasks to specialized agents. If a request doesn't require the use of a specialized agent, you can handle it yourself.
+
+        # How to call other agents
+        You can use the agentCall tool to call other agents.
+        Do not try to use VIM/ or Patching tools directly. If you must write to a file yourself use writeFileChunk
+
+        # Which Agent to Use:
+        Researcher -
+        - For answering questions about the codebase
+        - For providing context to modifications
+        - For figuring out which files to modify
+        - General Questions about codebase or file structure
+
+        Patcher
+        - For making modifications to files / code
+        - Great for big files
+
+        # Thought process
+        1. Is the user asking you a question about the codebase or files? Foreward the question to the Researcher.
+        2. Do you need to make changes to files?
+          2.a Do we have enough information to know exactly what to modify? If not, ask the Researcher.
+          2.b If we know what to modify, ask Patcher to make the changes with all the context required.
+        3. If the agent you call has declared it has completed a task, you may need to check it's modifications to see if there's some follow up work required.
+        4. If the user is asking for a general task, like webbrowsing or terminal commands, or general questions you may accomplish this yourself.
+        `,
+      },
+      {
+        role: "user",
+        content: userInput,
+      },
+    ] as Message[];
+  }
+}
+
+export const Developer = new DeveloperAgent();

package/src/agents/index.ts

@@ -0,0 +1,8 @@
+export * from "./base/base";
+export * from "./configurable/ConfigAgent";
+export * from "./developer/developer";
+export * from "./patcher/patcher";
+export * from "./researcher/researcher";
+
+export * as tools from "./tools";
+export { includedTools } from "./tools/list";

package/src/agents/interface.ts

@@ -0,0 +1,11 @@
+import { Message } from "../clients/types";
+
+export interface IAgent {
+  name: string;
+  description: string;
+  call: (userInput: string, messages?: Message[]) => Promise<string>;
+  getModel(): string;
+  getProvider(): string;
+  setModel(model: string): void;
+  setProvider(provider: string): void;
+}

package/src/agents/patcher/codebase.md

@@ -0,0 +1,27 @@
+# Agent Goals
+This agent should receive a user request, collect relevant files that should be read, and then research the request in context of the files, and then output a plan, of which files need to be modified.
+
+The agent should also plan to test it's changes. The testing phase can be accomplished through writing automated tests, executing terminal commands to verify things worked etc.
+
+# Simple Example Usage
+Codebase Agent: Write a plugin that takes in a user prompt, and then determines a good thing to google would be for that prompt, and then execute the google search returning the top 5 results.
+
+The agent should analzye the folder structure via RAG, perhaps multiple shots to find the plugins hiearchy.
+
+Once the examples are found the agent should contstruct a development plan for how the plugin should wbe written. Then the agent should use some tools to read/write the files.
+
+Search Files - Does a RAG search to try and find relevant files to the AI's goal.
+
+Read File - Opens a file and provides the full file as context to the LLM. If the file is too long, then it will be truncated at some point.
+
+Scan File - Opens a file, and reads from line A to line B, returning the contents to the LLM, also tells the LLM how many lines there are
+
+Write File - Writes the full contents of a file
+
+Patch File - The LLM outputs a patchfile which can be applied. This reduces output tokens
+
+Exec Command - The LLM should be able to call the cli to test it's changes, perhaps by running npm test (filename), to verify the tests it wrote pass
+
+
+# Implementation
+Implement the tools using the fs node module and the patch file tool should use the diff node module to apply the patches. Some configuration may be used to help the Agent know how to test it's work. For instance the agent could read the package.json for the test commands, or we could specify how changes can be tested in the knowhow config, since many projects have different testing patterns.

package/src/agents/patcher/patcher.ts

@@ -0,0 +1,110 @@
+import { Message } from "../../clients/types";
+import { BaseAgent } from "../base/base";
+import { BASE_PROMPT } from "../base/prompt";
+import { Models } from "../../ai";
+
+const example = `
+Index: ./src/agents/base/base.ts
+===================================================================
+--- ./src/agents/base/base.ts
++++ ./src/agents/base/base.ts
+@@ -186,9 +186,14 @@
+     startIndex: number,
+     endIndex: number
+   ) {
+     const toCompress = messages.slice(startIndex, endIndex);
+-    const toCompressPrompt = \`Summarize what this agent was tasked with, what has been tried so far, and what we're about to do next. This summary will become the agent's only memory of the past, all other messages will be dropped: \n\n\${JSON.stringify(
++    const toCompressPrompt = \`Summarize:
++    1. Initial Request - what this agent was tasked with.
++    2. Progress - what has been tried so far,
++    3. Next Steps - what we're about to do next to continue the user's original request.
++
++      This summary will become the agent's only memory of the past, all other messages will be dropped: \n\n\${JSON.stringify(
+       toCompress
+     )}\`;
+
+     const model = this.getModel();
+@@ -202,9 +207,12 @@
+         },
+       ],
+     });
+
++    const systemMesasges = toCompress.filter((m) => m.role === "system");
++
+     const newMessages = [
++      ...systemMesasges,
+       ...response.choices.map((c) => c.message),
+       ...messages.slice(endIndex),
+   ];
+
+`;
+
+const systemReminder = `# Patch Tool Rules:
+Here's an example of a correctly formatted patch:
+${example}
+
+Be sure to preserve sytanx, delete the correct lines of code, and insert new lines of code in the correct locations.
+
+The user's patch tool needs CORRECT patches that apply cleanly against the current contents of the file!
+Think carefully and make sure you include and mark all lines that need to be removed or changed as \`-\` lines.
+Make sure you mark all new or modified lines with \`+\`.
+Don't leave out any lines or the diff patch won't apply correctly.
+
+Indentation matters in the diffs!
+
+Start a new hunk for each section of the file that needs changes.
+
+Only output hunks that specify changes with \`+\` or \`-\` lines.
+Skip any hunks that are entirely unchanging \` \` lines.
+
+Output hunks in whatever order makes the most sense.
+Hunks don't need to be in any particular order.
+
+Hunks should have a context of 3 lines before and after the change, which match exactly from the source.
+
+When editing a function, method, loop, etc use a hunk to replace the *entire* code block.
+Delete the entire existing version with \`-\` lines and then add a new, updated version with \`+\` lines.
+This will help you generate correct code and correct diffs.
+
+To move code within a file, use 2 hunks: 1 to delete it from its current location, 1 to insert it in the new location.
+
+You should attempt to apply one hunk at a time, as an error in one hunk can cause the entire patch to fail to apply.
+`;
+
+export class PatchingAgent extends BaseAgent {
+  name = "Patcher";
+  description = `This agent is prepared to work on the codebase by leveraging patches`;
+
+  constructor() {
+    super();
+    this.disableTool("sendVimInput");
+    this.disableTool("openFileInVim");
+
+    this.setModelPreferences([
+      { model: Models.anthropic.Sonnet4, provider: "anthropic" },
+      {
+        model: Models.openai.GPT_41,
+        provider: "openai",
+      },
+    ]);
+  }
+
+  async getInitialMessages(userInput: string) {
+    return [
+      {
+        role: "system",
+        content: `${BASE_PROMPT}
+
+        ${systemReminder}
+
+        Specialization: Patcher Agent, ${this.description}
+        IF you fail twice to patch a file, you may switch using writeFileChunk to rewrite the whole file.
+        `,
+      },
+      // { role: "user", content: systemReminder },
+      { role: "user", content: userInput },
+    ] as Message[];
+  }
+}
+
+export const Patcher = new PatchingAgent();

package/src/agents/researcher/researcher.ts

@@ -0,0 +1,109 @@
+import { Models } from "../../ai";
+import { Message } from "../../clients/types";
+import { BaseAgent } from "../base/base";
+
+export class ResearcherAgent extends BaseAgent {
+  name = "Researcher";
+  description = `This agent is prepared to research a request using the tools available to them. Great for finding answers to questions about the codebase`;
+
+  constructor() {
+    super();
+    this.setModel(Models.google.Gemini_20_Flash);
+    this.setProvider("google");
+
+    this.disableTool("patchFile");
+  }
+
+  async getInitialMessages(userInput: string) {
+    return [
+      {
+        role: "system",
+        content: `
+            # Researcher Agent
+
+    You are a sophisticated research agent designed to investigate and provide comprehensive context for user requests. Your primary goal is to gather relevant information, clarify the scope of the inquiry, and prepare a detailed foundation for further action or implementation.
+
+    ## Core Responsibilities:
+
+    1. Analyze and break down the user's request into specific, answerable questions.
+    2. Conduct thorough research using all the tools to construct precise research.
+    3. Provide a comprehensive summary of findings, including relevant code locations, definitions, and contextual information.
+
+    ## Research Process:
+
+    Follow these steps for each research task:
+
+    1. **Term and Concept Identification:**
+       - Identify key terms and concepts in the request.
+       - Use available tools to find and provide clear definitions for unfamiliar terms.
+       - This step is crucial for understanding the full scope of the request.
+
+    2. **Request Breakdown:**
+       - Break down the request into specific, answerable questions.
+       - Prioritize questions that will lead to a comprehensive understanding of the task.
+
+    3. **Information Gathering:**
+       - For each question, use appropriate tools to find relevant information.
+       - Prioritize finding:
+         - Main implementation files
+         - Related models or data structures
+         - Associated services or utilities
+         - Relevant configuration files
+       - Provide file paths and brief descriptions of their roles in the system.
+
+    4. **Summarization:**
+       - Summarize findings for each question.
+       - Cite specific file paths or code snippets where applicable.
+
+    5. **Synthesis:**
+       - Synthesize the information to provide a comprehensive overview of the request's scope and implications.
+
+    ## Scope Clarification:
+
+    After initial research, clearly outline:
+    - The apparent scope of the request based on findings
+    - Any ambiguities or areas needing further clarification
+    - Potential implications or dependencies not explicitly mentioned in the original request
+
+    ## Tool Usage and Transparency:
+
+    - For each research step, briefly mention which tools you're using and why.
+
+    ## Iterative Refinement:
+
+    - After initial research, if the scope or requirements remain unclear, propose follow-up questions or areas for further investigation.
+    - Be prepared to iterate on your research based on additional input or clarifications.
+
+    ## Final Answer Format:
+
+    When calling finalAnswer, provide a structured summary including:
+    1. Initial Request: Restate the original task or question.
+    2. Key Terms and Definitions: List important terms and their definitions.
+    3. Relevant Code Locations: Provide file paths and brief descriptions of key code areas.
+    4. Scope and Implications: Outline the understood scope and any potential implications.
+    5. Areas for Further Investigation: Highlight any aspects that may need additional clarification or research.
+
+    ## Important Guidelines:
+
+    - Use all available search tools to ensure a robust set of references.
+    - Do not perform modifications; focus solely on research and information gathering.
+    - Aim for thoroughness and accuracy in your findings.
+    - Call finalAnswer after completing your research, but do not exceed 5 rounds of research without calling finalAnswer.
+    - You cannot request feedback from the user during your research process.
+
+    Remember, your role is to provide a comprehensive foundation of information to facilitate further action or implementation by other agents or developers.
+    Expect to use the tools, read files, etc. to construct a precise detailed analysis.
+`,
+      },
+
+      {
+        role: "user",
+        content: `The user has asked: ${userInput}
+        Do not do more than 5 rounds of research without calling finalAnswer.
+        `,
+      },
+    ] as Message[];
+  }
+}
+
+export const Researcher = new ResearcherAgent();

package/src/agents/tools/addInternalTools.ts

@@ -0,0 +1,21 @@
+// Add new internal tools to the existing suite
+export function addInternalTools(fns: {
+  [fnName: string]: (...args: any) => any;
+}) {
+  const callParallel = (
+    fnsToCall: { recipient_name: string; parameters: any }[]
+  ) => {
+    const promises = fnsToCall.map((param) => {
+      const name = param.recipient_name.split(".").pop();
+      const fn = fns[name];
+      const args = Object.values(param.parameters);
+      return fn(...args);
+    });
+
+    return Promise.all(promises);
+  };
+
+  fns["multi_tool_use.parallel"] = callParallel;
+
+  return fns;
+}

package/src/agents/tools/agentCall.ts

@@ -0,0 +1,18 @@
+import { Agents } from "../../services/AgentService";
+import { Events } from "../../services/EventService";
+import { Plugins } from "../../plugins/plugins";
+import { getConfig } from "../../config";
+
+export async function agentCall(agentName: string, userInput: string) {
+  return new Promise(async (resolve, reject) => {
+    const config = await getConfig();
+    const pluginText = await Plugins.callMany(config.plugins, userInput);
+    const fullPrompt = `${userInput} \n ${pluginText}`;
+    Events.emit("agents:call", {
+      name: agentName,
+      query: fullPrompt,
+      resolve,
+      reject,
+    });
+  });
+}

package/src/agents/tools/aiClient.ts

@@ -0,0 +1,36 @@
+import { Clients } from "../../clients";
+import {
+  GenericClient,
+  CompletionOptions,
+  CompletionResponse,
+  EmbeddingOptions,
+  EmbeddingResponse,
+} from "../../clients/types";
+
+export function createAiCompletion(
+  provider: string,
+  options: CompletionOptions
+): Promise<CompletionResponse> {
+  return Clients.createCompletion(provider, options);
+}
+
+export function createEmbedding(
+  provider: string,
+  options: EmbeddingOptions
+): Promise<EmbeddingResponse> {
+  return Clients.createEmbedding(provider, options);
+}
+
+export async function listModelsForProvider(
+  provider: string
+): Promise<string[]> {
+  return Clients.getRegisteredModels(provider);
+}
+
+export async function listAllModels(): Promise<Record<string, string[]>> {
+  return Clients.listAllModels();
+}
+
+export async function listAllProviders(): Promise<string[]> {
+  return Clients.listAllProviders();
+}

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

@@ -0,0 +1,199 @@
+export const definitions = [
+  {
+    type: "function",
+    function: {
+      name: "createTask",
+      description: "Create a new task in Asana",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          projectId: {
+            type: "string",
+            description: "The ID of the project where the task will be created",
+          },
+          taskName: {
+            type: "string",
+            description: "The name of the task to be created",
+          },
+          taskNotes: {
+            type: "string",
+            description: "The notes or description of the task",
+          },
+        },
+        required: ["projectId", "taskName", "taskNotes"],
+      },
+      returns: {
+        type: "object",
+        description: "The created task object",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "updateTask",
+      description: "Update an existing task in Asana",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          taskId: {
+            type: "string",
+            description: "The ID of the task to be updated",
+          },
+          updates: {
+            type: "object",
+            description:
+              "An object containing the updates to be applied to the task",
+          },
+        },
+        required: ["taskId", "updates"],
+      },
+      returns: {
+        type: "object",
+        description: "The updated task object",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "searchTasks",
+      description: "Search for tasks in Asana based on a search term",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          searchTerm: {
+            type: "string",
+            description: "The term to search for in task names and notes",
+          },
+        },
+        required: ["searchTerm"],
+      },
+      returns: {
+        type: "array",
+        description: "An array of tasks that match the search term",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "listProjects",
+      description: "List all projects in Asana",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "array",
+        description: "An array of project objects",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "findTask",
+      description: "Find a specific task in Asana by its ID",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          taskId: {
+            type: "string",
+            description: "The ID of the task to be found",
+          },
+        },
+        required: ["taskId"],
+      },
+      returns: {
+        type: "object",
+        description: "The task object that matches the given ID",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "myTasks",
+      description:
+        "Retrieve tasks assigned to the current user in Asana, only shows the uncompleted ones",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          project: {
+            type: "string",
+            description: "The ID of the project to filter tasks by (optional)",
+          },
+        },
+        required: [],
+      },
+      returns: {
+        type: "array",
+        description: "An array of tasks assigned to the current user",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "getSubtasks",
+      description: "Retrieve all subtasks for a given Asana task.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          taskId: {
+            type: "string",
+            description:
+              "The ID of the parent task for which to retrieve subtasks.",
+          },
+        },
+        required: ["taskId"],
+      },
+      returns: {
+        type: "array",
+        description:
+          "An array of subtasks associated with the specified parent task.",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "createSubtask",
+      description: "Create a new subtask under a given Asana task.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          taskId: {
+            type: "string",
+            description:
+              "The ID of the parent task under which the subtask will be created.",
+          },
+          taskName: {
+            type: "string",
+            description: "The name of the subtask to be created.",
+          },
+          taskNotes: {
+            type: "string",
+            description: "The optional notes or description of the subtask.",
+          },
+        },
+        required: ["taskId", "taskName"],
+      },
+      returns: {
+        type: "object",
+        description: "The created subtask object.",
+      },
+    },
+  },
+];