@tyvm/knowhow 0.0.47 → 0.0.49

package/jest.config.js

@@ -12,8 +12,8 @@ module.exports = {
     ],
   },
   testEnvironment: 'node',
-  testRegex: '/tests/.*\.(test|spec)?\.(ts|tsx|js)$',
+  testRegex: '/tests/.*\.(test|spec)\.(ts|tsx|js)$',
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
   modulePathIgnorePatterns: ["ts_build", "benchmarks"],
-  testPathIgnorePatterns: ["<rootDir>/benchmarks/"]
+  testPathIgnorePatterns: ["<rootDir>/benchmarks/", "<rootDir>/tests/manual/"],
 };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "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": "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",
@@ -41,7 +41,7 @@
     "@anthropic-ai/sdk": "^0.39.0",
     "@aws-sdk/client-s3": "^3.588.0",
     "@google/genai": "^0.14.1",
-    "@inquirer/editor": "^1.2.13",
+    "@inquirer/editor": "^4.2.18",
     "@linear/sdk": "^12.0.0",
     "@modelcontextprotocol/sdk": "^1.13.3",
     "@notionhq/client": "^2.2.14",
@@ -56,11 +56,13 @@
     "express": "^4.19.2",
     "figma-js": "^1.16.1-0",
     "gitignore-to-glob": "^0.3.0",
+    "glob": "11.0.3",
     "ink": "^6.0.1",
     "isolated-vm": "^5.0.4",
     "jira-client": "^8.2.2",
     "marked": "^10.0.0",
     "marked-terminal": "^6.2.0",
+    "minimatch": "^10.0.3",
     "morgan": "^1.10.0",
     "node-fetch": "^3.2.3",
     "node-jq": "^6.0.1",
@@ -77,6 +79,9 @@
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "react": "^19.1.0",
     "source-map-support": "^0.5.21",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-javascript": "^0.23.1",
+    "tree-sitter-typescript": "^0.23.1",
     "typescript": "^4.6.3",
     "ws": "^8.18.1",
     "youtube-dl-exec": "^2.5.5",

package/src/agents/base/base.ts

@@ -31,6 +31,11 @@ export interface AgentContext {
   Clients?: AIClient;
 }
 
+export interface ToolCallEvent {
+  toolCall: ToolCall;
+  functionResp: any;
+}
+
 export abstract class BaseAgent implements IAgent {
   abstract name: string;
   abstract description: string;
@@ -55,13 +60,15 @@ export abstract class BaseAgent implements IAgent {
   protected pendingUserMessages = [] as Message[];
   protected taskBreakdown = "";
   protected summaries = [] as string[];
+  protected currentTaskId: string | null = null;
 
   public agentEvents = new EventEmitter();
   public eventTypes = {
     newThread: "new_thread",
     threadUpdate: "thread_update",
     costUpdate: "cost_update",
-    toolUsed: "tool_used",
+    toolCall: "tool:pre_call",
+    toolUsed: "tool:post_call",
     done: "done",
     pause: "pause",
     kill: "kill",
@@ -87,6 +94,15 @@ export abstract class BaseAgent implements IAgent {
     if (!this.events) {
       throw new Error("EventService is required for BaseAgent");
     }
+
+    // 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);
+    });
   }
 
   setMaxTurns(maxTurns: number | null) {
@@ -101,7 +117,7 @@ export abstract class BaseAgent implements IAgent {
     this.maxRunTimeMs = maxRunTimeMs;
   }
 
-  newTask() {
+  newTask(taskId?: string) {
     this.currentThread = 0;
     this.threads = [];
     this.taskBreakdown = "";
@@ -110,6 +126,13 @@ export abstract class BaseAgent implements IAgent {
     this.status = "in_progress";
     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", {
+      taskId: id,
+    });
   }
 
   register() {
@@ -143,6 +166,7 @@ export abstract class BaseAgent implements IAgent {
 
   setModel(value: string) {
     this.modelName = value;
+    this.client = null; // Reset client to force re-fetch
   }
 
   getProvider() {
@@ -151,6 +175,7 @@ export abstract class BaseAgent implements IAgent {
 
   setProvider(value: keyof typeof Clients.clients) {
     this.provider = value;
+    this.client = null; // Reset client to force re-fetch
   }
 
   getClient() {
@@ -275,6 +300,8 @@ export abstract class BaseAgent implements IAgent {
   abstract getInitialMessages(userInput: string): Promise<Message[]>;
 
   async processToolMessages(toolCall: ToolCall) {
+    this.agentEvents.emit(this.eventTypes.toolCall, { toolCall });
+
     const { functionResp, toolMessages } = await this.tools.callTool(
       toolCall,
       this.getEnabledToolNames()
@@ -416,27 +443,6 @@ export abstract class BaseAgent implements IAgent {
     });
   }
 
-  async resume(resumeReason: string) {
-    const reason = resumeReason ? `Reason for resuming:  ${resumeReason}` : "";
-
-    // Create resume prompt
-    const resumePrompt = `We are resuming a previously started task. Here's the context:
-ORIGINAL REQUEST:
-${this.taskBreakdown}
-
-LAST Progress State:
-${JSON.stringify(this.threads[this.currentThread], null, 2)}
-
-Please continue from where you left off and complete the original request.
-${reason}
-
-`;
-
-    const lastThread = this.threads[this.currentThread] || [];
-    this.status = "in_progress";
-    this.call(resumePrompt, lastThread);
-  }
-
   async kill() {
     console.log("Killing agent");
     this.agentEvents.emit(this.eventTypes.kill, this);
@@ -564,6 +570,14 @@ ${reason}
             );
 
             if (finalMessage) {
+              // Emit task completion event for plugins (like GitPlugin)
+              this.events.emit("agent:taskComplete", {
+                taskId:
+                  this.currentTaskId ||
+                  this.startTimeMs?.toString() ||
+                  Date.now().toString(),
+                result: finalMessage.content || "Done",
+              });
               const doneMsg = finalMessage.content || "Done";
               this.agentEvents.emit(this.eventTypes.done, doneMsg);
               this.status = this.eventTypes.done;
@@ -620,7 +634,7 @@ ${reason}
 
       if (
         this.getMessagesLength(messages) > compressThreshold &&
-        messages.length > 10
+        messages.length > 20
       ) {
         const taskBreakdown = await this.getTaskBreakdown(messages);
         console.log(
@@ -702,7 +716,7 @@ ${reason}
 
   addPendingUserMessage(message: Message) {
     if (this.status === this.eventTypes.done) {
-      this.resume(JSON.stringify(message.content));
+      console.warn("Agent is done, cannot take more messages");
     } else {
       this.pendingUserMessages.push(message);
     }

package/src/agents/patcher/patcher.ts

@@ -79,11 +79,9 @@ export class PatchingAgent extends BaseAgent {
     super(context);
 
     this.setModelPreferences([
-      { model: Models.anthropic.Sonnet4, provider: "anthropic" },
-      {
-        model: Models.openai.GPT_41_Mini,
-        provider: "openai",
-      },
+      { model: Models.anthropic.Sonnet4_5, provider: "anthropic" },
+      { model: Models.xai.GrokCodeFast, provider: "xai" },
+      { model: Models.openai.GPT_5, provider: "openai" },
     ]);
   }
 
@@ -102,6 +100,29 @@ export class PatchingAgent extends BaseAgent {
         This helps ensure accurate modifications and can suggest fixes for compilation errors.
 
         IF you fail twice to patch a file, you may switch using writeFileChunk to rewrite the whole file.
+
+        If you need to know about a type, you should use the ycmd completion tool to discovery the properties, and fallback to reading the source files if the ycmd tools are not available.
+
+        # Debugging Workflow
+        If a build or test command fails due to compilation errors:
+
+        ALWAYS start by running ycmdDiagnostics on the file with errors to get a structured list of issues.
+
+        Address the errors one at a time, from top to bottom.
+
+        For each error, use ycmdGoTo to find the correct definition or readFile on the relevant source file to understand the correct implementation.
+
+        If an error is related to properties not being named correctly, you can use ycmdCompletion to get suggestions for the correct property or method names.
+
+        Apply a small, targeted patch to fix only that single error.
+
+        After every 2-3 fixes, run ycmdDiagnostics again to confirm progress.
+
+        # Test Writing Workflow
+        When writing tests, you proceed incrementally, writing one test, verifying it compiles and works before moving on to the next test.
+        You ALWAYS get to a stable state with tests compiling / running before adding the next test.
+        When writing tests, you never change the source code to pass the test, you always change the test to match the existing source code.
+
         `,
       },
       { role: "user", content: userInput },

package/src/agents/tools/agentCall.ts

@@ -1,10 +1,12 @@
 import { getConfig } from "../../config";
-import { ToolsService } from "../../services";
+import { services, ToolsService } from "../../services";
 
 export async function agentCall(agentName: string, userInput: string) {
   return new Promise(async (resolve, reject) => {
     const config = await getConfig();
-    const toolService = this as ToolsService;
+    const toolService = (
+      this instanceof ToolsService ? this : services().Tools
+    ) as ToolsService;
 
     const { Events, Plugins } = toolService.getContext();
 

package/src/agents/tools/aiClient.ts

@@ -9,7 +9,6 @@ import {
 import { services } from "../../services";
 
 export function createAiCompletion(
-  this: ToolsService,
   provider: string,
   options: CompletionOptions
 ): Promise<CompletionResponse> {
@@ -29,7 +28,6 @@ export function createAiCompletion(
 }
 
 export function createEmbedding(
-  this: ToolsService,
   provider: string,
   options: EmbeddingOptions
 ): Promise<EmbeddingResponse> {
@@ -49,7 +47,6 @@ export function createEmbedding(
 }
 
 export async function listModelsForProvider(
-  this: ToolsService,
   provider: string
 ): Promise<string[]> {
   // Get context from bound ToolsService
@@ -68,7 +65,6 @@ export async function listModelsForProvider(
 }
 
 export async function listAllModels(
-  this: ToolsService
 ): Promise<Record<string, string[]>> {
   // Get context from bound ToolsService
   const toolService = (
@@ -85,7 +81,7 @@ export async function listAllModels(
   return contextClients.listAllModels();
 }
 
-export async function listAllProviders(this: ToolsService): Promise<string[]> {
+export async function listAllProviders(): Promise<string[]> {
   // Get context from bound ToolsService
   const toolService = (
     this instanceof ToolsService ? this : services().Tools
@@ -101,9 +97,7 @@ export async function listAllProviders(this: ToolsService): Promise<string[]> {
   return contextClients.listAllProviders();
 }
 
-export async function listAllCompletionModels(
-  this: ToolsService
-): Promise<Record<string, string[]>> {
+export async function listAllCompletionModels(): Promise<Record<string, string[]>> {
   // Get context from bound ToolsService
   const toolService = (
     this instanceof ToolsService ? this : services().Tools
@@ -119,9 +113,7 @@ export async function listAllCompletionModels(
   return contextClients.listAllCompletionModels();
 }
 
-export async function listAllEmbeddingModels(
-  this: ToolsService
-): Promise<Record<string, string[]>> {
+export async function listAllEmbeddingModels(): Promise<Record<string, string[]>> {
   // Get context from bound ToolsService
   const toolService = (
     this instanceof ToolsService ? this : services().Tools

package/src/agents/tools/ast/astAppendNode.ts

@@ -0,0 +1,90 @@
+import * as fs from "fs";
+import { fileExists } from "../../../utils";
+import { services, ToolsService } from "../../../services";
+import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../plugins/tree-sitter/editor";
+
+/**
+ * Append a child node to a specific path in a file using tree-sitter AST parsing
+ */
+export async function astAppendNode(filePath: string, parentPath: string, newContent: string): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  // Read original content for event emission
+  let originalContent = "";
+  try {
+    originalContent = fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+  }
+
+  // Emit pre-edit blocking event
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-edit", {
+      filePath,
+      operation: "ast-append-node",
+      content: newContent,
+      originalContent,
+      astParentPath: parentPath,
+    });
+  }
+
+  try {
+    if (!LanguageAgnosticParser.supportsFile(filePath)) {
+      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
+    }
+
+    const parser = LanguageAgnosticParser.createParserForFile(filePath);
+    const editor = new TreeEditor(parser, originalContent);
+    const updatedEditor = editor.appendChild(parentPath, newContent);
+    const updatedContent = updatedEditor.getCurrentText();
+
+    // Write the updated content back to the file
+    fs.writeFileSync(filePath, updatedContent, "utf8");
+
+    // Emit post-edit blocking event (only on success)
+    let eventResults: any[] = [];
+    if (context.Events) {
+      eventResults = await context.Events.emitBlocking("file:post-edit", {
+        filePath,
+        operation: "ast-append-node",
+        content: newContent,
+        originalContent,
+        updatedContent,
+        astParentPath: parentPath,
+        success: true,
+      });
+    }
+
+    const result = {
+      file: filePath,
+      parentPath,
+      action: "appendChild",
+      success: true,
+      message: `Successfully appended child node to path: ${parentPath}`,
+    };
+
+    // Format event results
+    let eventResultsText = "";
+    if (eventResults && eventResults.length > 0) {
+      eventResultsText =
+        "\n\nAdditional Information:\n" +
+        JSON.stringify(eventResults, null, 2);
+    }
+
+    return JSON.stringify(result, null, 2) + eventResultsText;
+  } catch (error: any) {
+    // Do NOT emit post-edit event on error
+    throw new Error(`Failed to append node in ${filePath}: ${error.message}`);
+  }
+}

package/src/agents/tools/ast/astDeleteNode.ts

@@ -0,0 +1,88 @@
+import * as fs from "fs";
+import { fileExists } from "../../../utils";
+import { services, ToolsService } from "../../../services";
+import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../plugins/tree-sitter/editor";
+
+/**
+ * Delete a node at a specific path in a file using tree-sitter AST parsing
+ */
+export async function astDeleteNode(filePath: string, path: string): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  // Read original content for event emission
+  let originalContent = "";
+  try {
+    originalContent = fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+  }
+
+  // Emit pre-edit blocking event
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-edit", {
+      filePath,
+      operation: "ast-delete-node",
+      originalContent,
+      astPath: path,
+    });
+  }
+
+  try {
+    if (!LanguageAgnosticParser.supportsFile(filePath)) {
+      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
+    }
+
+    const parser = LanguageAgnosticParser.createParserForFile(filePath);
+    const editor = new TreeEditor(parser, originalContent);
+    const updatedEditor = editor.deleteNodeByPath(path);
+    const updatedContent = updatedEditor.getCurrentText();
+
+    // Write the updated content back to the file
+    fs.writeFileSync(filePath, updatedContent, "utf8");
+
+    // Emit post-edit blocking event (only on success)
+    let eventResults: any[] = [];
+    if (context.Events) {
+      eventResults = await context.Events.emitBlocking("file:post-edit", {
+        filePath,
+        operation: "ast-delete-node",
+        originalContent,
+        updatedContent,
+        astPath: path,
+        success: true,
+      });
+    }
+
+    const result = {
+      file: filePath,
+      path,
+      action: "delete",
+      success: true,
+      message: `Successfully deleted node at path: ${path}`,
+    };
+
+    // Format event results
+    let eventResultsText = "";
+    if (eventResults && eventResults.length > 0) {
+      eventResultsText =
+        "\n\nAdditional Information:\n" +
+        JSON.stringify(eventResults, null, 2);
+    }
+
+    return JSON.stringify(result, null, 2) + eventResultsText;
+  } catch (error: any) {
+    // Do NOT emit post-edit event on error
+    throw new Error(`Failed to delete node in ${filePath}: ${error.message}`);
+  }
+}

package/src/agents/tools/ast/astEditNode.ts

@@ -0,0 +1,95 @@
+import * as fs from "fs";
+import { fileExists } from "../../../utils";
+import { services, ToolsService } from "../../../services";
+import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../plugins/tree-sitter/editor";
+
+/**
+ * Update a node at a specific path in a file using tree-sitter AST parsing
+ */
+export async function astEditNode(
+  filePath: string,
+  path: string,
+  newContent: string
+): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  // Read original content for event emission
+  let originalContent = "";
+  try {
+    originalContent = fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+  }
+
+  // Emit pre-edit blocking event
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-edit", {
+      filePath,
+      operation: "ast-edit-node",
+      content: newContent,
+      originalContent,
+      astPath: path,
+    });
+  }
+
+  try {
+    if (!LanguageAgnosticParser.supportsFile(filePath)) {
+      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
+    }
+
+    const parser = LanguageAgnosticParser.createParserForFile(filePath);
+    const editor = new TreeEditor(parser, originalContent);
+    const updatedEditor = editor.updateNodeByPath(path, newContent);
+    const updatedContent = updatedEditor.getCurrentText();
+
+    // Write the updated content back to the file
+    fs.writeFileSync(filePath, updatedContent, "utf8");
+
+    // Emit post-edit blocking event
+    let eventResults: any[] = [];
+    if (context.Events) {
+      eventResults = await context.Events.emitBlocking("file:post-edit", {
+        filePath,
+        operation: "ast-edit-node",
+        content: newContent,
+        originalContent,
+        updatedContent,
+        astPath: path,
+        success: true,
+      });
+    }
+
+    const result = {
+      file: filePath,
+      path,
+      action: "update",
+      success: true,
+      message: `Successfully updated node at path: ${path}`,
+    };
+
+    // Format event results
+    let eventResultsText = "";
+    if (eventResults && eventResults.length > 0) {
+      eventResultsText =
+        "\n\nAdditional Information:\n" +
+        JSON.stringify(eventResults, null, 2);
+    }
+
+    return JSON.stringify(result, null, 2) + eventResultsText;
+  } catch (error: any) {
+    // Do NOT emit post-edit event on error
+
+    throw new Error(`Failed to edit node in ${filePath}: ${error.message}`);
+  }
+}

package/src/agents/tools/ast/astGetPathForLine.ts

@@ -0,0 +1,73 @@
+import * as fs from "fs";
+import { fileExists } from "../../../utils";
+import { services, ToolsService } from "../../../services";
+import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../plugins/tree-sitter/editor";
+
+/**
+ * Get the AST path for a specific line of text in a file using tree-sitter parsing
+ */
+export async function astGetPathForLine(
+  filePath: string,
+  searchText: string
+): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  // Emit pre-action event
+  if (context.Events) {
+    await context.Events.emitBlocking("ast:pre-get-path-for-line", {
+      filePath,
+      searchText,
+    });
+  }
+
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+
+    if (!LanguageAgnosticParser.supportsFile(filePath)) {
+      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
+    }
+
+    const parser = LanguageAgnosticParser.createParserForFile(filePath);
+    const tree = parser.parseString(content);
+    const pathLocations = parser.findPathsForLine(tree, searchText);
+
+    // Emit post-action event
+    if (context.Events) {
+      await context.Events.emitNonBlocking("ast:post-get-path-for-line", {
+        filePath,
+        searchText,
+        pathCount: pathLocations.length,
+      });
+    }
+
+    const result = {
+      file: filePath,
+      searchText,
+      language: parser.getLanguage(),
+      totalMatches: pathLocations.length,
+      matches: pathLocations.map((loc) => ({
+        path: loc.path,
+        line: loc.row + 1, // Convert from 0-based to 1-based line numbering
+        column: loc.column + 1, // Convert from 0-based to 1-based column numbering
+        text: loc.text,
+      })),
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error: any) {
+    throw new Error(
+      `Failed to get path for line in ${filePath}: ${error.message}`
+    );
+  }
+}