apexbot 1.0.0

package/dist/agent/agentManager.js

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * AI Agent Manager - handles AI model interactions
+ * Supports: Ollama (local), Claude (Anthropic), GPT (OpenAI), Gemini (Google)
+ * Default: Ollama for 100% free, privacy-focused operation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentManager = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+class AgentManager {
+    config = null;
+    googleClient = null;
+    defaultSystemPrompt = `You are ApexBot, a helpful AI assistant running locally via Ollama. You are 100% free, private, and self-hosted.
+
+Your goal is to act as a fully autonomous agent, not just a chatbot. Follow these principles:
+
+1. **EXPLORE:** Analyze code and context thoroughly before responding.
+2. **PLAN:** Outline a clear plan before implementing changes.
+3. **ACT:** Provide complete, working code without placeholders like "// ... rest of code".
+4. **VERIFY:** Test your suggestions mentally and point out edge cases.
+
+CODING STANDARDS:
+- TypeScript / Node.js with strict typing
+- Modular, clean, modern ES6+ syntax
+- Explicit error handling
+- Safety first for financial/crypto logic (arbitrage, Kelly criterion)
+
+INTERACTION STYLE:
+- Be direct and actionable
+- Proactively identify issues and offer fixes
+- Keep responses concise but complete
+- Start with context analysis when working with code
+
+You are running locally on the user's machine. No data leaves their computer. You are free, private, and open-source.`;
+    constructor(config) {
+        if (config) {
+            this.configure(config);
+        }
+    }
+    configure(config) {
+        this.config = {
+            maxTokens: 4096,
+            temperature: 0.7,
+            systemPrompt: this.defaultSystemPrompt,
+            ...config,
+        };
+        // Initialize client based on provider
+        if (config.provider === 'google') {
+            // apiKey is optional in AgentConfig ( Ollama doesn't need it ),
+            // so only initialize Google client if we have an API key (from config or env).
+            const gkey = config.apiKey || process.env.GOOGLE_API_KEY;
+            if (typeof gkey === 'string' && gkey.length > 0) {
+                this.googleClient = new generative_ai_1.GoogleGenerativeAI(gkey);
+            }
+            else {
+                console.warn('[Agent] Google provider selected but no API key provided — Gemini will be unavailable until configured.');
+            }
+        }
+        // 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'})`);
+    }
+    async process(session, message) {
+        if (!this.config) {
+            console.warn('[Agent] Not configured');
+            return { text: '⚠️ Agent not configured. Please set up an AI provider.' };
+        }
+        const userText = message.text || '';
+        // Handle slash commands
+        if (userText.startsWith('/')) {
+            return this.handleCommand(session, userText);
+        }
+        // Build conversation history
+        const history = this.buildHistory(session, userText);
+        try {
+            let response;
+            switch (this.config.provider) {
+                case 'ollama':
+                    response = await this.processWithOllama(history);
+                    break;
+                case 'google':
+                    response = await this.processWithGemini(history);
+                    break;
+                case 'anthropic':
+                    response = await this.processWithClaude(history);
+                    break;
+                case 'openai':
+                    response = await this.processWithOpenAI(history);
+                    break;
+                case 'kimi':
+                    response = await this.processWithKimi(history);
+                    break;
+                default:
+                    response = { text: '❌ Unknown AI provider' };
+            }
+            // Save to session
+            session.messages.push({ role: 'user', content: userText, timestamp: Date.now() });
+            session.messages.push({ role: 'assistant', content: response.text, timestamp: Date.now() });
+            session.messageCount += 2;
+            session.lastActivity = Date.now();
+            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, '\\$&');
+            return { text: `Error: ${errorMsg}` };
+        }
+    }
+    async processWithKimi(history) {
+        // Generic Kimi 2.5 integration wrapper. This implementation is intentionally
+        // generic: it will POST to a user-provided `apiUrl` (in config or env) and
+        // expects a JSON response with a `text` field. Adjust to Kimi's official SDK
+        // or API spec if available.
+        const cfg = this.config;
+        if (!cfg)
+            throw new Error('Agent not configured');
+        const apiKey = cfg.apiKey || process.env.KIMI_API_KEY;
+        const apiUrl = cfg.apiUrl || process.env.KIMI_API_URL;
+        if (!apiKey || !apiUrl) {
+            return { text: '⚠️ Kimi provider not configured. Set config.apiUrl and apiKey (or KIMI_API_URL/KIMI_API_KEY).' };
+        }
+        // Build prompt from history (system prompt + conversation)
+        const systemPrompt = history.find(m => m.role === 'system')?.content || '';
+        const userAndAssistant = history
+            .filter(m => m.role !== 'system')
+            .map(m => `${m.role.toUpperCase()}: ${m.content}`)
+            .join('\n\n');
+        const payload = {
+            model: cfg.model || 'kimi-2.5',
+            prompt: `${systemPrompt}\n\n${userAndAssistant}`,
+            max_tokens: cfg.maxTokens || 1024,
+            temperature: cfg.temperature || 0.2,
+        };
+        // Use global fetch (Node 18+) to call the endpoint
+        const res = await fetch(apiUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Kimi API error: ${res.status} ${res.statusText} ${body}`);
+        }
+        const data = await res.json().catch(() => ({}));
+        const text = data.text || data.output || (data.choices && data.choices[0]?.text) || '';
+        return {
+            text: String(text || '').trim() || '⚠️ Kimi returned an empty response.',
+        };
+    }
+    async processWithOllama(history) {
+        const cfg = this.config;
+        if (!cfg)
+            throw new Error('Agent not configured');
+        const apiUrl = cfg.apiUrl || 'http://localhost:11434';
+        const model = cfg.model || 'llama3.2';
+        const temperature = cfg.temperature ?? 0.7;
+        // Build messages array for Ollama chat API
+        const messages = history.map(m => ({
+            role: m.role,
+            content: m.content,
+        }));
+        try {
+            const res = await fetch(`${apiUrl}/api/chat`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    stream: false,
+                    options: {
+                        temperature,
+                        num_predict: cfg.maxTokens || 2048,
+                    },
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.text().catch(() => res.statusText);
+                throw new Error(`Ollama error: ${err}`);
+            }
+            const data = await res.json();
+            const text = data.message?.content || '';
+            return {
+                text: String(text).trim() || '🤔 No response from model',
+                usage: {
+                    inputTokens: data.prompt_eval_count || 0,
+                    outputTokens: data.eval_count || 0,
+                },
+            };
+        }
+        catch (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`,
+                };
+            }
+            throw error;
+        }
+    }
+    buildHistory(session, currentMessage) {
+        const history = [];
+        // System prompt
+        const systemPrompt = session.systemPrompt || this.config?.systemPrompt || this.defaultSystemPrompt;
+        history.push({ role: 'system', content: systemPrompt, timestamp: 0 });
+        // Previous messages
+        for (const msg of session.messages) {
+            if (msg.role !== 'system') {
+                history.push(msg);
+            }
+        }
+        // Current message
+        history.push({ role: 'user', content: currentMessage, timestamp: Date.now() });
+        return history;
+    }
+    async processWithGemini(history) {
+        if (!this.googleClient) {
+            throw new Error('Google client not initialized');
+        }
+        // Get system prompt and prepend to first user message
+        const systemPrompt = history.find(m => m.role === 'system')?.content || '';
+        const conversationHistory = history.filter(m => m.role !== 'system');
+        // Build contents array for generateContent
+        const contents = conversationHistory.map((m, idx) => ({
+            role: m.role === 'user' ? 'user' : 'model',
+            parts: [{
+                    text: idx === 0 && systemPrompt
+                        ? `[System: ${systemPrompt}]\n\n${m.content}`
+                        : m.content
+                }],
+        }));
+        const model = this.googleClient.getGenerativeModel({
+            model: this.config?.model || 'gemini-2.0-flash',
+        });
+        const result = await model.generateContent({
+            contents: contents,
+            generationConfig: {
+                maxOutputTokens: this.config?.maxTokens,
+                temperature: this.config?.temperature,
+            },
+        });
+        const response = result.response;
+        return {
+            text: response.text(),
+            usage: {
+                inputTokens: response.usageMetadata?.promptTokenCount || 0,
+                outputTokens: response.usageMetadata?.candidatesTokenCount || 0,
+            },
+        };
+    }
+    async processWithClaude(history) {
+        // TODO: Implement Anthropic Claude API
+        // Requires @anthropic-ai/sdk
+        return { text: '⚠️ Claude integration not yet implemented. Use Google/Gemini for now.' };
+    }
+    async processWithOpenAI(history) {
+        // TODO: Implement OpenAI API
+        // Requires openai package
+        return { text: '⚠️ OpenAI integration not yet implemented. Use Google/Gemini for now.' };
+    }
+    handleCommand(session, command) {
+        const [cmd, ...args] = command.slice(1).split(' ');
+        switch (cmd.toLowerCase()) {
+            case 'status':
+                return {
+                    text: `📊 *Session Status*\n` +
+                        `Session ID: \`${session.id}\`\n` +
+                        `Messages: ${session.messageCount}\n` +
+                        `Model: ${session.model || this.config?.model || 'default'}\n` +
+                        `Provider: ${this.config?.provider || 'not configured'}\n` +
+                        `Created: ${new Date(session.createdAt).toLocaleString()}\n` +
+                        `Last activity: ${new Date(session.lastActivity).toLocaleString()}`,
+                };
+            case 'new':
+            case 'reset':
+                // Reset session (keep only system prompt)
+                const systemMsgs = session.messages.filter(m => m.role === 'system');
+                session.messages = systemMsgs;
+                session.messageCount = 0;
+                return { text: '🔄 Conversation reset. Let\'s start fresh!' };
+            case 'help':
+                return {
+                    text: `📖 *ApexBot Commands*\n\n` +
+                        `/status - Show session info\n` +
+                        `/new - Reset conversation\n` +
+                        `/model <name> - Change AI model\n` +
+                        `/help - Show this help\n\n` +
+                        `Just send a message to chat with me!`,
+                };
+            case 'model':
+                if (args.length > 0) {
+                    session.model = args.join(' ');
+                    return { text: `✅ Model changed to: ${session.model}` };
+                }
+                return { text: `Current model: ${session.model || this.config?.model || 'default'}` };
+            default:
+                return { text: `❓ Unknown command: /${cmd}\nType /help for available commands.` };
+        }
+    }
+    getStatus() {
+        return {
+            provider: this.config?.provider || 'none',
+            model: this.config?.model || 'none',
+            configured: this.config !== null,
+        };
+    }
+}
+exports.AgentManager = AgentManager;
+exports.default = AgentManager;

package/dist/backtest/backtester.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Backtester = void 0;
+class Backtester {
+    engine;
+    ticks;
+    constructor(engine, ticks) {
+        this.engine = engine;
+        this.ticks = ticks;
+    }
+    run() {
+        // naive: feed ticks sequentially; when engine places an order we simulate immediate fill
+        for (const t of this.ticks) {
+            // feed market update
+            // @ts-ignore - use same event signature
+            (require('../eventBus').emit)('market:update', { marketId: t.marketId, price: t.price, probModel: t.price });
+            // In a realistic backtest we'd capture orders via event listeners and simulate fills; simple approach:
+            // If EV positive and order placed, compute pnl = (outcome * 1 - price) * (stake / price) ???
+            // For simplicity, assume stake purchased S at price p buys shares = S / p; payoff if outcome=1 is shares*1
+        }
+    }
+}
+exports.Backtester = Backtester;
+exports.default = Backtester;

package/dist/channels/channelManager.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Channel Manager - handles all messaging channels
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = void 0;
+class ChannelManager {
+    channels = new Map();
+    gateway;
+    constructor(gateway) {
+        this.gateway = gateway;
+    }
+    register(channel) {
+        this.channels.set(channel.name, channel);
+        console.log(`[Channels] Registered: ${channel.name}`);
+    }
+    async connect(name) {
+        const channel = this.channels.get(name);
+        if (!channel) {
+            throw new Error(`Channel not found: ${name}`);
+        }
+        await channel.connect();
+    }
+    async connectAll() {
+        const promises = Array.from(this.channels.values()).map(async (ch) => {
+            try {
+                await ch.connect();
+            }
+            catch (e) {
+                console.error(`[Channels] Failed to connect ${ch.name}:`, e);
+            }
+        });
+        await Promise.all(promises);
+    }
+    async disconnect(name) {
+        const channel = this.channels.get(name);
+        if (channel) {
+            await channel.disconnect();
+        }
+    }
+    async disconnectAll() {
+        const promises = Array.from(this.channels.values()).map(ch => ch.disconnect());
+        await Promise.all(promises);
+    }
+    async send(channelName, to, text, replyTo) {
+        const channel = this.channels.get(channelName);
+        if (!channel) {
+            // For webchat, broadcast via gateway
+            if (channelName === 'webchat') {
+                this.gateway.broadcast({ type: 'response', text, to });
+                return;
+            }
+            throw new Error(`Channel not found: ${channelName}`);
+        }
+        await channel.send(to, text, replyTo);
+    }
+    getStatus() {
+        const status = {};
+        for (const [name, channel] of this.channels) {
+            status[name] = channel.status;
+        }
+        return status;
+    }
+    get(name) {
+        return this.channels.get(name);
+    }
+    list() {
+        return Array.from(this.channels.keys());
+    }
+}
+exports.ChannelManager = ChannelManager;
+exports.default = ChannelManager;

package/dist/channels/discord.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Discord Channel - Bot integration via discord.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordChannel = void 0;
+const discord_js_1 = require("discord.js");
+const eventBus_1 = require("../core/eventBus");
+class DiscordChannel {
+    name = 'discord';
+    status = 'disconnected';
+    client;
+    config;
+    constructor(config) {
+        this.config = {
+            allowDMs: true,
+            requireMention: true,
+            ...config,
+        };
+        this.client = new discord_js_1.Client({
+            intents: [
+                discord_js_1.GatewayIntentBits.Guilds,
+                discord_js_1.GatewayIntentBits.GuildMessages,
+                discord_js_1.GatewayIntentBits.MessageContent,
+                discord_js_1.GatewayIntentBits.DirectMessages,
+            ],
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.client.on('ready', () => {
+            console.log(`[Discord] Logged in as ${this.client.user?.tag}`);
+            this.status = 'connected';
+            (0, eventBus_1.emit)('channel:status', { channel: 'discord', status: 'connected' });
+        });
+        this.client.on('messageCreate', async (message) => {
+            // Ignore bot messages
+            if (message.author.bot)
+                return;
+            const isGroup = message.guild !== null;
+            const isDM = message.channel.type === 1; // DM channel
+            // Check DM permission
+            if (isDM && !this.config.allowDMs)
+                return;
+            // Check guild permission
+            if (isGroup && this.config.allowedGuilds?.length) {
+                if (!this.config.allowedGuilds.includes(message.guild.id))
+                    return;
+            }
+            // Check channel permission
+            if (this.config.allowedChannels?.length) {
+                if (!this.config.allowedChannels.includes(message.channel.id))
+                    return;
+            }
+            // In guilds, check for mention
+            if (isGroup && this.config.requireMention) {
+                const mentioned = message.mentions.has(this.client.user.id) ||
+                    message.content.toLowerCase().includes(`@${this.client.user?.username?.toLowerCase()}`);
+                if (!mentioned)
+                    return;
+            }
+            // Clean text (remove bot mention)
+            let cleanText = message.content
+                .replace(new RegExp(`<@!?${this.client.user?.id}>`, 'g'), '')
+                .trim();
+            // Emit message
+            (0, eventBus_1.emit)('channel:message', {
+                channel: 'discord',
+                from: isDM ? message.author.id : message.channel.id,
+                text: cleanText,
+                id: message.id,
+                isGroup,
+                groupId: isGroup ? message.channel.id : undefined,
+                timestamp: message.createdTimestamp,
+            });
+        });
+        this.client.on('error', (error) => {
+            console.error('[Discord] Error:', error);
+            this.status = 'error';
+            (0, eventBus_1.emit)('channel:status', { channel: 'discord', status: 'error', data: error });
+        });
+    }
+    async connect() {
+        this.status = 'connecting';
+        try {
+            await this.client.login(this.config.botToken);
+        }
+        catch (e) {
+            this.status = 'error';
+            (0, eventBus_1.emit)('channel:status', { channel: 'discord', status: 'error', data: e });
+            throw e;
+        }
+    }
+    async disconnect() {
+        this.client.destroy();
+        this.status = 'disconnected';
+        (0, eventBus_1.emit)('channel:status', { channel: 'discord', status: 'disconnected' });
+    }
+    async send(to, text, replyTo) {
+        const channel = await this.client.channels.fetch(to);
+        if (!channel || !('send' in channel)) {
+            throw new Error(`Cannot send to channel: ${to}`);
+        }
+        const textChannel = channel;
+        // Split long messages (Discord limit: 2000)
+        const maxLength = 2000;
+        if (text.length <= maxLength) {
+            await textChannel.send(text);
+        }
+        else {
+            const chunks = this.splitMessage(text, maxLength);
+            for (const chunk of chunks) {
+                await textChannel.send(chunk);
+            }
+        }
+    }
+    splitMessage(text, maxLength) {
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+            if (remaining.length <= maxLength) {
+                chunks.push(remaining);
+                break;
+            }
+            let splitAt = remaining.lastIndexOf('\n', maxLength);
+            if (splitAt < maxLength / 2) {
+                splitAt = maxLength;
+            }
+            chunks.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt).trim();
+        }
+        return chunks;
+    }
+}
+exports.DiscordChannel = DiscordChannel;
+exports.default = DiscordChannel;