@tyvm/knowhow 0.0.56 → 0.0.59

package/src/cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --no-node-snapshot
 import "source-map-support/register";
 import * as fs from "fs";
 import * as path from "path";
@@ -11,7 +11,7 @@ import { init } from "./config";
 import { download, purge } from ".";
 import { includedTools } from "./agents/tools/list";
 import * as allTools from "./agents/tools";
-import { services } from "./services";
+import { LazyToolsService, services } from "./services";
 import { login } from "./login";
 import { worker } from "./worker";
 import {
@@ -35,8 +35,14 @@ import { SetupModule } from "./chat/modules/SetupModule";
 import { CliChatService } from "./chat/CliChatService";
 
 async function setupServices() {
-  const { Tools, Agents, Mcp, Clients } = services();
-  const { Researcher, Developer, Patcher, Setup } = agents();
+  const { Agents, Mcp, Clients } = services();
+  const Tools = new LazyToolsService();
+
+  const { Researcher, Developer, Patcher, Setup } = agents({
+    ...services(),
+    Tools,
+  });
+
   Agents.registerAgent(Researcher);
   Agents.registerAgent(Patcher);
   Agents.registerAgent(Developer);
@@ -45,6 +51,9 @@ async function setupServices() {
 
   Tools.defineTools(includedTools, allTools);
 
+  // Add Mcp service to tool context directly so MCP management tools can access it
+  Tools.addContext("Mcp", Mcp);
+
   await Promise.all([
     Mcp.connectToConfigured(Tools),
     Clients.registerConfiguredModels(),
@@ -81,9 +90,6 @@ async function main() {
     .description("AI CLI with plugins and agents")
     .version(version);
 
-  // Initialize services for all commands
-  await setupServices();
-
   program
     .command("init")
     .description("Initialize knowhow configuration")
@@ -103,6 +109,7 @@ async function main() {
     .command("generate")
     .description("Generate documentation")
     .action(async () => {
+      await setupServices();
       await generate();
     });
 
@@ -110,6 +117,7 @@ async function main() {
     .command("embed")
     .description("Create embeddings")
     .action(async () => {
+      await setupServices();
       await embed();
     });
 
@@ -139,6 +147,7 @@ async function main() {
     .command("chat")
     .description("Start new chat interface")
     .action(async () => {
+      await setupServices();
       await startChat();
     });
 
@@ -166,6 +175,7 @@ async function main() {
     .option("--input <text>", "Task input (fallback to stdin if not provided)")
     .action(async (options) => {
       try {
+        await setupServices();
         let input = options.input;
         if (!input) {
           input = await readStdin();
@@ -204,6 +214,7 @@ async function main() {
     .option("--prompt-file <path>", "Custom prompt template file")
     .action(async (options) => {
       try {
+        await setupServices();
         let input = options.input;
         if (!input) {
           input = await readStdin();
@@ -235,6 +246,7 @@ async function main() {
     .description("Ask the agent to configure knowhow")
     .action(async (options) => {
       try {
+        await setupServices();
         const setupModule = new SetupModule();
         await setupModule.initialize(chatService);
         await setupModule.handleSetupCommand([]);
@@ -258,6 +270,7 @@ async function main() {
     )
     .action(async (options) => {
       try {
+        await setupServices();
         let input = options.input;
         if (!input) {
           input = await readStdin();
@@ -292,13 +305,22 @@ async function main() {
 
   program
     .command("worker")
-    .description("Start worker process and optionally register current directory")
+    .description(
+      "Start worker process and optionally register current directory"
+    )
     .option("--register", "Register current directory as a worker path")
-    .option("--share", "Share this worker with your organization (allows other users to use it)")
+    .option(
+      "--share",
+      "Share this worker with your organization (allows other users to use it)"
+    )
     .option("--unshare", "Make this worker private (only you can use it)")
     .option("--sandbox", "Run worker in a Docker container for isolation")
-    .option("--no-sandbox", "Run worker directly on host (disable sandbox mode)")
+    .option(
+      "--no-sandbox",
+      "Run worker directly on host (disable sandbox mode)"
+    )
     .action(async (options) => {
+      await setupServices();
       await worker(options);
     });
 
@@ -337,6 +359,7 @@ async function main() {
         }
 
         // Default action: start all workers
+        await setupServices();
         await startAllWorkers();
       } catch (error) {
         console.error("Error managing workers:", error);

package/src/plugins/GitPlugin.ts

@@ -19,6 +19,7 @@ export class GitPlugin extends PluginBase {
   private projectHasGit: boolean = false;
   private eventService: EventService;
   private currentTask: string | null = null;
+  static isListening = false;
 
   constructor(context: PluginContext = {}) {
     super(context);
@@ -96,9 +97,7 @@ Your modifications are automatically tracked separately and won't affect the use
         // since HEAD doesn't exist yet
         try {
           this.gitCommand("add -A");
-          this.gitCommand(
-            'commit -m "Initial commit for agent tracking"'
-          );
+          this.gitCommand('commit -m "Initial commit for agent tracking"');
         } catch (error) {
           // If there's nothing to commit, create an empty commit
           this.gitCommand(
@@ -150,26 +149,30 @@ Your modifications are automatically tracked separately and won't affect the use
 
   private setupEventListeners(): void {
     // Listen for file:post-edit events to auto-commit
-    this.eventService.on("file:post-edit", async (data: any) => {
-      if (this.isEnabled()) {
-        await this.autoCommit(data);
-      }
-    });
+    if (!GitPlugin.isListening) {
+      this.eventService.on("file:post-edit", async (data: any) => {
+        if (this.isEnabled()) {
+          await this.autoCommit(data);
+        }
+      });
 
-    // Listen for agent newTask events to create new branches
-    this.eventService.on("agent:newTask", async (data: any) => {
-      if (this.isEnabled()) {
-        await this.ensureCleanState(data);
-        await this.handleNewTask(data);
-      }
-    });
+      // Listen for agent newTask events to create new branches
+      this.eventService.on("agent:newTask", async (data: any) => {
+        if (this.isEnabled()) {
+          await this.ensureCleanState(data);
+          await this.handleNewTask(data);
+        }
+      });
 
-    // Listen for task completion events to squash merge
-    this.eventService.on("agent:taskComplete", async (data: any) => {
-      if (this.isEnabled()) {
-        await this.handleTaskComplete(data);
-      }
-    });
+      // Listen for task completion events to squash merge
+      this.eventService.on("agent:taskComplete", async (data: any) => {
+        if (this.isEnabled()) {
+          await this.handleTaskComplete(data);
+        }
+      });
+
+      GitPlugin.isListening = true;
+    }
   }
 
   /**
@@ -306,8 +309,8 @@ Your modifications are automatically tracked separately and won't affect the use
     this.ensureValidHead();
 
     // Commit the changes
-    const escapedMessage = message.replace(/\n/g, '\\n');
-    this.gitCommand(`commit -m "${escapedMessage}"`);
+    const escapedMessage = message.replace(/\n/g, "\\n");
+    this.gitCommand(`commit --allow-empty -m "${escapedMessage}"`);
   }
 
   async commitAll(message: string): Promise<void> {
@@ -356,11 +359,14 @@ Your modifications are automatically tracked separately and won't affect the use
 
       this.eventService.emit(
         "agent:msg",
-        `GitPlugin::Commit: ${enhancedMessage} on branch: ${this.getCurrentBranch()}
+        `
+        <Workflow>
+        GitPlugin::Commit: ${enhancedMessage} on branch: ${this.getCurrentBranch()}
         You can access your change history via git --git-dir ${
           this.knowhowGitPath
         } log or other commands
         This can be used to revert changes, or compare against previous states during a task.
+        </Workflow>
         `
       );
     } catch (error) {

package/src/plugins/language.ts

@@ -46,11 +46,25 @@ export class LanguagePlugin extends PluginBase implements Plugin {
       });
 
       // Register handlers for each event
-      allEvents.forEach((eventType) => {
+      const fileEvents = Array.from(allEvents).filter((e: string) =>
+        e.startsWith("file")
+      );
+
+      const otherEvents = Array.from(allEvents).filter(
+        (e: string) => !e.startsWith("file")
+      );
+
+      fileEvents.forEach((eventType) => {
         this.eventService.on(eventType, async (eventData) => {
           await this.handleFileEvent(eventType, eventData);
         });
       });
+
+      otherEvents.forEach((eventType) => {
+        this.eventService.on(eventType, async (eventData) => {
+          await this.handleGenericEvent(eventType, eventData);
+        });
+      });
     } catch (error) {
       console.error("LANGUAGE PLUGIN: Error setting up event handlers:", error);
     }
@@ -143,7 +157,10 @@ export class LanguagePlugin extends PluginBase implements Plugin {
           const matches = patterns.some(
             (pattern) =>
               minimatch(filePath, pattern) ||
-              fileContent.toString().toLowerCase().includes(pattern.toLowerCase())
+              fileContent
+                .toString()
+                .toLowerCase()
+                .includes(pattern.toLowerCase())
           );
           return matches;
         })
@@ -153,21 +170,12 @@ export class LanguagePlugin extends PluginBase implements Plugin {
         // Resolve sources for matching terms
         const resolvedSources = await this.resolveSources(matchingFileTerms);
 
-        // Emit agent message event with resolved context
-        this.eventService.emit(
-          "agent:msg",
-          JSON.stringify({
-            type: "language_context_trigger",
-            filePath,
-            matchingTerms: matchingFileTerms,
-            eventType,
-            resolvedSources,
-            contextMessage: `LANGUAGE PLUGIN: File event ${eventType} on ${filePath} triggered contextual expansions for terms: ${matchingFileTerms.join(
-              ", "
-            )}.
-            Expanded context: ${JSON.stringify(resolvedSources)}
-            These terms are directly related to the file operation so be sure to contextualize your response to this information.`,
-          })
+        const message = `These terms are directly related to the file operation so be sure to contextualize your response to this information.`;
+        this.emitAgentMessage(
+          eventType,
+          matchingFileTerms,
+          resolvedSources,
+          message
         );
       }
     } catch (error) {
@@ -175,11 +183,72 @@ export class LanguagePlugin extends PluginBase implements Plugin {
     }
   }
 
+  private emitAgentMessage(
+    eventType: string,
+    matchingTerms: string[],
+    resolvedSources: any[],
+    context: string
+  ) {
+    this.eventService.emit(
+      "agent:msg",
+
+      `<Workflow>
+      ${JSON.stringify({
+        type: "language_context_trigger",
+        eventType,
+        matchingTerms,
+        resolvedSources,
+        contextMessage: `LANGUAGE PLUGIN: Agent event ${eventType} triggered contextual expansions for terms: ${matchingTerms.join(
+          ", "
+        )}.
+            Expanded context: ${JSON.stringify(resolvedSources)}
+            These terms are directly related to what the agent is discussing so be sure to contextualize your response to this information.
+            ${context}
+        `,
+      })}
+      </Workflow>
+      `
+    );
+  }
+
+  /**
+   * Handle agent message and say events and emit agent messages when patterns match
+   */
+  private async handleGenericEvent(eventType: string, eventData: any) {
+    try {
+      const languageConfig = await getLanguageConfig();
+      const userPrompt = JSON.stringify(eventData);
+      const isJsonObj = userPrompt.startsWith("{") && userPrompt.endsWith("}");
+
+      // Skip if this is probably a language_context_trigger to avoid loops
+      if (userPrompt.includes("language_context_trigger")) {
+        return;
+      }
+
+      const matchingTerms = await this.getMatchingTerms(userPrompt);
+
+      if (matchingTerms.length > 0) {
+        // Resolve sources for matching terms
+        const resolvedSources = await this.resolveSources(matchingTerms);
+
+        const message = `These terms are directly related to the agent's message so be sure to contextualize your response to this information.`;
+        this.emitAgentMessage(
+          eventType,
+          matchingTerms,
+          resolvedSources,
+          message
+        );
+      }
+    } catch (error) {
+      console.error("LANGUAGE PLUGIN: Error handling agent event:", error);
+    }
+  }
+
   async embed(userPrompt: string) {
     return [];
   }
 
-  async call(userPrompt: string) {
+  async getMatchingTerms(userPrompt: string) {
     // Get language configuration
     const languageConfig = await getLanguageConfig();
     const terms = Object.keys(languageConfig);
@@ -194,6 +263,12 @@ export class LanguagePlugin extends PluginBase implements Plugin {
           : userPrompt.toLowerCase().includes(trimmedPattern.toLowerCase());
       })
     );
+    return matchingTerms;
+  }
+
+  async call(userPrompt: string) {
+    // Get language configuration
+    const matchingTerms = await this.getMatchingTerms(userPrompt);
 
     if (matchingTerms.length === 0) {
       return "LANGUAGE PLUGIN: No matching terms found";
@@ -206,6 +281,8 @@ export class LanguagePlugin extends PluginBase implements Plugin {
       return "LANGUAGE PLUGIN: No matching terms found";
     }
 
+    console.log("LANGUAGE PLUGIN: Matching terms found:", matchingTerms);
+
     // Return the file contents in a format that can be added to the prompt context
     return `LANGUAGE PLUGIN: The user mentioned these terms triggering contextual expansions ${matchingTerms} expanded to: ${JSON.stringify(
       contexts

package/src/processors/ToolResponseCache.ts

@@ -1,8 +1,18 @@
 import { Message } from "../clients/types";
 import { MessageProcessorFunction } from "../services/MessageProcessor";
 import { ToolsService } from "../services";
-import { Tool } from "../clients";
-import * as jq from "node-jq";
+import {
+  jqToolResponseDefinition,
+  executeJqQuery,
+  grepToolResponseDefinition,
+  executeGrep,
+  GrepOptions,
+  tailToolResponseDefinition,
+  executeTail,
+  TailOptions,
+  listStoredToolResponsesDefinition,
+  executeListStoredToolResponses,
+} from "./tools";
 
 interface ToolResponseStorage {
   [toolCallId: string]: string;
@@ -21,7 +31,7 @@ interface ToolResponseMetadataStorage {
 export class ToolResponseCache {
   private storage: ToolResponseStorage = {};
   private metadataStorage: ToolResponseMetadataStorage = {};
-  private toolName: string = jqToolResponseDefinition.function.name;
+  private toolNameMap: { [toolCallId: string]: string } = {};
 
   constructor(toolsService: ToolsService) {
     this.registerTool(toolsService);
@@ -68,8 +78,19 @@ export class ToolResponseCache {
   /**
    * Stores a tool response for later manipulation
    */
-  public storeToolResponse(content: string, toolCallId: string): void {
-    // Always store the original content for later JQ manipulation
+  public storeToolResponse(
+    content: string,
+    toolCallId: string,
+    toolName?: string
+  ): void {
+    // Only store if not already stored - prevents overwriting with compressed data
+    // The first time we see a tool response, it contains the original uncompressed content
+    // On subsequent passes (after compression), we don't want to overwrite with compressed data
+    if (this.storage[toolCallId]) {
+      return;
+    }
+
+    // Store the original content for later JQ/grep manipulation
     this.storage[toolCallId] = content;
 
     // Store metadata for reference
@@ -78,6 +99,10 @@ export class ToolResponseCache {
       originalLength: content.length,
       storedAt: Date.now(),
     };
+
+    if (toolName) {
+      this.toolNameMap[toolCallId] = toolName;
+    }
   }
 
   /**
@@ -94,7 +119,7 @@ export class ToolResponseCache {
     }
 
     // Store the tool response silently without modifying the message
-    this.storeToolResponse(message.content, message.tool_call_id);
+    this.storeToolResponse(message.content, message.tool_call_id, message.name);
   }
 
   /**
@@ -104,7 +129,7 @@ export class ToolResponseCache {
     filterFn?: (msg: Message) => boolean
   ): MessageProcessorFunction {
     return async (originalMessages: Message[], modifiedMessages: Message[]) => {
-      for (const message of modifiedMessages) {
+      for (const message of originalMessages) {
         if (filterFn && !filterFn(message)) {
           continue;
         }
@@ -121,56 +146,44 @@ export class ToolResponseCache {
     jqQuery: string
   ): Promise<string> {
     const data = this.storage[toolCallId];
+    const availableIds = Object.keys(this.storage);
+    return executeJqQuery(data, toolCallId, jqQuery, availableIds);
+  }
 
-    if (!data) {
-      const availableIds = Object.keys(this.storage);
-      return `Error: No tool response found for toolCallId "${toolCallId}". Available IDs: ${availableIds.join(
-        ", "
-      )}`;
-    }
+  /**
+   * Grep through tool response data to find matching lines
+   */
+  async grepToolResponse(
+    toolCallId: string,
+    pattern: string,
+    options?: GrepOptions
+  ): Promise<string> {
+    const data = this.storage[toolCallId];
+    const availableIds = Object.keys(this.storage);
+    return executeGrep(data, toolCallId, pattern, availableIds, options);
+  }
 
-    try {
-      // First parse the stored string as JSON, then handle nested JSON strings
-      const jsonData = this.tryParseJson(data);
-      if (!jsonData) {
-        return `Error: Tool response data is not valid JSON for toolCallId "${toolCallId}"`;
-      }
-      const parsedData = this.parseNestedJsonStrings(jsonData);
-
-      // Execute JQ query
-      const result = await jq.run(jqQuery, parsedData, { input: "json" });
-
-      // Handle the result based on its type
-      if (typeof result === "string") {
-        return result;
-      } else if (typeof result === "number" || typeof result === "boolean") {
-        return String(result);
-      } else if (result === null) {
-        return "null";
-      } else {
-        return JSON.stringify(result);
-      }
-    } catch (error: any) {
-      // If JQ fails, try to provide helpful error message
-      let errorMessage = `JQ Query Error: ${error.message}`;
-
-      // Try to parse as JSON to see if it's valid
-      const jsonObj = this.tryParseJson(data);
-      if (!jsonObj) {
-        errorMessage += `\nNote: The tool response data is not valid JSON. Raw data preview:\n${data.substring(
-          0,
-          300
-        )}...`;
-      } else {
-        errorMessage += `\nData structure preview:\n${JSON.stringify(
-          jsonObj,
-          null,
-          2
-        ).substring(0, 500)}...`;
-      }
+  /**
+   * Get the last n lines from a tool response
+   */
+  async tailToolResponse(
+    toolCallId: string,
+    options?: TailOptions
+  ): Promise<string> {
+    const data = this.storage[toolCallId];
+    const availableIds = Object.keys(this.storage);
+    return executeTail(data, toolCallId, availableIds, options);
+  }
 
-      return errorMessage;
-    }
+  /**
+   * List all stored tool responses with metadata
+   */
+  async listStoredToolResponses(): Promise<string> {
+    return executeListStoredToolResponses(
+      this.storage,
+      this.metadataStorage,
+      this.toolNameMap
+    );
   }
 
   /**
@@ -206,36 +219,42 @@ export class ToolResponseCache {
    * Registers the jqToolResponse tool with the ToolsService
    */
   registerTool(toolsService: ToolsService): void {
-    toolsService.addTools([jqToolResponseDefinition]);
+    toolsService.addTools([
+      jqToolResponseDefinition,
+      grepToolResponseDefinition,
+      tailToolResponseDefinition,
+      listStoredToolResponsesDefinition,
+    ]);
     toolsService.addFunctions({
-      [this.toolName]: async (toolCallId: string, jqQuery: string) => {
+      [jqToolResponseDefinition.function.name]: async (
+        toolCallId: string,
+        jqQuery: string
+      ) => {
         return await this.queryToolResponse(toolCallId, jqQuery);
       },
+      [grepToolResponseDefinition.function.name]: async (
+        toolCallId: string,
+        pattern: string,
+        options?: any
+      ) => {
+        return await this.grepToolResponse(toolCallId, pattern, options);
+      },
+      [tailToolResponseDefinition.function.name]: async (
+        toolCallId: string,
+        options?: any
+      ) => {
+        return await this.tailToolResponse(toolCallId, options);
+      },
+      [listStoredToolResponsesDefinition.function.name]: async () => {
+        return await this.listStoredToolResponses();
+      },
     });
   }
 }
 
-export const jqToolResponseDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "jqToolResponse",
-    description:
-      "Execute a JQ query on a stored tool response to extract specific data. Use this when you need to extract specific information from any tool response that has been stored. Many MCP tool responses store data in nested structures like .content[0].text where the actual data array is located.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        toolCallId: {
-          type: "string",
-          description: "The toolCallId of the stored tool response",
-        },
-        jqQuery: {
-          type: "string",
-          description:
-            "The JQ query to execute on the tool response data. Examples: '.content[0].text | map(.title)' (extract titles from MCP array), '.content[0].text | map(select(.createdAt > \"2025-01-01\"))' (filter MCP items by date) ",
-        },
-      },
-      required: ["toolCallId", "jqQuery"],
-    },
-  },
+export {
+  jqToolResponseDefinition,
+  grepToolResponseDefinition,
+  tailToolResponseDefinition,
+  listStoredToolResponsesDefinition,
 };