atena-cli 0.1.0

package/dist/agent.js

@@ -0,0 +1,731 @@
+import { OllamaClient } from './ollama-client.js';
+import { tools, toolMap } from './tools/index.js';
+import { SpinnerManager, renderHeader, renderStatusBar, renderWelcome, renderUserMessage, renderAssistantMessage, renderToolCall, renderToolResult, renderSystemMessage, colors, icons, boxify, } from './ui.js';
+import { ContextManager } from './context.js';
+import { parseSlashCommand, parseMentions } from './commands.js';
+import { realtimeInput } from './realtime-input.js';
+import { detectSkills, getActiveSkillsInfo, buildEnhancedPrompt } from './skills.js';
+import { AgentManager, formatAgentName } from './agents.js';
+import { SessionManager } from './sessions.js';
+import { PermissionManager, parsePermissionsFromEnv } from './permissions.js';
+import { statsTracker } from './stats.js';
+import { MCPManager } from './mcp.js';
+export class AtenaAgent {
+    client;
+    options;
+    messages = [];
+    transcript = [];
+    ollamaTools;
+    spinner;
+    context;
+    agentManager;
+    sessionManager;
+    permissionManager;
+    statsTracker;
+    mcpManager;
+    constructor(options) {
+        this.options = options;
+        this.client = new OllamaClient(options.ollamaUrl);
+        this.ollamaTools = this.client.toOllamaTools(tools.map(t => t.definition));
+        this.spinner = new SpinnerManager();
+        this.context = new ContextManager();
+        this.agentManager = new AgentManager('build');
+        this.sessionManager = new SessionManager();
+        this.permissionManager = new PermissionManager(parsePermissionsFromEnv());
+        this.statsTracker = statsTracker;
+        this.statsTracker.startSession(`session_${Date.now()}`, options.model);
+        this.mcpManager = new MCPManager();
+        if (options.systemPrompt) {
+            const effectivePrompt = this.agentManager.getEffectiveSystemPrompt(options.systemPrompt);
+            this.messages.push({
+                role: 'system',
+                content: effectivePrompt,
+            });
+        }
+    }
+    renderAgentStatus() {
+        const agent = this.agentManager.getCurrentAgent();
+        console.log(colors.muted(`  ${icons.agent} Agente: ${formatAgentName(agent)} | Tab para cambiar`));
+    }
+    switchAgent(agentId) {
+        const success = this.agentManager.switchAgent(agentId);
+        if (success) {
+            const agent = this.agentManager.getCurrentAgent();
+            console.log(colors.success(`  ✓ Cambiado a agente: ${formatAgentName(agent)}`));
+            // Update system message with new agent prompt
+            if (this.messages.length > 0 && this.messages[0].role === 'system') {
+                const basePrompt = this.options.systemPrompt || '';
+                this.messages[0].content = this.agentManager.getEffectiveSystemPrompt(basePrompt);
+            }
+        }
+        return success;
+    }
+    listAgents() {
+        console.log(colors.primary('\n  Agentes disponibles:'));
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        for (const agent of this.agentManager.listAgents()) {
+            const isCurrent = agent.id === this.agentManager.getCurrentAgent().id;
+            const marker = isCurrent ? colors.success('● ') : '  ';
+            console.log(`${marker}${formatAgentName(agent)} - ${colors.muted(agent.description)}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(colors.muted('  Usa: /agent <nombre> para cambiar\n'));
+    }
+    // Session management methods
+    async listSessions() {
+        const sessions = await this.sessionManager.listSessions(10);
+        if (sessions.length === 0) {
+            console.log(colors.muted('\n  No hay sesiones guardadas.\n'));
+            return;
+        }
+        console.log(colors.primary('\n  Sesiones recientes:'));
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        for (let i = 0; i < sessions.length; i++) {
+            const session = sessions[i];
+            const date = new Date(session.updatedAt).toLocaleString('es-ES', {
+                day: '2-digit',
+                month: 'short',
+                hour: '2-digit',
+                minute: '2-digit',
+            });
+            console.log(`  ${i + 1}. ${colors.cyan(session.title)}`);
+            console.log(`     ${colors.muted(`Modelo: ${session.model} | Mensajes: ${session.messageCount} | ${date}`)}`);
+            if (session.preview) {
+                console.log(`     ${colors.dim(session.preview)}`);
+            }
+        }
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        console.log(colors.muted('  Usa: /session load <número> para cargar\n'));
+    }
+    async saveSession(name) {
+        const currentId = this.sessionManager.getCurrentSessionId();
+        if (currentId) {
+            // Update existing session
+            await this.sessionManager.updateCurrentSession(this.messages);
+            console.log(colors.success(`  ✓ Sesión actualizada: ${colors.cyan(currentId)}`));
+        }
+        else {
+            // Create new session
+            const session = await this.sessionManager.createSession(this.messages, this.options.model, this.agentManager.getCurrentAgent().id, process.cwd());
+            this.sessionManager.setCurrentSessionId(session.id);
+            console.log(colors.success(`  ✓ Sesión guardada: ${colors.cyan(session.title)}`));
+        }
+    }
+    async loadSession(indexOrId) {
+        let session = null;
+        // Check if it's a number (index from list)
+        const index = parseInt(indexOrId, 10);
+        if (!isNaN(index) && index > 0) {
+            const sessions = await this.sessionManager.listSessions(10);
+            if (index <= sessions.length) {
+                session = await this.sessionManager.loadSession(sessions[index - 1].id);
+            }
+        }
+        else {
+            // Treat as ID
+            session = await this.sessionManager.loadSession(indexOrId);
+        }
+        if (!session) {
+            console.log(colors.error(`  ✗ No se encontró la sesión: ${indexOrId}`));
+            return;
+        }
+        // Load session data
+        this.messages = session.messages;
+        this.options.model = session.model;
+        this.sessionManager.setCurrentSessionId(session.id);
+        // Switch to the agent used in the session
+        if (session.metadata.agent) {
+            this.agentManager.switchAgent(session.metadata.agent);
+        }
+        console.log(colors.success(`  ✓ Sesión cargada: ${colors.cyan(session.title)}`));
+        console.log(colors.muted(`     Modelo: ${session.model} | Mensajes: ${session.messages.length}`));
+    }
+    async exportSession(sessionId) {
+        const id = sessionId || this.sessionManager.getCurrentSessionId();
+        if (!id) {
+            console.log(colors.error('  ✗ No hay sesión activa para exportar'));
+            return;
+        }
+        const exportPath = await this.sessionManager.exportSession(id);
+        if (exportPath) {
+            console.log(colors.success(`  ✓ Sesión exportada a: ${colors.cyan(exportPath)}`));
+        }
+        else {
+            console.log(colors.error('  ✗ Error al exportar sesión'));
+        }
+    }
+    async deleteSession(sessionId) {
+        const success = await this.sessionManager.deleteSession(sessionId);
+        if (success) {
+            console.log(colors.success(`  ✓ Sesión eliminada: ${colors.cyan(sessionId)}`));
+        }
+        else {
+            console.log(colors.error(`  ✗ No se pudo eliminar la sesión: ${sessionId}`));
+        }
+    }
+    // MCP management methods
+    async listMCPServers() {
+        const servers = this.mcpManager.listServers();
+        const connections = this.mcpManager.listConnections();
+        if (servers.length === 0) {
+            console.log(colors.muted('\n  No hay servidores MCP configurados.\n'));
+            console.log(colors.muted('  Usa: /mcp add para agregar uno\n'));
+            return;
+        }
+        console.log(colors.primary('\n  Servidores MCP:'));
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        for (const server of servers) {
+            const connection = connections.find(c => c.name === server.name);
+            const authStatus = this.mcpManager.getAuthStatus(server.name);
+            let statusIcon = '○';
+            let statusColor = colors.muted;
+            if (connection?.status === 'connected') {
+                statusIcon = '●';
+                statusColor = colors.success;
+            }
+            else if (connection?.status === 'error') {
+                statusIcon = '✗';
+                statusColor = colors.error;
+            }
+            console.log(`  ${statusColor(statusIcon)} ${colors.cyan(server.name)} (${server.type})`);
+            console.log(`     ${colors.muted(`Habilitado: ${server.enabled ? 'sí' : 'no'}`)}`);
+            if (authStatus.hasOAuth) {
+                console.log(`     ${colors.muted(`Auth: ${authStatus.authenticated ? '✓' : '○'}`)}`);
+            }
+            if (connection?.tools.length) {
+                console.log(`     ${colors.muted(`Tools: ${connection.tools.join(', ')}`)}`);
+            }
+        }
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        console.log(colors.muted('  Usa: /mcp auth <nombre> para autenticar\n'));
+    }
+    async addMCPServer() {
+        await this.mcpManager.setupWizard();
+        console.log(colors.success('\n  ✓ Wizard de configuración MCP iniciado'));
+        console.log(colors.muted('  (Implementación completa requiere configuración manual)\n'));
+    }
+    async authenticateMCP(serverName) {
+        const success = await this.mcpManager.authenticate(serverName);
+        if (success) {
+            console.log(colors.success(`  ✓ Autenticado con: ${colors.cyan(serverName)}`));
+        }
+        else {
+            console.log(colors.error(`  ✗ No se pudo autenticar con: ${serverName}`));
+        }
+    }
+    async removeMCPServer(serverName) {
+        const success = await this.mcpManager.removeServer(serverName);
+        if (success) {
+            console.log(colors.success(`  ✓ Servidor MCP eliminado: ${colors.cyan(serverName)}`));
+        }
+        else {
+            console.log(colors.error(`  ✗ No se encontró el servidor: ${serverName}`));
+        }
+    }
+    // Permission management methods
+    async setPermission(type, level) {
+        const validLevels = ['ask', 'auto', 'deny'];
+        if (!validLevels.includes(level)) {
+            console.log(colors.error(`  ✗ Nivel inválido. Use: ask, auto, deny`));
+            return;
+        }
+        this.permissionManager.setPermissions({ [type]: level });
+        console.log(colors.success(`  ✓ Permiso ${type} configurado: ${level}`));
+    }
+    showPermissions() {
+        const perms = this.permissionManager.getPermissions();
+        console.log(colors.primary('\n  Permisos actuales:'));
+        console.log(colors.muted('  ' + '─'.repeat(40)));
+        console.log(`  fileWrite: ${perms.fileWrite}`);
+        console.log(`  fileDelete: ${perms.fileDelete}`);
+        console.log(`  bash: ${perms.bash}`);
+        console.log(`  network: ${perms.network}`);
+        console.log(colors.muted('  ' + '─'.repeat(40)));
+        console.log(colors.muted('  Usa: /permission <tipo> <nivel>\n'));
+    }
+    async showStats() {
+        const stats = await this.statsTracker.getStats(7);
+        console.log(colors.primary('\n  📊 Estadísticas de uso (últimos 7 días):'));
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(`  Sesiones: ${colors.cyan(stats.totalSessions.toString())}`);
+        console.log(`  Tokens totales: ${colors.cyan(this.statsTracker.formatTokens(stats.totalTokens))}`);
+        console.log(`  Costo estimado: ${colors.cyan(this.statsTracker.formatCurrency(stats.totalCost))}`);
+        if (Object.keys(stats.modelBreakdown).length > 0) {
+            console.log(colors.muted('  ' + '─'.repeat(50)));
+            console.log(colors.primary('  Por modelo:'));
+            for (const [model, data] of Object.entries(stats.modelBreakdown)) {
+                console.log(`    ${colors.cyan(model)}: ${this.statsTracker.formatTokens(data.tokens)} tokens, ${this.statsTracker.formatCurrency(data.cost)}`);
+            }
+        }
+        if (Object.keys(stats.toolBreakdown).length > 0) {
+            console.log(colors.muted('  ' + '─'.repeat(50)));
+            console.log(colors.primary('  Tools más usados:'));
+            const sortedTools = Object.entries(stats.toolBreakdown).sort((a, b) => b[1] - a[1]).slice(0, 5);
+            for (const [tool, count] of sortedTools) {
+                console.log(`    ${colors.cyan(tool)}: ${count} usos`);
+            }
+        }
+        // Current session stats
+        const currentStats = this.statsTracker.getCurrentSessionStats();
+        if (currentStats) {
+            console.log(colors.muted('  ' + '─'.repeat(50)));
+            console.log(colors.primary('  Sesión actual:'));
+            console.log(`    Tokens: ${this.statsTracker.formatTokens(currentStats.tokenUsage.totalTokens)}`);
+            console.log(`    Costo: ${this.statsTracker.formatCurrency(currentStats.tokenUsage.cost)}`);
+            console.log(`    Mensajes: ${currentStats.messages}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log();
+    }
+    showStatus() {
+        const agent = this.agentManager.getCurrentAgent();
+        const perms = this.permissionManager.getPermissions();
+        const currentStats = this.statsTracker.getCurrentSessionStats();
+        const fileCount = this.context.getAttachmentCount();
+        console.log(colors.primary('\n  ⚡ Estado actual de Atena CLI'));
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(`  Modelo:    ${colors.cyan(this.options.model)}`);
+        console.log(`  Agente:    ${formatAgentName(agent)}`);
+        console.log(`  CWD:       ${colors.muted(this.options.cwd)}`);
+        console.log(`  Archivos:  ${fileCount > 0 ? colors.cyan(String(fileCount)) : colors.muted('0')}`);
+        if (currentStats) {
+            console.log(`  Mensajes:  ${colors.cyan(String(currentStats.messages))}`);
+            console.log(`  Tokens:    ${colors.cyan(this.statsTracker.formatTokens(currentStats.tokenUsage.totalTokens))}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(`  Permisos:  write=${perms.fileWrite} | delete=${perms.fileDelete} | bash=${perms.bash} | net=${perms.network}`);
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log();
+    }
+    log(entry) {
+        this.transcript.push(entry);
+        this.renderEntry(entry);
+    }
+    renderEntry(entry) {
+        switch (entry.kind) {
+            case 'assistant':
+                this.spinner.stop();
+                renderAssistantMessage(entry.text);
+                break;
+            case 'thinking':
+                this.spinner.update(entry.text);
+                break;
+            case 'user':
+                renderUserMessage(entry.text);
+                break;
+            case 'tool_call':
+                this.spinner.stop();
+                renderToolCall(entry.name, (entry.input || {}));
+                break;
+            case 'tool_result':
+                this.spinner.stop();
+                renderToolResult({
+                    status: entry.isError ? 'error' : 'success',
+                    output: entry.content,
+                    error: entry.isError ? entry.content : undefined
+                });
+                break;
+            case 'system':
+                renderSystemMessage(entry.text);
+                break;
+            case 'stderr':
+                console.log(colors.error(`${icons.error} ${entry.text}`));
+                break;
+            case 'stdout':
+                if (this.options.debug) {
+                    console.log(colors.muted(`${entry.text}`));
+                }
+                break;
+        }
+    }
+    async executeTool(call) {
+        const toolName = call.function.name;
+        const toolArgs = call.function.arguments;
+        const tool = toolMap.get(toolName);
+        if (!tool) {
+            return {
+                status: 'error',
+                error: `Unknown tool: ${toolName}`,
+            };
+        }
+        // Check permissions for sensitive operations
+        let permissionType = null;
+        let permissionDesc = '';
+        let permissionDetails = '';
+        switch (toolName) {
+            case 'write_file':
+                permissionType = 'fileWrite';
+                permissionDesc = 'Escribir archivo';
+                permissionDetails = toolArgs.file_path;
+                break;
+            case 'edit_file':
+                permissionType = 'fileWrite';
+                permissionDesc = 'Editar archivo';
+                permissionDetails = toolArgs.file_path;
+                break;
+            case 'run_command':
+                permissionType = 'bash';
+                permissionDesc = 'Ejecutar comando shell';
+                permissionDetails = toolArgs.command;
+                break;
+            case 'view_url':
+            case 'web_search':
+            case 'browser':
+                permissionType = 'network';
+                permissionDesc = `Tool: ${toolName}`;
+                break;
+        }
+        if (permissionType) {
+            const allowed = await this.permissionManager.checkPermission({
+                type: permissionType,
+                tool: toolName,
+                description: permissionDesc,
+                details: permissionDetails,
+            });
+            if (!allowed) {
+                return {
+                    status: 'error',
+                    error: `Permiso denegado: ${permissionDesc}`,
+                };
+            }
+        }
+        try {
+            // Record tool usage for stats
+            this.statsTracker.recordToolUsage(toolName);
+            return await Promise.resolve(tool.handler(toolArgs));
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    renderContextStatus() {
+        if (this.context.hasAttachments()) {
+            const files = this.context.getAttachedFiles();
+            const fileList = files.map(f => colors.yellow(`@${f.path.split('/').pop()}`)).join(' ');
+            console.log(colors.muted(`  ${icons.file} Contexto: ${fileList} (${this.context.getTotalSize() / 1024}KB)`));
+        }
+    }
+    renderActiveSkills(prompt) {
+        const { names, count } = getActiveSkillsInfo(prompt);
+        if (count > 0) {
+            const skillsList = names.map(n => colors.primary(n)).join(', ');
+            console.log(colors.muted(`  ${icons.sparkle} Skills activas: ${skillsList}`));
+        }
+    }
+    async processInput(userInput) {
+        // Check for slash commands
+        const slashCmd = parseSlashCommand(userInput);
+        if (slashCmd && slashCmd.command) {
+            const result = await slashCmd.command.execute(slashCmd.args, this.context);
+            // Handle special commands
+            if (result === 'CLEAR_SCREEN') {
+                console.clear();
+                renderHeader();
+                renderStatusBar(this.options.model, tools.length);
+                return null;
+            }
+            if (result.startsWith('CHANGE_MODEL:')) {
+                const newModel = result.split(':')[1];
+                this.options.model = newModel;
+                console.log(colors.success(`${icons.success} Modelo cambiado a: ${newModel}`));
+                renderStatusBar(this.options.model, tools.length);
+                return null;
+            }
+            if (result === 'AGENT_LIST') {
+                this.listAgents();
+                return null;
+            }
+            if (result.startsWith('CHANGE_AGENT:')) {
+                const agentId = result.split(':')[1];
+                this.switchAgent(agentId);
+                return null;
+            }
+            // Session commands
+            if (result === 'SESSION_LIST') {
+                await this.listSessions();
+                return null;
+            }
+            if (result === 'SESSION_SAVE') {
+                await this.saveSession();
+                return null;
+            }
+            if (result.startsWith('SESSION_LOAD:')) {
+                const sessionId = result.split(':')[1];
+                await this.loadSession(sessionId);
+                return null;
+            }
+            if (result.startsWith('SESSION_EXPORT:')) {
+                const sessionId = result.split(':')[1];
+                await this.exportSession(sessionId || undefined);
+                return null;
+            }
+            if (result.startsWith('SESSION_DELETE:')) {
+                const sessionId = result.split(':')[1];
+                await this.deleteSession(sessionId);
+                return null;
+            }
+            // Permission commands
+            if (result === 'PERMISSION_SHOW') {
+                this.showPermissions();
+                return null;
+            }
+            if (result.startsWith('PERMISSION_SET:')) {
+                const parts = result.split(':');
+                const type = parts[1];
+                const level = parts[2];
+                await this.setPermission(type, level);
+                return null;
+            }
+            if (result === 'STATS_SHOW') {
+                await this.showStats();
+                return null;
+            }
+            if (result === 'STATUS_SHOW') {
+                this.showStatus();
+                return null;
+            }
+            // MCP commands
+            if (result === 'MCP_LIST') {
+                await this.listMCPServers();
+                return null;
+            }
+            if (result === 'MCP_ADD') {
+                await this.addMCPServer();
+                return null;
+            }
+            if (result.startsWith('MCP_AUTH:')) {
+                const serverName = result.split(':')[1];
+                await this.authenticateMCP(serverName);
+                return null;
+            }
+            if (result.startsWith('MCP_REMOVE:')) {
+                const serverName = result.split(':')[1];
+                await this.removeMCPServer(serverName);
+                return null;
+            }
+            // Workflow commands
+            if (result === 'WORKFLOW_LIST') {
+                const path = await import('node:path');
+                const fs = await import('node:fs/promises');
+                const wfDir = path.join(this.options.cwd, '.atena', 'workflows');
+                try {
+                    const files = await fs.readdir(wfDir);
+                    const mds = files.filter(f => f.endsWith('.md') || f.endsWith('.yaml'));
+                    console.log(colors.primary('\n  Flujos de trabajo disponibles en .atena/workflows/:'));
+                    if (mds.length === 0)
+                        console.log(colors.muted('  No hay flujos. Crea archivos .md en este directorio.'));
+                    for (const f of mds) {
+                        console.log(`  • ${f.replace(/\.(md|yaml)$/, '')}`);
+                    }
+                }
+                catch {
+                    console.log(colors.muted('\n  No hay flujos. Crea la carpeta .atena/workflows/ y añade archivos .md'));
+                }
+                return null;
+            }
+            if (result.startsWith('WORKFLOW_RUN:')) {
+                const flowName = result.split(':')[1];
+                await this.runWorkflow(flowName);
+                return null;
+            }
+            // Display command result
+            console.log(boxify(result, { style: 'round', color: colors.info, title: ' Comando ' }));
+            return null;
+        }
+        // Parse @ mentions
+        const { cleanedInput, mentions } = parseMentions(userInput);
+        // Attach mentioned files
+        if (mentions.length > 0) {
+            for (const mention of mentions) {
+                const result = await this.context.attachFile(mention);
+                if (result.success) {
+                    console.log(colors.success(`  ${icons.success} ${result.message}`));
+                }
+                else {
+                    console.log(colors.error(`  ${icons.error} ${result.message}`));
+                }
+            }
+        }
+        // Build final prompt with context
+        let finalPrompt = cleanedInput;
+        if (this.context.hasAttachments()) {
+            finalPrompt += this.context.getContextString();
+        }
+        return finalPrompt || null;
+    }
+    async runWorkflow(name) {
+        const path = await import('node:path');
+        const fs = await import('node:fs/promises');
+        const wfPath = path.join(this.options.cwd, '.atena', 'workflows', `${name}.md`);
+        let content;
+        try {
+            content = await fs.readFile(wfPath, 'utf8');
+        }
+        catch {
+            console.log(colors.error(`  ✗ No se encontró el flujo: ${name}.md (en .atena/workflows/)`));
+            return;
+        }
+        const lines = content.split('\n')
+            .map(l => l.trim())
+            .filter(l => l && !l.startsWith('#') && !l.startsWith('//'));
+        console.log(colors.success(`\n  🚀 Iniciando flujo: ${name} (${lines.length} pasos)`));
+        for (let i = 0; i < lines.length; i++) {
+            const step = lines[i];
+            console.log(colors.system(`\n  🔄 [Paso ${i + 1}/${lines.length}] Iniciando...`));
+            // Re-trigger the input directly
+            await this.runSingleTurn(step);
+        }
+        console.log(colors.success(`\n  ✨ Flujo completado exitosamente: ${name}\n`));
+    }
+    async runSingleTurn(userInput) {
+        const finalPrompt = await this.processInput(userInput);
+        if (!finalPrompt)
+            return;
+        // Display current agent and active skills
+        this.renderAgentStatus();
+        this.renderActiveSkills(userInput);
+        const now = new Date().toISOString();
+        this.log({
+            kind: 'user',
+            ts: now,
+            text: userInput,
+        });
+        // Build messages array with skill-enhanced system prompt if needed
+        const detectedSkills = detectSkills(userInput);
+        let messagesToSend = this.messages;
+        if (detectedSkills.length > 0 && this.options.systemPrompt) {
+            // Create enhanced system prompt with skills
+            const enhancedPrompt = buildEnhancedPrompt(this.options.systemPrompt, userInput);
+            messagesToSend = [
+                { role: 'system', content: enhancedPrompt },
+                ...this.messages.slice(1) // Keep rest of conversation
+            ];
+        }
+        this.messages.push({
+            role: 'user',
+            content: finalPrompt,
+        });
+        messagesToSend.push({
+            role: 'user',
+            content: finalPrompt,
+        });
+        let assistantContent = '';
+        const toolCalls = [];
+        try {
+            if (this.options.debug) {
+                console.log(colors.muted('Calling Ollama API...'));
+            }
+            this.spinner.start('Pensando...');
+            const stream = this.client.chatStream({
+                model: this.options.model,
+                messages: messagesToSend,
+                tools: this.ollamaTools,
+                stream: true,
+            });
+            for await (const chunk of stream) {
+                if (chunk.message?.content) {
+                    assistantContent += chunk.message.content;
+                    if (!this.options.interactive) {
+                        process.stdout.write(chunk.message.content);
+                    }
+                }
+                if (chunk.message?.tool_calls) {
+                    for (const call of chunk.message.tool_calls) {
+                        toolCalls.push(call);
+                    }
+                }
+            }
+            if (!this.options.interactive) {
+                process.stdout.write('\n');
+            }
+            this.spinner.stop();
+            if (assistantContent.trim()) {
+                this.log({
+                    kind: 'assistant',
+                    ts: new Date().toISOString(),
+                    text: assistantContent,
+                });
+                // Estimate and record token usage
+                // Rough estimate: ~4 chars per token for input, ~4 for output
+                const inputTokens = Math.ceil(finalPrompt.length / 4);
+                const outputTokens = Math.ceil(assistantContent.length / 4);
+                this.statsTracker.recordMessage(inputTokens, outputTokens, this.options.model);
+            }
+            if (toolCalls.length > 0) {
+                for (const call of toolCalls) {
+                    const toolCallId = `call_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+                    this.log({
+                        kind: 'tool_call',
+                        ts: new Date().toISOString(),
+                        name: call.function.name,
+                        input: call.function.arguments,
+                        toolUseId: toolCallId,
+                    });
+                    this.spinner.start(`Ejecutando ${call.function.name}...`);
+                    const result = await this.executeTool(call);
+                    this.spinner.stop();
+                    this.log({
+                        kind: 'tool_result',
+                        ts: new Date().toISOString(),
+                        toolUseId: toolCallId,
+                        toolName: call.function.name,
+                        content: result.output || result.error || '',
+                        isError: result.status === 'error',
+                    });
+                    this.messages.push({
+                        role: 'assistant',
+                        content: '',
+                        tool_calls: [call],
+                    });
+                    this.messages.push({
+                        role: 'tool',
+                        content: result.output || result.error || '',
+                    });
+                }
+                await this.runSingleTurn('');
+            }
+            else {
+                this.messages.push({
+                    role: 'assistant',
+                    content: assistantContent,
+                });
+            }
+        }
+        catch (err) {
+            this.spinner.stop();
+            this.log({
+                kind: 'system',
+                ts: new Date().toISOString(),
+                text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async runInteractive() {
+        // Render modern header
+        renderHeader();
+        renderWelcome(this.options.model, tools.length);
+        renderStatusBar(this.options.model, tools.length);
+        while (true) {
+            const input = await realtimeInput(colors.user(`${icons.user} Tú: `));
+            if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+                console.log();
+                console.log(boxify(`${colors.success('¡Gracias por usar Atena!')} ${icons.sparkle}\n\n` +
+                    `${colors.muted('Sesión guardada. Puedes retomarla más tarde.')}`, { style: 'round', color: colors.success }));
+                console.log();
+                break;
+            }
+            if (input.trim()) {
+                await this.runSingleTurn(input);
+                this.renderContextStatus();
+                renderStatusBar(this.options.model, tools.length);
+            }
+        }
+    }
+    getTranscript() {
+        return [...this.transcript];
+    }
+}
+//# sourceMappingURL=agent.js.map