sam-coder-cli 1.0.68 → 2.0.0

package/bin/agi-cli.js

@@ -12,6 +12,9 @@ const execAsync = util.promisify(exec);
 // Import AGI Animation module
 const { runAGIAnimation } = require('./agi-animation.js');
 
+// Import Brainstorm Core module
+const brainstormCore = require('./core');
+
 // Configuration
 const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
 let OPENROUTER_API_KEY;
@@ -67,43 +70,51 @@ const tools = [
                 items: {
                   type: 'object',
                   properties: {
-                    type: { 
-                      type: 'string', 
-                      enum: ['replace', 'insert', 'delete'],
+                    type: {
+                      type: 'string',
+                      enum: ['replace', 'insert', 'delete', 'search_replace'],
                       description: 'Type of edit operation'
                     },
-                    startLine: { 
-                      type: 'number', 
-                      description: 'Starting line number (1-based)' 
+                    old_string: {
+                      type: 'string',
+                      description: 'Exact string to search for and replace (for search_replace operations)'
+                    },
+                    new_string: {
+                      type: 'string',
+                      description: 'String to replace old_string with (for search_replace operations)'
                     },
-                    endLine: { 
-                      type: 'number', 
-                      description: 'Ending line number (1-based, inclusive)' 
+                    startLine: {
+                      type: 'number',
+                      description: 'Starting line number (1-based)'
                     },
-                    newText: { 
-                      type: 'string', 
-                      description: 'New text to insert or replace with' 
+                    endLine: {
+                      type: 'number',
+                      description: 'Ending line number (1-based, inclusive)'
                     },
-                    pattern: { 
-                      type: 'string', 
-                      description: 'Pattern to search for (for replace operations)' 
+                    newText: {
+                      type: 'string',
+                      description: 'New text to insert or replace with'
                     },
-                    replacement: { 
-                      type: 'string', 
-                      description: 'Replacement text (for pattern-based replace)' 
+                    pattern: {
+                      type: 'string',
+                      description: 'Pattern to search for (for replace operations)'
                     },
-                    flags: { 
-                      type: 'string', 
-                      description: 'Regex flags (e.g., "g" for global)' 
+                    replacement: {
+                      type: 'string',
+                      description: 'Replacement text (for pattern-based replace)'
                     },
-                    position: { 
-                      type: 'string', 
+                    flags: {
+                      type: 'string',
+                      description: 'Regex flags (e.g., "g" for global)'
+                    },
+                    position: {
+                      type: 'string',
                       enum: ['start', 'end'],
-                      description: 'Where to insert (only for insert operations)' 
+                      description: 'Where to insert (only for insert operations)'
                     },
-                    line: { 
-                      type: 'number', 
-                      description: 'Line number to insert at (for line-based insert)' 
+                    line: {
+                      type: 'number',
+                      description: 'Line number to insert at (for line-based insert)'
                     }
                   },
                   required: ['type'],
@@ -149,6 +160,14 @@ const tools = [
                         endLine: { type: 'number' }
                       },
                       required: ['startLine', 'endLine']
+                    },
+                    {
+                      properties: {
+                        type: { const: 'search_replace' },
+                        old_string: { type: 'string' },
+                        new_string: { type: 'string' }
+                      },
+                      required: ['old_string', 'new_string']
                     }
                   ]
                 }
@@ -214,6 +233,48 @@ INSTRUCTIONS:
 
 Always think step by step and explain your reasoning before taking actions that could affect the system.`;
 
+// System prompt for the AI Assistant when using Engineer Mode
+const ENGINEER_PROMPT = `You are a Senior Software Engineer with 15+ years of experience. You have deep expertise in:
+- Software architecture and design patterns
+- Clean code principles and best practices  
+- Test-driven development
+- Performance optimization
+- Security best practices
+- Code review and mentoring
+
+TOOLS AVAILABLE:
+1. readFile - Read the contents of a file
+2. writeFile - Write content to a file
+3. editFile - Edit specific parts of a file (use search_replace with old_string/new_string for precise edits)
+4. runCommand - Execute a shell command
+5. searchFiles - Search for files using a glob pattern
+
+ENGINEER PRINCIPLES:
+1. **Code Quality First**: Write clean, maintainable, well-documented code
+2. **Think Before Acting**: Analyze the problem thoroughly before making changes
+3. **Small, Focused Changes**: Make incremental changes that are easy to review
+4. **Test Your Work**: Verify changes work as expected before moving on
+5. **Explain Your Reasoning**: Document why you made certain technical decisions
+
+WHEN EDITING FILES:
+- ALWAYS use editFile with search_replace operations
+- Use { "type": "search_replace", "old_string": "exact text to find", "new_string": "replacement text" }
+- The old_string must match EXACTLY including whitespace
+- Make focused, minimal changes
+
+WORKFLOW:
+1. Read and understand the existing code
+2. Identify the minimal changes needed
+3. Make changes using precise search_replace operations  
+4. Verify the changes compile/run correctly
+5. Summarize what was done
+
+ENVIRONMENT:
+- OS: ${process.platform}
+- Current directory: ${process.cwd()}
+
+You are autonomous - continue working until the task is complete. Use the 'stop' action when finished.`;
+
 // System prompt for the AI Assistant when using legacy function calling (JSON actions)
 const FUNCTION_CALLING_PROMPT = `You are an autonomous AI agent with advanced problem-solving capabilities. You operate through strategic action sequences to accomplish complex tasks on the user's system. Think like an expert developer and system administrator combined.
 
@@ -430,9 +491,10 @@ const agentUtils = {
   },
 
   async writeFile(input, maybeContent) {
+    let filePath;
     try {
-      const filePath = typeof input === 'string' ? input : input?.path;
-      const content = typeof input === 'string' ? maybeContent : input?.content;
+      filePath = typeof input === 'string' ? input : input?.path;
+      const content = typeof input === 'string' ? maybeContent : (input?.content ?? input?.contents ?? input?.data);
       if (!filePath) throw new Error('writeFile: missing path');
       if (typeof content !== 'string') throw new Error('writeFile: missing content');
       const dir = path.dirname(filePath);
@@ -440,7 +502,8 @@ const agentUtils = {
       await fs.writeFile(filePath, content, 'utf-8');
       return `Successfully wrote to ${filePath}`;
     } catch (error) {
-      throw new Error(`Failed to write to file ${filePath}: ${error.message}`);
+      const ctx = filePath || (typeof input === 'object' ? input?.path : undefined) || 'unknown path';
+      throw new Error(`Failed to write to file ${ctx}: ${error.message}`);
     }
   },
 
@@ -453,7 +516,7 @@ const agentUtils = {
       // Read the current file content
       let content = await fs.readFile(targetPath, 'utf-8');
       const lines = content.split('\n');
-      
+
       // Process each edit operation
       for (const op of edits.operations) {
         switch (op.type) {
@@ -476,7 +539,7 @@ const agentUtils = {
               lines.push(...content.split('\n'));
             }
             break;
-            
+
           case 'insert':
             if (op.position === 'start') {
               lines.unshift(...op.text.split('\n'));
@@ -490,23 +553,44 @@ const agentUtils = {
               lines.splice(op.line - 1, 0, ...insertLines);
             }
             break;
-            
+
           case 'delete':
             if (op.startLine < 1 || op.endLine > lines.length) {
               throw new Error(`Line numbers out of range (1-${lines.length})`);
             }
             lines.splice(op.startLine - 1, op.endLine - op.startLine + 1);
             break;
-            
+
+          case 'search_replace':
+            // Claude Code style: exact string search and replace
+            if (op.old_string === undefined || op.new_string === undefined) {
+              throw new Error('search_replace requires old_string and new_string');
+            }
+            content = lines.join('\n');
+            if (!content.includes(op.old_string)) {
+              throw new Error(`Could not find exact match for old_string: "${op.old_string.substring(0, 50)}${op.old_string.length > 50 ? '...' : ''}"`);
+            }
+            // Count occurrences
+            const occurrences = content.split(op.old_string).length - 1;
+            if (occurrences > 1) {
+              console.log(`Warning: Found ${occurrences} occurrences of old_string. Replacing first occurrence only.`);
+            }
+            // Replace first occurrence (to be safe and predictable like Claude Code)
+            content = content.replace(op.old_string, op.new_string);
+            // Update lines array
+            lines.length = 0;
+            lines.push(...content.split('\n'));
+            break;
+
           default:
             throw new Error(`Unknown operation type: ${op.type}`);
         }
       }
-      
+
       // Write the modified content back to the file
       await fs.writeFile(targetPath, lines.join('\n'), 'utf-8');
       return `Successfully edited ${targetPath}`;
-      
+
     } catch (error) {
       throw new Error(`Failed to edit file ${typeof inputPathOrObj === 'string' ? inputPathOrObj : inputPathOrObj?.path}: ${error.message}`);
     }
@@ -514,9 +598,54 @@ const agentUtils = {
 
   async runCommand(input) {
     try {
-      const command = typeof input === 'string' ? input : input?.command;
-      if (!command) throw new Error('runCommand: missing command');
-      const { stdout, stderr } = await execAsync(command, { cwd: process.cwd() });
+      const isObj = typeof input === 'object' && input !== null;
+      let command = !isObj ? input : (input.command ?? null);
+      const cmd = isObj ? (input.cmd ?? input.program ?? null) : null;
+      const args = isObj ? (input.args ?? input.params ?? null) : null;
+      const script = isObj ? (input.script ?? null) : null;
+      const shell = isObj ? (input.shell ?? (input.powershell ? 'powershell.exe' : (input.bash ? 'bash' : undefined))) : undefined;
+      const cwdRaw = isObj ? input.cwd : undefined;
+      const envRaw = isObj ? input.env : undefined;
+      const timeout = isObj && typeof input.timeout === 'number' ? input.timeout : undefined;
+
+      const quoteArg = (a) => {
+        if (a == null) return '';
+        const s = String(a);
+        return /\s|["']/g.test(s) ? '"' + s.replace(/"/g, '\\"') + '"' : s;
+      };
+
+      // Build command from arrays or fields if not provided directly
+      if (!command && cmd) {
+        if (Array.isArray(cmd)) {
+          command = cmd.map(quoteArg).join(' ');
+        } else if (typeof cmd === 'string') {
+          command = cmd;
+        }
+      }
+      if (Array.isArray(command)) {
+        command = command.map(quoteArg).join(' ');
+      }
+      if (command && Array.isArray(args) && args.length) {
+        command = `${command} ${args.map(quoteArg).join(' ')}`;
+      }
+      if (script && !command) {
+        // If only a script is provided, run it directly under the selected shell
+        command = String(script);
+      }
+
+      if (!command || typeof command !== 'string' || command.trim().length === 0) {
+        throw new Error('runCommand: missing command');
+      }
+
+      // Resolve cwd
+      let cwd = process.cwd();
+      if (typeof cwdRaw === 'string' && cwdRaw.trim().length > 0) {
+        cwd = path.isAbsolute(cwdRaw) ? cwdRaw : path.join(process.cwd(), cwdRaw);
+      }
+      // Merge env
+      const env = envRaw && typeof envRaw === 'object' ? { ...process.env, ...envRaw } : undefined;
+
+      const { stdout, stderr } = await execAsync(command, { cwd, env, timeout, shell });
       if (stderr) {
         console.error('Command stderr:', stderr);
       }
@@ -614,7 +743,7 @@ function extractJsonFromMarkdown(text) {
   // Try to find a markdown code block with JSON content (case insensitive)
   const codeBlockRegex = /```(?:json|JSON)\s*([\s\S]*?)\s*```/i;
   const match = text.match(codeBlockRegex);
-  
+
   if (match && match[1]) {
     try {
       const jsonStr = match[1].trim();
@@ -626,7 +755,7 @@ function extractJsonFromMarkdown(text) {
       // ignore
     }
   }
-  
+
   // If no code block found, look for JSON-like patterns in the text
   const jsonPatterns = [
     // Look for objects that start with { and end with }
@@ -634,7 +763,7 @@ function extractJsonFromMarkdown(text) {
     // Look for arrays that start with [ and end with ]
     /\[[\s\S]*?\]/g
   ];
-  
+
   for (const pattern of jsonPatterns) {
     const matches = text.match(pattern);
     if (matches) {
@@ -652,7 +781,7 @@ function extractJsonFromMarkdown(text) {
       }
     }
   }
-  
+
   // If still no valid JSON found, try to parse the entire text as JSON
   try {
     const trimmed = text.trim();
@@ -662,7 +791,7 @@ function extractJsonFromMarkdown(text) {
   } catch (error) {
     // Last resort failed
   }
-  
+
   return null;
 }
 
@@ -928,24 +1057,24 @@ function extractArgsJson(text) {
   // Prefer fenced code block
   const fence = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
   if (fence && fence[1]) {
-    try { return JSON.parse(fence[1].trim()); } catch (_) {}
+    try { return JSON.parse(fence[1].trim()); } catch (_) { }
   }
   // Try straightforward parse
   const trimmed = text.trim();
   if ((trimmed.startsWith('{') && trimmed.includes('}')) || (trimmed.startsWith('[') && trimmed.includes(']'))) {
-    try { return JSON.parse(trimmed); } catch (_) {}
+    try { return JSON.parse(trimmed); } catch (_) { }
   }
   // Fallback: find first {...} minimally
   const braceRegex = /\{[\s\S]*?\}/g;
   const m = braceRegex.exec(text);
   if (m && m[0]) {
-    try { return JSON.parse(m[0]); } catch (_) {}
+    try { return JSON.parse(m[0]); } catch (_) { }
   }
   // Fallback: find first [...] minimally
   const arrRegex = /\[[\s\S]*?\]/g;
   const a = arrRegex.exec(text);
   if (a && a[0]) {
-    try { return JSON.parse(a[0]); } catch (_) {}
+    try { return JSON.parse(a[0]); } catch (_) { }
   }
   return {};
 }
@@ -1115,11 +1244,11 @@ async function processQueryWithTools(query, conversation = [], currentModel) {
 
 async function handleToolCalls(toolCalls, messages) {
   const results = [];
-  
+
   for (const toolCall of toolCalls) {
     const functionName = toolCall.function.name;
     let args;
-    
+
     try {
       args = JSON.parse(toolCall.function.arguments);
     } catch (error) {
@@ -1132,14 +1261,14 @@ async function handleToolCalls(toolCalls, messages) {
       });
       continue;
     }
-    
+
     console.log(`🔧 Executing ${functionName} with args:`, args);
-    
+
     try {
       if (!agentUtils[functionName]) {
         throw new Error(`Tool '${functionName}' not found`);
       }
-      
+
       let result;
       if (Array.isArray(args)) {
         result = await agentUtils[functionName](...args);
@@ -1151,9 +1280,9 @@ async function handleToolCalls(toolCalls, messages) {
         result = await agentUtils[functionName]();
       }
       console.log('✅ Tool executed successfully');
-      
+
       const resultContent = typeof result === 'string' ? result : JSON.stringify(result);
-      
+
       results.push({
         tool_call_id: toolCall.id,
         role: 'tool',
@@ -1162,25 +1291,25 @@ async function handleToolCalls(toolCalls, messages) {
       });
     } catch (error) {
       console.error('❌ Tool execution failed:', error);
-      
+
       results.push({
         tool_call_id: toolCall.id,
         role: 'tool',
         name: functionName,
-        content: JSON.stringify({ 
+        content: JSON.stringify({
           error: error.message,
           stack: process.env.DEBUG ? error.stack : undefined
         })
       });
     }
   }
-  
+
   return results;
 }
 
 async function executeAction(action) {
   const { type, data } = action;
-  
+
   switch (type) {
     case 'read':
       return await agentUtils.readFile(data.path);
@@ -1219,16 +1348,16 @@ async function executeAction(action) {
 async function processQuery(query, conversation = [], currentModel) {
   try {
     const userMessage = { role: 'user', content: query };
-    
+
     // Use existing conversation (which should already have system prompt from chat function)
     let messages = [...conversation, userMessage];
-    
+
     let actionCount = 0;
     const MAX_ACTIONS = 10;
     let finalResponse = '';
 
     ui.startThinking();
-    
+
     while (actionCount < MAX_ACTIONS) {
       const responseObj = await callOpenRouter(messages, currentModel, true);
       const assistantMessage = responseObj.choices[0].message;
@@ -1248,55 +1377,55 @@ async function processQuery(query, conversation = [], currentModel) {
       }
       normalizeToolCallsFromMessage(assistantMessage);
       messages.push(assistantMessage);
-      
+
       const actionData = extractJsonFromMarkdown(assistantMessage.content);
-      
+
       // If no valid action found, treat as final response
       if (!actionData || !actionData.type) {
         finalResponse = assistantMessage.content;
         break;
       }
-      
+
       // If stop action, break with the reasoning or content
       if (actionData.type === 'stop') {
         finalResponse = actionData.reasoning || assistantMessage.content;
         break;
       }
-      
+
       actionCount++;
       console.log(`🔧 Executing action ${actionCount}: ${actionData.type}`);
       if (actionData.reasoning) {
         console.log(`📝 Reasoning: ${actionData.reasoning}`);
       }
-      
+
       try {
         const result = await executeAction(actionData);
         console.log('✅ Action executed successfully');
-        
+
         // Add action result to conversation
         const resultMessage = {
-          role: 'user', 
+          role: 'user',
           content: `Action result (${actionData.type}): ${result}`
         };
         messages.push(resultMessage);
-        
+
       } catch (error) {
         console.error('❌ Action execution failed:', error.message);
-        
+
         // Add error result to conversation
         const errorMessage = {
-          role: 'user', 
+          role: 'user',
           content: `Action failed (${actionData.type}): ${error.message}`
         };
         messages.push(errorMessage);
       }
     }
-    
+
     // If we hit max actions, get a final response
     if (actionCount >= MAX_ACTIONS && !finalResponse) {
       const finalMsg = { role: 'user', content: 'Please provide a final summary of what was accomplished.' };
       messages.push(finalMsg);
-      
+
       const finalResponseObj = await callOpenRouter(messages, currentModel, true);
       const finalAssistantMessage = finalResponseObj.choices[0].message;
       if (finalAssistantMessage && typeof finalAssistantMessage.content === 'string') {
@@ -1326,22 +1455,27 @@ async function processQuery(query, conversation = [], currentModel) {
   }
 }
 
-async function chat(rl, useToolCalling, initialModel) {
+async function chat(rl, mode, initialModel) {
   let currentModel = initialModel;
   const conversation = [];
-  
-  // Initialize conversation with appropriate system prompt
-  if (useToolCalling) {
+
+  // Initialize conversation with appropriate system prompt based on mode
+  if (mode === 'engineer') {
+    conversation.push({ role: 'system', content: ENGINEER_PROMPT });
+  } else if (mode === 'tool') {
     conversation.push({ role: 'system', content: TOOL_CALLING_PROMPT });
   } else {
     conversation.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
   }
-  
+
+  // Determine if we should use tool calling API (both 'tool' and 'engineer' modes use tools)
+  const useToolCalling = (mode === 'tool' || mode === 'engineer');
+
   console.log('Type your message, or "exit" to quit.');
-  
+
   rl.setPrompt('> ');
   rl.prompt();
-  
+
   rl.on('line', async (input) => {
     if (input.toLowerCase().startsWith('/model')) {
       const newModel = input.split(' ')[1];
@@ -1394,11 +1528,99 @@ async function chat(rl, useToolCalling, initialModel) {
       return;
     }
 
+    // Brainstorm command: /brainstorm <project-name> <description>
+    if (input.toLowerCase().startsWith('/brainstorm')) {
+      const parts = input.substring('/brainstorm'.length).trim();
+      if (!parts) {
+        console.log('Usage: /brainstorm <project-name> "<description>"');
+        console.log('Example: /brainstorm "My Project" "A cool project that does things"');
+        rl.prompt();
+        return;
+      }
+
+      // Parse project name and description
+      const match = parts.match(/^"?([^"]+)"?\s+"?([^"]+)"?$/) || parts.match(/^(\S+)\s+(.+)$/);
+      if (!match) {
+        console.log('Usage: /brainstorm <project-name> "<description>"');
+        rl.prompt();
+        return;
+      }
+
+      const projectName = match[1].trim();
+      const projectDescription = match[2].trim();
+      const outputDir = path.join(process.cwd(), projectName.replace(/\s+/g, '-').toLowerCase());
+
+      try {
+        ui.showInfo(`Creating brainstorm session for "${projectName}"...`);
+        const session = await brainstormCore.quickStart(
+          projectName,
+          projectDescription,
+          outputDir,
+          ['CLAUDE-1'] // Single agent by default
+        );
+
+        ui.showSuccess(`✅ Brainstorm session created!`);
+        console.log(`   Session ID: ${session.id}`);
+        console.log(`   Output: ${outputDir}`);
+        console.log(`   Files generated: ${Object.keys(session.fileVersions).length}`);
+        console.log(`\n   Generated files:`);
+        Object.keys(session.fileVersions).forEach(f => console.log(`   - ${f}`));
+        console.log(`\n   Use "/finish <summary>" when done to complete the session.`);
+
+        // Store current session path for /finish command
+        global.currentSessionDir = outputDir;
+      } catch (error) {
+        ui.showError(`Failed to create brainstorm: ${error.message}`);
+      }
+
+      rl.prompt();
+      return;
+    }
+
+    // Finish command: /finish <summary>
+    if (input.toLowerCase().startsWith('/finish')) {
+      const summary = input.substring('/finish'.length).trim();
+
+      if (!global.currentSessionDir) {
+        console.log('No active brainstorm session. Use /brainstorm first.');
+        rl.prompt();
+        return;
+      }
+
+      if (!summary) {
+        console.log('Usage: /finish "<summary of what was accomplished>"');
+        rl.prompt();
+        return;
+      }
+
+      try {
+        ui.showInfo('Completing brainstorm session...');
+        const result = await brainstormCore.finishBrainstorm({
+          sessionDir: global.currentSessionDir,
+          summary,
+          actor: 'CLAUDE-1'
+        });
+
+        if (result.success) {
+          ui.showSuccess(`✅ Session completed!`);
+          console.log(`   Summary: ${summary}`);
+          global.currentSessionDir = null;
+        } else {
+          ui.showError(`Failed: ${result.errors.join(', ')}`);
+        }
+      } catch (error) {
+        ui.showError(`Failed to finish session: ${error.message}`);
+      }
+
+      rl.prompt();
+      return;
+    }
+
     if (input.toLowerCase() === 'exit') {
       rl.close();
       return;
     }
-    
+
     // Direct Harmony tool-call execution from user input (bypass model)
     try {
       const seg = parseSegmentedTranscript(input);
@@ -1429,16 +1651,16 @@ async function chat(rl, useToolCalling, initialModel) {
     } catch (e) {
       // Fall through to normal processing if parsing/execution fails
     }
-    
-    const result = useToolCalling 
+
+    const result = useToolCalling
       ? await processQueryWithTools(input, conversation, currentModel)
       : await processQuery(input, conversation, currentModel);
     ui.stopThinking();
     ui.showResponse(result.response);
-    
+
     conversation.length = 0;
     result.conversation.forEach(msg => conversation.push(msg));
-    
+
     rl.prompt();
   }).on('close', () => {
     ui.showResponse('Goodbye!');
@@ -1448,8 +1670,15 @@ async function chat(rl, useToolCalling, initialModel) {
 
 function askForMode(rl) {
   return new Promise((resolve) => {
-    rl.question('Select mode (1 for tool calling, 2 for function calling): ', (answer) => {
-      resolve(answer.trim() === '1');
+    rl.question('Select mode (1 for tool calling, 2 for function calling, 3 for engineer): ', (answer) => {
+      const mode = answer.trim();
+      if (mode === '3') {
+        resolve('engineer');
+      } else if (mode === '2') {
+        resolve('function');
+      } else {
+        resolve('tool');
+      }
     });
   });
 }
@@ -1532,11 +1761,11 @@ async function start() {
 
     // Check if animation should be shown (can be disabled via config)
     const showAnimation = config.showAnimation !== false; // Default to true
-    
+
     if (showAnimation && !process.env.SKIP_ANIMATION) {
       // Run the epic AGI awakening animation
       await runAGIAnimation();
-      
+
       // Small pause after animation
       await new Promise(resolve => setTimeout(resolve, 500));
     }
@@ -1545,11 +1774,13 @@ async function start() {
     console.log('Select Mode:');
     console.log('1. Tool Calling (for models that support it)');
     console.log('2. Function Calling (legacy)');
-    
-    const useToolCalling = await askForMode(rl);
-    ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
-    
-    await chat(rl, useToolCalling, MODEL);
+    console.log('3. Engineer Mode (autonomous engineering with Claude Code style editing)');
+
+    const selectedMode = await askForMode(rl);
+    const modeNames = { 'tool': 'Tool Calling', 'function': 'Function Calling', 'engineer': 'Engineer' };
+    ui.showResponse(`\nStarting in ${modeNames[selectedMode]} mode...\n`);
+
+    await chat(rl, selectedMode, MODEL);
   } catch (error) {
     ui.showError(error);
     rl.close();