@tyvm/knowhow 0.0.69 → 0.0.70

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();

package/src/cli.ts

@@ -7,7 +7,7 @@ import { Command } from "commander";
 import { execSync } from "child_process";
 import { version } from "../package.json";
 import { generate, embed, upload } from "./index";
-import { init } from "./config";
+import { init, migrateConfig } from "./config";
 
 import { download, purge } from ".";
 import { includedTools } from "./agents/tools/list";
@@ -26,6 +26,7 @@ import { startChat } from "./chat";
 import { askAI } from "./chat-old";
 import { getConfiguredEmbeddingMap, queryEmbedding } from "./embeddings";
 import { getConfig } from "./config";
+import { getEnabledPlugins } from "./types";
 import { marked } from "marked";
 import { BaseAgent } from "./agents/base/base";
 import { AskModule } from "./chat/modules/AskModule";
@@ -36,9 +37,16 @@ import { SetupModule } from "./chat/modules/SetupModule";
 import { CliChatService } from "./chat/CliChatService";
 
 async function setupServices() {
-  const { Agents, Mcp, Clients } = services();
+  await migrateConfig();
+
+  const { Agents, Mcp, Clients, Tools: OldTools } = services();
   const Tools = new LazyToolsService();
 
+  // We need to wireup the LazyTools to be connected to the same singletons that are in services()
+  Tools.setContext({
+    ...OldTools.getContext(),
+  });
+
   const { Researcher, Developer, Patcher, Setup } = agents({
     ...services(),
     Tools,
@@ -85,7 +93,7 @@ async function readStdin(): Promise<string> {
 async function main() {
   const program = new Command();
   const config = await getConfig();
-  const chatService = new CliChatService(config.plugins);
+  const chatService = new CliChatService(getEnabledPlugins(config.plugins));
 
   program
     .name("knowhow")
@@ -114,13 +122,13 @@ async function main() {
       try {
         console.log("🔄 Checking for knowhow updates...");
         console.log(`Current version: ${version}`);
-        
+
         console.log("📦 Installing latest version from npm...");
         execSync("npm install -g knowhow@latest", {
           stdio: "inherit",
           encoding: "utf-8",
         });
-        
+
         console.log("✓ knowhow has been updated successfully!");
         console.log("Run 'knowhow --version' to see the new version.");
       } catch (error) {
@@ -195,6 +203,8 @@ async function main() {
       "10"
     )
     .option("--message-id <messageId>", "Knowhow message ID for task tracking")
+    .option("--sync-fs", "Enable filesystem-based synchronization")
+    .option("--task-id <taskId>", "Pre-generated task ID (used with --sync-fs for predictable agent directory path)")
     .option("--prompt-file <path>", "Custom prompt template file with {text}")
     .option("--input <text>", "Task input (fallback to stdin if not provided)")
     .action(async (options) => {
@@ -255,7 +265,7 @@ async function main() {
         const askModule = new AskModule();
         await askModule.initialize(chatService);
         await askModule.processAIQuery(input, {
-          plugins: config.plugins,
+          plugins: config.plugins.enabled,
           currentModel: options.model,
           currentProvider: options.provider,
         });