@tyvm/knowhow 0.0.158 → 0.0.160

package/src/chat/modules/AskModule.ts

@@ -1,98 +0,0 @@
-/**
- * Ask Chat Module - Handles basic AI question/answer functionality
- */
-
-import { BaseChatModule } from "./BaseChatModule";
-import { TraceAll } from "../../util/Trace";
-import { ChatCommand, ChatMode, ChatContext } from "../types";
-import { ChatInteraction } from "../../types";
-import { Models } from "../../ai";
-import { services } from "../../services/index";
-import { Marked } from "../../utils/index";
-
-@TraceAll()
-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;
-      const model = context.currentModel || Models.openai.GPT_4o;
-
-      // Format the input with plugin context and chat history like original chat.ts
-      const formattedPrompt = await this.chatService.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

@@ -1,65 +0,0 @@
-/**
- * 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/ClipboardImageModule.ts

@@ -1,136 +0,0 @@
-import { exec } from "child_process";
-import { promisify } from "util";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { ChatModule, ChatCommand, ChatMode, ChatContext } from "../types";
-import { CliChatService } from "../CliChatService";
-
-const execAsync = promisify(exec);
-
-/**
- * Attempts to capture an image from the system clipboard and save it to a temp file.
- * Returns the filepath if successful, or null if the clipboard has no image.
- */
-export async function captureClipboardImage(): Promise<string | null> {
-  const tmpFile = path.join(os.tmpdir(), `knowhow-clipboard-${Date.now()}.png`);
-
-  const platform = process.platform;
-
-  try {
-    if (platform === "darwin") {
-      // macOS: use pngpaste if available, fall back to osascript
-      try {
-        await execAsync(`pngpaste "${tmpFile}"`);
-        if (fs.existsSync(tmpFile)) return tmpFile;
-      } catch {
-        // pngpaste not available or no image in clipboard, try osascript
-        const script = `
-          tell application "System Events"
-            set theImage to the clipboard as «class PNGf»
-            set fileRef to open for access POSIX file "${tmpFile}" with write permission
-            write theImage to fileRef
-            close access fileRef
-          end tell
-        `;
-        try {
-          await execAsync(`osascript -e '${script.replace(/'/g, "'\\''")}'`);
-          if (fs.existsSync(tmpFile)) return tmpFile;
-        } catch {
-          return null;
-        }
-      }
-    } else if (platform === "linux") {
-      // Linux: try xclip first, then xsel
-      try {
-        await execAsync(`xclip -selection clipboard -t image/png -o > "${tmpFile}"`);
-        if (fs.existsSync(tmpFile) && fs.statSync(tmpFile).size > 0) return tmpFile;
-      } catch {
-        try {
-          await execAsync(`xsel --clipboard --output > "${tmpFile}"`);
-          if (fs.existsSync(tmpFile) && fs.statSync(tmpFile).size > 0) return tmpFile;
-        } catch {
-          return null;
-        }
-      }
-    } else if (platform === "win32") {
-      // Windows: use PowerShell
-      const ps = `
-        Add-Type -AssemblyName System.Windows.Forms
-        $img = [System.Windows.Forms.Clipboard]::GetImage()
-        if ($img -ne $null) {
-          $img.Save('${tmpFile.replace(/\\/g, "\\\\")}')
-          Write-Output 'saved'
-        } else {
-          Write-Output 'no image'
-        }
-      `;
-      const { stdout } = await execAsync(`powershell -Command "${ps.replace(/"/g, '\\"')}"`);
-      if (stdout.trim() === "saved" && fs.existsSync(tmpFile)) return tmpFile;
-    }
-  } catch {
-    // Silently fail - clipboard doesn't contain an image
-  }
-
-  // Clean up empty file if created
-  try {
-    if (fs.existsSync(tmpFile) && fs.statSync(tmpFile).size === 0) {
-      fs.unlinkSync(tmpFile);
-    }
-  } catch { /* ignore */ }
-
-  return null;
-}
-
-export class ClipboardImageModule implements ChatModule {
-  name = "clipboard-image";
-  description = "Handles clipboard image paste detection and capture";
-  commands: ChatCommand[] = [];
-  modes: ChatMode[] = [];
-
-  getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "paste",
-        description: "Capture image from clipboard and send to agent",
-        handler: this.handlePasteCommand.bind(this),
-      },
-    ];
-  }
-
-  getModes(): ChatMode[] {
-    return [];
-  }
-
-  async initialize(chatService: CliChatService): Promise<void> {
-    // Register /paste command
-    chatService.registerCommand({
-      name: "paste",
-      description: "Capture image from clipboard and send to agent",
-      handler: this.handlePasteCommand.bind(this),
-    });
-
-  }
-
-  private async handlePasteCommand(args: string[]): Promise<{ handled: boolean; contents?: string }> {
-    console.log("🔍 Checking clipboard for image...");
-    const filepath = await captureClipboardImage();
-
-    if (!filepath) {
-      console.log("No image found in clipboard. Copy an image first, then use /paste.");
-      return { handled: true };
-    }
-
-    console.log(`📋 Image captured: ${filepath}`);
-
-    // Return as not-handled so the filepath flows through to modules (AgentModule)
-    return { handled: false, contents: filepath };
-  }
-
-  async handleInput(input: string, context: ChatContext): Promise<boolean> {
-    return false; // This module only handles commands
-  }
-
-  async cleanup(): Promise<void> {
-  }
-}

package/src/chat/modules/CustomCommandsModule.ts

@@ -1,80 +0,0 @@
-import { BaseChatModule } from "./BaseChatModule";
-import { ChatCommand, ChatService, CommandResult } from "../types";
-import { getLanguageConfig } from "../../config";
-import { TraceAll } from "../../util/Trace";
-
-/**
- * CustomCommandsModule - Loads `/command`-style keys from the language config
- * and registers them as chat commands. When invoked, the resolved language
- * sources are sent to the active agent via addPendingUserMessage.
- */
-@TraceAll()
-export class CustomCommandsModule extends BaseChatModule {
-  name = "custom-commands";
-  description =
-    "Dynamically registered commands from language config /command keys";
-
-  public getCommands(): ChatCommand[] {
-    // Commands are loaded asynchronously; return empty here and register dynamically in initialize
-    return [];
-  }
-
-  getPlugins() {
-    return this.chatService.getTools()?.getContext()?.Plugins;
-  }
-
-  async initialize(service: ChatService): Promise<void> {
-    this.chatService = service;
-
-    // Load language config and register /command-style keys
-    try {
-      const languageConfig = await getLanguageConfig();
-      const commandKeys = Object.keys(languageConfig).filter((key) =>
-        key.trim().startsWith("/")
-      );
-
-      for (const commandKey of commandKeys) {
-        // Strip the leading slash to get the command name
-        const commandName = commandKey.trim().slice(1);
-
-        console.log(
-          `CUSTOM-COMMANDS: Registering command /${commandName} from language config`
-        );
-
-        const command: ChatCommand = {
-          name: commandName,
-          description: `Custom command: ${commandKey}`,
-          modes: ["agent:attached", "agent"],
-          handler: async (args: string[]): Promise<CommandResult> => {
-            const config = languageConfig[commandKey];
-            const result = await this.getPlugins().call("language", commandKey);
-
-            // If handled is true, call the language plugin and display output but don't send to agent
-            if (config.handled === true) {
-              try {
-                console.log(result);
-                return {
-                  handled: true,
-                  contents: result,
-                };
-              } catch (error) {
-                console.error(`Error executing command ${commandKey}:`, error);
-                return { handled: true };
-              }
-            }
-
-            // By default (handled: false or undefined), return unhandled so agent module processes it
-            return {
-              handled: false,
-              contents: commandKey + " => " + result,
-            };
-          },
-        };
-
-        this.chatService.registerCommand(command);
-      }
-    } catch (error) {
-      console.error("CUSTOM-COMMANDS: Error loading language config:", error);
-    }
-  }
-}

package/src/chat/modules/InternalChatModule.ts

@@ -1,216 +0,0 @@
-import { ChatModule } from "../types";
-import { TraceAll } from "../../util/Trace";
-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";
-import { CustomCommandsModule } from "./CustomCommandsModule";
-import { ShellCommandModule } from "./ShellCommandModule";
-import { ToolCommandModule } from "./ToolCommandModule";
-import { RendererModule } from "./RendererModule";
-import { SessionsModule } from "./SessionsModule";
-import { RemoteSyncModule } from "./RemoteSyncModule";
-import { ClipboardImageModule } from "./ClipboardImageModule";
-
-@TraceAll()
-export class InternalChatModule implements ChatModule {
-  private clipboardImageModule = new ClipboardImageModule();
-  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 sessionsModule: SessionsModule;
-  private voiceModule = new VoiceModule();
-  private systemModule = new SystemModule();
-  private setupModule: SetupModule;
-  private customCommandsModule = new CustomCommandsModule();
-  private shellCommandModule = new ShellCommandModule();
-  private toolCommandModule = new ToolCommandModule();
-  private rendererModule: RendererModule;
-  private remoteSyncModule: RemoteSyncModule;
-
-  constructor() {
-    this.rendererModule = new RendererModule(this.agentModule);
-    this.setupModule = new SetupModule(this.agentModule);
-    this.sessionsModule = new SessionsModule(this.agentModule);
-    this.remoteSyncModule = new RemoteSyncModule(this.agentModule);
-    this.agentModule.setRemoteSyncModule(this.remoteSyncModule);
-  }
-
-  async initialize(chatService: CliChatService): Promise<void> {
-    this.chatService = chatService;
-
-    // Register this module first so it gets called for input handling
-    chatService.registerModule(this);
-
-    // Initialize renderer first so context.renderer is set before other modules use it
-    await this.rendererModule.initialize(chatService);
-    await this.agentModule.initialize(chatService);
-    await this.sessionsModule.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);
-    await this.customCommandsModule.initialize(chatService);
-    await this.remoteSyncModule.initialize(chatService);
-    await this.shellCommandModule.initialize(chatService);
-    await this.toolCommandModule.initialize(chatService);
-    await this.clipboardImageModule.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.sessionsModule.getCommands(),
-      ...this.askModule.getCommands(),
-      ...this.searchModule.getCommands(),
-      ...this.voiceModule.getCommands(),
-      ...this.systemModule.getCommands(),
-      ...this.setupModule.getCommands(),
-      ...this.customCommandsModule.getCommands(),
-      ...this.shellCommandModule.getCommands(),
-      ...this.toolCommandModule.getCommands(),
-      ...this.rendererModule.getCommands(),
-      ...this.remoteSyncModule.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.sessionsModule.getModes(),
-      ...this.askModule.getModes(),
-      ...this.searchModule.getModes(),
-      ...this.voiceModule.getModes(),
-      ...this.systemModule.getModes(),
-      ...this.setupModule.getModes(),
-      ...this.customCommandsModule.getModes(),
-      ...this.shellCommandModule.getModes(),
-      ...this.toolCommandModule.getModes(),
-      ...this.rendererModule.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
-  }
-}