@tyvm/knowhow 0.0.33 → 0.0.34

package/src/cli.ts

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 import "source-map-support/register";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { Command } from "commander";
 import { generate, embed, upload, chat } from "./index";
 import { init } from "./config";
 
@@ -10,59 +14,284 @@ import { services } from "./services";
 import { login } from "./login";
 import { worker } from "./worker";
 import { agents } from "./agents";
+import { startChat2 } from "./chat2";
+import { askAI } from "./chat";
+import { getConfiguredEmbeddingMap, queryEmbedding } from "./embeddings";
+import { getConfig } from "./config";
+import { marked } from "marked";
+import { BaseAgent } from "./agents/base/base";
+import { AskModule } from "./chat/modules/AskModule";
+import { SearchModule } from "./chat/modules/SearchModule";
+import { AgentModule } from "./chat/modules/AgentModule";
+import { readPromptFile } from "./ai";
+import { SetupModule } from "./chat/modules/SetupModule";
+import { CliChatService } from "./chat/CliChatService";
 
-const command = process.argv[2];
-
-async function main() {
+async function setupServices() {
   const { Tools, Agents, Mcp, Clients } = services();
-  const { Researcher, Developer, Patcher } = agents();
+  const { Researcher, Developer, Patcher, Setup } = agents();
   Agents.registerAgent(Researcher);
   Agents.registerAgent(Patcher);
   Agents.registerAgent(Developer);
+  Agents.registerAgent(Setup);
   Agents.loadAgentsFromConfig(services());
 
   Tools.defineTools(includedTools, allTools);
 
-  await Mcp.connectToConfigured(Tools);
-  await Clients.registerConfiguredModels();
+  await Promise.all([
+    Mcp.connectToConfigured(Tools),
+    Clients.registerConfiguredModels(),
+  ]);
+}
+
+// Utility function to read from stdin
+async function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+
+    process.stdin.on("readable", () => {
+      const chunk = process.stdin.read();
+      if (chunk !== null) data += chunk;
+    });
+
+    process.stdin.on("end", () => resolve(data.trim()));
+  });
+}
+
+async function main() {
+  const program = new Command();
+  const config = await getConfig();
+
+  program
+    .name("knowhow")
+    .description("AI CLI with plugins and agents")
+    .version("0.0.33");
 
-  // VIMMER is disabled for now
-  // Agents.registerAgent(Vimmer);
+  // Initialize services for all commands
+  await setupServices();
 
-  switch (command) {
-    case "init":
+  program
+    .command("init")
+    .description("Initialize knowhow configuration")
+    .action(async () => {
       await init();
-      break;
-    case "login":
-      await login();
-      break;
-    case "generate":
+    });
+
+  program
+    .command("login")
+    .description("Login to knowhow")
+    .option("--jwt", "should use JWT login", "true")
+    .action(async (opts) => {
+      await login(opts.jwt);
+    });
+
+  program
+    .command("generate")
+    .description("Generate documentation")
+    .action(async () => {
       await generate();
-      break;
-    case "embed":
+    });
+
+  program
+    .command("embed")
+    .description("Create embeddings")
+    .action(async () => {
       await embed();
-      break;
-    case "embed:purge":
-      await purge(process.argv[3]);
-      break;
-    case "upload":
+    });
+
+  program
+    .command("embed:purge")
+    .description("Purge embeddings matching a glob pattern")
+    .argument("<pattern>", "Glob pattern to match files for purging")
+    .action(async (pattern) => {
+      await purge(pattern);
+    });
+
+  program
+    .command("upload")
+    .description("Upload data")
+    .action(async () => {
       await upload();
-      break;
-    case "download":
+    });
+
+  program
+    .command("download")
+    .description("Download data")
+    .action(async () => {
       await download();
-      break;
-    case "chat":
+    });
+
+  program
+    .command("chat")
+    .description("Start chat interface")
+    .action(async () => {
       await chat();
-      break;
-    case "worker":
+    });
+
+  program
+    .command("chat2")
+    .description("Start new chat interface")
+    .action(async () => {
+      await startChat2();
+    });
+
+  program
+    .command("agent")
+    .description("Spin up agents directly from CLI")
+    .option(
+      "--provider <provider>",
+      "AI provider (openai, anthropic, google, xai)",
+      "openai"
+    )
+    .option("--model <model>", "Specific model for the provider")
+    .option("--agent-name <name>", "Which agent to use", "Patcher")
+    .option(
+      "--max-time-limit <minutes>",
+      "Time limit for agent execution (minutes)",
+      "30"
+    )
+    .option(
+      "--max-spend-limit <dollars>",
+      "Cost limit for agent execution (dollars)",
+      "10"
+    )
+    .option("--message-id <messageId>", "Knowhow message ID for task tracking")
+    .option("--prompt-file <path>", "Custom prompt template file with {text}")
+    .option("--input <text>", "Task input (fallback to stdin if not provided)")
+    .action(async (options) => {
+      try {
+        let input = options.input;
+        if (!input) {
+          input = await readStdin();
+          if (!input) {
+            console.error(
+              "Error: No input provided. Use --input flag or pipe input via stdin."
+            );
+            process.exit(1);
+          }
+        }
+
+        input = readPromptFile(options.promptFile, input);
+        const { taskCompleted } = await new AgentModule().setupAgent({
+          ...options,
+          input,
+          maxTimeLimit: parseInt(options.maxTimeLimit, 10),
+          maxSpendLimit: parseFloat(options.maxSpendLimit),
+          run: true,
+        });
+        await taskCompleted;
+      } catch (error) {
+        console.error("Error running agent:", error);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("ask")
+    .description("Direct AI questioning without agent overhead")
+    .option("--provider <provider>", "AI provider to use", "openai")
+    .option("--model <model>", "Specific model")
+    .option("--input <text>", "Question (fallback to stdin if not provided)")
+    .option("--prompt-file <path>", "Custom prompt template file")
+    .action(async (options) => {
+      try {
+        let input = options.input;
+        if (!input) {
+          input = await readStdin();
+          if (!input) {
+            console.error(
+              "Error: No question provided. Use --input flag or pipe input via stdin."
+            );
+            process.exit(1);
+          }
+        }
+
+        input = readPromptFile(options.promptFile, input);
+
+        await new AskModule().processAIQuery(input, {
+          plugins: config.plugins,
+          currentModel: options.model,
+          currentProvider: options.provider,
+        });
+      } catch (error) {
+        console.error("Error asking AI:", error);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("setup")
+    .description("Ask the agent to configure knowhow")
+    .action(async (options) => {
+      try {
+        const chatService = new CliChatService(config.plugins);
+        const setupModule = new SetupModule();
+        await setupModule.initialize(chatService);
+        await setupModule.handleSetupCommand([]);
+      } catch (error) {
+        console.error("Error running agent:", error);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("search")
+    .description("Search embeddings directly from CLI")
+    .option(
+      "--input <text>",
+      "Search query (fallback to stdin if not provided)"
+    )
+    .option(
+      "-e, --embedding <path>",
+      "Specific embedding path (default: all)",
+      "all"
+    )
+    .action(async (options) => {
+      try {
+        let input = options.input;
+        if (!input) {
+          input = await readStdin();
+          if (!input) {
+            console.error(
+              "Error: No search query provided. Use --input flag or pipe input via stdin."
+            );
+            process.exit(1);
+          }
+        }
+
+        await new SearchModule().searchEmbeddingsCLI(input, options.embedding);
+      } catch (error) {
+        console.error("Error searching embeddings:", error);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("sessions")
+    .description("Manage agent sessions from CLI")
+    .action(async () => {
+      try {
+        await new AgentModule().logSessionTable();
+      } catch (error) {
+        console.error("Error listing sessions:", error);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("worker")
+    .description("Start worker process")
+    .action(async () => {
       await worker();
-      break;
-    default:
-      console.log(
-        "Unknown command. Please use one of the following: init, login, generate, embed, embed:purge, upload, download, chat"
-      );
-      break;
-  }
+    });
+
+  await program.parseAsync(process.argv);
 }
 
 if (require.main === module) {

package/src/clients/anthropic.ts

@@ -14,10 +14,18 @@ import {
 type MessageParam = Anthropic.MessageParam;
 type Usage = Anthropic.Usage;
 
-export class GenericAnthropicClient extends Anthropic implements GenericClient {
-  constructor() {
-    super({
-      apiKey: process.env.ANTHROPIC_API_KEY,
+export class GenericAnthropicClient implements GenericClient {
+  private client: Anthropic;
+  private apiKey?: string;
+
+  constructor(apiKey?: string) {
+    this.setKey(apiKey || process.env.ANTHROPIC_API_KEY || "");
+  }
+
+  setKey(apiKey: string) {
+    this.apiKey = apiKey;
+    this.client = new Anthropic({
+      apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
     });
   }
 
@@ -26,7 +34,6 @@ export class GenericAnthropicClient extends Anthropic implements GenericClient {
 
     if (lastTool) {
       lastTool.cache_control = { type: "ephemeral" };
-      console.log("caching last tool");
     }
   }
 
@@ -242,7 +249,7 @@ export class GenericAnthropicClient extends Anthropic implements GenericClient {
 
     const tools = this.transformTools(options.tools);
     try {
-      const response = await this.messages.create({
+      const response = await this.client.messages.create({
         model: options.model,
         messages: claudeMessages,
         system: systemMessage
@@ -382,7 +389,7 @@ export class GenericAnthropicClient extends Anthropic implements GenericClient {
   }
 
   async getModels() {
-    const models = await this.models.list();
+    const models = await this.client.models.list();
     return models.data.map((m) => ({
       id: m.id,
     }));

package/src/clients/gemini.ts

@@ -32,10 +32,18 @@ function getMimeTypeFromUrl(url: string): string {
   return "image/jpeg";
 }
 
-export class GenericGeminiClient extends GoogleGenAI implements GenericClient {
-  constructor() {
-    super({
-      apiKey: process.env.GEMINI_API_KEY,
+export class GenericGeminiClient implements GenericClient {
+  private client: GoogleGenAI;
+  private apiKey?: string;
+
+  constructor(apiKey?: string) {
+    this.setKey(apiKey || process.env.GEMINI_API_KEY || "");
+  }
+
+  setKey(apiKey: string) {
+    this.apiKey = apiKey;
+    this.client = new GoogleGenAI({
+      apiKey: apiKey || process.env.GEMINI_API_KEY,
     });
   }
 
@@ -250,7 +258,7 @@ export class GenericGeminiClient extends GoogleGenAI implements GenericClient {
 
     try {
       await wait(2000);
-      const response = await this.models.generateContent({
+      const response = await this.client.models.generateContent({
         model: options.model,
         contents,
         config: {
@@ -428,7 +436,7 @@ export class GenericGeminiClient extends GoogleGenAI implements GenericClient {
 
   async getModels() {
     try {
-      const models = await this.models.list();
+      const models = await this.client.models.list();
       return models.page.map((m) => ({
         id: m.name!,
       }));
@@ -446,7 +454,7 @@ export class GenericGeminiClient extends GoogleGenAI implements GenericClient {
     }
 
     try {
-      const googleEmbedding = await this.models.embedContent({
+      const googleEmbedding = await this.client.models.embedContent({
         model: options.model,
         contents: options.input,
       });

package/src/clients/http.ts

@@ -23,6 +23,10 @@ export class HttpClient implements GenericClient {
     this.baseUrl = baseUrl;
   }
 
+  setKey(key: string) {
+    this.setJwt(key);
+  }
+
   loadJwtFile(filePath: string) {
     try {
       const jwtFile = path.join(process.cwd(), filePath);
@@ -39,15 +43,21 @@ export class HttpClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    const body = {
+      ...options,
+      model: options.model,
+      messages: options.messages,
+      max_tokens: options.max_tokens || 3000,
+
+      ...(options.tools && {
+        tools: options.tools,
+        tool_choice: "auto",
+      }),
+    };
+
     const response = await axios.post(
       `${this.baseUrl}/v1/chat/completions`,
-      {
-        model: options.model,
-        messages: options.messages,
-        max_tokens: options.max_tokens,
-        tools: options.tools,
-        tool_choice: options.tool_choice,
-      },
+      body,
       {
         headers: this.headers,
       }

package/src/clients/index.ts

@@ -12,6 +12,8 @@ import { HttpClient } from "./http";
 import { EmbeddingModels, Models } from "../types";
 import { getConfig } from "../config";
 import { GenericXAIClient } from "./xai";
+import { KnowhowGenericClient } from "./knowhow";
+import { loadKnowhowJwt } from "../services/KnowhowClient";
 
 function envCheck(key: string): boolean {
   const value = process.env[key];
@@ -31,6 +33,7 @@ export class AIClient {
 
     ...(envCheck("GEMINI_API_KEY") && { google: new GenericGeminiClient() }),
     ...(envCheck("XAI_API_KEY") && { xai: new GenericXAIClient() }),
+    ...(loadKnowhowJwt() && { knowhow: new KnowhowGenericClient() }),
   };
 
   completionModels = {
@@ -101,6 +104,12 @@ export class AIClient {
     this.clients[provider] = client;
   }
 
+  setKey(provider: string, apiKey: string) {
+    const { client } = this.getClient(provider); // Ensure provider is registered
+    client.setKey(apiKey);
+    this.clients[provider].setKey(apiKey);
+  }
+
   async registerConfiguredModels() {
     const config = await getConfig();
     const modelProviders = config.modelProviders || [];
@@ -115,9 +124,7 @@ export class AIClient {
       this.registerClient(modelProvider.provider, client);
 
       try {
-        const models = await client.getModels();
-        const ids = models.map((model) => model.id);
-        this.registerModels(modelProvider.provider, ids);
+        await this.loadProviderModels(modelProvider.provider);
       } catch (error) {
         console.error(
           `Failed to register models for provider ${modelProvider.provider}:`,
@@ -127,6 +134,23 @@ export class AIClient {
     }
   }
 
+  async loadProviderModels(provider: string) {
+    if (!this.clients[provider]) {
+      throw new Error(`Provider ${provider} not registered.`);
+    }
+
+    try {
+      const models = await this.clients[provider].getModels();
+      const ids = models.map((model) => model.id);
+      this.registerModels(provider, ids);
+    } catch (error) {
+      console.error(
+        `Failed to load models for provider ${provider}:`,
+        error.message
+      );
+    }
+  }
+
   registerModels(provider: string, models: string[]) {
     const currentModels = this.clientModels[provider] || [];
     const currentCompletionModels = this.completionModels[provider] || [];
@@ -140,6 +164,21 @@ export class AIClient {
     );
   }
 
+  /*
+   * Some clients support multiple providers, most clients are single provider
+   * For the mult-provider clients, we register them with this method
+   * TODO: currently registering overwrites any existing providers, but a fallback list could be useful
+   */
+  registerClientProviderModels(
+    client: GenericClient,
+    providerModels: Record<string, string[]>
+  ) {
+    for (const [provider, models] of Object.entries(providerModels)) {
+      this.registerClient(provider, client);
+      this.registerModels(provider, models);
+    }
+  }
+
   registerEmbeddingModels(provider: string, models: string[]) {
     const currentModels = this.clientModels[provider] || [];
     const currentEmbeddingModels = this.embeddingModels[provider] || [];
@@ -175,7 +214,7 @@ export class AIClient {
       return { provider, model };
     }
 
-    if (model.includes("/")) {
+    if (model?.includes("/")) {
       const split = model.split("/");
 
       const inferredProvider = split[0];
@@ -206,6 +245,13 @@ export class AIClient {
     options: CompletionOptions
   ): Promise<CompletionResponse> {
     const { client, model } = this.getClient(provider, options.model);
+    if (!model || !client) {
+      throw new Error(
+        `provider: ${provider} does not have ${
+          options.model
+        } model registered. Try using ${JSON.stringify(this.listAllModels())}`
+      );
+    }
     return client.createChatCompletion({ ...options, model });
   }
 
@@ -214,6 +260,13 @@ export class AIClient {
     options: EmbeddingOptions
   ): Promise<EmbeddingResponse> {
     const { client, model } = this.getClient(provider, options.model);
+    if (!model || !client) {
+      throw new Error(
+        `provider: ${provider} does not have ${
+          options.model
+        } model registered. Try using ${JSON.stringify(this.listAllModels())}`
+      );
+    }
     return client.createEmbedding({ ...options, model });
   }
 
@@ -225,6 +278,65 @@ export class AIClient {
     return this.clientModels;
   }
 
+  listAllModelsWithProvider() {
+    return Object.entries(this.listAllModels())
+      .map(([provider, models]) =>
+        models.map((m) => ({ id: `${provider}/${m}` }))
+      )
+      .flat();
+  }
+
+  /*
+   *
+   * some clients return models in the format "provider/model_name"
+   * this function parses those models into our {provider, model} format
+   * then creates a provider -> [models] map
+   * the models will not have the provider prefix
+   *
+   * if the client doesn't return models in that format, use knownProvider
+   * to set the provider
+   */
+  async parseProviderPrefixedModels(
+    client: GenericClient,
+    knownProvider = ""
+  ): Promise<Record<string, string[]>> {
+    const models = await client.getModels();
+    const providerModels = models
+      .map((m) => {
+        if (knownProvider) {
+          return {
+            provider: knownProvider,
+            model: m.id,
+          };
+        }
+
+        const splitModel = m.id.split("/");
+
+        if (splitModel.length < 2) {
+          console.error(`Cannot parse model format: ${m.id}`);
+        }
+
+        const provider = splitModel.length > 1 ? splitModel[0] : "";
+        const modelName = splitModel.slice(1).join("/");
+        return {
+          provider,
+          model: modelName,
+        };
+      })
+      .reduce((acc, { provider, model }) => {
+        acc[provider] = acc[provider] || [];
+        acc[provider].push(model);
+        return acc;
+      }, {});
+
+    for (const provider in providerModels) {
+      if (!providerModels[provider].length) {
+        delete providerModels[provider];
+      }
+    }
+    return providerModels;
+  }
+
   listAllEmbeddingModels() {
     return this.embeddingModels;
   }
@@ -248,3 +360,4 @@ export * from "./anthropic";
 export * from "./knowhow";
 export * from "./gemini";
 export * from "./xai";
+export * from "./knowhowMcp";

package/src/clients/knowhow.ts

@@ -7,11 +7,16 @@ import {
 } from "./types";
 import { KnowhowSimpleClient } from "../services/KnowhowClient";
 
+const envUrl = process.env.KNOWHOW_API_URL;
 export class KnowhowGenericClient implements GenericClient {
   private client: KnowhowSimpleClient;
 
-  constructor(baseUrl: string, jwt?: string) {
-    this.client = new KnowhowSimpleClient(baseUrl, jwt);
+  constructor(private baseUrl = envUrl, jwt?: string) {
+    this.setKey(jwt);
+  }
+
+  setKey(jwt: string): void {
+    this.client = new KnowhowSimpleClient(this.baseUrl, jwt);
   }
 
   async createChatCompletion(