@tyvm/knowhow 0.0.70 → 0.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.70",
+  "version": "0.0.72",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {

package/src/agents/base/base.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from "events";
 import {
   GenericClient,
   Message,
+  MessageContent,
   OutputMessage,
   Tool,
   ToolCall,
@@ -318,7 +319,7 @@ export abstract class BaseAgent implements IAgent {
     return this.summaries;
   }
 
-  abstract getInitialMessages(userInput: string): Promise<Message[]>;
+  abstract getInitialMessages(userInput: string | MessageContent[]): Promise<Message[]>;
 
   async processToolMessages(toolCall: ToolCall) {
     this.agentEvents.emit(this.eventTypes.toolCall, { toolCall });
@@ -479,7 +480,7 @@ export abstract class BaseAgent implements IAgent {
     } as Message);
   }
 
-  async call(userInput: string, _messages?: Message[]) {
+  async call(userInput: string | MessageContent[], _messages?: Message[]) {
     if (this.status === this.eventTypes.notStarted) {
       this.status = this.eventTypes.inProgress;
     }

package/src/agents/tools/startAgentTask.ts

@@ -139,12 +139,12 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
 
     const syncFsNote = syncFs
       ? `\nTask ID: ${taskId}\nAgent dir: ${agentTaskDir}\n` +
-        `To send follow-up messages, write to: ${agentTaskDir}/input.txt\n` +
+        `To send agent messages, write to: ${agentTaskDir}/input.txt\n` +
         `To check status, read: ${agentTaskDir}/status.txt\n`
       : "";
 
-    // Give the agent 30 seconds to finish before detaching
-    const detachTime = 30 * 1000; // 30 seconds
+    // Give the agent 5 seconds to finish before detaching
+    const detachTime = 5 * 1000;
     const tid = setTimeout(() => {
       try { child.unref(); } catch {}
       done(

package/src/agents/tools/stringReplace.ts

@@ -1,6 +1,5 @@
 import * as fs from "fs";
-import { embed } from "../../";
-import { lintFile } from ".";
+import { services, ToolsService } from "../../services";
 import { fileExists } from "../../utils";
 
 export async function stringReplace(
@@ -8,6 +7,12 @@ export async function stringReplace(
   replaceString: string,
   filePaths: string[]
 ): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+  const context = toolService.getContext();
+
   if (
     !findString ||
     replaceString === undefined ||
@@ -41,6 +46,20 @@ export async function stringReplace(
         continue;
       }
 
+      // Emit pre-edit blocking event
+      const eventResults: any[] = [];
+      if (context.Events) {
+        eventResults.push(
+          ...(await context.Events.emitBlocking("file:pre-edit", {
+            filePath,
+            operation: "stringReplace",
+            findString,
+            replaceString,
+            originalContent,
+          }))
+        );
+      }
+
       // Perform the replacement
       const newContent = content.replace(
         new RegExp(findString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
@@ -53,18 +72,29 @@ export async function stringReplace(
       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}`;
+      // Emit post-edit blocking event to get event results
+      if (context.Events) {
+        eventResults.push(
+          ...(await context.Events.emitBlocking("file:post-edit", {
+            filePath,
+            operation: "stringReplace",
+            findString,
+            replaceString,
+            originalContent,
+            updatedContent: newContent,
+          }))
+        );
       }
 
-      await embed();
+      // Format event results if any
+      if (eventResults && eventResults.length > 0) {
+        const eventResultsText = eventResults
+          .filter((r) => r && typeof r === "string" && r.trim())
+          .join("\n");
+        if (eventResultsText) {
+          results.push(eventResultsText);
+        }
+      }
     } catch (error) {
       results.push(`❌ Error processing ${filePath}: ${error.message}`);
     }

package/src/ai.ts

@@ -25,9 +25,19 @@ export function readPromptFile(promptFile: string, input: string) {
     if (fs.existsSync(promptFile)) {
       const promptTemplate = fs.readFileSync(promptFile, "utf-8");
       if (promptTemplate.includes("{text}")) {
-        return promptTemplate.replaceAll("{text}", input);
+        // Only replace if input is provided
+        if (input) {
+          return promptTemplate.replaceAll("{text}", input);
+        }
+        // If no input provided but template expects it, return template as-is
+        // This allows the calling code to handle the missing input
+        return promptTemplate;
       } else {
-        return `${promptTemplate}\n\n${input}`;
+        // Template doesn't have {text}, so input is optional
+        if (input) {
+          return `${promptTemplate}\n\n${input}`;
+        }
+        return promptTemplate;
       }
     }
   }

package/src/chat/modules/AgentModule.ts

@@ -528,6 +528,10 @@ Please continue from where you left off and complete the original request.
       // Save initial session
       this.saveSession(taskId, taskInfo, []);
 
+      // Reset sync services before setting up new task (removes old listeners)
+      this.webSync.reset();
+      this.fsSync.reset();
+
       // Create Knowhow chat task if messageId provided
       if (
         options.messageId &&
@@ -566,13 +570,11 @@ Please continue from where you left off and complete the original request.
       }
 
       // Set up session update listener
-      agent.agentEvents.on(
-        agent.eventTypes.threadUpdate,
-        async (threadState) => {
-          this.updateSession(taskId, threadState);
-          taskInfo.totalCost = agent.getTotalCostUsd();
-        }
-      );
+      const threadUpdateHandler = async (threadState: any) => {
+        this.updateSession(taskId, threadState);
+        taskInfo.totalCost = agent.getTotalCostUsd();
+      };
+      agent.agentEvents.on(agent.eventTypes.threadUpdate, threadUpdateHandler);
 
       console.log(
         Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`)
@@ -665,6 +667,8 @@ Please continue from where you left off and complete the original request.
           console.log("🎯 [AgentModule] Task Completed");
           done = true;
           output = doneMsg || "No response from the AI";
+          // Remove threadUpdate listener to prevent cost sharing across tasks
+          agent.agentEvents.removeListener(agent.eventTypes.threadUpdate, threadUpdateHandler);
           // Update task info
           taskInfo = this.taskRegistry.get(taskId);
 

package/src/cli.ts

@@ -15,6 +15,7 @@ import * as allTools from "./agents/tools";
 import { LazyToolsService, services } from "./services";
 import { login } from "./login";
 import { worker } from "./worker";
+import { fileSync } from "./fileSync";
 import {
   startAllWorkers,
   listWorkerPaths,
@@ -211,18 +212,23 @@ async function main() {
       try {
         await setupServices();
         let input = options.input;
-        if (!input) {
+
+        // Only read from stdin if we don't have input and don't have a standalone prompt file
+        if (!input && !options.promptFile) {
           input = await readStdin();
-          if (!input) {
-            console.error(
-              "Error: No input provided. Use --input flag or pipe input via stdin."
-            );
-            process.exit(1);
-          }
         }
 
+        // Read prompt file - it will handle cases where input is empty
         input = readPromptFile(options.promptFile, input);
 
+        // Only error if we have no prompt file and no input
+        if (!input) {
+          console.error(
+            "Error: No input provided. Use --input flag, pipe input via stdin, or provide --prompt-file."
+          );
+          process.exit(1);
+        }
+
         const agentModule = new AgentModule();
         await agentModule.initialize(chatService);
         const { taskCompleted } = await agentModule.setupAgent({
@@ -250,18 +256,23 @@ async function main() {
       try {
         await setupServices();
         let input = options.input;
-        if (!input) {
+
+        // Only read from stdin if we don't have input and don't have a standalone prompt file
+        if (!input && !options.promptFile) {
           input = await readStdin();
-          if (!input) {
-            console.error(
-              "Error: No question provided. Use --input flag or pipe input via stdin."
-            );
-            process.exit(1);
-          }
         }
 
+        // Read prompt file - it will handle cases where input is empty
         input = readPromptFile(options.promptFile, input);
 
+        // Only error if we have no prompt file and no input
+        if (!input) {
+          console.error(
+            "Error: No question provided. Use --input flag, pipe input via stdin, or provide --prompt-file."
+          );
+          process.exit(1);
+        }
+
         const askModule = new AskModule();
         await askModule.initialize(chatService);
         await askModule.processAIQuery(input, {
@@ -358,6 +369,22 @@ async function main() {
       await worker(options);
     });
 
+  program
+    .command("files")
+    .description("Sync files between local filesystem and Knowhow FS (uses fileMounts config)")
+    .option("--upload", "Force upload direction for all mounts")
+    .option("--download", "Force download direction for all mounts")
+    .option("--config <path>", "Path to knowhow.json", "./knowhow.json")
+    .option("--dry-run", "Print what would be synced without doing it")
+    .action(async (options) => {
+      try {
+        await fileSync(options);
+      } catch (error) {
+        console.error("Error syncing files:", error);
+        process.exit(1);
+      }
+    });
+
   program
     .command("workers")
     .description("Manage and start all registered workers")

package/src/clients/anthropic.ts

@@ -243,19 +243,29 @@ export class GenericAnthropicClient implements GenericClient {
                 if (item.type === "image_url") {
                   const url = item.image_url.url;
                   const isDataUrl = url.startsWith("data:");
-                  const base64Data = isDataUrl ? url.split(",")[1] : url;
-                  const mediaType = isDataUrl
-                    ? url.match(/data:([^;]+);/)?.[1] || "image/jpeg"
-                    : "image/jpeg";
-
-                  return {
-                    type: "image" as const,
-                    source: {
-                      type: "base64" as const,
-                      media_type: mediaType as any,
-                      data: base64Data,
-                    },
-                  };
+                  const isHttpUrl = url.startsWith("http");
+                  if (isHttpUrl) {
+                    return {
+                      type: "image" as const,
+                      source: {
+                        type: "url" as const,
+                        url,
+                      },
+                    } as Anthropic.ImageBlockParam;
+                  } else {
+                    const base64Data = isDataUrl ? url.split(",")[1] : url;
+                    const mediaType = isDataUrl
+                      ? url.match(/data:([^;]+);/)?.[1] || "image/jpeg"
+                      : "image/jpeg";
+                    return {
+                      type: "image" as const,
+                      source: {
+                        type: "base64" as const,
+                        media_type: mediaType as any,
+                        data: base64Data,
+                      },
+                    };
+                  }
                 } else if (item.type === "text") {
                   return { type: "text" as const, text: item.text };
                 }
@@ -308,15 +318,24 @@ export class GenericAnthropicClient implements GenericClient {
       }
       if (typeof e === "object" && e.type === "image_url") {
         const isUrl = e.image_url.url.startsWith("http");
-        return {
-          type: "image",
-          source: {
-            data: isUrl ? e.image_url.url : undefined,
-            media_type: "image/jpeg",
-            type: isUrl ? ("url" as const) : ("base64" as const),
-            url: isUrl ? e.image_url.url : undefined,
-          },
-        };
+        if (isUrl) {
+          return {
+            type: "image",
+            source: {
+              type: "url" as const,
+              url: e.image_url.url,
+            },
+          } as Anthropic.ContentBlockParam;
+        } else {
+          return {
+            type: "image",
+            source: {
+              type: "base64" as const,
+              media_type: "image/jpeg",
+              data: e.image_url.url,
+            },
+          } as Anthropic.ContentBlockParam;
+        }
       }
     };
 

package/src/fileSync.ts

@@ -0,0 +1,165 @@
+import * as fs from "fs";
+import * as path from "path";
+import { KnowhowSimpleClient, KNOWHOW_API_URL } from "./services/KnowhowClient";
+import { loadJwt } from "./login";
+import { getConfig } from "./config";
+import { services } from "./services";
+import { S3Service } from "./services/S3";
+
+export interface FileSyncOptions {
+  upload?: boolean;
+  download?: boolean;
+  apiUrl?: string;
+  configPath?: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Sync files between local filesystem and Knowhow FS
+ */
+export async function fileSync(options: FileSyncOptions = {}) {
+  const {
+    upload = false,
+    download = false,
+    apiUrl = KNOWHOW_API_URL,
+    configPath = "./knowhow.json",
+    dryRun = false,
+  } = options;
+
+  // Load configuration
+  const config = await getConfig();
+
+  // Check if files is configured
+  if (!config.files || config.files.length === 0) {
+    console.log("✓ No files configured, skipping sync");
+    return;
+  }
+
+  // Load JWT token
+  const jwt = await loadJwt();
+  if (!jwt) {
+    console.error("❌ No JWT token found. Please run 'knowhow login' first.");
+    process.exit(1);
+  }
+
+  // Create API client
+  const client = new KnowhowSimpleClient(apiUrl, jwt);
+
+  // Get S3 service for presigned URL operations
+  const { AwsS3 } = services();
+
+  console.log(`🔄 Starting file sync (${config.files.length} mounts)...`);
+
+  let successCount = 0;
+  let failCount = 0;
+
+  // Process each file mount
+  for (const mount of config.files) {
+    const { remotePath, localPath, direction = "download" } = mount;
+
+    // Determine actual direction based on flags and config
+    let actualDirection = direction;
+    if (upload) {
+      actualDirection = "upload";
+    } else if (download) {
+      actualDirection = "download";
+    }
+
+    try {
+      if (actualDirection === "download") {
+        await downloadFile(client, AwsS3, remotePath, localPath, dryRun);
+        successCount++;
+      } else if (actualDirection === "upload") {
+        await uploadFile(client, AwsS3, remotePath, localPath, dryRun);
+        successCount++;
+      }
+    } catch (error) {
+      console.error(`❌ Failed to sync ${remotePath}: ${error.message}`);
+      failCount++;
+    }
+  }
+
+  console.log(
+    `\n✓ Sync complete: ${successCount} succeeded, ${failCount} failed`
+  );
+
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Download a file from Knowhow FS to local filesystem
+ */
+async function downloadFile(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  remotePath: string,
+  localPath: string,
+  dryRun: boolean
+): Promise<void> {
+  console.log(`⬇️  Downloading ${remotePath} → ${localPath}`);
+
+  if (dryRun) {
+    console.log(`   [DRY RUN] Would download to ${localPath}`);
+    return;
+  }
+
+  try {
+    // Get presigned download URL
+    const presignedUrl = await client.getOrgFilePresignedDownloadUrl(
+      remotePath
+    );
+
+    // Ensure parent directory exists
+    const dir = path.dirname(localPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Download file using presigned URL
+    await s3Service.downloadFromPresignedUrl(presignedUrl, localPath);
+
+    // Get file size for logging
+    const stats = fs.statSync(localPath);
+    console.log(`   ✓ Downloaded ${stats.size} bytes`);
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Upload a file from local filesystem to Knowhow FS
+ */
+async function uploadFile(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  remotePath: string,
+  localPath: string,
+  dryRun: boolean
+): Promise<void> {
+  console.log(`⬆️  Uploading ${localPath} → ${remotePath}`);
+
+  if (dryRun) {
+    console.log(`   [DRY RUN] Would upload from ${localPath}`);
+    return;
+  }
+
+  // Check if local file exists
+  if (!fs.existsSync(localPath)) {
+    console.warn(`   ⚠️  Local file not found: ${localPath}`);
+    return;
+  }
+
+  // Get presigned upload URL
+  const presignedUrl = await client.getOrgFilePresignedUploadUrl(remotePath);
+
+  // Upload file using presigned URL
+  await s3Service.uploadToPresignedUrl(presignedUrl, localPath);
+
+  // Notify backend that upload is complete to update the updatedAt timestamp
+  await client.markOrgFileUploadComplete(remotePath);
+
+  const stats = fs.statSync(localPath);
+  console.log(`   ✓ Uploaded ${stats.size} bytes`);
+}

package/src/services/AgentSyncFs.ts

@@ -25,6 +25,9 @@ export class AgentSyncFs {
   private lastInputContent: string = "";
   private cleanupInterval: NodeJS.Timeout | null = null;
   private finalizationPromise: Promise<void> | null = null;
+  private agent: BaseAgent | undefined;
+  private threadUpdateHandler: ((...args: any[]) => void) | undefined;
+  private doneHandler: ((...args: any[]) => void) | undefined;
 
   constructor() {
     // Start cleanup process when created
@@ -281,8 +284,10 @@ export class AgentSyncFs {
    * Set up event handlers for automatic synchronization
    */
   private setupEventHandlers(agent: BaseAgent): void {
-    // Listen to thread updates to sync state
-    agent.agentEvents.on(agent.eventTypes.threadUpdate, async () => {
+    this.agent = agent;
+
+    // Listen to thread updates to sync state (store reference for cleanup)
+    this.threadUpdateHandler = async () => {
       if (!this.taskId) return;
 
       try {
@@ -291,10 +296,11 @@ export class AgentSyncFs {
       } catch (error) {
         console.error(`❌ Error during threadUpdate sync:`, error);
       }
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.threadUpdate, this.threadUpdateHandler);
 
-    // Listen to completion event to finalize task
-    agent.agentEvents.on(agent.eventTypes.done, (result: string) => {
+    // Listen to completion event to finalize task (store reference for cleanup)
+    this.doneHandler = (result: string) => {
       if (!this.taskId) {
         console.warn(`⚠️ [AgentSyncFs] Cannot finalize: taskId=${this.taskId}`);
         return;
@@ -313,7 +319,8 @@ export class AgentSyncFs {
           throw error;
         }
       })();
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.done, this.doneHandler);
   }
 
   /**
@@ -407,6 +414,18 @@ export class AgentSyncFs {
    * Reset synchronization state
    */
   reset(): void {
+    // Remove old event listeners from the agent before resetting
+    if (this.agent) {
+      if (this.threadUpdateHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+        this.threadUpdateHandler = undefined;
+      }
+      if (this.doneHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.done, this.doneHandler);
+        this.doneHandler = undefined;
+      }
+      this.agent = undefined;
+    }
     this.cleanup();
     this.taskId = undefined;
     this.taskPath = undefined;

package/src/services/AgentSyncKnowhowWeb.ts

@@ -33,6 +33,9 @@ export class AgentSyncKnowhowWeb {
   private knowhowTaskId: string | undefined;
   private eventHandlersSetup: boolean = false;
   private finalizationPromise: Promise<void> | null = null;
+  private agent: BaseAgent | undefined;
+  private threadUpdateHandler: ((...args: any[]) => void) | undefined;
+  private doneHandler: ((...args: any[]) => void) | undefined;
 
   constructor(baseUrl: string = KNOWHOW_API_URL) {
     this.baseUrl = baseUrl;
@@ -228,8 +231,10 @@ export class AgentSyncKnowhowWeb {
    * Set up event handlers for automatic synchronization
    */
   private setupEventHandlers(agent: BaseAgent): void {
-    // Listen to thread updates to sync state and check for pending messages
-    agent.agentEvents.on(agent.eventTypes.threadUpdate, async () => {
+    this.agent = agent;
+
+    // Listen to thread updates to sync state and check for pending messages (store reference for cleanup)
+    this.threadUpdateHandler = async () => {
       if (!this.knowhowTaskId || !this.baseUrl) {
         return;
       }
@@ -244,10 +249,11 @@ export class AgentSyncKnowhowWeb {
         console.error(`❌ Error during threadUpdate sync:`, error);
         // Continue execution even if synchronization fails
       }
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.threadUpdate, this.threadUpdateHandler);
 
-    // Listen to completion event to finalize task
-    agent.agentEvents.on(agent.eventTypes.done, async (result: string) => {
+    // Listen to completion event to finalize task (store reference for cleanup)
+    this.doneHandler = async (result: string) => {
       if (!this.knowhowTaskId || !this.baseUrl) {
         console.warn(`⚠️ [AgentSync] Cannot finalize: knowhowTaskId=${this.knowhowTaskId}, baseUrl=${this.baseUrl}`);
         return;
@@ -268,7 +274,8 @@ export class AgentSyncKnowhowWeb {
           throw error; // Re-throw so CLI can handle it
         }
       })();
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.done, this.doneHandler);
   }
 
   /**
@@ -284,6 +291,18 @@ export class AgentSyncKnowhowWeb {
    * Reset synchronization state (useful for reusing the service)
    */
   reset(): void {
+    // Remove old event listeners from the agent before resetting
+    if (this.agent) {
+      if (this.threadUpdateHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+        this.threadUpdateHandler = undefined;
+      }
+      if (this.doneHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.done, this.doneHandler);
+        this.doneHandler = undefined;
+      }
+      this.agent = undefined;
+    }
     this.knowhowTaskId = undefined;
     this.eventHandlersSetup = false;
     this.finalizationPromise = null;