apex-dev 1.0.0

package/index.js

@@ -0,0 +1,1587 @@
+#!/usr/bin/env node
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const boxen = require('boxen');
+const figures = require('figures');
+const readline = require('readline');
+const { highlight } = require('cli-highlight');
+const OpenAI = require('openai');
+const fs = require('fs');
+const path = require('path');
+const { execSync, exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+
+// ===== Config =====
+const NVIDIA_MODEL = 'nvidia/llama-3.1-nemotron-ultra-253b-v1';
+const REVIEWER_MODEL = 'nvidia/llama-3.1-nemotron-ultra-253b-v1';
+const MAX_TOOL_ITERATIONS = 50;
+const MAX_OUTPUT_LEN = 12000;
+const TOOL_TIMEOUT = 60000;
+const PROJECT_ROOT = process.cwd();
+
+const nvidiaClient = new OpenAI({
+  apiKey: process.env.NVIDIA_API_KEY || '',
+  baseURL: 'https://integrate.api.nvidia.com/v1',
+});
+
+// ===== Session State =====
+const session = {
+  conversationHistory: [],
+  totalTokens: 0,
+  totalCost: 0,
+  toolCallCount: 0,
+  filesModified: new Set(),
+  filesRead: new Set(),
+  commandsRun: [],
+  editHistory: [],       // { path, before, after, timestamp }
+  startTime: Date.now(),
+  turnCount: 0,
+};
+
+// ===== Agentic System Prompt =====
+function buildSystemPrompt() {
+  let gitInfo = '';
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT }).trim();
+    const status = execSync('git status --short 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT }).trim();
+    const remoteUrl = execSync('git config --get remote.origin.url 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT }).trim();
+    gitInfo = `\nGit branch: ${branch}\nGit remote: ${remoteUrl}\nGit status:\n${status || '(clean)'}`;
+  } catch {}
+
+  let projectInfo = '';
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf-8'));
+    projectInfo = `\nProject: ${pkg.name || 'unknown'} v${pkg.version || '0.0.0'}`;
+    if (pkg.dependencies) projectInfo += `\nDependencies: ${Object.keys(pkg.dependencies).join(', ')}`;
+    if (pkg.devDependencies) projectInfo += `\nDev dependencies: ${Object.keys(pkg.devDependencies).join(', ')}`;
+    if (pkg.scripts) projectInfo += `\nScripts: ${Object.keys(pkg.scripts).join(', ')}`;
+  } catch {}
+
+  return `detailed thinking on
+
+You are Apex AI, a friendly and approachable coding assistant. You're warm, helpful, and conversational — like a knowledgeable friend who loves coding.
+
+# Personality
+
+- Be friendly, warm, and encouraging. Use a casual but professional tone.
+- When a user asks a question that doesn't need any tools (like general knowledge, advice, greetings, or casual chat), just answer directly and naturally. You do NOT always need to use tools — only use them when the task actually requires reading, writing, or executing something on the filesystem.
+- NEVER say things like "I don't have any tool to call" or "I don't have the tools for that." Just respond helpfully with what you know.
+- If you're unsure, say so honestly, but still try your best to help.
+
+# Core Principles
+
+1. **Take initiative.** When asked to do something, DO it — don't just explain how. Use your tools to read, write, edit, and execute code until the task is COMPLETE.
+2. **Read before you edit.** NEVER modify a file you haven't read first. Always understand existing code before making changes.
+3. **Work incrementally.** Make small changes, verify they work (run tests, check syntax), then continue. Don't make huge changes blind.
+4. **Verify your work.** After making changes, run the relevant tests, linter, or type checker. If something fails, fix it before responding.
+5. **Follow conventions.** Match the existing code style, frameworks, libraries, and patterns. Check imports and neighboring files first.
+6. **Minimal changes.** Only change what's needed. Don't refactor, add features, or "improve" code beyond what was asked.
+7. **Keep going.** If a tool call fails, try to recover. If you need more context, read more files. Don't give up after one attempt.
+
+# Tool Usage
+
+- Use Bash for running commands (tests, builds, linters, git operations)
+- Use Read to understand files before modifying them
+- Use Grep/Glob/ListDir to explore the codebase and find relevant code
+- Use Edit for surgical changes to existing files (preferred over Write for existing files)
+- Use Write only for creating new files
+- Use Patch for making multiple edits to the same file at once
+- Execute multiple independent tool calls in parallel when possible
+- After editing code, verify with: syntax check, run tests, or at minimum read the changed section
+
+# Workflow for Code Tasks
+
+1. Explore: Use ListDir, Glob, Grep to understand the codebase structure
+2. Read: Read relevant files to understand context, conventions, dependencies
+3. Plan: Think about what changes are needed (briefly)
+4. Implement: Make changes using Edit/Write
+5. Verify: Run tests or check the result with Bash
+6. Iterate: If verification fails, fix and re-verify
+7. **Review: ALWAYS call CodeReview as the FINAL step after any code changes.** Pass a summary of what you did. It will auto-detect all files you modified and send them to a senior reviewer sub-agent. If the reviewer finds critical or warning-level issues, fix them before responding to the user.
+
+# Environment
+Working directory: ${PROJECT_ROOT}
+OS: ${process.platform}
+Node: ${process.version}${projectInfo}${gitInfo}
+
+# Important
+- You can call multiple tools at once — do so when the calls are independent
+- Don't ask for permission to use tools — just use them
+- Don't explain what you're going to do in detail — just do it and summarize what you did
+- If the user asks you to fix something, find the bug AND fix it
+- If the user asks you to build something, build it completely and verify it works
+- Maximum tool iterations per turn: ${MAX_TOOL_ITERATIONS}`;
+}
+
+// ===== Tool Definitions =====
+const toolDefs = [
+  {
+    type: 'function',
+    function: {
+      name: 'Read',
+      description: 'Read the contents of a file. Returns line-numbered content. Always read a file before editing it.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path to read (absolute or relative to project root).' },
+          start_line: { type: 'number', description: 'Start line (1-indexed). Omit to read from beginning.' },
+          end_line: { type: 'number', description: 'End line (1-indexed). Omit to read to end (max 500 lines).' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Write',
+      description: 'Create a new file or completely overwrite an existing file. For modifying existing files, prefer Edit instead.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path to write.' },
+          content: { type: 'string', description: 'Full content to write.' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Edit',
+      description: 'Replace an exact string in a file with new content. The old_str must match exactly (including whitespace). For existing files, this is preferred over Write.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path to edit.' },
+          old_str: { type: 'string', description: 'Exact string to find (must be unique in the file).' },
+          new_str: { type: 'string', description: 'Replacement string.' },
+        },
+        required: ['path', 'old_str', 'new_str'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Patch',
+      description: 'Apply multiple find-and-replace edits to a single file atomically. Use when you need to make several changes to the same file.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path to patch.' },
+          edits: {
+            type: 'array',
+            description: 'Array of edits to apply in order.',
+            items: {
+              type: 'object',
+              properties: {
+                old_str: { type: 'string', description: 'Exact string to find.' },
+                new_str: { type: 'string', description: 'Replacement string.' },
+              },
+              required: ['old_str', 'new_str'],
+            },
+          },
+        },
+        required: ['path', 'edits'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Bash',
+      description: 'Execute a shell command. Use for running tests, builds, git commands, installing packages, checking syntax, etc. Commands have a 60-second timeout.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Shell command to execute.' },
+          cwd: { type: 'string', description: 'Working directory (defaults to project root).' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Grep',
+      description: 'Search for a pattern across files using regex. Returns matching lines with file paths and line numbers.',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Regex pattern to search for.' },
+          path: { type: 'string', description: 'Directory or file to search in (defaults to project root).' },
+          include: { type: 'string', description: 'File glob pattern to include, e.g. "*.js" or "*.ts"' },
+          case_sensitive: { type: 'boolean', description: 'Case-sensitive search (default: false).' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Glob',
+      description: 'Find files matching a glob pattern. Returns file paths sorted by modification time.',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Glob pattern like "**/*.js", "src/**/*.ts", "*.json"' },
+          cwd: { type: 'string', description: 'Base directory for the search (defaults to project root).' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'ListDir',
+      description: 'List the contents of a directory. Shows files and subdirectories with type indicators.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory path to list (defaults to project root).' },
+          recursive: { type: 'boolean', description: 'If true, list recursively (max depth 3).' },
+        },
+        required: [],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'UndoEdit',
+      description: 'Undo the last edit made to a specific file, restoring its previous content.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path to undo the last edit for.' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Task',
+      description: 'Spawn a sub-task by executing a sequence of shell commands for a complex multi-step operation. Useful for build-test-fix cycles.',
+      parameters: {
+        type: 'object',
+        properties: {
+          description: { type: 'string', description: 'Brief description of the task.' },
+          commands: {
+            type: 'array',
+            description: 'Shell commands to execute in sequence. Stops on first failure.',
+            items: { type: 'string' },
+          },
+        },
+        required: ['description', 'commands'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'CodeReview',
+      description: 'MANDATORY — call this as the FINAL step after completing any code-writing or code-editing task. Spawns a code-review sub-agent that reviews ALL files you modified during this turn. Provide a summary of what you built/changed so the reviewer has context. The reviewer will analyse your changes for bugs, logic errors, style issues, and missed edge cases, then return its findings. If the reviewer finds problems, fix them before responding to the user.',
+      parameters: {
+        type: 'object',
+        properties: {
+          prompt: { type: 'string', description: 'Summary of what you built or changed, so the reviewer understands the intent behind the code. Include the original user request and any key design decisions.' },
+          files: {
+            type: 'array',
+            description: 'Additional file paths to include beyond the auto-detected modified files (e.g. related files for context). Modified files are always included automatically.',
+            items: { type: 'string' },
+          },
+        },
+        required: ['prompt'],
+      },
+    },
+  },
+];
+
+// ===== Tool Executors =====
+function truncateOutput(str) {
+  if (str.length > MAX_OUTPUT_LEN) {
+    return str.slice(0, MAX_OUTPUT_LEN) + `\n... (truncated, ${str.length} chars total)`;
+  }
+  return str;
+}
+
+function resolvePath(p) {
+  if (!p) return PROJECT_ROOT;
+  return path.isAbsolute(p) ? p : path.resolve(PROJECT_ROOT, p);
+}
+
+async function executeTool(name, args) {
+  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 '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: `You are a senior code reviewer. An AI coding assistant just made changes to a codebase. Your job is to review those changes thoroughly and report issues. Be specific — reference exact line numbers, function names, and variables.
+
+Focus on:
+1. **Bugs & logic errors** — incorrect conditions, off-by-one, null/undefined risks, race conditions
+2. **Security** — exposed secrets, injection risks, unsafe operations
+3. **Edge cases** — unhandled inputs, missing error handling at boundaries
+4. **Code quality** — naming, readability, dead code, unnecessary complexity
+5. **Correctness** — does the code actually fulfil the stated intent?
+
+If everything looks good, say so briefly. If there are problems, list them clearly with severity (critical / warning / nit). You have no tools; your only output is this review.`,
+          },
+          {
+            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 reviewResponse = await nvidiaClient.chat.completions.create({
+            model: REVIEWER_MODEL,
+            messages: reviewMessages,
+            max_tokens: 4096,
+            temperature: 0.3,
+          });
+          const reviewText = reviewResponse.choices[0]?.message?.content || '(No response from reviewer)';
+          return truncateOutput(`Code Review (${REVIEWER_MODEL}) — ${allFiles.size} file(s)\n${'─'.repeat(40)}\n${reviewText}`);
+        } catch (apiErr) {
+          return `Error: Code review failed — ${apiErr.message}`;
+        }
+      }
+
+      default:
+        return `Unknown tool: ${name}`;
+    }
+  } catch (err) {
+    return `Error executing ${name}: ${err.message}`;
+  }
+}
+
+// ===== Theme =====
+const t = {
+  brand:    chalk.hex('#818cf8'),
+  brandBold:chalk.hex('#818cf8').bold,
+  accent:   chalk.hex('#a78bfa'),
+  dim:      chalk.hex('#5a5a72'),
+  muted:    chalk.hex('#8888a0'),
+  text:     chalk.hex('#e4e4ed'),
+  green:    chalk.hex('#22c55e'),
+  greenBg:  chalk.bgHex('#22c55e').hex('#000'),
+  yellow:   chalk.hex('#eab308'),
+  yellowBg: chalk.bgHex('#eab308').hex('#000'),
+  red:      chalk.hex('#ef4444'),
+  redBg:    chalk.bgHex('#ef4444').hex('#fff'),
+  blue:     chalk.hex('#3b82f6'),
+  blueBg:   chalk.bgHex('#3b82f6').hex('#fff'),
+  cyan:     chalk.hex('#22d3ee'),
+  orange:   chalk.hex('#f97316'),
+  orangeBg: chalk.bgHex('#f97316').hex('#000'),
+  purple:   chalk.hex('#a855f7'),
+  purpleBg: chalk.bgHex('#a855f7').hex('#fff'),
+  bar:      chalk.hex('#2a2a3a'),
+  codeBg:   chalk.bgHex('#16161f'),
+};
+
+// ===== Layout Helpers =====
+const COLS = Math.min(process.stdout.columns || 80, 120);
+
+function hr(char = '─', color = t.bar) {
+  return color(char.repeat(COLS));
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function indent(str, n = 2) {
+  const prefix = ' '.repeat(n);
+  return str.split('\n').map(l => prefix + l).join('\n');
+}
+
+// ===== Header =====
+function showHeader() {
+  console.clear();
+  let branch = 'main';
+  try { branch = execSync('git rev-parse --abbrev-ref HEAD 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT }).trim(); } catch {}
+
+  const logo = t.brandBold('⬡ Apex') + t.accent(' AI');
+  const model = t.dim('model: ') + t.text(NVIDIA_MODEL);
+  const reasoning = t.accent('⟡') + t.dim(' reasoning ') + t.green('ON');
+  const branchLabel = t.brand('⎇') + t.accent(` ${branch}`);
+  const status = t.green(figures.bullet) + t.dim(' connected');
+
+  console.log();
+  console.log(indent(`${logo}  ${t.bar('│')}  ${model}  ${t.bar('│')}  ${reasoning}  ${t.bar('│')}  ${branchLabel}  ${t.bar('│')}  ${status}`));
+  console.log(indent(hr()));
+  console.log();
+}
+
+// ===== Welcome =====
+function showWelcome() {
+  const title = t.text.bold('What can I help you build?');
+  const subtitle = t.muted('I can read, write, execute code, and autonomously complete tasks in your project.');
+
+  console.log(indent(title));
+  console.log(indent(subtitle));
+  console.log();
+
+  const actions = [
+    [t.blue(figures.info),    t.muted('Explore & explain the codebase')],
+    [t.red(figures.cross),    t.muted('Find & fix bugs autonomously')],
+    [t.green(figures.tick),   t.muted('Write & run tests')],
+    [t.yellow(figures.warning), t.muted('Refactor & optimize')],
+    [t.cyan('⚡'),             t.muted('Build features end-to-end')],
+    [t.purple('⎇'),           t.muted('Git operations & code review')],
+  ];
+
+  actions.forEach(([icon, label]) => {
+    console.log(indent(`  ${icon}  ${label}`));
+  });
+  console.log();
+  console.log(indent(t.dim(`Tools: Read, Write, Edit, Patch, Bash, Grep, Glob, ListDir, UndoEdit, Task, CodeReview`)));
+  console.log(indent(t.dim(`Max ${MAX_TOOL_ITERATIONS} autonomous tool calls per turn`)));
+  console.log();
+  console.log(indent(hr()));
+  console.log();
+}
+
+// ===== Reasoning (Think Block) Parser =====
+function parseThinkBlocks(text) {
+  const thinkRegex = /<think>([\s\S]*?)(?:<\/think>|think>)/g;
+  const thoughts = [];
+  let match;
+  while ((match = thinkRegex.exec(text)) !== null) {
+    const content = match[1].trim();
+    if (content) thoughts.push(content);
+  }
+  const cleaned = text.replace(/<think>[\s\S]*?(?:<\/think>|think>)/g, '').trim();
+  return { thoughts, content: cleaned };
+}
+function findThinkClose(text) {
+  const fullClose = text.indexOf('</think>');
+  if (fullClose !== -1) return { pos: fullClose, len: 8 };
+  // Look for bare 'think>' but not as part of '<think>'
+  let searchFrom = 0;
+  while (searchFrom < text.length) {
+    const idx = text.indexOf('think>', searchFrom);
+    if (idx === -1) break;
+    if (idx === 0 || text[idx - 1] !== '<') return { pos: idx, len: 6 };
+    searchFrom = idx + 6;
+  }
+  return null;
+}
+function stripStrayCloseTag(text) {
+  return text.replace(/<\/think>/g, '').replace(/(?<!<)think>/g, '');
+}
+function splitAtPartialTag(text) {
+  const prefixes = [
+    '</think>', '</think', '</thin', '</thi', '</th', '</t', '</',
+    '<think>', '<think', '<thin', '<thi', '<th', '<t',
+    'think>', 'think', 'thin', 'thi', 'th',
+    '<',
+  ];
+  for (const prefix of prefixes) {
+    if (text.endsWith(prefix)) {
+      // If it's a complete closing tag, strip it entirely (stray closing tag)
+      if (prefix === '</think>' || prefix === 'think>') {
+        return { safe: text.slice(0, -prefix.length), pending: '' };
+      }
+      return { safe: text.slice(0, -prefix.length), pending: prefix };
+    }
+  }
+  return { safe: text, pending: '' };
+}
+function showThinkingBlock(thoughts) {
+  if (!thoughts.length) return;
+  const combined = thoughts.join('\n\n');
+  const lines = combined.split('\n');
+  const maxLines = 15;
+  const preview = lines.length > maxLines ? lines.slice(0, maxLines) : lines;
+  const isTruncated = lines.length > maxLines;
+
+  // Calculate dimensions
+  const boxWidth = Math.min(COLS - 8, 70);
+  const contentWidth = boxWidth - 4;
+
+  // Header with icon and label
+  const headerIcon = t.purple('🧠');
+  const headerLabel = t.purple.bold('Thinking');
+  const timestamp = t.dim(new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }));
+  const lineCount = t.dim(`${lines.length} lines`);
+
+  // Top border with gradient effect
+  const topLine = t.dim('┌') + t.purple('─'.repeat(Math.floor(boxWidth / 2))) + t.accent('─'.repeat(Math.ceil(boxWidth / 2))) + t.dim('┐');
+  
+  console.log(indent(topLine));
+  console.log(indent(t.dim('│') + ' ' + headerIcon + ' ' + headerLabel + t.dim(' · ') + timestamp + t.dim(' · ') + lineCount + ' '.repeat(Math.max(0, boxWidth - stripAnsi(headerIcon + headerLabel + timestamp + lineCount).length - 8)) + t.dim('│')));
+  
+  // Divider
+  console.log(indent(t.dim('├') + t.purple('─'.repeat(boxWidth)) + t.dim('┤')));
+  
+  // Content lines with word wrap
+  for (const line of preview) {
+    // Word wrap long lines
+    const words = line.split(' ');
+    let currentLine = '';
+    for (const word of words) {
+      // Handle words longer than contentWidth
+      if (word.length > contentWidth) {
+        if (currentLine) {
+          console.log(indent(t.dim('│ ') + t.dim.italic(currentLine.trim()) + ' '.repeat(Math.max(0, contentWidth - stripAnsi(currentLine).length)) + t.dim('│')));
+          currentLine = '';
+        }
+        // Split long word into chunks
+        for (let i = 0; i < word.length; i += contentWidth) {
+          const chunk = word.slice(i, i + contentWidth);
+          console.log(indent(t.dim('│ ') + t.dim.italic(chunk) + ' '.repeat(Math.max(0, contentWidth - chunk.length)) + t.dim('│')));
+        }
+        continue;
+      }
+      if ((currentLine + ' ' + word).trim().length > contentWidth) {
+        if (currentLine) {
+          console.log(indent(t.dim('│ ') + t.dim.italic(currentLine.trim()) + ' '.repeat(Math.max(0, contentWidth - stripAnsi(currentLine).length)) + t.dim('│')));
+        }
+        currentLine = word;
+      } else {
+        currentLine = (currentLine + ' ' + word).trim();
+      }
+    }
+    if (currentLine) {
+      console.log(indent(t.dim('│ ') + t.dim.italic(currentLine) + ' '.repeat(Math.max(0, contentWidth - stripAnsi(currentLine).length)) + t.dim('│')));
+    }
+  }
+
+  // Truncation indicator
+  if (isTruncated) {
+    const moreText = t.yellow(`+ ${lines.length - maxLines} more lines (scroll to see all)`);
+    console.log(indent(t.dim('│ ') + moreText + ' '.repeat(Math.max(0, contentWidth - stripAnsi(moreText).length)) + t.dim('│')));
+  }
+
+  // Bottom border
+  console.log(indent(t.dim('└' + '─'.repeat(boxWidth)) + t.dim('┘')));
+  console.log();
+}
+
+// ===== Message Display =====
+function showUserMessage(text) {
+  const header = t.blueBg(' U ') + ' ' + chalk.white.bold('You') + '  ' + t.dim(timestamp());
+  console.log(indent(header));
+  console.log(indent(t.text(text), 6));
+  console.log();
+}
+
+function showAssistantHeader() {
+  const header = t.brand('✦') + ' ' + t.brandBold('Apex AI') + '  ' + t.dim(timestamp());
+  console.log(indent(header));
+}
+
+function showAssistantMessage(text) {
+  const lines = text.split('\n');
+  const formatted = [];
+  let inCodeBlock = false;
+  let codeLines = [];
+  let codeLang = '';
+
+  for (const line of lines) {
+    if (line.startsWith('```') && !inCodeBlock) {
+      inCodeBlock = true;
+      codeLang = line.slice(3).trim() || 'code';
+      codeLines = [];
+    } else if (line.startsWith('```') && inCodeBlock) {
+      inCodeBlock = false;
+      formatted.push(renderCodeBlock(codeLines.join('\n'), codeLang));
+    } else if (inCodeBlock) {
+      codeLines.push(line);
+    } else {
+      const processed = line.replace(/`([^`]+)`/g, (_, code) => t.cyan(code));
+      formatted.push(t.text(processed));
+    }
+  }
+
+  console.log(indent(formatted.join('\n'), 4));
+  console.log();
+}
+
+// ===== Code Block =====
+function renderCodeBlock(code, lang) {
+  const width = Math.min(COLS - 8, 80);
+  const topBar = t.dim('┌─') + t.accent(` ${lang} `) + t.dim('─'.repeat(Math.max(0, width - lang.length - 4)) + '┐');
+  const bottomBar = t.dim('└' + '─'.repeat(width) + '┘');
+
+  let highlighted;
+  try {
+    highlighted = highlight(code, { language: lang, ignoreIllegals: true });
+  } catch {
+    highlighted = t.text(code);
+  }
+
+  const cLines = highlighted.split('\n').map((line, i) => {
+    const lineNo = t.dim(String(i + 1).padStart(3) + ' │ ');
+    return t.dim('│') + lineNo + line;
+  });
+
+  return [topBar, ...cLines, bottomBar].join('\n');
+}
+
+// ===== Tool Badges =====
+function toolBadge(name) {
+  const badges = {
+    'Read':     t.blueBg(` ${name} `),
+    'Edit':     t.yellowBg(` ${name} `),
+    'Write':    t.yellowBg(` ${name} `),
+    'Patch':    t.orangeBg(` ${name} `),
+    'Bash':     t.greenBg(` ${name} `),
+    'Grep':     t.purpleBg(` ${name} `),
+    'Glob':     t.purpleBg(` ${name} `),
+    'ListDir':  chalk.bgHex('#06b6d4').hex('#000')(` ${name} `),
+    'UndoEdit': t.redBg(` ${name} `),
+    'Task':       t.orangeBg(` ${name} `),
+    'CodeReview': chalk.bgHex('#76b900').hex('#000')(` ${name} `),
+  };
+  return badges[name] || chalk.bgHex('#6366f1').hex('#fff')(` ${name} `);
+}
+
+function toolDetail(name, args) {
+  switch (name) {
+    case 'Bash': return args.command || '';
+    case 'Grep': return `"${args.pattern}"${args.path ? ` in ${args.path}` : ''}`;
+    case 'Glob': return args.pattern || '';
+    case 'ListDir': return args.path || '.';
+    case 'Read': {
+      let d = args.path || '';
+      if (args.start_line) d += `:${args.start_line}-${args.end_line || ''}`;
+      return d;
+    }
+    case 'Write': return args.path || '';
+    case 'Edit': return args.path || '';
+    case 'Patch': return `${args.path} (${(args.edits || []).length} edits)`;
+    case 'UndoEdit': return args.path || '';
+    case 'Task': return args.description || '';
+    case 'CodeReview': {
+      const extra = (args.files || []).length;
+      const modCount = session.filesModified.size;
+      return `${modCount} modified${extra ? ` + ${extra} extra` : ''} — ${(args.prompt || '').slice(0, 50)}`;
+    }
+    default: return JSON.stringify(args).slice(0, 80);
+  }
+}
+
+// ===== Tool Call Display =====
+async function showToolCall(name, detail, startTime) {
+  const spinner = ora({
+    text: `${toolBadge(name)}  ${t.muted(detail.length > 80 ? detail.slice(0, 77) + '...' : detail)}`,
+    prefixText: '    ',
+    spinner: 'dots',
+    color: 'magenta',
+  }).start();
+
+  return spinner;
+}
+
+function finishToolCall(spinner, name, detail, startTime, success = true) {
+  const elapsed = Date.now() - startTime;
+  const icon = success ? t.green(figures.tick) : t.red(figures.cross);
+  const timeStr = elapsed < 1000 ? `${elapsed}ms` : `${(elapsed / 1000).toFixed(1)}s`;
+
+  spinner.stopAndPersist({
+    symbol: icon,
+    text: `${toolBadge(name)}  ${t.dim(detail.length > 80 ? detail.slice(0, 77) + '...' : detail)}  ${t.dim(timeStr)}`,
+    prefixText: '    ',
+  });
+}
+
+// ===== Diff Display =====
+function showDiff(filename, diffText) {
+  const width = Math.min(COLS - 8, 80);
+  console.log(indent(t.dim('┌─ ') + t.text.bold(path.basename(filename)) + t.dim(' ' + '─'.repeat(Math.max(0, width - path.basename(filename).length - 4)))));
+
+  const lines = diffText.split('\n');
+  for (const line of lines) {
+    if (line.startsWith('+')) {
+      console.log(indent(chalk.green('│ ' + line)));
+    } else if (line.startsWith('-')) {
+      console.log(indent(chalk.red('│ ' + line)));
+    }
+  }
+
+  console.log(indent(t.dim('└' + '─'.repeat(width))));
+  console.log();
+}
+
+// ===== Cost Summary =====
+function showTurnSummary(tokens, duration, toolCalls) {
+  const costPerToken = 0.000002;
+  const cost = tokens * costPerToken;
+  session.totalCost += cost;
+
+  const items = [
+    t.dim('Tokens   ') + t.text(tokens.toLocaleString()),
+    t.dim('Cost     ') + t.text('$' + cost.toFixed(4)),
+    t.dim('Duration ') + t.text(duration + 's'),
+    t.dim('Tools    ') + t.text(toolCalls.toString()),
+  ];
+
+  if (session.filesModified.size > 0) {
+    items.push(t.dim('Modified ') + t.text([...session.filesModified].map(f => path.basename(f)).join(', ')));
+  }
+
+  const box = boxen(items.join('\n'), {
+    padding: { left: 1, right: 1, top: 0, bottom: 0 },
+    borderColor: '#2a2a3a',
+    borderStyle: 'round',
+    dimBorder: true,
+  });
+  console.log(indent(box, 4));
+  console.log();
+}
+
+// ===== Interactive Prompt =====
+function createPrompt() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '',
+  });
+  return rl;
+}
+
+function showPrompt() {
+  console.log();
+  console.log('  ' + t.dim('Enter to send · /help for commands'));
+  return '  ' + t.brand('❯ ');
+}
+
+// ===== State =====
+let isProcessing = false;
+let rlClosed = false;
+let rl;
+let askQuestion;
+
+// ===== AI Conversation — Agentic Loop =====
+async function handleUserInput(userInput) {
+  isProcessing = true;
+  session.turnCount++;
+  showUserMessage(userInput);
+
+  session.conversationHistory.push({ role: 'user', content: userInput });
+
+  const startTime = Date.now();
+  let turnTokens = 0;
+  let turnToolCalls = 0;
+
+  try {
+    showAssistantHeader();
+    console.log();
+
+    const systemPrompt = buildSystemPrompt();
+    let messages = [
+      { role: 'system', content: systemPrompt },
+      ...session.conversationHistory,
+    ];
+
+    let iterations = 0;
+
+    // Agentic tool-use loop
+    while (iterations < MAX_TOOL_ITERATIONS) {
+      iterations++;
+
+      // Show thinking spinner while waiting for first token
+      const thinkSpinner = ora({
+        text: t.dim(iterations === 1 ? 'Reasoning deeply...' : 'Thinking further...'),
+        prefixText: '    ',
+        spinner: 'dots',
+        color: 'magenta',
+      }).start();
+
+      let stream;
+      try {
+        stream = await nvidiaClient.chat.completions.create({
+          model: NVIDIA_MODEL,
+          messages,
+          max_tokens: 4096,
+          temperature: 0.6,
+          top_p: 0.95,
+          tools: toolDefs,
+          tool_choice: 'auto',
+          stream: true,
+        });
+      } catch (apiErr) {
+        thinkSpinner.stop();
+        throw apiErr;
+      }
+
+      // Accumulate streamed response
+      let fullContent = '';
+      const toolCallDeltas = {};  // index -> { id, name, arguments }
+      let finishReason = null;
+      let streamUsage = null;
+      let reasoningText = '';  // collected reasoning from reasoning_content field
+
+      // Display state:
+      //   'buffering'  — accumulating, watching for <think> or safe-to-stream point
+      //   'thinking'   — inside <think>...</think>, accumulating reasoning
+      //   'streaming'  — think block done, streaming content live to terminal
+      let displayState = 'buffering';
+      let contentAccum = '';   // buffer for buffering/thinking states
+      let thinkAccum = '';     // accumulates text inside <think>...</think>
+      let streamingStarted = false;
+      let thinkSpinnerStopped = false;
+
+      function stopThinkSpinner() {
+        if (!thinkSpinnerStopped) { thinkSpinner.stop(); thinkSpinnerStopped = true; }
+      }
+
+      function writeToTerminal(text) {
+        if (!text) return;
+        if (!streamingStarted) {
+          streamingStarted = true;
+          process.stdout.write('    ');
+        }
+        process.stdout.write(t.text(text));
+      }
+
+      for await (const chunk of stream) {
+        if (chunk.usage) streamUsage = chunk.usage;
+
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) {
+          if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
+          continue;
+        }
+        if (chunk.choices[0].finish_reason) finishReason = chunk.choices[0].finish_reason;
+
+        // Accumulate tool call deltas
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index;
+            if (!toolCallDeltas[idx]) {
+              toolCallDeltas[idx] = { id: tc.id || '', name: tc.function?.name || '', arguments: '' };
+            }
+            if (tc.id) toolCallDeltas[idx].id = tc.id;
+            if (tc.function?.name) toolCallDeltas[idx].name = tc.function.name;
+            if (tc.function?.arguments) toolCallDeltas[idx].arguments += tc.function.arguments;
+          }
+        }
+
+        // Handle reasoning_content field (some APIs send reasoning separately)
+        if (delta.reasoning_content) {
+          reasoningText += delta.reasoning_content;
+        }
+
+        // Handle content tokens
+        if (delta.content) {
+          fullContent += delta.content;
+          const hasTool = Object.keys(toolCallDeltas).length > 0;
+
+          if (displayState === 'streaming') {
+            // Live-stream, but watch for a new <think> block
+            contentAccum += delta.content;
+            // Strip any stray closing tags
+            contentAccum = stripStrayCloseTag(contentAccum);
+            // Find and handle any <think> in the accumulated buffer
+            const openIdx = contentAccum.indexOf('<think>');
+            if (openIdx !== -1) {
+              // Write everything before <think>
+              if (openIdx > 0) writeToTerminal(contentAccum.slice(0, openIdx));
+              thinkAccum = contentAccum.slice(openIdx + 7);
+              contentAccum = '';
+              displayState = 'thinking';
+              // Check if closing tag already in this buffer
+              const closeMatch = findThinkClose(thinkAccum);
+              if (closeMatch) {
+                const thought = thinkAccum.slice(0, closeMatch.pos).trim();
+                const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
+                thinkAccum = '';
+                if (thought) showThinkingBlock([thought]);
+                displayState = 'streaming';
+                contentAccum = after;
+                if (!hasTool) writeToTerminal(after);
+                contentAccum = '';
+              }
+            } else {
+              // No <think> — stream it, but hold back possible partial tag at end
+              const { safe, pending } = splitAtPartialTag(contentAccum);
+              contentAccum = pending;
+              if (!hasTool && safe) writeToTerminal(safe);
+            }
+
+          } else if (displayState === 'thinking') {
+            // Accumulate inside think block
+            thinkAccum += delta.content;
+            const closeMatch = findThinkClose(thinkAccum);
+            if (closeMatch) {
+              const thought = thinkAccum.slice(0, closeMatch.pos).trim();
+              const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
+              thinkAccum = '';
+              stopThinkSpinner();
+              if (thought) showThinkingBlock([thought]);
+              displayState = 'streaming';
+              contentAccum = after;
+              if (!hasTool && after) writeToTerminal(after);
+              contentAccum = '';
+            }
+
+          } else {
+            // 'buffering' — accumulate until we know what's coming
+            contentAccum += delta.content;
+            // Strip stray closing tags
+            contentAccum = stripStrayCloseTag(contentAccum);
+            const openIdx = contentAccum.indexOf('<think>');
+            if (openIdx !== -1) {
+              // Text before <think>: stream it if non-empty
+              const before = contentAccum.slice(0, openIdx);
+              thinkAccum = contentAccum.slice(openIdx + 7);
+              contentAccum = '';
+              if (!hasTool && before.trim()) writeToTerminal(before);
+              displayState = 'thinking';
+              // Check if closing tag already present
+              const closeMatch = findThinkClose(thinkAccum);
+              if (closeMatch) {
+                const thought = thinkAccum.slice(0, closeMatch.pos).trim();
+                const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
+                thinkAccum = '';
+                stopThinkSpinner();
+                if (thought) showThinkingBlock([thought]);
+                displayState = 'streaming';
+                contentAccum = after;
+                if (!hasTool && after) writeToTerminal(after);
+                contentAccum = '';
+              }
+            } else if (!contentAccum.includes('<') && contentAccum.length > 20) {
+              // No think tag coming — start streaming immediately
+              stopThinkSpinner();
+              displayState = 'streaming';
+              if (!hasTool) writeToTerminal(contentAccum);
+              contentAccum = '';
+            }
+            // else keep buffering (might be start of <think>)
+          }
+        }
+      }
+
+      // Stream ended — flush any remaining buffers
+      stopThinkSpinner();
+
+      if (displayState === 'thinking') {
+        // Unclosed <think> block — show what we accumulated
+        const thought = (thinkAccum + contentAccum).trim();
+        if (thought) showThinkingBlock([thought]);
+        thinkAccum = '';
+        contentAccum = '';
+        displayState = 'streaming';
+      } else if (displayState === 'buffering') {
+        // Never left buffering — flush as plain content
+        const hasTool = Object.keys(toolCallDeltas).length > 0;
+        if (!hasTool && contentAccum.trim()) writeToTerminal(contentAccum);
+        contentAccum = '';
+      } else if (contentAccum) {
+        // Flush any pending partial-tag buffer
+        const hasTool = Object.keys(toolCallDeltas).length > 0;
+        if (!hasTool) writeToTerminal(contentAccum);
+        contentAccum = '';
+      }
+
+      // Show reasoning from reasoning_content field if not already shown via tags
+      if (reasoningText.trim() && displayState !== 'thinking') {
+        showThinkingBlock([reasoningText.trim()]);
+      }
+
+      if (streamingStarted) {
+        process.stdout.write('\n\n');
+      }
+
+      // Final parsed content for history/display (tags stripped)
+      const { content: displayContent } = parseThinkBlocks(fullContent);
+
+      turnTokens += streamUsage?.total_tokens || 0;
+
+      // Reconstruct the full message object
+      const toolCalls = Object.keys(toolCallDeltas).sort((a, b) => a - b).map(idx => ({
+        id: toolCallDeltas[idx].id,
+        type: 'function',
+        function: { name: toolCallDeltas[idx].name, arguments: toolCallDeltas[idx].arguments },
+      }));
+
+      const msg = {
+        role: 'assistant',
+        content: fullContent || null,
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+      };
+
+      // If the model wants to call tools
+      if (toolCalls.length > 0) {
+        messages.push(msg);
+
+        // Show intermediate reasoning that wasn't streamed (e.g. with tool calls)
+        // (thinking block already shown above, midContent has tags stripped)
+        if (displayContent && displayContent.trim()) {
+          console.log(indent(t.dim.italic(displayContent.trim()), 6));
+          console.log();
+        }
+
+        // Execute tool calls (parallel for independent calls)
+        const toolPromises = toolCalls.map(async (toolCall) => {
+          const toolName = toolCall.function.name;
+          let toolArgs;
+          try {
+            toolArgs = JSON.parse(toolCall.function.arguments);
+          } catch {
+            toolArgs = {};
+          }
+
+          const detail = toolDetail(toolName, toolArgs);
+          const callStart = Date.now();
+          const spinner = await showToolCall(toolName, detail, callStart);
+
+          // Execute
+          const result = await executeTool(toolName, toolArgs);
+          const success = !result.startsWith('Error');
+
+          finishToolCall(spinner, toolName, detail, callStart, success);
+          session.toolCallCount++;
+          turnToolCalls++;
+
+          // Show result preview
+          const resultLines = result.split('\n');
+          let preview;
+          if (toolName === 'Edit' || toolName === 'Patch') {
+            // Show diff
+            showDiff(toolArgs.path, result);
+          } else if (resultLines.length > 5) {
+            preview = resultLines.slice(0, 4).join('\n') + `\n... (${resultLines.length} lines)`;
+            console.log(indent(t.dim(preview), 8));
+            console.log();
+          } else if (result.trim() && result !== '(no output)') {
+            console.log(indent(t.dim(result.length > 300 ? result.slice(0, 297) + '...' : result), 8));
+            console.log();
+          }
+
+          return { id: toolCall.id, result };
+        });
+
+        const toolResults = await Promise.all(toolPromises);
+
+        for (const { id, result } of toolResults) {
+          messages.push({
+            role: 'tool',
+            tool_call_id: id,
+            content: result,
+          });
+        }
+
+        // Check for stop condition
+        if (finishReason === 'stop') break;
+        continue;
+      }
+
+      // No tool calls — final text response (already displayed above)
+      if (fullContent) {
+        const cleanedContent = displayContent.trim() || fullContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        session.conversationHistory.push({ role: 'assistant', content: cleanedContent || fullContent });
+      }
+      break;
+    }
+
+    if (iterations >= MAX_TOOL_ITERATIONS) {
+      console.log(indent(t.yellow(`⚠ Reached maximum tool iterations (${MAX_TOOL_ITERATIONS}). Stopping.`)));
+      console.log();
+    }
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+    session.totalTokens += turnTokens;
+    showTurnSummary(turnTokens, duration, turnToolCalls);
+  } catch (err) {
+    console.log();
+    console.log(indent(t.red('✗ Error: ') + t.text(err.message)));
+    if (!process.env.NVIDIA_API_KEY) {
+      console.log(indent(t.yellow('Set the NVIDIA_API_KEY environment variable with your API key from build.nvidia.com')));
+    }
+    console.log();
+  }
+
+  console.log(indent(hr()));
+  isProcessing = false;
+  if (rlClosed) {
+    // Readline closed during processing — re-create it if stdin is still usable
+    if (!process.stdin.destroyed && process.stdin.readable) {
+      setupInputLoop();
+      askQuestion();
+      return;
+    }
+    process.exit(0);
+  }
+}
+
+// ===== Utilities =====
+function timestamp() {
+  return new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+// ===== Input Loop =====
+function setupInputLoop() {
+  rlClosed = false;
+  rl = createPrompt();
+
+  rl.on('close', () => {
+    rlClosed = true;
+    if (isProcessing) return;
+    // If stdin is still usable, re-create readline (e.g. terminal glitch)
+    if (!process.stdin.destroyed && process.stdin.readable) {
+      setupInputLoop();
+      askQuestion();
+      return;
+    }
+    console.log();
+    showSessionSummary();
+    console.log(indent(t.dim('Goodbye! ') + t.brand('✦')));
+    console.log();
+    process.exit(0);
+  });
+}
+
+// ===== Main Loop =====
+async function main() {
+  showHeader();
+  showWelcome();
+
+  setupInputLoop();
+
+  askQuestion = () => {
+    if (rlClosed) return;
+    process.stdin.resume();
+    const promptStr = showPrompt();
+
+    rl.question(promptStr, async (answer) => {
+      if (answer === null || answer === undefined) {
+        process.exit(0);
+      }
+      const input = answer.trim();
+
+      if (!input) { askQuestion(); return; }
+
+      // Slash commands
+      if (input.startsWith('/')) {
+        await handleSlashCommand(input, rl);
+        askQuestion();
+        return;
+      }
+
+      if (input === 'exit' || input === 'quit') {
+        console.log();
+        showSessionSummary();
+        console.log(indent(t.dim('Goodbye! ') + t.brand('✦')));
+        console.log();
+        process.exit(0);
+      }
+
+      try {
+        await handleUserInput(input);
+      } catch (err) {
+        console.log(indent(t.red('✗ Unexpected error: ') + t.text(err.message)));
+        console.log();
+      }
+      askQuestion();
+    });
+  };
+
+  askQuestion();
+}
+
+// ===== Slash Commands =====
+async function handleSlashCommand(input, rl) {
+  const [cmd, ...rest] = input.split(' ');
+  const arg = rest.join(' ');
+
+  switch (cmd) {
+    case '/help':
+      showHelpMenu();
+      break;
+
+    case '/clear':
+      session.conversationHistory = [];
+      showHeader();
+      console.log(indent(t.green('✓ ') + t.muted('Conversation cleared.')));
+      console.log();
+      break;
+
+    case '/files':
+    case '/ls': {
+      const dirPath = arg ? resolvePath(arg) : PROJECT_ROOT;
+      console.log();
+      console.log(indent(t.text.bold('Project Files')));
+      console.log();
+      const result = await executeTool('ListDir', { path: dirPath, recursive: true });
+      console.log(indent(t.dim(result), 4));
+      console.log();
+      break;
+    }
+
+    case '/cost':
+    case '/status': {
+      const elapsed = ((Date.now() - session.startTime) / 1000 / 60).toFixed(1);
+      console.log();
+      console.log(indent(`  ${t.dim('Session')} ${t.text(elapsed + ' min')}  ${t.dim('Turns')} ${t.text(String(session.turnCount))}  ${t.dim('Tools')} ${t.text(String(session.toolCallCount))}  ${t.dim('Tokens')} ${t.text(session.totalTokens.toLocaleString())}  ${t.dim('Cost')} ${t.text('$' + session.totalCost.toFixed(4))}`));
+      console.log();
+      break;
+    }
+
+    case '/undo': {
+      if (session.editHistory.length === 0) {
+        console.log(indent(t.yellow('No edits to undo.')));
+      } else {
+        const last = session.editHistory[session.editHistory.length - 1];
+        fs.writeFileSync(last.path, last.before, 'utf-8');
+        session.editHistory.pop();
+        console.log(indent(t.green('✓ ') + t.muted(`Undone last edit to ${path.basename(last.path)}`)));
+      }
+      console.log();
+      break;
+    }
+
+    case '/diff': {
+      try {
+        const diff = execSync('git diff --stat 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT });
+        console.log();
+        console.log(indent(t.text.bold('Git Diff')));
+        console.log(indent(t.dim(diff || '(no changes)'), 4));
+        console.log();
+      } catch {
+        console.log(indent(t.yellow('Not a git repository.')));
+        console.log();
+      }
+      break;
+    }
+
+    case '/git': {
+      if (!arg) {
+        console.log(indent(t.yellow('Usage: /git <command>')));
+        console.log();
+        break;
+      }
+      try {
+        const output = execSync(`git ${arg}`, { encoding: 'utf-8', cwd: PROJECT_ROOT });
+        console.log();
+        console.log(indent(t.dim(output), 4));
+        console.log();
+      } catch (err) {
+        console.log(indent(t.red(err.stderr || err.message)));
+        console.log();
+      }
+      break;
+    }
+
+    case '/quit':
+      console.log();
+      showSessionSummary();
+      console.log(indent(t.dim('Goodbye! ') + t.brand('✦')));
+      console.log();
+      process.exit(0);
+
+    default:
+      console.log(indent(t.yellow(`Unknown command: ${cmd}. Type /help for available commands.`)));
+      console.log();
+  }
+}
+
+// ===== Session Summary =====
+function showSessionSummary() {
+  const elapsed = ((Date.now() - session.startTime) / 1000 / 60).toFixed(1);
+  const items = [
+    t.dim('Session    ') + t.text(`${elapsed} min`),
+    t.dim('Turns      ') + t.text(session.turnCount.toString()),
+    t.dim('Tool calls ') + t.text(session.toolCallCount.toString()),
+    t.dim('Tokens     ') + t.text(session.totalTokens.toLocaleString()),
+    t.dim('Cost       ') + t.text('$' + session.totalCost.toFixed(4)),
+  ];
+
+  if (session.filesModified.size > 0) {
+    items.push(t.dim('Modified   ') + t.text(`${session.filesModified.size} files`));
+  }
+  if (session.commandsRun.length > 0) {
+    items.push(t.dim('Commands   ') + t.text(`${session.commandsRun.length} executed`));
+  }
+
+  console.log();
+  const box = boxen(items.join('\n'), {
+    title: 'Session Summary',
+    titleAlignment: 'center',
+    padding: { left: 1, right: 1, top: 0, bottom: 0 },
+    borderColor: '#818cf8',
+    borderStyle: 'round',
+  });
+  console.log(indent(box, 2));
+  console.log();
+}
+
+// ===== Help =====
+function showHelpMenu() {
+  console.log();
+  console.log(indent(t.text.bold('Slash Commands')));
+  console.log();
+  console.log(indent(`  ${t.brand('/help')}           ${t.muted('Show this menu')}`));
+  console.log(indent(`  ${t.brand('/files')} ${t.dim('[path]')}  ${t.muted('Show project file tree')}`));
+  console.log(indent(`  ${t.brand('/clear')}          ${t.muted('Clear conversation history')}`));
+  console.log(indent(`  ${t.brand('/cost')}           ${t.muted('Show session statistics')}`));
+  console.log(indent(`  ${t.brand('/undo')}           ${t.muted('Undo last file edit')}`));
+  console.log(indent(`  ${t.brand('/diff')}           ${t.muted('Show git diff summary')}`));
+  console.log(indent(`  ${t.brand('/git')} ${t.dim('<cmd>')}     ${t.muted('Run a git command')}`));
+  console.log(indent(`  ${t.brand('/quit')}           ${t.muted('Exit with session summary')}`));
+  console.log();
+  console.log(indent(t.text.bold('Available Tools')));
+  console.log();
+  console.log(indent(`  ${toolBadge('Read')}     ${t.muted('Read file contents')}`));
+  console.log(indent(`  ${toolBadge('Write')}    ${t.muted('Create or overwrite files')}`));
+  console.log(indent(`  ${toolBadge('Edit')}     ${t.muted('Find-and-replace in files')}`));
+  console.log(indent(`  ${toolBadge('Patch')}    ${t.muted('Multiple edits to one file')}`));
+  console.log(indent(`  ${toolBadge('Bash')}     ${t.muted('Execute shell commands')}`));
+  console.log(indent(`  ${toolBadge('Grep')}     ${t.muted('Search code with regex')}`));
+  console.log(indent(`  ${toolBadge('Glob')}     ${t.muted('Find files by pattern')}`));
+  console.log(indent(`  ${toolBadge('ListDir')}  ${t.muted('List directory contents')}`));
+  console.log(indent(`  ${toolBadge('UndoEdit')}${t.muted(' Revert last file edit')}`));
+  console.log(indent(`  ${toolBadge('Task')}     ${t.muted('Run multi-step sub-tasks')}`));
+  console.log(indent(`  ${toolBadge('CodeReview')}${t.muted(' AI-powered code review sub-agent')}`));
+  console.log();
+}
+
+// ===== Run =====
+main().catch(console.error);