@tyvm/knowhow 0.0.1

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@tyvm/knowhow",
+  "version": "0.0.1",
+  "description": "ai cli with plugins and agents",
+  "main": "ts_build/src/index.js",
+  "bin": {
+    "knowhow": "ts_build/src/cli.js"
+  },
+  "scripts": {
+    "test": "jest --detectOpenHandles --forceExit --testTimeout 300000",
+    "test:debug": "node --inspect-brk ../../node_modules/jest/bin/jest.js --detectOpenHandles --forceExit --testTimeout 300000",
+    "compile": "tsc",
+    "start": "npm run compile && node ts_build/src/server/index.js",
+    "dataset:diffs:generate": "ts-node src/dataset/diffs/generate.ts",
+    "dataset:diffs:jsonl": "ts-node src/dataset/diffs/jsonl.ts",
+    "lint": "tslint ./src/**/*.ts"
+  },
+  "keywords": [],
+  "author": "Micah Riggan",
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.23.3",
+    "@types/asana": "^0.18.16",
+    "@types/diff": "^5.2.1",
+    "@types/express": "^4.17.13",
+    "@types/jest": "^29.5.13",
+    "@types/jira-client": "^7.1.9",
+    "@types/mocha": "^10.0.8",
+    "@types/node": "^20.6.3",
+    "@types/pdf-parse": "^1.1.4",
+    "@types/ws": "^8.18.1",
+    "jest": "^29.1.1",
+    "pdf-parse": "^1.1.1",
+    "prettier": "2.6.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.7.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@aws-sdk/client-s3": "^3.588.0",
+    "@google/genai": "^0.14.1",
+    "@inquirer/editor": "^1.2.13",
+    "@linear/sdk": "^12.0.0",
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "@notionhq/client": "^2.2.14",
+    "@octokit/rest": "^20.0.2",
+    "asana": "^3.0.16",
+    "axios": "^1.5.0",
+    "cheerio": "^1.0.0",
+    "diff": "^5.2.0",
+    "express": "^4.19.2",
+    "figma-js": "^1.16.1-0",
+    "gitignore-to-glob": "^0.3.0",
+    "jira-client": "^8.2.2",
+    "marked": "^10.0.0",
+    "marked-terminal": "^6.2.0",
+    "morgan": "^1.10.0",
+    "node-fetch": "^3.2.3",
+    "node-pty": "^1.0.0",
+    "node-record-lpcm16": "^1.0.1",
+    "openai": "4.89.1",
+    "ora": "^5.4.1",
+    "parse-diff": "^0.11.1",
+    "playwright": "^1.52.0",
+    "playwright-extra": "^4.3.6",
+    "progress-estimator": "^0.3.1",
+    "puppeteer": "^24.4.0",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "source-map-support": "^0.5.21",
+    "typescript": "^4.6.3",
+    "ws": "^8.18.1",
+    "youtube-dl-exec": "^2.5.5",
+    "zod": "^3.24.2"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/tyvm-ai/knowhow.git"
+  },
+  "types": "./ts_build/src/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/tyvm-ai/knowhow/issues"
+  },
+  "homepage": "https://github.com/tyvm-ai/knowhow#readme"
+}

package/src/agents/base/base.ts

@@ -0,0 +1,619 @@
+import { EventEmitter } from "events";
+import {
+  GenericClient,
+  Message,
+  OutputMessage,
+  Tool,
+  ToolCall,
+} from "../../clients/types";
+import { IAgent } from "../interface";
+import { ToolsService, Tools } from "../../services/Tools";
+import {
+  mcpToolName,
+  replaceEscapedNewLines,
+  restoreEscapedNewLines,
+} from "../../utils";
+import { Agents, AgentService } from "../../services/AgentService";
+import { Events, EventService } from "../../services/EventService";
+import { AIClient, Clients } from "../../clients";
+import { Models, openai } from "../../ai";
+
+export { Message, Tool, ToolCall };
+export interface ModelPreference {
+  model: string;
+  provider: keyof typeof Clients.clients;
+}
+
+export abstract class BaseAgent implements IAgent {
+  abstract name: string;
+  abstract description: string;
+
+  private status = "in_progress";
+  private lastHealthCheckTime: number = 0;
+  protected provider = "openai";
+  protected modelName: string = Models.openai.GPT_4o;
+  protected client: null | GenericClient = null;
+  protected modelPreferences: ModelPreference[] = [];
+  protected currentModelPreferenceIndex = 0;
+  protected easyFinalAnswer = false;
+  protected requiredToolNames = ["finalAnswer"];
+  protected totalCostUsd = 0;
+  protected currentThread = 0;
+  protected threads = [] as Message[][];
+  protected pendingUserMessages = [] as Message[];
+  protected taskBreakdown = "";
+  protected summaries = [] as string[];
+
+  public agentEvents = new EventEmitter();
+  public eventTypes = {
+    newThread: "new_thread",
+    threadUpdate: "thread_update",
+    costUpdate: "cost_update",
+    toolUsed: "tool_used",
+    done: "done",
+    pause: "pause",
+    kill: "kill",
+    unpause: "unpause",
+  };
+
+  disabledTools = [];
+
+  constructor(
+    public tools: ToolsService = Tools,
+    public events: EventService = Events
+  ) {}
+
+  newTask() {
+    this.currentThread = 0;
+    this.threads = [];
+    this.taskBreakdown = "";
+    this.summaries = [];
+    this.totalCostUsd = 0;
+    this.status = "in_progress";
+  }
+
+  register() {
+    this.events.registerAgent(this);
+  }
+
+  setModelPreferences(value: ModelPreference[]) {
+    this.modelPreferences = value;
+    if (value.length) {
+      this.updatePreferences(value[0]);
+    }
+  }
+
+  updatePreferences(value: ModelPreference) {
+    this.setModel(value.model);
+    this.setProvider(value.provider);
+  }
+
+  nextModel() {
+    this.currentModelPreferenceIndex++;
+    if (this.currentModelPreferenceIndex >= this.modelPreferences.length) {
+      throw new Error("We have exhausted all model preferences.");
+    }
+    const nextModel = this.modelPreferences[this.currentModelPreferenceIndex];
+    this.updatePreferences(nextModel);
+  }
+
+  getModel(): string {
+    return this.modelName;
+  }
+
+  setModel(value: string) {
+    this.modelName = value;
+  }
+
+  getProvider() {
+    return this.provider;
+  }
+
+  setProvider(value: keyof typeof Clients.clients) {
+    this.provider = value;
+  }
+
+  getClient() {
+    if (!this.client) {
+      this.client = Clients.getClient(this.provider)?.client;
+    }
+    return this.client;
+  }
+
+  setClient(client: GenericClient) {
+    this.client = client;
+  }
+
+  setEasyFinalAnswer(value: boolean) {
+    this.easyFinalAnswer = value;
+  }
+
+  getEnabledTools() {
+    return this.tools
+      .getTools()
+      .filter((t) => !this.disabledTools.includes(t.function.name));
+  }
+
+  getEnabledToolNames() {
+    return this.getEnabledTools().map((t) => t.function.name);
+  }
+
+  disableTool(toolName: string) {
+    this.disabledTools.push(toolName);
+  }
+
+  isToolEnabled(toolName: string) {
+    return !!this.getEnabledTools().find((t) => t.function.name === toolName);
+  }
+
+  enableTool(toolName: string) {
+    if (!this.isToolEnabled(toolName)) {
+      this.disabledTools = this.disabledTools.filter((t) => t !== toolName);
+    }
+  }
+
+  adjustTotalCostUsd(cost: number) {
+    if (cost) {
+      this.totalCostUsd += cost;
+      this.agentEvents.emit(this.eventTypes.costUpdate, this.totalCostUsd);
+    }
+  }
+
+  getTotalCostUsd() {
+    return this.totalCostUsd;
+  }
+
+  startNewThread(messages: Message[]) {
+    this.currentThread++;
+    this.agentEvents.emit(this.eventTypes.newThread, messages);
+    this.updateCurrentThread(messages);
+  }
+
+  updateCurrentThread(messages: Message[]) {
+    this.threads[this.currentThread] = messages;
+    this.agentEvents.emit(this.eventTypes.threadUpdate, messages);
+  }
+
+  getThreads() {
+    return this.threads;
+  }
+
+  getSummaries() {
+    return this.summaries;
+  }
+
+  abstract getInitialMessages(userInput: string): Promise<Message[]>;
+
+  async processToolMessages(toolCall: ToolCall) {
+    const functionName = toolCall.function.name;
+    const functionToCall = this.tools.getFunction(functionName);
+
+    console.log(toolCall);
+    const functionArgs = JSON.parse(
+      this.formatAiResponse(toolCall.function.arguments)
+    );
+
+    const toJsonIfObject = (arg: any) => {
+      if (typeof arg === "object") {
+        return JSON.stringify(arg, null, 2);
+      }
+      return arg;
+    };
+
+    const toolDefinition = this.tools.getTool(functionName);
+    const properties = toolDefinition?.function?.parameters?.properties || {};
+    const isPositional =
+      toolDefinition?.function?.parameters?.positional || false;
+    const fnArgs = isPositional
+      ? Object.keys(properties).map((p) => functionArgs[p])
+      : functionArgs;
+
+    console.log(
+      `Calling function ${functionName} with args:`,
+      JSON.stringify(fnArgs, null, 2)
+    );
+
+    if (!functionToCall) {
+      const options = this.getEnabledToolNames().join(", ");
+      const error = `Function ${functionName} not found, options are ${options}`;
+      console.log(error);
+      return [
+        {
+          tool_call_id: toolCall.id,
+          role: "tool",
+          name: "error",
+          content: error,
+        },
+      ];
+    }
+
+    const functionResponse = await Promise.resolve(
+      isPositional ? functionToCall(...fnArgs) : functionToCall(fnArgs)
+    ).catch((e) => "ERROR: " + e.message);
+
+    this.agentEvents.emit(this.eventTypes.toolUsed, {
+      toolCall,
+      functionResponse,
+    });
+
+    let toolMessages = [];
+
+    if (functionName === "multi_tool_use.parallel") {
+      const args = fnArgs[0] as {
+        recipient_name: string;
+        parameters: any;
+      }[];
+
+      toolMessages = args.map((call, index) => {
+        return {
+          tool_call_id: toolCall.id + "_" + index,
+          role: "tool",
+          name: call.recipient_name.split(".").pop(),
+          content: toJsonIfObject(functionResponse[index]) || "Done",
+        };
+      });
+    }
+
+    toolMessages = [
+      {
+        tool_call_id: toolCall.id,
+        role: "tool",
+        name: functionName,
+        content: toJsonIfObject(functionResponse) || "Done",
+      },
+    ];
+
+    console.log(toolMessages);
+
+    return toolMessages;
+  }
+
+  logMessages(messages: Message[]) {
+    for (const message of messages) {
+      if (message.role === "assistant") {
+        console.log(message.content);
+      }
+    }
+  }
+
+  formatInputContent(userInput: string) {
+    return replaceEscapedNewLines(userInput);
+  }
+
+  formatAiResponse(response: string) {
+    return restoreEscapedNewLines(response);
+  }
+
+  formatInputMessages(messages: Message[]) {
+    return messages.map((m) => ({
+      ...m,
+      content:
+        typeof m.content === "string"
+          ? this.formatInputContent(m.content)
+          : m.content,
+    })) as Message[];
+  }
+
+  formatOutputMessages(messages: Message[]) {
+    return messages.map((m) => ({
+      ...m,
+      content:
+        typeof m.content === "string"
+          ? this.formatAiResponse(m.content)
+          : m.content,
+    })) as Message[];
+  }
+
+  async healthCheck() {
+    try {
+      const canCallProvider = await this.getClient().createChatCompletion({
+        messages: [{ role: "user", content: "Hello!" }],
+        model: this.getModel(),
+        max_tokens: 2,
+      });
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
+
+  async selectHealthyModel() {
+    const currentTime = Date.now();
+    if (currentTime - this.lastHealthCheckTime < 60 * 1000) {
+      return;
+    }
+
+    let healthy = await this.healthCheck();
+    this.lastHealthCheckTime = Date.now();
+    while (!healthy) {
+      this.nextModel();
+      healthy = await this.healthCheck();
+    }
+    await this.healthCheck();
+  }
+
+  setNotHealthy() {
+    this.lastHealthCheckTime = 0;
+  }
+
+  pause() {
+    console.log("Pausing agent");
+    this.agentEvents.emit(this.eventTypes.pause, this);
+    this.status = this.eventTypes.pause;
+  }
+
+  unpause() {
+    console.log("Unpausing agent");
+    this.agentEvents.emit(this.eventTypes.unpause, this);
+    this.status = "in_progress";
+  }
+
+  async unpaused() {
+    return new Promise((resolve) => {
+      console.log("Waiting for agent to unpause");
+      this.agentEvents.once(this.eventTypes.unpause, () => {
+        console.log("Agent resumed");
+        resolve(true);
+      });
+      this.agentEvents.once(this.eventTypes.done, () => {
+        resolve(true);
+      });
+    });
+  }
+
+  async kill() {
+    console.log("Killing agent");
+    this.agentEvents.emit(this.eventTypes.kill, this);
+    this.status = this.eventTypes.kill;
+
+    this.addPendingUserMessage({
+      role: "user",
+      content: `<Workflow>The user has requested the task to end, please call ${this.requiredToolNames} with a report of your ending state</Workflow>`,
+    } as Message);
+  }
+
+  async call(userInput: string, _messages?: Message[]) {
+    if (this.status === this.eventTypes.pause) {
+      await this.unpaused();
+    }
+
+    await this.selectHealthyModel();
+
+    try {
+      const model = this.getModel();
+      let messages = _messages || (await this.getInitialMessages(userInput));
+      const taskBreakdown = await this.getTaskBreakdown(messages);
+
+      if (this.pendingUserMessages.length) {
+        messages.push(...this.pendingUserMessages);
+        this.pendingUserMessages = [];
+      }
+
+      messages = this.formatInputMessages(messages);
+      this.updateCurrentThread(messages);
+
+      const startIndex = 0;
+      const endIndex = messages.length;
+      const compressThreshold = 10000;
+
+      const response = await this.getClient().createChatCompletion({
+        model,
+        messages,
+        tools: this.getEnabledTools(),
+        tool_choice: "auto",
+      });
+
+      if (response?.usd_cost === undefined) {
+        console.warn("Response cost is undefined", response);
+      }
+
+      this.adjustTotalCostUsd(response?.usd_cost);
+      this.logMessages(response.choices.map((c) => c.message));
+
+      const firstMessage = response.choices[0].message;
+      const newToolCalls = response.choices.flatMap(
+        (c) => c.message.tool_calls
+      );
+
+      for (const choice of response.choices) {
+        const responseMessage = choice.message;
+        console.log(responseMessage);
+
+        const toolCalls = responseMessage.tool_calls;
+        if (responseMessage.tool_calls) {
+          // extend conversation with assistant's reply
+          messages.push(responseMessage);
+
+          for (const toolCall of toolCalls) {
+            const toolMessages = await this.processToolMessages(toolCall);
+            // Add the tool responses to the thread
+            messages.push(...(toolMessages as Message[]));
+
+            const finalMessage = toolMessages.find(
+              (m) =>
+                this.requiredToolNames.includes(m.name) ||
+                this.requiredToolNames.includes(mcpToolName(m.name))
+            );
+
+            if (finalMessage) {
+              const doneMsg = finalMessage.content || "Done";
+              this.agentEvents.emit(this.eventTypes.done, doneMsg);
+              return doneMsg;
+            }
+          }
+        }
+      }
+
+      // Early exit: not required to call tool
+      if (
+        response.choices.length === 1 &&
+        firstMessage.content &&
+        this.easyFinalAnswer
+      ) {
+        this.agentEvents.emit(this.eventTypes.done, firstMessage.content);
+        return firstMessage.content;
+      }
+
+      // Early exit: killed, agent was requested to wrap up
+      if (this.pendingUserMessages.length === 0 && this.status === "killed") {
+        console.log("Agent killed, stopping execution");
+        this.status = "killed";
+        this.agentEvents.emit(this.eventTypes.done, firstMessage.content);
+        return firstMessage.content;
+      }
+
+      if (this.getMessagesLength(messages) > compressThreshold) {
+        console.log(
+          "Compressing messages",
+          this.getMessagesLength(messages),
+          "exceeds",
+          compressThreshold
+        );
+        messages = await this.compressMessages(messages, startIndex, endIndex);
+        this.startNewThread(messages);
+      }
+
+      if (["assistant", "tool"].includes(messages[messages.length - 1].role)) {
+        // sometimes the agent just says a message and doesn't call a tool, or compression ends on a tool message
+        console.log(
+          "Agent continuing to the next iteration, reminding agent how to terminate"
+        );
+        messages.push({
+          role: "user",
+          content: `<Workflow>workflow continues until you call on of ${this.requiredToolNames}. Any continuation messages should be enclosed in workflow tags to hide intermediate work from users.</Workflow>`,
+        });
+      }
+
+      this.updateCurrentThread(messages);
+      return this.call(userInput, messages);
+    } catch (e) {
+      if (e.toString().includes("429")) {
+        this.setNotHealthy();
+        return this.call(userInput, _messages);
+      }
+
+      console.error(e);
+      this.agentEvents.emit(this.eventTypes.done, e.message);
+      return e.message;
+    }
+  }
+
+  addPendingUserMessage(message: Message) {
+    this.pendingUserMessages.push(message);
+  }
+
+  getMessagesLength(messages: Message[]) {
+    return JSON.stringify(messages).split(" ").length;
+  }
+
+  async getTaskBreakdown(messages: Message[]) {
+    if (this.taskBreakdown) {
+      return this.taskBreakdown;
+    }
+
+    const taskPrompt = `
+    Generate a detailed task breakdown for this conversation, include a section for the following:
+    1. Task List
+    2. Completion Criteria - when the agent should stop
+
+      : \n\n${JSON.stringify(messages)}`;
+
+    const model = this.getModel();
+
+    const response = await this.getClient().createChatCompletion({
+      model,
+      messages: [
+        {
+          role: "user",
+          content: taskPrompt,
+        },
+      ],
+    });
+
+    this.adjustTotalCostUsd(response.usd_cost);
+
+    console.log(response);
+
+    this.taskBreakdown = response.choices[0].message.content;
+    return this.taskBreakdown;
+  }
+
+  async compressMessages(
+    messages: Message[],
+    startIndex: number,
+    endIndex: number
+  ) {
+    const toCompress = messages.slice(startIndex, endIndex);
+    const toCompressPrompt = `We are compressing our conversation to save memory.
+    Please summarize the conversation so far, so that we may continue the original task with a smaller context
+
+    Include the following sections:
+    1. Initial Request - what this agent was originally 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.
+    4. Tasks remaining - what tasks are left from the initial task breakdown.
+
+      This summary will become the agent's only memory of the past, all other messages will be dropped:
+    ${JSON.stringify(toCompress)}
+
+      Our initial task breakdown: ${this.taskBreakdown}`;
+
+    const model = this.getModel();
+
+    const response = await this.getClient().createChatCompletion({
+      model,
+      messages: [
+        {
+          role: "user",
+          content: toCompressPrompt,
+        },
+      ],
+    });
+
+    this.adjustTotalCostUsd(response.usd_cost);
+
+    const summaries = response.choices.map((c) => c.message.content);
+    this.summaries.push(...summaries);
+
+    const startMessages = [
+      {
+        role: "user",
+        content: `
+        Initial task breakdown:
+        ${this.taskBreakdown}
+
+        We have just compressed the conversation to save memory:
+        ${JSON.stringify(summaries)}
+
+        Please continue the task from where we left off
+        `,
+      },
+    ] as Message[];
+    const systemMesasges = toCompress.filter((m) => m.role === "system");
+
+    const newMessages = [
+      ...systemMesasges,
+      ...startMessages,
+      ...messages.slice(endIndex),
+    ];
+
+    const oldLength = this.getMessagesLength(messages);
+    const newLength = this.getMessagesLength(newMessages);
+    const compressionRatio = (
+      ((oldLength - newLength) / oldLength) *
+      100
+    ).toFixed(2);
+
+    console.log(
+      "Compressed messages from",
+      oldLength,
+      "to",
+      newLength,
+      compressionRatio + "%",
+      "reduction in size"
+    );
+
+    return newMessages;
+  }
+}