apex-dev 3.0.2 → 3.0.3

package/src/toolExecutors.js

@@ -1,853 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const https = require('https');
-const { execSync } = require('child_process');
-const {
-  PROJECT_ROOT,
-  TOOL_TIMEOUT,
-  REVIEWER_MODEL,
-  REVIEWER_SYSTEM_PROMPT,
-  FILE_PICKER_MODEL,
-  FILE_PICKER_SYSTEM_PROMPT,
-  THINKER_MODEL,
-  THINKER_SYSTEM_PROMPT,
-  COMMANDER_MODEL,
-  COMMANDER_SYSTEM_PROMPT,
-  CONTEXT_PRUNER_MODEL,
-  CONTEXT_PRUNER_SYSTEM_PROMPT,
-  SELECTOR_SYSTEM_PROMPT,
-  NVIDIA_MODEL,
-  nvidiaClient,
-  session,
-  truncateOutput,
-  resolvePath,
-  sleep,
-  getMode,
-} = require('./config');
-
-async function streamCompletion(params, onStream) {
-  for (let attempt = 0; attempt <= 2; attempt++) {
-    let content = '';
-    let reasoning = '';
-    try {
-      if (onStream) {
-        const stream = await nvidiaClient.chat.completions.create({ ...params, stream: true });
-        for await (const chunk of stream) {
-          const delta = chunk.choices?.[0]?.delta;
-          if (delta?.content) {
-            content += delta.content;
-            onStream(content || reasoning);
-          }
-          if (delta?.reasoning_content) {
-            reasoning += delta.reasoning_content;
-            onStream(content || reasoning);
-          }
-        }
-        return content || reasoning || '';
-      } else {
-        const response = await nvidiaClient.chat.completions.create(params);
-        return response.choices[0]?.message?.content
-          || response.choices[0]?.message?.reasoning_content
-          || '';
-      }
-    } catch (err) {
-      if (attempt < 2 && err.status >= 400 && err.status < 500) {
-        await sleep(1000 * Math.pow(2, attempt));
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-
-async function executeTool(name, args, onStream) {
-  try {
-    switch (name) {
-      case 'Read': {
-        const filePath = resolvePath(args.path);
-        const stat = fs.statSync(filePath, { throwIfNoEntry: false });
-        if (!stat) return `Error: File not found: ${filePath}`;
-        if (stat.isDirectory()) return `Error: ${filePath} is a directory. Use ListDir instead.`;
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const lines = content.split('\n');
-        const start = Math.max(0, (args.start_line || 1) - 1);
-        const end = args.end_line ? Math.min(lines.length, args.end_line) : Math.min(lines.length, start + 500);
-        const slice = lines.slice(start, end);
-        const numbered = slice.map((l, i) => `${start + i + 1}: ${l}`).join('\n');
-        session.filesRead.add(filePath);
-        if (end < lines.length) {
-          return truncateOutput(numbered) + `\n(showing lines ${start + 1}-${end} of ${lines.length})`;
-        }
-        return truncateOutput(numbered);
-      }
-
-      case 'Write': {
-        const filePath = resolvePath(args.path);
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        const existed = fs.existsSync(filePath);
-        const before = existed ? fs.readFileSync(filePath, 'utf-8') : null;
-        fs.writeFileSync(filePath, args.content, 'utf-8');
-        if (before !== null) {
-          session.editHistory.push({ path: filePath, before, after: args.content, timestamp: Date.now() });
-        }
-        session.filesModified.add(filePath);
-        const lines = args.content.split('\n').length;
-        return `${existed ? 'Overwritten' : 'Created'}: ${filePath} (${lines} lines)`;
-      }
-
-      case 'Edit': {
-        const filePath = resolvePath(args.path);
-        if (!fs.existsSync(filePath)) return `Error: File not found: ${filePath}`;
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const count = content.split(args.old_str).length - 1;
-        if (count === 0) return `Error: old_str not found in ${path.basename(filePath)}. Make sure it matches exactly (including whitespace and indentation).`;
-        if (count > 1) return `Error: old_str found ${count} times in ${path.basename(filePath)}. It must be unique. Add more surrounding context to make it unique.`;
-        const updated = content.replace(args.old_str, args.new_str);
-        fs.writeFileSync(filePath, updated, 'utf-8');
-        session.editHistory.push({ path: filePath, before: content, after: updated, timestamp: Date.now() });
-        session.filesModified.add(filePath);
-        // Generate a mini diff
-        const oldLines = args.old_str.split('\n');
-        const newLines = args.new_str.split('\n');
-        let diff = `Edited: ${filePath}\n`;
-        oldLines.forEach(l => diff += `- ${l}\n`);
-        newLines.forEach(l => diff += `+ ${l}\n`);
-        return diff;
-      }
-
-      case 'Patch': {
-        const filePath = resolvePath(args.path);
-        if (!fs.existsSync(filePath)) return `Error: File not found: ${filePath}`;
-        let content = fs.readFileSync(filePath, 'utf-8');
-        const before = content;
-        const results = [];
-        for (let i = 0; i < args.edits.length; i++) {
-          const edit = args.edits[i];
-          if (!content.includes(edit.old_str)) {
-            results.push(`Edit ${i + 1}: FAILED - old_str not found`);
-            continue;
-          }
-          content = content.replace(edit.old_str, edit.new_str);
-          results.push(`Edit ${i + 1}: OK`);
-        }
-        fs.writeFileSync(filePath, content, 'utf-8');
-        session.editHistory.push({ path: filePath, before, after: content, timestamp: Date.now() });
-        session.filesModified.add(filePath);
-        return `Patched: ${filePath}\n${results.join('\n')}`;
-      }
-
-      case 'Bash': {
-        const cwd = args.cwd ? resolvePath(args.cwd) : PROJECT_ROOT;
-        session.commandsRun.push(args.command);
-        try {
-          const output = execSync(args.command, {
-            encoding: 'utf-8',
-            timeout: TOOL_TIMEOUT,
-            cwd,
-            maxBuffer: 1024 * 1024 * 5,
-            stdio: ['pipe', 'pipe', 'pipe'],
-          });
-          return truncateOutput(output || '(no output)');
-        } catch (err) {
-          // Return both stdout and stderr on failure
-          const stdout = err.stdout || '';
-          const stderr = err.stderr || '';
-          const exitCode = err.status || 1;
-          return truncateOutput(`Exit code: ${exitCode}\n${stdout}\n${stderr}`.trim());
-        }
-      }
-
-      case 'Grep': {
-        const searchPath = resolvePath(args.path);
-        const flags = args.case_sensitive ? '' : '-i';
-        const include = args.include ? `--include='${args.include}'` : '';
-        try {
-          const cmd = `grep -rn ${flags} ${include} --color=never "${args.pattern.replace(/"/g, '\\"')}" "${searchPath}" 2>/dev/null | head -80`;
-          const output = execSync(cmd, { encoding: 'utf-8', timeout: 15000 });
-          return truncateOutput(output || 'No matches found.');
-        } catch {
-          return 'No matches found.';
-        }
-      }
-
-      case 'Glob': {
-        const cwd = args.cwd ? resolvePath(args.cwd) : PROJECT_ROOT;
-        try {
-          // Use find command to simulate glob
-          const pattern = args.pattern;
-          let cmd;
-          if (pattern.includes('**')) {
-            const namePattern = pattern.replace(/\*\*\//g, '').replace(/\*/g, '*');
-            cmd = `find "${cwd}" -name "${namePattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -100`;
-          } else {
-            cmd = `find "${cwd}" -name "${pattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -100`;
-          }
-          const output = execSync(cmd, { encoding: 'utf-8', timeout: 10000 });
-          if (!output.trim()) return 'No files found matching pattern.';
-          // Make paths relative
-          const files = output.trim().split('\n').map(f => path.relative(cwd, f)).sort();
-          return files.join('\n');
-        } catch {
-          return 'No files found matching pattern.';
-        }
-      }
-
-      case 'ListDir': {
-        const dirPath = resolvePath(args.path);
-        if (!fs.existsSync(dirPath)) return `Error: Directory not found: ${dirPath}`;
-        const stat = fs.statSync(dirPath);
-        if (!stat.isDirectory()) return `Error: ${dirPath} is not a directory.`;
-
-        function listRecursive(dir, depth, maxDepth) {
-          const entries = fs.readdirSync(dir, { withFileTypes: true })
-            .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules')
-            .sort((a, b) => {
-              if (a.isDirectory() && !b.isDirectory()) return -1;
-              if (!a.isDirectory() && b.isDirectory()) return 1;
-              return a.name.localeCompare(b.name);
-            });
-          const lines = [];
-          for (const entry of entries) {
-            const prefix = '  '.repeat(depth);
-            if (entry.isDirectory()) {
-              lines.push(`${prefix}${entry.name}/`);
-              if (depth < maxDepth) {
-                lines.push(...listRecursive(path.join(dir, entry.name), depth + 1, maxDepth));
-              }
-            } else {
-              const size = fs.statSync(path.join(dir, entry.name)).size;
-              const sizeStr = size < 1024 ? `${size}B` : size < 1024 * 1024 ? `${(size / 1024).toFixed(1)}K` : `${(size / (1024 * 1024)).toFixed(1)}M`;
-              lines.push(`${prefix}${entry.name} (${sizeStr})`);
-            }
-          }
-          return lines;
-        }
-
-        const maxDepth = args.recursive ? 3 : 0;
-        const lines = listRecursive(dirPath, 0, maxDepth);
-        return truncateOutput(lines.join('\n') || '(empty directory)');
-      }
-
-      case 'UndoEdit': {
-        const filePath = resolvePath(args.path);
-        const lastEdit = [...session.editHistory].reverse().find(e => e.path === filePath);
-        if (!lastEdit) return `Error: No edit history for ${filePath}`;
-        fs.writeFileSync(filePath, lastEdit.before, 'utf-8');
-        session.editHistory = session.editHistory.filter(e => e !== lastEdit);
-        return `Undone last edit to ${filePath}`;
-      }
-
-      case 'Task': {
-        const results = [];
-        for (const cmd of args.commands) {
-          try {
-            const output = execSync(cmd, {
-              encoding: 'utf-8',
-              timeout: TOOL_TIMEOUT,
-              cwd: PROJECT_ROOT,
-              maxBuffer: 1024 * 1024 * 5,
-              stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            results.push(`✓ ${cmd}\n${output.trim()}`);
-            session.commandsRun.push(cmd);
-          } catch (err) {
-            results.push(`✗ ${cmd}\nExit code: ${err.status}\n${(err.stdout || '').trim()}\n${(err.stderr || '').trim()}`);
-            session.commandsRun.push(cmd);
-            break; // Stop on first failure
-          }
-        }
-        return truncateOutput(`Task: ${args.description}\n${'─'.repeat(40)}\n${results.join('\n\n')}`);
-      }
-
-      case 'WebSearch': {
-        const apiKey = process.env.EXA_API_KEY;
-        if (!apiKey) return 'Error: EXA_API_KEY environment variable is not set. Get one at https://dashboard.exa.ai/api-keys';
-
-        const body = JSON.stringify({
-          query: args.query,
-          numResults: Math.min(args.num_results || 5, 10),
-          type: args.type || 'auto',
-          ...(args.include_domains && { includeDomains: args.include_domains }),
-          ...(args.category && { category: args.category }),
-          contents: { highlights: { maxCharacters: 300 }, text: { maxCharacters: 1000 } },
-        });
-
-        const result = await new Promise((resolve) => {
-          const req = https.request({
-            hostname: 'api.exa.ai',
-            path: '/search',
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'x-api-key': apiKey,
-            },
-          }, (res) => {
-            let data = '';
-            res.on('data', (chunk) => data += chunk);
-            res.on('end', () => {
-              if (res.statusCode !== 200) {
-                resolve(`Error: Exa API returned ${res.statusCode}: ${data}`);
-                return;
-              }
-              try {
-                const json = JSON.parse(data);
-                if (!json.results || json.results.length === 0) {
-                  resolve('No results found.');
-                  return;
-                }
-                const formatted = json.results.map((r, i) => {
-                  let entry = `${i + 1}. **${r.title || 'Untitled'}**\n   ${r.url}`;
-                  if (r.publishedDate) entry += `\n   Published: ${r.publishedDate.split('T')[0]}`;
-                  if (r.author) entry += `\n   Author: ${r.author}`;
-                  if (r.text) entry += `\n   ${r.text.trim().slice(0, 500)}`;
-                  else if (r.highlights && r.highlights.length) entry += `\n   ${r.highlights[0].trim().slice(0, 300)}`;
-                  return entry;
-                }).join('\n\n');
-                resolve(truncateOutput(`Web Search Results (${json.results.length}):\n${'─'.repeat(40)}\n${formatted}`));
-              } catch (e) {
-                resolve(`Error: Failed to parse Exa response: ${e.message}`);
-              }
-            });
-          });
-          req.on('error', (e) => resolve(`Error: Exa request failed: ${e.message}`));
-          req.setTimeout(15000, () => { req.destroy(); resolve('Error: Exa search timed out.'); });
-          req.write(body);
-          req.end();
-        });
-        return result;
-      }
-
-      case 'FilePickerMax': {
-        // Gather full directory tree
-        let tree = '';
-        try {
-          tree = execSync(
-            `find "${PROJECT_ROOT}" -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/.cache/*" -not -path "*/.local/*" -not -path "*/.upm/*" -not -path "*/.config/*" 2>/dev/null | head -500`,
-            { encoding: 'utf-8', timeout: 15000 }
-          ).trim();
-          // Make paths relative
-          tree = tree.split('\n').map(f => path.relative(PROJECT_ROOT, f) || '.').join('\n');
-        } catch {
-          tree = '(failed to scan directory tree)';
-        }
-
-        // Gather previews of all source files (first 8 lines each)
-        const sourceExts = /\.(js|ts|jsx|tsx|py|rb|go|rs|java|c|cpp|h|hpp|css|scss|html|svelte|vue|json|yaml|yml|toml|md|sql|sh|bash|env|cfg|ini|xml)$/i;
-        const allFiles = tree.split('\n').filter(f => sourceExts.test(f));
-        const previews = [];
-        for (const relFile of allFiles.slice(0, 200)) {
-          const absFile = path.resolve(PROJECT_ROOT, relFile);
-          try {
-            const stat = fs.statSync(absFile, { throwIfNoEntry: false });
-            if (!stat || stat.isDirectory() || stat.size > 512 * 1024) continue;
-            const content = fs.readFileSync(absFile, 'utf-8');
-            const first8 = content.split('\n').slice(0, 8).join('\n');
-            previews.push(`--- ${relFile} ---\n${first8}`);
-          } catch { /* skip unreadable */ }
-        }
-
-        const pickerMessages = [
-          { role: 'system', content: FILE_PICKER_SYSTEM_PROMPT },
-          {
-            role: 'user',
-            content: `# Prompt\n${args.prompt}\n\n# Directory Tree\n${tree}\n\n# File Previews (first 8 lines each)\n${previews.join('\n\n')}`,
-          },
-        ];
-
-        try {
-          const header = `FilePickerMax Results\n${'─'.repeat(40)}\n`;
-          const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
-          const raw = await streamCompletion({
-            model: FILE_PICKER_MODEL,
-            messages: pickerMessages,
-            max_tokens: 4096,
-            temperature: 0.2,
-          }, streamCb) || '[]';
-          return truncateOutput(header + raw);
-        } catch (apiErr) {
-          return `Error: FilePickerMax failed — ${apiErr.message}`;
-        }
-      }
-
-      case 'TodoList': {
-        const todoFile = path.join(PROJECT_ROOT, '.apex-todos.json');
-        const loadTodos = () => {
-          try { return JSON.parse(fs.readFileSync(todoFile, 'utf-8')); }
-          catch { return []; }
-        };
-        const saveTodos = (todos) => fs.writeFileSync(todoFile, JSON.stringify(todos, null, 2), 'utf-8');
-        const formatTodos = (todos) => {
-          if (todos.length === 0) return 'Todo list is empty.';
-          return todos.map((t, i) =>
-            `${i + 1}. [${t.done ? 'x' : ' '}] ${t.text}${t.done ? ' ✓' : ''}`
-          ).join('\n');
-        };
-
-        const todos = loadTodos();
-        switch (args.action) {
-          case 'add': {
-            if (!args.text) return 'Error: "text" is required for add action.';
-            todos.push({ text: args.text, done: false, created: Date.now() });
-            saveTodos(todos);
-            return `Added item ${todos.length}: ${args.text}\n\n${formatTodos(todos)}`;
-          }
-          case 'list':
-            return formatTodos(todos);
-          case 'done': {
-            const idx = (args.index || 0) - 1;
-            if (idx < 0 || idx >= todos.length) return `Error: Invalid index. Use 1-${todos.length}.`;
-            todos[idx].done = true;
-            saveTodos(todos);
-            return `Completed: ${todos[idx].text}\n\n${formatTodos(todos)}`;
-          }
-          case 'remove': {
-            const idx = (args.index || 0) - 1;
-            if (idx < 0 || idx >= todos.length) return `Error: Invalid index. Use 1-${todos.length}.`;
-            const removed = todos.splice(idx, 1)[0];
-            saveTodos(todos);
-            return `Removed: ${removed.text}\n\n${formatTodos(todos)}`;
-          }
-          case 'clear': {
-            const before = todos.length;
-            const remaining = todos.filter(t => !t.done);
-            saveTodos(remaining);
-            return `Cleared ${before - remaining.length} completed item(s).\n\n${formatTodos(remaining)}`;
-          }
-          default:
-            return `Error: Unknown action "${args.action}". Use add, list, done, remove, or clear.`;
-        }
-      }
-
-      case 'CodeReview': {
-        // Auto-collect all modified files from this session
-        const allFiles = new Set([...session.filesModified]);
-        // Add any extra files the agent explicitly passed
-        if (args.files && args.files.length) {
-          for (const f of args.files) allFiles.add(resolvePath(f));
-        }
-
-        if (allFiles.size === 0) {
-          return 'CodeReview skipped — no files were modified this session.';
-        }
-
-        // Gather file contents for the reviewer's context
-        const fileContents = [];
-        for (const filePath of allFiles) {
-          if (!fs.existsSync(filePath)) {
-            fileContents.push(`--- ${filePath} ---\n[File not found]`);
-            continue;
-          }
-          const stat = fs.statSync(filePath);
-          if (stat.isDirectory()) continue;
-          const content = fs.readFileSync(filePath, 'utf-8');
-          fileContents.push(`--- ${path.relative(PROJECT_ROOT, filePath) || filePath} ---\n${content}`);
-        }
-
-        // Build git diff of modified files for richer context
-        let gitDiff = '';
-        try {
-          gitDiff = execSync('git diff 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT, timeout: 10000 }).trim();
-        } catch {}
-
-        const reviewMessages = [
-          {
-            role: 'system',
-            content: REVIEWER_SYSTEM_PROMPT,
-          },
-          {
-            role: 'user',
-            content: `# What was changed\n${args.prompt}\n\n# Modified files (${allFiles.size})\n\n${fileContents.join('\n\n')}${gitDiff ? `\n\n# Git diff\n\`\`\`diff\n${gitDiff}\n\`\`\`` : ''}`,
-          },
-        ];
-
-        try {
-          const header = `Code Review (${REVIEWER_MODEL}) — ${allFiles.size} file(s)\n${'─'.repeat(40)}\n`;
-          const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
-          const reviewText = await streamCompletion({
-            model: REVIEWER_MODEL,
-            messages: reviewMessages,
-            max_tokens: 4096,
-            temperature: 0.3,
-          }, streamCb) || '(No response from reviewer)';
-          return truncateOutput(header + reviewText);
-        } catch (apiErr) {
-          return `Error: Code review failed — ${apiErr.message}`;
-        }
-      }
-
-      // ===== Thinker — Deep reasoning/planning =====
-      case 'Thinker': {
-        const historyContext = session.conversationHistory.slice(-10).map(m =>
-          `[${m.role}]: ${(m.content || '').slice(0, 500)}`
-        ).join('\n');
-
-        const thinkerMessages = [
-          { role: 'system', content: THINKER_SYSTEM_PROMPT },
-          {
-            role: 'user',
-            content: `# Recent conversation context\n${historyContext}\n\n# Task to reason about\n${args.prompt}`,
-          },
-        ];
-
-        try {
-          const header = `Thinker (${THINKER_MODEL})\n${'─'.repeat(40)}\n`;
-          const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
-          const result = await streamCompletion({
-            model: THINKER_MODEL,
-            messages: thinkerMessages,
-            max_tokens: 4096,
-            temperature: 0.4,
-          }, streamCb) || '(No response from thinker)';
-          return truncateOutput(header + result);
-        } catch (apiErr) {
-          return `Error: Thinker failed — ${apiErr.message}`;
-        }
-      }
-
-      // ===== ThinkerBestOfN — Multiple reasoning passes, select best =====
-      case 'ThinkerBestOfN': {
-        const mode = getMode();
-        if (mode !== 'max') {
-          return 'ThinkerBestOfN is only available in MAX mode. Use /mode max to enable it, or use Thinker instead.';
-        }
-
-        const n = Math.min(5, Math.max(2, args.n || 3));
-        const historyCtx = session.conversationHistory.slice(-10).map(m =>
-          `[${m.role}]: ${(m.content || '').slice(0, 500)}`
-        ).join('\n');
-
-        const header = `Best-of-${n} Thinker (MAX mode)\n${'─'.repeat(40)}\n`;
-        if (onStream) onStream(header + `Spawning ${n} parallel thinking agents...`);
-
-        // Spawn N parallel thinking calls
-        const thinkPromises = [];
-        for (let i = 0; i < n; i++) {
-          const label = String.fromCharCode(65 + i); // A, B, C, ...
-          thinkPromises.push(
-            streamCompletion({
-              model: THINKER_MODEL,
-              messages: [
-                { role: 'system', content: THINKER_SYSTEM_PROMPT + `\n\nYou are Thinker ${label}. Approach this from a unique angle. Be creative and thorough.` },
-                {
-                  role: 'user',
-                  content: `# Context\n${historyCtx}\n\n# Task\n${args.prompt}`,
-                },
-              ],
-              max_tokens: 3072,
-              temperature: 0.7 + (i * 0.1), // Slightly different temperatures for diversity
-            }, null).then(result => ({ label, result }))
-          );
-        }
-
-        let thoughts;
-        try {
-          thoughts = await Promise.all(thinkPromises);
-        } catch (apiErr) {
-          return `Error: ThinkerBestOfN failed — ${apiErr.message}`;
-        }
-
-        if (onStream) onStream(header + `All ${n} thinkers completed. Selecting best response...`);
-
-        // Format thoughts for selector
-        const thoughtsFormatted = thoughts.map(t =>
-          `## Thought ${t.label}\n${t.result || '(empty)'}`
-        ).join('\n\n');
-
-        // Selector picks the best
-        try {
-          const selectorResult = await streamCompletion({
-            model: REVIEWER_MODEL,
-            messages: [
-              {
-                role: 'system',
-                content: `You are a thought selector. You will receive ${n} different reasoning responses to the same question. Pick the best one based on depth, correctness, clarity, and actionability. Output JSON only:\n{ "chosen": "A", "reason": "why this is best" }`,
-              },
-              { role: 'user', content: `# Original question\n${args.prompt}\n\n${thoughtsFormatted}` },
-            ],
-            max_tokens: 1024,
-            temperature: 0.1,
-          }, null);
-
-          let chosen = 'A';
-          let reason = '';
-          try {
-            const parsed = JSON.parse(selectorResult.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
-            chosen = parsed.chosen || 'A';
-            reason = parsed.reason || '';
-          } catch { /* default to A */ }
-
-          const winningThought = thoughts.find(t => t.label === chosen) || thoughts[0];
-          const result = `${header}Selected: Thought ${chosen}${reason ? ` — ${reason}` : ''}\n\n${winningThought.result}`;
-          if (onStream) onStream(truncateOutput(result));
-          return truncateOutput(result);
-        } catch (apiErr) {
-          // Fallback to first thought
-          const result = `${header}Selector failed, using Thought A:\n\n${thoughts[0].result}`;
-          return truncateOutput(result);
-        }
-      }
-
-      // ===== EditorMultiPrompt — Parallel implementation strategies, select best =====
-      case 'EditorMultiPrompt': {
-        const mode = getMode();
-        if (mode !== 'max') {
-          return 'EditorMultiPrompt is only available in MAX mode. Use /mode max to enable it.';
-        }
-
-        const strategies = args.strategies || ['straightforward implementation', 'alternative approach'];
-        const filesCtx = (args.files || []).map(f =>
-          `--- ${f.path} ---\n${f.content}`
-        ).join('\n\n');
-
-        const header = `Multi-Prompt Editor (${strategies.length} strategies)\n${'─'.repeat(40)}\n`;
-        if (onStream) onStream(header + `Spawning ${strategies.length} parallel editor agents...`);
-
-        // Spawn parallel editor agents, one per strategy
-        const editorPromises = strategies.map((strategy, i) => {
-          const label = String.fromCharCode(65 + i);
-          return streamCompletion({
-            model: NVIDIA_MODEL,
-            messages: [
-              {
-                role: 'system',
-                content: `You are Code Editor ${label}. You implement code changes using a specific strategy. Output your implementation as a series of file edits.\n\nFor each file change, output:\n--- EDIT: path/to/file ---\nOLD:\n\`\`\`\nexact old code\n\`\`\`\nNEW:\n\`\`\`\nnew replacement code\n\`\`\`\n\nFor new files, output:\n--- CREATE: path/to/file ---\n\`\`\`\nfull file content\n\`\`\`\n\nBe precise. Match existing code style.`,
-              },
-              {
-                role: 'user',
-                content: `# Task\n${args.prompt}\n\n# Strategy\n${strategy}\n\n# Current files\n${filesCtx}`,
-              },
-            ],
-            max_tokens: 4096,
-            temperature: 0.3,
-          }, null).then(result => ({ label, strategy, result: result || '(empty)' }));
-        });
-
-        let implementations;
-        try {
-          implementations = await Promise.all(editorPromises);
-        } catch (apiErr) {
-          return `Error: EditorMultiPrompt failed — ${apiErr.message}`;
-        }
-
-        if (onStream) onStream(header + `All editors completed. Selecting best implementation...`);
-
-        // Format implementations for selector
-        const implFormatted = implementations.map(impl =>
-          `## Implementation ${impl.label} — Strategy: "${impl.strategy}"\n${impl.result}`
-        ).join('\n\n');
-
-        // Selector picks the best
-        try {
-          const selectorResult = await streamCompletion({
-            model: REVIEWER_MODEL,
-            messages: [
-              { role: 'system', content: SELECTOR_SYSTEM_PROMPT },
-              {
-                role: 'user',
-                content: `# Original task\n${args.prompt}\n\n${implFormatted}`,
-              },
-            ],
-            max_tokens: 1024,
-            temperature: 0.1,
-          }, null);
-
-          let chosen = 'A';
-          let reason = '';
-          let improvements = '';
-          try {
-            const parsed = JSON.parse(selectorResult.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
-            chosen = parsed.chosen || 'A';
-            reason = parsed.reason || '';
-            improvements = parsed.improvements || '';
-          } catch { /* default to A */ }
-
-          const winning = implementations.find(impl => impl.label === chosen) || implementations[0];
-          let result = `${header}Selected: Implementation ${chosen} ("${winning.strategy}")`;
-          if (reason) result += `\nReason: ${reason}`;
-          if (improvements) result += `\nImprovements to consider: ${improvements}`;
-          result += `\n\n${winning.result}`;
-          if (onStream) onStream(truncateOutput(result));
-          return truncateOutput(result);
-        } catch (apiErr) {
-          const result = `${header}Selector failed, using Implementation A:\n\n${implementations[0].result}`;
-          return truncateOutput(result);
-        }
-      }
-
-      // ===== CodeReviewMulti — Multiple review perspectives in parallel =====
-      case 'CodeReviewMulti': {
-        const mode = getMode();
-        if (mode !== 'max') {
-          return 'CodeReviewMulti is only available in MAX mode. Use /mode max to enable it, or use CodeReview for a single review.';
-        }
-
-        const perspectives = args.perspectives || [
-          'correctness, logic errors, and edge cases',
-          'security vulnerabilities and data safety',
-          'performance, efficiency, and resource usage',
-        ];
-
-        // Gather modified files
-        const modFiles = new Set([...session.filesModified]);
-        if (modFiles.size === 0) return 'CodeReviewMulti skipped — no files were modified.';
-
-        const modFileContents = [];
-        for (const fp of modFiles) {
-          if (!fs.existsSync(fp)) continue;
-          const stat = fs.statSync(fp);
-          if (stat.isDirectory()) continue;
-          modFileContents.push(`--- ${path.relative(PROJECT_ROOT, fp)} ---\n${fs.readFileSync(fp, 'utf-8')}`);
-        }
-
-        let diffText = '';
-        try {
-          diffText = execSync('git diff 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT, timeout: 10000 }).trim();
-        } catch {}
-
-        const header = `Multi-Perspective Code Review (${perspectives.length} reviewers)\n${'─'.repeat(40)}\n`;
-        if (onStream) onStream(header + `Spawning ${perspectives.length} parallel reviewers...`);
-
-        const reviewPromises = perspectives.map((perspective, i) => {
-          const label = String.fromCharCode(65 + i);
-          return streamCompletion({
-            model: REVIEWER_MODEL,
-            messages: [
-              {
-                role: 'system',
-                content: REVIEWER_SYSTEM_PROMPT + `\n\nFocus specifically on: ${perspective}. You are Reviewer ${label}.`,
-              },
-              {
-                role: 'user',
-                content: `# Changes\n${args.prompt}\n\n# Files (${modFiles.size})\n${modFileContents.join('\n\n')}${diffText ? `\n\n# Git diff\n\`\`\`diff\n${diffText}\n\`\`\`` : ''}`,
-              },
-            ],
-            max_tokens: 3072,
-            temperature: 0.3,
-          }, null).then(result => ({ label, perspective, result: result || '(no issues found)' }));
-        });
-
-        let reviews;
-        try {
-          reviews = await Promise.all(reviewPromises);
-        } catch (apiErr) {
-          return `Error: CodeReviewMulti failed — ${apiErr.message}`;
-        }
-
-        let result = header;
-        for (const review of reviews) {
-          result += `\n## Reviewer ${review.label} — ${review.perspective}\n${review.result}\n`;
-        }
-        if (onStream) onStream(truncateOutput(result));
-        return truncateOutput(result);
-      }
-
-      // ===== Commander — Terminal command specialist =====
-      case 'Commander': {
-        const header = `Commander (${COMMANDER_MODEL})\n${'─'.repeat(40)}\n`;
-        if (onStream) onStream(header + 'Planning commands...');
-
-        let commandPlan;
-        try {
-          commandPlan = await streamCompletion({
-            model: COMMANDER_MODEL,
-            messages: [
-              { role: 'system', content: COMMANDER_SYSTEM_PROMPT },
-              { role: 'user', content: args.prompt },
-            ],
-            max_tokens: 2048,
-            temperature: 0.2,
-          }, null);
-        } catch (apiErr) {
-          return `Error: Commander failed — ${apiErr.message}`;
-        }
-
-        // Parse command plan
-        let commands;
-        try {
-          commands = JSON.parse(commandPlan.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
-          if (!Array.isArray(commands)) commands = [commands];
-        } catch {
-          return truncateOutput(`${header}Failed to parse command plan:\n${commandPlan}`);
-        }
-
-        // Execute commands in sequence
-        const results = [];
-        for (const cmd of commands) {
-          const command = typeof cmd === 'string' ? cmd : cmd.command;
-          const description = typeof cmd === 'string' ? '' : (cmd.description || '');
-          if (onStream) onStream(truncateOutput(`${header}Running: ${command}${description ? ` (${description})` : ''}...`));
-          try {
-            const output = execSync(command, {
-              encoding: 'utf-8',
-              timeout: TOOL_TIMEOUT,
-              cwd: PROJECT_ROOT,
-              maxBuffer: 1024 * 1024 * 5,
-              stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            results.push(`✓ ${command}${description ? `\n  (${description})` : ''}\n${(output || '').trim()}`);
-            session.commandsRun.push(command);
-          } catch (err) {
-            results.push(`✗ ${command}\nExit code: ${err.status}\n${(err.stdout || '').trim()}\n${(err.stderr || '').trim()}`);
-            session.commandsRun.push(command);
-            break;
-          }
-        }
-
-        const result = `${header}${results.join('\n\n')}`;
-        if (onStream) onStream(truncateOutput(result));
-        return truncateOutput(result);
-      }
-
-      // ===== ContextPruner — Conversation summarization =====
-      case 'ContextPruner': {
-        if (session.conversationHistory.length < 6) {
-          return 'Context pruning skipped — conversation is still short.';
-        }
-
-        const header = `Context Pruner\n${'─'.repeat(40)}\n`;
-        if (onStream) onStream(header + 'Summarizing conversation...');
-
-        const historyText = session.conversationHistory.map(m =>
-          `[${m.role}]: ${(m.content || '').slice(0, 1000)}`
-        ).join('\n');
-
-        try {
-          const summary = await streamCompletion({
-            model: CONTEXT_PRUNER_MODEL,
-            messages: [
-              { role: 'system', content: CONTEXT_PRUNER_SYSTEM_PROMPT },
-              { role: 'user', content: `# Conversation to summarize (${session.conversationHistory.length} messages)\n\n${historyText}` },
-            ],
-            max_tokens: 2048,
-            temperature: 0.2,
-          }, null);
-
-          // Replace conversation history with summary
-          const oldLen = session.conversationHistory.length;
-          session.conversationHistory = [
-            {
-              role: 'system',
-              content: `[Context Summary — ${oldLen} messages condensed]\n${summary}`,
-            },
-          ];
-
-          const result = `${header}Condensed ${oldLen} messages into summary.\n\n${summary}`;
-          if (onStream) onStream(truncateOutput(result));
-          return truncateOutput(result);
-        } catch (apiErr) {
-          return `Error: Context pruning failed — ${apiErr.message}`;
-        }
-      }
-
-      default:
-        return `Unknown tool: ${name}`;
-    }
-  } catch (err) {
-    return `Error executing ${name}: ${err.message}`;
-  }
-}
-
-module.exports = { executeTool };