@tyvm/knowhow 0.0.36 → 0.0.37

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";
@@ -86,7 +86,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 +129,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

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,7 +47,6 @@ 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";
@@ -315,12 +313,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();

package/src/login.ts

@@ -5,8 +5,9 @@ import { chmod } from "fs/promises";
 import { ask } from "./utils";
 import { getConfig, updateConfig } from "./config";
 import { KNOWHOW_API_URL } from "./services/KnowhowClient";
+import { BrowserLoginService } from "./auth/browserLogin";
 
-export async function login(jwtFlag?: string): Promise<void> {
+export async function login(jwtFlag?: boolean): Promise<void> {
   if (!KNOWHOW_API_URL) {
     throw new Error("Error: KNOWHOW_API_URL environment variable not set.");
   }
@@ -24,6 +25,18 @@ export async function login(jwtFlag?: string): Promise<void> {
     fs.writeFileSync(jwtFile, jwt);
     fs.chmodSync(jwtFile, 0o600);
     console.log("JWT updated successfully.");
+  } else {
+    // Use browser login as default method
+    console.log("Starting browser-based authentication...");
+    try {
+      const browserLoginService = new BrowserLoginService();
+      await browserLoginService.login();
+      console.log("Successfully authenticated via browser!");
+    } catch (error) {
+      console.error("Browser authentication failed:", error.message);
+      console.log("You can try manual JWT login with: knowhow login --jwt");
+      throw error;
+    }
   }
 
   // Get current user/org information

package/src/microphone.ts

@@ -1,7 +1,6 @@
 import { exec } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
-import { openai } from "./ai";
 import { execAsync, ask } from "./utils";
 import { convertToText, convertAudioToText } from "./conversion";
 

package/src/plugins/downloader/downloader.ts

@@ -8,11 +8,12 @@ import { execAsync, fileExists, readFile, mkdir } from "../../utils";
 import OpenAI from "openai";
 import { Clients } from "../../clients";
 import { Models } from "../../types";
+import { openai } from "../../ai";
 
 const logger = Logger();
 
 export class DownloaderService {
-  constructor(private openAi: OpenAI, private clients: typeof Clients) {}
+  constructor(private clients: typeof Clients) {}
 
   async askGptVision(
     imageUrl: string,
@@ -131,6 +132,7 @@ export class DownloaderService {
     }
 
     const allTranscripts = [];
+    const openAi = openai();
     for (const file of files) {
       const chunkName = path.parse(file).name;
       const chunkTranscriptPath = path.join(
@@ -157,7 +159,7 @@ export class DownloaderService {
       }
 
       console.log("Transcribing", file);
-      const transcript = await this.openAi.audio.transcriptions
+      const transcript = await openAi.audio.transcriptions
         .create({
           file: fs.createReadStream(file),
           model: "whisper-1",

package/src/services/KnowhowClient.ts

@@ -128,6 +128,9 @@ export class KnowhowSimpleClient {
   getModels() {
     this.checkJwt();
     return axios.get(`${this.baseUrl}/api/proxy/v1/models`, {
+      params: {
+        type: 'all'
+      },
       headers: this.headers,
     });
   }

package/src/services/index.ts

@@ -1,4 +1,3 @@
-import { openai } from "../ai";
 import { DownloaderService } from "../plugins/downloader/downloader";
 import { Clients } from "../clients";
 import { Plugins } from "../plugins/plugins";
@@ -41,7 +40,7 @@ export const services = (): typeof Singletons => {
     const Tools = new ToolsService();
     const Events = new EventService();
     const Agents = new AgentService(Tools, Events);
-    const Downloader = new DownloaderService(openai, Clients);
+    const Downloader = new DownloaderService(Clients);
     Singletons = {
       Tools,
       Events,