apexbot 1.0.9 → 1.1.1

package/dist/agent/agentManager.js

@@ -6,15 +6,23 @@
  *
  * Enhanced with Moltbot-style brain system for personality and memory.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentManager = void 0;
 const generative_ai_1 = require("@google/generative-ai");
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const openai_1 = __importDefault(require("openai"));
 const tools_1 = require("../tools");
 const brain_1 = require("../brain");
 const toolExecutor_1 = require("./toolExecutor");
+const debug_1 = require("../core/debug");
 class AgentManager {
     config = null;
     googleClient = null;
+    anthropicClient = null;
+    openaiClient = null;
     brain = null;
     // Moltbot-style model fallback chain
     fallbackModels = [
@@ -65,7 +73,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
      */
     setBrain(brain) {
         this.brain = brain;
-        console.log('[Agent] Brain connected');
+        (0, debug_1.debug)('Agent', 'Brain connected');
     }
     configure(config) {
         this.config = {
@@ -87,11 +95,31 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                 console.warn('[Agent] Google provider selected but no API key provided — Gemini will be unavailable until configured.');
             }
         }
+        // Initialize Anthropic Claude client
+        if (config.provider === 'anthropic') {
+            const claudeKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+            if (claudeKey) {
+                this.anthropicClient = new sdk_1.default({ apiKey: claudeKey });
+            }
+            else {
+                console.warn('[Agent] Anthropic provider selected but no API key provided — Claude will be unavailable.');
+            }
+        }
+        // Initialize OpenAI client
+        if (config.provider === 'openai') {
+            const openaiKey = config.apiKey || process.env.OPENAI_API_KEY;
+            if (openaiKey) {
+                this.openaiClient = new openai_1.default({ apiKey: openaiKey });
+            }
+            else {
+                console.warn('[Agent] OpenAI provider selected but no API key provided — GPT will be unavailable.');
+            }
+        }
         // Note: Kimi provider uses a generic HTTP endpoint (apiUrl) and apiKey
         if (config.provider === 'kimi') {
             // nothing to initialize here; processWithKimi will use fetch + config.apiUrl
         }
-        console.log(`[Agent] Configured with ${config.provider} (${config.model || 'default model'})`);
+        (0, debug_1.debug)('Agent', `Configured with ${config.provider} (${config.model || 'default model'})`);
     }
     async process(session, message) {
         if (!this.config) {
@@ -99,7 +127,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             return { text: 'Agent not configured. Please set up an AI provider.' };
         }
         const userText = message.text || '';
-        console.log(`[Agent] Processing message: ${userText.slice(0, 50)}...`);
+        (0, debug_1.debug)('Agent', `Processing message: ${userText.slice(0, 50)}...`);
         // Handle slash commands
         if (userText.startsWith('/')) {
             return this.handleCommand(session, userText);
@@ -123,9 +151,9 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                         if (fallback.provider === this.config.provider)
                             continue;
                         try {
-                            console.log(`[Agent] Trying fallback: ${fallback.provider}/${fallback.model}`);
+                            (0, debug_1.debug)('Agent', `Trying fallback: ${fallback.provider}/${fallback.model}`);
                             response = await this.processWithProvider(fallback.provider, fallback.model, history);
-                            console.log(`[Agent] Fallback ${fallback.provider} succeeded!`);
+                            (0, debug_1.debug)('Agent', `Fallback ${fallback.provider} succeeded!`);
                             lastError = null;
                             break;
                         }
@@ -145,7 +173,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             if (this.config.enableTools) {
                 const toolCalls = (0, toolExecutor_1.parseToolCalls)(response.text);
                 if (toolCalls.length > 0) {
-                    console.log(`[Agent] Found ${toolCalls.length} tool calls:`, toolCalls.map(t => t.name));
+                    (0, debug_1.debug)('Agent', `Found ${toolCalls.length} tool calls:`, toolCalls.map(t => t.name));
                     // Build tool context
                     const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || message.from || 'unknown', message.channel, { workspaceDir: process.cwd() });
                     // Execute tools
@@ -153,9 +181,9 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                     response.toolCalls = toolResults;
                     // Log results
                     for (const { call, result } of toolResults) {
-                        console.log(`[Agent] Tool ${call.name}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+                        (0, debug_1.debug)('Agent', `Tool ${call.name}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
                         if (!result.success)
-                            console.log(`[Agent] Error: ${result.error}`);
+                            (0, debug_1.debug)('Agent', `Error: ${result.error}`);
                     }
                     // Format results and continue conversation
                     const resultsText = (0, toolExecutor_1.formatToolResults)(toolResults);
@@ -193,7 +221,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                     }
                 }
             }
-            console.log(`[Agent] Generated response: ${response.text.slice(0, 50)}...`);
+            (0, debug_1.debug)('Agent', `Generated response: ${response.text.slice(0, 50)}...`);
             // Save to session (initialize messages array if needed)
             if (!session.messages)
                 session.messages = [];
@@ -351,7 +379,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
         const apiUrl = cfg.apiUrl || 'http://localhost:11434';
         const model = cfg.model || 'llama3.2';
         const temperature = cfg.temperature ?? 0.7;
-        console.log(`[Agent] Calling Ollama at ${apiUrl} with model ${model}...`);
+        (0, debug_1.debug)('Agent', `Calling Ollama at ${apiUrl} with model ${model}...`);
         // Build messages array for Ollama chat API
         const messages = history.map(m => ({
             role: m.role,
@@ -380,7 +408,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             }
             const data = await res.json();
             const text = data.message?.content || '';
-            console.log(`[Agent] Ollama response received: ${text.slice(0, 50)}...`);
+            (0, debug_1.debug)('Agent', `Ollama response received: ${text.slice(0, 50)}...`);
             return {
                 text: String(text).trim() || 'No response from model',
                 usage: {
@@ -432,7 +460,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             try {
                 // Build full system prompt from brain files
                 systemPrompt = await this.brain.buildSystemPrompt(this.defaultSystemPrompt);
-                console.log('[Agent] Using brain context for system prompt');
+                (0, debug_1.debug)('Agent', 'Using brain context for system prompt');
             }
             catch (e) {
                 console.warn('[Agent] Failed to load brain context, using default');
@@ -494,14 +522,77 @@ You are running locally on the user's machine. No data leaves their computer. Yo
         };
     }
     async processWithClaude(history) {
-        // TODO: Implement Anthropic Claude API
-        // Requires @anthropic-ai/sdk
-        return { text: 'Claude integration not yet implemented. Use Google/Gemini for now.' };
+        if (!this.anthropicClient) {
+            return { text: 'Claude API key not configured. Set ANTHROPIC_API_KEY environment variable.' };
+        }
+        // Separate system prompt from messages
+        const systemPrompt = this.config?.systemPrompt || this.defaultSystemPrompt;
+        // Convert messages to Claude format
+        const messages = history
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+            role: m.role === 'user' ? 'user' : 'assistant',
+            content: m.content,
+        }));
+        try {
+            const response = await this.anthropicClient.messages.create({
+                model: this.config?.model || 'claude-sonnet-4-20250514',
+                max_tokens: this.config?.maxTokens || 4096,
+                system: systemPrompt,
+                messages: messages,
+            });
+            // Extract text from response
+            const textContent = response.content.find(c => c.type === 'text');
+            const text = textContent && 'text' in textContent ? textContent.text : '';
+            return {
+                text,
+                usage: {
+                    inputTokens: response.usage.input_tokens,
+                    outputTokens: response.usage.output_tokens,
+                },
+            };
+        }
+        catch (error) {
+            console.error('[Agent] Claude API error:', error.message);
+            return { text: `Claude error: ${error.message}` };
+        }
     }
     async processWithOpenAI(history) {
-        // TODO: Implement OpenAI API
-        // Requires openai package
-        return { text: 'OpenAI integration not yet implemented. Use Google/Gemini for now.' };
+        if (!this.openaiClient) {
+            return { text: 'OpenAI API key not configured. Set OPENAI_API_KEY environment variable.' };
+        }
+        // Convert messages to OpenAI format
+        const systemPrompt = this.config?.systemPrompt || this.defaultSystemPrompt;
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...history
+                .filter(m => m.role !== 'system')
+                .map(m => ({
+                role: m.role === 'user' ? 'user' : 'assistant',
+                content: m.content,
+            })),
+        ];
+        try {
+            const response = await this.openaiClient.chat.completions.create({
+                model: this.config?.model || 'gpt-4o',
+                max_tokens: this.config?.maxTokens || 4096,
+                temperature: this.config?.temperature || 0.7,
+                messages: messages,
+            });
+            const choice = response.choices[0];
+            const text = choice?.message?.content || '';
+            return {
+                text,
+                usage: {
+                    inputTokens: response.usage?.prompt_tokens || 0,
+                    outputTokens: response.usage?.completion_tokens || 0,
+                },
+            };
+        }
+        catch (error) {
+            console.error('[Agent] OpenAI API error:', error.message);
+            return { text: `OpenAI error: ${error.message}` };
+        }
     }
     handleCommand(session, command) {
         const [cmd, ...args] = command.slice(1).split(' ');

package/dist/agent/orchestrator.js

@@ -22,6 +22,7 @@ const allowlist_1 = require("../safety/allowlist");
 const unifiedInbox_1 = require("../channels/unifiedInbox");
 const lobster_1 = require("../lobster");
 const agentManager_1 = require("./agentManager");
+const debug_1 = require("../core/debug");
 const tools_1 = require("../tools");
 /**
  * Agent Orchestrator - Main control loop
@@ -94,7 +95,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 1: INGEST
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 1: INGEST');
+            (0, debug_1.debugPhase)(1, 'INGEST', { message, sessionId });
             this.emit('phase:ingest', { message, sessionId });
             // Get or create session
             const session = await this.sessionStore.getOrCreate(sessionId, userId, channel);
@@ -107,7 +108,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 2: CONTEXT
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 2: CONTEXT');
+            (0, debug_1.debugPhase)(2, 'CONTEXT', { sessionId });
             this.emit('phase:context', { sessionId });
             // Get brain context
             const brainContext = await this.brain.buildSystemPrompt();
@@ -118,7 +119,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             if (this.config.enableRAG) {
                 const searchResults = await this.vectorStore.search(message, this.config.ragTopK, this.config.ragThreshold);
                 memories = searchResults.map(r => r.entry.content);
-                console.log(`[Orchestrator] Found ${memories.length} relevant memories`);
+                (0, debug_1.debug)('Orchestrator', `Found ${memories.length} relevant memories`);
             }
             const context = {
                 sessionId,
@@ -134,7 +135,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 3: INFER
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 3: INFER');
+            (0, debug_1.debugPhase)(3, 'INFER', null);
             this.emit('phase:infer', { context });
             // Build enhanced prompt with memories
             let enhancedMessage = message;
@@ -172,7 +173,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 4: EXECUTE (handled in agent)
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 4: EXECUTE');
+            (0, debug_1.debugPhase)(4, 'EXECUTE', { toolsExecuted: result.toolsExecuted });
             this.emit('phase:execute', { toolsExecuted: result.toolsExecuted });
             // Check for workflow triggers
             const workflowMatch = message.match(/^\/(run|workflow)\s+(\w+)/i);
@@ -190,7 +191,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 5: RESPOND
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 5: RESPOND');
+            (0, debug_1.debugPhase)(5, 'RESPOND', null);
             this.emit('phase:respond', { response: result.response });
             // Store assistant response in session
             await this.sessionStore.appendMessage(sessionId, {

package/dist/agent/toolExecutor.js

@@ -159,18 +159,76 @@ async function executeToolCalls(calls, context) {
 }
 /**
  * Format tool results for inclusion in AI response
+ * Provides clean, readable formatting for different data types
  */
 function formatToolResults(results) {
     if (results.length === 0)
         return '';
     return results.map(({ call, result }) => {
-        const status = result.success ? 'SUCCESS' : 'ERROR';
-        const data = result.success
-            ? JSON.stringify(result.data, null, 2)
-            : result.error;
-        return `[Tool: ${call.name}] ${status}\n${data}`;
+        const status = result.success ? '✅' : '❌';
+        if (!result.success) {
+            return `${status} [${call.name}] Error: ${result.error}`;
+        }
+        // Format data based on type
+        const data = formatToolData(result.data, call.name);
+        return `${status} [${call.name}]\n${data}`;
     }).join('\n\n');
 }
+/**
+ * Format tool data in a human-readable way
+ */
+function formatToolData(data, toolName) {
+    if (data === null || data === undefined) {
+        return 'No data returned';
+    }
+    // Handle specific tool outputs
+    if (toolName === 'get_weather' && data.current) {
+        return `🌡️ ${data.location}: ${data.current.temp}°C, ${data.current.condition}\n` +
+            `💧 Humidity: ${data.current.humidity}%, 💨 Wind: ${data.current.wind} km/h`;
+    }
+    if (toolName === 'search_web' && Array.isArray(data.results)) {
+        return data.results.slice(0, 5).map((r, i) => `${i + 1}. **${r.title}**\n   ${r.snippet || r.description || ''}\n   ${r.url || ''}`).join('\n');
+    }
+    if (toolName === 'get_reminders' && Array.isArray(data)) {
+        if (data.length === 0)
+            return 'No active reminders';
+        return data.map((r) => `⏰ ${r.message} - ${new Date(r.triggerAt).toLocaleString()}`).join('\n');
+    }
+    if (toolName === 'get_calendar_events' && Array.isArray(data)) {
+        if (data.length === 0)
+            return 'No upcoming events';
+        return data.map((e) => `📅 ${e.title} - ${new Date(e.start).toLocaleString()}`).join('\n');
+    }
+    // Handle arrays
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return 'Empty result';
+        if (data.length <= 5) {
+            return data.map((item) => typeof item === 'object' ? JSON.stringify(item, null, 2) : String(item)).join('\n');
+        }
+        return `${data.length} items:\n` + data.slice(0, 5).map((item) => typeof item === 'object' ? JSON.stringify(item) : String(item)).join('\n') + `\n... and ${data.length - 5} more`;
+    }
+    // Handle objects
+    if (typeof data === 'object') {
+        // Try to extract meaningful summary
+        if (data.message)
+            return String(data.message);
+        if (data.result)
+            return String(data.result);
+        if (data.output)
+            return String(data.output);
+        if (data.text)
+            return String(data.text);
+        // Compact JSON for small objects
+        const json = JSON.stringify(data, null, 2);
+        if (json.length < 500)
+            return json;
+        // Summary for large objects
+        const keys = Object.keys(data);
+        return `Object with ${keys.length} keys: ${keys.slice(0, 5).join(', ')}${keys.length > 5 ? '...' : ''}`;
+    }
+    return String(data);
+}
 /**
  * Get the system prompt addition for tool usage
  */
@@ -180,47 +238,48 @@ function getToolsSystemPrompt() {
         return '';
     }
     const toolDescriptions = tools.map(t => {
-        const params = t.parameters.map(p => `  - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`).join('\n');
-        return `- **${t.name}**: ${t.description}`;
+        const params = t.parameters.map(p => `    - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`).join('\n');
+        return `- **${t.name}**: ${t.description}\n  Parameters:\n${params}`;
     }).join('\n');
+    const toolNames = tools.map(t => t.name).join(', ');
     return `
-## TOOLS - IMPORTANT!
+## TOOLS - CRITICAL INSTRUCTIONS
 
-You have tools to interact with the real world. **USE THEM AUTOMATICALLY** when the user asks for something that requires them.
+You have access to specific tools listed below. Use them to perform real actions.
 
-**HOW TO USE A TOOL:**
-Include this EXACT format in your response (the system will execute it automatically):
+**⚠️ CRITICAL RULE:**
+You can ONLY use tools from this exact list: [${toolNames}]
+DO NOT invent, guess, or fabricate tool names. If a tool doesn't exist in the list, say "I don't have a tool for that" instead of making one up.
 
+**FORMAT (exact JSON required):**
 \`\`\`json
-{"tool": "tool_name", "args": {"param": "value"}}
+{"tool": "exact_tool_name_from_list", "args": {"param": "value"}}
 \`\`\`
 
-**WHEN TO USE TOOLS (do it automatically, don't ask!):**
-- "what's the weather" → use \`weather\` tool
-- "set a reminder" → use \`reminder_set\` tool  
-- "what time is it" → use \`datetime\` tool
-- "how much RAM" / system info → use \`system_info\` tool
-- "calculate X" / math → use \`math\` tool
-- "read file X" → use \`read_file\` tool
-- "run command X" → use \`shell\` tool
-- "search for X" → use \`web_search\` tool
-- "play music" / spotify → use \`spotify_*\` tools
-- "create playlist" → use \`spotify_create_playlist\` tool
-- "my notes" / obsidian → use \`obsidian_*\` tools
+**WHEN TO USE TOOLS (do it automatically):**
+- Weather request → use \`weather\`
+- Time/date → use \`datetime\`
+- Math → use \`math\`
+- System info → use \`system_info\`
+- Set reminder → use \`reminder_set\`
+- Spotify controls → use \`spotify_*\` (only if listed)
+- Notes/Obsidian → use \`obsidian_*\` (only if listed)
+- Web search → use \`search\` or \`web_search\`
+- Shell commands → use \`shell\`
+- Read/write files → use \`read_file\`, \`write_file\`
 
-**AVAILABLE TOOLS:**
+**AVAILABLE TOOLS (ONLY these exist):**
 ${toolDescriptions}
 
 **RULES:**
-1. ALWAYS use a tool when the user's request matches a tool's capability
-2. Do NOT explain how to use tools - just USE them
-3. Do NOT show code examples - execute the tool directly
-4. After tool execution, summarize the result in natural language
-5. If a tool fails, explain why and suggest alternatives
+1. ✅ USE tools from the above list automatically
+2. ❌ NEVER invent tool names that aren't listed
+3. ❌ NEVER show code examples - execute tools directly
+4. If tool doesn't exist, say "I don't have that capability" 
+5. After execution, explain results in natural language
 
 **EXAMPLE:**
 User: "What's the weather in Tokyo?"
-Your response should include:
 \`\`\`json
 {"tool": "weather", "args": {"location": "Tokyo"}}
 \`\`\`

package/dist/channels/channelManager.js

@@ -4,11 +4,33 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelManager = void 0;
+const eventBus_1 = require("../core/eventBus");
 class ChannelManager {
     channels = new Map();
     gateway;
+    activeUsers = new Map(); // channelName -> lastActiveUserId
     constructor(gateway) {
         this.gateway = gateway;
+        this.setupBroadcastHandler();
+    }
+    setupBroadcastHandler() {
+        // Handle broadcast to all channels (for calendar notifications etc)
+        (0, eventBus_1.on)('channel:broadcast', async (msg) => {
+            console.log(`[Channels] Broadcasting to all: ${msg.text.slice(0, 50)}...`);
+            // Send to all channels with known active users
+            for (const [channelName, userId] of this.activeUsers) {
+                try {
+                    await this.send(channelName, userId, msg.text);
+                }
+                catch (e) {
+                    console.error(`[Channels] Broadcast to ${channelName}:${userId} failed:`, e);
+                }
+            }
+        });
+    }
+    // Track active users for broadcasts
+    trackActiveUser(channelName, userId) {
+        this.activeUsers.set(channelName, userId);
     }
     register(channel) {
         this.channels.set(channel.name, channel);

package/dist/cli/chat.js

@@ -81,16 +81,13 @@ const FOX_THINKING = `${colors.orange}
   ${colors.orange} / - \\${colors.reset}
 `;
 const BANNER = `
-${colors.rust}╔═══════════════════════════════════════════════════════════╗${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}█████╗ ██████╗ ███████╗██╗  ██╗${colors.amber}  ██████╗  ██████╗ ████████╗${colors.reset}  ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}██╔══██╗██╔══██╗██╔════╝╚██╗██╔╝${colors.amber}  ██╔══██╗██╔═══██╗╚══██╔══╝${colors.reset}  ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}███████║██████╔╝█████╗   ╚███╔╝${colors.amber}  ██████╔╝██║   ██║   ██║${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}██╔══██║██╔═══╝ ██╔══╝   ██╔██╗${colors.amber}  ██╔══██╗██║   ██║   ██║${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}██║  ██║██║     ███████╗██╔╝ ██╗${colors.amber} ██████╔╝╚██████╔╝   ██║${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝${colors.amber} ╚═════╝  ╚═════╝    ╚═╝${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}╠═══════════════════════════════════════════════════════════╣${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.gold}🦊 Free • Private • Local-First AI${colors.reset}          ${colors.gray}v2026.1${colors.reset}  ${colors.rust}║${colors.reset}
-${colors.rust}╚═══════════════════════════════════════════════════════════╝${colors.reset}
+${colors.orange}${colors.bold}     _    ____  _______  ______   ___ _____${colors.reset}
+${colors.orange}${colors.bold}    / \\  |  _ \\| ____\\ \\/ / __ ) / _ \\_   _|${colors.reset}
+${colors.amber}${colors.bold}   / _ \\ | |_) |  _|  \\  /|  _ \\| | | || |${colors.reset}
+${colors.amber}${colors.bold}  / ___ \\|  __/| |___ /  \\| |_) | |_| || |${colors.reset}
+${colors.rust}${colors.bold} /_/   \\_\\_|   |_____/_/\\_\\____/ \\___/ |_|${colors.reset}
+
+${colors.gold}🦊 Free • Private • Local-First AI${colors.reset} ${colors.gray}v2026.1${colors.reset}
 `;
 const SPINNER_FRAMES = ['🦊', '🔥', '✨', '💫', '⭐', '🌟', '✨', '🔥'];
 /**
@@ -104,9 +101,45 @@ class CLIChat extends events_1.EventEmitter {
     currentSpinnerFrame = 0;
     isThinking = false;
     username;
+    commandHistory = [];
+    historyFile;
     constructor(options = {}) {
         super();
         this.username = options.username || process.env.USER || 'You';
+        this.historyFile = path.join(process.env.HOME || process.env.USERPROFILE || '', '.apexbot', 'cli_history.json');
+        this.loadCommandHistory();
+    }
+    loadCommandHistory() {
+        try {
+            if (fs.existsSync(this.historyFile)) {
+                const data = JSON.parse(fs.readFileSync(this.historyFile, 'utf-8'));
+                this.commandHistory = data.commands || [];
+            }
+        }
+        catch {
+            // Ignore errors, start with empty history
+        }
+    }
+    saveCommandHistory() {
+        try {
+            const dir = path.dirname(this.historyFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Keep last 500 commands
+            const commands = this.commandHistory.slice(-500);
+            fs.writeFileSync(this.historyFile, JSON.stringify({ commands }, null, 2));
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    saveCommandToHistory(input) {
+        // Don't add duplicates of the last command
+        if (this.commandHistory[this.commandHistory.length - 1] !== input) {
+            this.commandHistory.push(input);
+            this.saveCommandHistory();
+        }
     }
     setMessageHandler(handler) {
         this.messageHandler = handler;
@@ -128,6 +161,8 @@ class CLIChat extends events_1.EventEmitter {
                 this.rl?.prompt();
                 return;
             }
+            // Save to persistent history
+            this.saveCommandToHistory(input);
             // Handle prefixes like Claude Code
             if (input.startsWith('/')) {
                 await this.handleCommand(input);
@@ -253,6 +288,9 @@ ${colors.orange}${colors.bold}Input Prefixes${colors.reset}                 ${co
             case 'history':
                 this.showHistory(parseInt(args[0]) || 10);
                 break;
+            case 'commands':
+                this.showCommandHistory(parseInt(args[0]) || 20);
+                break;
             case 'reset':
                 this.history = [];
                 console.log(`${colors.green}✓ Conversation reset${colors.reset}`);
@@ -270,6 +308,27 @@ ${colors.orange}${colors.bold}Input Prefixes${colors.reset}                 ${co
             case 'tools':
                 this.emit('command:tools');
                 break;
+            case 'model':
+                if (args[0]) {
+                    this.emit('command:model', args[0]);
+                    console.log(`${colors.green}✓ Model changed to: ${colors.gold}${args[0]}${colors.reset}`);
+                }
+                else {
+                    this.emit('command:model:show');
+                }
+                break;
+            case 'provider':
+                if (args[0]) {
+                    this.emit('command:provider', args[0]);
+                    console.log(`${colors.green}✓ Provider changed to: ${colors.gold}${args[0]}${colors.reset}`);
+                }
+                else {
+                    console.log(`${colors.amber}Usage: /provider <ollama|google|anthropic|openai|kimi>${colors.reset}`);
+                }
+                break;
+            case 'config':
+                this.emit('command:config');
+                break;
             case 'exit':
             case 'quit':
             case 'bye':
@@ -285,15 +344,20 @@ ${colors.orange}${colors.bold}Input Prefixes${colors.reset}                 ${co
 ${colors.orange}${colors.bold}🦊 ApexBot Commands${colors.reset}
 ${colors.gray}${'─'.repeat(40)}${colors.reset}
 
-  ${colors.orange}/help${colors.reset}      Show this help
-  ${colors.orange}/clear${colors.reset}     Clear screen
-  ${colors.orange}/reset${colors.reset}     Reset conversation
-  ${colors.orange}/history${colors.reset}   Show recent messages
-  ${colors.orange}/status${colors.reset}    Show bot status
-  ${colors.orange}/skills${colors.reset}    List enabled skills
-  ${colors.orange}/tools${colors.reset}     List available tools
-  ${colors.orange}/fox${colors.reset}       Show fox mascot 🦊
-  ${colors.orange}/exit${colors.reset}      Exit ApexBot
+  ${colors.orange}/help${colors.reset}        Show this help
+  ${colors.orange}/clear${colors.reset}       Clear screen
+  ${colors.orange}/reset${colors.reset}       Reset conversation
+  ${colors.orange}/history${colors.reset}     Show recent messages
+  ${colors.orange}/commands${colors.reset}    Show command history
+  ${colors.orange}/status${colors.reset}      Show bot status
+  ${colors.orange}/skills${colors.reset}      List enabled skills
+  ${colors.orange}/tools${colors.reset}       List available tools
+  ${colors.orange}/model${colors.reset}       Show/change model
+  ${colors.orange}/model${colors.reset} ${colors.gray}<name>${colors.reset}  Change to specified model
+  ${colors.orange}/provider${colors.reset}    Change AI provider
+  ${colors.orange}/config${colors.reset}      Show configuration
+  ${colors.orange}/fox${colors.reset}         Show fox mascot 🦊
+  ${colors.orange}/exit${colors.reset}        Exit ApexBot
 
 ${colors.gray}Shortcuts: Ctrl+C (exit), Ctrl+L (clear), ↑↓ (history)${colors.reset}
         `);
@@ -315,6 +379,19 @@ ${colors.gray}Shortcuts: Ctrl+C (exit), Ctrl+L (clear), ↑↓ (history)${colors
         }
         console.log();
     }
+    showCommandHistory(count) {
+        const recent = this.commandHistory.slice(-count);
+        if (recent.length === 0) {
+            console.log(`${colors.gray}No command history yet${colors.reset}`);
+            return;
+        }
+        console.log(`\n${colors.orange}${colors.bold}Recent Commands (${recent.length})${colors.reset}\n`);
+        recent.forEach((cmd, i) => {
+            const num = this.commandHistory.length - count + i + 1;
+            console.log(`${colors.gray}${String(num).padStart(4)}.${colors.reset} ${cmd}`);
+        });
+        console.log(`\n${colors.gray}Total: ${this.commandHistory.length} commands in history${colors.reset}\n`);
+    }
     startSpinner(text) {
         this.isThinking = true;
         this.currentSpinnerFrame = 0;