grokcodecli 0.1.0

package/dist/conversation/chat.js

@@ -0,0 +1,1145 @@
+import * as readline from 'readline';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+import { GrokClient } from '../grok/client.js';
+import { allTools, executeTool } from '../tools/registry.js';
+import { PermissionManager } from '../permissions/manager.js';
+import { HistoryManager } from './history.js';
+import { ConfigManager } from '../config/manager.js';
+import { drawBox, randomTip } from '../utils/ui.js';
+const SYSTEM_PROMPT = `You are Grok Code, a powerful CLI coding assistant powered by xAI's Grok.
+You help users with software engineering tasks including writing code, debugging, explaining code, and managing files.
+
+## Available Tools
+- **Read**: Read file contents with line numbers
+- **Write**: Write content to files (creates directories if needed)
+- **Edit**: Edit files by replacing exact strings
+- **Bash**: Execute shell commands (git, npm, etc.)
+- **Glob**: Find files by pattern (e.g., "**/*.ts")
+- **Grep**: Search file contents with regex
+- **WebFetch**: Fetch content from URLs
+
+## Guidelines
+1. **Always read before editing**: Never modify a file you haven't read first
+2. **Be precise with edits**: The Edit tool requires exact string matches
+3. **Explain your actions**: Tell the user what you're doing and why
+4. **Security first**: Never introduce vulnerabilities (XSS, SQL injection, command injection)
+5. **Stay focused**: Only make changes that are directly requested
+6. **Use appropriate tools**: Prefer Read/Write/Edit over Bash for file operations
+
+## Git Operations
+- Use Bash for git commands
+- Never force push to main/master without explicit permission
+- Write clear, descriptive commit messages
+
+## Current Context
+- Working directory: ${process.cwd()}
+- Platform: ${process.platform}
+- Date: ${new Date().toLocaleDateString()}`;
+const VERSION = '0.1.0';
+export class GrokChat {
+    client;
+    messages = [];
+    rl;
+    permissions;
+    history;
+    config;
+    session = null;
+    useStreaming = true;
+    workingDirs = [process.cwd()];
+    tokenUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    sessionStartTime = new Date();
+    apiKey;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.client = new GrokClient(options.apiKey, options.model || 'grok-4-0709');
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        this.permissions = new PermissionManager();
+        this.permissions.setReadlineInterface(this.rl);
+        this.history = new HistoryManager();
+        this.config = new ConfigManager();
+    }
+    async start() {
+        // Beautiful welcome screen
+        console.log(chalk.cyan(`
+   ██████╗ ██████╗  ██████╗ ██╗  ██╗     ██████╗ ██████╗ ██████╗ ███████╗
+  ██╔════╝ ██╔══██╗██╔═══██╗██║ ██╔╝    ██╔════╝██╔═══██╗██╔══██╗██╔════╝
+  ██║  ███╗██████╔╝██║   ██║█████╔╝     ██║     ██║   ██║██║  ██║█████╗
+  ██║   ██║██╔══██╗██║   ██║██╔═██╗     ██║     ██║   ██║██║  ██║██╔══╝
+  ╚██████╔╝██║  ██║╚██████╔╝██║  ██╗    ╚██████╗╚██████╔╝██████╔╝███████╗
+   ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝`));
+        console.log();
+        console.log(drawBox([
+            `${chalk.bold('Grok Code CLI')} ${chalk.gray(`v${VERSION}`)}`,
+            '',
+            `${chalk.gray('Model:')}    ${chalk.green(this.client.model)}`,
+            `${chalk.gray('CWD:')}      ${chalk.blue(process.cwd())}`,
+            `${chalk.gray('Tools:')}    ${chalk.cyan('8 available')} ${chalk.gray('(Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch)')}`,
+            '',
+            `${chalk.gray('Commands:')} ${chalk.cyan('/help')} ${chalk.gray('•')} ${chalk.cyan('/model')} ${chalk.gray('•')} ${chalk.cyan('/doctor')} ${chalk.gray('•')} ${chalk.yellow('exit')}`,
+        ], { borderColor: chalk.cyan, padding: 0 }));
+        console.log();
+        console.log(randomTip());
+        console.log();
+        // Create new session
+        this.session = await this.history.createSession(process.cwd());
+        this.sessionStartTime = new Date();
+        // Initialize with system prompt
+        this.messages.push({
+            role: 'system',
+            content: SYSTEM_PROMPT,
+        });
+        await this.loop();
+    }
+    async resume(sessionId) {
+        let session = null;
+        if (sessionId) {
+            session = await this.history.loadSession(sessionId);
+        }
+        else {
+            session = await this.history.getLastSession();
+        }
+        if (!session) {
+            console.log(chalk.yellow('No previous session found. Starting new conversation.\n'));
+            await this.start();
+            return;
+        }
+        this.session = session;
+        this.messages = session.messages;
+        this.sessionStartTime = new Date();
+        console.log(chalk.cyan('\n🚀 Grok Code CLI (Resumed)'));
+        console.log(chalk.gray(`Session: ${session.title}`));
+        console.log(chalk.gray(`Model: ${this.client.model}`));
+        console.log(chalk.gray(`Working directory: ${process.cwd()}`));
+        console.log(chalk.gray('Type /help for commands, "exit" to quit.\n'));
+        // Show recent context
+        const recentMessages = this.messages.filter(m => m.role !== 'system').slice(-4);
+        if (recentMessages.length > 0) {
+            console.log(chalk.gray('─── Recent context ───'));
+            for (const msg of recentMessages) {
+                if (msg.role === 'user') {
+                    console.log(chalk.green('You: ') + chalk.gray(msg.content.slice(0, 100) + (msg.content.length > 100 ? '...' : '')));
+                }
+                else if (msg.role === 'assistant' && msg.content) {
+                    console.log(chalk.blue('Grok: ') + chalk.gray(msg.content.slice(0, 100) + (msg.content.length > 100 ? '...' : '')));
+                }
+            }
+            console.log(chalk.gray('──────────────────────\n'));
+        }
+        await this.loop();
+    }
+    async loop() {
+        const prompt = chalk.bold.green('❯ ');
+        const question = () => {
+            return new Promise((resolve) => {
+                this.rl.question(prompt, (answer) => {
+                    resolve(answer);
+                });
+            });
+        };
+        while (true) {
+            const input = await question();
+            const trimmed = input.trim();
+            if (!trimmed)
+                continue;
+            // Handle commands
+            if (trimmed.toLowerCase() === 'exit' || trimmed.toLowerCase() === 'quit') {
+                await this.saveSession();
+                console.log(chalk.gray('\nSession saved. Goodbye!\n'));
+                this.rl.close();
+                break;
+            }
+            if (trimmed.startsWith('/')) {
+                const shouldExit = await this.handleCommand(trimmed);
+                if (shouldExit) {
+                    this.rl.close();
+                    break;
+                }
+                continue;
+            }
+            await this.processMessage(trimmed);
+        }
+    }
+    async handleCommand(command) {
+        const parts = command.slice(1).split(' ');
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1).join(' ');
+        switch (cmd) {
+            // Session Management
+            case 'clear':
+                this.messages = [this.messages[0]]; // Keep system prompt
+                this.session = await this.history.createSession(process.cwd());
+                this.tokenUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+                console.log(chalk.gray('Conversation cleared.\n'));
+                break;
+            case 'exit':
+                await this.saveSession();
+                console.log(chalk.gray('\nSession saved. Goodbye!\n'));
+                return true;
+            case 'save':
+                await this.saveSession();
+                console.log(chalk.green('Session saved.\n'));
+                break;
+            case 'compact':
+                await this.handleCompact(args);
+                break;
+            case 'history':
+                await this.showHistory();
+                break;
+            case 'resume':
+                await this.handleResume(args);
+                break;
+            case 'rename':
+                await this.handleRename(args);
+                break;
+            case 'export':
+                await this.handleExport(args);
+                break;
+            // Configuration
+            case 'config':
+                await this.handleConfig();
+                break;
+            case 'model':
+                await this.handleModel(args);
+                break;
+            case 'stream':
+                this.useStreaming = !this.useStreaming;
+                console.log(chalk.gray(`Streaming ${this.useStreaming ? 'enabled' : 'disabled'}.\n`));
+                break;
+            case 'permissions':
+                this.handlePermissions();
+                break;
+            // Status & Info
+            case 'status':
+                this.showStatus();
+                break;
+            case 'context':
+                this.showContext();
+                break;
+            case 'cost':
+                this.showCost();
+                break;
+            case 'usage':
+                this.showUsage();
+                break;
+            case 'doctor':
+                await this.runDoctor();
+                break;
+            // Working Directory
+            case 'add-dir':
+                this.handleAddDir(args);
+                break;
+            case 'pwd':
+                console.log(chalk.cyan(`\nWorking directories:\n`));
+                this.workingDirs.forEach((dir, i) => {
+                    console.log(`  ${i === 0 ? chalk.green('→') : ' '} ${dir}`);
+                });
+                console.log();
+                break;
+            // Help
+            case 'help':
+                this.showHelp();
+                break;
+            case 'version':
+                console.log(chalk.cyan(`\nGrok Code CLI v${VERSION}\n`));
+                break;
+            // Project Setup
+            case 'init':
+                await this.handleInit();
+                break;
+            case 'review':
+                await this.handleReview(args);
+                break;
+            case 'terminal-setup':
+                this.showTerminalSetup();
+                break;
+            // Convenience aliases
+            case 'h':
+                this.showHelp();
+                break;
+            case 'q':
+                await this.saveSession();
+                console.log(chalk.gray('\nSession saved. Goodbye!\n'));
+                return true;
+            case 's':
+                await this.saveSession();
+                console.log(chalk.green('Session saved.\n'));
+                break;
+            case 'c':
+                this.messages = [this.messages[0]];
+                this.session = await this.history.createSession(process.cwd());
+                console.log(chalk.gray('Conversation cleared.\n'));
+                break;
+            default:
+                console.log(chalk.yellow(`Unknown command: /${cmd}`));
+                console.log(chalk.gray('Type /help to see available commands.\n'));
+        }
+        return false;
+    }
+    // === Command Handlers ===
+    async handleCompact(instructions) {
+        const keepCount = 20;
+        const originalCount = this.messages.length;
+        if (this.messages.length > keepCount + 1) {
+            const systemPrompt = this.messages[0];
+            const recentMessages = this.messages.slice(-keepCount);
+            this.messages = [systemPrompt, ...recentMessages];
+        }
+        const removedCount = originalCount - this.messages.length;
+        console.log(chalk.gray(`Conversation compacted. Removed ${removedCount} messages, kept ${this.messages.length}.\n`));
+        if (instructions) {
+            console.log(chalk.gray(`Focus instructions: ${instructions}\n`));
+        }
+    }
+    async handleResume(sessionId) {
+        if (!sessionId) {
+            const sessions = await this.history.listSessions(5);
+            if (sessions.length === 0) {
+                console.log(chalk.yellow('No sessions to resume.\n'));
+                return;
+            }
+            console.log(chalk.cyan('\nRecent sessions:\n'));
+            sessions.forEach((s) => {
+                console.log(`  ${chalk.gray(s.id.slice(0, 8))}  ${s.title}`);
+            });
+            console.log(chalk.gray('\nUse /resume <session-id> to resume.\n'));
+            return;
+        }
+        const session = await this.history.loadSession(sessionId);
+        if (!session) {
+            // Try partial match
+            const sessions = await this.history.listSessions(50);
+            const match = sessions.find(s => s.id.startsWith(sessionId));
+            if (match) {
+                this.session = match;
+                this.messages = match.messages;
+                console.log(chalk.green(`Resumed session: ${match.title}\n`));
+                return;
+            }
+            console.log(chalk.red(`Session not found: ${sessionId}\n`));
+            return;
+        }
+        this.session = session;
+        this.messages = session.messages;
+        console.log(chalk.green(`Resumed session: ${session.title}\n`));
+    }
+    async handleRename(name) {
+        if (!name) {
+            console.log(chalk.yellow('Usage: /rename <new-name>\n'));
+            return;
+        }
+        if (this.session) {
+            this.session.title = name;
+            await this.saveSession();
+            console.log(chalk.green(`Session renamed to: ${name}\n`));
+        }
+        else {
+            console.log(chalk.red('No active session to rename.\n'));
+        }
+    }
+    async handleExport(filename) {
+        const content = this.messages
+            .filter(m => m.role !== 'system')
+            .map(m => {
+            const role = m.role === 'user' ? 'You' : m.role === 'assistant' ? 'Grok' : 'Tool';
+            return `## ${role}\n\n${m.content}\n`;
+        })
+            .join('\n---\n\n');
+        if (filename) {
+            const filePath = path.resolve(filename);
+            await fs.writeFile(filePath, content, 'utf-8');
+            console.log(chalk.green(`Conversation exported to: ${filePath}\n`));
+        }
+        else {
+            // Copy to clipboard concept - just show it
+            console.log(chalk.cyan('\n─── Exported Conversation ───\n'));
+            console.log(content.slice(0, 2000));
+            if (content.length > 2000) {
+                console.log(chalk.gray('\n... (truncated, use /export <filename> to save full conversation)'));
+            }
+            console.log(chalk.cyan('\n─────────────────────────────\n'));
+        }
+    }
+    async handleConfig() {
+        console.log(chalk.cyan('\n⚙️  Configuration\n'));
+        const apiKey = await this.config.getApiKey();
+        console.log(`  API Key:     ${apiKey ? chalk.green('✓ Set') : chalk.red('✗ Not set')}`);
+        console.log(`  Model:       ${this.client.model}`);
+        console.log(`  Streaming:   ${this.useStreaming ? chalk.green('enabled') : chalk.gray('disabled')}`);
+        console.log(`  Temperature: ${this.config.get('temperature')}`);
+        console.log(`  Max Tokens:  ${this.config.get('maxTokens')}`);
+        console.log(`  Auto-approve: ${this.config.get('autoApprove').join(', ') || 'none'}`);
+        console.log();
+        console.log(chalk.gray(`  Config file: ~/.config/grokcodecli/config.json`));
+        console.log(chalk.gray('  Run `grok config` in terminal to modify.\n'));
+    }
+    async handleModel(modelName) {
+        // Fetch latest models from xAI API dynamically
+        console.log(chalk.gray('Fetching available models...\n'));
+        let availableModels = [];
+        try {
+            const response = await fetch('https://api.x.ai/v1/models', {
+                headers: { 'Authorization': `Bearer ${this.apiKey}` },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                availableModels = data.data.map(m => m.id).sort();
+            }
+            else {
+                // Fallback to known models if API fails
+                availableModels = [
+                    'grok-4-0709', 'grok-4-fast-reasoning', 'grok-4-fast-non-reasoning',
+                    'grok-4-1-fast-reasoning', 'grok-4-1-fast-non-reasoning',
+                    'grok-3', 'grok-3-mini', 'grok-code-fast-1',
+                    'grok-2-vision-1212', 'grok-2-image-1212',
+                ];
+            }
+        }
+        catch {
+            // Fallback to known models
+            availableModels = [
+                'grok-4-0709', 'grok-4-fast-reasoning', 'grok-4-fast-non-reasoning',
+                'grok-3', 'grok-3-mini', 'grok-code-fast-1',
+            ];
+        }
+        if (!modelName) {
+            console.log();
+            console.log(chalk.cyan('╭──────────────────────────────────────────────────────────────────────╮'));
+            console.log(chalk.cyan('│') + chalk.bold.cyan('  🤖 Model Selection                                                   ') + chalk.cyan('│'));
+            console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
+            console.log();
+            console.log(`  ${chalk.gray('Current Model:')} ${chalk.bold.green(this.client.model)}`);
+            console.log();
+            // Better categorization
+            const grok41Reasoning = [];
+            const grok41NonReasoning = [];
+            const grok4Reasoning = [];
+            const grok4NonReasoning = [];
+            const grok4Other = [];
+            const grok3 = [];
+            const grok2 = [];
+            const specialized = [];
+            for (const model of availableModels) {
+                if (model.startsWith('grok-4-1')) {
+                    if (model.includes('non-reasoning')) {
+                        grok41NonReasoning.push(model);
+                    }
+                    else if (model.includes('reasoning')) {
+                        grok41Reasoning.push(model);
+                    }
+                }
+                else if (model.startsWith('grok-4')) {
+                    if (model.includes('non-reasoning')) {
+                        grok4NonReasoning.push(model);
+                    }
+                    else if (model.includes('reasoning')) {
+                        grok4Reasoning.push(model);
+                    }
+                    else {
+                        grok4Other.push(model);
+                    }
+                }
+                else if (model.startsWith('grok-3')) {
+                    grok3.push(model);
+                }
+                else if (model.startsWith('grok-2')) {
+                    grok2.push(model);
+                }
+                else if (model.includes('code') || model.includes('vision') || model.includes('image')) {
+                    specialized.push(model);
+                }
+            }
+            // Display Grok 4.1 (Latest)
+            if (grok41Reasoning.length > 0 || grok41NonReasoning.length > 0) {
+                console.log(chalk.bold.magenta('  ⭐ Grok 4.1 (Latest)'));
+                console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+                for (const model of grok41Reasoning) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.green('🧠')} ${chalk.green(model)}${current} ${chalk.yellow('[REASONING]')}`);
+                }
+                for (const model of grok41NonReasoning) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.cyan('⚡')} ${model}${current} ${chalk.gray('[FAST]')}`);
+                }
+                console.log();
+            }
+            // Display Grok 4
+            if (grok4Reasoning.length > 0 || grok4NonReasoning.length > 0 || grok4Other.length > 0) {
+                console.log(chalk.bold.cyan('  🚀 Grok 4'));
+                console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+                for (const model of grok4Other) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.cyan('•')} ${model}${current} ${chalk.gray('(recommended)')}`);
+                }
+                for (const model of grok4Reasoning) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.green('🧠')} ${chalk.green(model)}${current} ${chalk.yellow('[REASONING]')}`);
+                }
+                for (const model of grok4NonReasoning) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.cyan('⚡')} ${model}${current} ${chalk.gray('[FAST]')}`);
+                }
+                console.log();
+            }
+            // Display Grok 3
+            if (grok3.length > 0) {
+                console.log(chalk.bold.blue('  📦 Grok 3'));
+                console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+                for (const model of grok3) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.cyan('•')} ${model}${current}`);
+                }
+                console.log();
+            }
+            // Display Grok 2
+            if (grok2.length > 0) {
+                console.log(chalk.bold.gray('  📷 Grok 2 (Vision/Image)'));
+                console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+                for (const model of grok2) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.cyan('•')} ${model}${current}`);
+                }
+                console.log();
+            }
+            // Display Specialized
+            if (specialized.length > 0) {
+                console.log(chalk.bold.yellow('  🔧 Specialized'));
+                console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+                for (const model of specialized) {
+                    const current = model === this.client.model ? chalk.green(' ← current') : '';
+                    console.log(`    ${chalk.cyan('•')} ${model}${current}`);
+                }
+                console.log();
+            }
+            console.log(chalk.gray(`  ${availableModels.length} models available • Use /model <name> to switch`));
+            console.log(chalk.gray('  🧠 = Reasoning (best for complex tasks) • ⚡ = Fast (quick responses)'));
+            console.log();
+            return;
+        }
+        // Allow partial matching with normalization
+        let matchedModel = modelName;
+        if (!availableModels.includes(modelName)) {
+            // Normalize input:
+            // "grok41" → "grok-4-1", "grok4" → "grok-4", "grok 3" → "grok-3"
+            // "4.1" → "4-1", "grok 4 1" → "grok-4-1"
+            let normalized = modelName.toLowerCase()
+                .replace(/grok\s*(\d)(\d)?(\d)?/g, (_, d1, d2, d3) => {
+                if (d3)
+                    return `grok-${d1}-${d2}-${d3}`;
+                if (d2)
+                    return `grok-${d1}-${d2}`;
+                return `grok-${d1}`;
+            })
+                .replace(/(\d+)\.(\d+)/g, '$1-$2') // "4.1" → "4-1"
+                .replace(/\s+/g, '-'); // spaces to hyphens
+            // Try to find a match
+            let partialMatch = availableModels.find(m => m.toLowerCase().includes(normalized));
+            // If no match, try the original input
+            if (!partialMatch) {
+                partialMatch = availableModels.find(m => m.toLowerCase().includes(modelName.toLowerCase()));
+            }
+            if (partialMatch) {
+                matchedModel = partialMatch;
+                console.log(chalk.gray(`Matched: ${matchedModel}`));
+            }
+            else {
+                console.log(chalk.red(`Unknown model: ${modelName}\n`));
+                console.log(chalk.gray('Use /model to see available models.\n'));
+                return;
+            }
+        }
+        this.client = new GrokClient(this.apiKey, matchedModel);
+        console.log(chalk.green(`✓ Switched to model: ${matchedModel}\n`));
+    }
+    handlePermissions() {
+        console.log(chalk.cyan('\n🔐 Permission Settings\n'));
+        console.log('  Tool Risk Levels:');
+        console.log(`    ${chalk.green('📖 Read')}    - Read, Glob, Grep, WebFetch`);
+        console.log(`    ${chalk.yellow('✏️  Write')}   - Write, Edit`);
+        console.log(`    ${chalk.red('⚡ Execute')} - Bash`);
+        console.log();
+        console.log('  Permission Responses:');
+        console.log('    [y] Allow once');
+        console.log('    [a] Allow for session');
+        console.log('    [n] Deny');
+        console.log('    [!] Block for session');
+        console.log();
+        console.log(chalk.gray('  Auto-approved tools: ' + (this.config.get('autoApprove').join(', ') || 'none')));
+        console.log(chalk.gray('  Edit config to add auto-approve rules.\n'));
+    }
+    showStatus() {
+        const uptime = Math.floor((Date.now() - this.sessionStartTime.getTime()) / 1000);
+        const minutes = Math.floor(uptime / 60);
+        const seconds = uptime % 60;
+        console.log(chalk.cyan('\n📊 Status\n'));
+        console.log(`  Version:     ${VERSION}`);
+        console.log(`  Model:       ${this.client.model}`);
+        console.log(`  Session:     ${this.session?.title || 'Untitled'}`);
+        console.log(`  Session ID:  ${this.session?.id.slice(0, 8) || 'N/A'}`);
+        console.log(`  Messages:    ${this.messages.length}`);
+        console.log(`  Uptime:      ${minutes}m ${seconds}s`);
+        console.log(`  Streaming:   ${this.useStreaming ? 'on' : 'off'}`);
+        console.log(`  Working Dir: ${process.cwd()}`);
+        console.log(`  Platform:    ${process.platform} ${process.arch}`);
+        console.log(`  Node:        ${process.version}`);
+        console.log();
+    }
+    showContext() {
+        const messageCount = this.messages.length;
+        const userMessages = this.messages.filter(m => m.role === 'user').length;
+        const assistantMessages = this.messages.filter(m => m.role === 'assistant').length;
+        const toolMessages = this.messages.filter(m => m.role === 'tool').length;
+        // Estimate tokens (rough: 4 chars = 1 token)
+        const totalChars = this.messages.reduce((acc, m) => acc + (m.content?.length || 0), 0);
+        const estimatedTokens = Math.ceil(totalChars / 4);
+        const maxTokens = 128000; // Approximate context window
+        const usagePercent = Math.min(100, Math.round((estimatedTokens / maxTokens) * 100));
+        console.log(chalk.cyan('\n📈 Context Usage\n'));
+        // Visual bar
+        const barWidth = 40;
+        const filledWidth = Math.round((usagePercent / 100) * barWidth);
+        const emptyWidth = barWidth - filledWidth;
+        const bar = chalk.green('█'.repeat(filledWidth)) + chalk.gray('░'.repeat(emptyWidth));
+        console.log(`  [${bar}] ${usagePercent}%`);
+        console.log();
+        console.log(`  Estimated tokens: ~${estimatedTokens.toLocaleString()} / ${maxTokens.toLocaleString()}`);
+        console.log(`  Total messages:   ${messageCount}`);
+        console.log(`    User:           ${userMessages}`);
+        console.log(`    Assistant:      ${assistantMessages}`);
+        console.log(`    Tool results:   ${toolMessages}`);
+        console.log();
+        if (usagePercent > 80) {
+            console.log(chalk.yellow('  ⚠️  Context is getting full. Consider using /compact.\n'));
+        }
+    }
+    showCost() {
+        // Rough cost estimation based on token usage
+        const inputCostPer1M = 3.00; // $3 per 1M input tokens (estimated)
+        const outputCostPer1M = 15.00; // $15 per 1M output tokens (estimated)
+        const inputCost = (this.tokenUsage.promptTokens / 1000000) * inputCostPer1M;
+        const outputCost = (this.tokenUsage.completionTokens / 1000000) * outputCostPer1M;
+        const totalCost = inputCost + outputCost;
+        console.log(chalk.cyan('\n💰 Token Usage & Cost (Estimated)\n'));
+        console.log(`  Input tokens:    ${this.tokenUsage.promptTokens.toLocaleString()}`);
+        console.log(`  Output tokens:   ${this.tokenUsage.completionTokens.toLocaleString()}`);
+        console.log(`  Total tokens:    ${this.tokenUsage.totalTokens.toLocaleString()}`);
+        console.log();
+        console.log(`  Estimated cost:  $${totalCost.toFixed(4)}`);
+        console.log(chalk.gray('\n  Note: Actual costs may vary. Check xAI pricing.\n'));
+    }
+    showUsage() {
+        console.log(chalk.cyan('\n📊 Usage Statistics\n'));
+        console.log(`  Session tokens:  ${this.tokenUsage.totalTokens.toLocaleString()}`);
+        console.log(`  Messages sent:   ${this.messages.filter(m => m.role === 'user').length}`);
+        console.log(`  Tool calls:      ${this.messages.filter(m => m.role === 'tool').length}`);
+        console.log();
+        console.log(chalk.gray('  For billing info, visit: https://console.x.ai/\n'));
+    }
+    async runDoctor() {
+        console.log(chalk.cyan('\n🩺 Running diagnostics...\n'));
+        const checks = [];
+        // Check API key
+        const apiKey = await this.config.getApiKey();
+        if (apiKey) {
+            checks.push({ name: 'API Key', status: 'ok', message: 'API key is configured' });
+        }
+        else {
+            checks.push({ name: 'API Key', status: 'fail', message: 'No API key found. Run `grok auth`' });
+        }
+        // Check Node version
+        const nodeVersion = process.version;
+        const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+        if (majorVersion >= 18) {
+            checks.push({ name: 'Node.js', status: 'ok', message: `${nodeVersion} (>=18 required)` });
+        }
+        else {
+            checks.push({ name: 'Node.js', status: 'fail', message: `${nodeVersion} - upgrade to >=18` });
+        }
+        // Check working directory
+        try {
+            await fs.access(process.cwd(), fs.constants.R_OK | fs.constants.W_OK);
+            checks.push({ name: 'Working Dir', status: 'ok', message: 'Read/write access confirmed' });
+        }
+        catch {
+            checks.push({ name: 'Working Dir', status: 'warn', message: 'Limited access to working directory' });
+        }
+        // Check config directory
+        const configDir = path.join(os.homedir(), '.config', 'grokcodecli');
+        try {
+            await fs.access(configDir);
+            checks.push({ name: 'Config Dir', status: 'ok', message: configDir });
+        }
+        catch {
+            checks.push({ name: 'Config Dir', status: 'warn', message: 'Will be created on first use' });
+        }
+        // Check git
+        try {
+            const { execSync } = await import('child_process');
+            execSync('git --version', { stdio: 'pipe' });
+            checks.push({ name: 'Git', status: 'ok', message: 'Git is available' });
+        }
+        catch {
+            checks.push({ name: 'Git', status: 'warn', message: 'Git not found (optional)' });
+        }
+        // Test API connection
+        if (apiKey) {
+            try {
+                const response = await fetch('https://api.x.ai/v1/models', {
+                    headers: { 'Authorization': `Bearer ${apiKey}` },
+                });
+                if (response.ok) {
+                    checks.push({ name: 'API Connection', status: 'ok', message: 'Connected to xAI API' });
+                }
+                else {
+                    checks.push({ name: 'API Connection', status: 'fail', message: `API error: ${response.status}` });
+                }
+            }
+            catch (error) {
+                checks.push({ name: 'API Connection', status: 'fail', message: 'Cannot reach xAI API' });
+            }
+        }
+        // Display results
+        for (const check of checks) {
+            const icon = check.status === 'ok' ? chalk.green('✓') :
+                check.status === 'warn' ? chalk.yellow('⚠') : chalk.red('✗');
+            const name = check.status === 'ok' ? chalk.green(check.name) :
+                check.status === 'warn' ? chalk.yellow(check.name) : chalk.red(check.name);
+            console.log(`  ${icon} ${name.padEnd(20)} ${chalk.gray(check.message)}`);
+        }
+        const failures = checks.filter(c => c.status === 'fail').length;
+        const warnings = checks.filter(c => c.status === 'warn').length;
+        console.log();
+        if (failures > 0) {
+            console.log(chalk.red(`  ${failures} issue(s) found. Please fix before using.\n`));
+        }
+        else if (warnings > 0) {
+            console.log(chalk.yellow(`  ${warnings} warning(s). Grok Code should work fine.\n`));
+        }
+        else {
+            console.log(chalk.green('  All checks passed! Grok Code is ready.\n'));
+        }
+    }
+    handleAddDir(dirPath) {
+        if (!dirPath) {
+            console.log(chalk.yellow('Usage: /add-dir <path>\n'));
+            return;
+        }
+        const resolved = path.resolve(dirPath);
+        if (this.workingDirs.includes(resolved)) {
+            console.log(chalk.yellow(`Directory already added: ${resolved}\n`));
+            return;
+        }
+        this.workingDirs.push(resolved);
+        console.log(chalk.green(`Added working directory: ${resolved}\n`));
+    }
+    async showHistory() {
+        const sessions = await this.history.listSessions(10);
+        if (sessions.length === 0) {
+            console.log(chalk.gray('No saved conversations.\n'));
+            return;
+        }
+        console.log(chalk.cyan('\n📚 Recent Conversations\n'));
+        for (const session of sessions) {
+            const date = new Date(session.updatedAt).toLocaleDateString();
+            const time = new Date(session.updatedAt).toLocaleTimeString();
+            const isCurrent = session.id === this.session?.id;
+            const marker = isCurrent ? chalk.green(' ← current') : '';
+            console.log(`  ${chalk.gray(session.id.slice(0, 8))}  ${session.title}${marker}`);
+            console.log(`           ${chalk.gray(`${date} ${time} • ${session.messages.length} messages`)}`);
+        }
+        console.log(chalk.gray('\nUse /resume <id> to switch sessions.\n'));
+    }
+    async handleInit() {
+        const grokMdPath = path.join(process.cwd(), 'GROK.md');
+        try {
+            await fs.access(grokMdPath);
+            console.log(chalk.yellow('GROK.md already exists in this project.\n'));
+            console.log(chalk.gray('Edit it directly or delete it to re-initialize.\n'));
+            return;
+        }
+        catch {
+            // File doesn't exist, create it
+        }
+        const template = `# Project Guide for Grok
+
+## Project Overview
+<!-- Describe what this project does -->
+
+## Tech Stack
+<!-- List the main technologies used -->
+
+## Project Structure
+<!-- Describe the key directories and files -->
+
+## Development Guidelines
+<!-- Any coding standards or practices to follow -->
+
+## Common Commands
+\`\`\`bash
+# Build the project
+npm run build
+
+# Run tests
+npm test
+
+# Start development server
+npm run dev
+\`\`\`
+
+## Notes for Grok
+<!-- Any specific instructions for the AI assistant -->
+- Always read files before editing
+- Run tests after making changes
+- Follow existing code patterns
+`;
+        await fs.writeFile(grokMdPath, template, 'utf-8');
+        console.log(chalk.green('✓ Created GROK.md\n'));
+        console.log(chalk.gray('Edit this file to help Grok understand your project better.\n'));
+        console.log(chalk.cyan('Contents will be automatically included in conversations.\n'));
+    }
+    async handleReview(focus) {
+        console.log(chalk.cyan('\n🔍 Starting Code Review\n'));
+        const reviewPrompt = focus
+            ? `Please review the code changes in this project, focusing on: ${focus}
+
+Check for:
+1. Code quality and best practices
+2. Potential bugs or issues
+3. Security vulnerabilities
+4. Performance concerns
+5. Test coverage gaps
+
+Provide specific, actionable feedback.`
+            : `Please review the recent code changes in this project.
+
+Check for:
+1. Code quality and best practices
+2. Potential bugs or issues
+3. Security vulnerabilities
+4. Performance concerns
+5. Test coverage gaps
+
+Start by checking git status and recent changes, then provide specific, actionable feedback.`;
+        // Send as a message to Grok
+        await this.processMessage(reviewPrompt);
+    }
+    showTerminalSetup() {
+        console.log(chalk.cyan('\n⌨️  Terminal Setup\n'));
+        console.log(chalk.bold('Recommended Key Bindings:\n'));
+        console.log('  ' + chalk.green('Shift+Enter') + ' - Insert newline without sending');
+        console.log('  ' + chalk.green('Ctrl+C') + '      - Cancel current operation');
+        console.log('  ' + chalk.green('Ctrl+D') + '      - Exit (same as typing "exit")');
+        console.log('  ' + chalk.green('Up/Down') + '     - Navigate command history');
+        console.log();
+        console.log(chalk.bold('For Bash/Zsh (add to ~/.bashrc or ~/.zshrc):\n'));
+        console.log(chalk.gray('  # Grok Code CLI alias'));
+        console.log(chalk.cyan('  alias g="grok"'));
+        console.log(chalk.cyan('  alias gr="grok --resume"'));
+        console.log();
+        console.log(chalk.bold('For Fish (add to ~/.config/fish/config.fish):\n'));
+        console.log(chalk.gray('  # Grok Code CLI alias'));
+        console.log(chalk.cyan('  alias g "grok"'));
+        console.log(chalk.cyan('  alias gr "grok --resume"'));
+        console.log();
+        console.log(chalk.bold('VS Code Integration:\n'));
+        console.log('  Add to settings.json:');
+        console.log(chalk.gray('  "terminal.integrated.env.linux": {'));
+        console.log(chalk.gray('    "XAI_API_KEY": "your-api-key"'));
+        console.log(chalk.gray('  }'));
+        console.log();
+        console.log(chalk.gray('Tip: Run `grok auth` to save your API key permanently.\n'));
+    }
+    showHelp() {
+        console.log();
+        console.log(chalk.cyan('╭──────────────────────────────────────────────────────────────────────╮'));
+        console.log(chalk.cyan('│') + chalk.bold.cyan('  📚 Grok Code CLI - Command Reference                                 ') + chalk.cyan('│'));
+        console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
+        console.log();
+        console.log(chalk.bold.cyan('  Session Management'));
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+        console.log(`  ${chalk.cyan('/clear')}              Clear conversation and start fresh`);
+        console.log(`  ${chalk.cyan('/save')}, ${chalk.cyan('/s')}           Save current conversation`);
+        console.log(`  ${chalk.cyan('/history')}            Show saved conversations`);
+        console.log(`  ${chalk.cyan('/resume')} ${chalk.gray('[id]')}        Resume a previous conversation`);
+        console.log(`  ${chalk.cyan('/rename')} ${chalk.gray('<name>')}      Rename current session`);
+        console.log(`  ${chalk.cyan('/export')} ${chalk.gray('[file]')}      Export conversation to file`);
+        console.log(`  ${chalk.cyan('/compact')} ${chalk.gray('[focus]')}    Reduce context size`);
+        console.log(`  ${chalk.cyan('/exit')}, ${chalk.cyan('/q')}           Save and quit`);
+        console.log();
+        console.log(chalk.bold.cyan('  Configuration'));
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+        console.log(`  ${chalk.cyan('/config')}             Show current configuration`);
+        console.log(`  ${chalk.cyan('/model')} ${chalk.gray('[name]')}       Show or change the AI model`);
+        console.log(`  ${chalk.cyan('/stream')}             Toggle streaming mode`);
+        console.log(`  ${chalk.cyan('/permissions')}        View permission settings`);
+        console.log();
+        console.log(chalk.bold.cyan('  Status & Diagnostics'));
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+        console.log(`  ${chalk.cyan('/status')}             Show session status and info`);
+        console.log(`  ${chalk.cyan('/context')}            Visualize context usage`);
+        console.log(`  ${chalk.cyan('/cost')}               Show token usage and estimated cost`);
+        console.log(`  ${chalk.cyan('/doctor')}             Run diagnostics check`);
+        console.log(`  ${chalk.cyan('/version')}            Show version`);
+        console.log();
+        console.log(chalk.bold.cyan('  Project Setup'));
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+        console.log(`  ${chalk.cyan('/init')}               Initialize project with GROK.md`);
+        console.log(`  ${chalk.cyan('/review')} ${chalk.gray('[focus]')}     Request AI code review`);
+        console.log(`  ${chalk.cyan('/terminal-setup')}     Show terminal tips`);
+        console.log();
+        console.log(chalk.bold.cyan('  Available Tools'));
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
+        console.log(`  ${chalk.green('📖 Read')}       Read file contents with line numbers`);
+        console.log(`  ${chalk.yellow('✏️  Write')}      Create or overwrite files`);
+        console.log(`  ${chalk.yellow('🔧 Edit')}       Edit files by string replacement`);
+        console.log(`  ${chalk.red('⚡ Bash')}       Execute shell commands`);
+        console.log(`  ${chalk.green('🔍 Glob')}       Find files by pattern`);
+        console.log(`  ${chalk.green('🔎 Grep')}       Search file contents with regex`);
+        console.log(`  ${chalk.green('🌐 WebFetch')}   Fetch and parse web content`);
+        console.log(`  ${chalk.green('🔍 WebSearch')}  Search the web for information`);
+        console.log();
+        console.log(chalk.bold('Permission Responses:'));
+        console.log('  [y] Allow once       [a] Allow for session');
+        console.log('  [n] Deny             [!] Block for session');
+        console.log();
+    }
+    // === Core Processing ===
+    async processMessage(input) {
+        this.messages.push({
+            role: 'user',
+            content: input,
+        });
+        try {
+            if (this.useStreaming) {
+                await this.getStreamingResponse();
+            }
+            else {
+                await this.getResponse();
+            }
+            await this.saveSession();
+        }
+        catch (error) {
+            const err = error;
+            console.log(chalk.red(`\nError: ${err.message}\n`));
+        }
+    }
+    async getResponse() {
+        console.log(chalk.blue('\nGrok: ') + chalk.gray('thinking...'));
+        const response = await this.client.chat(this.messages, allTools);
+        const choice = response.choices[0];
+        const message = choice.message;
+        // Update token usage
+        if (response.usage) {
+            this.tokenUsage.promptTokens += response.usage.prompt_tokens;
+            this.tokenUsage.completionTokens += response.usage.completion_tokens;
+            this.tokenUsage.totalTokens += response.usage.total_tokens;
+        }
+        this.messages.push(message);
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            if (message.content) {
+                this.printMarkdown(message.content);
+            }
+            for (const toolCall of message.tool_calls) {
+                await this.executeToolCall(toolCall);
+            }
+            await this.getResponse();
+        }
+        else {
+            if (message.content) {
+                process.stdout.write('\x1b[1A\x1b[2K');
+                console.log(chalk.blue('Grok: '));
+                this.printMarkdown(message.content);
+                console.log();
+            }
+        }
+    }
+    async getStreamingResponse() {
+        // Show thinking indicator
+        process.stdout.write(chalk.cyan('\n╭─ ') + chalk.bold.cyan('Grok') + chalk.cyan(' ─────────────────────────────────────────────────────────────╮\n'));
+        process.stdout.write(chalk.cyan('│ ') + chalk.gray('⠋ thinking...'));
+        let fullContent = '';
+        let toolCalls = [];
+        let currentToolCall = null;
+        let firstChunk = true;
+        try {
+            for await (const chunk of this.client.chatStream(this.messages, allTools)) {
+                const delta = chunk.choices[0]?.delta;
+                if (delta?.content) {
+                    if (firstChunk) {
+                        // Clear thinking indicator and start content
+                        process.stdout.write('\r' + chalk.cyan('│ ') + ' '.repeat(50) + '\r' + chalk.cyan('│ '));
+                        firstChunk = false;
+                    }
+                    process.stdout.write(delta.content);
+                    fullContent += delta.content;
+                }
+                // Handle streaming tool calls
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        if (tc.id) {
+                            // New tool call
+                            if (currentToolCall && currentToolCall.id) {
+                                toolCalls.push(currentToolCall);
+                            }
+                            currentToolCall = {
+                                id: tc.id,
+                                type: 'function',
+                                function: {
+                                    name: tc.function?.name || '',
+                                    arguments: tc.function?.arguments || '',
+                                },
+                            };
+                        }
+                        else if (currentToolCall && tc.function?.arguments) {
+                            // Append to current tool call arguments
+                            currentToolCall.function.arguments += tc.function.arguments;
+                        }
+                    }
+                }
+            }
+            // Push last tool call if exists
+            if (currentToolCall && currentToolCall.id) {
+                toolCalls.push(currentToolCall);
+            }
+            // Close the response box
+            if (fullContent) {
+                console.log();
+                console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
+            }
+            else if (toolCalls.length > 0) {
+                process.stdout.write('\r' + chalk.cyan('│ ') + chalk.gray('Using tools...') + ' '.repeat(40) + '\n');
+                console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
+            }
+            // Build the message for history
+            const message = {
+                role: 'assistant',
+                content: fullContent,
+            };
+            if (toolCalls.length > 0) {
+                message.tool_calls = toolCalls;
+            }
+            this.messages.push(message);
+            // Execute tool calls
+            if (toolCalls.length > 0) {
+                for (const toolCall of toolCalls) {
+                    await this.executeToolCall(toolCall);
+                }
+                await this.getStreamingResponse();
+            }
+        }
+        catch (error) {
+            console.log();
+            throw error;
+        }
+    }
+    async executeToolCall(toolCall) {
+        const { name, arguments: argsJson } = toolCall.function;
+        let params;
+        try {
+            params = JSON.parse(argsJson);
+        }
+        catch {
+            console.log(chalk.red(`\n⚠️ Invalid arguments for ${name}`));
+            this.messages.push({
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                content: 'Error: Invalid JSON arguments',
+            });
+            return;
+        }
+        // Request permission
+        const riskLevel = this.permissions.getToolRiskLevel(name);
+        const description = this.permissions.formatToolDetails(name, params);
+        const approved = await this.permissions.requestPermission({
+            tool: name,
+            description,
+            riskLevel,
+            details: params,
+        });
+        if (!approved) {
+            this.messages.push({
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                content: 'Error: Permission denied by user',
+            });
+            return;
+        }
+        // Show execution with beautiful box
+        const toolIcons = {
+            Read: '📖', Write: '✏️', Edit: '🔧', Bash: '⚡',
+            Glob: '🔍', Grep: '🔎', WebFetch: '🌐', WebSearch: '🔍'
+        };
+        const toolColors = {
+            Read: chalk.green, Write: chalk.yellow, Edit: chalk.yellow, Bash: chalk.red,
+            Glob: chalk.green, Grep: chalk.green, WebFetch: chalk.green, WebSearch: chalk.green
+        };
+        const icon = toolIcons[name] || '🔧';
+        const color = toolColors[name] || chalk.gray;
+        console.log();
+        console.log(color('┌─ ') + chalk.bold(`${icon} ${name}`) + color(' ─────────────────────────────────────────────────'));
+        // Show details based on tool type
+        if (name === 'Bash') {
+            console.log(color('│ ') + chalk.gray('$') + ' ' + chalk.white(params.command));
+        }
+        else if (name === 'Read' || name === 'Write' || name === 'Edit') {
+            console.log(color('│ ') + chalk.gray('File:') + ' ' + chalk.cyan(params.file_path));
+        }
+        else if (name === 'Glob' || name === 'Grep') {
+            console.log(color('│ ') + chalk.gray('Pattern:') + ' ' + chalk.cyan(params.pattern));
+        }
+        else if (name === 'WebFetch') {
+            console.log(color('│ ') + chalk.gray('URL:') + ' ' + chalk.cyan(params.url));
+        }
+        else if (name === 'WebSearch') {
+            console.log(color('│ ') + chalk.gray('Query:') + ' ' + chalk.cyan(params.query));
+        }
+        // Execute
+        const result = await executeTool(name, params);
+        if (result.success) {
+            console.log(color('│'));
+            console.log(color('│ ') + chalk.green('✓ Success'));
+            if (result.output && result.output.length < 500) {
+                const lines = result.output.split('\n').slice(0, 10);
+                for (const line of lines) {
+                    console.log(color('│ ') + chalk.gray(line.slice(0, 80)));
+                }
+                if (result.output.split('\n').length > 10) {
+                    console.log(color('│ ') + chalk.gray('... (truncated)'));
+                }
+            }
+            else if (result.output) {
+                console.log(color('│ ') + chalk.gray(result.output.slice(0, 200) + '... (truncated)'));
+            }
+        }
+        else {
+            console.log(color('│'));
+            console.log(color('│ ') + chalk.red('✗ Failed: ') + chalk.red(result.error || 'Unknown error'));
+        }
+        console.log(color('└──────────────────────────────────────────────────────────────────────'));
+        this.messages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: result.success ? result.output : `Error: ${result.error}`,
+        });
+    }
+    async saveSession() {
+        if (this.session) {
+            this.session.messages = this.messages;
+            await this.history.saveSession(this.session);
+        }
+    }
+    printMarkdown(content) {
+        const formatted = content
+            .replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
+            return chalk.gray(`─── ${lang || 'code'} ───\n`) + chalk.cyan(code.trim()) + chalk.gray('\n───────────');
+        })
+            .replace(/`([^`]+)`/g, chalk.cyan('$1'));
+        console.log(formatted);
+    }
+}
+//# sourceMappingURL=chat.js.map