vigthoria-cli 1.0.0

package/dist/commands/chat.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Interactive Chat Command for Vigthoria CLI
+ *
+ * Now with Claude Code-like agentic capabilities!
+ */
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface ChatOptions {
+    model: string;
+    project: string;
+    agent?: boolean;
+    autoApprove?: boolean;
+    resume?: boolean;
+    stream?: boolean;
+    local?: boolean;
+}
+export declare class ChatCommand {
+    private config;
+    private logger;
+    private api;
+    private messages;
+    private fileUtils;
+    private marked;
+    private tools;
+    private agentMode;
+    private rl;
+    private sessionManager;
+    private currentSession;
+    private streamMode;
+    private localMode;
+    constructor(config: Config, logger: Logger);
+    run(options: ChatOptions): Promise<void>;
+    private buildSystemPrompt;
+    private printWelcome;
+    private startRepl;
+    private chat;
+    /**
+     * Execute tool calls from AI response (Claude Code-like)
+     */
+    private executeToolCalls;
+    /**
+     * Format tool results for AI context
+     */
+    private formatToolResults;
+    /**
+     * Truncate long output for context management
+     */
+    private truncateOutput;
+    /**
+     * Ask user for permission to execute dangerous action
+     */
+    private askPermission;
+    private addFileToContext;
+    private startEditMode;
+    private showPendingDiff;
+    private applyChanges;
+    private printHelp;
+    private listSessions;
+    private showHistory;
+    private compactContext;
+    private printModels;
+}
+export {};
+//# sourceMappingURL=chat.d.ts.map

package/dist/commands/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/commands/chat.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAM5C,UAAU,WAAW;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,GAAG,CAAY;IACvB,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,EAAE,CAAmC;IAC7C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,SAAS,CAAkB;gBAEvB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAYpC,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA+D9C,OAAO,CAAC,iBAAiB;IAqCzB,OAAO,CAAC,YAAY;YAmBN,SAAS;YAoMT,IAAI;IA+ClB;;OAEG;YACW,gBAAgB;IA+B9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;YACW,aAAa;YAgBb,gBAAgB;YAkBhB,aAAa;IAqB3B,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,SAAS;IA4BjB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,WAAW;YAkBL,cAAc;IA6C5B,OAAO,CAAC,WAAW;CAUpB"}

package/dist/commands/chat.js

@@ -0,0 +1,596 @@
+"use strict";
+/**
+ * Interactive Chat Command for Vigthoria CLI
+ *
+ * Now with Claude Code-like agentic capabilities!
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const readline = __importStar(require("readline"));
+const marked_1 = require("marked");
+const marked_terminal_1 = require("marked-terminal");
+const api_js_1 = require("../utils/api.js");
+const files_js_1 = require("../utils/files.js");
+const tools_js_1 = require("../utils/tools.js");
+const session_js_1 = require("../utils/session.js");
+class ChatCommand {
+    config;
+    logger;
+    api;
+    messages = [];
+    fileUtils;
+    marked;
+    tools = null;
+    agentMode = false;
+    rl = null;
+    sessionManager;
+    currentSession = null;
+    streamMode = true;
+    localMode = false;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.api = new api_js_1.APIClient(config, logger);
+        this.fileUtils = new files_js_1.FileUtils(process.cwd(), config.get('project').ignorePatterns);
+        this.sessionManager = new session_js_1.SessionManager();
+        // Setup marked for terminal rendering
+        this.marked = new marked_1.Marked();
+        this.marked.use((0, marked_terminal_1.markedTerminal)());
+    }
+    async run(options) {
+        // Check authentication (skip for local testing mode)
+        if (!options.local && !this.config.isAuthenticated()) {
+            this.logger.error('Not authenticated. Run: vigthoria login');
+            this.logger.info('Tip: Use --local flag to test with local Ollama models');
+            return;
+        }
+        if (!options.local && !this.config.hasValidSubscription()) {
+            this.logger.warn('Your subscription has expired. Some features may be limited.');
+        }
+        if (options.local) {
+            this.logger.info('Local mode: Using Ollama for AI responses');
+        }
+        // Setup agentic tools if enabled
+        this.agentMode = options.agent || false;
+        this.streamMode = options.stream !== false; // Default to true
+        this.localMode = options.local || false;
+        if (this.agentMode) {
+            this.tools = new tools_js_1.AgenticTools(this.logger, options.project, this.askPermission.bind(this), options.autoApprove || false);
+        }
+        // Try to resume previous session or create new one
+        if (options.resume) {
+            this.currentSession = this.sessionManager.getLatest(options.project);
+            if (this.currentSession) {
+                this.messages = [...this.currentSession.messages];
+                this.logger.success(`Resumed session: ${this.currentSession.id}`);
+            }
+        }
+        if (!this.currentSession) {
+            this.currentSession = this.sessionManager.create(options.project, options.model, this.agentMode);
+        }
+        // Get project context
+        const projectContext = await this.fileUtils.getProjectContext();
+        // Setup system message
+        const systemMessage = {
+            role: 'system',
+            content: this.buildSystemPrompt(projectContext, options),
+        };
+        this.messages.push(systemMessage);
+        this.printWelcome(options);
+        // Start REPL
+        await this.startRepl(options);
+    }
+    buildSystemPrompt(projectContext, options) {
+        let prompt = `You are Vigthoria, a premium AI coding assistant. You help developers write, understand, and improve code.
+
+Project Context:
+- Type: ${projectContext.type}
+- Root: ${options.project}
+- Key files: ${projectContext.files.slice(0, 10).join(', ')}
+${projectContext.type === 'node' ? `- Dependencies: ${Object.keys(projectContext.dependencies).slice(0, 15).join(', ')}` : ''}
+
+Guidelines:
+- Provide complete, production-ready code
+- Use modern best practices (2024-2026 standards)
+- Include proper error handling
+- Explain your reasoning when helpful
+- Be concise but thorough
+
+Special Commands (user may use these):
+- /file <path> - Read and include a file in context
+- /edit <path> - Switch to file editing mode
+- /diff - Show pending changes
+- /apply - Apply pending changes
+- /clear - Clear conversation history
+- /model <name> - Switch AI model
+- /agent - Toggle agentic mode (Claude Code-like autonomous actions)
+- /help - Show available commands`;
+        // Add tool instructions if in agent mode
+        if (this.agentMode && this.tools) {
+            prompt += `\n\n${tools_js_1.AgenticTools.getToolsForPrompt()}`;
+        }
+        return prompt;
+    }
+    printWelcome(options) {
+        const sub = this.config.get('subscription');
+        console.log();
+        this.logger.box(`Model: ${chalk_1.default.cyan(options.model)}\n` +
+            `Plan: ${chalk_1.default.green(sub.plan || 'free')}\n` +
+            `Project: ${chalk_1.default.gray(options.project)}\n` +
+            `Agent Mode: ${this.agentMode ? chalk_1.default.green('ON ✓') : chalk_1.default.gray('OFF')}`, 'Vigthoria Chat');
+        console.log();
+        if (this.agentMode) {
+            console.log(chalk_1.default.yellow('🤖 Agent Mode: AI can read files, edit code, and run commands autonomously.'));
+        }
+        console.log(chalk_1.default.gray('Type your message or /help for commands. Press Ctrl+C to exit.'));
+        console.log();
+    }
+    async startRepl(options) {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: chalk_1.default.cyan('you › '),
+        });
+        let currentModel = options.model;
+        let pendingChanges = null;
+        this.rl.prompt();
+        for await (const line of this.rl) {
+            const input = line.trim();
+            if (!input) {
+                this.rl.prompt();
+                continue;
+            }
+            // Handle special commands
+            if (input.startsWith('/')) {
+                const [cmd, ...args] = input.slice(1).split(' ');
+                switch (cmd) {
+                    case 'help':
+                        this.printHelp();
+                        break;
+                    case 'clear':
+                        this.messages = [this.messages[0]]; // Keep system message
+                        this.logger.success('Conversation cleared');
+                        break;
+                    case 'model':
+                        if (args[0]) {
+                            currentModel = args[0];
+                            this.logger.success(`Model switched to: ${currentModel}`);
+                        }
+                        else {
+                            this.printModels();
+                        }
+                        break;
+                    case 'agent':
+                        this.agentMode = !this.agentMode;
+                        if (this.agentMode && !this.tools) {
+                            this.tools = new tools_js_1.AgenticTools(this.logger, options.project, this.askPermission.bind(this), options.autoApprove || false);
+                        }
+                        // Rebuild system prompt with/without tools
+                        this.messages[0] = {
+                            role: 'system',
+                            content: this.buildSystemPrompt(await this.fileUtils.getProjectContext(), { ...options, agent: this.agentMode }),
+                        };
+                        this.logger.success(`Agent mode: ${this.agentMode ? chalk_1.default.green('ON') : chalk_1.default.red('OFF')}`);
+                        if (this.agentMode) {
+                            console.log(chalk_1.default.yellow('  AI can now read files, edit code, and run commands.'));
+                        }
+                        break;
+                    case 'approve':
+                        if (this.tools) {
+                            options.autoApprove = !options.autoApprove;
+                            this.tools = new tools_js_1.AgenticTools(this.logger, options.project, this.askPermission.bind(this), options.autoApprove);
+                            this.logger.success(`Auto-approve: ${options.autoApprove ? chalk_1.default.green('ON') : chalk_1.default.red('OFF')}`);
+                            if (options.autoApprove) {
+                                console.log(chalk_1.default.red('  ⚠️  AI actions will be executed without confirmation!'));
+                            }
+                        }
+                        break;
+                    case 'file':
+                        if (args[0]) {
+                            await this.addFileToContext(args[0]);
+                        }
+                        else {
+                            this.logger.error('Usage: /file <path>');
+                        }
+                        break;
+                    case 'edit':
+                        if (args[0]) {
+                            pendingChanges = await this.startEditMode(args[0], currentModel);
+                        }
+                        else {
+                            this.logger.error('Usage: /edit <path>');
+                        }
+                        break;
+                    case 'diff':
+                        if (pendingChanges) {
+                            this.showPendingDiff(pendingChanges);
+                        }
+                        else {
+                            this.logger.info('No pending changes');
+                        }
+                        break;
+                    case 'apply':
+                        if (pendingChanges) {
+                            this.applyChanges(pendingChanges);
+                            pendingChanges = null;
+                        }
+                        else {
+                            this.logger.info('No pending changes to apply');
+                        }
+                        break;
+                    case 'sessions':
+                        this.listSessions();
+                        break;
+                    case 'history':
+                        this.showHistory();
+                        break;
+                    case 'save':
+                        if (this.currentSession) {
+                            this.sessionManager.save(this.currentSession);
+                            this.logger.success(`Session saved: ${this.currentSession.id}`);
+                        }
+                        break;
+                    case 'new':
+                        // Start new session
+                        this.currentSession = this.sessionManager.create(options.project, currentModel, this.agentMode);
+                        this.messages = [this.messages[0]]; // Keep only system message
+                        this.logger.success(`New session: ${this.currentSession.id}`);
+                        break;
+                    case 'compact':
+                        // Compact context by summarizing older messages
+                        await this.compactContext(currentModel);
+                        break;
+                    case 'undo':
+                        // Undo last file operation
+                        if (this.tools) {
+                            const undoResult = await this.tools.undo();
+                            if (undoResult.success) {
+                                this.logger.success(undoResult.output || 'Undo completed');
+                                if (undoResult.metadata?.remainingUndos !== undefined) {
+                                    console.log(chalk_1.default.gray(`  ${undoResult.metadata.remainingUndos} more undo(s) available`));
+                                }
+                            }
+                            else {
+                                this.logger.error(undoResult.error || 'Nothing to undo');
+                            }
+                        }
+                        else {
+                            this.logger.info('Undo is only available in agent mode. Use /agent to enable.');
+                        }
+                        break;
+                    case 'exit':
+                    case 'quit':
+                        // Auto-save session on exit
+                        if (this.currentSession && this.messages.length > 1) {
+                            this.sessionManager.save(this.currentSession);
+                            console.log(chalk_1.default.gray(`Session saved: ${this.currentSession.id}`));
+                        }
+                        console.log(chalk_1.default.cyan('\nGoodbye! 👋\n'));
+                        this.rl.close();
+                        return;
+                    default:
+                        this.logger.warn(`Unknown command: /${cmd}`);
+                }
+                this.rl.prompt();
+                continue;
+            }
+            // Regular chat message
+            await this.chat(input, currentModel);
+            // Save message to session
+            if (this.currentSession) {
+                this.currentSession.messages = [...this.messages];
+                this.sessionManager.save(this.currentSession);
+            }
+            this.rl.prompt();
+        }
+    }
+    async chat(userInput, model) {
+        // Add user message (skip if empty - used for tool continuation)
+        if (userInput) {
+            this.messages.push({ role: 'user', content: userInput });
+        }
+        const spinner = (0, ora_1.default)({
+            text: chalk_1.default.gray('Thinking...'),
+            spinner: 'dots',
+        }).start();
+        try {
+            const response = await this.api.chat(this.messages, model, this.localMode);
+            spinner.stop();
+            // Add assistant message
+            this.messages.push({ role: 'assistant', content: response.message });
+            // Render markdown response
+            console.log();
+            console.log(chalk_1.default.cyan('vigthoria ›'));
+            console.log(this.marked.parse(response.message));
+            // Show token usage
+            if (response.usage) {
+                console.log(chalk_1.default.gray(`[${response.usage.total_tokens} tokens]`));
+            }
+            console.log();
+            // In agent mode, check for and execute tool calls
+            if (this.agentMode && this.tools) {
+                const toolCalls = tools_js_1.AgenticTools.parseToolCalls(response.message);
+                if (toolCalls.length > 0) {
+                    await this.executeToolCalls(toolCalls, model);
+                }
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error('Failed to get response:', error.message);
+            // Remove failed user message
+            this.messages.pop();
+        }
+    }
+    /**
+     * Execute tool calls from AI response (Claude Code-like)
+     */
+    async executeToolCalls(calls, model) {
+        const results = [];
+        for (const call of calls) {
+            console.log(chalk_1.default.yellow(`\n⚙ Executing: ${call.tool}`));
+            const result = await this.tools.execute(call);
+            results.push({ tool: call.tool, result });
+            if (result.success) {
+                this.logger.success(`${call.tool}: Success`);
+                if (result.output) {
+                    console.log(chalk_1.default.gray(this.truncateOutput(result.output)));
+                }
+            }
+            else {
+                this.logger.error(`${call.tool}: ${result.error}`);
+            }
+        }
+        // Send tool results back to AI for continuation
+        const toolResultsMessage = {
+            role: 'user',
+            content: this.formatToolResults(results),
+        };
+        this.messages.push(toolResultsMessage);
+        // Get AI's follow-up response
+        console.log();
+        await this.chat('', model);
+    }
+    /**
+     * Format tool results for AI context
+     */
+    formatToolResults(results) {
+        let msg = 'Tool execution results:\n\n';
+        for (const { tool, result } of results) {
+            msg += `## ${tool}\n`;
+            msg += `Status: ${result.success ? 'Success' : 'Failed'}\n`;
+            if (result.output) {
+                msg += `Output:\n\`\`\`\n${this.truncateOutput(result.output)}\n\`\`\`\n`;
+            }
+            if (result.error) {
+                msg += `Error: ${result.error}\n`;
+            }
+            msg += '\n';
+        }
+        msg += 'Continue with your analysis or next steps.';
+        return msg;
+    }
+    /**
+     * Truncate long output for context management
+     */
+    truncateOutput(output, maxLines = 50) {
+        const lines = output.split('\n');
+        if (lines.length <= maxLines) {
+            return output;
+        }
+        return lines.slice(0, maxLines).join('\n') + `\n... (${lines.length - maxLines} more lines)`;
+    }
+    /**
+     * Ask user for permission to execute dangerous action
+     */
+    async askPermission(action) {
+        return new Promise((resolve) => {
+            console.log('\n' + action);
+            if (!this.rl) {
+                resolve(false);
+                return;
+            }
+            this.rl.question(chalk_1.default.yellow('Allow? [y/N] '), (answer) => {
+                const allowed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+                resolve(allowed);
+            });
+        });
+    }
+    async addFileToContext(filePath) {
+        const file = this.fileUtils.readFile(filePath);
+        if (!file) {
+            this.logger.error(`File not found: ${filePath}`);
+            return;
+        }
+        // Add file content to messages
+        const fileMessage = {
+            role: 'user',
+            content: `Here is the content of ${file.relativePath} (${file.language}, ${file.lines} lines):\n\n\`\`\`${file.language}\n${file.content}\n\`\`\``,
+        };
+        this.messages.push(fileMessage);
+        this.logger.success(`Added ${file.relativePath} to context (${file.lines} lines)`);
+    }
+    async startEditMode(filePath, model) {
+        const file = this.fileUtils.readFile(filePath);
+        if (!file) {
+            this.logger.error(`File not found: ${filePath}`);
+            return null;
+        }
+        console.log();
+        this.logger.section(`Editing: ${file.relativePath}`);
+        console.log(chalk_1.default.gray('What changes would you like to make?'));
+        console.log();
+        // This would enter a sub-REPL for editing
+        // For now, return the file info
+        return { file: file.path, content: file.content };
+    }
+    showPendingDiff(changes) {
+        const file = this.fileUtils.readFile(changes.file);
+        if (!file)
+            return;
+        const diff = this.fileUtils.createDiff(file.content, changes.content);
+        this.logger.section('Pending Changes');
+        this.logger.diff(diff.added, diff.removed);
+    }
+    applyChanges(changes) {
+        // Backup first
+        const backup = this.fileUtils.backupFile(changes.file);
+        if (backup) {
+            this.logger.info(`Backup created: ${backup}`);
+        }
+        // Apply
+        if (this.fileUtils.writeFile(changes.file, changes.content)) {
+            this.logger.success(`Changes applied to ${changes.file}`);
+        }
+        else {
+            this.logger.error('Failed to apply changes');
+        }
+    }
+    printHelp() {
+        console.log();
+        this.logger.section('Available Commands');
+        console.log(chalk_1.default.cyan('/file <path>') + '  - Add file to conversation context');
+        console.log(chalk_1.default.cyan('/edit <path>') + '  - Start editing a file');
+        console.log(chalk_1.default.cyan('/diff') + '         - Show pending changes');
+        console.log(chalk_1.default.cyan('/apply') + '        - Apply pending changes');
+        console.log(chalk_1.default.cyan('/model <name>') + ' - Switch AI model');
+        console.log(chalk_1.default.cyan('/agent') + '        - Toggle agentic mode (Claude Code-like)');
+        console.log(chalk_1.default.cyan('/approve') + '      - Toggle auto-approve for agent actions');
+        console.log(chalk_1.default.cyan('/undo') + '         - Undo last file operation (agent mode)');
+        console.log(chalk_1.default.cyan('/clear') + '        - Clear conversation history');
+        console.log(chalk_1.default.cyan('/compact') + '      - Compact context (summarize older messages)');
+        console.log(chalk_1.default.cyan('/sessions') + '     - List saved sessions');
+        console.log(chalk_1.default.cyan('/history') + '      - Show conversation history');
+        console.log(chalk_1.default.cyan('/save') + '         - Save current session');
+        console.log(chalk_1.default.cyan('/new') + '          - Start new session');
+        console.log(chalk_1.default.cyan('/help') + '         - Show this help');
+        console.log(chalk_1.default.cyan('/exit') + '         - Exit Vigthoria (auto-saves)');
+        console.log();
+        if (this.agentMode) {
+            console.log(chalk_1.default.yellow('Agent Mode Tools:'));
+            console.log(chalk_1.default.gray('  read_file, write_file, edit_file, bash, grep, list_dir, glob, git'));
+            console.log();
+        }
+    }
+    listSessions() {
+        const sessions = this.sessionManager.list();
+        console.log();
+        this.logger.section('Saved Sessions');
+        if (sessions.length === 0) {
+            console.log(chalk_1.default.gray('  No saved sessions'));
+        }
+        else {
+            sessions.slice(0, 10).forEach(s => {
+                const current = this.currentSession?.id === s.id ? chalk_1.default.green(' (current)') : '';
+                const agent = s.agentMode ? chalk_1.default.yellow(' [agent]') : '';
+                console.log(chalk_1.default.cyan(s.id) + agent + current);
+                console.log(chalk_1.default.gray(`  ${s.project} - ${new Date(s.updatedAt).toLocaleString()}`));
+            });
+        }
+        console.log();
+    }
+    showHistory() {
+        console.log();
+        this.logger.section('Conversation History');
+        const userMessages = this.messages.filter(m => m.role !== 'system');
+        if (userMessages.length === 0) {
+            console.log(chalk_1.default.gray('  No messages yet'));
+        }
+        else {
+            userMessages.forEach((m, i) => {
+                const role = m.role === 'user' ? chalk_1.default.cyan('you') : chalk_1.default.green('vigthoria');
+                const preview = m.content.substring(0, 60).replace(/\n/g, ' ');
+                console.log(`${i + 1}. ${role}: ${chalk_1.default.gray(preview)}...`);
+            });
+        }
+        console.log();
+    }
+    async compactContext(model) {
+        // If we have too many messages, summarize older ones
+        if (this.messages.length < 10) {
+            this.logger.info('Context is already compact');
+            return;
+        }
+        const spinner = (0, ora_1.default)({
+            text: chalk_1.default.gray('Compacting context...'),
+            spinner: 'dots',
+        }).start();
+        try {
+            // Keep system message and last 4 messages
+            const systemMessage = this.messages[0];
+            const recentMessages = this.messages.slice(-4);
+            const olderMessages = this.messages.slice(1, -4);
+            if (olderMessages.length === 0) {
+                spinner.stop();
+                this.logger.info('Nothing to compact');
+                return;
+            }
+            // Ask AI to summarize older conversation
+            const summaryResponse = await this.api.chat([
+                { role: 'system', content: 'Summarize this conversation in a concise way, preserving key context and decisions.' },
+                ...olderMessages,
+            ], model, this.localMode);
+            // Create compacted context
+            this.messages = [
+                systemMessage,
+                { role: 'system', content: `[Previous conversation summary]: ${summaryResponse.message}` },
+                ...recentMessages,
+            ];
+            spinner.stop();
+            this.logger.success(`Compacted ${olderMessages.length} messages into summary`);
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error('Failed to compact context:', error.message);
+        }
+    }
+    printModels() {
+        const models = this.config.getAvailableModels();
+        console.log();
+        this.logger.section('Available Models');
+        models.forEach(m => {
+            console.log(chalk_1.default.cyan(m.id.padEnd(20)) + chalk_1.default.gray(m.description));
+        });
+        console.log();
+    }
+}
+exports.ChatCommand = ChatCommand;
+//# sourceMappingURL=chat.js.map