apexbot 1.0.2 → 1.0.4

package/dist/agent/agentManager.js

@@ -7,6 +7,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentManager = void 0;
 const generative_ai_1 = require("@google/generative-ai");
+const tools_1 = require("../tools");
+const toolExecutor_1 = require("./toolExecutor");
 class AgentManager {
     config = null;
     googleClient = null;
@@ -42,6 +44,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             maxTokens: 4096,
             temperature: 0.7,
             systemPrompt: this.defaultSystemPrompt,
+            enableTools: true, // Tools enabled by default
             ...config,
         };
         // Initialize client based on provider
@@ -68,6 +71,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)}...`);
         // Handle slash commands
         if (userText.startsWith('/')) {
             return this.handleCommand(session, userText);
@@ -95,6 +99,43 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                 default:
                     response = { text: 'Unknown AI provider' };
             }
+            // Check for tool calls in response
+            if (this.config.enableTools) {
+                const toolCalls = (0, toolExecutor_1.parseToolCalls)(response.text);
+                if (toolCalls.length > 0) {
+                    console.log(`[Agent] Found ${toolCalls.length} tool calls`);
+                    // Build tool context
+                    const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || 'unknown', message.channel, { workspaceDir: process.cwd() });
+                    // Execute tools
+                    const toolResults = await (0, toolExecutor_1.executeToolCalls)(toolCalls, context);
+                    response.toolCalls = toolResults;
+                    // Format results and continue conversation
+                    const resultsText = (0, toolExecutor_1.formatToolResults)(toolResults);
+                    if (resultsText) {
+                        // Add tool results to history and get follow-up response
+                        const followUpHistory = [
+                            ...history,
+                            { role: 'assistant', content: response.text, timestamp: Date.now() },
+                            { role: 'user', content: `Tool results:\n${resultsText}\n\nPlease continue based on these results.`, timestamp: Date.now() },
+                        ];
+                        // Get follow-up response
+                        let followUp;
+                        switch (this.config.provider) {
+                            case 'ollama':
+                                followUp = await this.processWithOllama(followUpHistory);
+                                break;
+                            case 'google':
+                                followUp = await this.processWithGemini(followUpHistory);
+                                break;
+                            default:
+                                followUp = { text: resultsText };
+                        }
+                        // Combine responses
+                        response.text = followUp.text;
+                    }
+                }
+            }
+            console.log(`[Agent] Generated response: ${response.text.slice(0, 50)}...`);
             // Save to session
             session.messages.push({ role: 'user', content: userText, timestamp: Date.now() });
             session.messages.push({ role: 'assistant', content: response.text, timestamp: Date.now() });
@@ -103,9 +144,8 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             return response;
         }
         catch (e) {
-            console.error('[Agent] Error:', e);
-            // Escape special characters for Telegram
-            const errorMsg = (e.message || 'Unknown error').slice(0, 200).replace(/[_*\[\]()~`>#+=|{}.!-]/g, '\\$&');
+            console.error('[Agent] Error processing:', e);
+            const errorMsg = (e.message || 'Unknown error').slice(0, 200);
             return { text: `Error: ${errorMsg}` };
         }
     }
@@ -160,6 +200,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}...`);
         // Build messages array for Ollama chat API
         const messages = history.map(m => ({
             role: m.role,
@@ -183,10 +224,12 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             });
             if (!res.ok) {
                 const err = await res.text().catch(() => res.statusText);
+                console.error(`[Agent] Ollama error: ${err}`);
                 throw new Error(`Ollama error: ${err}`);
             }
             const data = await res.json();
             const text = data.message?.content || '';
+            console.log(`[Agent] Ollama response received: ${text.slice(0, 50)}...`);
             return {
                 text: String(text).trim() || 'No response from model',
                 usage: {
@@ -196,6 +239,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             };
         }
         catch (error) {
+            console.error('[Agent] Ollama fetch error:', error);
             if (error.code === 'ECONNREFUSED' || error.message?.includes('fetch failed')) {
                 return {
                     text: `Ollama not running.\n\nPlease:\n1. Install Ollama: https://ollama.com\n2. Pull a model: ollama pull llama3.2\n3. Start Ollama: ollama serve`,
@@ -206,8 +250,11 @@ You are running locally on the user's machine. No data leaves their computer. Yo
     }
     buildHistory(session, currentMessage) {
         const history = [];
-        // System prompt
-        const systemPrompt = session.systemPrompt || this.config?.systemPrompt || this.defaultSystemPrompt;
+        // System prompt with tools if enabled
+        let systemPrompt = session.systemPrompt || this.config?.systemPrompt || this.defaultSystemPrompt;
+        if (this.config?.enableTools && tools_1.toolRegistry.list().length > 0) {
+            systemPrompt += '\n\n' + (0, toolExecutor_1.getToolsSystemPrompt)();
+        }
         history.push({ role: 'system', content: systemPrompt, timestamp: 0 });
         // Previous messages
         for (const msg of session.messages) {

package/dist/agent/toolExecutor.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Tool Executor - Handles tool calling from AI models
+ *
+ * This module integrates the tool system with AI responses,
+ * parsing tool calls and executing them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToolCalls = parseToolCalls;
+exports.executeTool = executeTool;
+exports.executeToolCalls = executeToolCalls;
+exports.formatToolResults = formatToolResults;
+exports.getToolsSystemPrompt = getToolsSystemPrompt;
+exports.buildToolContext = buildToolContext;
+const tools_1 = require("../tools");
+/**
+ * Parse tool calls from AI response
+ * Supports multiple formats:
+ * 1. JSON block: ```json\n{"tool": "name", "args": {...}}```
+ * 2. XML-style: <tool name="name">{"args": {...}}</tool>
+ * 3. Function call style: tool_name({"arg": "value"})
+ */
+function parseToolCalls(text) {
+    const calls = [];
+    // Pattern 1: JSON blocks with tool calls
+    const jsonBlockRegex = /```(?:json)?\s*\n?\s*\{[\s\S]*?"(?:tool|function|name)"[\s\S]*?\}\s*```/gi;
+    const jsonBlocks = text.match(jsonBlockRegex) || [];
+    for (const block of jsonBlocks) {
+        try {
+            const jsonStr = block.replace(/```(?:json)?\s*\n?/gi, '').replace(/\s*```/g, '');
+            const parsed = JSON.parse(jsonStr);
+            if (parsed.tool || parsed.function || parsed.name) {
+                calls.push({
+                    name: parsed.tool || parsed.function || parsed.name,
+                    arguments: parsed.args || parsed.arguments || parsed.parameters || {},
+                });
+            }
+        }
+        catch (e) {
+            // Invalid JSON, skip
+        }
+    }
+    // Pattern 2: XML-style tool calls
+    const xmlRegex = /<tool\s+name=["']([^"']+)["']>\s*([\s\S]*?)\s*<\/tool>/gi;
+    let xmlMatch;
+    while ((xmlMatch = xmlRegex.exec(text)) !== null) {
+        try {
+            const name = xmlMatch[1];
+            const argsStr = xmlMatch[2].trim();
+            const args = argsStr ? JSON.parse(argsStr) : {};
+            calls.push({ name, arguments: args });
+        }
+        catch (e) {
+            // Invalid args, skip
+        }
+    }
+    // Pattern 3: Function call style: tool_name({"arg": "value"})
+    const funcRegex = /\b([a-z_][a-z0-9_]*)\s*\(\s*(\{[\s\S]*?\})\s*\)/gi;
+    let funcMatch;
+    while ((funcMatch = funcRegex.exec(text)) !== null) {
+        const name = funcMatch[1];
+        // Check if it's a registered tool
+        if (tools_1.toolRegistry.has(name)) {
+            try {
+                const args = JSON.parse(funcMatch[2]);
+                calls.push({ name, arguments: args });
+            }
+            catch (e) {
+                // Invalid args, skip
+            }
+        }
+    }
+    return calls;
+}
+/**
+ * Execute a single tool call
+ */
+async function executeTool(call, context) {
+    console.log(`[ToolExecutor] Executing: ${call.name}`, call.arguments);
+    return tools_1.toolRegistry.execute(call.name, call.arguments, context);
+}
+/**
+ * Execute multiple tool calls in sequence
+ */
+async function executeToolCalls(calls, context) {
+    const results = [];
+    for (const call of calls) {
+        const result = await executeTool(call, context);
+        results.push({ call, result });
+    }
+    return results;
+}
+/**
+ * Format tool results for inclusion in AI response
+ */
+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}`;
+    }).join('\n\n');
+}
+/**
+ * Get the system prompt addition for tool usage
+ */
+function getToolsSystemPrompt() {
+    const tools = tools_1.toolRegistry.list();
+    if (tools.length === 0) {
+        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}\nParameters:\n${params}`;
+    }).join('\n\n');
+    return `
+You have access to the following tools. To use a tool, include a JSON block in your response:
+
+\`\`\`json
+{"tool": "tool_name", "args": {"param1": "value1"}}
+\`\`\`
+
+Available tools:
+
+${toolDescriptions}
+
+After I execute the tool, I'll show you the result so you can incorporate it into your response.
+`;
+}
+/**
+ * Build context for tool execution
+ */
+function buildToolContext(sessionId, userId, channel, config) {
+    return {
+        sessionId,
+        userId,
+        channel,
+        workspaceDir: config?.workspaceDir || process.cwd(),
+        config,
+    };
+}

package/dist/channels/channelManager.js

@@ -47,10 +47,12 @@ class ChannelManager {
         if (!channel) {
             // For webchat, broadcast via gateway
             if (channelName === 'webchat') {
+                console.log(`[Channels] Broadcasting to webchat: ${text.slice(0, 50)}...`);
                 this.gateway.broadcast({ type: 'response', text, to });
                 return;
             }
-            throw new Error(`Channel not found: ${channelName}`);
+            console.error(`[Channels] Channel not found: ${channelName}`);
+            return;
         }
         await channel.send(to, text, replyTo);
     }

package/dist/cli/index.js

@@ -452,9 +452,12 @@ async function startGatewayServer(config, options = {}) {
         host: '127.0.0.1',
         token: config.gateway?.token,
         verbose: options.verbose,
+        configDir: CONFIG_DIR,
     });
     // Configure agent
     gateway.agents.configure(config.agent);
+    // Initialize tools and skills system
+    await gateway.initializeTools();
     // Register channels
     if (config.channels?.telegram?.botToken) {
         const telegram = new telegram_1.TelegramChannel({
@@ -466,6 +469,9 @@ async function startGatewayServer(config, options = {}) {
     // Start gateway
     await gateway.start();
     await gateway.channels.connectAll();
+    // Show tool info
+    const tools = gateway.getToolRegistry().list();
+    const skills = gateway.getSkillManager()?.list() || [];
     console.log('');
     console.log(chalk.green('ApexBot is running!'));
     console.log('');
@@ -473,6 +479,9 @@ async function startGatewayServer(config, options = {}) {
     console.log(`   ${chalk.cyan('API:')}        http://127.0.0.1:${port}`);
     console.log(`   ${chalk.cyan('WebSocket:')} ws://127.0.0.1:${port}`);
     console.log('');
+    console.log(`   ${chalk.cyan('Tools:')}      ${tools.length} available`);
+    console.log(`   ${chalk.cyan('Skills:')}     ${skills.length} registered`);
+    console.log('');
     console.log(chalk.gray('Press Ctrl+C to stop.'));
     console.log('');
     // Handle shutdown
@@ -828,6 +837,111 @@ program
     }
 });
 // ─────────────────────────────────────────────────────────────────
+// SKILLS Command - Manage skills
+// ─────────────────────────────────────────────────────────────────
+program
+    .command('skills [action]')
+    .alias('skill')
+    .description('Manage ApexBot skills (integrations)')
+    .option('-n, --name <name>', 'Skill name')
+    .action(async (action = 'list', options) => {
+    const config = loadConfig();
+    const port = config.gateway?.port || 18789;
+    switch (action) {
+        case 'list':
+            console.log('');
+            console.log(chalk.cyan('Available Skills:'));
+            console.log('');
+            try {
+                const res = await fetch(`http://127.0.0.1:${port}/api/skills`);
+                const data = await res.json();
+                for (const skill of data.skills) {
+                    const status = skill.enabled ? chalk.green('[ENABLED]') : chalk.gray('[disabled]');
+                    console.log(`  ${status} ${chalk.white(skill.name)} v${skill.version}`);
+                    console.log(`           ${chalk.gray(skill.description)}`);
+                    console.log(`           Tools: ${skill.tools.join(', ')}`);
+                    console.log('');
+                }
+            }
+            catch (e) {
+                console.log(chalk.yellow('Gateway not running. Available skills:'));
+                console.log('');
+                console.log('  - obsidian   Obsidian note-taking integration');
+                console.log('  - weather    Weather forecasts');
+                console.log('  - reminder   Reminders and timers');
+                console.log('  - system     System info and process management');
+                console.log('');
+            }
+            break;
+        case 'enable':
+            if (!options.name) {
+                console.log(chalk.red('Please specify skill name: --name <skill>'));
+                return;
+            }
+            console.log(chalk.yellow(`Enabling skill: ${options.name}...`));
+            console.log(chalk.gray('(Skill configuration will be saved to ~/.apexbot/skills.json)'));
+            break;
+        case 'disable':
+            if (!options.name) {
+                console.log(chalk.red('Please specify skill name: --name <skill>'));
+                return;
+            }
+            console.log(chalk.yellow(`Disabling skill: ${options.name}...`));
+            break;
+        default:
+            console.log('Usage: apexbot skills [list|enable|disable] --name <skill>');
+    }
+});
+// ─────────────────────────────────────────────────────────────────
+// TOOLS Command - List available tools
+// ─────────────────────────────────────────────────────────────────
+program
+    .command('tools')
+    .alias('tool')
+    .description('List available tools')
+    .action(async () => {
+    const config = loadConfig();
+    const port = config.gateway?.port || 18789;
+    console.log('');
+    console.log(chalk.cyan('Available Tools:'));
+    console.log('');
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/tools`);
+        const data = await res.json();
+        // Group by category
+        const byCategory = {};
+        for (const tool of data.tools) {
+            const cat = tool.category || 'other';
+            if (!byCategory[cat])
+                byCategory[cat] = [];
+            byCategory[cat].push(tool);
+        }
+        for (const [category, tools] of Object.entries(byCategory)) {
+            console.log(chalk.yellow(`  ${category.toUpperCase()}`));
+            for (const tool of tools) {
+                console.log(`    ${chalk.white(tool.name)} - ${chalk.gray(tool.description)}`);
+            }
+            console.log('');
+        }
+    }
+    catch (e) {
+        console.log(chalk.yellow('Gateway not running. Built-in tools:'));
+        console.log('');
+        console.log('  CORE');
+        console.log('    shell         Execute shell commands');
+        console.log('    read_file     Read file contents');
+        console.log('    write_file    Write to files');
+        console.log('    list_dir      List directory contents');
+        console.log('    edit_file     Edit files (search/replace)');
+        console.log('    fetch_url     Fetch web pages');
+        console.log('    web_search    Search the web');
+        console.log('    datetime      Date/time operations');
+        console.log('    math          Mathematical calculations');
+        console.log('    convert       Unit conversions');
+        console.log('');
+    }
+});
+// ─────────────────────────────────────────────────────────────────
 // Default action - show help with banner
 // ─────────────────────────────────────────────────────────────────
 program

package/dist/gateway/index.js

@@ -10,16 +10,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gateway = void 0;
 const ws_1 = require("ws");
 const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
 const eventBus_1 = require("../core/eventBus");
 const sessionManager_1 = require("../sessions/sessionManager");
 const channelManager_1 = require("../channels/channelManager");
 const agentManager_1 = require("../agent/agentManager");
 const dashboard_1 = require("./dashboard");
+const loader_1 = require("../tools/loader");
 class Gateway {
     config;
     server = null;
     wss = null;
     clients = new Map();
+    skillManager = null;
     sessions;
     channels;
     agents;
@@ -29,34 +32,69 @@ class Gateway {
             host: config.host || '127.0.0.1',
             token: config.token,
             verbose: config.verbose || false,
+            configDir: config.configDir || path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.apexbot'),
         };
         this.sessions = new sessionManager_1.SessionManager();
         this.channels = new channelManager_1.ChannelManager(this);
         this.agents = new agentManager_1.AgentManager();
         this.setupEventHandlers();
     }
+    /**
+     * Initialize tools and skills system
+     */
+    async initializeTools() {
+        console.log('[Gateway] Initializing tools system...');
+        this.skillManager = await (0, loader_1.initializeToolsSystem)(this.config.configDir);
+        console.log(`[Gateway] Tools ready: ${loader_1.toolRegistry.list().length} tools, ${this.skillManager.list().length} skills`);
+    }
+    getSkillManager() {
+        return this.skillManager;
+    }
+    getToolRegistry() {
+        return loader_1.toolRegistry;
+    }
     setupEventHandlers() {
         // Route incoming messages to agent
         (0, eventBus_1.on)('channel:message', async (msg) => {
-            if (this.config.verbose) {
-                console.log(`[Gateway] Message from ${msg.channel}:${msg.from}: ${msg.text?.slice(0, 50)}...`);
-            }
+            console.log(`[Gateway] Message from ${msg.channel}:${msg.from}: ${msg.text?.slice(0, 50)}...`);
             // Get or create session
             const session = this.sessions.getOrCreate(msg.channel, msg.from, msg.isGroup);
-            // Process with agent
-            const response = await this.agents.process(session, msg);
-            // Send response back
-            if (response) {
+            try {
+                // Process with agent
+                const response = await this.agents.process(session, msg);
+                console.log(`[Gateway] Agent response: ${response?.text?.slice(0, 50)}...`);
+                // Send response back
+                if (response && response.text) {
+                    (0, eventBus_1.emit)('channel:send', {
+                        channel: msg.channel,
+                        to: msg.from,
+                        text: response.text,
+                        replyTo: msg.id,
+                    });
+                }
+                else {
+                    console.warn('[Gateway] No response from agent');
+                    (0, eventBus_1.emit)('channel:send', {
+                        channel: msg.channel,
+                        to: msg.from,
+                        text: 'Sorry, I could not generate a response. Please try again.',
+                        replyTo: msg.id,
+                    });
+                }
+            }
+            catch (error) {
+                console.error('[Gateway] Error processing message:', error);
                 (0, eventBus_1.emit)('channel:send', {
                     channel: msg.channel,
                     to: msg.from,
-                    text: response.text,
+                    text: `Error: ${error.message || 'Unknown error'}`,
                     replyTo: msg.id,
                 });
             }
         });
         // Handle outgoing messages
         (0, eventBus_1.on)('channel:send', async (msg) => {
+            console.log(`[Gateway] Sending to ${msg.channel}:${msg.to}: ${msg.text?.slice(0, 50)}...`);
             await this.channels.send(msg.channel, msg.to, msg.text, msg.replyTo);
         });
     }
@@ -131,6 +169,22 @@ class Gateway {
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify(this.sessions.getAll()));
                 break;
+            case '/api/tools':
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    tools: loader_1.toolRegistry.list(),
+                    count: loader_1.toolRegistry.list().length,
+                    categories: loader_1.toolRegistry.getCategories(),
+                }));
+                break;
+            case '/api/skills':
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                const sm = this.getSkillManager();
+                res.end(JSON.stringify({
+                    skills: sm ? sm.list() : [],
+                    enabled: sm ? sm.listEnabled() : [],
+                }));
+                break;
             default:
                 // Serve Dashboard UI
                 if (url.pathname.startsWith('/chat') || url.pathname === '/ui' || url.pathname === '/dashboard') {