apexbot 1.0.0

package/dist/safety/llmChecker.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafetyChecker = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const eventBus_1 = require("../eventBus");
+/**
+ * LLM-based safety checker for market descriptions.
+ * Uses Google Gemini API.
+ * Analyzes market text for:
+ * - Ambiguous resolution criteria
+ * - Potential for bad-faith resolution
+ * - Misleading question framing
+ * - Political/controversial topics with unclear outcomes
+ */
+class SafetyChecker {
+    client;
+    cfg;
+    cache = new Map();
+    constructor(cfg) {
+        this.cfg = {
+            model: 'gemini-2.0-flash',
+            cacheEnabled: true,
+            ...cfg,
+        };
+        this.client = new generative_ai_1.GoogleGenerativeAI(cfg.googleApiKey);
+    }
+    async checkMarket(marketId, question, description, creatorId) {
+        const cacheKey = `${marketId}:${question.slice(0, 50)}`;
+        if (this.cfg.cacheEnabled && this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        const prompt = `You are a prediction market analyst evaluating market quality and safety for automated trading.
+
+Analyze this market and identify potential issues:
+
+**Question:** ${question}
+
+**Description:** ${description || '(no description provided)'}
+
+**Creator ID:** ${creatorId || 'unknown'}
+
+Evaluate for these risks:
+1. AMBIGUOUS RESOLUTION: Are the resolution criteria clear and objective?
+2. BAD FAITH RISK: Could the creator resolve this unfairly?
+3. MISLEADING FRAMING: Is the question misleading or loaded?
+4. EXTERNAL DEPENDENCY: Does resolution depend on hard-to-verify information?
+5. TIME RISK: Is there a clear end date? Could it drag on indefinitely?
+
+Respond in this exact JSON format:
+{
+  "safe": true/false,
+  "score": 0.0-1.0,
+  "warnings": ["warning1", "warning2"],
+  "reasoning": "brief explanation"
+}
+
+Only output the JSON, nothing else.`;
+        try {
+            const model = this.client.getGenerativeModel({ model: this.cfg.model });
+            const result = await model.generateContent(prompt);
+            const response = await result.response;
+            const text = response.text();
+            const parsed = this.parseResponse(text, marketId);
+            if (this.cfg.cacheEnabled) {
+                this.cache.set(cacheKey, parsed);
+            }
+            // Emit warning if unsafe
+            if (!parsed.safe || parsed.score < 0.5) {
+                (0, eventBus_1.emit)('safety:warning', {
+                    marketId,
+                    question,
+                    reason: parsed.warnings.join('; ') || parsed.reasoning,
+                    score: parsed.score,
+                });
+            }
+            return parsed;
+        }
+        catch (e) {
+            console.error('Safety check failed:', e);
+            // Return conservative result on error
+            return {
+                safe: false,
+                score: 0,
+                warnings: ['Safety check API error'],
+                reasoning: 'Could not complete safety analysis',
+            };
+        }
+    }
+    parseResponse(text, marketId) {
+        try {
+            // Extract JSON from response (handle markdown code blocks)
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                throw new Error('No JSON found');
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                safe: Boolean(parsed.safe),
+                score: Math.max(0, Math.min(1, Number(parsed.score) || 0)),
+                warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
+                reasoning: String(parsed.reasoning || ''),
+            };
+        }
+        catch (e) {
+            console.error(`Failed to parse safety response for ${marketId}:`, text);
+            return {
+                safe: false,
+                score: 0.3,
+                warnings: ['Could not parse safety analysis'],
+                reasoning: text.slice(0, 200),
+            };
+        }
+    }
+    /**
+     * Quick heuristic check (no API call).
+     * Returns true if market passes basic sanity checks.
+     */
+    quickCheck(question, description) {
+        const issues = [];
+        // Check for common red flags
+        if (!description || description.length < 20) {
+            issues.push('No or very short description');
+        }
+        if (question.includes('?') === false) {
+            issues.push('Question mark missing - may not be a clear question');
+        }
+        const redFlags = [
+            /i will resolve/i,
+            /resolve.*my (discretion|judgment)/i,
+            /subjective/i,
+            /vibe|feeling|think/i,
+            /probably|maybe|might/i,
+        ];
+        for (const flag of redFlags) {
+            if (flag.test(description)) {
+                issues.push(`Red flag pattern: ${flag.toString()}`);
+            }
+        }
+        return {
+            pass: issues.length === 0,
+            issues,
+        };
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+exports.SafetyChecker = SafetyChecker;
+exports.default = SafetyChecker;

package/dist/sessions/sessionManager.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Session Manager - handles conversation sessions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+class SessionManager {
+    sessions = new Map();
+    maxHistoryLength = 50;
+    makeId(channel, peer, isGroup, groupId) {
+        if (isGroup && groupId) {
+            return `${channel}:group:${groupId}`;
+        }
+        return `${channel}:dm:${peer}`;
+    }
+    getOrCreate(channel, peer, isGroup, groupId) {
+        const id = this.makeId(channel, peer, isGroup, groupId);
+        let session = this.sessions.get(id);
+        if (!session) {
+            session = {
+                id,
+                channel,
+                peer,
+                isGroup,
+                groupId,
+                messages: [],
+                messageCount: 0,
+                createdAt: Date.now(),
+                lastActivity: Date.now(),
+            };
+            this.sessions.set(id, session);
+            console.log(`[Sessions] Created session: ${id}`);
+        }
+        return session;
+    }
+    get(id) {
+        return this.sessions.get(id);
+    }
+    addMessage(sessionId, role, content) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.messages.push({
+            role,
+            content,
+            timestamp: Date.now(),
+        });
+        session.messageCount++;
+        session.lastActivity = Date.now();
+        // Trim history if too long
+        if (session.messages.length > this.maxHistoryLength) {
+            // Keep system message if present, trim oldest user/assistant messages
+            const systemMsgs = session.messages.filter(m => m.role === 'system');
+            const otherMsgs = session.messages.filter(m => m.role !== 'system');
+            session.messages = [
+                ...systemMsgs,
+                ...otherMsgs.slice(-this.maxHistoryLength + systemMsgs.length),
+            ];
+        }
+    }
+    getHistory(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.messages || [];
+    }
+    reset(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            const systemMsgs = session.messages.filter(m => m.role === 'system');
+            session.messages = systemMsgs; // Keep system prompt
+            session.messageCount = 0;
+            console.log(`[Sessions] Reset session: ${sessionId}`);
+        }
+    }
+    delete(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    getAll() {
+        return Array.from(this.sessions.values());
+    }
+    count() {
+        return this.sessions.size;
+    }
+    setSystemPrompt(sessionId, prompt) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.systemPrompt = prompt;
+            // Add or update system message
+            const systemIdx = session.messages.findIndex(m => m.role === 'system');
+            if (systemIdx >= 0) {
+                session.messages[systemIdx].content = prompt;
+            }
+            else {
+                session.messages.unshift({ role: 'system', content: prompt, timestamp: Date.now() });
+            }
+        }
+    }
+    setModel(sessionId, model) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.model = model;
+        }
+    }
+    // Cleanup old sessions
+    cleanup(maxAgeMs = 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - maxAgeMs;
+        let cleaned = 0;
+        for (const [id, session] of this.sessions) {
+            if (session.lastActivity < cutoff) {
+                this.sessions.delete(id);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[Sessions] Cleaned up ${cleaned} old sessions`);
+        }
+        return cleaned;
+    }
+}
+exports.SessionManager = SessionManager;
+exports.default = SessionManager;

package/dist/strategy/arbitrage.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArbitrageDetector = void 0;
+const eventBus_1 = require("../eventBus");
+/**
+ * Arbitrage detector for Manifold Markets.
+ * Detects:
+ * 1. Binary complement arb: market A (YES) + market B (NO on same event) should sum to ~1
+ * 2. Multi-outcome arb: multiple choice markets where probabilities don't sum to 1
+ * 3. Correlated market arb: related markets with known relationships
+ */
+class ArbitrageDetector {
+    cfg;
+    manifold;
+    marketCache = new Map();
+    constructor(manifold, cfg) {
+        this.manifold = manifold;
+        this.cfg = cfg;
+    }
+    /**
+     * Check for binary complement arbitrage.
+     * If buying YES on market A at price pA and YES on market B (which is "NOT A") at pB,
+     * and pA + pB < 1, there's an arbitrage opportunity.
+     */
+    checkBinaryComplement(marketA, marketB) {
+        const pA = marketA.probability;
+        const pB = marketB.probability;
+        // If these are complementary events (A and NOT A), probabilities should sum to 1
+        // If pA + pB < 1, buy both YES; if pA + pB > 1, buy both NO
+        const sum = pA + pB;
+        if (sum < 1 - 0.02) {
+            // Buy YES on both; guaranteed profit = 1 - sum per $1 total invested
+            const profitPerDollar = 1 - sum;
+            const expectedProfit = profitPerDollar * 100; // assuming $100 total stake
+            if (expectedProfit >= this.cfg.minProfitThreshold) {
+                return {
+                    type: 'binary_complement',
+                    markets: [marketA.id, marketB.id],
+                    expectedProfit,
+                    details: `Buy YES on both: ${marketA.question} (${(pA * 100).toFixed(1)}%) + ${marketB.question} (${(pB * 100).toFixed(1)}%) = ${(sum * 100).toFixed(1)}% < 100%`,
+                    timestamp: Date.now(),
+                };
+            }
+        }
+        if (sum > 1 + 0.02) {
+            // Buy NO on both; profit = sum - 1
+            const profitPerDollar = sum - 1;
+            const expectedProfit = profitPerDollar * 100;
+            if (expectedProfit >= this.cfg.minProfitThreshold) {
+                return {
+                    type: 'binary_complement',
+                    markets: [marketA.id, marketB.id],
+                    expectedProfit,
+                    details: `Buy NO on both: ${marketA.question} (${(pA * 100).toFixed(1)}%) + ${marketB.question} (${(pB * 100).toFixed(1)}%) = ${(sum * 100).toFixed(1)}% > 100%`,
+                    timestamp: Date.now(),
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Check correlated pairs from config.
+     */
+    async checkCorrelatedPairs() {
+        const opportunities = [];
+        for (const pair of this.cfg.correlatedPairs) {
+            try {
+                const [marketA, marketB] = await Promise.all([
+                    this.getMarketCached(pair.marketA),
+                    this.getMarketCached(pair.marketB),
+                ]);
+                if (!marketA || !marketB)
+                    continue;
+                if (pair.relation === 'sum_to_one') {
+                    const arb = this.checkBinaryComplement(marketA, marketB);
+                    if (arb) {
+                        arb.type = 'correlated';
+                        opportunities.push(arb);
+                    }
+                }
+                else if (pair.relation === 'positive') {
+                    // Markets should move together; large divergence = opportunity
+                    const diff = Math.abs(marketA.probability - marketB.probability);
+                    if (diff > 0.15) { // >15% divergence
+                        opportunities.push({
+                            type: 'correlated',
+                            markets: [marketA.id, marketB.id],
+                            expectedProfit: diff * 50, // rough estimate
+                            details: `Correlated markets diverged: ${marketA.question} (${(marketA.probability * 100).toFixed(1)}%) vs ${marketB.question} (${(marketB.probability * 100).toFixed(1)}%)`,
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+                else if (pair.relation === 'negative') {
+                    // Markets should move opposite; if both high or both low = opportunity
+                    const sum = marketA.probability + marketB.probability;
+                    if (Math.abs(sum - 1) > 0.15) {
+                        opportunities.push({
+                            type: 'correlated',
+                            markets: [marketA.id, marketB.id],
+                            expectedProfit: Math.abs(sum - 1) * 50,
+                            details: `Negative correlation broken: ${marketA.question} (${(marketA.probability * 100).toFixed(1)}%) + ${marketB.question} (${(marketB.probability * 100).toFixed(1)}%) = ${(sum * 100).toFixed(1)}%`,
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`Error checking pair ${pair.marketA}/${pair.marketB}:`, e);
+            }
+        }
+        return opportunities;
+    }
+    /**
+     * Scan for arbitrage across all markets (expensive; use sparingly).
+     */
+    async scanAllMarkets(limit = 100) {
+        const markets = await this.manifold.getMarkets(limit);
+        const opportunities = [];
+        // Update cache
+        for (const m of markets) {
+            this.marketCache.set(m.id, m);
+        }
+        // Check configured correlated pairs
+        const corrArbs = await this.checkCorrelatedPairs();
+        opportunities.push(...corrArbs);
+        // Emit opportunities
+        for (const opp of opportunities) {
+            (0, eventBus_1.emit)('arb:opportunity', opp);
+        }
+        return opportunities;
+    }
+    async getMarketCached(id) {
+        if (this.marketCache.has(id)) {
+            return this.marketCache.get(id);
+        }
+        try {
+            const m = await this.manifold.getMarket(id);
+            this.marketCache.set(id, m);
+            return m;
+        }
+        catch {
+            return null;
+        }
+    }
+    clearCache() {
+        this.marketCache.clear();
+    }
+}
+exports.ArbitrageDetector = ArbitrageDetector;
+exports.default = ArbitrageDetector;

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "apexbot",
+  "version": "1.0.0",
+  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Like Clawdbot but open-source!",
+  "main": "dist/index.js",
+  "bin": {
+    "apexbot": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "preferGlobal": true,
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/cli/index.ts gateway",
+    "cli": "ts-node src/cli/index.ts",
+    "gateway": "ts-node src/cli/index.ts gateway",
+    "onboard": "ts-node src/cli/index.ts onboard",
+    "dev": "ts-node-dev --respawn src/cli/index.ts gateway --verbose",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo 'TODO: add eslint'",
+    "test": "echo 'TODO: add tests' && exit 0"
+  },
+  "keywords": [
+    "ai-assistant",
+    "telegram-bot",
+    "discord-bot",
+    "chatbot",
+    "ollama",
+    "local-llm",
+    "gemini",
+    "claude",
+    "openai",
+    "typescript",
+    "free",
+    "open-source"
+  ],
+  "author": "ApexBot Team",
+  "license": "MIT",
+  "homepage": "https://github.com/YOUR_USERNAME/apexbot#readme",
+  "bugs": {
+    "url": "https://github.com/YOUR_USERNAME/apexbot/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YOUR_USERNAME/apexbot.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@google/generative-ai": "^0.24.1",
+    "axios": "^1.5.0",
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "discord.js": "^14.25.1",
+    "dotenv": "^17.2.3",
+    "eventemitter3": "^4.0.7",
+    "figlet": "^1.10.0",
+    "grammy": "^1.39.3",
+    "inquirer": "^8.2.7",
+    "ora": "^5.4.1",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}

package/scripts/install.ps1

@@ -0,0 +1,114 @@
+#!/usr/bin/env pwsh
+# ApexBot Installer for Windows
+# Usage: iwr -useb https://raw.githubusercontent.com/YOUR_USERNAME/apexbot/main/scripts/install.ps1 | iex
+
+$ErrorActionPreference = "Stop"
+
+# Colors
+function Write-Color($Text, $Color) {
+    Write-Host $Text -ForegroundColor $Color
+}
+
+# ASCII Art
+$logo = @"
+
+    ___    ____  _______  ______  ____  ______
+   /   |  / __ \/ ____/ |/ / __ )/ __ \/_  __/
+  / /| | / /_/ / __/  |   / __  / / / / / /   
+ / ___ |/ ____/ /___ /   / /_/ / /_/ / / /    
+/_/  |_/_/   /_____//_/|_/_____/\____/ /_/    
+                                               
+       🦊 Your Free AI Assistant 🦊
+"@
+
+Write-Color $logo "Cyan"
+Write-Host ""
+Write-Color "Welcome to ApexBot Installer!" "Green"
+Write-Host ""
+
+# Check Node.js
+Write-Host "Checking prerequisites..." -NoNewline
+if (!(Get-Command node -ErrorAction SilentlyContinue)) {
+    Write-Color " FAILED" "Red"
+    Write-Host ""
+    Write-Color "Node.js is required but not installed." "Yellow"
+    Write-Host "Install Node.js from: https://nodejs.org/"
+    Write-Host ""
+    $install = Read-Host "Would you like to install Node.js via winget? (Y/n)"
+    if ($install -ne "n" -and $install -ne "N") {
+        winget install OpenJS.NodeJS.LTS
+        Write-Color "Please restart your terminal and run this installer again." "Yellow"
+        exit 0
+    }
+    exit 1
+}
+Write-Color " OK" "Green"
+
+# Check npm
+if (!(Get-Command npm -ErrorAction SilentlyContinue)) {
+    Write-Color "npm is required but not installed." "Red"
+    exit 1
+}
+
+# Check Ollama (optional but recommended)
+Write-Host "Checking Ollama (recommended for free AI)..." -NoNewline
+$ollamaInstalled = Get-Command ollama -ErrorAction SilentlyContinue
+if ($ollamaInstalled) {
+    Write-Color " INSTALLED" "Green"
+} else {
+    Write-Color " NOT FOUND" "Yellow"
+    Write-Host ""
+    Write-Color "Ollama is recommended for 100% free, local AI." "Yellow"
+    Write-Host "Install from: https://ollama.com"
+    Write-Host ""
+    $installOllama = Read-Host "Would you like to install Ollama via winget? (Y/n)"
+    if ($installOllama -ne "n" -and $installOllama -ne "N") {
+        winget install Ollama.Ollama
+        Write-Color "Ollama installed! Pull a model with: ollama pull llama3.2" "Green"
+    }
+}
+
+Write-Host ""
+Write-Color "Installing ApexBot..." "Cyan"
+Write-Host ""
+
+# Install ApexBot globally
+try {
+    npm install -g apexbot
+    Write-Color "ApexBot installed successfully!" "Green"
+} catch {
+    Write-Color "npm global install failed, trying with sudo..." "Yellow"
+    npm install -g apexbot --unsafe-perm
+}
+
+Write-Host ""
+Write-Color "================================================" "Cyan"
+Write-Host ""
+Write-Color "🎉 Installation Complete!" "Green"
+Write-Host ""
+Write-Host "Next steps:"
+Write-Host "  1. Run: " -NoNewline
+Write-Color "apexbot onboard" "Yellow"
+Write-Host "  2. Follow the setup wizard"
+Write-Host "  3. Start your bot: " -NoNewline
+Write-Color "apexbot daemon start" "Yellow"
+Write-Host ""
+
+# Check if Ollama needs setup
+if ($ollamaInstalled) {
+    Write-Host "Ollama detected! Make sure to:"
+    Write-Host "  - Pull a model: " -NoNewline
+    Write-Color "ollama pull llama3.2" "Yellow"
+    Write-Host "  - Start Ollama: " -NoNewline
+    Write-Color "ollama serve" "Yellow"
+    Write-Host ""
+}
+
+Write-Color "Documentation: https://github.com/YOUR_USERNAME/apexbot" "Cyan"
+Write-Host ""
+
+# Offer to run onboard
+$runOnboard = Read-Host "Would you like to run the setup wizard now? (Y/n)"
+if ($runOnboard -ne "n" -and $runOnboard -ne "N") {
+    apexbot onboard
+}