sam-coder-cli 2.0.4 → 2.0.7

package/bin/agi-cli.js

@@ -9,12 +9,20 @@ const { exec } = require('child_process');
 const util = require('util');
 const execAsync = util.promisify(exec);
 
+// Global error handlers to prevent silent crashes
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  // Don't exit, just log the error
+});
+
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error);
+  // Don't exit, just log the error
+});
+
 // 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;
@@ -72,17 +80,9 @@ const tools = [
                   properties: {
                     type: {
                       type: 'string',
-                      enum: ['replace', 'insert', 'delete', 'search_replace'],
+                      enum: ['replace', 'insert', 'delete', 'replace_block'],
                       description: 'Type of edit operation'
                     },
-                    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)'
-                    },
                     startLine: {
                       type: 'number',
                       description: 'Starting line number (1-based)'
@@ -95,6 +95,14 @@ const tools = [
                       type: 'string',
                       description: 'New text to insert or replace with'
                     },
+                    oldText: {
+                      type: 'string',
+                      description: 'Exact text to search for and replace (for replace_block)'
+                    },
+                    replacementContent: {
+                      type: 'string',
+                      description: 'New text to replace oldText with (for replace_block)'
+                    },
                     pattern: {
                       type: 'string',
                       description: 'Pattern to search for (for replace operations)'
@@ -137,6 +145,14 @@ const tools = [
                       },
                       required: ['pattern', 'replacement']
                     },
+                    {
+                      properties: {
+                        type: { const: 'replace_block' },
+                        oldText: { type: 'string' },
+                        replacementContent: { type: 'string' }
+                      },
+                      required: ['oldText', 'replacementContent']
+                    },
                     {
                       properties: {
                         type: { const: 'insert' },
@@ -160,14 +176,6 @@ 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']
                     }
                   ]
                 }
@@ -233,48 +241,6 @@ 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.
 
@@ -513,77 +479,94 @@ const agentUtils = {
       const edits = typeof inputPathOrObj === 'string' ? maybeEdits : inputPathOrObj?.edits;
       if (!targetPath) throw new Error('editFile: missing path');
       if (!edits) throw new Error('editFile: missing edits');
+
       // Read the current file content
       let content = await fs.readFile(targetPath, 'utf-8');
-      const lines = content.split('\n');
+      let lines = content.split('\n');
 
       // Process each edit operation
-      for (const op of edits.operations) {
-        switch (op.type) {
-          case 'replace':
-            if (op.startLine !== undefined && op.endLine !== undefined) {
-              // Line-based replacement
-              if (op.startLine < 1 || op.endLine > lines.length) {
-                throw new Error(`Line numbers out of range (1-${lines.length})`);
+      for (let i = 0; i < edits.operations.length; i++) {
+        const op = edits.operations[i];
+        try {
+          switch (op.type) {
+            case 'replace':
+              if (op.startLine !== undefined && op.endLine !== undefined) {
+                // Line-based replacement
+                if (op.startLine < 1 || op.endLine > lines.length) {
+                  throw new Error(`Line numbers out of range (1-${lines.length})`);
+                }
+                if (typeof op.newText !== 'string') {
+                  throw new Error(`'newText' must be a string for replace operation`);
+                }
+                const before = lines.slice(0, op.startLine - 1);
+                const after = lines.slice(op.endLine);
+                const newLines = op.newText.split('\n');
+                lines = [...before, ...newLines, ...after];
+              } else if (op.pattern) {
+                // Pattern-based replacement
+                if (typeof op.replacement !== 'string') {
+                  throw new Error(`'replacement' must be a string for pattern-based replace`);
+                }
+                const regex = new RegExp(op.pattern, op.flags || '');
+                content = lines.join('\n');
+                content = content.replace(regex, op.replacement);
+                lines = content.split('\n');
+              } else {
+                throw new Error('Replace operation requires either startLine/endLine/newText or pattern/replacement');
               }
-              const before = lines.slice(0, op.startLine - 1);
-              const after = lines.slice(op.endLine);
-              const newLines = op.newText.split('\n');
-              lines.splice(0, lines.length, ...before, ...newLines, ...after);
-            } else if (op.pattern) {
-              // Pattern-based replacement
-              const regex = new RegExp(op.pattern, op.flags || '');
-              content = content.replace(regex, op.replacement);
-              // Update lines array for subsequent operations
-              lines.length = 0;
-              lines.push(...content.split('\n'));
-            }
-            break;
-
-          case 'insert':
-            if (op.position === 'start') {
-              lines.unshift(...op.text.split('\n'));
-            } else if (op.position === 'end') {
-              lines.push(...op.text.split('\n'));
-            } else if (op.line !== undefined) {
-              if (op.line < 1 || op.line > lines.length + 1) {
-                throw new Error(`Line number out of range (1-${lines.length + 1})`);
+              break;
+
+            case 'replace_block':
+              if (typeof op.oldText !== 'string' || typeof op.replacementContent !== 'string') {
+                throw new Error('replace_block requires both oldText and replacementContent as strings');
               }
-              const insertLines = op.text.split('\n');
-              lines.splice(op.line - 1, 0, ...insertLines);
-            }
-            break;
+              content = lines.join('\n');
+              if (!content.includes(op.oldText)) {
+                throw new Error('Could not find exact match for oldText in file');
+              }
+              // Check for uniqueness
+              const occurrences = content.split(op.oldText).length - 1;
+              if (occurrences > 1) {
+                throw new Error(`Found ${occurrences} occurrences of oldText. Please be more specific to ensure a unique match.`);
+              }
+              content = content.replace(op.oldText, op.replacementContent);
+              lines = content.split('\n');
+              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 'insert':
+              if (typeof op.text !== 'string') {
+                throw new Error(`'text' must be a string for insert operation`);
+              }
+              if (op.position === 'start') {
+                lines.unshift(...op.text.split('\n'));
+              } else if (op.position === 'end') {
+                lines.push(...op.text.split('\n'));
+              } else if (op.line !== undefined) {
+                if (op.line < 1 || op.line > lines.length + 1) {
+                  throw new Error(`Line number out of range (1-${lines.length + 1})`);
+                }
+                const insertLines = op.text.split('\n');
+                lines.splice(op.line - 1, 0, ...insertLines);
+              } else {
+                throw new Error('Insert operation requires either position (start/end) or line number');
+              }
+              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}`);
+            case 'delete':
+              if (op.startLine === undefined || op.endLine === undefined) {
+                throw new Error('Delete operation requires both startLine and endLine');
+              }
+              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;
+
+            default:
+              throw new Error(`Unknown operation type: ${op.type}`);
+          }
+        } catch (opError) {
+          throw new Error(`Operation #${i + 1} (${op.type}) failed: ${opError.message}`);
         }
       }
 
@@ -592,7 +575,8 @@ const agentUtils = {
       return `Successfully edited ${targetPath}`;
 
     } catch (error) {
-      throw new Error(`Failed to edit file ${typeof inputPathOrObj === 'string' ? inputPathOrObj : inputPathOrObj?.path}: ${error.message}`);
+      const pathInfo = typeof inputPathOrObj === 'string' ? inputPathOrObj : inputPathOrObj?.path;
+      throw new Error(`Failed to edit file ${pathInfo}: ${error.message}`);
     }
   },
 
@@ -1455,225 +1439,145 @@ async function processQuery(query, conversation = [], currentModel) {
   }
 }
 
-async function chat(rl, mode, initialModel) {
-  let currentModel = initialModel;
-  const conversation = [];
-
-  // 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.');
-
-  // Use async iterator pattern instead of event-based 'on' to avoid async callback issues
-  while (true) {
-    const input = await new Promise((resolve) => {
-      rl.question('> ', resolve);
-    });
-
-    // Handle commands
-    if (input.toLowerCase().startsWith('/model')) {
-      const newModel = input.split(' ')[1];
-      if (newModel) {
-        currentModel = newModel;
-        let config = await readConfig() || {};
-        config.MODEL = currentModel;
-        await writeConfig(config);
-        console.log(`Model changed to: ${currentModel}`);
-      } else {
-        console.log('Please specify a model. Usage: /model <model_name>');
-      }
-      continue;
-    }
-
-    if (input.toLowerCase().startsWith('/thoughts')) {
-      const parts = input.trim().split(/\s+/);
-      const arg = parts[1] ? parts[1].toLowerCase() : '';
-      if (arg !== 'on' && arg !== 'off') {
-        const state = SHOW_THOUGHTS ? 'on' : 'off';
-        ui.showInfo(`Usage: /thoughts on|off (currently ${state})`);
-        continue;
-      }
-      const enable = arg === 'on';
-      SHOW_THOUGHTS = enable;
-      let config = await readConfig() || {};
-      config.showThoughts = enable;
-      await writeConfig(config);
-      ui.showResponse(`Hidden thoughts ${enable ? 'enabled' : 'disabled'}.`);
-      continue;
-    }
-
-    if (input.toLowerCase() === '/default-model') {
-      currentModel = 'deepseek/deepseek-chat-v3-0324:free';
-      let config = await readConfig() || {};
-      config.MODEL = currentModel;
-      await writeConfig(config);
-      console.log(`Model reset to default: ${currentModel}`);
-      continue;
-    }
+async function chat(rl, useToolCalling, initialModel) {
+  return new Promise((resolve) => {
+    let currentModel = initialModel;
+    const conversation = [];
 
-    if (input.toLowerCase() === '/setup') {
-      await runSetup(rl, true);
-      console.log('\nSetup complete. Please restart the application to apply changes.');
-      rl.close();
-      return;
+    // Initialize conversation with appropriate system prompt
+    if (useToolCalling) {
+      conversation.push({ role: 'system', content: TOOL_CALLING_PROMPT });
+    } else {
+      conversation.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
     }
 
-    // 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"');
-        continue;
-      }
-
-      // Parse project name and description
-      const match = parts.match(/^"?([^"]+)"?\s+"?([^"]+)"?$/) || parts.match(/^(\S+)\s+(.+)$/);
-      if (!match) {
-        console.log('Usage: /brainstorm <project-name> "<description>"');
-        continue;
-      }
+    console.log('Type your message, or "exit" to quit.');
 
-      const projectName = match[1].trim();
-      const projectDescription = match[2].trim();
-      const outputDir = path.join(process.cwd(), projectName.replace(/\s+/g, '-').toLowerCase());
+    rl.setPrompt('> ');
+    rl.prompt();
 
+    rl.on('line', async (input) => {
       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}`);
-      }
-      continue;
-    }
-
-    // Finish command: /finish <summary>
-    if (input.toLowerCase().startsWith('/finish')) {
-      const summary = input.substring('/finish'.length).trim();
+        // Handle empty input - just reprompt
+        if (!input || !input.trim()) {
+          rl.prompt();
+          return;
+        }
 
-      if (!global.currentSessionDir) {
-        console.log('No active brainstorm session. Use /brainstorm first.');
-        continue;
-      }
+        if (input.toLowerCase().startsWith('/model')) {
+          const newModel = input.split(' ')[1];
+          if (newModel) {
+            currentModel = newModel;
+            let config = await readConfig() || {};
+            config.MODEL = currentModel;
+            await writeConfig(config);
+            console.log(`Model changed to: ${currentModel}`);
+          } else {
+            console.log('Please specify a model. Usage: /model <model_name>');
+          }
+          rl.prompt();
+          return;
+        }
 
-      if (!summary) {
-        console.log('Usage: /finish "<summary of what was accomplished>"');
-        continue;
-      }
+        if (input.toLowerCase().startsWith('/thoughts')) {
+          const parts = input.trim().split(/\s+/);
+          const arg = parts[1] ? parts[1].toLowerCase() : '';
+          if (arg !== 'on' && arg !== 'off') {
+            const state = SHOW_THOUGHTS ? 'on' : 'off';
+            ui.showInfo(`Usage: /thoughts on|off (currently ${state})`);
+            rl.prompt();
+            return;
+          }
+          const enable = arg === 'on';
+          SHOW_THOUGHTS = enable;
+          let config = await readConfig() || {};
+          config.showThoughts = enable;
+          await writeConfig(config);
+          ui.showResponse(`Hidden thoughts ${enable ? 'enabled' : 'disabled'}.`);
+          rl.prompt();
+          return;
+        }
 
-      try {
-        ui.showInfo('Completing brainstorm session...');
-        const result = await brainstormCore.finishBrainstorm({
-          sessionDir: global.currentSessionDir,
-          summary,
-          actor: 'CLAUDE-1'
-        });
+        if (input.toLowerCase() === '/default-model') {
+          currentModel = 'deepseek/deepseek-chat-v3-0324:free';
+          let config = await readConfig() || {};
+          config.MODEL = currentModel;
+          await writeConfig(config);
+          console.log(`Model reset to default: ${currentModel}`);
+          rl.prompt();
+          return;
+        }
 
-        if (result.success) {
-          ui.showSuccess(`✅ Session completed!`);
-          console.log(`   Summary: ${summary}`);
-          global.currentSessionDir = null;
-        } else {
-          ui.showError(`Failed: ${result.errors.join(', ')}`);
+        if (input.toLowerCase() === '/setup') {
+          await runSetup(rl, true);
+          console.log('\nSetup complete. Please restart the application to apply changes.');
+          rl.close();
+          return;
         }
-      } catch (error) {
-        ui.showError(`Failed to finish session: ${error.message}`);
-      }
-      continue;
-    }
 
-    if (input.toLowerCase() === 'exit') {
-      ui.showResponse('Goodbye!');
-      rl.close();
-      return;
-    }
+        if (input.toLowerCase() === 'exit') {
+          rl.close();
+          return;
+        }
 
-    // Direct Harmony tool-call execution from user input (bypass model)
-    try {
-      const seg = parseSegmentedTranscript(input);
-      if (seg && seg.segmented && seg.recoveredToolCalls && seg.recoveredToolCalls.length) {
-        const messages = [];
-        if (useToolCalling) {
-          messages.push({ role: 'system', content: TOOL_CALLING_PROMPT });
-        } else {
-          messages.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
+        // Direct Harmony tool-call execution from user input (bypass model)
+        try {
+          const seg = parseSegmentedTranscript(input);
+          if (seg && seg.segmented && seg.recoveredToolCalls && seg.recoveredToolCalls.length) {
+            const messages = [];
+            if (useToolCalling) {
+              messages.push({ role: 'system', content: TOOL_CALLING_PROMPT });
+            } else {
+              messages.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
+            }
+            messages.push({ role: 'user', content: input });
+            ui.startThinking();
+            const results = await handleToolCalls(seg.recoveredToolCalls, messages);
+            ui.stopThinking();
+            if (results.length === 1) {
+              ui.showSuccess(`Tool '${results[0].name}' executed.`);
+            } else {
+              ui.showSuccess(`Executed ${results.length} tool calls.`);
+            }
+            // Show concise outputs
+            results.forEach(r => {
+              const preview = typeof r.content === 'string' ? r.content : JSON.stringify(r.content);
+              ui.showInfo(`${r.name}: ${preview.length > 300 ? preview.slice(0, 300) + '...' : preview}`);
+            });
+            rl.prompt();
+            return;
+          }
+        } catch (e) {
+          // Fall through to normal processing if parsing/execution fails
         }
-        messages.push({ role: 'user', content: input });
-        ui.startThinking();
-        const results = await handleToolCalls(seg.recoveredToolCalls, messages);
+
+        const result = useToolCalling
+          ? await processQueryWithTools(input, conversation, currentModel)
+          : await processQuery(input, conversation, currentModel);
         ui.stopThinking();
-        if (results.length === 1) {
-          ui.showSuccess(`Tool '${results[0].name}' executed.`);
-        } else {
-          ui.showSuccess(`Executed ${results.length} tool calls.`);
-        }
-        // Show concise outputs
-        results.forEach(r => {
-          const preview = typeof r.content === 'string' ? r.content : JSON.stringify(r.content);
-          ui.showInfo(`${r.name}: ${preview.length > 300 ? preview.slice(0, 300) + '...' : preview}`);
-        });
-        continue;
-      }
-    } catch (e) {
-      // Fall through to normal processing if parsing/execution fails
-    }
+        ui.showResponse(result.response);
 
-    // Main query processing
-    try {
-      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));
 
-      conversation.length = 0;
-      result.conversation.forEach(msg => conversation.push(msg));
-    } catch (error) {
-      ui.stopThinking();
-      console.error('❌ Error processing request:', error.message);
-      if (process.env.DEBUG) {
-        console.error(error.stack);
+        rl.prompt();
+      } catch (error) {
+        ui.stopThinking();
+        ui.showError(`Unexpected error: ${error.message}`);
+        console.error(error);
+        rl.prompt();
       }
-    }
-  }
+    }).on('close', () => {
+      ui.showResponse('Goodbye!');
+      resolve();
+    });
+  });
 }
 
 function askForMode(rl) {
   return new Promise((resolve) => {
-    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');
-      }
+    rl.question('Select mode (1 for tool calling, 2 for function calling): ', (answer) => {
+      resolve(answer.trim() === '1');
     });
   });
 }
@@ -1769,14 +1673,11 @@ async function start() {
     console.log('Select Mode:');
     console.log('1. Tool Calling (for models that support it)');
     console.log('2. Function Calling (legacy)');
-    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`);
+    const useToolCalling = await askForMode(rl);
+    ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
 
-    await chat(rl, selectedMode, MODEL);
-    process.exit(0);
+    await chat(rl, useToolCalling, MODEL);
   } catch (error) {
     ui.showError(error);
     rl.close();
@@ -1784,12 +1685,4 @@ async function start() {
   }
 }
 
-// Keep the process alive and handle uncaught errors
-process.on('uncaughtException', (err) => {
-  console.error('Uncaught Exception:', err.message);
-});
-process.on('unhandledRejection', (reason) => {
-  console.error('Unhandled Rejection:', reason);
-});
-
 start().catch(console.error);