@tyvm/knowhow 0.0.33 → 0.0.35

package/src/chat/modules/SystemModule.ts

@@ -0,0 +1,120 @@
+import { BaseChatModule } from "./BaseChatModule";
+import { CliChatService } from "../CliChatService";
+import { ChatCommand, ChatMode, ChatContext } from "../types";
+import { ask } from "../../utils";
+import { services } from "../../services";
+
+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",
+        handler: this.handleClearCommand.bind(this),
+      },
+    ];
+  }
+
+  getModes(): ChatMode[] {
+    return [];
+  }
+
+  async handleModelCommand(args: string[]): Promise<void> {
+    const context = this.chatService?.getContext();
+    const { Clients } = services();
+
+    const currentProvider = context?.currentProvider || "openai";
+    const currentModel = context?.currentModel || "gpt-4o";
+
+    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
+    );
+
+    this.chatService?.setContext({
+      currentModel: selectedModel,
+      currentProvider,
+    });
+
+    console.log(`Model set to: ${selectedModel}`);
+  }
+
+  async handleProviderCommand(args: string[]): Promise<void> {
+    const context = this.chatService?.getContext();
+    const { Clients } = services();
+
+    const currentProvider = context?.currentProvider || "openai";
+    const currentModel = context?.currentModel || "gpt-4o";
+
+    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
+    );
+
+    // Get default model for new provider
+    const ChatModelDefaults = {
+      openai: "gpt-4o",
+      anthropic: "claude-3-5-sonnet-20241022",
+      google: "gemini-2.0-flash-exp",
+      xai: "grok-beta",
+    };
+
+    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}`
+    );
+  }
+
+  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/VoiceModule.ts

@@ -0,0 +1,70 @@
+/**
+ * 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.js

@@ -0,0 +1,5 @@
+export { AskModule } from './AskModule';
+export { SearchModule } from './SearchModule';
+export { AgentModule } from './AgentModule';
+export { VoiceModule } from './VoiceModule';
+export { InternalChatModule } from './InternalChatModule';

package/src/chat/types.ts

@@ -0,0 +1,97 @@
+/**
+ * Core Types for Modular Chat System
+ */
+import { BaseAgent } from '../agents/base/base.js';
+
+export interface ChatContext {
+  debugMode?: boolean;
+  agentMode?: boolean;
+  currentAgent?: string;
+  searchMode?: boolean;
+  voiceMode?: boolean;
+  multilineMode?: boolean;
+  currentModel?: string;
+  currentProvider?: string;
+  inputMethod?: InputMethod;
+  [key: string]: any;
+}
+
+export interface ChatMode {
+  name: string;
+  description: string;
+  active: boolean;
+}
+
+export interface ChatCommand {
+  name: string;
+  description: string;
+  handler: (args: string[]) => Promise<void>;
+}
+
+export interface InputMethod {
+  name: string;
+  description: string;
+  getInput: (prompt?: string) => Promise<string>;
+}
+
+export interface ChatService {
+  getContext(): ChatContext;
+  setContext(context: Partial<ChatContext>): void;
+  setInputMethod(method: InputMethod): void;
+  resetInputMethod(): void;
+  registerCommand(command: ChatCommand): void;
+  registerMode(mode: ChatMode): void;
+  getCommands(): ChatCommand[];
+  getModes(): ChatMode[];
+  getMode(name: string): ChatMode | undefined;
+  enableMode(name: string): void;
+  disableMode(name: string): void;
+  processInput(input: string): Promise<boolean>;
+  getInput(prompt?: string, options?: string[], chatHistory?: any[]): Promise<string>;
+}
+
+// Enhanced task management types
+export interface TaskInfo {
+  taskId: string;
+  knowhowMessageId?: string;
+  knowhowTaskId?: string;
+  agentName: string;
+  agent: BaseAgent;
+  initialInput: string;
+  status: 'running' | 'paused' | 'completed' | 'failed';
+  startTime: number;
+  endTime?: number;
+  totalCost: number;
+  sessionFile?: string;
+}
+
+export interface ChatSession {
+  knowhowMessageId?: string;
+  knowhowTaskId?: string;
+  sessionId: string;
+  taskId: string;
+  agentName: string;
+  initialInput: string;
+  startTime: number;
+  endTime?: number;
+  status: 'running' | 'paused' | 'completed' | 'failed';
+  totalCost: number;
+  threads: any[][];
+  currentThread: number;
+  lastUpdated: number;
+}
+
+export interface ChatHistory {
+  inputs: string[];
+}
+
+export interface ChatModule {
+  name: string;
+  description: string;
+  commands: ChatCommand[];
+  modes: ChatMode[];
+
+  initialize(service: ChatService): Promise<void>;
+  handleInput(input: string, context: ChatContext): Promise<boolean>;
+  cleanup(): Promise<void>;
+}

package/src/chat.ts

@@ -23,6 +23,7 @@ import { BaseAgent } from "./agents";
 import { getConfig } from "./config";
 import { TokenCompressor } from "./processors/TokenCompressor";
 import { ToolResponseCache } from "./processors/ToolResponseCache";
+import { CustomVariables, XmlToolCallProcessor, HarmonyToolProcessor } from "./processors";
 
 enum ChatFlags {
   agent = "agent",
@@ -351,12 +352,19 @@ export async function startAgent(
     activeAgent.call(formattedPrompt);
 
     // Compress tokens of tool responses
-    activeAgent.messageProcessor.setProcessors("per_call", [
+    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 (

package/src/chat2.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * New Modular Chat Interface - Simplified and cleaner than original chat.ts
+ */
+
+import { CliChatService } from "./chat/CliChatService.js";
+import { InternalChatModule } from "./chat/modules/InternalChatModule.js";
+import { getConfig } from "./config.js";
+
+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",
+        ],
+      };
+    }
+
+    // Create chat service with plugins
+    const chatService = new CliChatService(config.plugins);
+
+    // Load internal chat module (includes all core functionality)
+    const internalModule = new InternalChatModule();
+    await internalModule.initialize(chatService);
+
+    // Start the chat loop
+    await chatService.startChatLoop();
+  } catch (error) {
+    console.error("Error starting chat:", error);
+    process.exit(1);
+  }
+}
+
+// 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 (isMainModule) {
+  main().catch(console.error);
+}
+
+export { main as startChat2 };