@tyvm/knowhow 0.0.47 → 0.0.49

package/src/agents/tools/writeFile.ts

@@ -1,4 +1,5 @@
 import * as fs from "fs";
+import { services, ToolsService } from "../../services";
 
 // Tool to write the full contents of a file
 export function writeFile(filePath: string, content: string): string {
@@ -16,12 +17,39 @@ export async function writeFileChunk(
   isContinuing: boolean,
   isDone: boolean
 ) {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+  const context = toolService.getContext();
+
   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."
     );
   }
 
+  // Read original content for event emission
+  let originalContent = "";
+  try {
+    if (fs.existsSync(filePath)) {
+      originalContent = fs.readFileSync(filePath, "utf8");
+    }
+  } catch (error) {
+    // If we can't read the original file, continue with empty string
+    originalContent = "";
+  }
+
+  // Emit pre-edit blocking event
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-edit", {
+      filePath,
+      operation: isContinuing ? "append" : "write",
+      content,
+      originalContent,
+    });
+  }
+
   if (!isContinuing) {
     fs.writeFileSync(filePath, content);
   }
@@ -42,6 +70,33 @@ export async function writeFileChunk(
 
   if (isDone) {
     message = " File write complete. Use readFile to verify";
+
+    // Emit post-edit blocking event to get event results
+    let eventResults: any[] = [];
+    if (context.Events) {
+      // Read updated content for event emission
+      const updatedContent = fs.readFileSync(filePath, "utf8");
+
+      eventResults = await context.Events.emitBlocking("file:post-edit", {
+        filePath,
+        operation: "write",
+        content,
+        originalContent,
+        updatedContent,
+      });
+    }
+
+    // Format event results
+    let eventResultsText = "";
+    if (eventResults && eventResults.length > 0) {
+      if (eventResults.length > 0) {
+        eventResultsText =
+          "\n\nAdditional Information:\n" +
+          JSON.stringify(eventResults, null, 2);
+      }
+    }
+
+    message += eventResultsText;
   }
 
   return message;

package/src/agents/tools/ycmd/server.ts

@@ -364,11 +364,13 @@ export class YcmdServer {
    */
   private async waitForServerStart(): Promise<YcmdServerInfo> {
     return new Promise((resolve, reject) => {
+      let timedOut = false;
       const timeout = setTimeout(() => {
         console.log(
           "ycmd server startup timeout - server failed to start within 30 seconds"
         );
         reject(new Error("ycmd server failed to start within timeout"));
+        timedOut = true;
       }, 30000);
 
       const host = "127.0.0.1";
@@ -378,6 +380,10 @@ export class YcmdServer {
       // Check for server readiness
       const checkReady = async () => {
         try {
+          if (timedOut) {
+            return;
+          }
+
           const port = getPort();
           console.log(`Checking ycmd server health on port ${port}`);
 
@@ -450,18 +456,22 @@ export class YcmdServer {
   private setupExitHandler(): void {
     // Handle normal process exit
     process.on("exit", () => this.forceCleanup());
-    
+
     // Handle Ctrl+C (SIGINT)
     process.on("SIGINT", () => {
-      console.log("\nReceived SIGINT (Ctrl+C), shutting down ycmd server gracefully...");
+      console.log(
+        "\nReceived SIGINT (Ctrl+C), shutting down ycmd server gracefully..."
+      );
       this.gracefulShutdown().finally(() => {
         process.exit(0);
       });
     });
-    
+
     // Handle SIGTERM (termination signal)
     process.on("SIGTERM", () => {
-      console.log("\nReceived SIGTERM, shutting down ycmd server gracefully...");
+      console.log(
+        "\nReceived SIGTERM, shutting down ycmd server gracefully..."
+      );
       this.gracefulShutdown().finally(() => {
         process.exit(0);
       });

package/src/chat/CliChatService.ts

@@ -17,7 +17,7 @@ import { recordAudio, voiceToText } from "../microphone";
 import editor from "@inquirer/editor";
 import fs from "fs";
 import path from "path";
-import { Plugins } from "../plugins/plugins";
+import { services } from "../services";
 
 export class CliChatService implements ChatService {
   private context: ChatContext;
@@ -44,6 +44,10 @@ export class CliChatService implements ChatService {
     this.loadInputHistory();
   }
 
+  getModuleByName(name: string) {
+    return this.modules.find((module) => module.name === "agent");
+  }
+
   /**
    * Load input history from disk for scrollback functionality
    */
@@ -239,6 +243,7 @@ export class CliChatService implements ChatService {
     plugins: string[] = [],
     chatHistory: ChatInteraction[] = []
   ) {
+    const { Plugins } = services();
     const pluginText = await Plugins.callMany(plugins, input);
     const historyMessage = `<PreviousChats>
   This information is provided as historical context and is likely not related to the current task:

package/src/chat/modules/AgentModule.ts

@@ -20,6 +20,7 @@ import {
 } from "../../processors/index";
 import { TaskInfo, ChatSession } from "../types";
 import { agents } from "../../agents";
+import { ToolCallEvent } from "src/agents/base/base";
 
 export class AgentModule extends BaseChatModule {
   name = "agent";
@@ -535,9 +536,9 @@ ${reason}
         messageId: session.knowhowMessageId,
         existingKnowhowTaskId: session.knowhowTaskId,
         chatHistory: [],
-        run: true,
+        run: false, // Don't run yet, we need to set up event listeners first
       });
-      await this.attachedAgentChatLoop(taskId, agent);
+      await this.attachedAgentChatLoop(taskId, agent, resumePrompt);
     } catch (error) {
       console.error(
         `Failed to resume session ${sessionId}:`,
@@ -549,11 +550,26 @@ ${reason}
   async handleInput(input: string, context: ChatContext): Promise<boolean> {
     // If in agent mode, start agent with the input as initial task (like original chat.ts)
     if (context.agentMode && context.selectedAgent) {
-      const result = await this.startAgent(
+      // Create initial interaction for the chatHistory
+      const initialInteraction: ChatInteraction = {
+        input,
+        output: "", // Will be filled after agent completion
+        summaries: [],
+        lastThread: [],
+      };
+
+      const { result, finalOutput } = await this.startAgent(
         context.selectedAgent,
         input,
         context.chatHistory || []
       );
+
+      // Update the chatHistory with the completed interaction
+      if (result && finalOutput) {
+        initialInteraction.output = finalOutput;
+        context.chatHistory.push(initialInteraction);
+      }
+
       return result;
     }
     return false;
@@ -593,6 +609,17 @@ ${reason}
     let knowhowTaskId: string | undefined;
 
     try {
+      // Get context for plugins
+      const context = this.chatService?.getContext();
+      const plugins = context?.plugins || [];
+
+      // Format the prompt with plugins and chat history
+      const formattedPrompt = await this.chatService.formatChatInput(
+        input,
+        plugins,
+        chatHistory
+      );
+
       // Create task info object
       let taskInfo: TaskInfo = {
         taskId,
@@ -601,6 +628,7 @@ ${reason}
         agentName,
         agent,
         initialInput: input,
+        formattedPrompt,
         status: "running",
         startTime: Date.now(),
         totalCost: 0,
@@ -637,25 +665,28 @@ ${reason}
       }
 
       // Set up session update listener
-      agent.agentEvents.on("threadUpdate", async (threadState) => {
-        // Update task cost from agent's current total cost
-        taskInfo.totalCost = agent.getTotalCostUsd();
-        this.updateSession(taskId, threadState);
-
-        // Update Knowhow chat task if created
-        if (knowhowTaskId && options.messageId && baseUrl) {
-          await client
-            .updateChatTask(knowhowTaskId, {
-              threads: agent.getThreads(),
-              totalCostUsd: agent.getTotalCostUsd(),
-              inProgress: true,
-            })
-            .catch((error) => {
-              console.error(`❌ Failed to update Knowhow chat task:`, error);
-            });
-          console.log(`✅ Updated Knowhow chat task: ${knowhowTaskId}`);
+      agent.agentEvents.on(
+        agent.eventTypes.threadUpdate,
+        async (threadState) => {
+          // Update task cost from agent's current total cost
+          taskInfo.totalCost = agent.getTotalCostUsd();
+          this.updateSession(taskId, threadState);
+
+          // Update Knowhow chat task if created
+          if (knowhowTaskId && options.messageId && baseUrl) {
+            await client
+              .updateChatTask(knowhowTaskId, {
+                threads: agent.getThreads(),
+                totalCostUsd: agent.getTotalCostUsd(),
+                inProgress: true,
+              })
+              .catch((error) => {
+                console.error(`❌ Failed to update Knowhow chat task:`, error);
+              });
+            console.log(`✅ Updated Knowhow chat task: ${knowhowTaskId}`);
+          }
         }
-      });
+      );
 
       console.log(
         Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`)
@@ -663,7 +694,7 @@ ${reason}
       console.log(Marked.parse(`**Task:** ${input}`));
 
       // Initialize new task
-      await agent.newTask();
+      await agent.newTask(taskId);
 
       if (options.model) {
         console.log("Setting model:", options.model);
@@ -673,17 +704,6 @@ ${reason}
         ]);
       }
 
-      // Get context for plugins
-      const context = this.chatService?.getContext();
-      const plugins = context?.plugins || [];
-
-      // Format the prompt with plugins and chat history
-      const formattedPrompt = await this.chatService.formatChatInput(
-        input,
-        plugins,
-        chatHistory
-      );
-
       // Set up message processors like in original startAgent
 
       agent.messageProcessor.setProcessors("pre_call", [
@@ -700,15 +720,33 @@ ${reason}
       ]);
 
       // Set up event listeners
+      if (!agent.agentEvents.listenerCount(agent.eventTypes.toolCall)) {
+        agent.agentEvents.on(
+          agent.eventTypes.toolCall,
+          (responseMsg: ToolCallEvent) => {
+            console.time(JSON.stringify(responseMsg.toolCall.function.name));
+            console.log(
+              ` 🔨 Tool: ${responseMsg.toolCall.function.name}\n Args: ${responseMsg.toolCall.function.arguments}\n`
+            );
+          }
+        );
+      }
       if (!agent.agentEvents.listenerCount(agent.eventTypes.toolUsed)) {
-        agent.agentEvents.on(agent.eventTypes.toolUsed, (responseMsg) => {
-          console.log(` 🔨 Tool used: ${JSON.stringify(responseMsg, null, 2)}`);
-        });
+        agent.agentEvents.on(
+          agent.eventTypes.toolUsed,
+          (responseMsg: ToolCallEvent) => {
+            console.timeEnd(JSON.stringify(responseMsg.toolCall.function.name));
+            console.log(
+              ` 🔨 Tool Response:
+              ${JSON.stringify(responseMsg.functionResp, null, 2)}`
+            );
+          }
+        );
       }
 
       const taskCompleted = new Promise<string>((resolve) => {
         agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
-          console.log("Agent has finished.");
+          console.log("Agent has completed the task.");
           done = true;
           output = doneMsg || "No response from the AI";
           // Update task info
@@ -767,7 +805,13 @@ ${reason}
         agent.call(formattedPrompt);
       }
 
-      return { agent, taskId, formattedPrompt, taskCompleted };
+      return {
+        agent,
+        taskId,
+        formattedPrompt,
+        initialInput: input,
+        taskCompleted,
+      };
     } catch (error) {
       console.error("Agent setup failed:", error);
       this.taskRegistry.delete(taskId);
@@ -809,11 +853,11 @@ ${reason}
       .replace(/[^\w\s]/g, "")
       .split(/\s+/)
       .filter((word) => word.length > 2)
-      .slice(0, 3);
+      .slice(0, 9);
 
     const wordPart = words.join("-") || "task";
-    const timestamp = Date.now().toString().slice(-6);
-    return `${wordPart}-${timestamp}`;
+    const epochSeconds = Math.floor(Date.now() / 1000);
+    return `${epochSeconds}-${wordPart}`;
   }
 
   /**
@@ -887,47 +931,67 @@ ${reason}
     selectedAgent: BaseAgent,
     initialInput: string,
     chatHistory: ChatInteraction[] = []
-  ): Promise<boolean> {
+  ): Promise<{ result: boolean; finalOutput?: string }> {
     try {
-      const { agent, taskId } = await this.setupAgent({
+      const { agent, taskId, formattedPrompt } = await this.setupAgent({
         agentName: selectedAgent.name,
         input: initialInput,
         chatHistory,
-        run: true,
+        run: false, // Don't run yet, we need to set up event listeners first
       });
-      return await this.attachedAgentChatLoop(taskId, agent);
+      const result = await this.attachedAgentChatLoop(
+        taskId,
+        agent,
+        formattedPrompt
+      );
+      return result;
     } catch (error) {
       console.error("Error starting agent:", error);
-      return false;
+      return { result: false, finalOutput: "Error starting agent" };
     }
   }
 
-  async attachedAgentChatLoop(taskId: string, agent: BaseAgent) {
+  async attachedAgentChatLoop(
+    taskId: string,
+    agent: BaseAgent,
+    initialInput?: string
+  ): Promise<{ result: boolean; finalOutput?: string }> {
     try {
       let done = false;
       let output = "Done";
+      let agentFinalOutput: string | undefined;
 
       // Define available commands
-      const commands = ["pause", "unpause", "kill", "detach"];
+      const commands = ["/pause", "/unpause", "/kill", "/detach", "/done"];
       const history: string[] = [];
 
-      let input =
-        (await this.chatService?.getInput(
-          `Enter command or message for ${agent.name}: `,
-          commands
-        )) || "";
-
-      history.push(input);
-
+      // Set up the event listener BEFORE starting the agent to avoid race condition
       let finished = false;
       const donePromise = new Promise<string>((resolve) => {
         agent.agentEvents.once(agent.eventTypes.done, (doneMsg) => {
-          console.log("Agent has completed the task.");
+          // Capture the agent's final output
+          agentFinalOutput = doneMsg || "No response from the AI";
           finished = true;
           resolve("done");
         });
       });
 
+      // Now start the agent if we have an initial input (this means we're starting, not just attaching)
+      if (initialInput) {
+        const taskInfo = this.taskRegistry.get(taskId);
+        agent.call(
+          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput
+        );
+      }
+
+      let input =
+        (await this.chatService?.getInput(
+          `Enter command or message for ${agent.name}: `,
+          commands
+        )) || "";
+
+      history.push(input);
+
       while (!done) {
         switch (input) {
           case "":
@@ -936,26 +1000,26 @@ ${reason}
               done = true;
             }
             break;
-          case "done":
+          case "/done":
             output = "Exited agent interaction.";
             done = true;
             break;
-          case "pause":
+          case "/pause":
             await agent.pause();
             console.log("Agent paused.");
             break;
-          case "unpause":
+          case "/unpause":
             await agent.unpause();
             console.log("Agent unpaused.");
             break;
-          case "kill":
+          case "/kill":
             await agent.kill();
             console.log("Agent terminated.");
             done = true;
             break;
-          case "detach":
+          case "/detach":
             console.log("Detached from agent");
-            return true;
+            return { result: true, finalOutput: agentFinalOutput };
           default:
             agent.addPendingUserMessage({
               role: "user",
@@ -981,12 +1045,10 @@ ${reason}
           finalTaskInfo.endTime = Date.now();
         }
       }
-
-      return true;
+      return { result: true, finalOutput: agentFinalOutput };
     } catch (error) {
       console.error("Agent execution failed:", error);
-      this.taskRegistry.delete(taskId);
-      return false;
+      return { result: false, finalOutput: "Error during agent execution" };
     }
   }
 }

package/src/chat/modules/AskModule.ts

@@ -7,7 +7,6 @@ import { ChatCommand, ChatMode, ChatContext } from "../types";
 import { ChatInteraction } from "../../types";
 import { Models } from "../../ai";
 import { services } from "../../services/index";
-import { Plugins } from "../../plugins/plugins";
 import { Marked } from "../../utils/index";
 
 export class AskModule extends BaseChatModule {

package/src/chat/modules/SetupModule.ts

@@ -167,13 +167,13 @@ export class SetupModule extends BaseChatModule {
       ) {
         // Launch Setup agent to guide user through configuration
         if (this.agentModule) {
+          const initialInput = "Help me set up my Knowhow configuration with the missing features and optimize my setup.";
           const { taskId, agent } = await this.agentModule.setupAgent({
             agentName: "Setup",
-            run: true,
-            input:
-              "Help me set up my Knowhow configuration with the missing features and optimize my setup.",
+            run: false,
+            input: initialInput,
           });
-          await this.agentModule.attachedAgentChatLoop(taskId, agent);
+          await this.agentModule.attachedAgentChatLoop(taskId, agent, initialInput);
         }
       }
     } else {

package/src/chat/modules/SystemModule.ts

@@ -3,6 +3,7 @@ import { CliChatService } from "../CliChatService";
 import { ChatCommand, ChatMode, ChatContext } from "../types";
 import { ask } from "../../utils";
 import { services } from "../../services";
+import { Models } from "../../types";
 
 export class SystemModule extends BaseChatModule {
   name = "system";
@@ -56,8 +57,18 @@ export class SystemModule extends BaseChatModule {
       currentModel: selectedModel,
       currentProvider,
     });
-
     console.log(`Model set to: ${selectedModel}`);
+
+    // Update currently active agent if any
+    if (context?.selectedAgent) {
+      console.log(
+        `Updating active agent ${context.currentAgent} model to: ${selectedModel}`
+      );
+      context?.selectedAgent?.updatePreferences({
+        model: selectedModel,
+        provider: currentProvider as any,
+      });
+    }
   }
 
   async handleProviderCommand(args: string[]): Promise<void> {
@@ -77,10 +88,10 @@ export class SystemModule extends BaseChatModule {
 
     // Get default model for new provider
     const ChatModelDefaults = {
-      openai: "gpt-4o",
-      anthropic: "claude-3-5-sonnet-20241022",
-      google: "gemini-2.0-flash-exp",
-      xai: "grok-beta",
+      openai: Models.openai.GPT_5,
+      anthropic: Models.anthropic.Sonnet4,
+      google: Models.google.Gemini_25_Flash_Preview,
+      xai: Models.xai.GrokCodeFast,
     };
 
     const newModel =
@@ -95,6 +106,18 @@ export class SystemModule extends BaseChatModule {
     console.log(
       `Provider set to: ${selectedProvider}, Model set to: ${newModel}`
     );
+
+    // Update currently active agent if any
+    if (context?.selectedAgent) {
+      console.log(
+        `Updating active agent ${context.currentAgent} provider to: ${selectedProvider} and model to: ${newModel}`
+      );
+
+      context?.selectedAgent?.updatePreferences({
+        model: newModel,
+        provider: selectedProvider as any,
+      });
+    }
   }
 
   async handleDebugCommand(args: string[]): Promise<void> {

package/src/chat/types.ts

@@ -14,6 +14,7 @@ export interface ChatContext {
   currentModel?: string;
   currentProvider?: string;
   inputMethod?: InputMethod;
+  selectedAgent?: BaseAgent;
   [key: string]: any;
 }
 
@@ -68,6 +69,7 @@ export interface TaskInfo {
   agentName: string;
   agent: BaseAgent;
   initialInput: string;
+  formattedPrompt: string;
   status: "running" | "paused" | "completed" | "failed";
   startTime: number;
   endTime?: number;

package/src/chat-old.ts

@@ -10,9 +10,8 @@ import {
 } from "./types";
 import { Marked } from "./utils";
 import { ask } from "./utils";
-import { Plugins } from "./plugins/plugins";
+import { services } from "./services";
 import { queryEmbedding, getConfiguredEmbeddingMap } from "./embeddings";
-import { services } from "./services/";
 import { FlagsService } from "./services/flags";
 import { IAgent } from "./agents/interface";
 import { Message } from "./clients";
@@ -165,6 +164,7 @@ export async function formatChatInput(
   plugins: string[] = [],
   chatHistory: ChatInteraction[] = []
 ) {
+  const { Plugins } = services();
   const pluginText = await Plugins.callMany(plugins, input);
   const historyMessage = `<PreviousChats>
   This information is provided as historical context and is likely not related to the current task:

package/src/clients/anthropic.ts

@@ -151,6 +151,15 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
+  tryParse(str: string): any {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+      console.error("Invalid JSON from tool call", str);
+      return {};
+    }
+  }
+
   transformMessages(messages: Message[]): MessageParam[] {
     const toolCalls = messages.flatMap((msg) => msg.tool_calls || []);
     const claudeMessages: MessageParam[] = messages
@@ -173,7 +182,7 @@ export class GenericAnthropicClient implements GenericClient {
                   type: "tool_use",
                   id: msg.tool_call_id,
                   name: toolCall.function.name,
-                  input: JSON.parse(toolCall.function.arguments),
+                  input: this.tryParse(toolCall.function.arguments),
                 },
               ],
             });
@@ -332,6 +341,18 @@ export class GenericAnthropicClient implements GenericClient {
         cache_hit: 0.3,
         output: 15.0,
       },
+      [Models.anthropic.Sonnet4_5]: {
+        input: 3.0,
+        cache_write: 3.75,
+        cache_hit: 0.3,
+        output: 15.0,
+      },
+      [Models.anthropic.Haiku4_5]: {
+        input: 1,
+        cache_write: 1.25,
+        cache_hit: 0.1,
+        output: 5,
+      },
       [Models.anthropic.Sonnet3_7]: {
         input: 3.0,
         cache_write: 3.75,

package/src/clients/openai.ts

@@ -29,7 +29,7 @@ export class GenericOpenAiClient implements GenericClient {
     this.apiKey = apiKey;
     this.client = new OpenAI({
       apiKey,
-      ...(config.openaiBaseUrl && { baseURL: config.openaiBaseUrl }),
+      ...(config?.openaiBaseUrl && { baseURL: config.openaiBaseUrl }),
     });
   }