@tyvm/knowhow 0.0.158 → 0.0.160

package/src/chat/modules/SetupModule.ts

@@ -1,185 +0,0 @@
-import { services } from "../../services";
-import { TraceAll } from "../../util/Trace";
-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";
-
-@TraceAll()
-export class SetupModule extends BaseChatModule {
-  name = "setup";
-  description = "Setup commands";
-  private agentModule: AgentModule;
-
-  constructor(agentModule: AgentModule) {
-    super();
-    this.agentModule = agentModule;
-  }
-
-  getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "setup",
-        description: "Check environment setup and run Setup agent",
-        handler: this.handleSetupCommand.bind(this),
-      },
-    ];
-  }
-
-  getModes(): ChatMode[] {
-    return [];
-  }
-
-  /**
-   * 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 initialInput = "Help me set up my Knowhow configuration with the missing features and optimize my setup.";
-          const { taskId, agent } = await this.agentModule.setupAgent({
-            agentName: "Setup",
-            run: false,
-            input: initialInput,
-          });
-          await this.agentModule.attachedAgentChatLoop(taskId, agent, initialInput);
-        }
-      }
-    } else {
-      console.log(
-        "\n🎉 Great! All major features are available. Your setup looks good!"
-      );
-    }
-  }
-}

package/src/chat/modules/ShellCommandModule.ts

@@ -1,98 +0,0 @@
-import { BaseChatModule } from "./BaseChatModule";
-import { TraceAll } from "../../util/Trace";
-import { ChatCommand, ChatContext, CommandResult } from "../types";
-import { execSync } from "child_process";
-
-/**
- * ShellCommandModule - Handles /! and /!! commands for executing shell commands
- * /! - Execute command and display output in console (interactive if needed)
- * /!! - Execute command and send output to the AI agent
- */
-@TraceAll()
-export class ShellCommandModule extends BaseChatModule {
-  name = "shell-command";
-  description = "Execute shell commands with /! and /!!";
-
-  public getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "!",
-        description: "Execute a shell command (interactive)",
-        modes: ["agent", "agent:attached"],
-        handler: async (args: string[]): Promise<CommandResult> => {
-          const command = args.join(" ");
-          if (!command) {
-            console.log("Usage: /! <command>");
-            return { handled: true };
-          }
-
-          try {
-            console.log(`Executing: ${command}`);
-            // Execute the command and inherit stdio for interactivity
-            const result = execSync(command, {
-              encoding: "utf8",
-              stdio: "inherit",
-              cwd: process.cwd(),
-            });
-            
-            return { handled: true };
-          } catch (error: any) {
-            console.error(`Command failed: ${error.message}`);
-            if (error.stderr) {
-              console.error(error.stderr);
-            }
-            return { handled: true };
-          }
-        },
-      },
-      {
-        name: "!!",
-        description: "Execute a shell command and send output to AI",
-        modes: ["agent", "agent:attached"],
-        handler: async (args: string[]): Promise<CommandResult> => {
-          const command = args.join(" ");
-          if (!command) {
-            console.log("Usage: /!! <command>");
-            return { handled: true };
-          }
-
-          try {
-            console.log(`Executing: ${command}`);
-            const result = execSync(command, {
-              encoding: "utf8",
-              cwd: process.cwd(),
-            });
-
-            console.log(result);
-
-            // Return unhandled with the command output so it gets sent to the agent
-            return {
-              handled: false,
-              contents: `Command output from \`${command}\`:\n\`\`\`\n${result}\n\`\`\``,
-            };
-          } catch (error: any) {
-            const errorMessage = error.message;
-            const stderr = error.stderr || "";
-            const stdout = error.stdout || "";
-            
-            console.error(`Command failed: ${errorMessage}`);
-            if (stderr) {
-              console.error(stderr);
-            }
-
-            // Send error output to agent as well
-            return {
-              handled: false,
-              contents: `Command \`${command}\` failed:\n\`\`\`\n${stdout}\n${stderr}\n${errorMessage}\n\`\`\``,
-            };
-          }
-        },
-      },
-    ];
-  }
-
-  async handleInput(input: string, context: ChatContext): Promise<boolean> {
-    // This module only handles commands registered above
-    return false;
-  }
-}

package/src/chat/modules/SystemModule.ts

@@ -1,161 +0,0 @@
-import { BaseChatModule } from "./BaseChatModule";
-import { TraceAll } from "../../util/Trace";
-import { CliChatService } from "../CliChatService";
-import { ChatCommand, ChatMode, ChatContext } from "../types";
-import { ask } from "../../utils";
-import { services } from "../../services";
-import { Models } from "../../types";
-
-@TraceAll()
-export class SystemModule extends BaseChatModule {
-  name = "system";
-  description = "System commands for model, provider, debug, and clear";
-
-  getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "model",
-        description: "Select AI model",
-        handler: this.handleModelCommand.bind(this),
-      },
-      {
-        name: "provider",
-        description: "Select AI provider",
-        handler: this.handleProviderCommand.bind(this),
-      },
-      {
-        name: "debug",
-        description: "Toggle debug mode",
-        handler: this.handleDebugCommand.bind(this),
-      },
-      {
-        name: "clear",
-        description:
-          "Clear chat history - AI will not remember previous messages",
-        handler: this.handleClearCommand.bind(this),
-      },
-    ];
-  }
-
-  getModes(): ChatMode[] {
-    return [];
-  }
-
-  async handleModelCommand(args: string[]): Promise<void> {
-    const context = this.chatService?.getContext();
-
-    const agent = context?.selectedAgent;
-    const Clients = agent.clientService;
-    const currentProvider = context?.currentProvider || "openai";
-    const currentModel = context?.currentModel || "gpt-5.4-nano";
-
-    const models = Clients.getRegisteredModels(currentProvider);
-    console.log(models);
-
-    const selectedModel = await ask(
-      `\n\nCurrent Provider: ${currentProvider}\nCurrent Model: ${currentModel}\n\nWhich model would you like to use: `,
-      models
-    );
-
-    if (!selectedModel) {
-      return;
-    }
-
-    this.chatService?.setContext({
-      currentModel: selectedModel,
-      currentProvider,
-    });
-    console.log(
-      `Model set to: ${selectedModel} for provider: ${currentProvider}`
-    );
-
-    // Update currently active agent if any
-    if (context?.selectedAgent) {
-      console.log(
-        `Updating active agent ${context.currentAgent} model to: ${selectedModel}`
-      );
-      context?.selectedAgent?.updatePreferences({
-        model: selectedModel,
-        provider: currentProvider as any,
-      });
-    }
-  }
-
-  async handleProviderCommand(args: string[]): Promise<void> {
-    const context = this.chatService?.getContext();
-
-    const agent = context?.selectedAgent;
-    const Clients = agent.clientService;
-
-    const currentProvider = context?.currentProvider || "openai";
-    const currentModel = context?.currentModel || "gpt-5.4-nano";
-
-    const providers = Object.keys(Clients.clients);
-    console.log(providers);
-
-    const selectedProvider = await ask(
-      `\n\nCurrent Provider: ${currentProvider}\nCurrent Model: ${currentModel}\n\nWhich provider would you like to use: `,
-      providers
-    );
-
-    if (!selectedProvider) {
-      return;
-    }
-
-    // Get default model for new provider
-    const ChatModelDefaults = {
-      openai: Models.openai.GPT_56_Sol,
-      anthropic: Models.anthropic.Sonnet4_6,
-      google: Models.google.Gemini_35_Flash_Lite,
-      xai: Models.xai.Grok4_5,
-      knowhow: "anthropic/" + Models.anthropic.Sonnet4_6,
-      fireworks: Models.fireworks.KimiK3,
-    };
-
-    const newModel =
-      ChatModelDefaults[selectedProvider] ||
-      (await Clients.getRegisteredModels(selectedProvider))[0];
-
-    this.chatService?.setContext({
-      currentProvider: selectedProvider,
-      currentModel: newModel,
-    });
-
-    console.log(
-      `Provider set to: ${selectedProvider}, Model set to: ${newModel}`
-    );
-
-    // Update currently active agent if any
-    if (context?.selectedAgent) {
-      console.log(
-        `Updating active agent ${context.currentAgent} provider to: ${selectedProvider} and model to: ${newModel}`
-      );
-
-      context?.selectedAgent?.updatePreferences({
-        model: newModel,
-        provider: selectedProvider as any,
-      });
-    }
-  }
-
-  async handleDebugCommand(args: string[]): Promise<void> {
-    const context = this.chatService?.getContext();
-    const newDebugMode = !context?.debugMode;
-
-    this.chatService?.setContext({ debugMode: newDebugMode });
-    console.log(`Debug mode: ${newDebugMode ? "enabled" : "disabled"}`);
-  }
-
-  async handleClearCommand(args: string[]): Promise<void> {
-    (this.chatService as CliChatService)?.clearHistory();
-    console.log("Chat history cleared.");
-  }
-
-  async handleInput(input: string, context: ChatContext): Promise<boolean> {
-    return false; // Commands are handled separately
-  }
-
-  async cleanup(): Promise<void> {
-    // No cleanup needed
-  }
-}

package/src/chat/modules/ToolCommandModule.ts

@@ -1,102 +0,0 @@
-import { ToolCall } from "../../clients/types";
-import { services } from "../../services";
-import { BaseChatModule } from "./BaseChatModule";
-import { ChatCommand, ChatContext, CommandResult } from "../types";
-
-/** Execute registered tools directly from interactive chat. */
-export class ToolCommandModule extends BaseChatModule {
-  name = "tool-command";
-  description = "Execute a tool with /tool";
-
-  public getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "tool",
-        description: "Execute a tool call from JSON",
-        handler: (args: string[]) => this.handleToolCommand(args),
-      },
-    ];
-  }
-
-  private async handleToolCommand(args: string[]): Promise<CommandResult> {
-    const input = args.join(" ").trim();
-    if (!input) {
-      console.log('Usage: /tool {"name":"toolName","arguments":{"key":"value"}}');
-      return { handled: true };
-    }
-
-    let toolCall: ToolCall;
-    try {
-      toolCall = this.parseToolCall(input);
-    } catch (error: any) {
-      console.error(`Invalid tool call JSON: ${error.message}`);
-      return { handled: true };
-    }
-
-    const tools = this.chatService.getTools() || services().Tools;
-    if (!tools) {
-      console.error("Tool execution failed: no tool service is available");
-      return { handled: true };
-    }
-
-    try {
-      const context = this.chatService.getContext();
-      const result = await tools.callTool(
-        toolCall,
-        tools.getFunctionNames(),
-        {
-          caller: context.selectedAgent,
-          taskId: context.activeAgentTaskId,
-        }
-      );
-
-      const toolError = result.toolMessages?.find(
-        (message: any) => message.name === "error"
-      );
-      if (toolError) {
-        console.error(`Tool execution failed: ${toolError.content}`);
-      } else {
-        const output = result.functionResp;
-        console.log(
-          typeof output === "object"
-            ? JSON.stringify(output, null, 2)
-            : String(output)
-        );
-      }
-    } catch (error: any) {
-      console.error(`Tool execution failed: ${error.message || String(error)}`);
-    }
-
-    return { handled: true };
-  }
-
-  private parseToolCall(input: string): ToolCall {
-    const parsed = JSON.parse(input);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("expected a JSON object");
-    }
-
-    const fn = parsed.function || parsed;
-    if (!fn || typeof fn.name !== "string" || !fn.name.trim()) {
-      throw new Error('expected a non-empty "name" (or "function.name")');
-    }
-
-    const args = fn.arguments === undefined ? {} : fn.arguments;
-    if (typeof args !== "string" && (args === null || typeof args !== "object")) {
-      throw new Error('"arguments" must be a JSON object, array, or JSON string');
-    }
-
-    return {
-      id: typeof parsed.id === "string" ? parsed.id : `chat_tool_${Date.now()}`,
-      type: "function",
-      function: {
-        name: fn.name,
-        arguments: typeof args === "string" ? args : JSON.stringify(args),
-      },
-    };
-  }
-
-  async handleInput(input: string, context: ChatContext): Promise<boolean> {
-    return false;
-  }
-}

package/src/chat/modules/VoiceModule.ts

@@ -1,70 +0,0 @@
-/**
- * Voice Chat Module - Handles voice input functionality
- */
-
-import { BaseChatModule } from "./BaseChatModule";
-import { ChatCommand, ChatMode, ChatContext, InputMethod } from "../types";
-import { voiceToText } from "../../microphone";
-
-export class VoiceModule extends BaseChatModule {
-  name = "voice";
-  description = "Voice input functionality";
-
-  getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "voice",
-        description: "Toggle voice input mode",
-        handler: this.handleVoiceCommand.bind(this),
-      },
-    ];
-  }
-
-  getModes(): ChatMode[] {
-    return [
-      {
-        name: "voice",
-        description: "Voice input mode",
-        active: false,
-      },
-    ];
-  }
-
-  async handleVoiceCommand(args: string[]): Promise<void> {
-    const voiceMode = this.chatService?.getMode("voice");
-    const context = this.chatService?.getContext();
-    if (!voiceMode) return;
-
-    voiceMode.active = !voiceMode.active;
-    const newVoiceMode = !context?.voiceMode;
-    this.chatService?.setContext({ voiceMode: newVoiceMode });
-
-    console.log(`Voice mode: ${newVoiceMode ? "enabled" : "disabled"}`);
-  }
-
-  private async getVoiceInput(prompt?: string): Promise<string> {
-    try {
-      // This would integrate with actual voice recognition
-      // For now, we'll simulate it
-      console.log("🎤 Listening... (Press Enter to record)");
-
-      const value = await voiceToText();
-
-      return value;
-    } catch (error) {
-      console.error("Error getting voice input:", error);
-      return "";
-    }
-  }
-
-  async handleInput(input: string, context: ChatContext): Promise<boolean> {
-    const voiceMode = this.chatService?.getMode("voice");
-    if (!voiceMode?.active) {
-      return false;
-    }
-
-    // Voice mode doesn't handle input directly, it overrides the input method
-    // The actual handling would be done by other modules
-    return false;
-  }
-}

package/src/chat/modules/index.ts

@@ -1,8 +0,0 @@
-export { AskModule } from './AskModule';
-export { SearchModule } from './SearchModule';
-export { AgentModule } from './AgentModule';
-export { VoiceModule } from './VoiceModule';
-export { InternalChatModule } from './InternalChatModule';
-export { ShellCommandModule } from './ShellCommandModule';
-export { ToolCommandModule } from './ToolCommandModule';
-export { RendererModule } from './RendererModule';