@tyvm/knowhow 0.0.36 → 0.0.38

package/src/chat.ts

@@ -1,447 +1,62 @@
-import { ChatCompletionMessageParam } from "openai/resources/chat";
-import Ora from "ora";
-import editor from "@inquirer/editor";
-import { openai } from "./ai";
-import { cosineSimilarity } from "./utils";
-import {
-  EmbeddingBase,
-  GptQuestionEmbedding,
-  Embeddable,
-  ChatInteraction,
-} from "./types";
-import { Marked } from "./utils";
-import { ask } from "./utils";
-import { Plugins } from "./plugins/plugins";
-import { queryEmbedding, getConfiguredEmbeddingMap } from "./embeddings";
-import { services } from "./services/";
-import { FlagsService } from "./services/flags";
-import { IAgent } from "./agents/interface";
-import { Message } from "./clients";
-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";
-import { CustomVariables, XmlToolCallProcessor, HarmonyToolProcessor } from "./processors";
+#!/usr/bin/env node
 
-enum ChatFlags {
-  agent = "agent",
-  agents = "agents",
-  debug = "debug",
-  multi = "multi",
-  model = "model",
-  search = "search",
-  clear = "clear",
-  provider = "provider",
-  voice = "voice",
-}
-
-const Flags = new FlagsService(
-  [ChatFlags.agent, ChatFlags.debug, ChatFlags.multi, ChatFlags.voice],
-  true
-);
-
-const taskRegistry = new Map<string, BaseAgent>();
+/**
+ * New Modular Chat Interface - Simplified and cleaner than original chat.ts
+ */
 
-export async function askEmbedding<E>(promptText: string) {
-  const options = ["next", "exit", "embeddings", "use"];
-  console.log(`Commands: ${options.join(", ")}`);
-  let input = await ask(promptText + ": ", options);
-  let answer: EmbeddingBase<any> | undefined;
-  let results = new Array<EmbeddingBase>();
-  let embedMap = await getConfiguredEmbeddingMap();
-  const config = await getConfig();
-  const files = Object.keys(embedMap);
+import { CliChatService } from "./chat/CliChatService.js";
+import { InternalChatModule } from "./chat/modules/InternalChatModule.js";
+import { getConfig } from "./config.js";
 
-  while (input !== "exit") {
-    const embeddings = Object.values(embedMap).flat();
-
-    switch (input) {
-      case "next":
-        answer = results.shift();
-        break;
-      case "embeddings":
-        console.log(files);
-        break;
-      case "use":
-        const searchOptions = ["all", ...files];
-        console.log(searchOptions);
-        const embeddingName = await ask("Embedding to search: ", searchOptions);
-        if (embeddingName === "all") {
-          embedMap = await getConfiguredEmbeddingMap();
-          break;
-        }
-
-        embedMap = { ...{ [embeddingName]: embedMap[embeddingName] } };
-        break;
-      default:
-        results = await queryEmbedding(
-          input,
-          embeddings,
-          config.embeddingModel
-        );
-        answer = results.shift();
-        break;
-    }
-    if (answer) {
-      console.log(
-        Marked.parse(
-          "### TEXT \n" +
-            answer.text +
-            "\n### METADATA \n" +
-            JSON.stringify(answer.metadata, null, 2)
-        )
+async function main() {
+  try {
+    // Load configuration and plugins
+    let config;
+    try {
+      config = await getConfig();
+    } catch (configError) {
+      console.warn(
+        "Warning: Could not load config, using default plugins:",
+        configError
       );
+      config = {
+        plugins: [
+          "embeddings",
+          "language",
+          "vim",
+          "github",
+          "asana",
+          "jira",
+          "linear",
+          "download",
+          "figma",
+          "url",
+        ],
+      };
     }
 
-    input = await ask(promptText + ": ");
-  }
-}
-
-const ChatModelDefaults = {
-  openai: Models.openai.GPT_4o,
-  anthropic: Models.anthropic.Sonnet4,
-  google: Models.google.Gemini_25_Flash_Preview,
-  xai: Models.xai.Grok3Beta,
-};
-export async function askAI<E extends EmbeddingBase>(
-  query: string,
-  provider = "openai",
-  model = ChatModelDefaults[provider]
-) {
-  const gptPrompt = `
+    // Create chat service with plugins
+    const chatService = new CliChatService(config.plugins);
 
-The user has asked:
-  ${query}
+    // Load internal chat module (includes all core functionality)
+    const internalModule = new InternalChatModule();
+    await internalModule.initialize(chatService);
 
-  Output Format in Markdown
-`;
-  if (Flags.enabled("debugger")) {
-    console.log(gptPrompt);
+    // Start the chat loop
+    await chatService.startChatLoop();
+  } catch (error) {
+    console.error("Error starting chat:", error);
+    process.exit(1);
   }
-
-  const thread = [
-    {
-      role: "system",
-      content:
-        "Helpful Codebase assistant. Answer users questions using the embedding data that is provided with the user's question. You have limited access to the codebase based off of how similar the codebase is to the user's question. You may reference file paths by using the IDs present in the embedding data, but be sure to remove the chunk from the end of the filepaths.",
-    },
-    { role: "user", content: gptPrompt },
-  ] as Message[];
-
-  const { Clients } = services();
-  const response = await Clients.createCompletion(provider, {
-    messages: thread,
-    model,
-  });
-
-  return response.choices[0].message.content;
-}
-
-export async function getInput(
-  question: string,
-  options = [],
-  chatHistory: ChatInteraction[] = []
-): Promise<string> {
-  const multiLine = Flags.enabled(ChatFlags.multi);
-  const voice = Flags.enabled(ChatFlags.voice);
-
-  let value = "";
-  if (voice) {
-    value = await voiceToText();
-  } else if (multiLine) {
-    value = await editor({ message: question });
-    Flags.disable(ChatFlags.multi);
-  } else {
-    const history = chatHistory.map((c) => c.input).reverse();
-    value = await ask(question, options, history);
-  }
-
-  return value.trim();
 }
 
-export async function formatChatInput(
-  input: string,
-  plugins: string[] = [],
-  chatHistory: ChatInteraction[] = []
-) {
-  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:
-  ${JSON.stringify(chatHistory)}
-    </PreviousChats>`;
-  const fullPrompt = `
-    ${historyMessage} \n
-    <PluginContext> ${pluginText} </PluginContext>
-    <CurrentTask>${input}</CurrentTask>
-  `;
-  return fullPrompt;
-}
-
-export async function chatLoop<E extends GptQuestionEmbedding>(
-  aiName: string,
-  embeddings: Embeddable<E>[],
-  plugins: string[] = []
-) {
-  const { Agents, Clients } = services();
-  let activeAgent = Agents.getAgent("Developer") as BaseAgent;
-  let provider = "openai" as keyof typeof Clients.clients;
-  let model = ChatModelDefaults[provider];
-  const providers = Object.keys(Clients.clients);
-  const commands = [
-    "agent",
-    "agents",
-    "clear",
-    "debugger",
-    "exit",
-    "model",
-    "multi",
-    "provider",
-    "search",
-    "voice",
-  ];
-  console.log("Commands: ", commands.join(", "));
-  const promptText = () =>
-    Flags.enabled(ChatFlags.agent)
-      ? `\nAsk ${aiName} ${activeAgent.name}: `
-      : `\nAsk ${aiName}: `;
-
-  let chatHistory = new Array<ChatInteraction>();
-  let input = await getInput(promptText(), commands, chatHistory);
-
-  let results = "";
-  while (input !== "exit") {
-    try {
-      switch (input) {
-        case ChatFlags.agents:
-          Flags.enable(ChatFlags.agent);
-          const agents = Agents.listAgents();
-          console.log(agents);
-          const selected = await ask(
-            "Which agent would you like to use: ",
-            agents
-          );
-          activeAgent = Agents.getAgent(selected) as BaseAgent;
-          model = activeAgent.getModel();
-          provider = activeAgent.getProvider() as keyof typeof Clients.clients;
-          break;
-        case ChatFlags.agent:
-          Flags.flip(ChatFlags.agent);
-          break;
-        case ChatFlags.debug:
-          Flags.flip(ChatFlags.debug);
-          break;
-        case ChatFlags.multi:
-          Flags.flip(ChatFlags.multi);
-          break;
-        case ChatFlags.voice:
-          Flags.flip(ChatFlags.voice);
-          break;
-        case ChatFlags.search:
-          await askEmbedding("searching");
-          break;
-        case ChatFlags.clear:
-          chatHistory = [];
-          break;
-        case ChatFlags.provider:
-          console.log(providers);
-          provider = await ask(
-            `\n\nCurrent Provider: ${provider}\nCurrent Model: ${model}\n\nWhich provider would you like to use: `,
-            providers
-          );
-          model =
-            ChatModelDefaults[provider] ||
-            (await Clients.getRegisteredModels(provider))[0];
-
-          if (Flags.enabled("agent")) {
-            activeAgent.setProvider(provider);
-            activeAgent.setModel(model);
-          }
-
-          break;
-        case ChatFlags.model:
-          const models = Clients.getRegisteredModels(provider);
-          console.log(models);
-          const selectedModel = await ask(
-            `\n\nCurrent Provider: ${provider}\nCurrent Model: ${model}\n\nWhich model would you like to use: `,
-            models
-          );
-          model = selectedModel;
+// Check if this file is being run directly
+const isMainModule =
+  (process.argv[1] && process.argv[1].endsWith("chat2.ts")) ||
+  (process.argv[1] && process.argv[1].endsWith("chat2.js"));
 
-          if (Flags.enabled("agent")) {
-            activeAgent.setProvider(provider);
-            activeAgent.setModel(model);
-          }
-          break;
-        case "attach":
-          if (taskRegistry.size > 0) {
-            const options = Array.from(taskRegistry.keys());
-            const selectedInitialMessage = await ask(
-              "Select an agent to attach to:",
-              options
-            );
-            activeAgent = taskRegistry.get(selectedInitialMessage)!;
-            console.log(
-              `Attached to agent with task: "${selectedInitialMessage}"`
-            );
-            await startAgent(activeAgent, null, true);
-          } else {
-            console.log("No detached agents available.");
-          }
-        case "":
-          break;
-        default:
-          console.log("Thinking...");
-          console.log(input);
-          const interaction = {
-            input,
-            output: "",
-          } as ChatInteraction;
-          if (Flags.enabled("agent")) {
-            taskRegistry.set(input, activeAgent);
-            await startAgent(activeAgent, {
-              initialInput: input,
-              plugins,
-              chatHistory,
-              interaction,
-            });
-          } else {
-            const formattedPrompt = await formatChatInput(
-              input,
-              plugins,
-              chatHistory
-            );
-            results = await askAI(formattedPrompt, provider, model);
-            interaction.output = results;
-            console.log(Marked.parse(results || "No response from the AI"));
-          }
-          console.log("\n\n");
-          chatHistory.push(interaction);
-          break;
-      }
-    } catch (e) {
-      console.log(e);
-    } finally {
-      input = await getInput(promptText(), commands, chatHistory);
-    }
-  }
+if (isMainModule) {
+  main().catch(console.error);
 }
 
-export async function startAgent(
-  activeAgent: BaseAgent,
-  newTask?: {
-    initialInput: string;
-    plugins: string[];
-    chatHistory: ChatInteraction[];
-    interaction: ChatInteraction;
-  },
-  attach = false
-) {
-  let done = false;
-  let output = "Done";
-
-  if (newTask) {
-    const { initialInput, plugins, chatHistory, interaction } = newTask;
-    await activeAgent.newTask();
-    const formattedPrompt = await formatChatInput(
-      initialInput,
-      plugins,
-      chatHistory
-    );
-    activeAgent.call(formattedPrompt);
-
-    // Compress tokens of tool responses
-    activeAgent.messageProcessor.setProcessors("pre_call", [
-      new ToolResponseCache(activeAgent.tools).createProcessor(),
-
-      new TokenCompressor(activeAgent.tools).createProcessor((msg) =>
-        Boolean(msg.role === "tool" && msg.tool_call_id)
-      ),
-      new CustomVariables(activeAgent.tools).createProcessor(),
-    ]);
-
-    // Process XML and Harmony tool calls in assistant responses
-    activeAgent.messageProcessor.setProcessors("post_call", [
-      new XmlToolCallProcessor().createProcessor(),
-      new HarmonyToolProcessor().createProcessor(),
-    ]);
-
-    if (
-      !activeAgent.agentEvents.listenerCount(activeAgent.eventTypes.toolUsed)
-    ) {
-      activeAgent.agentEvents.on(
-        activeAgent.eventTypes.toolUsed,
-        (responseMsg) => {
-          console.log(` 🔨 Tool used: ${JSON.stringify(responseMsg, null, 2)}`);
-        }
-      );
-    }
-
-    activeAgent.agentEvents.once(activeAgent.eventTypes.done, (doneMsg) => {
-      console.log("Agent has finished.");
-      done = true;
-      taskRegistry.delete(initialInput);
-      output = doneMsg || "No response from the AI";
-      interaction.output = output;
-      console.log(Marked.parse(output));
-    });
-  }
-
-  // Define available commands
-  const commands = ["pause", "unpause", "kill", "detach"];
-  const history = [];
-
-  let input = await getInput(
-    `Enter command or message for ${activeAgent.name}: `,
-    commands,
-    history
-  );
-
-  history.push(input);
-
-  const donePromise = new Promise<string>((resolve) => {
-    activeAgent.agentEvents.on(activeAgent.eventTypes.done, () => {
-      done = true;
-      resolve("done");
-    });
-  });
-
-  while (!done) {
-    switch (input) {
-      case "":
-        break;
-      case "done":
-        output = "Exited agent interaction.";
-        break;
-      case "pause":
-        await activeAgent.pause();
-        console.log("Agent paused.");
-        break;
-      case "unpause":
-        await activeAgent.unpause();
-        console.log("Agent unpaused.");
-        break;
-      case "kill":
-        await activeAgent.kill();
-        console.log("Agent terminated.");
-        break;
-      case "detach":
-        return "Detached from agent";
-        break;
-      default:
-        activeAgent.addPendingUserMessage({ role: "user", content: input });
-    }
-
-    input = await Promise.race([
-      getInput(
-        `Enter command or message for ${activeAgent.name}: `,
-        commands,
-        history
-      ),
-      donePromise,
-    ]);
-  }
-
-  return output;
-}
+export { main as startChat };

package/src/cli.ts

@@ -4,7 +4,7 @@ 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 { generate, embed, upload } from "./index";
 import { init } from "./config";
 
 import { download, purge } from ".";
@@ -14,8 +14,8 @@ 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 { startChat } from "./chat";
+import { askAI } from "./chat-old";
 import { getConfiguredEmbeddingMap, queryEmbedding } from "./embeddings";
 import { getConfig } from "./config";
 import { marked } from "marked";
@@ -67,6 +67,7 @@ async function readStdin(): Promise<string> {
 async function main() {
   const program = new Command();
   const config = await getConfig();
+  const chatService = new CliChatService(config.plugins);
 
   program
     .name("knowhow")
@@ -86,7 +87,7 @@ async function main() {
   program
     .command("login")
     .description("Login to knowhow")
-    .option("--jwt", "should use JWT login", "true")
+    .option("--jwt", "Use manual JWT input instead of browser login")
     .action(async (opts) => {
       await login(opts.jwt);
     });
@@ -129,16 +130,9 @@ async function main() {
 
   program
     .command("chat")
-    .description("Start chat interface")
-    .action(async () => {
-      await chat();
-    });
-
-  program
-    .command("chat2")
     .description("Start new chat interface")
     .action(async () => {
-      await startChat2();
+      await startChat();
     });
 
   program
@@ -214,7 +208,9 @@ async function main() {
 
         input = readPromptFile(options.promptFile, input);
 
-        await new AskModule().processAIQuery(input, {
+        const askModule = new AskModule();
+        await askModule.initialize(chatService);
+        await askModule.processAIQuery(input, {
           plugins: config.plugins,
           currentModel: options.model,
           currentProvider: options.provider,
@@ -230,7 +226,6 @@ async function main() {
     .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([]);

package/src/clients/index.ts

@@ -158,9 +158,18 @@ export class AIClient {
       new Set(currentModels.concat(models))
     );
 
+    const embeddingModels = this.embeddingModels[provider] || [];
+    this.embeddingModels[provider] = Array.from<string>(
+      new Set(embeddingModels.concat(models.filter((m) => m.includes("embed"))))
+    );
+
     // We will assume if you register models, it's for completions
     this.completionModels[provider] = Array.from<string>(
-      new Set(currentCompletionModels.concat(models))
+      new Set(
+        currentCompletionModels.concat(
+          models.filter((m) => !m.includes("embed"))
+        )
+      )
     );
   }
 
@@ -200,15 +209,37 @@ export class AIClient {
 
   findModel(modelPrefix: string) {
     for (const provider of Object.keys(this.clientModels)) {
-      const models = this.clientModels[provider];
+      const models = this.clientModels[provider] as string[];
       const foundModel = models.find((m) => m.startsWith(modelPrefix));
       if (foundModel) {
         return { provider, model: foundModel };
       }
+
+      // Handle the case when model prefix is gpt-5 and the provider is knowhow, and the actual model is openai/gpt-5
+      const inferredFound = models.find((m) => {
+        const split = m.split("/");
+        if (split.length < 2) return false;
+        const inferredModel = split.slice(1).join("/");
+        return (
+          m === modelPrefix ||
+          inferredModel === modelPrefix ||
+          inferredModel.startsWith(modelPrefix)
+        );
+      });
+      if (inferredFound) {
+        return { provider, model: inferredFound };
+      }
     }
     return undefined;
   }
 
+  // detects these formats
+  // "openai", "gpt-5"
+  // "knowhow", "openai/gpt-5"
+  // "", "openai/gpt-5"
+  // "", openai/gpt-5
+  // "", "knowhow/openai/gpt-5"
+  //
   detectProviderModel(provider: string, model?: string) {
     if (this.providerHasModel(provider, model)) {
       return { provider, model };
@@ -237,6 +268,8 @@ export class AIClient {
       return foundByModel;
     }
 
+    console.log({ provider, model, all: this.listAllModels() });
+
     return { provider, model };
   }
 

package/src/embeddings.ts

@@ -17,7 +17,7 @@ import {
   cosineSimilarity,
   takeFirstNWords,
 } from "./utils";
-import { summarizeTexts, openai, chunkText } from "./ai";
+import { summarizeTexts, chunkText } from "./ai";
 import { Plugins } from "./plugins/plugins";
 import { md5Hash } from "./hashes";
 import { convertToText } from "./conversion";

package/src/index.ts

@@ -39,7 +39,6 @@ import {
 } from "./embeddings";
 
 import { abort } from "process";
-import { chatLoop } from "./chat";
 import { convertToText } from "./conversion";
 import { Plugins } from "./plugins/plugins";
 import { knowhowMcpClient } from "./services/Mcp";
@@ -48,11 +47,11 @@ import { Models } from "./types";
 
 export * as clients from "./clients";
 export * as agents from "./agents";
-export * as ai from "./ai";
 export * as services from "./services";
 export * as embeddings from "./embeddings";
 export * as types from "./types";
 export * as processors from "./processors";
+export * as ai from "./ai";
 
 export async function embed() {
   // load config
@@ -315,12 +314,6 @@ export async function handleSingleOutputGeneration(
   await saveAllFileHashes(filesToCheck, promptHash);
 }
 
-export async function chat() {
-  const config = await getConfig();
-  const embeddings = await getConfiguredEmbeddings();
-  await chatLoop("knowhow", embeddings, config.plugins);
-}
-
 export async function download() {
   const config = await getConfig();
   const { AwsS3, GitHub, knowhowApiClient } = services();