@compilr-dev/cli 0.4.0

package/dist/index.old.js

@@ -0,0 +1,1014 @@
+#!/usr/bin/env node
+/**
+ * Agent Demo - CLI Interface
+ *
+ * Simple readline-based REPL for testing the agent.
+ */
+import pc from 'picocolors';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { createAgent } from './agent.js';
+import { selectToolNamesByIntent, estimateTokenSavings } from './tool-selector.js';
+import { createInteractiveInput } from './slash-autocomplete.js';
+import { showHelpMenu } from './tabbed-menu.js';
+// Configure marked for terminal output
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+marked.use(markedTerminal({
+    reflowText: true,
+    width: 80,
+}));
+/**
+ * Render markdown text for terminal display
+ */
+function renderMarkdown(text) {
+    try {
+        // Preprocess: remove common leading indentation that breaks markdown parsing
+        // (4 spaces makes it a code block, which preserves raw **bold** markers)
+        const lines = text.split('\n');
+        const processedLines = lines.map(line => {
+            // Remove leading 4 spaces that would make it a code block
+            // But preserve intentional code blocks (``` fenced)
+            if (line.startsWith('    ') && !line.startsWith('    ```')) {
+                return line.slice(4);
+            }
+            return line;
+        });
+        const processed = processedLines.join('\n');
+        // marked.parse returns string synchronously with these options
+        let rendered = marked.parse(processed, { async: false });
+        // Post-process: marked-terminal doesn't render bold/italic inside list items
+        // Convert remaining **bold** and *italic* to ANSI codes
+        rendered = rendered
+            .replace(/\*\*([^*]+)\*\*/g, (_, text) => pc.bold(text)) // **bold**
+            .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, text) => pc.italic(text)) // *italic* (not **)
+            .replace(/`([^`]+)`/g, (_, text) => pc.cyan(text)); // `code`
+        // Remove trailing newlines that marked adds
+        return rendered.replace(/\n+$/, '');
+    }
+    catch {
+        return text; // Fallback to raw text
+    }
+}
+// Funny thinking words (inspired by Claude Code)
+const THINKING_WORDS = [
+    'Thinking',
+    'Pondering',
+    'Contemplating',
+    'Ruminating',
+    'Cogitating',
+    'Deliberating',
+    'Musing',
+    'Reflecting',
+    'Considering',
+    'Analyzing',
+    'Processing',
+    'Computing',
+    'Synthesizing',
+    'Extrapolating',
+    'Hypothesizing',
+    'Discombobulating',
+    'Nebulizing',
+    'Percolating',
+    'Marinating',
+    'Simmering',
+    'Brewing',
+    'Fermenting',
+    'Distilling',
+    'Crystallizing',
+    'Transmuting',
+];
+// Global spinner instance for Esc handling
+let spinnerInstance = null;
+/**
+ * Format duration in human-readable format (e.g., "1m 23s", "45s")
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+/**
+ * Format token count (e.g., "1.2k", "500")
+ */
+function formatTokens(tokens) {
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(1)}k`;
+    }
+    return tokens.toString();
+}
+/**
+ * Current todo list (stored globally for display during agent execution)
+ */
+let currentTodos = [];
+/**
+ * Render todo list with visual styling like Claude Code
+ */
+function renderTodoList(todos) {
+    if (!todos || todos.length === 0) {
+        return '';
+    }
+    const lines = [];
+    for (const todo of todos) {
+        let checkbox;
+        let text;
+        switch (todo.status) {
+            case 'completed':
+                checkbox = pc.dim('☒');
+                text = pc.strikethrough(pc.dim(todo.content));
+                break;
+            case 'in_progress':
+                checkbox = pc.cyan('☐');
+                text = pc.bold(todo.content);
+                break;
+            case 'pending':
+            default:
+                checkbox = pc.dim('☐');
+                text = pc.dim(todo.content);
+                break;
+        }
+        lines.push(`${checkbox} ${text}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get the currently active todo (in_progress)
+ */
+function getActiveTodo() {
+    return currentTodos.find(t => t.status === 'in_progress');
+}
+/**
+ * Format tool result for display - handles strings, objects, arrays
+ */
+function formatToolResult(result) {
+    if (result === null || result === undefined) {
+        return '';
+    }
+    // String result - count lines or truncate
+    if (typeof result === 'string') {
+        const lines = result.split('\n').filter(l => l.trim()).length;
+        if (lines > 3) {
+            return pc.dim(`${lines} lines`);
+        }
+        const truncated = result.slice(0, 80).replace(/\n/g, ' ');
+        return pc.dim(truncated + (result.length > 80 ? '...' : ''));
+    }
+    // Array result - show count and type hint
+    if (Array.isArray(result)) {
+        const len = result.length;
+        if (len === 0)
+            return pc.dim('empty array');
+        // Try to describe contents
+        const first = result[0];
+        if (typeof first === 'string') {
+            return pc.dim(`${len} items`);
+        }
+        else if (typeof first === 'object' && first !== null) {
+            // Check for common patterns like todos, files, branches
+            if ('content' in first && 'status' in first) {
+                return pc.dim(`${len} todo items`);
+            }
+            if ('name' in first || 'path' in first) {
+                return pc.dim(`${len} items`);
+            }
+        }
+        return pc.dim(`${len} items`);
+    }
+    // Object result - try to extract meaningful summary
+    if (typeof result === 'object') {
+        const obj = result;
+        // Git status pattern
+        if ('branch' in obj && 'clean' in obj) {
+            const branch = obj.branch;
+            const clean = obj.clean;
+            return pc.dim(`${branch}${clean ? ' (clean)' : ' (changes)'}`);
+        }
+        // Git diff pattern
+        if ('files' in obj && Array.isArray(obj.files)) {
+            const files = obj.files;
+            if (files.length === 0)
+                return pc.dim('no changes');
+            return pc.dim(`${files.length} file(s) changed`);
+        }
+        // Git branch pattern
+        if ('current' in obj && 'branches' in obj) {
+            const branches = obj.branches;
+            return pc.dim(`${branches?.length || 0} branches`);
+        }
+        // File read pattern
+        if ('content' in obj) {
+            const content = String(obj.content);
+            const lines = content.split('\n').length;
+            return pc.dim(`${lines} lines`);
+        }
+        // Bash/command pattern
+        if ('stdout' in obj || 'output' in obj) {
+            const out = String(obj.stdout || obj.output || '');
+            const lines = out.split('\n').filter(l => l.trim()).length;
+            if (lines > 0)
+                return pc.dim(`${lines} lines`);
+            return pc.dim('done');
+        }
+        // Success message pattern
+        if ('success' in obj && typeof obj.message === 'string') {
+            return pc.dim(obj.message.slice(0, 60));
+        }
+        // Fallback - show key count
+        const keys = Object.keys(obj);
+        if (keys.length <= 3) {
+            return pc.dim(keys.join(', '));
+        }
+        return pc.dim(`${keys.length} fields`);
+    }
+    // Primitive - just stringify
+    return pc.dim(String(result).slice(0, 60));
+}
+/**
+ * Animated thinking spinner with Knight Rider scanning effect
+ * Shows elapsed time, token usage, and todo list
+ */
+class ThinkingSpinner {
+    word = '';
+    position = 0;
+    direction = 1; // 1 = right, -1 = left
+    interval = null;
+    abortController = null;
+    startTime = 0;
+    tokens = 0;
+    currentTool = null;
+    renderedLines = 0; // Track how many lines we've rendered
+    start() {
+        this.abortController = new AbortController();
+        spinnerInstance = this;
+        this.startTime = Date.now();
+        this.tokens = 0;
+        this.currentTool = null;
+        this.renderedLines = 0;
+        // Pick a random word
+        this.word = THINKING_WORDS[Math.floor(Math.random() * THINKING_WORDS.length)] + '...';
+        this.position = 0;
+        this.direction = 1;
+        // Start animation
+        this.render();
+        this.interval = setInterval(() => {
+            // Move position
+            this.position += this.direction;
+            // Bounce at edges
+            if (this.position >= this.word.length - 1) {
+                this.direction = -1;
+            }
+            else if (this.position <= 0) {
+                this.direction = 1;
+            }
+            this.render();
+        }, 150); // Smooth scanning speed
+        return this.abortController;
+    }
+    /**
+     * Update token count (called when tokens are received)
+     */
+    addTokens(count) {
+        this.tokens += count;
+    }
+    /**
+     * Set current tool being executed
+     */
+    setTool(toolName) {
+        this.currentTool = toolName;
+        // Re-render immediately to show tool
+        if (this.interval) {
+            this.render();
+        }
+    }
+    /**
+     * Clear the spinner area (all rendered lines)
+     */
+    clearArea() {
+        if (this.renderedLines > 0) {
+            // Move to start of current line
+            process.stdout.write('\r');
+            // Move up to first line
+            if (this.renderedLines > 1) {
+                process.stdout.write(`\x1b[${this.renderedLines - 1}A`);
+            }
+            // Clear from cursor to end of screen
+            process.stdout.write('\x1b[J');
+        }
+        else {
+            process.stdout.write('\r\x1b[K');
+        }
+    }
+    render() {
+        const elapsed = formatDuration(Date.now() - this.startTime);
+        const tokenStr = formatTokens(this.tokens);
+        // Clear previous render
+        this.clearArea();
+        // Build stats string
+        const stats = pc.dim(` (Esc to interrupt · ${elapsed} · ↓ ${tokenStr} tokens)`);
+        // If a tool is running, show that instead of the thinking word
+        if (this.currentTool) {
+            const toolDisplay = pc.yellow(`● ${this.currentTool}`);
+            process.stdout.write(`${toolDisplay}${stats}`);
+            // Render todo list below if we have todos
+            if (currentTodos.length > 0) {
+                process.stdout.write('\n' + renderTodoList(currentTodos));
+                this.renderedLines = 1 + currentTodos.length; // status + todos
+            }
+            else {
+                this.renderedLines = 1;
+            }
+            return;
+        }
+        // Check if there's an active todo - show that with animation
+        const activeTodo = getActiveTodo();
+        const displayText = activeTodo
+            ? (activeTodo.activeForm || activeTodo.content) + '...'
+            : this.word;
+        // Build the text with scanning highlight (knight rider effect)
+        let result = '';
+        for (let i = 0; i < displayText.length; i++) {
+            const distance = Math.abs(i - (this.position % displayText.length));
+            const char = displayText[i];
+            if (distance === 0) {
+                result += pc.bold(pc.magenta(char));
+            }
+            else if (distance === 1) {
+                result += pc.magenta(char);
+            }
+            else if (distance === 2) {
+                result += pc.red(char);
+            }
+            else {
+                result += pc.dim(pc.red(char));
+            }
+        }
+        // If we have an active todo, show the indicator
+        if (activeTodo) {
+            result = pc.red('✱ ') + result;
+        }
+        process.stdout.write(`${result}${stats}`);
+        // Render todo list below if we have todos
+        if (currentTodos.length > 0) {
+            process.stdout.write('\n' + renderTodoList(currentTodos));
+            this.renderedLines = 1 + currentTodos.length; // status + todos
+        }
+        else {
+            this.renderedLines = 1;
+        }
+    }
+    stop(wasAborted = false) {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        spinnerInstance = null;
+        // Clear all spinner lines
+        this.clearArea();
+        this.renderedLines = 0;
+        if (wasAborted) {
+            console.log(pc.yellow('Interrupted by user.\n'));
+        }
+    }
+    /**
+     * Pause the spinner animation (for permission prompts)
+     */
+    pause() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        // Clear the spinner line
+        process.stdout.write('\r\x1b[K');
+    }
+    /**
+     * Clear all spinner lines for external output (tool results, etc.)
+     * After calling this, call render() to redraw if spinner should continue.
+     */
+    clearForOutput() {
+        this.clearArea();
+        this.renderedLines = 0;
+    }
+    /**
+     * Force an immediate render (e.g., after todos are updated)
+     */
+    forceRender() {
+        if (spinnerInstance === this) {
+            this.render();
+        }
+    }
+    /**
+     * Resume the spinner animation after pause
+     */
+    resume() {
+        if (!this.interval && spinnerInstance === this) {
+            this.render();
+            this.interval = setInterval(() => {
+                this.position += this.direction;
+                if (this.position >= this.word.length - 1) {
+                    this.direction = -1;
+                }
+                else if (this.position <= 0) {
+                    this.direction = 1;
+                }
+                this.render();
+            }, 150);
+        }
+    }
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+        this.stop(true);
+    }
+    isAborted() {
+        return this.abortController?.signal.aborted ?? false;
+    }
+}
+/**
+ * Set up global Esc key handler (called once at startup)
+ */
+function setupEscHandler() {
+    // Listen for escape key (0x1b by itself, not part of arrow key sequence)
+    process.stdin.on('data', (data) => {
+        if (data.length === 1 && data[0] === 0x1b && spinnerInstance) {
+            spinnerInstance.abort();
+        }
+    });
+}
+// Parse command line arguments
+const args = process.argv.slice(2);
+const verbose = args.includes('--verbose') || args.includes('-v');
+const minimal = args.includes('--minimal') || args.includes('-m');
+const help = args.includes('--help') || args.includes('-h');
+const showFiltering = args.includes('--show-filtering') || args.includes('-f');
+// Parse --provider flag
+let provider = 'claude';
+const providerIdx = args.findIndex((a) => a === '--provider' || a === '-p');
+if (providerIdx !== -1 && args[providerIdx + 1]) {
+    const p = args[providerIdx + 1].toLowerCase();
+    if (p === 'claude' || p === 'ollama' || p === 'openai' || p === 'gemini') {
+        provider = p;
+    }
+    else {
+        console.error(`Unknown provider: ${p}. Use 'claude', 'ollama', 'openai', or 'gemini'.`);
+        process.exit(1);
+    }
+}
+// Parse --model flag
+let model;
+const modelIdx = args.findIndex((a) => a === '--model');
+if (modelIdx !== -1 && args[modelIdx + 1]) {
+    model = args[modelIdx + 1];
+}
+if (help) {
+    console.log(`
+Agent Demo - PoC for @compilr-dev/agents
+
+Usage:
+  npm run dev [options]
+
+Options:
+  -v, --verbose           Show tool execution events
+  -m, --minimal           Use minimal tool set (faster startup)
+  -f, --show-filtering    Show tool filtering analysis (token savings)
+  -p, --provider <name>   LLM provider: claude (default), ollama, openai, gemini
+  --model <name>          Model to use (provider-specific, see examples)
+  -h, --help              Show this help message
+
+Commands (in REPL):
+  exit             Quit the demo
+  clear            Clear conversation history
+  tools            List available tools
+
+Environment Variables:
+  ANTHROPIC_API_KEY    Required for Claude provider
+  OPENAI_API_KEY       Required for OpenAI provider
+  GOOGLE_AI_API_KEY    Required for Gemini provider (or GEMINI_API_KEY)
+  OLLAMA_BASE_URL      Ollama server URL (default: http://localhost:11434)
+
+Examples:
+  npm run dev -- --provider claude               # Claude with claude-sonnet-4
+  npm run dev -- --provider ollama               # Ollama with llama3.1
+  npm run dev -- -p ollama --model mistral       # Ollama with mistral
+  npm run dev -- --provider openai               # OpenAI with gpt-4o
+  npm run dev -- -p openai --model gpt-4o-mini   # OpenAI with gpt-4o-mini
+  npm run dev -- --provider gemini               # Gemini with gemini-2.0-flash
+  npm run dev -- -p gemini --model gemini-1.5-pro  # Gemini with gemini-1.5-pro
+`);
+    process.exit(0);
+}
+async function main() {
+    // Clear screen and move cursor to top
+    process.stdout.write('\x1B[2J\x1B[H');
+    // ASCII Logo (from compilr-dev-cli)
+    console.log(pc.cyan(`   ___  ___  _ __ ___  _ __ (_) |_ __
+  / __|/ _ \\| '_ \` _ \\| '_ \\| | | '__|
+ | (__| (_) | | | | | | |_) | | | |
+  \\___|\\___/|_| |_| |_| .__/|_|_|_|
+                      | | .dev
+                      |_|`));
+    console.log('');
+    console.log(pc.bold(pc.cyan('compilr-dev-cli')) + pc.dim(' - AI-powered terminal assistant'));
+    console.log('');
+    // Interactive input handler (will be initialized later)
+    let inputHandler = null;
+    /**
+     * Simple single-key input for permission prompts
+     */
+    const askYesNo = (prompt) => {
+        return new Promise((resolve) => {
+            process.stdout.write(prompt);
+            // Ensure stdin is in the right state for reading
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.resume();
+            const onData = (data) => {
+                const key = data.toString().toLowerCase();
+                process.stdin.removeListener('data', onData);
+                // Restore stdin state
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.pause();
+                if (key === 'y') {
+                    process.stdout.write('y\n');
+                    resolve(true);
+                }
+                else {
+                    process.stdout.write('n\n');
+                    resolve(false);
+                }
+            };
+            process.stdin.once('data', onData);
+        });
+    };
+    /**
+     * Permission handler - prompts user for approval
+     */
+    const handlePermissionRequest = async (request) => {
+        // Pause spinner if active (stop the interval, clear the line)
+        let wasSpinnerActive = false;
+        if (spinnerInstance) {
+            wasSpinnerActive = true;
+            spinnerInstance.pause();
+        }
+        // Show permission request
+        console.log('');
+        console.log(pc.yellow('⚠ Permission Required'));
+        console.log(pc.bold(`  Tool: ${request.toolName}`));
+        if (request.description) {
+            console.log(pc.dim(`  ${request.description}`));
+        }
+        // Show preview of what will happen
+        const input = request.input;
+        if (input.command) {
+            console.log(pc.dim(`  Command: ${String(input.command).slice(0, 60)}${String(input.command).length > 60 ? '...' : ''}`));
+        }
+        else if (input.path) {
+            console.log(pc.dim(`  Path: ${input.path}`));
+        }
+        else if (input.message) {
+            console.log(pc.dim(`  Message: ${String(input.message).slice(0, 60)}`));
+        }
+        console.log('');
+        const allowed = await askYesNo(pc.cyan('  Allow? [y/N]: '));
+        if (allowed) {
+            console.log(pc.green('  ✓ Allowed\n'));
+        }
+        else {
+            console.log(pc.red('  ✗ Denied\n'));
+        }
+        // Resume spinner if it was active
+        if (wasSpinnerActive && spinnerInstance) {
+            spinnerInstance.resume();
+        }
+        return allowed;
+    };
+    // Create agent with permission handler
+    let agent;
+    try {
+        agent = createAgent({
+            verbose,
+            minimal,
+            provider,
+            model,
+            onPermissionRequest: handlePermissionRequest,
+        });
+        console.log(pc.green('✓') + ` Agent initialized with ${minimal ? 'minimal' : 'full'} tool set.`);
+        console.log(pc.green('✓') + ` Permissions enabled for: bash, write_file, edit, git_commit`);
+        console.log(pc.dim('Type / for commands, /exit to quit.\n'));
+    }
+    catch (error) {
+        console.error('Failed to create agent:', error.message);
+        process.exit(1);
+    }
+    // Session-wide token tracking
+    let sessionInputTokens = 0;
+    let sessionOutputTokens = 0;
+    let sessionRequests = 0;
+    // Set up Esc key handler for interrupting agent (once at startup)
+    setupEscHandler();
+    // Handle slash commands
+    function handleCommand(input) {
+        const trimmed = input.trim();
+        // Commands must start with /
+        if (!trimmed.startsWith('/')) {
+            return false;
+        }
+        const cmd = trimmed.slice(1).toLowerCase();
+        switch (cmd) {
+            case 'exit':
+            case 'quit':
+            case 'q':
+                console.log('\nGoodbye!');
+                inputHandler?.stop();
+                process.exit(0);
+            case 'clear':
+                agent.clearHistory();
+                console.log(pc.green('✓') + ' Conversation history cleared.\n');
+                return true;
+            case 'tools': {
+                const tools = agent.getToolDefinitions();
+                console.log(pc.bold(`\nAvailable tools (${tools.length}):`));
+                for (const tool of tools) {
+                    console.log(pc.dim('  •') + ` ${tool.name}`);
+                }
+                console.log('');
+                return true;
+            }
+            case 'tokens': {
+                const sessionTotal = sessionInputTokens + sessionOutputTokens;
+                console.log(pc.bold(`\nSession Token Usage:`));
+                console.log(`  Total:    ${pc.cyan(sessionTotal.toLocaleString())} tokens`);
+                console.log(`  Input:    ${pc.dim(sessionInputTokens.toLocaleString())} tokens`);
+                console.log(`  Output:   ${pc.dim(sessionOutputTokens.toLocaleString())} tokens`);
+                console.log(`  Requests: ${sessionRequests}`);
+                if (sessionRequests > 0) {
+                    console.log(`  Average:  ${Math.round(sessionTotal / sessionRequests).toLocaleString()} tokens/req`);
+                }
+                console.log('');
+                return true;
+            }
+            case 'context': {
+                const stats = agent.getContextStats?.();
+                if (stats) {
+                    const pct = (stats.utilization * 100).toFixed(2);
+                    const sessionTotal = sessionInputTokens + sessionOutputTokens;
+                    // Color utilization based on level
+                    const pctNum = parseFloat(pct);
+                    const pctColor = pctNum > 80 ? pc.red : pctNum > 50 ? pc.yellow : pc.green;
+                    console.log(pc.bold(`\nContext Window:`));
+                    console.log(`  History:     ${pc.cyan(stats.currentTokens.toLocaleString())} tokens ${pc.dim(`(${stats.messageCount} msgs, ${stats.turnCount} turns)`)}`);
+                    console.log(`  Limit:       ${pc.dim(stats.maxTokens.toLocaleString())} tokens`);
+                    console.log(`  Utilization: ${pctColor(pct + '%')}`);
+                    console.log(pc.bold(`\nSession Usage:`));
+                    console.log(`  API tokens:  ${pc.cyan(sessionTotal.toLocaleString())} ${pc.dim(`(${sessionInputTokens.toLocaleString()} in / ${sessionOutputTokens.toLocaleString()} out)`)}`);
+                    console.log(`  Requests:    ${sessionRequests}`);
+                    if (stats.compactionCount > 0 || stats.summarizationCount > 0) {
+                        console.log(pc.bold(`\nContext Management:`));
+                        if (stats.compactionCount > 0) {
+                            console.log(`  Compactions:     ${stats.compactionCount}`);
+                        }
+                        if (stats.summarizationCount > 0) {
+                            console.log(`  Summarizations:  ${stats.summarizationCount}`);
+                        }
+                    }
+                }
+                else {
+                    console.log(pc.yellow('\nContext manager not enabled or no stats available.'));
+                }
+                console.log('');
+                return true;
+            }
+            case 'compact': {
+                // Mark as async command - will be handled separately
+                return 'async';
+            }
+            case 'help':
+            case '?':
+                // Mark as async command - will show tabbed help menu
+                return 'async';
+            default:
+                if (trimmed.startsWith('/')) {
+                    console.log(pc.yellow(`Unknown command: ${trimmed}`) + pc.dim(` - Type /help for available commands.\n`));
+                    return true;
+                }
+                return false;
+        }
+    }
+    // Handle async /compact command
+    async function handleCompact() {
+        const statsBefore = agent.getContextStats?.();
+        if (!statsBefore || statsBefore.currentTokens === 0) {
+            console.log(pc.yellow('\nNothing to compact (history is empty).\n'));
+            return;
+        }
+        const history = agent.getHistory();
+        if (history.length < 6) {
+            console.log(pc.yellow('\nNot enough history to compact (need at least 6 messages).\n'));
+            return;
+        }
+        console.log(pc.bold('\nCompacting context...'));
+        console.log(`  Before: ${pc.cyan(statsBefore.currentTokens.toLocaleString())} tokens (${history.length} messages)`);
+        try {
+            // Keep the last 4 messages (2 turns), but only text-only messages
+            // Tool call messages can cause issues when restored without proper context
+            const keepCount = 4;
+            // Filter to get only "clean" messages (text-only, no tool calls)
+            const cleanMessages = history.filter(m => {
+                if (typeof m.content === 'string')
+                    return true;
+                // Check if any content block is a tool_use or tool_result
+                const hasToolContent = m.content.some(b => b.type === 'tool_use' || b.type === 'tool_result');
+                return !hasToolContent;
+            });
+            if (cleanMessages.length < 4) {
+                console.log(pc.yellow('  Not enough text messages to compact (mostly tool calls).\n'));
+                console.log(pc.dim('  Use /clear to reset history completely.\n'));
+                return;
+            }
+            const recentMessages = cleanMessages.slice(-keepCount);
+            const oldMessages = cleanMessages.slice(0, -keepCount);
+            if (oldMessages.length === 0) {
+                console.log(pc.yellow('  Nothing to summarize (only recent messages remain).\n'));
+                return;
+            }
+            // Generate a summary of the old messages using the agent
+            console.log(pc.dim(`  Summarizing ${oldMessages.length} old messages...`));
+            // Build a summary prompt from old messages
+            const oldContent = oldMessages
+                .filter(m => m.role !== 'system')
+                .map(m => {
+                const role = m.role === 'user' ? 'User' : 'Assistant';
+                const text = typeof m.content === 'string'
+                    ? m.content
+                    : m.content
+                        .filter((b) => b.type === 'text')
+                        .map(b => b.text)
+                        .join('\n');
+                return `${role}: ${text.slice(0, 500)}${text.length > 500 ? '...' : ''}`;
+            })
+                .join('\n\n');
+            // Use a temporary clear to generate summary without old context
+            agent.clearHistory();
+            // Generate summary
+            let summary = '';
+            const summaryPrompt = `Summarize this conversation in 2-3 sentences, focusing on key topics discussed and any important outcomes:\n\n${oldContent}`;
+            for await (const event of agent.stream(summaryPrompt)) {
+                if (event.type === 'llm_chunk' && event.chunk.type === 'text' && event.chunk.text) {
+                    summary += event.chunk.text;
+                }
+            }
+            // Clear again and set new history with summary + recent messages
+            agent.clearHistory();
+            // Create a system-style message with the summary
+            const summaryMessage = {
+                role: 'user',
+                content: `[Previous conversation summary: ${summary.trim()}]`,
+            };
+            const assistantAck = {
+                role: 'assistant',
+                content: 'I understand. I have context from our previous conversation. How can I help you continue?',
+            };
+            // Set new compacted history
+            await agent.setHistory([summaryMessage, assistantAck, ...recentMessages]);
+            const statsAfter = agent.getContextStats?.();
+            const saved = statsBefore.currentTokens - (statsAfter?.currentTokens ?? 0);
+            const savedPct = ((saved / statsBefore.currentTokens) * 100).toFixed(1);
+            console.log(`  After:  ${pc.cyan(statsAfter?.currentTokens.toLocaleString() ?? '0')} tokens (${(statsAfter?.messageCount ?? 0)} messages)`);
+            console.log(pc.green('✓') + ` Compacted! Saved ${pc.cyan(saved.toLocaleString())} tokens (${savedPct}% reduction)`);
+        }
+        catch (error) {
+            console.log(pc.red('  Error:'), error.message);
+        }
+        console.log('');
+    }
+    /**
+     * Process user input (command or message to agent)
+     */
+    async function processInput(input) {
+        // Handle empty input
+        if (!input.trim()) {
+            return;
+        }
+        // Check for slash commands
+        const cmdResult = handleCommand(input);
+        if (cmdResult === 'async') {
+            // Handle async commands
+            const cmd = input.trim().toLowerCase();
+            if (cmd === '/compact') {
+                await handleCompact();
+            }
+            else if (cmd === '/help' || cmd === '/?') {
+                await showHelpMenu();
+            }
+            return;
+        }
+        if (cmdResult === true) {
+            return;
+        }
+        // Apply tool filtering - select relevant tools based on user intent
+        const totalTools = agent.getToolDefinitions().length;
+        const selectedNames = selectToolNamesByIntent(input);
+        // Show tool filtering analysis if enabled
+        if (showFiltering) {
+            const savings = estimateTokenSavings(selectedNames.length, totalTools);
+            console.log(`\n[Tool Filtering] Selecting ${selectedNames.length}/${totalTools} tools:`);
+            console.log(`  Selected: ${selectedNames.join(', ')}`);
+            console.log(`  Estimated savings: ~${savings.saved} tokens (${savings.percentage}% reduction)`);
+        }
+        // Send to agent using stream() for real-time output
+        // Pass toolFilter to reduce token usage by only sending relevant tools
+        const spinner = new ThinkingSpinner();
+        try {
+            // Start the thinking spinner
+            const abortController = spinner.start();
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            let llmCalls = 0;
+            let hasTextOutput = false;
+            let usedTools = false;
+            let spinnerStopped = false;
+            let lastToolInput = null;
+            let textBuffer = ''; // Buffer text for markdown rendering
+            for await (const event of agent.stream(input, {
+                toolFilter: selectedNames,
+                signal: abortController.signal,
+            })) {
+                // Check if aborted
+                if (spinner.isAborted()) {
+                    break;
+                }
+                if (event.type === 'llm_chunk') {
+                    if (event.chunk.type === 'text' && event.chunk.text) {
+                        // Stop spinner on first text output
+                        if (!spinnerStopped) {
+                            spinner.stop();
+                            spinnerStopped = true;
+                        }
+                        // Buffer text for markdown rendering at the end
+                        textBuffer += event.chunk.text;
+                        hasTextOutput = true;
+                    }
+                    else if (event.chunk.type === 'done' && event.chunk.usage) {
+                        // Update token tracking
+                        const tokens = event.chunk.usage.inputTokens + event.chunk.usage.outputTokens;
+                        spinner.addTokens(tokens);
+                        totalInputTokens += event.chunk.usage.inputTokens;
+                        totalOutputTokens += event.chunk.usage.outputTokens;
+                        llmCalls++;
+                    }
+                }
+                else if (event.type === 'tool_start') {
+                    usedTools = true;
+                    // Store input for when tool ends
+                    lastToolInput = event.input;
+                    // Show tool name in spinner while running (but not for todo tools - they're silent)
+                    if (event.name !== 'todo_read' && event.name !== 'todo_write') {
+                        spinner.setTool(event.name);
+                    }
+                }
+                else if (event.type === 'tool_end') {
+                    // Clear all spinner lines (including todos) before printing tool result
+                    spinner.clearForOutput();
+                    // Format: ● ToolName(args)
+                    //         ⎿  Result summary
+                    const toolName = event.name;
+                    const toolInput = lastToolInput;
+                    const result = event.result;
+                    lastToolInput = null;
+                    // Build argument summary (first string arg or key info)
+                    let argSummary = '';
+                    if (toolInput) {
+                        // Common patterns: path, file_path, command, pattern
+                        const path = toolInput.path || toolInput.file_path || toolInput.filePath;
+                        const command = toolInput.command;
+                        const pattern = toolInput.pattern;
+                        if (typeof path === 'string') {
+                            // Show just filename, not full path
+                            const filename = path.split('/').pop() || path;
+                            argSummary = filename;
+                        }
+                        else if (typeof command === 'string') {
+                            // Truncate long commands
+                            argSummary = command.length > 40 ? command.slice(0, 40) + '...' : command;
+                        }
+                        else if (typeof pattern === 'string') {
+                            argSummary = pattern;
+                        }
+                    }
+                    // Special handling for todo tools - silent, rendered with spinner
+                    if (toolName === 'todo_write' && toolInput && Array.isArray(toolInput.todos)) {
+                        // Normalize todos - handle different property names the agent might use
+                        currentTodos = toolInput.todos.map((t) => ({
+                            content: String(t.content || t.title || t.task || t.description || t.text || 'Untitled task'),
+                            status: (['pending', 'in_progress', 'completed'].includes(String(t.status))
+                                ? t.status
+                                : 'pending'),
+                            activeForm: t.activeForm ? String(t.activeForm) : undefined,
+                        }));
+                        // Immediately render updated todos
+                        spinner.setTool(null);
+                        spinner.forceRender();
+                        continue; // Skip normal tool result display
+                    }
+                    // Skip todo_read display - silent like todo_write
+                    if (toolName === 'todo_read') {
+                        spinner.setTool(null);
+                        continue;
+                    }
+                    // Format tool header
+                    const toolHeader = argSummary
+                        ? pc.yellow(`● ${toolName}`) + pc.dim(`(${argSummary})`)
+                        : pc.yellow(`● ${toolName}`);
+                    // Format result summary
+                    let resultSummary = '';
+                    if (result) {
+                        if (result.error) {
+                            resultSummary = pc.red(`Error: ${String(result.error).slice(0, 60)}`);
+                        }
+                        else if (result.result !== undefined) {
+                            resultSummary = formatToolResult(result.result);
+                        }
+                    }
+                    // Print tool log
+                    console.log(toolHeader);
+                    if (resultSummary) {
+                        console.log(pc.dim('  ⎿  ') + resultSummary);
+                    }
+                    console.log(''); // Blank line between tools
+                    // Clear tool from spinner and immediately re-render with todos
+                    spinner.setTool(null);
+                    spinner.forceRender();
+                }
+            }
+            // Make sure spinner is stopped
+            if (!spinnerStopped && !spinner.isAborted()) {
+                spinner.stop();
+            }
+            // Skip stats if aborted
+            if (spinner.isAborted()) {
+                return;
+            }
+            // Output buffered text with markdown rendering
+            if (textBuffer) {
+                process.stdout.write(pc.bold(pc.green('Agent: ')));
+                console.log(renderMarkdown(textBuffer));
+            }
+            // Warn if tools were used but no text output (common with lite models)
+            if (usedTools && !hasTextOutput) {
+                console.log(pc.yellow('(No text response from model - try a more capable model like gemini-2.0-flash)'));
+            }
+            // Update session totals
+            sessionInputTokens += totalInputTokens;
+            sessionOutputTokens += totalOutputTokens;
+            sessionRequests++;
+            // Show token usage summary
+            if (totalInputTokens > 0 || totalOutputTokens > 0) {
+                const total = totalInputTokens + totalOutputTokens;
+                const sessionTotal = sessionInputTokens + sessionOutputTokens;
+                console.log(pc.dim(`\n[Tokens: ${total.toLocaleString()} (${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out) - ${llmCalls} LLM call(s)]`));
+                console.log(pc.dim(`[Session: ${sessionTotal.toLocaleString()} total (${sessionRequests} requests, avg ${Math.round(sessionTotal / sessionRequests).toLocaleString()}/req)]`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            spinner.stop();
+            // Don't show error for abort
+            if (error.name !== 'AbortError') {
+                console.error('\n' + pc.red('Error:'), error.message);
+            }
+            console.log('');
+        }
+    }
+    // Create interactive input with slash command autocomplete
+    const promptText = pc.bold(pc.cyan('compilr>')) + ' ';
+    const handleInput = async (input) => {
+        // Stop input handler while processing
+        inputHandler?.stop();
+        // Process the input
+        await processInput(input);
+        // Restart input handler for next prompt
+        inputHandler?.start();
+    };
+    inputHandler = createInteractiveInput(promptText, (input) => {
+        handleInput(input);
+    }, true, () => currentTodos);
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+        console.log('\n\nGoodbye!');
+        inputHandler?.stop();
+        process.exit(0);
+    });
+    // Start the interactive input
+    inputHandler.start();
+}
+// Run
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});