@tyvm/knowhow 0.0.33 → 0.0.34

package/src/chat/modules/AskModule.ts

@@ -0,0 +1,98 @@
+/**
+ * Ask Chat Module - Handles basic AI question/answer functionality
+ */
+
+import { BaseChatModule } from "./BaseChatModule";
+import { ChatCommand, ChatMode, ChatContext } from "../types";
+import { ChatInteraction } from "../../types";
+import { Models } from "../../ai";
+import { services } from "../../services/index";
+import { Plugins } from "../../plugins/plugins";
+import { Marked } from "../../utils/index";
+import { formatChatInput } from "../../chat";
+
+export class AskModule extends BaseChatModule {
+  name = "ask";
+  description = "Basic AI question/answer functionality";
+
+  getCommands(): ChatCommand[] {
+    return [
+      // AskModule provides chat functionality, commands are handled by SystemModule
+    ];
+  }
+
+  getModes(): ChatMode[] {
+    return [
+      {
+        name: "chat",
+        description: "Basic AI chat mode",
+        active: true,
+      },
+    ];
+  }
+
+  async handleInput(input: string, context: ChatContext): Promise<boolean> {
+    // AskModule is the default handler - it handles input when no other module does
+    // Skip if in agent mode (let AgentModule handle it)
+    if (context.mode === "agent") {
+      return false;
+    }
+
+    // This is the default handler for all non-command input
+    return await this.processAIQuery(input, context);
+  }
+
+  /**
+   * Process AI query with full chat functionality (like original chat.ts)
+   */
+  public async processAIQuery(
+    input: string,
+    context: ChatContext
+  ): Promise<boolean> {
+    try {
+      const { Clients } = services();
+      const provider = context.currentProvider || "openai";
+      const model = context.currentModel || Models.openai.GPT_4o;
+
+      // Format the input with plugin context and chat history like original chat.ts
+      const formattedPrompt = await formatChatInput(
+        input,
+        context.plugins || [],
+        context.chatHistory || []
+      );
+
+      // Get AI response using the same pattern as original chat.ts
+      const response = await Clients.createCompletion(provider, {
+        messages: [
+          {
+            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: formattedPrompt },
+        ],
+        model,
+      });
+
+      const result =
+        response.choices[0].message.content || "No response from the AI";
+
+      // Create interaction with proper ChatInteraction structure (input/output)
+      const interaction: ChatInteraction = {
+        input,
+        output: result,
+      } as ChatInteraction;
+
+      context.chatHistory?.push(interaction);
+
+      // Display the result using Marked parser like in original chat.ts
+      console.log(Marked.parse(result));
+
+      return true;
+    } catch (error) {
+      console.error("Error getting AI response:", error);
+      console.log("Failed to get AI response. Please try again.");
+      return false;
+    }
+  }
+}

package/src/chat/modules/BaseChatModule.ts

@@ -0,0 +1,66 @@
+/**
+ * Base Chat Module - Abstract base class for all chat modules
+ */
+
+import {
+  ChatModule,
+  ChatService,
+  ChatCommand,
+  ChatMode,
+  ChatContext,
+} from "../types";
+
+export abstract class BaseChatModule implements ChatModule {
+  public abstract name: string;
+  public abstract description: string;
+  public commands: ChatCommand[] = [];
+  public modes: ChatMode[] = [];
+
+  protected chatService!: ChatService;
+
+  async initialize(service: ChatService): Promise<void> {
+    this.chatService = service;
+    this.commands = this.getCommands();
+    this.modes = this.getModes();
+
+    // Register all commands with the ChatService
+    for (const command of this.commands) {
+      this.chatService.registerCommand(command);
+    }
+  }
+
+  /**
+   * Override this method to provide commands
+   */
+  public getCommands(): ChatCommand[] {
+    return [];
+  }
+
+  /**
+   * Override this method to provide modes
+   */
+  public getModes(): ChatMode[] {
+    return [];
+  }
+
+  /**
+   * Override this method to handle non-command input
+   */
+  async handleInput(input: string, context: ChatContext): Promise<boolean> {
+    return false; // Default: don't handle input
+  }
+
+  /**
+   * Override this method for cleanup
+   */
+  async cleanup(): Promise<void> {
+    // Default: no cleanup needed
+  }
+
+  /**
+   * Helper method to update context
+   */
+  protected updateContext(updates: Partial<ChatContext>): void {
+    this.chatService.setContext(updates);
+  }
+}

package/src/chat/modules/InternalChatModule.ts

@@ -0,0 +1,174 @@
+import { ChatModule } from "../types";
+import { CliChatService } from "../CliChatService";
+import { AgentModule } from "./AgentModule";
+import { ChatCommand, ChatMode, ChatContext } from "../types";
+import { AskModule } from "./AskModule";
+import { SearchModule } from "./SearchModule";
+import { VoiceModule } from "./VoiceModule";
+import { SystemModule } from "./SystemModule";
+import { SetupModule } from "./SetupModule";
+
+export class InternalChatModule implements ChatModule {
+  private chatService?: CliChatService;
+  name = "internal";
+  description = "Internal chat module aggregating all functionality";
+  commands: ChatCommand[] = [];
+  modes: ChatMode[] = [];
+  private agentModule = new AgentModule();
+  private askModule = new AskModule();
+  private searchModule = new SearchModule();
+  private voiceModule = new VoiceModule();
+  private systemModule = new SystemModule();
+  private setupModule = new SetupModule();
+
+  async initialize(chatService: CliChatService): Promise<void> {
+    this.chatService = chatService;
+
+    // Register this module first so it gets called for input handling
+    chatService.registerModule(this);
+
+    // Initialize all sub-modules
+    await this.agentModule.initialize(chatService);
+    await this.askModule.initialize(chatService);
+    await this.searchModule.initialize(chatService);
+    await this.voiceModule.initialize(chatService);
+    await this.systemModule.initialize(chatService);
+    await this.setupModule.initialize(chatService);
+
+    // Register our own commands (exit and multi) - not duplicated by BaseChatModule
+    chatService.registerCommand({
+      name: "exit",
+      description: "Exit the chat",
+      handler: this.handleExitCommand.bind(this),
+    });
+
+    chatService.registerCommand({
+      name: "multi",
+      description: "Toggle multiline mode",
+      handler: this.handleMultiCommand.bind(this),
+    });
+
+
+    for (const mode of this.getModes()) {
+      chatService.registerMode(mode);
+    }
+  }
+
+  getCommands(): ChatCommand[] {
+    const commands: ChatCommand[] = [
+      ...this.agentModule.getCommands(),
+      ...this.askModule.getCommands(),
+      ...this.searchModule.getCommands(),
+      ...this.voiceModule.getCommands(),
+      ...this.systemModule.getCommands(),
+      ...this.setupModule.getCommands(),
+      {
+        name: "exit",
+        description: "Exit the chat",
+        handler: this.handleExitCommand.bind(this),
+      },
+      {
+        name: "multi",
+        description: "Toggle multiline mode",
+        handler: this.handleMultiCommand.bind(this),
+      },
+    ];
+    return commands;
+  }
+
+  getModes(): ChatMode[] {
+    return [
+      ...this.agentModule.getModes(),
+      ...this.askModule.getModes(),
+      ...this.searchModule.getModes(),
+      ...this.voiceModule.getModes(),
+      ...this.systemModule.getModes(),
+      ...this.setupModule.getModes(),
+    ];
+  }
+
+  async handleExitCommand(args: string[]): Promise<void> {
+    console.log("Goodbye!");
+    process.exit(0);
+  }
+
+  async handleMultiCommand(args: string[]): Promise<void> {
+    const context = this.chatService?.getContext();
+    const newMultiMode = !context?.multilineMode;
+    this.chatService?.setContext({ multilineMode: newMultiMode });
+    console.log(`Multiline mode: ${newMultiMode ? "enabled" : "disabled"}`);
+  }
+
+  /**
+   * Check if input matches a known command without prefix and suggest using the prefix
+   */
+  private checkForFuzzyCommand(input: string): boolean {
+    if (!this.chatService) return false;
+
+    const trimmedInput = input.toLowerCase().trim();
+    const availableCommands = this.chatService.getCommands();
+
+    // Check if the input matches any command name exactly (case-insensitive)
+    const matchingCommand = availableCommands.find(
+      (cmd) =>
+        cmd.name.toLowerCase() === trimmedInput ||
+        trimmedInput.startsWith(cmd.name.toLowerCase() + " ")
+    );
+
+    if (matchingCommand) {
+      console.log(
+        `Did you mean "/${matchingCommand.name}"? Commands must start with "/"`
+      );
+      console.log(
+        `Available commands: ${availableCommands
+          .map((cmd) => `/${cmd.name}`)
+          .join(", ")}`
+      );
+      return true;
+    }
+
+    return false;
+  }
+
+  async handleInput(input: string, context: ChatContext): Promise<boolean> {
+    // Check for fuzzy command matches first to prevent agent calls
+    // This prevents accidental agent calls when user types commands without "/"
+    if (this.checkForFuzzyCommand(input)) {
+      return true; // Command suggestion shown, input handled
+    }
+
+    // If in agent mode, check if this looks like a command before calling agent
+    if (
+      context.agentMode &&
+      input
+        .toLowerCase()
+        .match(
+          /^(multi|agent|ask|search|voice|system|exit|setup|help|clear)(\s|$)/i
+        )
+    ) {
+      return this.checkForFuzzyCommand(input); // Will show suggestion and return true
+    }
+
+    // Try agent module first (handles agent mode)
+    if (await this.agentModule.handleInput(input, context)) {
+      return true;
+    }
+
+    // Try search module
+    if (await this.searchModule.handleInput(input, context)) {
+      return true;
+    }
+
+    // Try voice module
+    if (await this.voiceModule.handleInput(input, context)) {
+      return true;
+    }
+
+    // Default to ask module (handles all non-command input when not in agent mode)
+    return await this.askModule.handleInput(input, context);
+  }
+
+  async cleanup(): Promise<void> {
+    // No cleanup needed
+  }
+}

package/src/chat/modules/SearchModule.ts

@@ -0,0 +1,166 @@
+import { BaseChatModule } from "./BaseChatModule";
+import { ChatContext, ChatCommand } from "../types";
+import { getConfiguredEmbeddingMap, queryEmbedding } from "../../embeddings";
+import { getConfig } from "../../config";
+import { ask } from "../../utils";
+import { marked } from "marked";
+
+export class SearchModule extends BaseChatModule {
+  name = "Search";
+  description = "Search through embeddings for relevant information";
+
+  getCommands(): ChatCommand[] {
+    return [
+      {
+        name: "search",
+        description: "Search embeddings",
+        handler: this.handleSearchCommand.bind(this),
+      },
+    ];
+  }
+
+  async handleSearchCommand(args: string[]): Promise<void> {
+    await this.askEmbedding("searching");
+  }
+
+  async executeCommand(command: string, context: ChatContext): Promise<void> {
+    if (command === "search") {
+      await this.askEmbedding("searching");
+    }
+  }
+
+  async askEmbedding(promptText: string) {
+    const options = ["next", "exit", "embeddings", "use"];
+    console.log(`Commands: ${options.join(", ")}`);
+    let input = await ask(promptText + ": ", options);
+    let answer: any | undefined;
+    let results = new Array<any>();
+    let embedMap = await getConfiguredEmbeddingMap();
+    const config = await getConfig();
+    const files = Object.keys(embedMap);
+
+    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)
+          )
+        );
+      }
+
+      input = await ask(promptText + ": ");
+    }
+  }
+
+  /**
+   * Search embeddings for CLI usage
+   */
+  public async searchEmbeddingsCLI(
+    query: string,
+    embeddingPath?: string
+  ): Promise<void> {
+    try {
+      const config = await getConfig();
+      let embedMap = await getConfiguredEmbeddingMap();
+
+      console.log(`🔍 Searching embeddings for: "${query}"`);
+      console.log(`📂 Embedding scope: ${embeddingPath || "all"}`);
+      console.log("─".repeat(50));
+
+      // If specific embedding path is requested, filter to that one
+      if (embeddingPath && embeddingPath !== "all") {
+        if (embedMap[embeddingPath]) {
+          embedMap = { [embeddingPath]: embedMap[embeddingPath] };
+        } else {
+          console.log("No results found.");
+          return;
+        }
+      }
+
+      const embeddings = Object.values(embedMap).flat();
+
+      const results = await queryEmbedding(
+        query,
+        embeddings,
+        config.embeddingModel
+      );
+
+      if (results && results.length > 0) {
+        results.slice(0, 5).forEach((result, index) => {
+          const metadata = result.metadata as any;
+          console.log(`\n${index + 1}. ${result.id}`);
+          console.log(
+            `   Metadata: ${JSON.stringify(
+              result.metadata || {},
+              null,
+              2
+            ).slice(0, 100)}`
+          );
+          console.log(
+            `Content: \n${result.text?.substring(0, 500)}${
+              result.text?.length > 500 ? "..." : ""
+            }`
+          );
+        });
+      } else {
+        console.log("No results found.");
+      }
+    } catch (error) {
+      console.error("Error searching embeddings:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Show embedding selection menu
+   */
+  private async showEmbeddingSelectionMenu(): Promise<string[]> {
+    const embedMap = await getConfiguredEmbeddingMap();
+    const files = Object.keys(embedMap);
+    const searchOptions = ["all", ...files];
+
+    console.log("Available embeddings:");
+    searchOptions.forEach((option, index) => {
+      console.log(`  ${index + 1}. ${option}`);
+    });
+
+    const embeddingName = await ask("Embedding to search: ", searchOptions);
+
+    return embeddingName === "all" ? files : [embeddingName];
+  }
+}

package/src/chat/modules/SetupModule.ts

@@ -0,0 +1,185 @@
+import { services } from "../../services";
+import { login } from "../../login";
+import { ask } from "../../utils";
+import { CliChatService } from "../CliChatService";
+import { ChatCommand, ChatMode } from "../types";
+import { AgentModule } from "./AgentModule";
+import { BaseChatModule } from "./BaseChatModule";
+
+export class SetupModule extends BaseChatModule {
+  name = "setup";
+  description = "Setup commands";
+  private agentModule?: AgentModule;
+
+  getCommands(): ChatCommand[] {
+    return [
+      {
+        name: "setup",
+        description: "Check environment setup and run Setup agent",
+        handler: this.handleSetupCommand.bind(this),
+      },
+    ];
+  }
+
+  getModes(): ChatMode[] {
+    return [];
+  }
+
+  async initialize(chatService: CliChatService): Promise<void> {
+    await super.initialize(chatService);
+    // We'll need access to AgentModule for launching Setup agent
+    this.agentModule = new AgentModule();
+    await this.agentModule.initialize(chatService);
+  }
+
+  /**
+   * Check environment variables and show setup status
+   */
+  private async checkEnvironmentSetup(): Promise<{
+    available: string[];
+    missing: string[];
+    setupNeeded: boolean;
+  }> {
+    const envCheck = (varName: string): boolean => {
+      return !!process.env[varName];
+    };
+
+    const envChecks = [
+      {
+        name: "OpenAI",
+        vars: ["OPENAI_KEY"],
+        feature: "OpenAI models (GPT-4o, etc.)",
+      },
+      {
+        name: "Anthropic",
+        vars: ["ANTHROPIC_API_KEY"],
+        feature: "Claude models",
+      },
+      { name: "Google", vars: ["GEMINI_API_KEY"], feature: "Gemini models" },
+      { name: "XAI", vars: ["XAI_API_KEY"], feature: "Grok models" },
+      {
+        name: "GitHub",
+        vars: ["GITHUB_TOKEN"],
+        feature: "GitHub integration (PRs, issues, repos)",
+      },
+      {
+        name: "Linear",
+        vars: ["LINEAR_API_KEY"],
+        feature: "Linear integration",
+      },
+      {
+        name: "Asana",
+        vars: ["ASANA_ACCESS_TOKEN"],
+        feature: "Asana integration",
+      },
+      {
+        name: "Jira",
+        vars: ["JIRA_HOST", "JIRA_USER", "JIRA_PASSWORD"],
+        feature: "Jira integration",
+      },
+      { name: "Notion", vars: ["NOTION_TOKEN"], feature: "Notion integration" },
+      {
+        name: "Google Search",
+        vars: ["GOOGLE_SEARCH_API_KEY"],
+        feature: "Google Search",
+      },
+    ];
+
+    const available: string[] = [];
+    const missing: string[] = [];
+
+    for (const check of envChecks) {
+      const missingEnv = check.vars.filter((varName) => !process.env[varName]);
+      if (!missingEnv.length) {
+        available.push(`✅ ${check.name}: ${check.feature}`);
+      } else {
+        missing.push(
+          `❌ ${check.name}: ${check.feature} (missing: ${missingEnv.join(
+            " and "
+          )})`
+        );
+      }
+    }
+
+    const canLogin = await this.checkKnowhowLogin();
+    if (canLogin) {
+      available.push("✅ Knowhow: Logged in successfully");
+    } else {
+      missing.push("❌ Knowhow: Not logged in");
+    }
+
+    const models = await this.canGetKnowhowModels();
+    if (models && models.length > 0) {
+      available.push(
+        `✅ Knowhow: ${models.length} Models available: ${models
+          .slice(0, 3)
+          .join(", ")}...`
+      );
+    } else {
+      missing.push("❌ Knowhow: No models available");
+    }
+
+    return { available, missing, setupNeeded: missing.length > 0 };
+  }
+
+  async checkKnowhowLogin(): Promise<boolean> {
+    try {
+      const canLogin = await login();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async canGetKnowhowModels() {
+    const { Clients } = services();
+    const models = await Clients.loadProviderModels("knowhow");
+    return Clients.getRegisteredModels("knowhow");
+  }
+
+  async handleSetupCommand(args: string[]): Promise<void> {
+    console.log("\n🔧 Knowhow Environment Setup Status\n");
+
+    const { available, missing, setupNeeded } =
+      await this.checkEnvironmentSetup();
+
+    console.log("📋 Available Features:");
+    available.forEach((item) => console.log(`  ${item}`));
+
+    if (missing.length > 0) {
+      console.log("\n⚠️  Missing Features:");
+      missing.forEach((item) => console.log(`  ${item}`));
+    }
+
+    if (setupNeeded) {
+      console.log(
+        "\n💡 To enable missing features, set the required environment variables."
+      );
+
+      const proceedSetup = await ask(
+        "\nWould you like me to help you set up your configuration? (y/n): ",
+        ["y", "n"]
+      );
+
+      if (
+        proceedSetup.toLowerCase() === "y" ||
+        proceedSetup.toLowerCase() === "yes"
+      ) {
+        // Launch Setup agent to guide user through configuration
+        if (this.agentModule) {
+          const { taskId, agent } = await this.agentModule.setupAgent({
+            agentName: "Setup",
+            run: true,
+            input:
+              "Help me set up my Knowhow configuration with the missing features and optimize my setup.",
+          });
+          await this.agentModule.attachedAgentChatLoop(taskId, agent);
+        }
+      }
+    } else {
+      console.log(
+        "\n🎉 Great! All major features are available. Your setup looks good!"
+      );
+    }
+  }
+}