feat: Add interactive correction feature to CLI mode

This commit adds the ability to send corrections to the main agent while it's running.
Key features:
- Press Ctrl+M during agent execution to enter correction mode
- Type a correction message and send it to the agent
- Agent receives and incorporates the message into its context
- Similar to how parent agents can send messages to sub-agents

Closes #326

Author: bhouston

README.md

@@ -35,6 +35,9 @@ mycoder "Implement a React component that displays a list of items"
 # Run with a prompt from a file
 mycoder -f prompt.txt
 
+# Enable interactive corrections during execution (press Ctrl+M to send corrections)
+mycoder --interactive "Implement a React component that displays a list of items"
+
 # Disable user prompts for fully automated sessions
 mycoder --userPrompt false "Generate a basic Express.js server"
 
@@ -119,6 +122,35 @@ export default {
 
 CLI arguments will override settings in your configuration file.
 
+## Interactive Corrections
+
+MyCoder supports sending corrections to the main agent while it's running. This is useful when you notice the agent is going off track or needs additional information.
+
+### Usage
+
+1. Start MyCoder with the `--interactive` flag:
+   ```bash
+   mycoder --interactive "Implement a React component"
+   ```
+
+2. While the agent is running, press `Ctrl+M` to enter correction mode
+3. Type your correction or additional context
+4. Press Enter to send the correction to the agent
+
+The agent will receive your message and incorporate it into its decision-making process, similar to how parent agents can send messages to sub-agents.
+
+### Configuration
+
+You can enable interactive corrections in your configuration file:
+
+```js
+// mycoder.config.js
+export default {
+  // ... other options
+  interactive: true,
+};
+```
+
 ### GitHub Comment Commands
 
 MyCoder can be triggered directly from GitHub issue comments using the flexible `/mycoder` command:

issue_content.md

@@ -0,0 +1,21 @@
+## Add Interactive Correction Feature to CLI Mode
+
+### Description
+Add a feature to the CLI mode that allows users to send corrections to the main agent while it's running, similar to how sub-agents can receive messages via the `agentMessage` tool. This would enable users to provide additional context, corrections, or guidance to the main agent without restarting the entire process.
+
+### Requirements
+- Implement a key command that pauses the output and triggers a user prompt
+- Allow the user to type a correction message
+- Send the correction to the main agent using a mechanism similar to `agentMessage`
+- Resume normal operation after the correction is sent
+- Ensure the correction is integrated into the agent's context
+
+### Implementation Considerations
+- Reuse the existing `agentMessage` functionality
+- Add a new tool for the main agent to receive messages from the user
+- Modify the CLI to capture key commands during execution
+- Handle the pausing and resuming of output during message entry
+- Ensure the correction is properly formatted and sent to the agent
+
+### Why this is valuable
+This feature will make the tool more interactive and efficient, allowing users to steer the agent in the right direction without restarting when they notice the agent is going off track or needs additional information.

packages/agent/src/core/toolAgent/toolAgentCore.ts

@@ -88,6 +88,30 @@ export const toolAgent = async (
         }
       }
     }
+    
+    // Check for messages from user (for main agent only)
+    // Import this at the top of the file
+    try {
+      // Dynamic import to avoid circular dependencies
+      const { userMessages } = await import('../../tools/interaction/userMessage.js');
+      
+      if (userMessages && userMessages.length > 0) {
+        // Get all user messages and clear the queue
+        const pendingUserMessages = [...userMessages];
+        userMessages.length = 0;
+        
+        // Add each message to the conversation
+        for (const message of pendingUserMessages) {
+          logger.log(`Message from user: ${message}`);
+          messages.push({
+            role: 'user',
+            content: `[Correction from user]: ${message}`,
+          });
+        }
+      }
+    } catch (error) {
+      logger.debug('Error checking for user messages:', error);
+    }
 
     // Convert tools to function definitions
     const functionDefinitions = tools.map((tool) => ({

packages/agent/src/index.ts

@@ -25,6 +25,7 @@ export * from './tools/agent/AgentTracker.js';
 // Tools - Interaction
 export * from './tools/agent/agentExecute.js';
 export * from './tools/interaction/userPrompt.js';
+export * from './tools/interaction/userMessage.js';
 
 // Core
 export * from './core/executeToolCall.js';
@@ -49,3 +50,4 @@ export * from './utils/logger.js';
 export * from './utils/mockLogger.js';
 export * from './utils/stringifyLimited.js';
 export * from './utils/userPrompt.js';
+export * from './utils/interactiveInput.js';

packages/agent/src/tools/agent/agentStart.ts

@@ -7,7 +7,7 @@ import {
 } from '../../core/toolAgent/config.js';
 import { toolAgent } from '../../core/toolAgent/toolAgentCore.js';
 import { Tool, ToolContext } from '../../core/types.js';
-import { LogLevel, LoggerListener } from '../../utils/logger.js';
+import { LogLevel, Logger, LoggerListener } from '../../utils/logger.js';
 import { getTools } from '../getTools.js';
 
 import { AgentStatus, AgentState } from './AgentTracker.js';
@@ -161,7 +161,7 @@ export const agentStartTool: Tool<Parameters, ReturnType> = {
       });
       // Add the listener to the sub-agent logger as well
       subAgentLogger.listeners.push(logCaptureListener);
-    } catch (e) {
+    } catch {
       // If Logger instantiation fails (e.g., in tests), fall back to using the context logger
       context.logger.debug('Failed to create sub-agent logger, using context logger instead');
     }

packages/agent/src/tools/getTools.ts

@@ -8,6 +8,7 @@ import { agentStartTool } from './agent/agentStart.js';
 import { listAgentsTool } from './agent/listAgents.js';
 import { fetchTool } from './fetch/fetch.js';
 import { userPromptTool } from './interaction/userPrompt.js';
+import { userMessageTool } from './interaction/userMessage.js';
 import { createMcpTool } from './mcp.js';
 import { listSessionsTool } from './session/listSessions.js';
 import { sessionMessageTool } from './session/sessionMessage.js';
@@ -52,9 +53,10 @@ export function getTools(options?: GetToolsOptions): Tool[] {
     waitTool as unknown as Tool,
   ];
 
-  // Only include userPrompt tool if enabled
+  // Only include user interaction tools if enabled
   if (userPrompt) {
     tools.push(userPromptTool as unknown as Tool);
+    tools.push(userMessageTool as unknown as Tool);
   }
 
   // Add MCP tool if we have any servers configured

packages/agent/src/tools/interaction/userMessage.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Tool } from '../../core/types.js';
+
+// Track the messages sent to the main agent
+export const userMessages: string[] = [];
+
+const parameterSchema = z.object({
+  message: z
+    .string()
+    .describe('The message or correction to send to the main agent'),
+  description: z
+    .string()
+    .describe('The reason for this message (max 80 chars)'),
+});
+
+const returnSchema = z.object({
+  received: z
+    .boolean()
+    .describe('Whether the message was received by the main agent'),
+  messageCount: z
+    .number()
+    .describe('The number of messages in the queue'),
+});
+
+type Parameters = z.infer<typeof parameterSchema>;
+type ReturnType = z.infer<typeof returnSchema>;
+
+export const userMessageTool: Tool<Parameters, ReturnType> = {
+  name: 'userMessage',
+  description: 'Sends a message or correction from the user to the main agent',
+  logPrefix: '✉️',
+  parameters: parameterSchema,
+  parametersJsonSchema: zodToJsonSchema(parameterSchema),
+  returns: returnSchema,
+  returnsJsonSchema: zodToJsonSchema(returnSchema),
+  execute: async ({ message }, { logger }) => {
+    logger.debug(`Received message from user: ${message}`);
+
+    // Add the message to the queue
+    userMessages.push(message);
+    
+    logger.debug(`Added message to queue. Total messages: ${userMessages.length}`);
+
+    return {
+      received: true,
+      messageCount: userMessages.length,
+    };
+  },
+  logParameters: (input, { logger }) => {
+    logger.log(`User message received: ${input.description}`);
+  },
+  logReturns: (output, { logger }) => {
+    if (output.received) {
+      logger.log(
+        `Message added to queue. Queue now has ${output.messageCount} message(s).`,
+      );
+    } else {
+      logger.error('Failed to add message to queue.');
+    }
+  },
+};

packages/agent/src/utils/interactiveInput.ts

@@ -0,0 +1,118 @@
+import * as readline from 'readline';
+import { createInterface } from 'readline/promises';
+import { Writable } from 'stream';
+
+import chalk from 'chalk';
+
+import { userMessages } from '../tools/interaction/userMessage.js';
+
+// Custom output stream to intercept console output
+class OutputInterceptor extends Writable {
+  private originalStdout: NodeJS.WriteStream;
+  private paused: boolean = false;
+
+  constructor(originalStdout: NodeJS.WriteStream) {
+    super();
+    this.originalStdout = originalStdout;
+  }
+
+  pause() {
+    this.paused = true;
+  }
+
+  resume() {
+    this.paused = false;
+  }
+
+  _write(chunk: Buffer | string, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+    if (!this.paused) {
+      this.originalStdout.write(chunk, encoding);
+    }
+    callback();
+  }
+}
+
+// Initialize interactive input mode
+export const initInteractiveInput = () => {
+  // Save original stdout
+  const originalStdout = process.stdout;
+  
+  // Create interceptor
+  const interceptor = new OutputInterceptor(originalStdout);
+  
+  // Replace stdout with our interceptor
+  // @ts-expect-error - This is a hack to replace stdout
+  process.stdout = interceptor;
+  
+  // Create readline interface for listening to key presses
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: interceptor,
+    terminal: true,
+  });
+  
+  // Close the interface to avoid keeping the process alive
+  rl.close();
+  
+  // Listen for keypress events
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  
+  process.stdin.on('keypress', async (str, key) => {
+    // Check for Ctrl+C to exit
+    if (key.ctrl && key.name === 'c') {
+      process.exit(0);
+    }
+    
+    // Check for Ctrl+M to enter message mode
+    if (key.ctrl && key.name === 'm') {
+      // Pause output
+      interceptor.pause();
+      
+      // Create a readline interface for input
+      const inputRl = createInterface({
+        input: process.stdin,
+        output: originalStdout,
+      });
+      
+      try {
+        // Reset cursor position and clear line
+        originalStdout.write('\r\n');
+        originalStdout.write(chalk.green('Enter correction or additional context (Ctrl+C to cancel):\n') + '> ');
+        
+        // Get user input
+        const userInput = await inputRl.question('');
+        
+        // Add message to queue if not empty
+        if (userInput.trim()) {
+          userMessages.push(userInput);
+          originalStdout.write(chalk.green('\nMessage sent to agent. Resuming output...\n\n'));
+        } else {
+          originalStdout.write(chalk.yellow('\nEmpty message not sent. Resuming output...\n\n'));
+        }
+      } catch (error) {
+        originalStdout.write(chalk.red(`\nError sending message: ${error}\n\n`));
+      } finally {
+        // Close input readline interface
+        inputRl.close();
+        
+        // Resume output
+        interceptor.resume();
+      }
+    }
+  });
+  
+  // Return a cleanup function
+  return () => {
+    // Restore original stdout
+    // @ts-expect-error - This is a hack to restore stdout
+    process.stdout = originalStdout;
+    
+    // Disable raw mode
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+  };
+};

packages/cli/src/commands/$default.ts

@@ -20,6 +20,7 @@ import {
   consoleOutputLogger,
 } from 'mycoder-agent';
 import { TokenTracker } from 'mycoder-agent/dist/core/tokens.js';
+import { initInteractiveInput } from 'mycoder-agent/dist/utils/interactiveInput.js';
 
 import { SharedOptions } from '../options.js';
 import { captureException } from '../sentry/index.js';
@@ -106,6 +107,9 @@ export async function executePrompt(
   // Use command line option if provided, otherwise use config value
   tokenTracker.tokenCache = config.tokenCache;
 
+  // Initialize interactive input if enabled
+  let cleanupInteractiveInput: (() => void) | undefined;
+  
   try {
     // Early API key check based on model provider
     const providerSettings =
@@ -164,6 +168,12 @@ export async function executePrompt(
       );
       process.exit(0);
     });
+    
+    // Initialize interactive input if enabled
+    if (config.interactive) {
+      logger.info(chalk.green('Interactive correction mode enabled. Press Ctrl+M to send a correction to the agent.'));
+      cleanupInteractiveInput = initInteractiveInput();
+    }
 
     // Create a config for the agent
     const agentConfig: AgentConfig = {
@@ -206,7 +216,11 @@ export async function executePrompt(
     // Capture the error with Sentry
     captureException(error);
   } finally {
-    // No cleanup needed here as it's handled by the cleanup utility
+    // Clean up interactive input if it was initialized
+    if (cleanupInteractiveInput) {
+      cleanupInteractiveInput();
+    }
+    // Other cleanup is handled by the cleanup utility
   }
 
   logger.log(

packages/cli/src/options.ts

@@ -51,7 +51,7 @@ export const sharedOptions = {
   interactive: {
     type: 'boolean',
     alias: 'i',
-    description: 'Run in interactive mode, asking for prompts',
+    description: 'Run in interactive mode, asking for prompts and enabling corrections during execution (use Ctrl+M to send corrections)',
     default: false,
   } as const,
   file: {