sona-code 0.1.0

package/dist/cli.js

@@ -0,0 +1,2979 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * SONA CODE
+ *
+ * AI coding assistant with 100x cost reduction.
+ * Full CLI capabilities powered by DeepSeek + SMR compression.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+const child_process_1 = require("child_process");
+const compressor_js_1 = require("./compressor.js");
+const proxy_js_1 = require("./proxy.js");
+const session_js_1 = require("./session.js");
+const rules_js_1 = require("./rules.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const VERSION = '0.1.0';
+const APP_NAME = 'SONA CODE';
+// Config file path for persistent settings
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.sona');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// Default configuration
+const DEFAULT_CONFIG = {
+    provider: 'deepseek',
+    model: 'deepseek-chat',
+    apiKey: '',
+    pricePerMillion: 0.14, // DeepSeek is much cheaper!
+};
+/**
+ * Load configuration from file
+ */
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+        }
+    }
+    catch {
+        // Ignore errors, use default
+    }
+    return { ...DEFAULT_CONFIG };
+}
+/**
+ * Save configuration to file
+ */
+function saveConfig(config) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        console.error('Failed to save config:', error);
+    }
+}
+const MEMORY_VERSION = 2;
+let pendingSave = null;
+let currentMemory = null;
+/**
+ * Get the memory file path for current workspace
+ */
+function getHistoryPath() {
+    const workspaceDir = path.join(process.cwd(), '.sona');
+    return path.join(workspaceDir, 'memory.json');
+}
+/**
+ * Initialize empty workspace memory
+ */
+function createEmptyMemory() {
+    return {
+        version: MEMORY_VERSION,
+        workspace: process.cwd(),
+        lastUpdated: new Date().toISOString(),
+        currentTask: null,
+        taskHistory: [],
+        filesRead: [],
+        filesWritten: [],
+        filesCreated: [],
+        commandsRun: [],
+        codebaseNotes: [],
+        recentExchanges: [],
+        stats: {
+            totalSessions: 1,
+            totalExchanges: 0,
+            firstSession: new Date().toISOString()
+        }
+    };
+}
+/**
+ * Load workspace memory
+ */
+function loadHistory() {
+    try {
+        const memoryPath = getHistoryPath();
+        if (fs.existsSync(memoryPath)) {
+            const data = fs.readFileSync(memoryPath, 'utf-8');
+            const memory = JSON.parse(data);
+            if (memory.version === MEMORY_VERSION) {
+                memory.stats.totalSessions++;
+                currentMemory = memory;
+                return memory;
+            }
+        }
+    }
+    catch {
+        // Ignore errors - corrupted file will be overwritten
+    }
+    currentMemory = createEmptyMemory();
+    return null;
+}
+/**
+ * Track a file operation
+ */
+function trackFileOp(op, filePath) {
+    if (!currentMemory)
+        currentMemory = createEmptyMemory();
+    const relativePath = filePath.startsWith(process.cwd())
+        ? filePath.slice(process.cwd().length + 1)
+        : filePath;
+    const list = op === 'read' ? currentMemory.filesRead
+        : op === 'write' ? currentMemory.filesWritten
+            : currentMemory.filesCreated;
+    if (!list.includes(relativePath)) {
+        list.push(relativePath);
+        // Keep lists bounded
+        if (list.length > 50)
+            list.shift();
+    }
+}
+/**
+ * Track a command execution
+ */
+function trackCommand(cmd, success) {
+    if (!currentMemory)
+        currentMemory = createEmptyMemory();
+    currentMemory.commandsRun.push({
+        cmd: cmd.slice(0, 200),
+        success,
+        timestamp: new Date().toISOString()
+    });
+    // Keep last 30 commands
+    if (currentMemory.commandsRun.length > 30) {
+        currentMemory.commandsRun.shift();
+    }
+}
+/**
+ * Update current task
+ */
+function updateTask(task) {
+    if (!currentMemory)
+        currentMemory = createEmptyMemory();
+    if (currentMemory.currentTask && currentMemory.currentTask !== task) {
+        currentMemory.taskHistory.push(currentMemory.currentTask);
+        if (currentMemory.taskHistory.length > 10) {
+            currentMemory.taskHistory.shift();
+        }
+    }
+    currentMemory.currentTask = task.slice(0, 500);
+}
+/**
+ * Add a codebase discovery note
+ */
+function addCodebaseNote(note) {
+    if (!currentMemory)
+        currentMemory = createEmptyMemory();
+    if (!currentMemory.codebaseNotes.includes(note)) {
+        currentMemory.codebaseNotes.push(note.slice(0, 300));
+        if (currentMemory.codebaseNotes.length > 20) {
+            currentMemory.codebaseNotes.shift();
+        }
+    }
+}
+/**
+ * Debounced save - batches rapid writes into single file operation
+ */
+function saveHistory(messages, existingHistory) {
+    if (pendingSave)
+        clearTimeout(pendingSave);
+    pendingSave = setTimeout(() => {
+        try {
+            const workspaceDir = path.join(process.cwd(), '.sona');
+            if (!fs.existsSync(workspaceDir)) {
+                fs.mkdirSync(workspaceDir, { recursive: true });
+            }
+            if (!currentMemory)
+                currentMemory = existingHistory || createEmptyMemory();
+            // Extract recent exchanges
+            const filtered = messages.filter(m => m.role === 'user' || m.role === 'assistant');
+            const pairs = [];
+            for (let i = 0; i < filtered.length - 1; i += 2) {
+                if (filtered[i]?.role === 'user' && filtered[i + 1]?.role === 'assistant') {
+                    pairs.push({
+                        user: filtered[i].content.slice(0, 2000),
+                        assistant: filtered[i + 1].content.slice(0, 3000),
+                        timestamp: new Date().toISOString()
+                    });
+                }
+            }
+            // Keep last 10 exchanges - enough for full context
+            currentMemory.recentExchanges = pairs.slice(-10);
+            currentMemory.lastUpdated = new Date().toISOString();
+            currentMemory.stats.totalExchanges = (existingHistory?.stats.totalExchanges || 0) + pairs.length;
+            // Try to extract task from first user message
+            if (pairs.length > 0 && !currentMemory.currentTask) {
+                const firstMsg = pairs[0].user;
+                if (firstMsg.length > 10) {
+                    currentMemory.currentTask = firstMsg.slice(0, 200);
+                }
+            }
+            // Atomic write
+            const tempPath = getHistoryPath() + '.tmp';
+            fs.writeFileSync(tempPath, JSON.stringify(currentMemory, null, 2));
+            fs.renameSync(tempPath, getHistoryPath());
+        }
+        catch {
+            // Silently fail
+        }
+    }, 2000);
+}
+/**
+ * Build rich context from workspace memory
+ */
+function buildHistoryContext(memory) {
+    if (!memory)
+        return '';
+    const parts = [];
+    parts.push('## Workspace Memory (from previous sessions)');
+    // Current/recent tasks - most important
+    if (memory.currentTask) {
+        parts.push(`\n**Last task:** ${memory.currentTask}`);
+    }
+    if (memory.taskHistory.length > 0) {
+        parts.push(`**Previous tasks:** ${memory.taskHistory.slice(-3).join(' → ')}`);
+    }
+    // Files touched - crucial for continuation
+    if (memory.filesWritten.length > 0) {
+        parts.push(`\n**Files modified:** ${memory.filesWritten.slice(-15).join(', ')}`);
+    }
+    if (memory.filesCreated.length > 0) {
+        parts.push(`**Files created:** ${memory.filesCreated.slice(-10).join(', ')}`);
+    }
+    if (memory.filesRead.length > 0) {
+        parts.push(`**Files explored:** ${memory.filesRead.slice(-15).join(', ')}`);
+    }
+    // Recent commands
+    if (memory.commandsRun.length > 0) {
+        const recentCmds = memory.commandsRun.slice(-5).map(c => `${c.success ? '✓' : '✗'} ${c.cmd}`);
+        parts.push(`\n**Recent commands:**\n${recentCmds.join('\n')}`);
+    }
+    // Codebase notes
+    if (memory.codebaseNotes.length > 0) {
+        parts.push(`\n**Codebase notes:**\n- ${memory.codebaseNotes.join('\n- ')}`);
+    }
+    // Recent conversation
+    if (memory.recentExchanges.length > 0) {
+        parts.push('\n**Recent conversation:**');
+        memory.recentExchanges.slice(-5).forEach(ex => {
+            parts.push(`User: ${ex.user.slice(0, 300)}${ex.user.length > 300 ? '...' : ''}`);
+            parts.push(`You: ${ex.assistant.slice(0, 400)}${ex.assistant.length > 400 ? '...' : ''}`);
+        });
+    }
+    // Stats
+    parts.push(`\n(Session ${memory.stats.totalSessions}, ${memory.stats.totalExchanges} total exchanges since ${memory.stats.firstSession.split('T')[0]})`);
+    return parts.join('\n');
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// SONA CODE - Retro Terminal UI System
+// Broken white theme with pixel-art ASCII aesthetic
+// ═══════════════════════════════════════════════════════════════════════════
+// Get terminal width for responsive layout
+function getTerminalWidth() {
+    return process.stdout.columns || 80;
+}
+function isWideTerminal() {
+    return getTerminalWidth() >= 100;
+}
+// ASCII Art logo - pixel/retro style (simulates Press Start 2P at 40px)
+const SONA_LOGO = `
+ ███████╗ ██████╗ ███╗   ██╗ █████╗ 
+ ██╔════╝██╔═══██╗████╗  ██║██╔══██╗
+ ███████╗██║   ██║██╔██╗ ██║███████║
+ ╚════██║██║   ██║██║╚██╗██║██╔══██║
+ ███████║╚██████╔╝██║ ╚████║██║  ██║
+ ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝`;
+// ANSI color codes - Broken white/gray theme
+const colors = {
+    // Primary - broken white (off-white, warm)
+    brokenWhite: (s) => `\x1b[38;5;253m${s}\x1b[0m`, // #dadada - broken white
+    warmWhite: (s) => `\x1b[38;5;230m${s}\x1b[0m`, // Warm off-white
+    // Grays (tailwind-inspired)
+    gray200: (s) => `\x1b[38;5;252m${s}\x1b[0m`, // Light gray - lines
+    gray400: (s) => `\x1b[38;5;246m${s}\x1b[0m`, // Medium gray
+    gray500: (s) => `\x1b[38;5;244m${s}\x1b[0m`, // Gray
+    gray600: (s) => `\x1b[38;5;242m${s}\x1b[0m`, // Darker gray
+    gray700: (s) => `\x1b[38;5;240m${s}\x1b[0m`, // thinking text
+    gray800: (s) => `\x1b[38;5;238m${s}\x1b[0m`, // Very dark
+    // Accent colors (muted)
+    cyan: (s) => `\x1b[38;5;117m${s}\x1b[0m`, // Soft cyan
+    green: (s) => `\x1b[38;5;114m${s}\x1b[0m`, // Soft green
+    red: (s) => `\x1b[38;5;174m${s}\x1b[0m`, // Soft red
+    yellow: (s) => `\x1b[38;5;186m${s}\x1b[0m`, // Soft yellow
+    blue: (s) => `\x1b[38;5;110m${s}\x1b[0m`, // Soft blue
+    magenta: (s) => `\x1b[38;5;182m${s}\x1b[0m`, // Soft magenta
+    orange: (s) => `\x1b[38;5;216m${s}\x1b[0m`, // Soft orange
+    // Legacy aliases
+    white: (s) => `\x1b[38;5;253m${s}\x1b[0m`,
+    lightGray: (s) => `\x1b[38;5;252m${s}\x1b[0m`,
+    gray: (s) => `\x1b[38;5;244m${s}\x1b[0m`,
+    dimGray: (s) => `\x1b[38;5;240m${s}\x1b[0m`,
+    darkGray: (s) => `\x1b[38;5;236m${s}\x1b[0m`,
+    // Text styles
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+    italic: (s) => `\x1b[3m${s}\x1b[0m`,
+    underline: (s) => `\x1b[4m${s}\x1b[0m`,
+    // Semantic styles - SONA theme
+    title: (s) => `\x1b[1m\x1b[38;5;253m${s}\x1b[0m`, // Bold broken white - headers
+    subtitle: (s) => `\x1b[38;5;250m${s}\x1b[0m`, // Lighter
+    body: (s) => `\x1b[38;5;252m${s}\x1b[0m`, // Gray 200 - main text
+    small: (s) => `\x1b[38;5;244m${s}\x1b[0m`, // Gray 500 - small text
+    muted: (s) => `\x1b[38;5;240m${s}\x1b[0m`, // Gray 700 - muted
+    accent: (s) => `\x1b[38;5;253m${s}\x1b[0m`, // Broken white accent
+    success: (s) => `\x1b[38;5;114m${s}\x1b[0m`, // Soft green
+    warning: (s) => `\x1b[38;5;186m${s}\x1b[0m`, // Soft yellow
+    error: (s) => `\x1b[38;5;174m${s}\x1b[0m`, // Soft red
+    info: (s) => `\x1b[38;5;110m${s}\x1b[0m`, // Soft blue
+    highlight: (s) => `\x1b[48;5;236m\x1b[38;5;253m${s}\x1b[0m`,
+    // File types
+    folder: (s) => `\x1b[38;5;110m${s}\x1b[0m`,
+    file: (s) => `\x1b[38;5;252m${s}\x1b[0m`,
+    exec: (s) => `\x1b[38;5;114m${s}\x1b[0m`,
+    link: (s) => `\x1b[38;5;117m${s}\x1b[0m`,
+};
+// Unicode characters for clean UI
+const ui = {
+    // Box drawing (clean lines)
+    topLeft: '┌',
+    topRight: '┐',
+    bottomLeft: '└',
+    bottomRight: '┘',
+    horizontal: '─',
+    vertical: '│',
+    leftT: '├',
+    rightT: '┤',
+    topT: '┬',
+    bottomT: '┴',
+    crossBox: '┼',
+    // Double lines for emphasis
+    dHorizontal: '═',
+    dVertical: '║',
+    // Icons (minimal)
+    bullet: '•',
+    arrow: '→',
+    arrowRight: '▸',
+    arrowDown: '▾',
+    star: '★',
+    dot: '·',
+    diamond: '◆',
+    circle: '○',
+    circleFilled: '●',
+    square: '□',
+    // Spinners
+    spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+    thinking: ['◐', '◓', '◑', '◒'],
+    // Status
+    success: '✓',
+    error: '✗',
+    warning: '⚠',
+    info: 'ℹ',
+    check: '✓',
+    cross: '✗',
+    // File icons (simple)
+    folderIcon: '▸',
+    fileIcon: '·',
+    git: '⎇',
+    chart: '📊',
+    money: '💰',
+};
+// Formatting helpers
+const fmt = {
+    // Create a horizontal line
+    line: (width = 60) => ui.horizontal.repeat(width),
+    // Create a box around text
+    box: (title, content, width = 56) => {
+        const lines = [];
+        const innerWidth = width - 4;
+        // Top border with title
+        const titlePad = Math.max(0, innerWidth - title.length - 2);
+        lines.push(colors.accent(ui.topLeft + ui.horizontal + ' ') + colors.title(title) + ' ' + colors.accent(ui.horizontal.repeat(titlePad) + ui.topRight));
+        // Content lines
+        for (const line of content) {
+            const stripped = line.replace(/\x1b\[[0-9;]*m/g, ''); // Strip ANSI for length calc
+            const padding = Math.max(0, innerWidth - stripped.length);
+            lines.push(colors.accent(ui.vertical) + ' ' + line + ' '.repeat(padding) + ' ' + colors.accent(ui.vertical));
+        }
+        // Bottom border
+        lines.push(colors.accent(ui.bottomLeft + ui.horizontal.repeat(width - 2) + ui.bottomRight));
+        return lines.join('\n');
+    },
+    // Indent text
+    indent: (s, spaces = 2) => ' '.repeat(spaces) + s,
+    // Format a key-value pair
+    kv: (key, value, keyWidth = 14) => {
+        return colors.muted(key.padEnd(keyWidth)) + colors.body(value);
+    },
+    // Format a list item
+    li: (text, indent = 0) => {
+        return ' '.repeat(indent) + colors.accent(ui.bullet) + ' ' + colors.body(text);
+    },
+    // Format numbered list item
+    num: (n, text, indent = 0) => {
+        return ' '.repeat(indent) + colors.accent(`${n}.`) + ' ' + colors.body(text);
+    },
+    // Section header
+    section: (title) => {
+        return '\n' + colors.title(title) + '\n' + colors.dimGray(ui.horizontal.repeat(title.length));
+    },
+    // Subtle divider
+    divider: () => colors.dimGray('  ' + ui.dot.repeat(40)),
+};
+// Response formatter - broken white theme, reduced line spacing
+function formatResponse(text) {
+    const lines = text.split('\n');
+    const formatted = [];
+    let inCodeBlock = false;
+    let inList = false;
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        // Code blocks - gray 500
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            formatted.push(colors.gray600(' ' + line));
+            continue;
+        }
+        if (inCodeBlock) {
+            formatted.push(colors.gray400(' ' + line));
+            continue;
+        }
+        // Headers - broken white bold
+        if (line.startsWith('### ')) {
+            formatted.push(colors.brokenWhite(' ' + line.slice(4)));
+            continue;
+        }
+        if (line.startsWith('## ')) {
+            formatted.push(colors.bold(colors.brokenWhite(' ' + line.slice(3))));
+            continue;
+        }
+        if (line.startsWith('# ')) {
+            formatted.push(colors.bold(colors.brokenWhite(' ' + line.slice(2))));
+            continue;
+        }
+        // Numbered lists with bold (1. **Item**)
+        const numMatch = line.match(/^(\d+)\.\s+\*\*(.+?)\*\*:?\s*(.*)/);
+        if (numMatch) {
+            inList = true;
+            const [, num, boldPart, rest] = numMatch;
+            formatted.push(` ${colors.gray500(num + '.')} ${colors.brokenWhite(boldPart)}${rest ? ' ' + colors.gray200(rest) : ''}`);
+            continue;
+        }
+        // Simple numbered lists
+        const simpleNumMatch = line.match(/^(\d+)\.\s+(.*)/);
+        if (simpleNumMatch) {
+            inList = true;
+            const [, num, content] = simpleNumMatch;
+            formatted.push(` ${colors.gray500(num + '.')} ${colors.gray200(content)}`);
+            continue;
+        }
+        // Bullet points
+        if (line.match(/^[-*]\s+/)) {
+            inList = true;
+            const content = line.replace(/^[-*]\s+/, '');
+            formatted.push(` ${colors.gray500('·')} ${colors.gray200(content)}`);
+            continue;
+        }
+        // Sub-bullets
+        if (line.match(/^\s+[-*]\s+/)) {
+            const content = line.replace(/^\s+[-*]\s+/, '');
+            formatted.push(`   ${colors.gray600('·')} ${colors.gray400(content)}`);
+            continue;
+        }
+        // Empty line resets list state - reduced spacing
+        if (line.trim() === '') {
+            inList = false;
+            // Only add empty line if not consecutive
+            if (formatted.length > 0 && formatted[formatted.length - 1] !== '') {
+                formatted.push('');
+            }
+            continue;
+        }
+        // Bold text **text**
+        line = line.replace(/\*\*(.+?)\*\*/g, (_, text) => colors.brokenWhite(text));
+        // Inline code `code`
+        line = line.replace(/`([^`]+)`/g, (_, code) => colors.gray400(code));
+        // Regular paragraph - gray 200
+        formatted.push(' ' + colors.gray200(line));
+    }
+    return formatted.join('\n');
+}
+const program = new commander_1.Command();
+program
+    .name('sona')
+    .description('SONA CODE - AI coding assistant with 100x cost reduction')
+    .version(VERSION)
+    .option('--deepseek-key <key>', 'DeepSeek API key')
+    .option('--openai-key <key>', 'OpenAI API key')
+    .option('--anthropic-key <key>', 'Anthropic API key')
+    .option('-m, --model <model>', 'Model to use (deepseek-chat, gpt-4o-mini, etc.)')
+    .option('--provider <provider>', 'Provider: deepseek, openai, or anthropic')
+    .option('-s, --system <prompt>', 'System prompt')
+    .option('--no-compress', 'Disable compression')
+    .action(async (opts) => {
+    // Default action: start chat
+    await startChat(opts);
+});
+// ============================================================
+// PROXY COMMANDS
+// ============================================================
+/**
+ * Start proxy server
+ */
+program
+    .command('start')
+    .alias('proxy')
+    .description('Start the transparent proxy server')
+    .option('-p, --port <number>', 'Port to listen on', '8787')
+    .option('-v, --verbose', 'Show request logs')
+    .option('--openai-key <key>', 'OpenAI API key')
+    .option('--anthropic-key <key>', 'Anthropic API key')
+    .option('--openai-url <url>', 'OpenAI API base URL', 'https://api.openai.com')
+    .option('--anthropic-url <url>', 'Anthropic API base URL', 'https://api.anthropic.com')
+    .option('--price <number>', 'Price per million tokens for cost estimation', '15')
+    .action(async (opts) => {
+    const port = parseInt(opts.port);
+    console.log('');
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log(colors.bold('  SONA CODE Proxy'));
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log('');
+    // Check for API keys
+    let openaiKey = opts.openaiKey || process.env.OPENAI_API_KEY;
+    let anthropicKey = opts.anthropicKey || process.env.ANTHROPIC_API_KEY;
+    // If no keys provided, prompt user
+    if (!openaiKey && !anthropicKey) {
+        console.log(colors.yellow('  No API keys found. Please provide at least one:'));
+        console.log('');
+        const rl = (0, readline_1.createInterface)({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const question = (prompt) => {
+            return new Promise((resolve) => {
+                rl.question(prompt, (answer) => {
+                    resolve(answer.trim());
+                });
+            });
+        };
+        console.log(colors.gray('  Press Enter to skip if you don\'t have a key.'));
+        console.log('');
+        openaiKey = await question(colors.cyan('  OpenAI API Key: '));
+        anthropicKey = await question(colors.cyan('  Anthropic API Key: '));
+        rl.close();
+        console.log('');
+        if (!openaiKey && !anthropicKey) {
+            console.log(colors.red('  Error: At least one API key is required.'));
+            console.log('');
+            console.log('  You can also set environment variables:');
+            console.log(colors.dim('    export OPENAI_API_KEY=sk-...'));
+            console.log(colors.dim('    export ANTHROPIC_API_KEY=sk-ant-...'));
+            console.log('');
+            console.log('  Or pass keys directly:');
+            console.log(colors.dim('    sona start --openai-key sk-... --anthropic-key sk-ant-...'));
+            console.log('');
+            process.exit(1);
+        }
+    }
+    // Show which APIs are configured
+    console.log(colors.bold('  API Configuration:'));
+    if (openaiKey) {
+        console.log(`    ${colors.green('✓')} OpenAI:    ${colors.green('configured')} ${colors.gray(`(${maskKey(openaiKey)})`)}`);
+    }
+    else {
+        console.log(`    ${colors.gray('○')} OpenAI:    ${colors.gray('not configured')}`);
+    }
+    if (anthropicKey) {
+        console.log(`    ${colors.green('✓')} Anthropic: ${colors.green('configured')} ${colors.gray(`(${maskKey(anthropicKey)})`)}`);
+    }
+    else {
+        console.log(`    ${colors.gray('○')} Anthropic: ${colors.gray('not configured')}`);
+    }
+    console.log('');
+    try {
+        const proxy = await (0, proxy_js_1.startProxy)({
+            port,
+            verbose: opts.verbose,
+            openaiBaseUrl: opts.openaiUrl,
+            anthropicBaseUrl: opts.anthropicUrl,
+            pricePerMillionTokens: parseFloat(opts.price),
+            openaiApiKey: openaiKey,
+            anthropicApiKey: anthropicKey,
+        });
+        console.log(`  ${colors.green('●')} Proxy running on ${colors.bold(`http://localhost:${port}`)}`);
+        console.log('');
+        console.log(colors.bold('  How to use:'));
+        console.log('');
+        console.log('  ' + colors.cyan('Option 1:') + ' Set environment variables');
+        console.log(colors.dim('    export OPENAI_BASE_URL=http://localhost:' + port));
+        console.log(colors.dim('    export ANTHROPIC_BASE_URL=http://localhost:' + port));
+        console.log('');
+        console.log('  ' + colors.cyan('Option 2:') + ' Use one-liner');
+        console.log(colors.dim(`    eval $(sona env -p ${port})`));
+        console.log('');
+        console.log('  ' + colors.cyan('Option 3:') + ' Wrap commands directly');
+        console.log(colors.dim('    sona wrap codex "your prompt"'));
+        console.log('');
+        console.log(colors.bold('  Dashboard: ') + colors.blue(`http://localhost:${port}`));
+        console.log('');
+        console.log(colors.gray('  Press Ctrl+C to stop'));
+        console.log('');
+        console.log(colors.cyan('═'.repeat(60)));
+        console.log('');
+        // Handle shutdown
+        process.on('SIGINT', async () => {
+            console.log('');
+            console.log(colors.yellow('  Shutting down...'));
+            const stats = proxy.getStats();
+            if (stats.totalRequests > 0) {
+                console.log('');
+                console.log(colors.bold('  Session Summary:'));
+                console.log(`    Requests:     ${stats.totalRequests}`);
+                console.log(`    Tokens saved: ${colors.green(stats.totalTokensSaved.toLocaleString())}`);
+                console.log(`    Cost saved:   ${colors.green('$' + stats.estimatedCostSaved.toFixed(4))}`);
+            }
+            await proxy.stop();
+            console.log('');
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.error(colors.red(`  Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+/**
+ * Mask API key for display
+ */
+function maskKey(key) {
+    if (key.length < 10)
+        return '***';
+    return key.substring(0, 7) + '...' + key.substring(key.length - 4);
+}
+/**
+ * Output environment variables for shell eval
+ */
+program
+    .command('env')
+    .description('Output environment variables (use with eval)')
+    .option('-p, --port <number>', 'Proxy port', '8787')
+    .option('--fish', 'Output for fish shell')
+    .option('--powershell', 'Output for PowerShell')
+    .action((opts) => {
+    const port = opts.port;
+    if (opts.fish) {
+        console.log(`set -gx OPENAI_BASE_URL http://localhost:${port}`);
+        console.log(`set -gx ANTHROPIC_BASE_URL http://localhost:${port}`);
+    }
+    else if (opts.powershell) {
+        console.log(`$env:OPENAI_BASE_URL = "http://localhost:${port}"`);
+        console.log(`$env:ANTHROPIC_BASE_URL = "http://localhost:${port}"`);
+    }
+    else {
+        console.log(`export OPENAI_BASE_URL=http://localhost:${port}`);
+        console.log(`export ANTHROPIC_BASE_URL=http://localhost:${port}`);
+    }
+});
+/**
+ * One-line setup
+ */
+program
+    .command('init')
+    .description('Initialize SONA CODE in current shell')
+    .option('-p, --port <number>', 'Proxy port', '8787')
+    .action(async (opts) => {
+    const port = parseInt(opts.port);
+    console.log('');
+    console.log(colors.cyan('SONA CODE - Quick Setup'));
+    console.log('');
+    console.log('Add this to your shell profile (~/.zshrc, ~/.bashrc):');
+    console.log('');
+    console.log(colors.gray('  # SONA CODE Proxy'));
+    console.log(colors.cyan(`  alias sona-start='sona start -p ${port} &'`));
+    console.log(colors.cyan(`  export OPENAI_BASE_URL=http://localhost:${port}`));
+    console.log(colors.cyan(`  export ANTHROPIC_BASE_URL=http://localhost:${port}`));
+    console.log('');
+    console.log('Then restart your shell or run:');
+    console.log(colors.yellow('  source ~/.zshrc'));
+    console.log('');
+    console.log(colors.gray('After setup, run `sona start` and use your tools normally.'));
+    console.log('');
+});
+// ============================================================
+// WRAP COMMAND - Run any command with compression
+// ============================================================
+/**
+ * Wrap a command with SONA compression
+ */
+program
+    .command('wrap <command...>')
+    .description('Run a command with SONA compression enabled')
+    .option('-p, --port <number>', 'Proxy port (starts proxy if needed)', '8787')
+    .action(async (command, opts) => {
+    const port = parseInt(opts.port);
+    // Set environment variables for the child process
+    const env = {
+        ...process.env,
+        OPENAI_BASE_URL: `http://localhost:${port}`,
+        ANTHROPIC_BASE_URL: `http://localhost:${port}`,
+    };
+    // Check if proxy is running
+    try {
+        const response = await fetch(`http://localhost:${port}/_sona/health`);
+        if (!response.ok)
+            throw new Error('Proxy not healthy');
+    }
+    catch {
+        console.error(colors.yellow(`Starting SONA proxy on port ${port}...`));
+        // Start proxy in background
+        const proxyProcess = (0, child_process_1.spawn)('node', [process.argv[1], 'start', '-p', port.toString()], {
+            detached: true,
+            stdio: 'ignore',
+            env,
+        });
+        proxyProcess.unref();
+        // Wait for proxy to start
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    // Run the wrapped command
+    const [cmd, ...args] = command;
+    const child = (0, child_process_1.spawn)(cmd, args, {
+        stdio: 'inherit',
+        env,
+        shell: true,
+    });
+    child.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+});
+// ============================================================
+// DOCUMENT PROCESSING COMMANDS
+// ============================================================
+/**
+ * Process command - Process documents for LLM with continuous compression
+ */
+program
+    .command('process')
+    .description('Process documents for LLM with streaming compression')
+    .argument('<files...>', 'Input files to process')
+    .option('-o, --output <dir>', 'Output directory for compressed files')
+    .option('-c, --chunk-size <number>', 'Chunk size in characters', '4000')
+    .option('-p, --protect <terms...>', 'Terms to protect from compression')
+    .option('--json', 'Output as JSON with full metrics')
+    .option('-v, --verbose', 'Show detailed progress')
+    .action(async (files, opts) => {
+    const session = (0, session_js_1.createSession)({
+        protectedTerms: opts.protect || [],
+        verbose: opts.verbose,
+    });
+    const chunkSize = parseInt(opts.chunkSize);
+    const results = [];
+    console.log('');
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log(colors.bold('  SONA CODE Document Processing'));
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log('');
+    for (const file of files) {
+        if (!(0, fs_1.existsSync)(file)) {
+            console.error(colors.red(`  ✗ File not found: ${file}`));
+            continue;
+        }
+        const fileName = path.basename(file);
+        console.log(`  Processing: ${colors.cyan(fileName)}`);
+        session.startDocument(file, fileName);
+        const content = (0, fs_1.readFileSync)(file, 'utf-8');
+        const chunks = splitIntoChunks(content, chunkSize);
+        const compressedChunks = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const result = session.compressChunk(chunks[i]);
+            compressedChunks.push(result.compressedText);
+            if (opts.verbose) {
+                process.stdout.write(`\r    Chunk ${i + 1}/${chunks.length}: -${result.tokenSavings} tokens`);
+            }
+        }
+        if (opts.verbose) {
+            console.log('');
+        }
+        const docStats = session.endDocument();
+        if (docStats) {
+            results.push({
+                file: fileName,
+                originalTokens: docStats.originalTokens,
+                compressedTokens: docStats.compressedTokens,
+                tokensSaved: docStats.tokensSaved,
+                savingsPercent: docStats.savingsPercent,
+                chunks: docStats.chunksProcessed,
+            });
+            console.log(`    ${colors.green('✓')} ${docStats.chunksProcessed} chunks, ${colors.green(`${docStats.tokensSaved} tokens saved`)} (${docStats.savingsPercent.toFixed(1)}%)`);
+            // Save compressed output if requested
+            if (opts.output) {
+                if (!(0, fs_1.existsSync)(opts.output)) {
+                    fs.mkdirSync(opts.output, { recursive: true });
+                }
+                const outPath = path.join(opts.output, `compressed_${fileName}`);
+                (0, fs_1.writeFileSync)(outPath, compressedChunks.join('\n\n'));
+                console.log(`    ${colors.gray(`→ Saved to ${outPath}`)}`);
+            }
+        }
+    }
+    console.log('');
+    console.log(colors.cyan('─'.repeat(60)));
+    const stats = session.getStats();
+    if (opts.json) {
+        console.log(JSON.stringify({
+            session: stats.sessionId,
+            files: results,
+            totals: {
+                originalTokens: stats.totalOriginalInputTokens,
+                compressedTokens: stats.totalCompressedInputTokens,
+                tokensSaved: stats.totalInputTokensSaved,
+                savingsPercent: stats.inputSavingsPercent,
+                estimatedCostSaved: stats.estimatedInputCostSaved,
+            },
+        }, null, 2));
+    }
+    else {
+        console.log(colors.bold('  Summary:'));
+        console.log(`    Files processed:    ${results.length}`);
+        console.log(`    Total chunks:       ${stats.documentChunksProcessed}`);
+        console.log(`    Original tokens:    ${stats.totalOriginalInputTokens.toLocaleString()}`);
+        console.log(`    Compressed tokens:  ${stats.totalCompressedInputTokens.toLocaleString()}`);
+        console.log(`    ${colors.green(`Tokens saved:       ${stats.totalInputTokensSaved.toLocaleString()} (${stats.inputSavingsPercent.toFixed(1)}%)`)}`);
+        console.log(`    ${colors.yellow(`Est. cost saved:    $${stats.estimatedInputCostSaved.toFixed(4)}`)}`);
+    }
+    console.log('');
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log('');
+});
+/**
+ * Execute a shell command and return output
+ */
+async function execCommand(cmd) {
+    const { exec } = await import('child_process');
+    return new Promise((resolve) => {
+        exec(cmd, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            resolve({
+                stdout: stdout.toString(),
+                stderr: stderr.toString(),
+                code: error?.code || 0,
+            });
+        });
+    });
+}
+const fileCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+function getCachedFile(filePath) {
+    const entry = fileCache.get(filePath);
+    if (!entry)
+        return null;
+    // Check if file was modified
+    try {
+        const stats = fs.statSync(filePath);
+        if (stats.mtimeMs > entry.mtime) {
+            fileCache.delete(filePath);
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    // Check TTL
+    if (Date.now() - entry.lastAccess > CACHE_TTL) {
+        fileCache.delete(filePath);
+        return null;
+    }
+    entry.accessCount++;
+    entry.lastAccess = Date.now();
+    return entry.content;
+}
+function setCachedFile(filePath, content) {
+    try {
+        const stats = fs.statSync(filePath);
+        fileCache.set(filePath, {
+            content,
+            mtime: stats.mtimeMs,
+            accessCount: 1,
+            lastAccess: Date.now(),
+        });
+    }
+    catch {
+        // Ignore cache errors
+    }
+}
+function invalidateCache(filePath) {
+    fileCache.delete(filePath);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// TOOLS - Claude Code-like capabilities
+// ═══════════════════════════════════════════════════════════════════════════
+const TOOLS = [
+    // ─────────────────────────────────────────────────────────────────────────
+    // FILE SYSTEM OPERATIONS
+    // ─────────────────────────────────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read a file from the filesystem. Supports reading specific line ranges for large files to save tokens.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file to read' },
+                    start_line: { type: 'number', description: 'Start reading from this line (1-indexed). Omit to read from beginning.' },
+                    end_line: { type: 'number', description: 'Stop reading at this line (inclusive). Omit to read to end.' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Write content to a file. Creates parent directories if needed.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file to write' },
+                    content: { type: 'string', description: 'Content to write to the file' },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: 'Make surgical edits to a file using search and replace. More efficient than rewriting entire file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file to edit' },
+                    search: { type: 'string', description: 'Exact text to search for (must be unique in file)' },
+                    replace: { type: 'string', description: 'Text to replace with' },
+                },
+                required: ['path', 'search', 'replace'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Delete a file or empty directory from the filesystem.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to file or directory to delete' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'move_file',
+            description: 'Move or rename a file or directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    source: { type: 'string', description: 'Current path' },
+                    destination: { type: 'string', description: 'New path' },
+                },
+                required: ['source', 'destination'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'List files and directories with details (size, type, modified date).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path (default: current directory)' },
+                    recursive: { type: 'boolean', description: 'List recursively (default: false)' },
+                    max_depth: { type: 'number', description: 'Max depth for recursive listing (default: 3)' },
+                },
+                required: [],
+            },
+        },
+    },
+    // ─────────────────────────────────────────────────────────────────────────
+    // SEARCH & DISCOVERY
+    // ─────────────────────────────────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'glob_search',
+            description: 'Find files matching a glob pattern. Fast file discovery.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.{js,jsx}")' },
+                    path: { type: 'string', description: 'Base directory (default: current directory)' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'grep_search',
+            description: 'Search file contents using regex. Like ripgrep. Returns matching lines with context.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Regex pattern to search for' },
+                    path: { type: 'string', description: 'Directory or file to search (default: current directory)' },
+                    include: { type: 'string', description: 'File pattern to include (e.g., "*.ts")' },
+                    context: { type: 'number', description: 'Lines of context around matches (default: 2)' },
+                    max_results: { type: 'number', description: 'Maximum results to return (default: 20)' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    // ─────────────────────────────────────────────────────────────────────────
+    // TERMINAL & COMMANDS
+    // ─────────────────────────────────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'run_command',
+            description: 'Execute a shell command. For git, npm, builds, tests, etc.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'Shell command to execute' },
+                    cwd: { type: 'string', description: 'Working directory (default: current directory)' },
+                    timeout: { type: 'number', description: 'Timeout in seconds (default: 30)' },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    // ─────────────────────────────────────────────────────────────────────────
+    // GIT OPERATIONS
+    // ─────────────────────────────────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'git_status',
+            description: 'Get git status: branch, changed files, staged files, etc.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git_diff',
+            description: 'Show git diff. Unstaged changes by default.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    staged: { type: 'boolean', description: 'Show staged changes instead' },
+                    file: { type: 'string', description: 'Specific file to diff' },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git_log',
+            description: 'Show recent git commits.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    count: { type: 'number', description: 'Number of commits to show (default: 10)' },
+                    file: { type: 'string', description: 'Show commits for specific file' },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git_commit',
+            description: 'Stage files and create a commit.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    message: { type: 'string', description: 'Commit message' },
+                    files: { type: 'array', items: { type: 'string' }, description: 'Files to stage (default: all changed)' },
+                },
+                required: ['message'],
+            },
+        },
+    },
+];
+// Internal compression tools (not advertised to LLM but still functional)
+const INTERNAL_TOOLS = ['compress_document', 'compare_compression'];
+/**
+ * Word wrap text to specified width
+ */
+function wordWrap(text, maxWidth) {
+    const lines = [];
+    for (const paragraph of text.split('\n')) {
+        if (paragraph.length <= maxWidth) {
+            lines.push(paragraph);
+            continue;
+        }
+        const words = paragraph.split(' ');
+        let currentLine = '';
+        for (const word of words) {
+            if (currentLine.length + word.length + 1 <= maxWidth) {
+                currentLine += (currentLine ? ' ' : '') + word;
+            }
+            else {
+                if (currentLine)
+                    lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+        if (currentLine)
+            lines.push(currentLine);
+    }
+    return lines.join('\n');
+}
+/**
+ * Show spinner - shimmering * animation, gray 700
+ */
+async function withSpinner(message, work) {
+    let frameIndex = 0;
+    const start = Date.now();
+    const shimmer = ['*', '✦', '✧', '·', '✧', '✦'];
+    process.stdout.write(colors.gray700(`  ${shimmer[0]} ${message}`));
+    const interval = setInterval(() => {
+        frameIndex = (frameIndex + 1) % shimmer.length;
+        const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+        process.stdout.write(`\r` + colors.gray700(`  ${shimmer[frameIndex]} ${message} ${elapsed}s`));
+    }, 150);
+    try {
+        const result = await work();
+        clearInterval(interval);
+        const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+        process.stdout.write(`\r` + colors.gray500(`  ✓ ${message} ${elapsed}s`) + '\n');
+        return result;
+    }
+    catch (error) {
+        clearInterval(interval);
+        process.stdout.write(`\r` + colors.error(`  ✗ ${message}`) + '\n');
+        throw error;
+    }
+}
+/**
+ * Show file reading progress - gray 700, minimal
+ */
+function showFileProgress(filePath, size) {
+    const fileName = path.basename(filePath);
+    const sizeStr = size > 1024 ? `${(size / 1024).toFixed(1)}KB` : `${size}B`;
+    console.log(colors.gray700(`  · ${fileName} ${sizeStr}`));
+}
+/**
+ * Show a collapsible summary for file content (don't dump everything)
+ */
+function summarizeContent(content, _maxPreview = 200) {
+    const lines = content.split('\n');
+    const lineCount = lines.length;
+    if (lineCount <= 10) {
+        return content;
+    }
+    return content;
+}
+/**
+ * Execute a tool call with nice visual feedback
+ */
+async function executeTool(name, args) {
+    try {
+        switch (name) {
+            // ─────────────────────────────────────────────────────────────────────
+            // FILE OPERATIONS
+            // ─────────────────────────────────────────────────────────────────────
+            case 'read_file': {
+                const filePath = args.path;
+                const startLine = args.start_line;
+                const endLine = args.end_line;
+                if (!fs.existsSync(filePath)) {
+                    console.log(`  ${colors.error(ui.cross)} File not found: ${filePath}`);
+                    return `Error: File not found: ${filePath}`;
+                }
+                // Check cache first
+                const cached = getCachedFile(filePath);
+                let content;
+                if (cached && !startLine && !endLine) {
+                    content = cached;
+                    // 12px style - compact cached message
+                    console.log(colors.small(`  ${ui.success} cached: ${path.basename(filePath)}`));
+                }
+                else {
+                    const stats = fs.statSync(filePath);
+                    showFileProgress(filePath, stats.size);
+                    content = fs.readFileSync(filePath, 'utf-8');
+                    setCachedFile(filePath, content);
+                }
+                // Handle line ranges - 3px gap style
+                if (startLine || endLine) {
+                    const lines = content.split('\n');
+                    const start = Math.max(1, startLine || 1) - 1;
+                    const end = endLine ? Math.min(endLine, lines.length) : lines.length;
+                    content = lines.slice(start, end).map((line, i) => `${start + i + 1}| ${line}`).join('\n');
+                    console.log(colors.small(`    ${lines.length} lines, showing ${start + 1}-${end}`));
+                }
+                else {
+                    const lineCount = content.split('\n').length;
+                    console.log(colors.small(`    ${lineCount} lines`));
+                }
+                // Track file read for workspace memory
+                trackFileOp('read', filePath);
+                return content.slice(0, 50000);
+            }
+            case 'write_file': {
+                const filePath = args.path;
+                const content = args.content;
+                const isNew = !fs.existsSync(filePath);
+                // Show file creation/update preview with broken white strip style
+                const diffWidth = getTerminalWidth() - 2;
+                const contentLines = content.split('\n');
+                // Header
+                console.log('');
+                console.log(colors.gray500(` ${isNew ? 'creating' : 'writing'} ${path.basename(filePath)}`));
+                console.log('');
+                // Added lines: dark text on broken white background - continuous block
+                // Using dim style to simulate smaller 12px font
+                contentLines.forEach((line, i) => {
+                    const showLine = i < 8 || i >= contentLines.length - 2;
+                    const isEllipsis = i === 8 && contentLines.length > 10;
+                    if (showLine) {
+                        const displayLine = `  ${line}`.slice(0, diffWidth).padEnd(diffWidth);
+                        // \x1b[48;5;253m = broken white bg, \x1b[38;5;235m = dark text, \x1b[2m = dim (smaller feel)
+                        console.log(`\x1b[48;5;253m\x1b[38;5;235m\x1b[2m${displayLine}\x1b[0m`);
+                    }
+                    else if (isEllipsis) {
+                        const moreLine = `  ... ${contentLines.length - 10} more ...`.slice(0, diffWidth).padEnd(diffWidth);
+                        console.log(`\x1b[48;5;253m\x1b[38;5;240m\x1b[2m${moreLine}\x1b[0m`);
+                    }
+                });
+                console.log('');
+                // Write the file
+                const dir = path.dirname(filePath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(filePath, content);
+                invalidateCache(filePath);
+                // Track file operation for workspace memory
+                trackFileOp(isNew ? 'create' : 'write', filePath);
+                console.log(colors.gray500(` ✓ ${contentLines.length} lines`));
+                return `File written: ${filePath}`;
+            }
+            case 'edit_file': {
+                const filePath = args.path;
+                const search = args.search;
+                const replace = args.replace;
+                if (!fs.existsSync(filePath)) {
+                    console.log(colors.error(` ✗ not found: ${filePath}`));
+                    return `Error: File not found: ${filePath}`;
+                }
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const occurrences = content.split(search).length - 1;
+                if (occurrences === 0) {
+                    console.log(colors.warning(` ! search text not found`));
+                    return `Error: Search text not found in ${filePath}`;
+                }
+                if (occurrences > 1) {
+                    console.log(colors.warning(` ! ${occurrences} occurrences found (must be unique)`));
+                    return `Error: Found ${occurrences} occurrences. Search text must be unique.`;
+                }
+                // Show diff-style edit preview
+                const diffWidth = getTerminalWidth() - 2;
+                const searchLines = search.split('\n');
+                const replaceLines = replace.split('\n');
+                // Header
+                console.log('');
+                console.log(colors.gray500(` editing ${path.basename(filePath)}`));
+                console.log('');
+                // Removed lines: broken white text on terminal bg - dim for 12px feel
+                searchLines.forEach((line, i) => {
+                    const showLine = i < 6 || i >= searchLines.length - 2;
+                    const isEllipsis = i === 6 && searchLines.length > 8;
+                    if (showLine) {
+                        const displayLine = `  ${line}`.slice(0, diffWidth);
+                        // Dim broken white text, no background
+                        console.log(`\x1b[38;5;250m\x1b[2m${displayLine}\x1b[0m`);
+                    }
+                    else if (isEllipsis) {
+                        console.log(`\x1b[38;5;242m\x1b[2m  ... ${searchLines.length - 8} more ...\x1b[0m`);
+                    }
+                });
+                console.log(''); // gap between removed and added
+                // Added lines: dark text on broken white background - continuous block
+                // Using dim style to simulate smaller 12px font
+                replaceLines.forEach((line, i) => {
+                    const showLine = i < 6 || i >= replaceLines.length - 2;
+                    const isEllipsis = i === 6 && replaceLines.length > 8;
+                    if (showLine) {
+                        const displayLine = `  ${line}`.slice(0, diffWidth).padEnd(diffWidth);
+                        // \x1b[48;5;253m = broken white bg, \x1b[38;5;235m = dark text, \x1b[2m = dim (smaller feel)
+                        console.log(`\x1b[48;5;253m\x1b[38;5;235m\x1b[2m${displayLine}\x1b[0m`);
+                    }
+                    else if (isEllipsis) {
+                        const moreLine = `  ... ${replaceLines.length - 8} more ...`.slice(0, diffWidth).padEnd(diffWidth);
+                        console.log(`\x1b[48;5;253m\x1b[38;5;240m\x1b[2m${moreLine}\x1b[0m`);
+                    }
+                });
+                console.log('');
+                // Apply the edit
+                const newContent = content.replace(search, replace);
+                fs.writeFileSync(filePath, newContent);
+                invalidateCache(filePath);
+                // Track file operation for workspace memory
+                trackFileOp('write', filePath);
+                const linesChanged = replaceLines.length - searchLines.length;
+                console.log(colors.gray500(` ✓ ${linesChanged >= 0 ? '+' : ''}${linesChanged} lines`));
+                return `File edited: ${filePath}`;
+            }
+            case 'delete_file': {
+                const filePath = args.path;
+                if (!fs.existsSync(filePath)) {
+                    console.log(`  ${colors.error(ui.cross)} Not found: ${filePath}`);
+                    return `Error: File not found: ${filePath}`;
+                }
+                await withSpinner(`Deleting: ${path.basename(filePath)}`, async () => {
+                    const stats = fs.statSync(filePath);
+                    if (stats.isDirectory()) {
+                        fs.rmdirSync(filePath);
+                    }
+                    else {
+                        fs.unlinkSync(filePath);
+                    }
+                    invalidateCache(filePath);
+                });
+                return `Deleted: ${filePath}`;
+            }
+            case 'move_file': {
+                const source = args.source;
+                const destination = args.destination;
+                if (!fs.existsSync(source)) {
+                    console.log(`  ${colors.error(ui.cross)} Source not found: ${source}`);
+                    return `Error: Source not found: ${source}`;
+                }
+                await withSpinner(`Moving: ${path.basename(source)} → ${path.basename(destination)}`, async () => {
+                    const destDir = path.dirname(destination);
+                    if (!fs.existsSync(destDir)) {
+                        fs.mkdirSync(destDir, { recursive: true });
+                    }
+                    fs.renameSync(source, destination);
+                    invalidateCache(source);
+                });
+                return `Moved: ${source} → ${destination}`;
+            }
+            case 'list_directory': {
+                const dirPath = args.path || process.cwd();
+                const recursive = args.recursive || false;
+                const maxDepth = args.max_depth || 3;
+                if (!fs.existsSync(dirPath)) {
+                    console.log(`  ${colors.error(ui.cross)} Directory not found: ${dirPath}`);
+                    return `Error: Directory not found: ${dirPath}`;
+                }
+                if (recursive) {
+                    const result = await withSpinner(`Scanning: ${path.basename(dirPath) || dirPath}`, async () => {
+                        return await execCommand(`find "${dirPath}" -maxdepth ${maxDepth} -type f -o -type d 2>/dev/null | head -100`);
+                    });
+                    return result.stdout || 'Empty directory';
+                }
+                const entries = await withSpinner(`Listing: ${path.basename(dirPath) || dirPath}`, async () => {
+                    return fs.readdirSync(dirPath, { withFileTypes: true });
+                });
+                const dirs = entries.filter(e => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+                const files = entries.filter(e => !e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+                console.log(colors.dimGray(`    └─ ${dirs.length} folders, ${files.length} files`));
+                const output = [];
+                dirs.forEach(d => output.push(`📁 ${d.name}/`));
+                files.forEach(f => {
+                    try {
+                        const stats = fs.statSync(path.join(dirPath, f.name));
+                        const size = stats.size > 1024 ? `${(stats.size / 1024).toFixed(1)}KB` : `${stats.size}B`;
+                        output.push(`📄 ${f.name} (${size})`);
+                    }
+                    catch {
+                        output.push(`📄 ${f.name}`);
+                    }
+                });
+                return output.join('\n');
+            }
+            // ─────────────────────────────────────────────────────────────────────
+            // SEARCH & DISCOVERY
+            // ─────────────────────────────────────────────────────────────────────
+            case 'glob_search': {
+                const pattern = args.pattern;
+                const searchPath = args.path || '.';
+                const result = await withSpinner(`Searching: ${pattern}`, async () => {
+                    // Use find with pattern conversion
+                    const findPattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '*');
+                    return await execCommand(`find "${searchPath}" -name "${findPattern}" 2>/dev/null | head -50`);
+                });
+                const matches = result.stdout.trim().split('\n').filter(Boolean);
+                if (matches.length > 0) {
+                    console.log(colors.dimGray(`    └─ ${matches.length} files found`));
+                }
+                return result.stdout || 'No files found';
+            }
+            case 'grep_search': {
+                const pattern = args.pattern;
+                const searchPath = args.path || '.';
+                const include = args.include;
+                const context = args.context || 2;
+                const maxResults = args.max_results || 20;
+                let cmd = `grep -rn --color=never -C${context}`;
+                if (include) {
+                    cmd += ` --include="${include}"`;
+                }
+                cmd += ` "${pattern}" "${searchPath}" 2>/dev/null | head -${maxResults * 5}`;
+                const result = await withSpinner(`Searching: "${pattern}"`, async () => {
+                    return await execCommand(cmd);
+                });
+                if (result.stdout.trim()) {
+                    const lines = result.stdout.trim().split('\n');
+                    console.log(colors.dimGray(`    └─ ${Math.min(lines.length, maxResults)} matches`));
+                }
+                return result.stdout || 'No matches found';
+            }
+            // ─────────────────────────────────────────────────────────────────────
+            // TERMINAL & COMMANDS
+            // ─────────────────────────────────────────────────────────────────────
+            case 'run_command': {
+                const cmd = args.command;
+                const cwd = args.cwd;
+                const shortCmd = cmd.length > 50 ? cmd.slice(0, 47) + '...' : cmd;
+                const result = await withSpinner(`Running: ${shortCmd}`, async () => {
+                    if (cwd) {
+                        return await execCommand(`cd "${cwd}" && ${cmd}`);
+                    }
+                    return await execCommand(cmd);
+                });
+                const output = result.stdout || result.stderr || '(no output)';
+                // Smart output truncation for common commands
+                let displayOutput = output.trim();
+                if (cmd.includes('npm install') || cmd.includes('yarn add')) {
+                    // Summarize package install output
+                    const lines = displayOutput.split('\n');
+                    const added = lines.find(l => l.includes('added') || l.includes('packages'));
+                    if (added && lines.length > 5) {
+                        displayOutput = added;
+                    }
+                }
+                const outputLines = displayOutput.split('\n');
+                if (outputLines.length > 10) {
+                    console.log(colors.dimGray(`     ${ui.topLeft}${ui.horizontal} Output (${outputLines.length} lines)`));
+                    outputLines.slice(0, 5).forEach(line => {
+                        console.log(colors.dimGray(`     ${ui.vertical} `) + colors.body(line.slice(0, 70)));
+                    });
+                    console.log(colors.dimGray(`     ${ui.vertical} `) + colors.muted(`... ${outputLines.length - 5} more lines`));
+                    console.log(colors.dimGray(`     ${ui.bottomLeft}${ui.horizontal.repeat(3)}`));
+                }
+                else if (outputLines.length > 0 && displayOutput) {
+                    console.log(colors.dimGray(`     ${ui.topLeft}${ui.horizontal} Output`));
+                    outputLines.forEach(line => {
+                        console.log(colors.dimGray(`     ${ui.vertical} `) + colors.body(line.slice(0, 80)));
+                    });
+                    console.log(colors.dimGray(`     ${ui.bottomLeft}${ui.horizontal.repeat(3)}`));
+                }
+                // Track command for workspace memory
+                trackCommand(cmd, result.code === 0);
+                if (result.code !== 0) {
+                    return `Exit code ${result.code}:\n${output}`;
+                }
+                return output.slice(0, 10000);
+            }
+            // ─────────────────────────────────────────────────────────────────────
+            // GIT OPERATIONS
+            // ─────────────────────────────────────────────────────────────────────
+            case 'git_status': {
+                const result = await withSpinner('Git status', async () => {
+                    return await execCommand('git status --porcelain -b');
+                });
+                const lines = result.stdout.trim().split('\n');
+                const branch = lines[0]?.replace('## ', '') || 'unknown';
+                const changes = lines.slice(1).length;
+                console.log(colors.dimGray(`    └─ ${branch}, ${changes} changed files`));
+                // Parse into structured output
+                const output = [`Branch: ${branch}`];
+                if (changes > 0) {
+                    output.push('\nChanges:');
+                    lines.slice(1).forEach(line => {
+                        const status = line.slice(0, 2);
+                        const file = line.slice(3);
+                        const icon = status.includes('M') ? '~' : status.includes('A') ? '+' : status.includes('D') ? '-' : '?';
+                        output.push(`  ${icon} ${file}`);
+                    });
+                }
+                return output.join('\n');
+            }
+            case 'git_diff': {
+                const staged = args.staged || false;
+                const file = args.file;
+                let cmd = staged ? 'git diff --cached' : 'git diff';
+                if (file)
+                    cmd += ` -- "${file}"`;
+                cmd += ' | head -200';
+                const result = await withSpinner(staged ? 'Git diff (staged)' : 'Git diff', async () => {
+                    return await execCommand(cmd);
+                });
+                const lines = result.stdout.trim().split('\n').length;
+                if (result.stdout.trim()) {
+                    console.log(colors.dimGray(`    └─ ${lines} lines of diff`));
+                }
+                return result.stdout || 'No changes';
+            }
+            case 'git_log': {
+                const count = args.count || 10;
+                const file = args.file;
+                let cmd = `git log --oneline -${count}`;
+                if (file)
+                    cmd += ` -- "${file}"`;
+                const result = await withSpinner('Git log', async () => {
+                    return await execCommand(cmd);
+                });
+                return result.stdout || 'No commits';
+            }
+            case 'git_commit': {
+                const message = args.message;
+                const files = args.files;
+                // Stage files
+                const stageCmd = files && files.length > 0
+                    ? `git add ${files.map(f => `"${f}"`).join(' ')}`
+                    : 'git add -A';
+                await withSpinner('Staging files', async () => {
+                    return await execCommand(stageCmd);
+                });
+                // Commit
+                const result = await withSpinner('Committing', async () => {
+                    return await execCommand(`git commit -m "${message.replace(/"/g, '\\"')}"`);
+                });
+                if (result.code !== 0) {
+                    return `Commit failed: ${result.stderr || result.stdout}`;
+                }
+                // Get commit hash
+                const hashResult = await execCommand('git rev-parse --short HEAD');
+                const hash = hashResult.stdout.trim();
+                console.log(colors.dimGray(`    └─ Committed: ${hash}`));
+                return `Committed: ${hash} - ${message}`;
+            }
+            case 'compress_document': {
+                const filePath = args.path;
+                const returnText = args.return_text || false;
+                const pricePerMillion = args.price_per_million || 15;
+                if (!fs.existsSync(filePath)) {
+                    console.log(`  ${colors.red('✗')} File not found: ${filePath}`);
+                    return `Error: File not found: ${filePath}`;
+                }
+                // Read file content (handle PDF via pdf-parse)
+                let content;
+                const ext = path.extname(filePath).toLowerCase();
+                if (ext === '.pdf') {
+                    content = await withSpinner(`Extracting PDF: ${path.basename(filePath)}`, async () => {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-require-imports
+                            const pdfParse = require('pdf-parse');
+                            const dataBuffer = fs.readFileSync(filePath);
+                            const data = await pdfParse(dataBuffer);
+                            return data.text || '';
+                        }
+                        catch {
+                            // Fallback to pdftotext CLI
+                            const result = await execCommand(`pdftotext "${filePath}" - 2>/dev/null`);
+                            return result.stdout || '';
+                        }
+                    });
+                    if (!content.trim()) {
+                        return 'Error: Could not extract text from PDF.';
+                    }
+                }
+                else {
+                    content = fs.readFileSync(filePath, 'utf-8');
+                }
+                const stats = fs.statSync(filePath);
+                showFileProgress(filePath, stats.size);
+                // Compress using SONA
+                const compressor = new compressor_js_1.SonaCompressor();
+                const result = await withSpinner('Compressing with SMR...', async () => {
+                    return compressor.compress(content);
+                });
+                // Calculate costs
+                const costOriginal = (result.originalTokens / 1_000_000) * pricePerMillion;
+                const costCompressed = (result.compressedTokens / 1_000_000) * pricePerMillion;
+                const costSaved = costOriginal - costCompressed;
+                // Display metrics with premium styling
+                console.log('');
+                console.log(colors.accent(`  ${ui.topLeft}${ui.horizontal.repeat(48)}${ui.topRight}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.title('  ' + ui.chart + ' Compression Results') + '                         ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.leftT}${ui.horizontal.repeat(48)}${ui.rightT}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('  Original') + colors.body(`     ${result.originalTokens.toLocaleString().padStart(10)} tokens`) + '        ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('  Compressed') + colors.body(`   ${result.compressedTokens.toLocaleString().padStart(10)} tokens`) + '        ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('  Saved') + colors.success(`        ${result.tokenSavings.toLocaleString().padStart(10)} tokens`) + colors.success(` (${result.tokenSavingsPercent.toFixed(1)}%)`) + '   ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.leftT}${ui.horizontal.repeat(48)}${ui.rightT}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.success(`  ${ui.money} Cost saved: $${costSaved.toFixed(4)} per request`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.bottomLeft}${ui.horizontal.repeat(48)}${ui.bottomRight}`));
+                console.log('');
+                const metrics = {
+                    file: filePath,
+                    originalTokens: result.originalTokens,
+                    compressedTokens: result.compressedTokens,
+                    tokensSaved: result.tokenSavings,
+                    compressionRatio: result.tokenSavingsPercent,
+                    costOriginal: costOriginal,
+                    costCompressed: costCompressed,
+                    costSaved: costSaved,
+                    pricePerMillion: pricePerMillion,
+                };
+                if (returnText) {
+                    return JSON.stringify({ metrics, compressedText: result.compressedText }, null, 2);
+                }
+                return JSON.stringify(metrics, null, 2);
+            }
+            case 'compare_compression': {
+                const filePath = args.path;
+                const pricePerMillion = args.price_per_million || 15;
+                const outputReport = args.output_report;
+                if (!fs.existsSync(filePath)) {
+                    console.log(`  ${colors.red('✗')} File not found: ${filePath}`);
+                    return `Error: File not found: ${filePath}`;
+                }
+                // Read file
+                let content;
+                const ext = path.extname(filePath).toLowerCase();
+                if (ext === '.pdf') {
+                    content = await withSpinner(`Extracting PDF: ${path.basename(filePath)}`, async () => {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-require-imports
+                            const pdfParse = require('pdf-parse');
+                            const dataBuffer = fs.readFileSync(filePath);
+                            const data = await pdfParse(dataBuffer);
+                            return data.text || '';
+                        }
+                        catch {
+                            const result = await execCommand(`pdftotext "${filePath}" - 2>/dev/null`);
+                            return result.stdout || '';
+                        }
+                    });
+                    if (!content.trim()) {
+                        return 'Error: Could not extract text from PDF.';
+                    }
+                }
+                else {
+                    content = fs.readFileSync(filePath, 'utf-8');
+                }
+                const stats = fs.statSync(filePath);
+                showFileProgress(filePath, stats.size);
+                // Compress
+                const compressor = new compressor_js_1.SonaCompressor();
+                const result = await withSpinner('Running compression analysis...', async () => {
+                    return compressor.compress(content);
+                });
+                // Calculate costs for different scales
+                const scales = [1, 100, 1000, 10000];
+                const costAnalysis = scales.map(n => ({
+                    requests: n,
+                    withoutSona: (result.originalTokens * n / 1_000_000) * pricePerMillion,
+                    withSona: (result.compressedTokens * n / 1_000_000) * pricePerMillion,
+                    saved: (result.tokenSavings * n / 1_000_000) * pricePerMillion,
+                }));
+                // Build report
+                const report = `# SONA CODE Compression Analysis Report
+
+## Document: ${path.basename(filePath)}
+
+**Analysis Date:** ${new Date().toISOString().split('T')[0]}
+**Price Model:** $${pricePerMillion} per million tokens (GPT-4o)
+
+---
+
+## 📊 Compression Metrics
+
+| Metric | Value |
+|--------|-------|
+| Original Tokens | ${result.originalTokens.toLocaleString()} |
+| Compressed Tokens | ${result.compressedTokens.toLocaleString()} |
+| Tokens Saved | ${result.tokenSavings.toLocaleString()} |
+| **Compression Ratio** | **${result.tokenSavingsPercent.toFixed(2)}%** |
+
+---
+
+## 💰 Cost Analysis
+
+### Per-Request Cost
+| Scenario | Cost |
+|----------|------|
+| Without SONA | $${((result.originalTokens / 1_000_000) * pricePerMillion).toFixed(6)} |
+| With SONA | $${((result.compressedTokens / 1_000_000) * pricePerMillion).toFixed(6)} |
+| **Savings** | **$${((result.tokenSavings / 1_000_000) * pricePerMillion).toFixed(6)}** |
+
+### Scaled Cost Savings
+
+| Requests | Without SONA | With SONA | Savings |
+|----------|--------------|-----------|---------|
+${costAnalysis.map(c => `| ${c.requests.toLocaleString()} | $${c.withoutSona.toFixed(4)} | $${c.withSona.toFixed(4)} | $${c.saved.toFixed(4)} |`).join('\n')}
+
+---
+
+## 🎯 Key Findings
+
+1. **Token Reduction:** ${result.tokenSavingsPercent.toFixed(1)}% fewer tokens sent to the LLM
+2. **Quality Preserved:** Semantic compression maintains document meaning
+3. **ROI at Scale:** Processing 10,000 documents saves ~$${costAnalysis[3].saved.toFixed(2)}
+
+---
+
+## How It Works
+
+SONA CODE uses **Structural Memory Reconstruction (SMR)** compression:
+- Removes filler phrases ("it is important to note that" → "notably")
+- Applies semantic abbreviations ("implementation" → "impl")
+- Preserves technical accuracy and context
+
+> Note: Compression ratios vary by document type. Legal/technical documents typically see 15-25% reduction.
+`;
+                // Display summary with premium styling
+                console.log('');
+                console.log(colors.accent(`  ${ui.topLeft}${ui.horizontal.repeat(52)}${ui.topRight}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.title(`  ${ui.chart} Compression Analysis`) + '                           ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.leftT}${ui.horizontal.repeat(52)}${ui.rightT}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + '                                                    ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('   Original tokens') + colors.body(`     ${result.originalTokens.toLocaleString().padStart(12)}`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('   Compressed tokens') + colors.body(`   ${result.compressedTokens.toLocaleString().padStart(12)}`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.success(`   Reduction`) + colors.success(`             ${result.tokenSavingsPercent.toFixed(1).padStart(11)}%`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + '                                                    ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.leftT}${ui.horizontal.repeat(52)}${ui.rightT}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.title(`  ${ui.money} Cost @ 10,000 requests`) + '                        ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.leftT}${ui.horizontal.repeat(52)}${ui.rightT}`));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('   Without SONA') + colors.body(`        $${costAnalysis[3].withoutSona.toFixed(2).padStart(12)}`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.muted('   With SONA') + colors.body(`           $${costAnalysis[3].withSona.toFixed(2).padStart(12)}`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + colors.success(`   You save`) + colors.success(`            $${costAnalysis[3].saved.toFixed(2).padStart(12)}`) + '            ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.vertical}`) + '                                                    ' + colors.accent(ui.vertical));
+                console.log(colors.accent(`  ${ui.bottomLeft}${ui.horizontal.repeat(52)}${ui.bottomRight}`));
+                console.log('');
+                // Save report if requested
+                if (outputReport) {
+                    await withSpinner(`Writing report: ${path.basename(outputReport)}`, async () => {
+                        fs.writeFileSync(outputReport, report);
+                    });
+                    console.log(colors.dim(`    └─ Report saved to ${outputReport}`));
+                }
+                return outputReport
+                    ? `Analysis complete. Report saved to ${outputReport}\n\n${report}`
+                    : report;
+            }
+            default:
+                return `Unknown tool: ${name}`;
+        }
+    }
+    catch (error) {
+        console.log(`  ${colors.red('✗')} Error: ${error.message}`);
+        return `Error: ${error.message}`;
+    }
+}
+/**
+ * Main chat function - the default sona experience
+ */
+async function startChat(opts) {
+    // Load saved configuration
+    let config = loadConfig();
+    // Override with environment variables
+    const envDeepseekKey = process.env.DEEPSEEK_API_KEY;
+    const envOpenaiKey = process.env.OPENAI_API_KEY;
+    const envAnthropicKey = process.env.ANTHROPIC_API_KEY;
+    // Use saved config or env vars
+    let provider = (opts.provider || config.provider || 'deepseek');
+    let model = opts.model || config.model || 'deepseek-chat';
+    let apiKey = opts.deepseekKey || config.apiKey || envDeepseekKey || envOpenaiKey || envAnthropicKey || '';
+    // Set terminal title to "sona"
+    process.stdout.write('\x1b]0;sona\x07');
+    // First-time setup if no API key configured
+    if (!apiKey) {
+        console.log('\x1b[2J\x1b[H'); // Clear screen
+        console.log('');
+        console.log(colors.title('  SONA CODE'));
+        console.log(colors.dimGray('  ' + ui.horizontal.repeat(40)));
+        console.log('');
+        console.log(colors.body('  Welcome! Let\'s configure your API.'));
+        console.log('');
+        console.log(colors.small('  Select a provider:'));
+        console.log('');
+        console.log(colors.cyan('    1.') + colors.body(' DeepSeek') + colors.success('  $0.14/M') + colors.small('  (recommended)'));
+        console.log(colors.dimGray('    2.') + colors.body(' OpenAI') + colors.dimGray('    $15/M'));
+        console.log(colors.dimGray('    3.') + colors.body(' Anthropic') + colors.dimGray(' $15/M'));
+        console.log('');
+        const rl = (0, readline_1.createInterface)({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const question = (prompt) => {
+            return new Promise((resolve) => {
+                rl.question(prompt, (answer) => resolve(answer.trim()));
+            });
+        };
+        // Provider selection
+        const providerChoice = await question(colors.accent(`  ${ui.arrowRight} Select provider (1/2/3): `));
+        switch (providerChoice) {
+            case '1':
+                provider = 'deepseek';
+                model = 'deepseek-chat';
+                console.log('');
+                console.log(colors.muted('  Get your API key at: ') + colors.info('https://platform.deepseek.com'));
+                break;
+            case '2':
+                provider = 'openai';
+                model = 'gpt-4o-mini';
+                console.log('');
+                console.log(colors.muted('  Get your API key at: ') + colors.info('https://platform.openai.com'));
+                break;
+            case '3':
+                provider = 'anthropic';
+                model = 'claude-3-5-sonnet-20241022';
+                console.log('');
+                console.log(colors.muted('  Get your API key at: ') + colors.info('https://console.anthropic.com'));
+                break;
+            default:
+                provider = 'deepseek';
+                model = 'deepseek-chat';
+                console.log(colors.muted('  Using DeepSeek (default)'));
+                console.log('');
+                console.log(colors.muted('  Get your API key at: ') + colors.info('https://platform.deepseek.com'));
+        }
+        console.log('');
+        apiKey = await question(colors.accent(`  ${ui.arrowRight} API Key: `));
+        if (!apiKey) {
+            console.log('');
+            console.log(colors.error('  API key required.'));
+            console.log(colors.muted('  You can also set DEEPSEEK_API_KEY environment variable.'));
+            console.log('');
+            rl.close();
+            process.exit(1);
+        }
+        // Save configuration
+        config = { ...config, provider, model, apiKey };
+        saveConfig(config);
+        console.log('');
+        console.log(colors.success(`  ${ui.success} Saved to ~/.sona/config.json`));
+        console.log(colors.small('  Use /api to reconfigure'));
+        console.log('');
+        rl.close();
+    }
+    const compress = opts.compress !== false;
+    const session = (0, session_js_1.createSession)({
+        protectedTerms: opts.protect || [],
+    });
+    // Check for SONA.md project instructions
+    let projectInstructions = '';
+    const sonaMdPath = path.join(process.cwd(), 'SONA.md');
+    if (fs.existsSync(sonaMdPath)) {
+        try {
+            projectInstructions = fs.readFileSync(sonaMdPath, 'utf-8');
+        }
+        catch { /* ignore */ }
+    }
+    // Load previous conversation history for this workspace
+    const history = loadHistory();
+    const historyContext = buildHistoryContext(history);
+    // System prompt - senior engineer personality
+    const systemPrompt = opts.system || `You're a senior engineer pair-programming with the user. Full access to their codebase, terminal, and filesystem.
+
+Be natural. Talk like a smart colleague, not a chatbot. Skip formalities when a simple answer works.
+
+Capabilities:
+- Read/write/edit files (use line ranges for large files)
+- Run any shell command
+- Search code (glob, regex)
+- Git operations
+- Navigate and understand codebases quickly
+
+Working in: ${process.cwd()}
+
+Style:
+- Direct and concise
+- Don't list capabilities unless asked
+- Just do things - don't ask permission for read operations
+- Brief greetings - one line max
+- Be honest when things break
+- No unnecessary pleasantries
+- Think step by step on complex tasks
+- Be thorough - explore before concluding
+
+${projectInstructions ? `Project context (from SONA.md):\n${projectInstructions}\n` : ''}${historyContext}`;
+    const messages = [
+        { role: 'system', content: systemPrompt }
+    ];
+    // Show if we have previous context - richer memory indicator
+    if (history) {
+        const memoryParts = [];
+        if (history.stats.totalSessions > 1)
+            memoryParts.push(`session ${history.stats.totalSessions}`);
+        if (history.filesWritten.length > 0)
+            memoryParts.push(`${history.filesWritten.length} files modified`);
+        if (history.currentTask)
+            memoryParts.push(`task: ${history.currentTask.slice(0, 40)}...`);
+        if (memoryParts.length > 0) {
+            console.log(colors.gray600(` ↻ ${memoryParts.join(' · ')}`));
+        }
+    }
+    // SONA CODE Header - Retro pixel aesthetic
+    const cwd = process.cwd();
+    const shortCwd = cwd.split('/').slice(-2).join('/');
+    const termRows = process.stdout.rows || 24;
+    // Calculate header height (logo lines + status lines + gaps)
+    const logoLines = SONA_LOGO.split('\n').filter(l => l.length > 0);
+    const headerHeight = 1 + logoLines.length + 4 + 1; // top gap + logo + separator + version + path + help + bottom gap
+    // Function to draw header
+    const drawHeader = () => {
+        // Save cursor position
+        process.stdout.write('\x1b7');
+        // Move to top
+        process.stdout.write('\x1b[H');
+        // Clear header area
+        for (let i = 0; i < headerHeight; i++) {
+            process.stdout.write('\x1b[2K\n'); // Clear line and move down
+        }
+        // Move back to top
+        process.stdout.write('\x1b[H');
+        // Top gap
+        console.log('');
+        // ASCII Logo - bold broken white
+        logoLines.forEach(line => {
+            console.log(colors.bold(colors.brokenWhite(line)));
+        });
+        // Thin line separator - gray 200
+        console.log(colors.gray200(' ' + '─'.repeat(40)));
+        // Status - compact, gray 200
+        console.log(colors.gray200(` sona code v${VERSION} · ${provider}`));
+        console.log(colors.gray500(` ${shortCwd}`));
+        console.log(colors.gray700(` /help · /api · /quit`));
+        // Bottom gap  
+        console.log('');
+        // Restore cursor position
+        process.stdout.write('\x1b8');
+    };
+    // Initial clear and setup
+    process.stdout.write('\x1b[2J\x1b[H'); // Clear screen
+    // Draw initial header
+    // Top gap
+    console.log('');
+    // ASCII Logo - bold broken white
+    logoLines.forEach(line => {
+        console.log(colors.bold(colors.brokenWhite(line)));
+    });
+    // Thin line separator - gray 200
+    console.log(colors.gray200(' ' + '─'.repeat(40)));
+    // Status - compact, gray 200
+    console.log(colors.gray200(` sona code v${VERSION} · ${provider}`));
+    console.log(colors.gray500(` ${shortCwd}`));
+    console.log(colors.gray700(` /help · /api · /quit`));
+    // Bottom gap
+    console.log('');
+    // Set up scrolling region: from header bottom to terminal bottom
+    process.stdout.write(`\x1b[${headerHeight + 1};${termRows}r`);
+    // Move cursor to scrolling region
+    process.stdout.write(`\x1b[${headerHeight + 1};1H`);
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    // Clean up on exit
+    const cleanup = () => {
+        process.stdout.write('\x1b[r'); // Reset scrolling region
+        process.stdout.write('\x1b[?25h'); // Show cursor
+        process.stdout.write('\x1b[2J\x1b[H'); // Clear screen
+    };
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => { cleanup(); process.exit(0); });
+    // Redraw header periodically to keep it sticky (handles terminal resize too)
+    const headerInterval = setInterval(() => {
+        drawHeader();
+    }, 5000); // Every 5 seconds
+    // Also redraw on terminal resize
+    process.stdout.on('resize', () => {
+        const newRows = process.stdout.rows || 24;
+        process.stdout.write(`\x1b[${headerHeight + 1};${newRows}r`);
+        drawHeader();
+    });
+    const chat = async () => {
+        rl.question(colors.brokenWhite('> '), async (input) => {
+            const trimmed = input.trim();
+            if (!trimmed) {
+                chat();
+                return;
+            }
+            // Handle commands
+            if (trimmed.startsWith('/')) {
+                const [cmd, ...args] = trimmed.slice(1).split(' ');
+                switch (cmd) {
+                    case 'help':
+                    case 'h':
+                        console.log(colors.gray200(' ─────────────────────'));
+                        console.log(colors.gray500(' /api') + colors.gray700('     provider'));
+                        console.log(colors.gray500(' /model') + colors.gray700('   model'));
+                        console.log(colors.gray500(' /clear') + colors.gray700('   reset session'));
+                        console.log(colors.gray500(' /forget') + colors.gray700('  clear history'));
+                        console.log(colors.gray500(' /config') + colors.gray700('  config'));
+                        console.log(colors.gray500(' /quit') + colors.gray700('    exit'));
+                        console.log(colors.gray200(' ─────────────────────'));
+                        console.log(colors.gray400(' deepseek-chat') + colors.green(' $0.14'));
+                        console.log(colors.gray600(' gpt-4o-mini   $15'));
+                        console.log(colors.gray600(' claude-sonnet $15'));
+                        break;
+                    case 'api':
+                        // Interactive API configuration
+                        console.log(colors.gray200(' ─────────────────────'));
+                        console.log(colors.gray400(' 1. DeepSeek') + colors.green('  $0.14'));
+                        console.log(colors.gray600(' 2. OpenAI    $15'));
+                        console.log(colors.gray600(' 3. Anthropic $15'));
+                        const apiRl = (0, readline_1.createInterface)({
+                            input: process.stdin,
+                            output: process.stdout,
+                        });
+                        const apiQuestion = (prompt) => {
+                            return new Promise((resolve) => {
+                                apiRl.question(prompt, (answer) => resolve(answer.trim()));
+                            });
+                        };
+                        const providerChoice = await apiQuestion(colors.accent(`  ${ui.arrowRight} Provider (1/2/3): `));
+                        let newProvider = 'deepseek';
+                        let newModel = 'deepseek-chat';
+                        switch (providerChoice) {
+                            case '2':
+                                newProvider = 'openai';
+                                newModel = 'gpt-4o-mini';
+                                console.log(colors.muted('  Get key at: ') + colors.info('https://platform.openai.com'));
+                                break;
+                            case '3':
+                                newProvider = 'anthropic';
+                                newModel = 'claude-3-5-sonnet-20241022';
+                                console.log(colors.muted('  Get key at: ') + colors.info('https://console.anthropic.com'));
+                                break;
+                            default:
+                                newProvider = 'deepseek';
+                                newModel = 'deepseek-chat';
+                                console.log(colors.muted('  Get key at: ') + colors.info('https://platform.deepseek.com'));
+                        }
+                        console.log('');
+                        const newKey = await apiQuestion(colors.accent(`  ${ui.arrowRight} API Key: `));
+                        apiRl.close();
+                        if (newKey) {
+                            provider = newProvider;
+                            model = newModel;
+                            apiKey = newKey;
+                            // Save to config
+                            config = { ...config, provider, model, apiKey };
+                            saveConfig(config);
+                            console.log('');
+                            console.log(colors.success(`  ${ui.check} Configuration saved!`));
+                            console.log(colors.muted(`  Provider: ${provider}, Model: ${model}`));
+                        }
+                        else {
+                            console.log(colors.muted('  Cancelled.'));
+                        }
+                        console.log('');
+                        break;
+                    case 'config':
+                        console.log('');
+                        console.log(colors.title('  Config'));
+                        console.log(colors.dimGray('  ' + ui.horizontal.repeat(20)));
+                        console.log('');
+                        console.log(colors.small('  provider  ') + colors.body(`${provider}`));
+                        console.log(colors.small('  model     ') + colors.body(`${model}`));
+                        console.log(colors.small('  api key   ') + colors.dimGray(`${apiKey.slice(0, 8)}...`));
+                        console.log(colors.small('  file      ') + colors.dimGray(`~/.sona/config.json`));
+                        console.log('');
+                        break;
+                    case 'stats':
+                    case 's':
+                        const s = session.getStats();
+                        console.log('');
+                        console.log(colors.title('  Stats'));
+                        console.log(colors.dimGray('  ' + ui.horizontal.repeat(20)));
+                        console.log('');
+                        console.log(colors.small('  messages  ') + colors.body(`${s.conversationTurns}`));
+                        console.log(colors.small('  saved     ') + colors.success(`${s.totalInputTokensSaved}`) + colors.small(` tokens`));
+                        console.log(colors.small('  cost      ') + colors.success(`$${s.estimatedInputCostSaved.toFixed(4)}`));
+                        console.log('');
+                        break;
+                    case 'clear':
+                        messages.length = 1; // Keep system prompt
+                        // Clear only the scrolling region (below header)
+                        process.stdout.write(`\x1b[${headerHeight + 1};1H`); // Move to scroll region start
+                        process.stdout.write('\x1b[J'); // Clear from cursor to end
+                        console.log(colors.gray700(' cleared'));
+                        break;
+                    case 'forget':
+                        // Clear saved history for this workspace
+                        messages.length = 1; // Keep system prompt
+                        try {
+                            const historyPath = getHistoryPath();
+                            if (fs.existsSync(historyPath)) {
+                                fs.unlinkSync(historyPath);
+                            }
+                            console.log(colors.gray700(' history cleared'));
+                        }
+                        catch {
+                            console.log(colors.gray700(' no history to clear'));
+                        }
+                        break;
+                    case 'model':
+                        if (args[0]) {
+                            model = args[0];
+                            // Auto-detect provider from model name
+                            if (model.startsWith('deepseek')) {
+                                provider = 'deepseek';
+                            }
+                            else if (model.startsWith('gpt') || model.startsWith('o1')) {
+                                provider = 'openai';
+                            }
+                            else if (model.startsWith('claude')) {
+                                provider = 'anthropic';
+                            }
+                            config = { ...config, model, provider };
+                            saveConfig(config);
+                            console.log(colors.success(`  ${ui.check} Model: ${model} (${provider})`));
+                        }
+                        else {
+                            console.log(colors.muted(`  Current: ${model}`));
+                            console.log(colors.muted('  Usage: /model <model-name>'));
+                        }
+                        console.log('');
+                        break;
+                    case 'pwd':
+                        console.log(colors.body(`  ${process.cwd()}`));
+                        console.log('');
+                        break;
+                    case 'quit':
+                    case 'exit':
+                    case 'q':
+                        clearInterval(headerInterval);
+                        cleanup();
+                        // Flush any pending history save before exit
+                        if (pendingSave) {
+                            clearTimeout(pendingSave);
+                            saveHistory(messages, history);
+                        }
+                        console.log(colors.gray500(' bye'));
+                        rl.close();
+                        process.exit(0);
+                    default:
+                        console.log(colors.muted(`  Unknown command: /${cmd}`));
+                        console.log(colors.muted('  Type /help for available commands.'));
+                        console.log('');
+                }
+                chat();
+                return;
+            }
+            // Compress the user message
+            let userContent = trimmed;
+            let tokensSaved = 0;
+            if (compress) {
+                const result = session.compressTurn(trimmed);
+                userContent = result.compressedText;
+                tokensSaved = result.tokenSavings;
+            }
+            messages.push({ role: 'user', content: userContent });
+            // Show compression indicator inline
+            if (compress && tokensSaved > 0) {
+                console.log(colors.gray(`  [-${tokensSaved} tokens]`));
+            }
+            console.log('');
+            try {
+                // Shimmering * thinking indicator - gray 700
+                let thinkingInterval = null;
+                let shimmerFrame = 0;
+                const shimmerFrames = ['*', '✦', '✧', '·', '✧', '✦']; // Shimmer animation
+                const startThinking = () => {
+                    process.stdout.write(colors.gray700(`  ${shimmerFrames[0]} thinking..`));
+                    thinkingInterval = setInterval(() => {
+                        shimmerFrame = (shimmerFrame + 1) % shimmerFrames.length;
+                        const dots = '.'.repeat((shimmerFrame % 3) + 1).padEnd(3);
+                        process.stdout.write(`\r` + colors.gray700(`  ${shimmerFrames[shimmerFrame]} thinking${dots}`));
+                    }, 200);
+                };
+                const stopThinking = () => {
+                    if (thinkingInterval) {
+                        clearInterval(thinkingInterval);
+                        process.stdout.write('\r' + ' '.repeat(20) + '\r');
+                    }
+                };
+                startThinking();
+                // Call LLM with tools
+                let response = await callLLMWithTools(provider, model, messages, apiKey, TOOLS);
+                stopThinking();
+                // Handle tool calls
+                while (response.tool_calls && response.tool_calls.length > 0) {
+                    // Show what the assistant is doing
+                    if (response.content) {
+                        console.log(colors.blue('  ') + response.content.split('\n').join('\n  '));
+                        console.log('');
+                    }
+                    messages.push({
+                        role: 'assistant',
+                        content: response.content || '',
+                        tool_calls: response.tool_calls
+                    });
+                    // Execute each tool call
+                    for (const toolCall of response.tool_calls) {
+                        const toolName = toolCall.function.name;
+                        const toolArgs = JSON.parse(toolCall.function.arguments);
+                        const toolResult = await executeTool(toolName, toolArgs);
+                        messages.push({
+                            role: 'tool',
+                            tool_call_id: toolCall.id,
+                            content: toolResult,
+                        });
+                    }
+                    console.log('');
+                    startThinking();
+                    // Get next response
+                    response = await callLLMWithTools(provider, model, messages, apiKey, TOOLS);
+                    stopThinking();
+                }
+                // Print final response with premium formatting
+                if (response.content) {
+                    console.log(formatResponse(response.content));
+                }
+                console.log('');
+                messages.push({ role: 'assistant', content: response.content || '' });
+                // Save conversation history after each exchange (debounced)
+                saveHistory(messages, history);
+            }
+            catch (error) {
+                console.log(colors.red(`  Error: ${error.message}`));
+                console.log('');
+                messages.pop();
+            }
+            chat();
+        });
+    };
+    chat();
+}
+/**
+ * Chat command - alias for default behavior
+ */
+program
+    .command('chat')
+    .alias('c')
+    .description('Chat with LLM using automatic token compression')
+    .option('--openai-key <key>', 'OpenAI API key')
+    .option('--anthropic-key <key>', 'Anthropic API key')
+    .option('-m, --model <model>', 'Model to use')
+    .option('--provider <provider>', 'Provider: openai or anthropic')
+    .option('-s, --system <prompt>', 'System prompt')
+    .option('-p, --protect <terms...>', 'Terms to protect from compression')
+    .option('--no-compress', 'Disable compression')
+    .action(startChat);
+/**
+ * Call LLM API with tool support
+ */
+async function callLLMWithTools(provider, model, messages, apiKey, tools) {
+    const https = await import('https');
+    return new Promise((resolve, reject) => {
+        if (provider === 'deepseek' || provider === 'openai') {
+            // DeepSeek uses OpenAI-compatible API
+            const hostname = provider === 'deepseek' ? 'api.deepseek.com' : 'api.openai.com';
+            // Format messages for OpenAI/DeepSeek
+            const formattedMessages = messages.map(m => {
+                if (m.role === 'tool') {
+                    return { role: 'tool', tool_call_id: m.tool_call_id, content: m.content };
+                }
+                if (m.tool_calls) {
+                    return { role: 'assistant', content: m.content, tool_calls: m.tool_calls };
+                }
+                return { role: m.role, content: m.content };
+            });
+            const data = JSON.stringify({
+                model,
+                messages: formattedMessages,
+                tools,
+                tool_choice: 'auto',
+            });
+            const req = https.request({
+                hostname,
+                path: '/v1/chat/completions',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                },
+            }, (res) => {
+                let body = '';
+                res.on('data', chunk => body += chunk);
+                res.on('end', () => {
+                    try {
+                        const json = JSON.parse(body);
+                        if (json.error) {
+                            reject(new Error(json.error.message || JSON.stringify(json.error)));
+                        }
+                        else {
+                            const choice = json.choices[0];
+                            resolve({
+                                content: choice.message.content,
+                                tool_calls: choice.message.tool_calls,
+                            });
+                        }
+                    }
+                    catch (e) {
+                        reject(new Error('Failed to parse response: ' + body.slice(0, 200)));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(data);
+            req.end();
+        }
+        else {
+            // Anthropic with tools
+            const systemMsg = messages.find(m => m.role === 'system');
+            const chatMessages = messages
+                .filter(m => m.role !== 'system')
+                .map(m => {
+                if (m.role === 'tool') {
+                    return {
+                        role: 'user',
+                        content: [{
+                                type: 'tool_result',
+                                tool_use_id: m.tool_call_id,
+                                content: m.content,
+                            }],
+                    };
+                }
+                if (m.tool_calls && m.tool_calls.length > 0) {
+                    return {
+                        role: 'assistant',
+                        content: m.tool_calls.map(tc => ({
+                            type: 'tool_use',
+                            id: tc.id,
+                            name: tc.function.name,
+                            input: JSON.parse(tc.function.arguments),
+                        })),
+                    };
+                }
+                return { role: m.role, content: m.content };
+            });
+            // Convert tools to Anthropic format
+            const anthropicTools = tools.map((t) => ({
+                name: t.function.name,
+                description: t.function.description,
+                input_schema: t.function.parameters,
+            }));
+            const data = JSON.stringify({
+                model,
+                max_tokens: 4096,
+                system: systemMsg?.content,
+                messages: chatMessages,
+                tools: anthropicTools,
+            });
+            const req = https.request({
+                hostname: 'api.anthropic.com',
+                path: '/v1/messages',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+            }, (res) => {
+                let body = '';
+                res.on('data', chunk => body += chunk);
+                res.on('end', () => {
+                    try {
+                        const json = JSON.parse(body);
+                        if (json.error) {
+                            reject(new Error(json.error.message));
+                        }
+                        else {
+                            // Extract text and tool uses
+                            let content = '';
+                            const toolCalls = [];
+                            for (const block of json.content) {
+                                if (block.type === 'text') {
+                                    content += block.text;
+                                }
+                                else if (block.type === 'tool_use') {
+                                    toolCalls.push({
+                                        id: block.id,
+                                        function: {
+                                            name: block.name,
+                                            arguments: JSON.stringify(block.input),
+                                        },
+                                    });
+                                }
+                            }
+                            resolve({
+                                content: content || null,
+                                tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                            });
+                        }
+                    }
+                    catch (e) {
+                        reject(new Error('Failed to parse response: ' + body.slice(0, 200)));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(data);
+            req.end();
+        }
+    });
+}
+/**
+ * Session command - Start an interactive document processing session
+ */
+program
+    .command('session')
+    .description('Start an interactive document processing session')
+    .option('-p, --protect <terms...>', 'Terms to protect from compression')
+    .action(async (opts) => {
+    const session = (0, session_js_1.createSession)({
+        protectedTerms: opts.protect || [],
+    });
+    console.log('');
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log(colors.bold('  SONA CODE Document Session'));
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log('');
+    console.log('  Paste text to compress. Commands:');
+    console.log(colors.gray('    /doc <name>  Start a document'));
+    console.log(colors.gray('    /end         End document'));
+    console.log(colors.gray('    /stats       Show stats'));
+    console.log(colors.gray('    /quit        Exit'));
+    console.log('');
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let inDocument = false;
+    const prompt = () => {
+        rl.question(colors.cyan('> '), (line) => {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('/')) {
+                const [cmd, ...args] = trimmed.slice(1).split(' ');
+                switch (cmd) {
+                    case 'doc':
+                        const docName = args.join(' ') || `doc_${Date.now()}`;
+                        session.startDocument(docName, docName);
+                        inDocument = true;
+                        console.log(colors.green(`  Started: ${docName}`));
+                        break;
+                    case 'end':
+                        if (inDocument) {
+                            const stats = session.endDocument();
+                            if (stats)
+                                console.log(colors.green(`  Done: ${stats.tokensSaved} tokens saved`));
+                            inDocument = false;
+                        }
+                        break;
+                    case 'stats':
+                        const s = session.getStats();
+                        console.log(`  Saved: ${colors.green(s.totalInputTokensSaved + '')} tokens (${s.inputSavingsPercent.toFixed(1)}%)`);
+                        break;
+                    case 'quit':
+                    case 'exit':
+                        rl.close();
+                        return;
+                }
+            }
+            else if (trimmed) {
+                const result = inDocument ? session.compressChunk(trimmed) : session.compressTurn(trimmed);
+                console.log(colors.dim(result.compressedText));
+                console.log(colors.gray(`  [-${result.tokenSavings} tokens]`));
+            }
+            prompt();
+        });
+    };
+    prompt();
+});
+// ============================================================
+// COMPRESSION COMMANDS
+// ============================================================
+/**
+ * Compress command - compress a file or stdin
+ */
+program
+    .command('compress')
+    .description('Compress text to reduce tokens')
+    .argument('[input]', 'Input file (use - for stdin)')
+    .option('-o, --output <file>', 'Output file (default: stdout)')
+    .option('-q, --quiet', 'Only output compressed text')
+    .option('--json', 'Output as JSON with metrics')
+    .option('-p, --protect <terms...>', 'Terms to protect from compression')
+    .action(async (input, opts) => {
+    try {
+        let text;
+        if (!input || input === '-') {
+            text = await readStdin();
+        }
+        else {
+            if (!(0, fs_1.existsSync)(input)) {
+                console.error(colors.red(`Error: File not found: ${input}`));
+                process.exit(1);
+            }
+            text = (0, fs_1.readFileSync)(input, 'utf-8');
+        }
+        const compressor = new compressor_js_1.SonaCompressor({
+            protectedTerms: opts.protect || [],
+        });
+        const result = compressor.compress(text);
+        if (opts.json) {
+            const output = JSON.stringify({
+                compressed: result.compressedText,
+                metrics: {
+                    originalTokens: result.originalTokens,
+                    compressedTokens: result.compressedTokens,
+                    tokenSavings: result.tokenSavings,
+                    tokenSavingsPercent: Math.round(result.tokenSavingsPercent * 10) / 10,
+                    rulesApplied: result.rulesApplied.length,
+                },
+            }, null, 2);
+            if (opts.output) {
+                (0, fs_1.writeFileSync)(opts.output, output);
+            }
+            else {
+                console.log(output);
+            }
+        }
+        else if (opts.quiet) {
+            if (opts.output) {
+                (0, fs_1.writeFileSync)(opts.output, result.compressedText);
+            }
+            else {
+                process.stdout.write(result.compressedText);
+            }
+        }
+        else {
+            if (opts.output) {
+                (0, fs_1.writeFileSync)(opts.output, result.compressedText);
+            }
+            else {
+                console.log(result.compressedText);
+            }
+            console.error('');
+            console.error(colors.cyan('─'.repeat(40)));
+            console.error(colors.bold('📊 Compression Results'));
+            console.error(colors.cyan('─'.repeat(40)));
+            console.error(`  Original tokens:   ${colors.yellow(result.originalTokens.toString())}`);
+            console.error(`  Compressed tokens: ${colors.green(result.compressedTokens.toString())}`);
+            console.error(`  Tokens saved:      ${colors.bold(colors.green(`${result.tokenSavings} (${result.tokenSavingsPercent.toFixed(1)}%)`))}`);
+            console.error(`  Rules applied:     ${result.rulesApplied.length}`);
+            console.error(colors.cyan('─'.repeat(40)));
+        }
+    }
+    catch (error) {
+        console.error(colors.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+/**
+ * Analyze command
+ */
+program
+    .command('analyze')
+    .description('Analyze text and show compression potential')
+    .argument('<input>', 'Input file')
+    .option('--json', 'Output as JSON')
+    .action(async (input, opts) => {
+    try {
+        if (!(0, fs_1.existsSync)(input)) {
+            console.error(colors.red(`Error: File not found: ${input}`));
+            process.exit(1);
+        }
+        const text = (0, fs_1.readFileSync)(input, 'utf-8');
+        const result = (0, compressor_js_1.compress)(text);
+        if (opts.json) {
+            console.log(JSON.stringify({
+                file: input,
+                analysis: {
+                    originalChars: result.originalChars,
+                    compressedChars: result.compressedChars,
+                    charSavings: result.charSavings,
+                    charSavingsPercent: Math.round(result.charSavingsPercent * 10) / 10,
+                    originalTokens: result.originalTokens,
+                    compressedTokens: result.compressedTokens,
+                    tokenSavings: result.tokenSavings,
+                    tokenSavingsPercent: Math.round(result.tokenSavingsPercent * 10) / 10,
+                    rulesApplied: result.rulesApplied,
+                    estimatedCostSavings: result.estimatedCostSavings,
+                },
+            }, null, 2));
+        }
+        else {
+            console.log('');
+            console.log(colors.cyan('═'.repeat(50)));
+            console.log(colors.bold(`📋 Analysis: ${input}`));
+            console.log(colors.cyan('═'.repeat(50)));
+            console.log('');
+            console.log(colors.bold('Characters:'));
+            console.log(`  Original:   ${result.originalChars.toLocaleString()}`);
+            console.log(`  Compressed: ${result.compressedChars.toLocaleString()}`);
+            console.log(`  Savings:    ${colors.green(`${result.charSavings.toLocaleString()} (${result.charSavingsPercent.toFixed(1)}%)`)}`);
+            console.log('');
+            console.log(colors.bold('Tokens:'));
+            console.log(`  Original:   ${result.originalTokens.toLocaleString()}`);
+            console.log(`  Compressed: ${result.compressedTokens.toLocaleString()}`);
+            console.log(`  Savings:    ${colors.green(`${result.tokenSavings.toLocaleString()} (${result.tokenSavingsPercent.toFixed(1)}%)`)}`);
+            console.log('');
+            console.log(colors.bold('Cost Impact (at $15/1M tokens):'));
+            console.log(`  Savings per request: ${colors.green(`$${result.estimatedCostSavings.toFixed(6)}`)}`);
+            console.log('');
+            console.log(colors.bold('Rules Applied:'));
+            if (result.rulesApplied.length === 0) {
+                console.log(colors.gray('  (none - text already optimal)'));
+            }
+            else {
+                result.rulesApplied.slice(0, 10).forEach(rule => {
+                    console.log(`  • ${rule}`);
+                });
+                if (result.rulesApplied.length > 10) {
+                    console.log(colors.gray(`  ... and ${result.rulesApplied.length - 10} more`));
+                }
+            }
+            console.log('');
+            console.log(colors.cyan('═'.repeat(50)));
+        }
+    }
+    catch (error) {
+        console.error(colors.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+/**
+ * Pipe command
+ */
+program
+    .command('pipe')
+    .description('Process stdin continuously (for piping)')
+    .option('-p, --protect <terms...>', 'Terms to protect from compression')
+    .action(async (opts) => {
+    const compressor = new compressor_js_1.SonaCompressor({
+        protectedTerms: opts.protect || [],
+    });
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+    });
+    rl.on('line', (line) => {
+        const result = compressor.compress(line);
+        console.log(result.compressedText);
+    });
+});
+// ============================================================
+// MCP SERVER
+// ============================================================
+/**
+ * MCP command
+ */
+program
+    .command('mcp')
+    .description('Start MCP server for Claude Code / Codex integration')
+    .option('--stdio', 'Use stdio transport (default)')
+    .action(async () => {
+    await startMcpServer();
+});
+// ============================================================
+// INFO & INTERACTIVE
+// ============================================================
+/**
+ * Info command
+ */
+program
+    .command('info')
+    .description('Show SONA CODE information and configuration')
+    .action(() => {
+    console.log('');
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log(colors.bold('  SONA CODE - SMR Token Compression'));
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log('');
+    console.log(`  Version:        ${colors.green(VERSION)}`);
+    console.log(`  Rules loaded:   ${colors.green((0, rules_js_1.getRuleCount)().toString())}`);
+    console.log('');
+    console.log(colors.bold('  Integration Options:'));
+    console.log('');
+    console.log(`  ${colors.cyan('1.')} ${colors.bold('Transparent Proxy')} ${colors.gray('(recommended)')}`);
+    console.log('     Start proxy and route all LLM traffic through it:');
+    console.log(colors.dim('     $ sona start'));
+    console.log(colors.dim('     $ eval $(sona env)'));
+    console.log('');
+    console.log(`  ${colors.cyan('2.')} ${colors.bold('Wrap Command')}`);
+    console.log('     Run any command with compression enabled:');
+    console.log(colors.dim('     $ sona wrap codex "explain this code"'));
+    console.log(colors.dim('     $ sona wrap claude "summarize file.txt"'));
+    console.log('');
+    console.log(`  ${colors.cyan('3.')} ${colors.bold('SDK Middleware')}`);
+    console.log('     Wrap OpenAI/Anthropic SDKs in your code:');
+    console.log(colors.dim("     import { createMiddleware } from 'sona-code';"));
+    console.log(colors.dim('     const openai = createMiddleware().wrapOpenAI(new OpenAI());'));
+    console.log('');
+    console.log(`  ${colors.cyan('4.')} ${colors.bold('MCP Server')}`);
+    console.log('     For Claude Code / Codex native integration:');
+    console.log(colors.dim('     $ sona mcp'));
+    console.log('');
+    console.log(`  ${colors.cyan('5.')} ${colors.bold('CLI Piping')}`);
+    console.log('     Compress text before sending to any tool:');
+    console.log(colors.dim('     $ cat prompt.txt | sona compress -q | your-tool'));
+    console.log('');
+    console.log(colors.cyan('═'.repeat(60)));
+    console.log('');
+});
+/**
+ * Interactive mode
+ */
+program
+    .command('interactive')
+    .alias('i')
+    .description('Start interactive compression mode')
+    .action(async () => {
+    const compressor = new compressor_js_1.SonaCompressor();
+    console.log('');
+    console.log(colors.cyan('═'.repeat(50)));
+    console.log(colors.bold('SONA CODE Interactive Mode'));
+    console.log(colors.cyan('═'.repeat(50)));
+    console.log('');
+    console.log('Enter text to compress. Press Ctrl+D to exit.');
+    console.log('Use /stats to see session statistics.');
+    console.log('');
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let totalSaved = 0;
+    let totalProcessed = 0;
+    const prompt = () => {
+        rl.question(colors.cyan('> '), (input) => {
+            if (input === '/stats') {
+                console.log('');
+                console.log(colors.bold('Session Statistics:'));
+                console.log(`  Requests: ${totalProcessed}`);
+                console.log(`  Tokens saved: ${colors.green(totalSaved.toString())}`);
+                console.log('');
+                prompt();
+                return;
+            }
+            if (input === '/exit' || input === '/quit') {
+                console.log(colors.gray('Goodbye!'));
+                rl.close();
+                return;
+            }
+            const result = compressor.compress(input);
+            totalProcessed++;
+            totalSaved += result.tokenSavings;
+            console.log('');
+            console.log(colors.bold('Compressed:'));
+            console.log(result.compressedText);
+            console.log('');
+            console.log(colors.gray(`[${result.tokenSavings} tokens saved (${result.tokenSavingsPercent.toFixed(1)}%)]`));
+            console.log('');
+            prompt();
+        });
+    };
+    prompt();
+});
+// ============================================================
+// HELPERS
+// ============================================================
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('readable', () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) !== null) {
+                data += chunk;
+            }
+        });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+/**
+ * Split text into chunks, trying to break at paragraph/sentence boundaries
+ */
+function splitIntoChunks(text, maxChunkSize) {
+    const chunks = [];
+    const paragraphs = text.split(/\n\n+/);
+    let currentChunk = '';
+    for (const para of paragraphs) {
+        if (currentChunk.length + para.length + 2 <= maxChunkSize) {
+            currentChunk += (currentChunk ? '\n\n' : '') + para;
+        }
+        else {
+            // Current chunk is full, save it
+            if (currentChunk) {
+                chunks.push(currentChunk);
+            }
+            // If paragraph itself is too long, split by sentences
+            if (para.length > maxChunkSize) {
+                const sentences = para.split(/(?<=[.!?])\s+/);
+                currentChunk = '';
+                for (const sentence of sentences) {
+                    if (currentChunk.length + sentence.length + 1 <= maxChunkSize) {
+                        currentChunk += (currentChunk ? ' ' : '') + sentence;
+                    }
+                    else {
+                        if (currentChunk) {
+                            chunks.push(currentChunk);
+                        }
+                        // If even a single sentence is too long, just truncate
+                        if (sentence.length > maxChunkSize) {
+                            chunks.push(sentence.slice(0, maxChunkSize));
+                        }
+                        else {
+                            currentChunk = sentence;
+                        }
+                    }
+                }
+            }
+            else {
+                currentChunk = para;
+            }
+        }
+    }
+    // Don't forget the last chunk
+    if (currentChunk) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+async function startMcpServer() {
+    const compressor = new compressor_js_1.SonaCompressor();
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+    });
+    const handleMessage = (line) => {
+        try {
+            const message = JSON.parse(line);
+            if (message.method === 'initialize') {
+                respond(message.id, {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'sona', version: VERSION },
+                });
+            }
+            else if (message.method === 'tools/list') {
+                respond(message.id, {
+                    tools: [
+                        {
+                            name: 'compress',
+                            description: 'Compress text to reduce LLM tokens by removing verbose phrases while preserving meaning. Reduces costs by ~20%.',
+                            inputSchema: {
+                                type: 'object',
+                                properties: {
+                                    text: { type: 'string', description: 'The text to compress' },
+                                    protectedTerms: { type: 'array', items: { type: 'string' }, description: 'Terms that should not be modified' },
+                                },
+                                required: ['text'],
+                            },
+                        },
+                        {
+                            name: 'analyze',
+                            description: 'Analyze text and show compression potential without modifying it',
+                            inputSchema: {
+                                type: 'object',
+                                properties: { text: { type: 'string', description: 'The text to analyze' } },
+                                required: ['text'],
+                            },
+                        },
+                    ],
+                });
+            }
+            else if (message.method === 'tools/call') {
+                const { name, arguments: args } = message.params;
+                if (name === 'compress') {
+                    const comp = new compressor_js_1.SonaCompressor({ protectedTerms: args.protectedTerms || [] });
+                    const result = comp.compress(args.text);
+                    respond(message.id, {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    compressed: result.compressedText,
+                                    originalTokens: result.originalTokens,
+                                    compressedTokens: result.compressedTokens,
+                                    tokensSaved: result.tokenSavings,
+                                    savingsPercent: `${result.tokenSavingsPercent.toFixed(1)}%`,
+                                }, null, 2),
+                            }],
+                    });
+                }
+                else if (name === 'analyze') {
+                    const result = (0, compressor_js_1.compress)(args.text);
+                    respond(message.id, {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    originalTokens: result.originalTokens,
+                                    compressedTokens: result.compressedTokens,
+                                    potentialSavings: result.tokenSavings,
+                                    savingsPercent: `${result.tokenSavingsPercent.toFixed(1)}%`,
+                                    rulesMatched: result.rulesApplied.length,
+                                }, null, 2),
+                            }],
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    };
+    const respond = (id, result) => {
+        console.log(JSON.stringify({ jsonrpc: '2.0', id, result }));
+    };
+    rl.on('line', handleMessage);
+    await new Promise(() => { });
+}
+program.parse();
+//# sourceMappingURL=cli.js.map