@tyvm/knowhow 0.0.57 → 0.0.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.57",
+  "version": "0.0.60",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -10,7 +10,7 @@
     "test": "jest --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",
+    "start": "npm run compile && node --no-node-snapshot 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",
     "prepublishOnly": "npm run compile",
@@ -62,7 +62,7 @@
     "jira-client": "^8.2.2",
     "marked": "^10.0.0",
     "marked-terminal": "^6.2.0",
-    "minimatch": "^10.0.3",
+    "minimatch": "^10.1.2",
     "morgan": "^1.10.0",
     "node-fetch": "^3.2.3",
     "node-jq": "^6.0.1",

package/src/agents/base/base.ts

@@ -41,7 +41,7 @@ export abstract class BaseAgent implements IAgent {
   abstract name: string;
   abstract description: string;
 
-  private status = "in_progress";
+  private status = "not_started";
   private lastHealthCheckTime: number = 0;
   protected provider = "openai";
   protected modelName: string = Models.openai.GPT_4o;
@@ -70,11 +70,19 @@ export abstract class BaseAgent implements IAgent {
     costUpdate: "cost_update",
     toolCall: "tool:pre_call",
     toolUsed: "tool:post_call",
+    notStarted: "not_started",
+    inProgress: "in_progress",
     done: "done",
     pause: "pause",
     kill: "kill",
     unpause: "unpause",
+    agentMsg: "agent:msg",
+    userSay: "user:say",
+    agentSay: "agent:say",
+    agentNewTask: "agent:newTask",
+    agentTaskComplete: "agent:taskComplete",
   };
+
   public tools: ToolsService;
   public events: EventService;
   public messageProcessor: MessageProcessor;
@@ -97,12 +105,17 @@ export abstract class BaseAgent implements IAgent {
     }
 
     // Subscribe to "agent:msg" events for dynamic context loading
-    this.events.on("agent:msg", (eventData: any) => {
-      const message = {
-        role: "user",
-        content: JSON.stringify(eventData),
-      } as Message;
-      this.addPendingUserMessage(message);
+    this.events.on(this.eventTypes.agentMsg, (eventData: any) => {
+      if (
+        this.status === this.eventTypes.inProgress ||
+        this.status === this.eventTypes.pause
+      ) {
+        const message = {
+          role: "user",
+          content: JSON.stringify(eventData),
+        } as Message;
+        this.addPendingMessage(message);
+      }
     });
   }
 
@@ -124,14 +137,14 @@ export abstract class BaseAgent implements IAgent {
     this.taskBreakdown = "";
     this.summaries = [];
     this.totalCostUsd = 0;
-    this.status = "in_progress";
+    this.status = this.eventTypes.inProgress;
     this.turnCount = 0;
     this.startTimeMs = Date.now();
     this.currentTaskId = taskId || this.startTimeMs.toString();
 
     // Emit event for plugin integration
     const id = taskId || this.startTimeMs.toString();
-    this.events.emit("agent:newTask", {
+    this.events.emit(this.eventTypes.agentNewTask, {
       taskId: id,
     });
   }
@@ -319,6 +332,9 @@ export abstract class BaseAgent implements IAgent {
   logMessages(messages: Message[]) {
     for (const message of messages) {
       if (message.role === "assistant" && message.content) {
+        this.agentEvents.emit(this.eventTypes.agentSay, {
+          message: message.content,
+        });
         console.log("\n", "💬 " + message.content, "\n");
       }
     }
@@ -429,7 +445,7 @@ export abstract class BaseAgent implements IAgent {
   unpause() {
     console.log("Unpausing agent");
     this.agentEvents.emit(this.eventTypes.unpause, this);
-    this.status = "in_progress";
+    this.status = this.eventTypes.inProgress;
   }
 
   async unpaused() {
@@ -457,6 +473,10 @@ export abstract class BaseAgent implements IAgent {
   }
 
   async call(userInput: string, _messages?: Message[]) {
+    if (this.status === this.eventTypes.notStarted) {
+      this.status = this.eventTypes.inProgress;
+    }
+
     if (this.status === this.eventTypes.pause) {
       await this.unpaused();
     }
@@ -560,6 +580,8 @@ export abstract class BaseAgent implements IAgent {
             "pre_tools"
           );
 
+          this.updateCurrentThread(messages);
+
           for (const toolCall of toolCalls) {
             const toolMessages = await this.processToolMessages(toolCall);
             // Add the tool responses to the thread
@@ -576,7 +598,7 @@ export abstract class BaseAgent implements IAgent {
 
             if (finalMessage) {
               // Emit task completion event for plugins (like GitPlugin)
-              this.events.emit("agent:taskComplete", {
+              this.events.emit(this.eventTypes.agentTaskComplete, {
                 taskId:
                   this.currentTaskId ||
                   this.startTimeMs?.toString() ||
@@ -654,41 +676,13 @@ export abstract class BaseAgent implements IAgent {
 
       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"
-        );
-
-        const remainingTime =
-          this.maxRunTimeMs && this.startTimeMs
-            ? this.maxRunTimeMs - (Date.now() - this.startTimeMs)
-            : null;
-
-        const remainingTurns = this.maxTurns
-          ? this.maxTurns - this.turnCount
-          : null;
-
-        const timeRemainsingMsg = remainingTime
-          ? `You have approximately ${Math.floor(
-              remainingTime / 1000
-            )} seconds remaining for this task. `
-          : "";
-
-        const turnsRemainingMsg = remainingTurns
-          ? `You have ${remainingTurns} turns remaining. `
-          : "";
 
-        const remainingBudget = this.maxSpend
-          ? this.maxSpend - this.totalCostUsd
-          : null;
-        const budgetRemainingMsg = remainingBudget
-          ? `You have $${remainingBudget.toFixed(4)} remaining in your budget.`
-          : "";
+        const statusMessage = this.getStatusMessage();
+        this.logStatus();
 
         const continuation = `<Workflow>
         workflow continues until you call one of ${this.requiredToolNames}.\n
-        ${timeRemainsingMsg}
-        ${turnsRemainingMsg}
-        ${budgetRemainingMsg}
+        ${statusMessage}
         </Workflow>`;
 
         messages.push({
@@ -719,14 +713,64 @@ export abstract class BaseAgent implements IAgent {
     }
   }
 
-  addPendingUserMessage(message: Message) {
+  getStatusMessage() {
+    const remainingTime =
+      this.maxRunTimeMs && this.startTimeMs
+        ? this.maxRunTimeMs - (Date.now() - this.startTimeMs)
+        : null;
+
+    const remainingTurns = this.maxTurns
+      ? this.maxTurns - this.turnCount
+      : null;
+
+    const timeRemainingMsg = remainingTime
+      ? `You have approximately ${Math.floor(
+          remainingTime / 1000
+        )} seconds remaining for this task. `
+      : "";
+
+    const turnsRemainingMsg = remainingTurns
+      ? `You have ${remainingTurns} turns remaining. `
+      : "";
+
+    const remainingBudget = this.maxSpend
+      ? this.maxSpend - this.totalCostUsd
+      : null;
+    const budgetRemainingMsg = remainingBudget
+      ? `You have $${remainingBudget.toFixed(4)} remaining in your budget.`
+      : "";
+
+    const statusMessage = `${timeRemainingMsg}\n${turnsRemainingMsg}\n${budgetRemainingMsg}`;
+    return statusMessage;
+  }
+
+  logStatus() {
+    const statusMessage = this.getStatusMessage();
+    console.log(
+      `\n● ${this.name} status: $${this.getTotalCostUsd().toPrecision(
+        3
+      )}\n${statusMessage}`
+    );
+  }
+
+  addPendingMessage(message: Message) {
     if (this.status === this.eventTypes.done) {
       console.warn("Agent is done, cannot take more messages");
     } else {
+      const pendingMessages = this.pendingUserMessages.map((m) => m.content);
+      if (pendingMessages.includes(message.content)) {
+        // Ignore messages we already have queue'd up
+        return;
+      }
       this.pendingUserMessages.push(message);
     }
   }
 
+  addPendingUserMessage(message: Message) {
+    this.addPendingMessage(message);
+    this.events.emit(this.eventTypes.userSay, message.content);
+  }
+
   getMessagesLength(messages: Message[]) {
     return JSON.stringify(messages).split(" ").length;
   }

package/src/agents/tools/execCommand.ts

@@ -42,19 +42,19 @@ function commandNameFrom(cmd: string) {
 
 function makeLogPath(cmd: string, customFileName?: string) {
   // Use custom filename if provided, otherwise derive from command
-  let baseName = customFileName 
+  let baseName = customFileName
     ? customFileName.replace(/[^\w.-]+/g, "_")
     : commandNameFrom(cmd);
-  
+
   let logPath = path.join(PROCESSES_DIR, `${baseName}.txt`);
-  
+
   // If file already exists, append epoch seconds to ensure uniqueness
   if (fs.existsSync(logPath)) {
     const epochSeconds = Math.floor(Date.now() / 1000);
     baseName = `${baseName}_${epochSeconds}`;
     logPath = path.join(PROCESSES_DIR, `${baseName}.txt`);
   }
-  
+
   return logPath;
 }
 
@@ -282,15 +282,18 @@ export const execCommand = async (
     : "";
 
   const lines = output.split("\n");
-  const maxLines = 1000;
-  const maxChars = 40000;
-  const trimmed = (lines.length > maxLines ? lines.slice(0, maxLines) : lines)
-    .join("\n")
-    .slice(0, maxChars);
-  const trimmedMsg =
-    lines.length > maxLines
-      ? ` (${lines.length - maxLines} results trimmed)`
-      : "";
+  /*
+   *const maxLines = 1000;
+   *const maxChars = 40000;
+   *const trimmed = (lines.length > maxLines ? lines.slice(0, maxLines) : lines)
+   *  .join("\n")
+   *  .slice(0, maxChars);
+   *const trimmedMsg =
+   *  lines.length > maxLines
+   *    ? ` (${lines.length - maxLines} results trimmed)`
+   *    : "";
+   */
 
-  return `$ ${command}${statusMsg}\n${trimmed}${trimmedMsg}`;
+  // return `$ ${command}${statusMsg}\n${trimmed}${trimmedMsg}`;
+  return `$ ${command}${statusMsg}\n${output}`;
 };

package/src/agents/tools/googleSearch.ts

@@ -154,6 +154,7 @@ function transformGoogleSearchResponseForLLM(
     searchQuery,
     totalResults,
     results: relevantItems,
+    usd_cost: 0.005,
   };
 }
 

package/src/agents/tools/index.ts

@@ -27,3 +27,4 @@ export * from "./executeScript";
 export * from "./ast";
 export * from "./startAgentTask";
 export * from "./ycmd";
+export * from "./mcp";

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

@@ -0,0 +1,65 @@
+import { Tool } from "../../../clients/types";
+
+export const listAvailableToolsDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "listAvailableTools",
+    description:
+      "List all available tools in the system, showing which are currently enabled and disabled. Use this to discover what tools exist before enabling them.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {},
+      required: [],
+    },
+  },
+};
+
+export const enableToolsDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "enableTools",
+    description:
+      "Enable tools matching glob patterns. Examples: ['read*'] enables all tools starting with 'read', ['mcp_*_browser_*'] enables all browser MCP tools, ['*File'] enables all tools ending with 'File'. Pass an array of pattern strings.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        patterns: {
+          type: "array",
+          items: { type: "string" },
+          description:
+            "Array of glob patterns to match tool names.",
+        },
+      },
+      required: ["patterns"],
+    },
+  },
+};
+
+export const disableToolsDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "disableTools",
+    description:
+      "Disable tools matching glob patterns. This removes tools from the available tool list to stay within provider limits. Pass an array of pattern strings.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        patterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Array of glob patterns to match tool names for disabling.",
+        },
+      },
+      required: ["patterns"],
+    },
+  },
+};
+
+export const definitions = [
+  listAvailableToolsDefinition,
+  enableToolsDefinition,
+  disableToolsDefinition,
+];

package/src/agents/tools/lazy/disableTools.ts

@@ -0,0 +1,16 @@
+import { LazyToolsService } from "../../../services/LazyToolsService";
+import { ToolsService } from "../../../services/Tools";
+
+export async function disableTools(
+  this: ToolsService,
+  patterns: string[]
+) {
+  if (!(this instanceof LazyToolsService)) {
+    return {
+      error: "This tool requires LazyToolsService",
+      message: "disableTools is only available when using LazyToolsService",
+    };
+  }
+
+  return this.disableTools(patterns);
+}

package/src/agents/tools/lazy/enableTools.ts

@@ -0,0 +1,16 @@
+import { LazyToolsService } from "../../../services/LazyToolsService";
+import { ToolsService } from "../../../services/Tools";
+
+export async function enableTools(
+  this: ToolsService,
+  patterns: string[]
+) {
+  if (!(this instanceof LazyToolsService)) {
+    return {
+      error: "This tool requires LazyToolsService",
+      message: "enableTools is only available when using LazyToolsService",
+    };
+  }
+
+  return this.enableTools(patterns);
+}

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

@@ -0,0 +1,3 @@
+export * from "./listAvailableTools";
+export * from "./enableTools";
+export * from "./disableTools";

package/src/agents/tools/lazy/listAvailableTools.ts

@@ -0,0 +1,14 @@
+import { LazyToolsService } from "../../../services/LazyToolsService";
+import { ToolsService } from "../../../services/Tools";
+
+export async function listAvailableTools(this: ToolsService) {
+  if (!(this instanceof LazyToolsService)) {
+    return {
+      error: "This tool requires LazyToolsService",
+      message:
+        "listAvailableTools is only available when using LazyToolsService",
+    };
+  }
+
+  return this.listAvailableTools();
+}

package/src/agents/tools/list.ts

@@ -6,6 +6,7 @@ import * as github from "./github/definitions";
 import * as asana from "./asana/definitions";
 import * as ycmd from "./ycmd/definitions";
 import * as language from "./language/definitions";
+import * as mcp from "./mcp/definitions";
 import { googleSearchDefinition } from "./googleSearch";
 import { executeScriptDefinition } from "./executeScript/definition";
 import { startAgentTaskDefinition } from "./startAgentTask";
@@ -795,4 +796,5 @@ export const includedTools = [
   ...ycmd.definitions,
   ...github.definitions,
   ...language.definitions,
+  ...mcp.definitions,
 ] as Tool[];

package/src/agents/tools/mcp/connectMcpServer.ts

@@ -0,0 +1,40 @@
+import { services } from "../../../services";
+import { McpService } from "../../../services/Mcp";
+import { ToolsService } from "../../../services/Tools";
+
+export async function connectMcpServer(
+  serverName: string,
+  timeout: number = 30000
+) {
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+  const Mcp = context.Mcp;
+
+  if (!Mcp) {
+    return {
+      success: false,
+      error: "MCP service not available in context",
+      toolsAdded: [],
+    };
+  }
+
+  if (!serverName) {
+    return {
+      success: false,
+      error: "serverName parameter is required",
+      toolsAdded: [],
+    };
+  }
+
+  const result = await Mcp.connectSingle(serverName, timeout);
+
+  // If connection was successful and tools were added, register them with the ToolsService
+  if (result.success && result.toolsAdded.length > 0) {
+    await Mcp.addTools(toolService);
+  }
+
+  return result;
+}

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

@@ -0,0 +1,67 @@
+import { Tool } from "../../../clients/types";
+
+const listAvailableMcpServersDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "listAvailableMcpServers",
+    description:
+      "List all configured MCP servers and their connection status. Shows which servers are connected, which are disconnected, and how many tools each provides.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {},
+      required: [],
+    },
+  },
+};
+
+const connectMcpServerDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "connectMcpServer",
+    description:
+      "Connect to a specific MCP server on-demand. This is useful for servers configured with autoConnect: false, or to reconnect a disconnected server. Once connected, the server's tools will be available for use.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        serverName: {
+          type: "string",
+          description: "The name of the MCP server to connect to",
+        },
+        timeout: {
+          type: "number",
+          description:
+            "Connection timeout in milliseconds (optional, default: 30000)",
+        },
+      },
+      required: ["serverName"],
+    },
+  },
+};
+
+const disconnectMcpServerDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "disconnectMcpServer",
+    description:
+      "Disconnect from a specific MCP server. This will close the connection and remove the server's tools from the available tools list.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        serverName: {
+          type: "string",
+          description: "The name of the MCP server to disconnect from",
+        },
+      },
+      required: ["serverName"],
+    },
+  },
+};
+
+export const definitions = [
+  listAvailableMcpServersDefinition,
+  connectMcpServerDefinition,
+  disconnectMcpServerDefinition,
+];

package/src/agents/tools/mcp/disconnectMcpServer.ts

@@ -0,0 +1,40 @@
+import { services } from "../../../services";
+import { McpService } from "../../../services/Mcp";
+import { ToolsService } from "../../../services/Tools";
+
+export async function disconnectMcpServer(serverName: string) {
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+  const Mcp = context.Mcp;
+
+  if (!Mcp) {
+    return {
+      success: false,
+      error: "MCP service not available in context",
+      toolsRemoved: [],
+    };
+  }
+
+  if (!serverName) {
+    return {
+      success: false,
+      error: "serverName parameter is required",
+      toolsRemoved: [],
+    };
+  }
+
+  const result = await Mcp.disconnectSingle(serverName);
+
+  // If disconnection was successful and tools were removed, update the ToolsService
+  if (result.success && result.toolsRemoved.length > 0) {
+    // Remove tools from the current ToolsService instance
+    toolService.tools = toolService.tools.filter(
+      (tool) => !result.toolsRemoved.includes(tool.function.name)
+    );
+  }
+
+  return result;
+}

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

@@ -0,0 +1,3 @@
+export { listAvailableMcpServers } from "./listAvailableMcpServers";
+export { connectMcpServer } from "./connectMcpServer";
+export { disconnectMcpServer } from "./disconnectMcpServer";

package/src/agents/tools/mcp/listAvailableMcpServers.ts

@@ -0,0 +1,28 @@
+import { services } from "../../../services";
+import { McpService } from "../../../services/Mcp";
+import { ToolsService } from "../../../services/Tools";
+
+export async function listAvailableMcpServers() {
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+  const Mcp = context.Mcp;
+
+  if (!Mcp) {
+    return {
+      error: "MCP service not available in context",
+      servers: [],
+    };
+  }
+
+  const servers = Mcp.getAvailableServers();
+
+  return {
+    servers,
+    summary: `Found ${servers.length} configured MCP server(s). ${
+      servers.filter((s) => s.connected).length
+    } connected, ${servers.filter((s) => !s.connected).length} disconnected.`,
+  };
+}

package/src/agents/tools/writeFile.ts

@@ -25,7 +25,10 @@ export async function writeFileChunk(
 
   if (!filePath || content === undefined) {
     throw new Error(
-      "File path and content are both required. Make sure you write small chunks of content, otherwise you may hit output limits."
+      `File path and content are both required. We received: ${JSON.stringify({
+        filePath,
+        content,
+      })}. Make sure you write small chunks of content, otherwise you will hit output limits, resulting in content being empty.`
     );
   }