@tyvm/knowhow 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -60,6 +60,7 @@
     "marked-terminal": "^6.2.0",
     "morgan": "^1.10.0",
     "node-fetch": "^3.2.3",
+    "node-jq": "^6.0.1",
     "node-pty": "^1.0.0",
     "node-record-lpcm16": "^1.0.1",
     "openai": "4.89.1",

package/src/agents/base/base.ts

@@ -13,10 +13,10 @@ import {
   replaceEscapedNewLines,
   restoreEscapedNewLines,
 } from "../../utils";
-import { Agents, AgentService } from "../../services/AgentService";
 import { Events, EventService } from "../../services/EventService";
 import { AIClient, Clients } from "../../clients";
 import { Models } from "../../ai";
+import { MessageProcessor } from "../../services/MessageProcessor";
 
 export { Message, Tool, ToolCall };
 export interface ModelPreference {
@@ -60,7 +60,8 @@ export abstract class BaseAgent implements IAgent {
 
   constructor(
     public tools: ToolsService = Tools,
-    public events: EventService = Events
+    public events: EventService = Events,
+    public messageProcessor: MessageProcessor = new MessageProcessor()
   ) {}
 
   newTask() {
@@ -418,6 +419,11 @@ export abstract class BaseAgent implements IAgent {
       const model = this.getModel();
       let messages = _messages || (await this.getInitialMessages(userInput));
 
+      // Process initial messages if this is the first call
+      if (!_messages) {
+        messages = await this.messageProcessor.processMessages(messages, "initial_call");
+      }
+
       if (this.pendingUserMessages.length) {
         messages.push(...this.pendingUserMessages);
         this.pendingUserMessages = [];
@@ -429,6 +435,9 @@ export abstract class BaseAgent implements IAgent {
 
       const startIndex = 0;
       const endIndex = messages.length;
+
+      // Process messages before each AI call
+      messages = await this.messageProcessor.processMessages(messages, "per_call");
       const compressThreshold = 10000;
 
       const response = await this.getClient().createChatCompletion({
@@ -479,6 +488,11 @@ export abstract class BaseAgent implements IAgent {
         }
       }
 
+      // Process messages after tool execution
+      if (newToolCalls && newToolCalls.length > 0) {
+        messages = await this.messageProcessor.processMessages(messages, "post_call");
+      }
+
       // Early exit: not required to call tool
       if (
         response.choices.length === 1 &&
@@ -565,7 +579,9 @@ export abstract class BaseAgent implements IAgent {
     1. Task List
     2. Completion Criteria - when the agent should stop
 
-      : \n\n${JSON.stringify(messages)}`;
+    This output will be used to guide the work of the agent, and determine when we've accomplished the goal
+
+    \n\n<ToAnalyze>${JSON.stringify(messages)}</ToAnalyze>`;
 
     const model = this.getModel();
 
@@ -577,6 +593,7 @@ export abstract class BaseAgent implements IAgent {
           content: taskPrompt,
         },
       ],
+      max_tokens: 2000,
     });
 
     this.adjustTotalCostUsd(response.usd_cost);
@@ -602,10 +619,12 @@ export abstract class BaseAgent implements IAgent {
     3. Next Steps - what we're about to do next to continue the user's original request.
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
-      This summary will become the agent's only memory of the past, all other messages will be dropped:
-    ${JSON.stringify(toCompress)}
+    Our initial task breakdown: ${this.taskBreakdown}
+
+    This summary will become the agent's only memory of the past, all other messages will be dropped:
+    <ToSummarize>${JSON.stringify(toCompress)}</ToSummarize>
 
-      Our initial task breakdown: ${this.taskBreakdown}`;
+      `;
 
     const model = this.getModel();
 

package/src/agents/index.ts

@@ -1,5 +1,5 @@
-export * from "./base/base";
-export * from "./configurable/ConfigAgent";
+export { BaseAgent } from "./base/base";
+export { ConfigAgent } from "./configurable/ConfigAgent";
 export * from "./developer/developer";
 export * from "./patcher/patcher";
 export * from "./researcher/researcher";

package/src/agents/tools/agentCall.ts

@@ -1,4 +1,3 @@
-import { Agents } from "../../services/AgentService";
 import { Events } from "../../services/EventService";
 import { Plugins } from "../../plugins/plugins";
 import { getConfig } from "../../config";

package/src/agents/tools/execCommand.ts

@@ -1,15 +1,106 @@
-import { execAsync } from "../../utils";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+export interface ExecCommandOptions {
+  timeout?: number; // Timeout in milliseconds
+  killOnTimeout?: boolean; // Whether to kill the command on timeout (default: false)
+  waitForCompletion?: boolean; // Whether to wait for full completion (default: true)
+}
+
+// Enhanced exec function with timeout support
+const execWithTimeout = async (
+  command: string,
+  options: ExecCommandOptions = {}
+): Promise<{ stdout: string; stderr: string; timedOut: boolean; killed: boolean }> => {
+  const { timeout, killOnTimeout = false, waitForCompletion = true } = options;
+  
+  if (!timeout || waitForCompletion) {
+    // Default behavior - wait for completion
+    try {
+      const result = await execAsync(command);
+      return { ...result, timedOut: false, killed: false };
+    } catch (error) {
+      return { 
+        stdout: error.stdout || "", 
+        stderr: error.stderr || error.message, 
+        timedOut: false, 
+        killed: false 
+      };
+    }
+  }
+
+  // Timeout behavior
+  return new Promise((resolve) => {
+    const childProcess = exec(command, (error, stdout, stderr) => {
+      if (error && !error.killed) {
+        resolve({ stdout, stderr: stderr || error.message, timedOut: false, killed: false });
+      } else {
+        resolve({ stdout, stderr, timedOut: false, killed: error?.killed || false });
+      }
+    });
+
+    const timeoutId = setTimeout(() => {
+      if (killOnTimeout) {
+        childProcess.kill('SIGTERM');
+        // Force kill after additional 5 seconds if still running
+        setTimeout(() => {
+          if (!childProcess.killed) {
+            childProcess.kill('SIGKILL');
+          }
+        }, 5000);
+        resolve({ 
+          stdout: "", 
+          stderr: `Command timed out after ${timeout}ms and was killed`, 
+          timedOut: true, 
+          killed: true 
+        });
+      } else {
+        resolve({ 
+          stdout: "", 
+          stderr: `Command timed out after ${timeout}ms but is still running in background`, 
+          timedOut: true, 
+          killed: false 
+        });
+      }
+    }, timeout);
+
+    // Clear timeout if command completes before timeout
+    childProcess.on('exit', () => {
+      clearTimeout(timeoutId);
+    });
+  });
+};
 
 // Tool to execute a command in the system's command line interface
-export const execCommand = async (command: string): Promise<string> => {
+export const execCommand = async (
+  command: string,
+  timeout?: number,
+  killOnTimeout?: boolean,
+  waitForCompletion?: boolean
+): Promise<string> => {
   let output = "";
   console.log("execCommand:", command);
-  const { stdout, stderr } = await execAsync(command).catch((e) => e);
+  
+  const { stdout, stderr, timedOut, killed } = await execWithTimeout(command, {
+    timeout,
+    killOnTimeout,
+    waitForCompletion,
+
+  });
+
   if (stderr) {
     output += stderr + "\n";
   }
   output += stdout;
-  console.log(`$ ${command}:\n${output}`);
+  
+  if (timedOut) {
+    const statusMsg = killed ? " (killed due to timeout)" : " (timed out, still running)";
+    console.log(`$ ${command}${statusMsg}:\n${output}`);
+  } else {
+    console.log(`$ ${command}:\n${output}`);
+  }
 
   const fullOutput = output.split("\n");
 

package/src/agents/tools/list.ts

@@ -7,7 +7,6 @@ import * as github from "./github/definitions";
 import * as asana from "./asana/definitions";
 import * as language from "./language/definitions";
 import { googleSearchDefinition } from "./googleSearch";
-import { Agents } from "../../services/AgentService";
 
 export const includedTools = [
   {
@@ -39,7 +38,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",
+        "Execute a command in the system's command line interface. Use this to run tests and things in the terminal. Supports timeout functionality.",
       parameters: {
         type: "object",
         positional: true,
@@ -48,23 +47,28 @@ export const includedTools = [
             type: "string",
             description: "The command to execute",
           },
+          timeout: {
+            type: "number",
+            description:
+              "Timeout in milliseconds (optional). If not provided, waits indefinitely.",
+          },
+          killOnTimeout: {
+            type: "boolean",
+            description:
+              "Whether to kill the command when timeout is reached (default: false). If false, command continues running in background.",
+          },
+          waitForCompletion: {
+            type: "boolean",
+            description:
+              "Whether to wait for full completion regardless of timeout (default: true). Overrides timeout behavior.",
+          },
         },
         required: ["command"],
       },
       returns: {
-        type: "object",
-        properties: {
-          stdout: {
-            type: "string",
-            description: "The standard output of the executed command",
-          },
-          stderr: {
-            type: "string",
-            description: "The standard error output of the executed command",
-          },
-        },
+        type: "string",
         description:
-          "The result of the command execution, including any output and errors",
+          "The result of the command execution, including any output and errors. May include timeout status information.",
       },
     },
   },
@@ -473,8 +477,6 @@ export const includedTools = [
       },
     },
   },
-
-  googleSearchDefinition,
   {
     type: "function",
     function: {
@@ -515,9 +517,6 @@ export const includedTools = [
       },
     },
   },
-  ...asana.definitions,
-  ...github.definitions,
-  ...language.definitions,
   {
     type: "function",
     function: {
@@ -553,4 +552,9 @@ export const includedTools = [
       },
     },
   },
+
+  googleSearchDefinition,
+  ...asana.definitions,
+  ...github.definitions,
+  ...language.definitions,
 ] as Tool[];

package/src/agents/tools/writeFile.ts

@@ -27,7 +27,7 @@ export async function writeFileChunk(
   }
 
   if (isContinuing) {
-    fs.appendFileSync(filePath, content);
+    fs.appendFileSync(filePath, "\n" + content);
   }
 
   let message = "";

package/src/chat.ts

@@ -21,6 +21,8 @@ import { recordAudio, voiceToText } from "./microphone";
 import { Models } from "./ai";
 import { BaseAgent } from "./agents";
 import { getConfig } from "./config";
+import { TokenCompressor } from "./processors/TokenCompressor";
+import { ToolResponseCache } from "./processors/ToolResponseCache";
 
 enum ChatFlags {
   agent = "agent",
@@ -346,6 +348,15 @@ export async function startAgent(
     );
     activeAgent.call(formattedPrompt);
 
+    // Compress tokens of tool responses
+    activeAgent.messageProcessor.setProcessors("per_call", [
+      new ToolResponseCache(activeAgent.tools).createProcessor(),
+
+      new TokenCompressor(activeAgent.tools).createProcessor((msg) =>
+        Boolean(msg.role === "tool" && msg.tool_call_id)
+      ),
+    ]);
+
     activeAgent.agentEvents.once(activeAgent.eventTypes.done, (doneMsg) => {
       console.log("Agent has finished.");
       done = true;

package/src/config.ts

@@ -187,7 +187,9 @@ export function getConfigSync() {
 
 export async function getConfig() {
   if (!fs.existsSync(".knowhow/knowhow.json")) {
-    return {} as Config;
+    throw new Error(
+      "KnowHow config file not found. Please run `knowhow init` to create it."
+    );
   }
   const config = JSON.parse(await readFile(".knowhow/knowhow.json", "utf8"));
   return config as Config;

package/src/processors/Base64ImageDetector.ts

@@ -0,0 +1,190 @@
+import { Message } from "../clients/types";
+import { MessageProcessorFunction } from "../services/MessageProcessor";
+
+interface ImageContent {
+  type: "image_url";
+  image_url: {
+    url: string;
+    detail?: "auto" | "low" | "high";
+  };
+}
+
+interface TextContent {
+  type: "text";
+  text: string;
+}
+
+export class Base64ImageDetector {
+  private imageDetail: "auto" | "low" | "high";
+  private supportedFormats: string[];
+
+  constructor(
+    imageDetail: "auto" | "low" | "high" = "auto",
+    supportedFormats: string[] = ["png", "jpeg", "jpg", "gif", "webp"]
+  ) {
+    this.imageDetail = imageDetail;
+    this.supportedFormats = supportedFormats;
+  }
+
+  private isBase64Image(text: string): { isImage: boolean; mimeType?: string; data?: string } {
+    // Check for data URL format: data:image/type;base64,actualdata
+    const dataUrlPattern = /^data:image\/([a-zA-Z]+);base64,(.+)$/;
+    const match = text.match(dataUrlPattern);
+    
+    if (match) {
+      const [, mimeType, data] = match;
+      if (this.supportedFormats.includes(mimeType.toLowerCase())) {
+        return { isImage: true, mimeType, data };
+      }
+    }
+
+    // Check for plain base64 that might be an image
+    // This is a heuristic - look for long base64 strings that might be images
+    const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
+    if (base64Pattern.test(text) && text.length > 100) {
+      // Try to detect image type from base64 header
+      const header = text.substring(0, 50);
+      try {
+        const decoded = atob(header);
+        // Check for common image file signatures
+        if (decoded.startsWith('\x89PNG')) {
+          return { isImage: true, mimeType: 'png', data: text };
+        } else if (decoded.startsWith('\xFF\xD8\xFF')) {
+          return { isImage: true, mimeType: 'jpeg', data: text };
+        } else if (decoded.startsWith('GIF87a') || decoded.startsWith('GIF89a')) {
+          return { isImage: true, mimeType: 'gif', data: text };
+        } else if (decoded.startsWith('RIFF') && decoded.includes('WEBP')) {
+          return { isImage: true, mimeType: 'webp', data: text };
+        }
+      } catch (e) {
+        // Not valid base64 or not an image
+      }
+    }
+
+    return { isImage: false };
+  }
+
+  private convertBase64ToImageContent(text: string): ImageContent | null {
+    const detection = this.isBase64Image(text);
+    
+    if (!detection.isImage) {
+      return null;
+    }
+
+    const dataUrl = detection.data!.startsWith('data:') 
+      ? detection.data 
+      : `data:image/${detection.mimeType};base64,${detection.data}`;
+
+    return {
+      type: "image_url",
+      image_url: {
+        url: dataUrl,
+        detail: this.imageDetail
+      }
+    };
+  }
+
+  private processMessageContent(message: Message): void {
+    if (typeof message.content === 'string') {
+      const imageContent = this.convertBase64ToImageContent(message.content);
+      if (imageContent) {
+        // Convert string content to multimodal array
+        message.content = [imageContent];
+      }
+    } else if (Array.isArray(message.content)) {
+      // Process each content item
+      const newContent: (TextContent | ImageContent)[] = [];
+      
+      for (const item of message.content) {
+        if (item.type === 'text' && item.text) {
+          const imageContent = this.convertBase64ToImageContent(item.text);
+          if (imageContent) {
+            newContent.push(imageContent);
+          } else {
+            newContent.push(item as TextContent);
+          }
+        } else {
+          newContent.push(item as TextContent | ImageContent);
+        }
+      }
+      
+      message.content = newContent;
+    }
+  }
+
+  private processToolCallArguments(message: Message): void {
+    if (message.tool_calls) {
+      for (const toolCall of message.tool_calls) {
+        if (toolCall.function.arguments) {
+          try {
+            const args = JSON.parse(toolCall.function.arguments);
+            let modified = false;
+            
+            // Recursively check all string values in arguments
+            const processValue = (obj: any): any => {
+              if (typeof obj === 'string') {
+                const detection = this.isBase64Image(obj);
+                if (detection.isImage) {
+                  modified = true;
+                  const dataUrl = detection.data!.startsWith('data:') 
+                    ? detection.data 
+                    : `data:image/${detection.mimeType};base64,${detection.data}`;
+                  return `[CONVERTED TO IMAGE: ${dataUrl.substring(0, 50)}...]`;
+                }
+                return obj;
+              } else if (Array.isArray(obj)) {
+                return obj.map(processValue);
+              } else if (obj && typeof obj === 'object') {
+                const result = {};
+                for (const [key, value] of Object.entries(obj)) {
+                  result[key] = processValue(value);
+                }
+                return result;
+              }
+              return obj;
+            };
+            
+            const processedArgs = processValue(args);
+            if (modified) {
+              toolCall.function.arguments = JSON.stringify(processedArgs);
+            }
+          } catch (e) {
+            // Arguments are not valid JSON, treat as string
+            const detection = this.isBase64Image(toolCall.function.arguments);
+            if (detection.isImage) {
+              const dataUrl = detection.data!.startsWith('data:') 
+                ? detection.data 
+                : `data:image/${detection.mimeType};base64,${detection.data}`;
+              toolCall.function.arguments = `[CONVERTED TO IMAGE: ${dataUrl.substring(0, 50)}...]`;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  createProcessor(): MessageProcessorFunction {
+    return (originalMessages: Message[], modifiedMessages: Message[]) => {
+      for (const message of modifiedMessages) {
+        // Only process user messages (images typically come from users)
+        if (message.role === 'user') {
+          this.processMessageContent(message);
+        }
+        
+        // Process tool calls in any message
+        this.processToolCallArguments(message);
+      }
+    };
+  }
+
+  setImageDetail(detail: "auto" | "low" | "high"): void {
+    this.imageDetail = detail;
+  }
+
+  setSupportedFormats(formats: string[]): void {
+    this.supportedFormats = formats;
+  }
+}
+
+// Global instance
+export const globalBase64ImageDetector = new Base64ImageDetector();