@tyvm/knowhow 0.0.46 → 0.0.48

package/src/agents/tools/list.ts

@@ -1,8 +1,7 @@
 import { Tool } from "../../clients/types";
 import { ChatCompletionTool } from "openai/resources/chat";
-import { Plugins } from "../../plugins/plugins";
 
-const pluginNames = Plugins.listPlugins().join(", ");
+import { services } from "../../services";
 import * as github from "./github/definitions";
 import * as asana from "./asana/definitions";
 import * as ycmd from "./ycmd/definitions";
@@ -11,6 +10,15 @@ import { googleSearchDefinition } from "./googleSearch";
 import { executeScriptDefinition } from "./executeScript/definition";
 import { startAgentTaskDefinition } from "./startAgentTask";
 
+function getPluginNames(): string {
+  try {
+    const { Plugins } = services();
+    return Plugins.listPlugins().join(", ");
+  } catch {
+    return "";
+  }
+}
+
 export const includedTools = [
   {
     type: "function",
@@ -41,7 +49,7 @@ export const includedTools = [
     function: {
       name: "execCommand",
       description:
-        "Execute a command in the system's command line interface. Use this to run tests and things in the terminal. Supports timeout functionality.",
+        "Execute a command in the system's command line interface. Use this to run tests and things in the terminal. Supports timeout functionality. Use timeout: -1 to wait indefinitely. Commands ending with '&' or with continueInBackground=true will run in the background and write logs to .knowhow/processes/<command_name>.txt with PID in the first line for cleanup.",
       parameters: {
         type: "object",
         positional: true,
@@ -53,18 +61,13 @@ export const includedTools = [
           timeout: {
             type: "number",
             description:
-              "Timeout in milliseconds (optional). If not provided, defaults to 5000ms.",
+              "Timeout in milliseconds (optional). If not provided, defaults to 5000ms. Use -1 to wait indefinitely for command completion.",
           },
           continueInBackground: {
             type: "boolean",
             description:
               "Whether to let command continue in background on timeout (default: false). If false, command is killed on timeout.",
           },
-          waitForCompletion: {
-            type: "boolean",
-            description:
-              "Whether to wait for full completion regardless of timeout (default: false). When true, overrides timeout behavior.",
-          },
         },
         required: ["command"],
       },
@@ -104,7 +107,7 @@ export const includedTools = [
     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}`,
+      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: ${getPluginNames()}`,
       parameters: {
         type: "object",
         positional: true,
@@ -382,38 +385,66 @@ export const includedTools = [
       parameters: {
         type: "object",
         positional: true,
+        additionalProperties: false,
+        $defs: {
+          message: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              role: {
+                type: "string",
+                enum: ["system", "user", "assistant", "tool"],
+              },
+              content: { type: "string" },
+            },
+            required: ["role", "content"],
+          },
+          toolLite: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              type: { type: "string", enum: ["function"] },
+              function: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  name: { type: "string" },
+                  description: { type: "string" },
+                  parameters: { type: "object" },
+                },
+                required: ["name", "parameters"],
+              },
+            },
+            required: ["type", "function"],
+          },
+        },
         properties: {
           provider: {
             type: "string",
             description:
               "The AI provider to use (e.g., 'openai', 'anthropic'). Use listAllModels to discover providers.",
           },
-
           options: {
             type: "object",
+            additionalProperties: false,
             description: "Provider-specific completion options",
             properties: {
-              model: {
-                type: "string",
-                description: "The model to use",
-              },
-
+              model: { type: "string", description: "The model to use" },
               messages: {
                 type: "array",
                 description: "The chat history for the completion",
-                items: { $ref: "#/definitions/message" },
+                items: { $ref: "#/$defs/message" },
                 minItems: 1,
               },
-
               max_tokens: {
                 type: "number",
                 description: "Maximum number of tokens to generate",
               },
-
               tools: {
                 type: "array",
-                description: "Tool definitions the model may call",
-                items: { $ref: "#/definitions/tool" },
+                description:
+                  "Tool definitions the model may call (non-recursive subset)",
+                items: { $ref: "#/$defs/toolLite" },
               },
             },
             required: ["model", "messages"],
@@ -421,54 +452,18 @@ export const includedTools = [
         },
         required: ["provider"],
       },
-
       returns: {
         type: "object",
         description: "The completion response from the AI provider",
       },
     },
-
-    definitions: {
-      message: {
-        type: "object",
-        properties: {
-          role: {
-            type: "string",
-            enum: ["system", "user", "assistant", "tool"],
-          },
-          content: { type: "string" },
-        },
-        required: ["role", "content"],
-      },
-
-      tool: {
-        type: "object",
-        properties: {
-          type: {
-            type: "string",
-            enum: ["function"],
-          },
-          function: {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              description: { type: "string" },
-              parameters: { type: "object" },
-              returns: { type: "object" },
-            },
-            required: ["name", "description", "parameters"],
-          },
-        },
-        required: ["type", "function"],
-      },
-    },
   },
-
   {
     type: "function",
     function: {
       name: "listAllCompletionModels",
-      description: "List all available completion models using the knowhow ai client",
+      description:
+        "List all available completion models using the knowhow ai client",
       parameters: {
         type: "object",
         properties: {},
@@ -476,7 +471,8 @@ export const includedTools = [
       },
       returns: {
         type: "object",
-        description: "A dictionary of all available completion models for each provider",
+        description:
+          "A dictionary of all available completion models for each provider",
       },
     },
   },
@@ -485,7 +481,8 @@ export const includedTools = [
     type: "function",
     function: {
       name: "listAllEmbeddingModels",
-      description: "List all available embedding models using the knowhow ai client",
+      description:
+        "List all available embedding models using the knowhow ai client",
       parameters: {
         type: "object",
         properties: {},
@@ -493,7 +490,8 @@ export const includedTools = [
       },
       returns: {
         type: "object",
-        description: "A dictionary of all available embedding models for each provider",
+        description:
+          "A dictionary of all available embedding models for each provider",
       },
     },
   },
@@ -645,6 +643,149 @@ export const includedTools = [
   executeScriptDefinition,
   googleSearchDefinition,
   startAgentTaskDefinition,
+  {
+    type: "function",
+    function: {
+      name: "astListPaths",
+      description:
+        "List all available simple paths in a file using tree-sitter AST parsing. Useful for understanding the structure of a file before making targeted edits.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to analyze",
+          },
+        },
+        required: ["filePath"],
+      },
+      returns: {
+        type: "string",
+        description:
+          "JSON object containing all available AST paths in the file",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "astEditNode",
+      description:
+        "Update a node at a specific AST path in a file using tree-sitter parsing. Use astListPaths first to find available paths.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to edit",
+          },
+          path: {
+            type: "string",
+            description:
+              "The AST path to the node to update (from astListPaths)",
+          },
+          newContent: {
+            type: "string",
+            description: "The new content to replace the node with",
+          },
+        },
+        required: ["filePath", "path", "newContent"],
+      },
+      returns: {
+        type: "string",
+        description: "JSON object with edit result and updated file content",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "astAppendNode",
+      description:
+        "Append a child node to a specific AST path in a file using tree-sitter parsing. Use astListPaths first to find available paths.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to edit",
+          },
+          parentPath: {
+            type: "string",
+            description: "The AST path to the parent node (from astListPaths)",
+          },
+          newContent: {
+            type: "string",
+            description: "The content of the child node to append",
+          },
+        },
+        required: ["filePath", "parentPath", "newContent"],
+      },
+      returns: {
+        type: "string",
+        description: "JSON object with append result and updated file content",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "astDeleteNode",
+      description:
+        "Delete a node at a specific AST path in a file using tree-sitter parsing. Use astListPaths first to find available paths.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to edit",
+          },
+          path: {
+            type: "string",
+            description:
+              "The AST path to the node to delete (from astListPaths)",
+          },
+        },
+        required: ["filePath", "path"],
+      },
+      returns: {
+        type: "string",
+        description: "JSON object with delete result and updated file content",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "astGetPathForLine",
+      description:
+        "Get the AST path for a specific line of text in a file using tree-sitter parsing. Useful for finding the structural location of specific code.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The path to the file to analyze",
+          },
+          searchText: {
+            type: "string",
+            description: "The text to search for in the file",
+          },
+        },
+        required: ["filePath", "searchText"],
+      },
+      returns: {
+        type: "string",
+        description:
+          "JSON object containing AST paths and locations for the matching text",
+      },
+    },
+  },
   ...asana.definitions,
   ...ycmd.definitions,
   ...github.definitions,

package/src/agents/tools/patch.ts

@@ -9,7 +9,7 @@ import {
   mkdir,
   splitByNewLines,
 } from "../../utils"; // Assuming these utils exist
-import { lintFile } from "./lintFile"; // Assuming this exists
+import { services, ToolsService } from "../../services";
 
 // --- Utility Functions (Keep or Simplify) ---
 
@@ -127,10 +127,10 @@ export function parseHunks(patch: string): Hunk[] {
   const hunks: Hunk[] = [];
   let currentHunkLines: string[] = [];
   let currentHeader = "";
-  let originalStart = 0,
-    originalCount = 0,
-    newStart = 0,
-    newCount = 0;
+  let originalStart = 0;
+  let originalCount = 0;
+  let newStart = 0;
+  let newCount = 0;
 
   for (const line of patchLines) {
     if (line.startsWith("@@")) {
@@ -540,6 +540,13 @@ export async function patchFile(
   filePath: string,
   patch: string
 ): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
   let originalContent = "";
   try {
     if (!fs.existsSync(filePath)) {
@@ -625,22 +632,49 @@ export async function patchFile(
       console.log("Successfully applied the original patch.");
     }
 
+    const eventResults: any[] = [];
+    // Emit pre-edit blocking event
+    if (context.Events) {
+      eventResults.push(
+        ...(await context.Events.emitBlocking("file:pre-edit", {
+          filePath,
+          operation: "patch",
+          patch: appliedPatch,
+          originalContent,
+          updatedContent: updatedContent as string,
+        }))
+      );
+    }
+
     // Write the updated content
     await writeFile(filePath, updatedContent as string); // Type assertion needed as applyPatch might return boolean
 
-    // Optional: Lint the result
-    let lintResult = "";
-    try {
-      lintResult = await lintFile(filePath);
-    } catch (lintError: any) {
-      console.warn("Linting failed after patching:", lintError);
-      lintResult = `Linting after patch failed: ${lintError.message}`;
+    // Emit post-edit blocking event to get event results
+    if (context.Events) {
+      eventResults.push(
+        ...(await context.Events.emitBlocking("file:post-edit", {
+          filePath,
+          operation: "patch",
+          patch: appliedPatch,
+          originalContent,
+          updatedContent: updatedContent as string,
+        }))
+      );
+    }
+
+    // Format event results
+    let eventResultsText = "";
+    if (eventResults && eventResults.length > 0) {
+      if (eventResults.length > 0) {
+        eventResultsText =
+          "\n\nAdditional Information:\n" +
+          JSON.stringify(eventResults, null, 2);
+      }
     }
 
     return `Patch applied successfully.${
       filePath ? ` Use readFile on ${filePath} to verify changes.` : ""
-    }
-${lintResult ? "\nLinting Result:\n" + lintResult : ""}`.trim();
+    }${eventResultsText}`.trim();
   } catch (e: any) {
     console.error(`Error in patchFile function for ${filePath}:`, e);
     // Save error only if it's not a controlled failure path that already saved

package/src/agents/tools/readBlocks.ts

@@ -1,4 +1,5 @@
 import * as fs from "fs";
+import { services, ToolsService } from "../../services";
 import { FileBlock } from "./types/fileblock";
 
 const BLOCK_SIZE = 500;
@@ -6,6 +7,21 @@ export async function readBlocks(
   filePath: string,
   blockNumbers: number[] = []
 ) {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  // Emit pre-read blocking event
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-read", {
+      filePath,
+      blockNumbers,
+    });
+  }
+
   const text = fs.readFileSync(filePath, "utf8");
 
   const lines = text.split("");
@@ -34,6 +50,15 @@ export async function readBlocks(
   }
 
   if (blockNumbers.length === 0) {
+    // Emit post-read non-blocking event
+    if (context.Events) {
+      await context.Events.emitNonBlocking("file:post-read", {
+        filePath,
+        blockNumbers,
+        content: blocks.map((block) => block.content).join(""),
+      });
+    }
+
     return blocks;
   }
 
@@ -45,5 +70,14 @@ export async function readBlocks(
     return blocks;
   }
 
+  // Emit post-read non-blocking event
+  if (context.Events) {
+    await context.Events.emitNonBlocking("file:post-read", {
+      filePath,
+      blockNumbers,
+      content: filtered.map((block) => block.content).join(""),
+    });
+  }
+
   return filtered;
 }

package/src/agents/tools/readFile.ts

@@ -1,5 +1,6 @@
 import * as fs from "fs";
 import { fileExists } from "../../utils";
+import { services, ToolsService } from "../../services";
 import { getConfiguredEmbeddings } from "../../embeddings";
 import { fileSearch } from "./fileSearch";
 import { createPatch } from "diff";
@@ -18,6 +19,20 @@ import { createPatch } from "diff";
  */
 
 export async function readFile(filePath: string): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  // Emit pre-read blocking event
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-read", {
+      filePath,
+    });
+  }
+
   const exists = await fileExists(filePath);
 
   if (!exists) {
@@ -35,5 +50,13 @@ export async function readFile(filePath: string): Promise<string> {
   const text = fs.readFileSync(filePath, "utf8");
   const patch = createPatch(filePath, "", text);
 
+  // Emit post-read non-blocking event
+  if (context.Events) {
+    await context.Events.emitNonBlocking("file:post-read", {
+      filePath,
+      content: text,
+    });
+  }
+
   return patch;
 }

package/src/agents/tools/stringReplace.ts

@@ -1,4 +1,6 @@
 import * as fs from "fs";
+import { embed } from "../../";
+import { lintFile } from ".";
 import { fileExists } from "../../utils";
 
 export async function stringReplace(
@@ -6,8 +8,15 @@ export async function stringReplace(
   replaceString: string,
   filePaths: string[]
 ): Promise<string> {
-  if (!findString || replaceString === undefined || !filePaths || filePaths.length === 0) {
-    throw new Error("findString, replaceString, and filePaths are all required parameters");
+  if (
+    !findString ||
+    replaceString === undefined ||
+    !filePaths ||
+    filePaths.length === 0
+  ) {
+    throw new Error(
+      "findString, replaceString, and filePaths are all required parameters"
+    );
   }
 
   const results: string[] = [];
@@ -23,24 +32,39 @@ export async function stringReplace(
 
       const content = fs.readFileSync(filePath, "utf8");
       const originalContent = content;
-      
+
       // Count occurrences before replacement
       const matches = content.split(findString).length - 1;
-      
+
       if (matches === 0) {
         results.push(`ℹ️  No matches found in: ${filePath}`);
         continue;
       }
 
       // Perform the replacement
-      const newContent = content.replace(new RegExp(findString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), replaceString);
-      
+      const newContent = content.replace(
+        new RegExp(findString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+        replaceString
+      );
+
       // Write the modified content back to the file
       fs.writeFileSync(filePath, newContent);
-      
+
       totalReplacements += matches;
       results.push(`✅ Replaced ${matches} occurrence(s) in: ${filePath}`);
-      
+
+      let lintResult = "";
+      try {
+        lintResult = await lintFile(filePath);
+        if (lintResult) {
+          results.push(`$Linting Result:\n" + ${lintResult}`);
+        }
+      } catch (lintError: any) {
+        console.warn("Linting failed after patching:", lintError);
+        lintResult = `Linting after patch failed: ${lintError.message}`;
+      }
+
+      await embed();
     } catch (error) {
       results.push(`❌ Error processing ${filePath}: ${error.message}`);
     }
@@ -48,4 +72,4 @@ export async function stringReplace(
 
   const summary = `\n📊 Summary: ${totalReplacements} total replacements made across ${filePaths.length} file(s)`;
   return results.join("\n") + summary;
-}
+}