@tyvm/knowhow 0.0.69 → 0.0.71

package/src/cli.ts

@@ -7,7 +7,7 @@ import { Command } from "commander";
 import { execSync } from "child_process";
 import { version } from "../package.json";
 import { generate, embed, upload } from "./index";
-import { init } from "./config";
+import { init, migrateConfig } from "./config";
 
 import { download, purge } from ".";
 import { includedTools } from "./agents/tools/list";
@@ -26,6 +26,7 @@ import { startChat } from "./chat";
 import { askAI } from "./chat-old";
 import { getConfiguredEmbeddingMap, queryEmbedding } from "./embeddings";
 import { getConfig } from "./config";
+import { getEnabledPlugins } from "./types";
 import { marked } from "marked";
 import { BaseAgent } from "./agents/base/base";
 import { AskModule } from "./chat/modules/AskModule";
@@ -36,9 +37,16 @@ import { SetupModule } from "./chat/modules/SetupModule";
 import { CliChatService } from "./chat/CliChatService";
 
 async function setupServices() {
-  const { Agents, Mcp, Clients } = services();
+  await migrateConfig();
+
+  const { Agents, Mcp, Clients, Tools: OldTools } = services();
   const Tools = new LazyToolsService();
 
+  // We need to wireup the LazyTools to be connected to the same singletons that are in services()
+  Tools.setContext({
+    ...OldTools.getContext(),
+  });
+
   const { Researcher, Developer, Patcher, Setup } = agents({
     ...services(),
     Tools,
@@ -85,7 +93,7 @@ async function readStdin(): Promise<string> {
 async function main() {
   const program = new Command();
   const config = await getConfig();
-  const chatService = new CliChatService(config.plugins);
+  const chatService = new CliChatService(getEnabledPlugins(config.plugins));
 
   program
     .name("knowhow")
@@ -114,13 +122,13 @@ async function main() {
       try {
         console.log("🔄 Checking for knowhow updates...");
         console.log(`Current version: ${version}`);
-        
+
         console.log("📦 Installing latest version from npm...");
         execSync("npm install -g knowhow@latest", {
           stdio: "inherit",
           encoding: "utf-8",
         });
-        
+
         console.log("✓ knowhow has been updated successfully!");
         console.log("Run 'knowhow --version' to see the new version.");
       } catch (error) {
@@ -195,6 +203,8 @@ async function main() {
       "10"
     )
     .option("--message-id <messageId>", "Knowhow message ID for task tracking")
+    .option("--sync-fs", "Enable filesystem-based synchronization")
+    .option("--task-id <taskId>", "Pre-generated task ID (used with --sync-fs for predictable agent directory path)")
     .option("--prompt-file <path>", "Custom prompt template file with {text}")
     .option("--input <text>", "Task input (fallback to stdin if not provided)")
     .action(async (options) => {
@@ -255,7 +265,7 @@ async function main() {
         const askModule = new AskModule();
         await askModule.initialize(chatService);
         await askModule.processAIQuery(input, {
-          plugins: config.plugins,
+          plugins: config.plugins.enabled,
           currentModel: options.model,
           currentProvider: options.provider,
         });

package/src/clients/anthropic.ts

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { wait } from "../utils";
+import { AnthropicTextPricing } from "./pricing";
 import { Models } from "../types";
 import {
   GenericClient,
@@ -9,6 +10,14 @@ import {
   Message,
   EmbeddingOptions,
   EmbeddingResponse,
+  AudioTranscriptionOptions,
+  AudioTranscriptionResponse,
+  AudioGenerationOptions,
+  AudioGenerationResponse,
+  ImageGenerationOptions,
+  ImageGenerationResponse,
+  VideoGenerationOptions,
+  VideoGenerationResponse,
 } from "./types";
 
 type MessageParam = Anthropic.MessageParam;
@@ -234,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 };
                 }
@@ -299,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;
+        }
       }
     };
 
@@ -340,7 +368,7 @@ export class GenericAnthropicClient implements GenericClient {
               },
             ]
           : undefined,
-        max_tokens: options.max_tokens || 4096,
+        max_tokens: options.max_tokens || 8000,
         ...(tools.length && {
           tool_choice: { type: "auto" },
           tools,
@@ -398,98 +426,14 @@ export class GenericAnthropicClient implements GenericClient {
   }
 
   pricesPerMillion() {
-    return {
-      [Models.anthropic.Opus4_6]: {
-        input: 5.0,
-        input_gt_200k: 10.0,
-        cache_write: 6.25,
-        cache_hit: 0.5,
-        output: 25.0,
-        output_gt_200k: 37.5,
-      },
-      [Models.anthropic.Sonnet4_6]: {
-        input: 3.0,
-        input_gt_200k: 6.0,
-        cache_write: 3.75,
-        cache_hit: 0.3,
-        output: 15.0,
-        output_gt_200k: 22.5,
-      },
-      [Models.anthropic.Opus4_5]: {
-        input: 5.0,
-        cache_write: 6.25,
-        cache_hit: 0.5,
-        output: 25.0,
-      },
-      [Models.anthropic.Opus4_1]: {
-        input: 15.0,
-        cache_write: 18.75,
-        cache_hit: 1.5,
-        output: 75.0,
-      },
-      [Models.anthropic.Opus4]: {
-        input: 15.0,
-        cache_write: 18.75,
-        cache_hit: 1.5,
-        output: 75.0,
-      },
-      [Models.anthropic.Sonnet4]: {
-        input: 3.0,
-        input_gt_200k: 6.0,
-        cache_write: 3.75,
-        cache_hit: 0.3,
-        output: 15.0,
-        output_gt_200k: 22.5,
-      },
-      [Models.anthropic.Sonnet4_5]: {
-        input: 3.0,
-        input_gt_200k: 6.0,
-        cache_write: 3.75,
-        cache_hit: 0.3,
-        output: 15.0,
-        output_gt_200k: 22.5,
-      },
-      [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,
-        cache_hit: 0.3,
-        output: 15.0,
-      },
-      [Models.anthropic.Sonnet3_5]: {
-        input: 3.0,
-        cache_write: 3.75,
-        cache_hit: 0.3,
-        output: 15.0,
-      },
-      [Models.anthropic.Haiku3_5]: {
-        input: 0.8,
-        cache_write: 1.0,
-        cache_hit: 0.08,
-        output: 4.0,
-      },
-      [Models.anthropic.Opus3]: {
-        input: 15.0,
-        cache_write: 18.75,
-        cache_hit: 1.5,
-        output: 75.0,
-      },
-      [Models.anthropic.Haiku3]: {
-        input: 0.25,
-        cache_write: 0.3125,
-        cache_hit: 0.025,
-        output: 1.25,
-      },
-    };
+    return AnthropicTextPricing;
   }
 
   calculateCost(model: string, usage: Usage): number | undefined {
-    const p = this.pricesPerMillion()[model];
+    const rawP = this.pricesPerMillion()[model];
+    // Fall back to pricing file for unknown/newer models
+    const fallback = AnthropicTextPricing[model as keyof typeof AnthropicTextPricing];
+    const p: any = rawP || fallback || undefined;
     if (!p) return undefined;
 
     const inputTokens = usage.input_tokens ?? 0;
@@ -532,4 +476,30 @@ export class GenericAnthropicClient implements GenericClient {
   async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
     throw new Error("Provider does not support embeddings");
   }
+
+  async createAudioTranscription(
+    options: AudioTranscriptionOptions
+  ): Promise<AudioTranscriptionResponse> {
+    throw new Error("Anthropic does not support audio transcription");
+  }
+
+  async createAudioGeneration(
+    options: AudioGenerationOptions
+  ): Promise<AudioGenerationResponse> {
+    throw new Error("Anthropic does not support audio generation");
+  }
+
+  async createImageGeneration(
+    options: ImageGenerationOptions
+  ): Promise<ImageGenerationResponse> {
+    throw new Error("Anthropic does not support image generation");
+  }
+
+  async createVideoGeneration(
+    options: VideoGenerationOptions
+  ): Promise<VideoGenerationResponse> {
+    throw new Error(
+      "Video generation is not supported by the Anthropic provider."
+    );
+  }
 }