polly-gamba 1.0.3 → 1.0.4

package/dist/claude-trader.d.ts

@@ -0,0 +1,36 @@
+import { PriceSignal } from './signals/coinbase-ws';
+import { Market } from './markets/gamma';
+export interface TraderConfig {
+    cwd: string;
+    redisPrefix: string;
+    model?: string;
+    envOverrides?: Record<string, string>;
+    label: string;
+}
+export declare class ClaudeTrader {
+    private proc;
+    private redis;
+    private ready;
+    private queue;
+    private config;
+    constructor(config: TraderConfig);
+    start(): void;
+    private handleOutputLine;
+    private sendRaw;
+    private flushQueue;
+    onSignal(signal: PriceSignal, markets: Market[]): Promise<void>;
+    onAutonomousScan(markets: Market[]): Promise<void>;
+    onPositionReview(positions: Array<{
+        market_id: string;
+        market_question: string;
+        outcome: string;
+        side: string;
+        price: number;
+        size_usdc: number;
+        exit_trigger?: string;
+        ts: number;
+        current_price?: number;
+        hours_to_expiry?: number;
+    }>): Promise<void>;
+    private log;
+}

package/dist/claude-trader.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeTrader = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+const ioredis_1 = __importDefault(require("ioredis"));
+function findClaudeBin() {
+    const candidates = [
+        process.env.CLAUDE_BIN,
+        '/Users/feral/.npm-global/bin/claude',
+        '/usr/local/bin/claude',
+        '/opt/homebrew/bin/claude',
+    ].filter(Boolean);
+    try {
+        const fromWhich = (0, child_process_1.execSync)('which claude 2>/dev/null', { encoding: 'utf8' }).trim();
+        if (fromWhich)
+            candidates.unshift(fromWhich);
+    }
+    catch { }
+    for (const p of candidates) {
+        if ((0, fs_1.existsSync)(p))
+            return p;
+    }
+    throw new Error(`claude binary not found. Tried: ${candidates.join(', ')}. Set CLAUDE_BIN env var.`);
+}
+const CLAUDE_BIN = findClaudeBin();
+const CLAUDE_TOKEN = process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY || '';
+class ClaudeTrader {
+    proc = null;
+    redis;
+    ready = false;
+    queue = [];
+    config;
+    constructor(config) {
+        this.config = config;
+        this.redis = new ioredis_1.default(process.env.REDIS_URL || 'redis://localhost:6379', {
+            retryStrategy: (times) => Math.min(times * 500, 5000),
+            maxRetriesPerRequest: null,
+            enableReadyCheck: false,
+        });
+        this.redis.on('error', (e) => console.error(`[redis:${config.label}]`, e.message));
+    }
+    start() {
+        const env = {
+            ...process.env,
+        };
+        if (CLAUDE_TOKEN) {
+            if (CLAUDE_TOKEN.startsWith('sk-ant-oat')) {
+                env.CLAUDE_CODE_OAUTH_TOKEN = CLAUDE_TOKEN;
+            }
+            else {
+                env.ANTHROPIC_API_KEY = CLAUDE_TOKEN;
+            }
+        }
+        if (this.config.envOverrides) {
+            Object.assign(env, this.config.envOverrides);
+        }
+        const args = [
+            '--output-format', 'stream-json',
+            '--input-format', 'stream-json',
+            '--print',
+            '--verbose',
+            '--dangerously-skip-permissions',
+        ];
+        if (this.config.model) {
+            args.push('--model', this.config.model);
+        }
+        this.proc = (0, child_process_1.spawn)(CLAUDE_BIN, args, { cwd: this.config.cwd, env });
+        const rl = (0, readline_1.createInterface)({ input: this.proc.stdout });
+        rl.on('line', (line) => this.handleOutputLine(line));
+        this.proc.stderr?.on('data', (d) => {
+            const s = d.toString();
+            if (s.trim())
+                this.log('stderr', { text: s.trim() }).catch(() => { });
+        });
+        this.proc.on('close', (code) => {
+            console.error(`[claude-trader:${this.config.label}] process closed (code=${code}) — restarting in 5s`);
+            this.log('process', { event: 'closed', code }).catch(() => { });
+            this.proc = null;
+            this.ready = false;
+            setTimeout(() => this.start(), 5000);
+        });
+        this.proc.on('error', (err) => {
+            console.error(`[claude-trader:${this.config.label}] spawn error:`, err.message);
+            this.log('process', { event: 'error', message: err.message }).catch(() => { });
+        });
+        // Send system context after brief startup delay
+        setTimeout(() => {
+            this.sendRaw(JSON.stringify({
+                type: 'user',
+                message: {
+                    role: 'user',
+                    content: `You are a Polymarket paper trader running a high-volume moneyball strategy. Your job is to place paper trades on EVERY market where you have ANY opinion on fair value — even slight.
+
+TOOLS: place_order, skip_all, get_budget_status
+RULES:
+- Output ONLY tool calls. Zero prose.
+- For EVERY market in the list: if current price differs from your estimated fair probability by more than 5%, place a trade.
+- YES is underpriced → BUY YES. NO is underpriced (YES overpriced) → BUY NO.
+- $10 USDC per trade (small size, many bets).
+- NO cap on number of trades — bet every market where you see any edge.
+- Only skip_all if you genuinely have zero opinion on any market (rare).
+- Use your world knowledge: sports standings, political context, recent events, base rates.
+
+## POSITION DISCIPLINE:
+- Max $100 per market (20% of $500 budget). The MCP enforces this — don't fight it.
+- To add to an existing position: you MUST cite a specific new catalyst (news published in last 24h, not price movement). Price dipping is NOT a catalyst. Price rising is NOT a catalyst. New information is a catalyst.
+- exit_trigger is required on every trade. Be specific: "Exit when price hits 0.X" or "Exit when [specific news event]" — not "when narrative converges."
+- Call get_budget_status at the start of each scan to know available capital.`
+                }
+            }));
+            this.ready = true;
+            this.flushQueue();
+            console.log(`[claude-trader:${this.config.label}] ready`);
+        }, 2000);
+    }
+    handleOutputLine(line) {
+        if (!line.trim())
+            return;
+        try {
+            const msg = JSON.parse(line);
+            this.log('claude_output', msg).catch(() => { });
+        }
+        catch {
+            this.log('claude_raw', { text: line }).catch(() => { });
+        }
+    }
+    sendRaw(json) {
+        if (this.proc?.stdin?.writable) {
+            this.proc.stdin.write(json + '\n');
+        }
+    }
+    flushQueue() {
+        while (this.queue.length && this.ready) {
+            this.sendRaw(this.queue.shift());
+        }
+    }
+    async onSignal(signal, markets) {
+        const signalId = signal.id || Math.random().toString(36).slice(2);
+        const pct = signal.pct_change;
+        const prefix = this.config.redisPrefix;
+        // Log signal to Redis
+        await this.redis.lpush(`${prefix}:signals`, JSON.stringify({ ...signal, id: signalId, markets_count: markets.length }));
+        await this.redis.ltrim(`${prefix}:signals`, 0, 9999);
+        await this.redis.set(`${prefix}:signal:${signalId}`, JSON.stringify({ signal, markets }), 'EX', 86400);
+        const prompt = `## Signal ${signalId}
+
+**${signal.asset} ${signal.direction === 'up' ? '+' : '-'}${(Math.abs(pct) * 100).toFixed(2)}%** @ $${signal.price.toFixed(2)}
+Window: ${signal.window_secs}s | Time: ${new Date(signal.signal_ts).toISOString()}
+
+## Relevant Polymarket Markets (${markets.length} found)
+
+${markets.map((m, i) => `### ${i + 1}. ${m.question}
+- Volume: $${(m.volume || 0).toLocaleString()}
+- Liquidity: $${(m.liquidity || 0).toLocaleString()}
+- Market ID: ${m.id}
+- Tokens: ${m.tokens?.map(t => `${t.outcome}@${t.price}`).join(', ') || 'none'}
+${m.description ? `- Description: ${m.description.slice(0, 200)}` : ''}`).join('\n\n')}
+
+Call place_order on any market you have edge on. $10 per trade. No cap.`;
+        const msg = JSON.stringify({
+            type: 'user',
+            message: { role: 'user', content: prompt }
+        });
+        if (this.ready) {
+            this.sendRaw(msg);
+        }
+        else {
+            this.queue.push(msg);
+        }
+    }
+    async onAutonomousScan(markets) {
+        const scanId = Math.random().toString(36).slice(2);
+        const prefix = this.config.redisPrefix;
+        await this.redis.lpush(`${prefix}:scans`, JSON.stringify({ scanId, markets_count: markets.length, ts: Date.now() }));
+        await this.redis.ltrim(`${prefix}:scans`, 0, 9999);
+        const tradeable = markets.filter(m => m.tokens?.some(t => t.price > 0.02 && t.price < 0.98));
+        const prompt = `## Autonomous Scan ${scanId}
+
+Time: ${new Date().toISOString()}
+
+## High-Quality Markets (${tradeable.length} found — vol24h>$50k, liq>$50k, price 0.10-0.90)
+
+${tradeable.map((m, i) => `### ${i + 1}. ${m.question}
+- Volume 24h: $${(m.volume24hr || 0).toLocaleString()}
+- Liquidity: $${(m.liquidity || 0).toLocaleString()}
+- Market ID: ${m.id}
+- Tokens: ${m.tokens?.map(t => `${t.outcome}@${t.price}`).join(', ') || 'none'}
+${m.description ? `- Description: ${m.description.slice(0, 200)}` : ''}`).join('\n\n')}
+
+For EVERY market above: if price differs from your fair probability by >5%, place a trade ($10 USDC). Call skip_all only if you have zero opinion on all markets.`;
+        const msg = JSON.stringify({
+            type: 'user',
+            message: { role: 'user', content: prompt }
+        });
+        if (this.ready) {
+            this.sendRaw(msg);
+        }
+        else {
+            this.queue.push(msg);
+        }
+    }
+    async onPositionReview(positions) {
+        const prefix = this.config.redisPrefix;
+        await this.redis.lpush(`${prefix}:reviews`, JSON.stringify({ ts: Date.now(), positions_count: positions.length }));
+        await this.redis.ltrim(`${prefix}:reviews`, 0, 9999);
+        const positionLines = positions.map(p => {
+            const gainPct = p.current_price != null && p.price > 0
+                ? (((p.current_price - p.price) / p.price) * 100).toFixed(1)
+                : 'N/A';
+            return `### ${p.market_id} ${p.market_question}
+- Side: ${p.side} ${p.outcome} | Entry: ${p.price} | Now: ${p.current_price ?? 'N/A'} | Gain: ${gainPct}%
+- Exit trigger: ${p.exit_trigger || '(none set)'}
+- Size: $${p.size_usdc} | Hours to expiry: ${p.hours_to_expiry ?? 'N/A'}h`;
+        }).join('\n\n');
+        const prompt = `## Position Review — ${new Date().toISOString()}
+
+Review each open position against its stated exit trigger. Call close_position for any position that has hit its exit condition.
+
+${positionLines}
+
+For each position that has reached its exit_trigger condition: call close_position immediately.
+For positions still within bounds: do nothing (no output needed).`;
+        const msg = JSON.stringify({
+            type: 'user',
+            message: { role: 'user', content: prompt }
+        });
+        if (this.ready) {
+            this.sendRaw(msg);
+        }
+        else {
+            this.queue.push(msg);
+        }
+    }
+    async log(type, data) {
+        const prefix = this.config.redisPrefix;
+        const entry = JSON.stringify({ type, data, ts: Date.now(), model: this.config.label });
+        await this.redis.lpush(`${prefix}:log`, entry);
+        await this.redis.ltrim(`${prefix}:log`, 0, 9999);
+    }
+}
+exports.ClaudeTrader = ClaudeTrader;
+//# sourceMappingURL=claude-trader.js.map

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,132 @@
+"use strict";
+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 });
+const coinbase_ws_1 = require("./signals/coinbase-ws");
+const gamma_1 = require("./markets/gamma");
+const claude_trader_1 = require("./claude-trader");
+const position_monitor_1 = require("./position-monitor");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CWD = process.env.POLLY_CWD || path.join(os.homedir(), 'polly-gamba');
+async function main() {
+    console.log('[polly-gamba] Starting paper trading service');
+    console.log(`[polly-gamba] Claude cwd: ${CWD}`);
+    const anthropicTrader = new claude_trader_1.ClaudeTrader({ cwd: CWD, redisPrefix: 'polly', label: 'anthropic' });
+    const ollamaTrader = new claude_trader_1.ClaudeTrader({
+        cwd: CWD,
+        redisPrefix: 'polly:ollama',
+        label: 'ollama',
+        model: 'glm-4.7-flash',
+        envOverrides: {
+            ANTHROPIC_BASE_URL: 'http://localhost:11434',
+            ANTHROPIC_AUTH_TOKEN: 'ollama',
+            ANTHROPIC_API_KEY: 'ollama',
+            USER_TYPE: 'ant',
+        },
+    });
+    const signals = new coinbase_ws_1.CoinbaseSignalDetector();
+    const monitor = new position_monitor_1.PositionMonitor(process.env.REDIS_URL || 'redis://localhost:6379', 'polly');
+    anthropicTrader.start();
+    ollamaTrader.start();
+    signals.on('signal', (signal) => {
+        console.log(`[signal] ${signal.asset} ${signal.direction} ${(Math.abs(signal.pct_change) * 100).toFixed(2)}% @ $${signal.price.toLocaleString()}`);
+        handleSignal(signal, anthropicTrader, ollamaTrader).catch((e) => {
+            console.error('[error] signal handling failed:', e.message);
+        });
+    });
+    signals.start();
+    console.log('[polly-gamba] Listening for BTC/ETH price signals (threshold: 0.5% in 60s)...');
+    // Position monitor: check every 15 minutes for exits
+    const SCAN_INTERVAL_MS = 15 * 60 * 1000; // 15 minutes
+    monitor.checkPositions().catch((e) => console.error('[monitor]', e.message));
+    setInterval(() => {
+        monitor.checkPositions().catch((e) => console.error('[monitor]', e.message));
+    }, SCAN_INTERVAL_MS);
+    // Autonomous scan on startup and every 15 minutes
+    autonomousScan(anthropicTrader, ollamaTrader).catch((e) => {
+        console.error('[error] autonomous scan failed:', e.message);
+    });
+    setInterval(() => {
+        autonomousScan(anthropicTrader, ollamaTrader).catch((e) => {
+            console.error('[error] autonomous scan failed:', e.message);
+        });
+    }, SCAN_INTERVAL_MS);
+    process.on('SIGINT', () => {
+        console.log('\n[polly-gamba] Shutting down...');
+        signals.stop();
+        monitor.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        signals.stop();
+        monitor.stop();
+        process.exit(0);
+    });
+}
+async function autonomousScan(...traders) {
+    console.log('[scan] fetching high-quality markets (vol24h>$50k, liq>$50k, price 0.10-0.90)');
+    let markets;
+    try {
+        markets = await (0, gamma_1.fetchHighQualityMarkets)();
+    }
+    catch (e) {
+        console.error('[scan] failed to fetch markets:', e.message);
+        return;
+    }
+    console.log(`[scan] ${markets.length} high-quality markets for autonomous review`);
+    await Promise.all(traders.map(t => t.onAutonomousScan(markets)));
+}
+async function handleSignal(signal, ...traders) {
+    let markets;
+    try {
+        markets = await (0, gamma_1.fetchActiveMarkets)(10_000, 1_000);
+    }
+    catch (e) {
+        console.error('[error] failed to fetch markets:', e.message);
+        return;
+    }
+    const relevant = (0, gamma_1.filterBySignal)(signal.asset, markets);
+    console.log(`[match] ${relevant.length} markets for ${signal.asset} signal`);
+    if (relevant.length === 0) {
+        console.log('[match] no relevant markets found');
+        return;
+    }
+    await Promise.all(traders.map(t => t.onSignal(signal, relevant)));
+}
+main().catch((err) => {
+    console.error('[polly-gamba] Fatal:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/markets/clob.d.ts

@@ -0,0 +1,32 @@
+export interface OrderbookLevel {
+    price: string;
+    size: string;
+}
+export interface Orderbook {
+    market: string;
+    asset_id: string;
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+    spread?: number;
+}
+export interface PlaceOrderParams {
+    token_id: string;
+    side: 'BUY' | 'SELL';
+    size_usdc: number;
+    price: number;
+    dry_run?: boolean;
+}
+export interface OrderResult {
+    dry_run: boolean;
+    token_id: string;
+    side: 'BUY' | 'SELL';
+    size_usdc: number;
+    price: number;
+    estimated_shares: number;
+    order_id?: string;
+    logged_at: number;
+}
+export declare function getOrderbook(tokenId: string): Promise<Orderbook>;
+export declare function getPrice(tokenId: string, side: 'buy' | 'sell'): Promise<number>;
+export declare function getPrices(tokenIds: string[]): Promise<Map<string, number>>;
+export declare function placeOrder(params: PlaceOrderParams): Promise<OrderResult>;

package/dist/markets/clob.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderbook = getOrderbook;
+exports.getPrice = getPrice;
+exports.getPrices = getPrices;
+exports.placeOrder = placeOrder;
+const CLOB_BASE = 'https://clob.polymarket.com';
+async function getOrderbook(tokenId) {
+    const url = `${CLOB_BASE}/book?token_id=${encodeURIComponent(tokenId)}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`CLOB getOrderbook error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    const bids = (data.bids ?? []).slice(0, 10);
+    const asks = (data.asks ?? []).slice(0, 10);
+    let spread;
+    if (bids.length > 0 && asks.length > 0) {
+        spread = parseFloat(asks[0].price) - parseFloat(bids[0].price);
+    }
+    return {
+        market: data.market ?? '',
+        asset_id: data.asset_id ?? tokenId,
+        bids,
+        asks,
+        spread,
+    };
+}
+async function getPrice(tokenId, side) {
+    const url = `${CLOB_BASE}/price?token_id=${encodeURIComponent(tokenId)}&side=${side}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`CLOB getPrice error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return parseFloat(data.price ?? data) ?? 0;
+}
+async function getPrices(tokenIds) {
+    const prices = new Map();
+    // Batch with concurrency limit of 5
+    const chunks = [];
+    for (let i = 0; i < tokenIds.length; i += 5) {
+        chunks.push(tokenIds.slice(i, i + 5));
+    }
+    for (const chunk of chunks) {
+        await Promise.all(chunk.map(async (id) => {
+            try {
+                const price = await getPrice(id, 'buy');
+                prices.set(id, price);
+            }
+            catch (e) {
+                // skip failed lookups
+            }
+        }));
+    }
+    return prices;
+}
+async function placeOrder(params) {
+    const { token_id, side, size_usdc, price, dry_run = true } = params;
+    const estimated_shares = price > 0 ? size_usdc / price : 0;
+    const result = {
+        dry_run,
+        token_id,
+        side,
+        size_usdc,
+        price,
+        estimated_shares,
+        logged_at: Date.now(),
+    };
+    if (dry_run) {
+        console.log(`[clob/dry-run] WOULD PLACE ORDER: ${side} ${size_usdc} USDC @ ${price} ` +
+            `(~${estimated_shares.toFixed(2)} shares) token=${token_id}`);
+        return result;
+    }
+    // Real order placement — requires CLOB auth (L1/L2 headers)
+    // Auth implementation deferred — set POLYMARKET_KEY env var when ready
+    const apiKey = process.env.POLYMARKET_API_KEY;
+    if (!apiKey) {
+        throw new Error('POLYMARKET_API_KEY not set — cannot place real orders');
+    }
+    // TODO: implement full CLOB auth (EIP-712 L1 + L2 API key headers)
+    // See: https://docs.polymarket.com/#authentication
+    throw new Error('Real order placement not yet implemented — use dry_run=true');
+}
+//# sourceMappingURL=clob.js.map

package/dist/markets/gamma.d.ts

@@ -0,0 +1,22 @@
+export interface MarketToken {
+    token_id: string;
+    outcome: string;
+    price: number;
+}
+export interface Market {
+    id: string;
+    conditionId: string;
+    question: string;
+    description: string;
+    volume: number;
+    volume24hr: number;
+    liquidity: number;
+    tokens: MarketToken[];
+    active: boolean;
+    closed: boolean;
+}
+export declare function fetchActiveMarkets(minVolume?: number, minLiquidity?: number): Promise<Market[]>;
+export declare function fetchHighQualityMarkets(minVolume24h?: number, minLiquidity?: number, minPrice?: number, maxPrice?: number): Promise<Market[]>;
+export declare function fetchMarket(id: string): Promise<Market | null>;
+export declare function clearCache(): void;
+export declare function filterBySignal(asset: string, markets: Market[]): Market[];

package/dist/markets/gamma.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchActiveMarkets = fetchActiveMarkets;
+exports.fetchHighQualityMarkets = fetchHighQualityMarkets;
+exports.fetchMarket = fetchMarket;
+exports.clearCache = clearCache;
+exports.filterBySignal = filterBySignal;
+const GAMMA_BASE = 'https://gamma-api.polymarket.com';
+const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+let cache = null;
+function parseNumber(val) {
+    if (typeof val === 'number')
+        return val;
+    if (typeof val === 'string')
+        return parseFloat(val) || 0;
+    return 0;
+}
+function parseTokens(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((t) => ({
+        token_id: t.token_id ?? t.tokenId ?? '',
+        outcome: t.outcome ?? '',
+        price: parseNumber(t.price),
+    }));
+}
+function parseMarket(raw) {
+    // Gamma API returns outcomes/prices as JSON strings, not a tokens array
+    let tokens = parseTokens(raw.tokens);
+    if (tokens.length === 0 && raw.outcomes) {
+        try {
+            const outcomes = JSON.parse(raw.outcomes);
+            const prices = JSON.parse(raw.outcomePrices || '[]');
+            tokens = outcomes.map((outcome, i) => ({
+                token_id: '',
+                outcome,
+                price: parseFloat(prices[i]) || 0,
+            }));
+        }
+        catch { }
+    }
+    return {
+        id: String(raw.id ?? ''),
+        conditionId: String(raw.conditionId ?? raw.condition_id ?? ''),
+        question: String(raw.question ?? ''),
+        description: String(raw.description ?? ''),
+        volume: parseNumber(raw.volume),
+        volume24hr: parseNumber(raw.volume24hr),
+        liquidity: parseNumber(raw.liquidity),
+        tokens,
+        active: Boolean(raw.active),
+        closed: Boolean(raw.closed),
+    };
+}
+async function fetchActiveMarkets(minVolume = 10_000, minLiquidity = 1_000) {
+    const now = Date.now();
+    if (cache && now - cache.ts < CACHE_TTL_MS) {
+        return cache.markets;
+    }
+    const url = `${GAMMA_BASE}/markets?active=true&closed=false&limit=500`;
+    console.log(`[gamma] Fetching active markets from ${url}`);
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Gamma API error: ${res.status} ${res.statusText}`);
+    }
+    const raw = await res.json();
+    const data = Array.isArray(raw) ? raw : [];
+    const markets = data
+        .map(parseMarket)
+        .filter(m => m.active && !m.closed && m.volume >= minVolume && m.liquidity >= minLiquidity);
+    console.log(`[gamma] Loaded ${markets.length} markets (filtered from ${data.length})`);
+    cache = { markets, ts: now };
+    return markets;
+}
+async function fetchHighQualityMarkets(minVolume24h = 50_000, minLiquidity = 50_000, minPrice = 0.10, maxPrice = 0.90) {
+    const all = await fetchActiveMarkets(1_000, 1_000);
+    return all
+        .filter(m => {
+        const vol24 = m.volume24hr ?? 0;
+        const liq = m.liquidity ?? 0;
+        const hasUncertainty = m.tokens?.some(t => t.price >= minPrice && t.price <= maxPrice);
+        return vol24 >= minVolume24h && liq >= minLiquidity && hasUncertainty;
+    })
+        .sort((a, b) => (b.volume24hr ?? 0) - (a.volume24hr ?? 0));
+}
+async function fetchMarket(id) {
+    const url = `${GAMMA_BASE}/markets/${id}`;
+    const res = await fetch(url);
+    if (!res.ok)
+        return null;
+    const data = await res.json();
+    return parseMarket(data);
+}
+function clearCache() {
+    cache = null;
+}
+const KEYWORDS = {
+    BTC: ['bitcoin', 'btc', 'crypto', 'cryptocurrency'],
+    ETH: ['ethereum', 'eth', 'ether', 'defi'],
+};
+function filterBySignal(asset, markets) {
+    const kw = KEYWORDS[asset] || [];
+    const scored = markets
+        .map(m => {
+        const text = `${m.question} ${m.description || ''}`.toLowerCase();
+        const score = kw.reduce((s, k) => s + (text.includes(k) ? 1 : 0), 0);
+        return { m, score };
+    })
+        .filter(x => x.score > 0)
+        .sort((a, b) => b.score - a.score || b.m.volume - a.m.volume);
+    return scored.slice(0, 20).map(x => x.m);
+}
+//# sourceMappingURL=gamma.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};