apexbot 1.0.1 → 1.0.4

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);
         });
     }
@@ -71,8 +109,8 @@ class Gateway {
         // Start listening
         return new Promise((resolve) => {
             this.server.listen(this.config.port, this.config.host, () => {
-                console.log(`🚀 Gateway running at http://${this.config.host}:${this.config.port}`);
-                console.log(`📡 WebSocket at ws://${this.config.host}:${this.config.port}`);
+                console.log(`Gateway running at http://${this.config.host}:${this.config.port}`);
+                console.log(`WebSocket at ws://${this.config.host}:${this.config.port}`);
                 resolve();
             });
         });
@@ -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') {
@@ -228,7 +282,7 @@ class Gateway {
 </head>
 <body>
   <header>
-    <h1>🤖 ApexBot</h1>
+    <h1>ApexBot</h1>
     <span class="status" id="status">Connecting...</span>
   </header>
   <div id="messages"></div>

package/dist/index.js

@@ -54,7 +54,7 @@ const config = {
 // Main
 // ─────────────────────────────────────────────────────────────────
 async function main() {
-    console.log('🚀 ApexBot starting...');
+    console.log('ApexBot starting...');
     // Initialize adapters
     const manifold = new manifold_1.default(config.manifold);
     const engine = new decisionEngine_1.default(config.engine);
@@ -69,9 +69,9 @@ async function main() {
         telegram = new telegram_1.default(config.telegram);
         // Handle telegram commands
         (0, eventBus_1.on)('telegram:status_request', async (req) => {
-            const status = `📊 *ApexBot Status*\n` +
+            const status = `*ApexBot Status*\n` +
                 `Bankroll: M$${engine.getBankroll().toFixed(2)}\n` +
-                `Trading: ${tradingEnabled ? '✅ Active' : '🛑 Stopped'}\n` +
+                `Trading: ${tradingEnabled ? 'Active' : 'Stopped'}\n` +
                 `Risk multiplier: ${config.engine.riskMultiplier}`;
             await telegram.sendTo(req.chatId, status);
         });
@@ -79,10 +79,10 @@ async function main() {
             try {
                 const markets = await manifold.getMarkets(10);
                 const list = markets.slice(0, 10).map((m, i) => `${i + 1}. ${m.question.slice(0, 50)}... (${(m.probability * 100).toFixed(0)}%)`).join('\n');
-                await telegram.sendTo(req.chatId, `📈 *Top Markets*\n\n${list}`);
+                await telegram.sendTo(req.chatId, `*Top Markets*\n\n${list}`);
             }
             catch (e) {
-                await telegram.sendTo(req.chatId, '❌ Nie udało się pobrać rynków.');
+                await telegram.sendTo(req.chatId, 'Failed to fetch markets.');
             }
         });
         (0, eventBus_1.on)('telegram:stop_trading', () => {
@@ -97,25 +97,25 @@ async function main() {
         telegram.start().catch((e) => {
             console.error('Telegram bot failed to start:', e);
         });
-        console.log('🤖 Telegram bot initialized');
+        console.log('Telegram bot initialized');
     }
     else {
-        console.log('⚠️  Telegram not configured (set TELEGRAM_BOT_TOKEN and TELEGRAM_ALLOWED_USERS)');
+        console.log('Telegram not configured (set TELEGRAM_BOT_TOKEN and TELEGRAM_ALLOWED_USERS)');
     }
     // ─────────────────────────────────────────────────────────────────
     // Arbitrage Detector
     // ─────────────────────────────────────────────────────────────────
     arbDetector = new arbitrage_1.default(manifold, config.arbitrage);
-    console.log('🔍 Arbitrage detector initialized');
+    console.log('Arbitrage detector initialized');
     // ─────────────────────────────────────────────────────────────────
     // LLM Safety Checker (optional)
     // ─────────────────────────────────────────────────────────────────
     if (config.safety.enabled) {
         safetyChecker = new llmChecker_1.default({ googleApiKey: config.safety.googleApiKey });
-        console.log('🛡️  LLM safety checker initialized (Gemini)');
+        console.log('LLM safety checker initialized (Gemini)');
     }
     else {
-        console.log('⚠️  LLM safety checker not enabled (set GOOGLE_API_KEY)');
+        console.log('LLM safety checker not enabled (set GOOGLE_API_KEY)');
     }
     // ─────────────────────────────────────────────────────────────────
     // Event handlers
@@ -182,9 +182,9 @@ async function main() {
     // ─────────────────────────────────────────────────────────────────
     if (config.manifold.apiKey) {
         manifold.connectWebSocket();
-        console.log('📡 WebSocket connection initiated');
+        console.log('WebSocket connection initiated');
     }
-    console.log('✅ ApexBot running. Press Ctrl+C to stop.');
+    console.log('ApexBot running. Press Ctrl+C to stop.');
 }
 // ─────────────────────────────────────────────────────────────────
 // Entry point

package/dist/skills/index.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * ApexBot Skills System
+ *
+ * Skills are collections of tools for specific integrations (Obsidian, Spotify, etc.)
+ * Similar to Clawdbot's skills/integrations architecture.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillManager = void 0;
+exports.getSkillManager = getSkillManager;
+exports.initSkillManager = initSkillManager;
+const events_1 = require("events");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const tools_1 = require("../tools");
+class SkillManager extends events_1.EventEmitter {
+    skills = new Map();
+    enabledSkills = new Set();
+    skillConfigs = new Map();
+    configDir;
+    constructor(configDir) {
+        super();
+        this.configDir = configDir;
+    }
+    async loadConfig() {
+        try {
+            const configPath = path.join(this.configDir, 'skills.json');
+            const data = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(data);
+            this.enabledSkills = new Set(config.enabled || []);
+            this.skillConfigs = new Map(Object.entries(config.configs || {}));
+            console.log('[Skills] Loaded config, enabled:', Array.from(this.enabledSkills));
+        }
+        catch (error) {
+            // Config doesn't exist yet, use defaults
+            console.log('[Skills] No config found, using defaults');
+        }
+    }
+    async saveConfig() {
+        const configPath = path.join(this.configDir, 'skills.json');
+        const config = {
+            enabled: Array.from(this.enabledSkills),
+            configs: Object.fromEntries(this.skillConfigs),
+        };
+        await fs.mkdir(this.configDir, { recursive: true });
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+        console.log('[Skills] Saved config');
+    }
+    register(skill) {
+        const name = skill.manifest.name;
+        this.skills.set(name, skill);
+        console.log(`[Skills] Registered: ${name} v${skill.manifest.version}`);
+        this.emit('skill:registered', { name, manifest: skill.manifest });
+    }
+    async enable(name, config) {
+        const skill = this.skills.get(name);
+        if (!skill) {
+            console.error(`[Skills] Skill not found: ${name}`);
+            return false;
+        }
+        try {
+            // Store config
+            if (config) {
+                this.skillConfigs.set(name, config);
+            }
+            // Initialize skill
+            const skillConfig = this.skillConfigs.get(name) || {};
+            if (skill.initialize) {
+                await skill.initialize(skillConfig);
+            }
+            // Register tools
+            for (const tool of skill.tools) {
+                tools_1.toolRegistry.register(tool);
+            }
+            this.enabledSkills.add(name);
+            await this.saveConfig();
+            console.log(`[Skills] Enabled: ${name}`);
+            this.emit('skill:enabled', { name });
+            return true;
+        }
+        catch (error) {
+            console.error(`[Skills] Failed to enable ${name}:`, error.message);
+            return false;
+        }
+    }
+    async disable(name) {
+        const skill = this.skills.get(name);
+        if (!skill) {
+            return false;
+        }
+        try {
+            // Shutdown skill
+            if (skill.shutdown) {
+                await skill.shutdown();
+            }
+            // Unregister tools
+            for (const tool of skill.tools) {
+                tools_1.toolRegistry.unregister(tool.definition.name);
+            }
+            this.enabledSkills.delete(name);
+            await this.saveConfig();
+            console.log(`[Skills] Disabled: ${name}`);
+            this.emit('skill:disabled', { name });
+            return true;
+        }
+        catch (error) {
+            console.error(`[Skills] Failed to disable ${name}:`, error.message);
+            return false;
+        }
+    }
+    isEnabled(name) {
+        return this.enabledSkills.has(name);
+    }
+    get(name) {
+        return this.skills.get(name);
+    }
+    list() {
+        return Array.from(this.skills.values()).map(skill => ({
+            name: skill.manifest.name,
+            version: skill.manifest.version,
+            description: skill.manifest.description,
+            category: skill.manifest.category,
+            enabled: this.enabledSkills.has(skill.manifest.name),
+            tools: skill.tools.map(t => t.definition.name),
+        }));
+    }
+    listEnabled() {
+        return this.list().filter(s => s.enabled);
+    }
+    listByCategory(category) {
+        return this.list().filter(s => s.category === category);
+    }
+    getConfig(name) {
+        return this.skillConfigs.get(name);
+    }
+    async setConfig(name, config) {
+        this.skillConfigs.set(name, config);
+        await this.saveConfig();
+        // Re-initialize if enabled
+        if (this.enabledSkills.has(name)) {
+            const skill = this.skills.get(name);
+            if (skill?.initialize) {
+                await skill.initialize(config);
+            }
+        }
+    }
+    // Initialize all enabled skills on startup
+    async initializeEnabled() {
+        for (const name of this.enabledSkills) {
+            const skill = this.skills.get(name);
+            if (skill) {
+                try {
+                    const config = this.skillConfigs.get(name) || {};
+                    if (skill.initialize) {
+                        await skill.initialize(config);
+                    }
+                    for (const tool of skill.tools) {
+                        tools_1.toolRegistry.register(tool);
+                    }
+                    console.log(`[Skills] Initialized: ${name}`);
+                }
+                catch (error) {
+                    console.error(`[Skills] Failed to initialize ${name}:`, error.message);
+                }
+            }
+        }
+    }
+}
+exports.SkillManager = SkillManager;
+// Global skill manager instance (initialized in gateway)
+let skillManager = null;
+function getSkillManager() {
+    return skillManager;
+}
+function initSkillManager(configDir) {
+    skillManager = new SkillManager(configDir);
+    return skillManager;
+}
+exports.default = { SkillManager, getSkillManager, initSkillManager };