@tyvm/knowhow 0.0.68 → 0.0.70

package/src/chat/CliChatService.ts

@@ -5,6 +5,7 @@
 import {
   ChatService,
   ChatContext,
+  CommandResult,
   ChatCommand,
   ChatMode,
   InputMethod,
@@ -112,6 +113,10 @@ export class CliChatService implements ChatService {
     return this.context;
   }
 
+  getTools() {
+    return this.context.selectedAgent?.tools;
+  }
+
   setContext(context: Partial<ChatContext>): void {
     this.context = { ...this.context, ...context };
     // Keep chatHistory reference synchronized
@@ -144,6 +149,37 @@ export class CliChatService implements ChatService {
     return this.commands;
   }
 
+  /**
+   * Get commands available in the current mode
+   */
+  getCommandsForMode(mode: string): ChatCommand[] {
+    return this.commands.filter(
+      (cmd) => !cmd.modes || cmd.modes.length === 0 || cmd.modes.includes(mode)
+    );
+  }
+
+  getCommandsForActiveModes(): ChatCommand[] {
+    const activeModes = this.modes
+      .filter((mode) => mode.active)
+      .map((mode) => mode.name);
+    return this.commands.filter(
+      (cmd) =>
+        !cmd.modes ||
+        cmd.modes.length === 0 ||
+        cmd.modes.some((mode) => activeModes.includes(mode))
+    );
+  }
+
+  setMode(mode: string): void {
+    this.modes.forEach((m) => {
+      if (m.name !== "default" && m.name !== mode) {
+        m.active = false;
+      } else if (m.name === mode) {
+        m.active = true;
+      }
+    });
+  }
+
   getModes(): ChatMode[] {
     return this.modes;
   }
@@ -154,16 +190,28 @@ export class CliChatService implements ChatService {
 
   async processInput(input: string): Promise<boolean> {
     // Note: Input is added to history via setOnNewHistoryEntry callback when user presses Enter
-    // Note: this actually sends all commands to modules, first to service takes it
+    // Note: this actually sends all commands to modules if not handled by a command
 
     // Check if input is a command
     if (input.startsWith("/")) {
       const [commandName, ...args] = input.slice(1).split(" ");
-      const command = this.commands.find((cmd) => cmd.name === commandName);
+      const availableCommands = this.getCommandsForActiveModes();
+      const command = availableCommands.find((cmd) => cmd.name === commandName);
 
       if (command) {
-        await command.handler(args);
-        return true;
+        const result = await command.handler(args);
+
+        // If handler returns a CommandResult and it's not handled, pass to modules
+        if (result && typeof result === "object" && "handled" in result) {
+          if (result.handled) {
+            return true;
+          }
+          // Not handled, use contents if provided or original input
+          input = result.contents || input;
+        } else {
+          // Old-style void handler, consider it handled
+          return true;
+        }
       }
     }
 
@@ -198,7 +246,7 @@ export class CliChatService implements ChatService {
 
   async getInput(
     prompt: string = "> ",
-    options: string[] = [],
+    options: string[] = []
   ): Promise<string> {
     if (this.context.inputMethod) {
       return await this.context.inputMethod.getInput(prompt);
@@ -264,8 +312,9 @@ export class CliChatService implements ChatService {
 
   async startChatLoop(): Promise<void> {
     // Display available commands like the original
-    const commandNames = this.commands.map((cmd) => `/${cmd.name}`);
-    console.log("Commands: ", commandNames.join(", "));
+    const availableCommands = this.getCommandsForActiveModes();
+    const commandNames = availableCommands.map((cmd) => `/${cmd.name}`);
+    console.log("Commands:", commandNames.join(", "));
 
     while (true) {
       const promptText =
@@ -274,10 +323,7 @@ export class CliChatService implements ChatService {
           : `\nAsk knowhow: `;
       try {
         // Pass command names as autocomplete options
-        const input = await this.getInput(
-          promptText,
-          commandNames,
-        );
+        const input = await this.getInput(promptText, commandNames);
 
         if (input.trim() === "") {
           continue;

package/src/chat/modules/AgentModule.ts

@@ -2,7 +2,8 @@
  * Agent Chat Module - Handles agent interactions
  */
 import {
-  AgentSynchronization,
+  AgentSyncKnowhowWeb,
+  AgentSyncFs,
   SessionManager,
   TaskRegistry,
 } from "../../services/index";
@@ -35,13 +36,15 @@ export class AgentModule extends BaseChatModule {
   // Service instances for task management, session management, and synchronization
   private taskRegistry: TaskRegistry;
   private sessionManager: SessionManager;
-  private agentSync: AgentSynchronization;
+  private webSync: AgentSyncKnowhowWeb;
+  private fsSync: AgentSyncFs;
 
   constructor() {
     super();
     this.taskRegistry = new TaskRegistry();
     this.sessionManager = new SessionManager();
-    this.agentSync = new AgentSynchronization();
+    this.webSync = new AgentSyncKnowhowWeb();
+    this.fsSync = new AgentSyncFs();
   }
 
   getCommands(): ChatCommand[] {
@@ -95,6 +98,7 @@ export class AgentModule extends BaseChatModule {
           context.agentMode = false;
           context.selectedAgent = undefined;
           context.currentAgent = undefined;
+          this.chatService.disableMode("agent");
         }
         console.log("Agent mode disabled. Switched to chat mode.");
         return;
@@ -122,7 +126,9 @@ export class AgentModule extends BaseChatModule {
           // so /model and /provider commands show accurate information
           context.currentModel = selectedAgent.getModel();
           context.currentProvider = selectedAgent.getProvider();
+          this.chatService.setMode("agent");
         }
+
         console.log(
           `Agent mode enabled. Selected agent: ${agentName}. Type your task to get started.`
         );
@@ -399,7 +405,7 @@ Please continue from where you left off and complete the original request.
 `;
 
       console.log("🚀 Session resuming...");
-      const context = this.chatService?.getContext() || {};
+      const context = this.chatService?.getContext();
       const allAgents = agents();
       const selectedAgent =
         allAgents[session.agentName] || allAgents[context.currentAgent];
@@ -462,6 +468,7 @@ Please continue from where you left off and complete the original request.
     agentName: string;
     input: string;
     messageId?: string;
+    syncFs?: boolean;
     existingKnowhowTaskId?: string;
     provider?: string;
     model?: string;
@@ -469,6 +476,7 @@ Please continue from where you left off and complete the original request.
     maxSpendLimit?: number; // in dollars
     chatHistory?: ChatInteraction[];
     run?: boolean; // whether to run immediately
+    taskId?: string; // optional pre-generated taskId
   }) {
     const allAgents = agents();
 
@@ -485,7 +493,7 @@ Please continue from where you left off and complete the original request.
 
     let done = false;
     let output = "Done";
-    const taskId = this.sessionManager.generateTaskId(input);
+    const taskId = options.taskId || this.sessionManager.generateTaskId(input);
     let knowhowTaskId: string | undefined;
 
     try {
@@ -521,8 +529,12 @@ Please continue from where you left off and complete the original request.
       this.saveSession(taskId, taskInfo, []);
 
       // Create Knowhow chat task if messageId provided
-      if (options.messageId && !options.existingKnowhowTaskId) {
-        knowhowTaskId = await this.agentSync.createChatTask({
+      if (
+        options.messageId &&
+        !options.existingKnowhowTaskId &&
+        !options.syncFs
+      ) {
+        knowhowTaskId = await this.webSync.createChatTask({
           messageId: options.messageId,
           prompt: input,
         });
@@ -533,8 +545,24 @@ Please continue from where you left off and complete the original request.
           this.taskRegistry.register(taskId, taskInfo);
 
           // Set up event-based synchronization with Knowhow API
-          await this.agentSync.setupAgentSync(agent, knowhowTaskId);
+          await this.webSync.setupAgentSync(agent, knowhowTaskId);
         }
+      } else if (!options.messageId || options.syncFs) {
+        // Use filesystem sync when no messageId is provided or syncFs is explicitly enabled
+        console.log(
+          `📁 Using filesystem-based synchronization for task: ${taskId}`
+        );
+
+        const fsTaskId = await this.fsSync.createTask({
+          taskId,
+          prompt: input,
+        });
+
+        // Update TaskInfo with the fs sync info
+        taskInfo.knowhowTaskId = fsTaskId;
+        this.taskRegistry.register(taskId, taskInfo);
+
+        await this.fsSync.setupAgentSync(agent, fsTaskId);
       }
 
       // Set up session update listener
@@ -642,10 +670,15 @@ Please continue from where you left off and complete the original request.
 
           // Wait for AgentSync to finish before resolving
           if (knowhowTaskId) {
-            console.log("🎯 [AgentModule] Waiting for sync finalization...");
-            await this.agentSync.waitForFinalization();
-            console.log("🎯 [AgentModule] Sync finalization complete");
+            console.log(
+              "🎯 [AgentModule] Waiting for web sync finalization..."
+            );
+            await this.webSync.waitForFinalization();
+            console.log("🎯 [AgentModule] Web sync finalization complete");
           }
+          console.log("🎯 [AgentModule] Waiting for fs sync finalization...");
+          await this.fsSync.waitForFinalization();
+          console.log("🎯 [AgentModule] Fs sync finalization complete");
 
           if (taskInfo) {
             taskInfo.status = "completed";
@@ -778,7 +811,25 @@ Please continue from where you left off and complete the original request.
       let agentFinalOutput: string | undefined;
 
       // Define available commands
-      const commands = ["/pause", "/unpause", "/kill", "/detach", "/done"];
+      // Set mode to agent:attached so custom commands are available
+      if (this.chatService) {
+        this.chatService.setMode("agent:attached");
+      }
+
+      // Get mode-specific commands for autocomplete
+      const modeCommands =
+        this.chatService
+          ?.getCommandsForMode("agent:attached")
+          .map((cmd) => `/${cmd.name}`) || [];
+
+      const commands = [
+        ...modeCommands,
+        "/pause",
+        "/unpause",
+        "/kill",
+        "/detach",
+        "/done",
+      ];
       const history: string[] = [];
 
       // Set up the event listener BEFORE starting the agent to avoid race condition
@@ -836,6 +887,10 @@ Please continue from where you left off and complete the original request.
             break;
           case "/detach":
             console.log("Detached from agent");
+            // Reset mode back to default when detaching
+            if (this.chatService) {
+              this.chatService.setMode("default");
+            }
             return { result: true, finalOutput: agentFinalOutput };
           default:
             agent.addPendingUserMessage({
@@ -852,6 +907,11 @@ Please continue from where you left off and complete the original request.
         }
       }
 
+      // Reset mode back to default when exiting loop
+      if (this.chatService) {
+        this.chatService.setMode("default");
+      }
+
       // Update final task status and save session
       const finalTaskInfo = this.taskRegistry.get(taskId);
       if (finalTaskInfo) {

package/src/chat/modules/CustomCommandsModule.ts

@@ -0,0 +1,79 @@
+import { BaseChatModule } from "./BaseChatModule";
+import { ChatCommand, ChatService, CommandResult } from "../types";
+import { getLanguageConfig } from "../../config";
+import { services } from "../../services";
+
+/**
+ * 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.
+ */
+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

@@ -7,6 +7,8 @@ import { SearchModule } from "./SearchModule";
 import { VoiceModule } from "./VoiceModule";
 import { SystemModule } from "./SystemModule";
 import { SetupModule } from "./SetupModule";
+import { CustomCommandsModule } from "./CustomCommandsModule";
+import { ShellCommandModule } from "./ShellCommandModule";
 
 export class InternalChatModule implements ChatModule {
   private chatService?: CliChatService;
@@ -20,6 +22,8 @@ export class InternalChatModule implements ChatModule {
   private voiceModule = new VoiceModule();
   private systemModule = new SystemModule();
   private setupModule = new SetupModule();
+  private customCommandsModule = new CustomCommandsModule();
+  private shellCommandModule = new ShellCommandModule();
 
   async initialize(chatService: CliChatService): Promise<void> {
     this.chatService = chatService;
@@ -34,7 +38,9 @@ export class InternalChatModule implements ChatModule {
     await this.voiceModule.initialize(chatService);
     await this.systemModule.initialize(chatService);
     await this.setupModule.initialize(chatService);
-
+    await this.customCommandsModule.initialize(chatService);
+    await this.shellCommandModule.initialize(chatService);
+    
     // Register our own commands (exit and multi) - not duplicated by BaseChatModule
     chatService.registerCommand({
       name: "exit",
@@ -62,6 +68,8 @@ export class InternalChatModule implements ChatModule {
       ...this.voiceModule.getCommands(),
       ...this.systemModule.getCommands(),
       ...this.setupModule.getCommands(),
+      ...this.customCommandsModule.getCommands(),
+      ...this.shellCommandModule.getCommands(),
       {
         name: "exit",
         description: "Exit the chat",
@@ -84,6 +92,8 @@ export class InternalChatModule implements ChatModule {
       ...this.voiceModule.getModes(),
       ...this.systemModule.getModes(),
       ...this.setupModule.getModes(),
+      ...this.customCommandsModule.getModes(),
+      ...this.shellCommandModule.getModes(),
     ];
   }
 

package/src/chat/modules/ShellCommandModule.ts

@@ -0,0 +1,96 @@
+import { BaseChatModule } from "./BaseChatModule";
+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
+ */
+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/index.ts

@@ -3,3 +3,4 @@ export { SearchModule } from './SearchModule';
 export { AgentModule } from './AgentModule';
 export { VoiceModule } from './VoiceModule';
 export { InternalChatModule } from './InternalChatModule';
+export { ShellCommandModule } from './ShellCommandModule';

package/src/chat/types.ts

@@ -1,8 +1,9 @@
 /**
  * Core Types for Modular Chat System
  */
-import { ChatInteraction } from "../types";
+import { ChatInteraction, Config } from "../types";
 import { BaseAgent } from "../agents/base/base";
+import { ToolsService } from "src/services";
 
 export interface ChatContext {
   debugMode?: boolean;
@@ -15,6 +16,8 @@ export interface ChatContext {
   currentProvider?: string;
   inputMethod?: InputMethod;
   selectedAgent?: BaseAgent;
+  plugins: string[];
+
   [key: string]: any;
 }
 
@@ -24,10 +27,16 @@ export interface ChatMode {
   active: boolean;
 }
 
+export interface CommandResult {
+  handled: boolean;
+  contents?: string;
+}
+
 export interface ChatCommand {
   name: string;
   description: string;
-  handler: (args: string[]) => Promise<void>;
+  handler: (args: string[]) => Promise<void | CommandResult>;
+  modes?: string[]; // Commands can specify which modes they're available in
 }
 
 export interface InputMethod {
@@ -38,12 +47,15 @@ export interface InputMethod {
 
 export interface ChatService {
   getContext(): ChatContext;
+  getTools(): ToolsService | undefined;
   setContext(context: Partial<ChatContext>): void;
   setInputMethod(method: InputMethod): void;
   resetInputMethod(): void;
   registerCommand(command: ChatCommand): void;
   registerMode(mode: ChatMode): void;
   getCommands(): ChatCommand[];
+  getCommandsForMode(mode: string): ChatCommand[];
+  setMode(mode: string): void;
   getModes(): ChatMode[];
   getMode(name: string): ChatMode | undefined;
   enableMode(name: string): void;

package/src/chat.ts

@@ -20,23 +20,26 @@ async function main() {
         configError
       );
       config = {
-        plugins: [
-          "embeddings",
-          "language",
-          "vim",
-          "github",
-          "asana",
-          "jira",
-          "linear",
-          "download",
-          "figma",
-          "url",
-        ],
+        plugins: {
+          enabled: [
+            "embeddings",
+            "language",
+            "vim",
+            "github",
+            "asana",
+            "jira",
+            "linear",
+            "download",
+            "figma",
+            "url",
+          ],
+          disabled: [],
+        },
       };
     }
 
     // Create chat service with plugins
-    const chatService = new CliChatService(config.plugins);
+    const chatService = new CliChatService(config.plugins.enabled);
 
     // Load internal chat module (includes all core functionality)
     const internalModule = new InternalChatModule();