@spfunctions/cli 0.1.3 → 0.1.5

package/dist/commands/agent.d.ts

@@ -0,0 +1,18 @@
+/**
+ * sf agent — Interactive natural language terminal agent.
+ *
+ * Uses pi-agent-core's Agent class for the tool-calling loop.
+ * Uses pi-ai for unified LLM access via OpenRouter.
+ *
+ * The agent has 6 tools:
+ *   get_context   — thesis snapshot (causal tree, edges, confidence)
+ *   inject_signal — inject news/note/external signal
+ *   trigger_evaluation — trigger deep eval (heavy model)
+ *   scan_markets  — search Kalshi markets
+ *   list_theses   — list all theses
+ *   get_positions  — Kalshi portfolio positions
+ */
+export declare function agentCommand(thesisId?: string, opts?: {
+    model?: string;
+    modelKey?: string;
+}): Promise<void>;

package/dist/commands/agent.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * sf agent — Interactive natural language terminal agent.
+ *
+ * Uses pi-agent-core's Agent class for the tool-calling loop.
+ * Uses pi-ai for unified LLM access via OpenRouter.
+ *
+ * The agent has 6 tools:
+ *   get_context   — thesis snapshot (causal tree, edges, confidence)
+ *   inject_signal — inject news/note/external signal
+ *   trigger_evaluation — trigger deep eval (heavy model)
+ *   scan_markets  — search Kalshi markets
+ *   list_theses   — list all theses
+ *   get_positions  — Kalshi portfolio positions
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentCommand = agentCommand;
+const readline_1 = __importDefault(require("readline"));
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+async function agentCommand(thesisId, opts) {
+    // ── Dynamic imports for ESM-only packages ──────────────────────────────────
+    const piAi = await import('@mariozechner/pi-ai');
+    const piAgent = await import('@mariozechner/pi-agent-core');
+    const { getModel, streamSimple, Type } = piAi;
+    const { Agent } = piAgent;
+    // ── Validate API keys ──────────────────────────────────────────────────────
+    const openrouterKey = opts?.modelKey || process.env.OPENROUTER_API_KEY;
+    if (!openrouterKey) {
+        console.error('Need OpenRouter API key. Set OPENROUTER_API_KEY or use --model-key.');
+        process.exit(1);
+    }
+    const sfClient = new client_js_1.SFClient();
+    // ── Resolve thesis ID ──────────────────────────────────────────────────────
+    let resolvedThesisId = thesisId;
+    if (!resolvedThesisId) {
+        const data = await sfClient.listTheses();
+        const theses = data.theses || data;
+        const active = theses.find((t) => t.status === 'active');
+        if (!active) {
+            console.error('No active thesis. Create one first: sf create "..."');
+            process.exit(1);
+        }
+        resolvedThesisId = active.id;
+    }
+    // ── Fetch initial context ──────────────────────────────────────────────────
+    const context = await sfClient.getContext(resolvedThesisId);
+    // ── Define tools ───────────────────────────────────────────────────────────
+    const thesisIdParam = Type.Object({
+        thesisId: Type.String({ description: 'Thesis ID (short or full UUID)' }),
+    });
+    const signalParams = Type.Object({
+        thesisId: Type.String({ description: 'Thesis ID' }),
+        content: Type.String({ description: 'Signal content' }),
+        type: Type.Optional(Type.String({ description: 'Signal type: news, user_note, external. Default: user_note' })),
+    });
+    const scanParams = Type.Object({
+        query: Type.Optional(Type.String({ description: 'Keyword search for Kalshi markets' })),
+        series: Type.Optional(Type.String({ description: 'Kalshi series ticker (e.g. KXWTIMAX)' })),
+        market: Type.Optional(Type.String({ description: 'Specific market ticker' })),
+    });
+    const emptyParams = Type.Object({});
+    const tools = [
+        {
+            name: 'get_context',
+            label: 'Get Context',
+            description: 'Get thesis snapshot: causal tree, edge prices, last evaluation, confidence',
+            parameters: thesisIdParam,
+            execute: async (_toolCallId, params) => {
+                const ctx = await sfClient.getContext(params.thesisId);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(ctx, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'inject_signal',
+            label: 'Inject Signal',
+            description: 'Inject a signal into the thesis (news, note, external event)',
+            parameters: signalParams,
+            execute: async (_toolCallId, params) => {
+                const result = await sfClient.injectSignal(params.thesisId, params.type || 'user_note', params.content);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'trigger_evaluation',
+            label: 'Evaluate',
+            description: 'Trigger a deep evaluation cycle (heavy model, takes longer)',
+            parameters: thesisIdParam,
+            execute: async (_toolCallId, params) => {
+                const result = await sfClient.evaluate(params.thesisId);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'scan_markets',
+            label: 'Scan Markets',
+            description: 'Search Kalshi prediction markets: by keywords, series ticker, or specific market ticker',
+            parameters: scanParams,
+            execute: async (_toolCallId, params) => {
+                let result;
+                if (params.market) {
+                    result = await (0, client_js_1.kalshiFetchMarket)(params.market);
+                }
+                else if (params.series) {
+                    result = await (0, client_js_1.kalshiFetchMarketsBySeries)(params.series);
+                }
+                else if (params.query) {
+                    const series = await (0, client_js_1.kalshiFetchAllSeries)();
+                    const keywords = params.query.toLowerCase().split(/\s+/);
+                    const matched = series
+                        .filter((s) => keywords.some((kw) => (s.title || '').toLowerCase().includes(kw) ||
+                        (s.ticker || '').toLowerCase().includes(kw)))
+                        .slice(0, 15);
+                    result = matched;
+                }
+                else {
+                    result = { error: 'Provide query, series, or market parameter' };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'list_theses',
+            label: 'List Theses',
+            description: 'List all theses for the current user',
+            parameters: emptyParams,
+            execute: async () => {
+                const theses = await sfClient.listTheses();
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(theses, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'get_positions',
+            label: 'Get Positions',
+            description: 'Get Kalshi exchange positions with live prices and PnL (requires local Kalshi key config)',
+            parameters: emptyParams,
+            execute: async () => {
+                const positions = await (0, kalshi_js_1.getPositions)();
+                if (!positions) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Kalshi not configured. Set KALSHI_API_KEY_ID and KALSHI_PRIVATE_KEY_PATH environment variables.',
+                            },
+                        ],
+                        details: {},
+                    };
+                }
+                // Enrich with live prices (same logic as sf positions command)
+                for (const pos of positions) {
+                    const livePrice = await (0, kalshi_js_1.getMarketPrice)(pos.ticker);
+                    if (livePrice !== null) {
+                        pos.current_value = livePrice;
+                        pos.unrealized_pnl = Math.round((livePrice - pos.average_price_paid) * pos.quantity);
+                    }
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(positions, null, 2) }],
+                    details: {},
+                };
+            },
+        },
+    ];
+    // ── System prompt ──────────────────────────────────────────────────────────
+    const confidencePct = typeof context.confidence === 'number'
+        ? Math.round(context.confidence * 100)
+        : context.confidence;
+    const systemPrompt = `You are a SimpleFunctions prediction market trading assistant.
+
+Current thesis: ${context.thesis || context.rawThesis || 'N/A'}
+Confidence: ${confidencePct}%
+Status: ${context.status}
+Thesis ID: ${context.thesisId || resolvedThesisId}
+
+You have six tools available. Use them when you need real-time data. Answer directly when you don't.
+Be concise. Use Chinese if the user writes in Chinese, English if they write in English.
+Do NOT make up data. Always call tools to get current state.`;
+    // ── Configure model via OpenRouter ─────────────────────────────────────────
+    const rawModelName = opts?.model || 'anthropic/claude-sonnet-4-20250514';
+    // Strip 'openrouter/' prefix if user passed it (provider is already openrouter)
+    const modelName = rawModelName.replace(/^openrouter\//, '');
+    // Try the registry first. If the model isn't registered, construct manually.
+    // OpenRouter accepts any model ID — the registry just may not have it yet.
+    let model;
+    try {
+        model = getModel('openrouter', modelName);
+    }
+    catch {
+        // Manual fallback: construct a Model object compatible with pi-ai's openai-completions API
+        // (OpenRouter uses OpenAI-compatible API)
+        model = {
+            modelId: modelName,
+            provider: 'openrouter',
+            api: 'openai-completions',
+            baseUrl: 'https://openrouter.ai/api/v1',
+            id: modelName,
+            name: modelName,
+            inputPrice: 0,
+            outputPrice: 0,
+            contextWindow: 200000,
+            supportsImages: true,
+            supportsTools: true,
+        };
+        console.log(`\x1b[33mModel '${modelName}' not in registry, using direct OpenRouter API\x1b[0m`);
+    }
+    // ── Create Agent ───────────────────────────────────────────────────────────
+    const agent = new Agent({
+        initialState: {
+            systemPrompt,
+            model,
+            tools,
+            thinkingLevel: 'off',
+        },
+        streamFn: streamSimple,
+        getApiKey: (provider) => {
+            if (provider === 'openrouter')
+                return openrouterKey;
+            return undefined;
+        },
+    });
+    // ── Subscribe to streaming events ──────────────────────────────────────────
+    agent.subscribe((event) => {
+        if (event.type === 'message_update') {
+            const e = event.assistantMessageEvent;
+            if (e.type === 'text_delta') {
+                process.stdout.write(e.delta);
+            }
+        }
+        if (event.type === 'tool_execution_start') {
+            process.stdout.write(`\n\x1b[33m⚡ ${event.toolName}\x1b[0m `);
+        }
+        if (event.type === 'tool_execution_end') {
+            if (event.isError) {
+                process.stdout.write('\x1b[31m✗\x1b[0m\n');
+            }
+            else {
+                process.stdout.write('\x1b[32m✓\x1b[0m\n');
+            }
+        }
+    });
+    // ── Terminal REPL ──────────────────────────────────────────────────────────
+    const shortId = (resolvedThesisId || '').slice(0, 8);
+    console.log(`\n\x1b[32mSimpleFunctions Agent\x1b[0m — ${shortId}`);
+    console.log(`Model: ${modelName} | Type "exit" to quit\n`);
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const prompt = () => {
+        rl.question('\x1b[36m> \x1b[0m', async (input) => {
+            const trimmed = input.trim();
+            if (!trimmed) {
+                prompt();
+                return;
+            }
+            if (trimmed === 'exit' || trimmed === 'quit') {
+                rl.close();
+                process.exit(0);
+            }
+            try {
+                await agent.prompt(trimmed);
+                console.log('\n');
+            }
+            catch (err) {
+                console.error(`\n\x1b[31mError: ${err.message}\x1b[0m\n`);
+            }
+            prompt();
+        });
+    };
+    prompt();
+}

package/dist/commands/positions.js

@@ -69,6 +69,25 @@ async function positionsCommand(opts) {
             }
         }
     }
+    // ── Step 2.5: Enrich positions with live prices ──
+    if (positions && positions.length > 0) {
+        console.log(`${utils_js_1.c.dim}Fetching live prices for ${positions.length} positions...${utils_js_1.c.reset}`);
+        for (const pos of positions) {
+            try {
+                const livePrice = await (0, kalshi_js_1.getMarketPrice)(pos.ticker);
+                if (livePrice !== null) {
+                    pos.current_value = livePrice;
+                    // P&L in cents: (currentPrice - avgEntry) * quantity
+                    pos.unrealized_pnl = (livePrice - pos.average_price_paid) * pos.quantity;
+                }
+                // Small delay to avoid rate limits
+                await new Promise(r => setTimeout(r, 100));
+            }
+            catch {
+                // skip — live price optional
+            }
+        }
+    }
     // ── Step 3: Merge ──
     // Build a lookup from ticker → edge
     const edgeByTicker = new Map();
@@ -156,6 +175,23 @@ async function positionsCommand(opts) {
     if (unpositionedEdges.length > 0) {
         // Sort by absolute edge size descending
         unpositionedEdges.sort((a, b) => Math.abs(b.edge.edge ?? b.edge.edgeSize ?? 0) - Math.abs(a.edge.edge ?? a.edge.edgeSize ?? 0));
+        // Pre-fetch orderbooks locally for top Kalshi edges that don't already have server OB data
+        const topEdgesForOB = unpositionedEdges.slice(0, 10).filter(item => item.edge.venue === 'kalshi' && !item.edge.orderbook && Math.abs(item.edge.edge ?? item.edge.edgeSize ?? 0) > 5);
+        const localObMap = new Map();
+        if (topEdgesForOB.length > 0 && (0, kalshi_js_1.isKalshiConfigured)()) {
+            console.log(`${utils_js_1.c.dim}Fetching orderbooks for ${topEdgesForOB.length} edges...${utils_js_1.c.reset}`);
+            for (const item of topEdgesForOB) {
+                try {
+                    const ob = await (0, kalshi_js_1.getOrderbook)(item.edge.marketId);
+                    if (ob)
+                        localObMap.set(item.edge.marketId, ob);
+                    await new Promise(r => setTimeout(r, 150));
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
         const thesisLabel = opts.thesis ? ` (thesis ${(0, utils_js_1.shortId)(opts.thesis)})` : '';
         (0, utils_js_1.header)(`Unpositioned Edges${thesisLabel}`);
         console.log('  ' + utils_js_1.c.bold +
@@ -175,8 +211,10 @@ async function positionsCommand(opts) {
             const mktPrice = e.marketPrice ?? 0;
             const thesisPrice = e.thesisPrice ?? e.thesisImpliedPrice ?? 0;
             const title = (e.market || e.marketTitle || e.marketId || '?').slice(0, 29);
-            // Orderbook info (if present from rescan)
-            const ob = e.orderbook;
+            // Orderbook: prefer server data, fallback to local fetch
+            const serverOb = e.orderbook;
+            const localOb = localObMap.get(e.marketId);
+            const ob = serverOb || localOb;
             const spreadStr = ob ? `${ob.spread}¢` : '-';
             const liqStr = ob ? ob.liquidityScore : '-';
             const liqColor = ob?.liquidityScore === 'high' ? utils_js_1.c.green : ob?.liquidityScore === 'medium' ? utils_js_1.c.yellow : utils_js_1.c.dim;

package/dist/index.js

@@ -25,6 +25,7 @@ const signal_js_1 = require("./commands/signal.js");
 const evaluate_js_1 = require("./commands/evaluate.js");
 const scan_js_1 = require("./commands/scan.js");
 const positions_js_1 = require("./commands/positions.js");
+const agent_js_1 = require("./commands/agent.js");
 const utils_js_1 = require("./utils.js");
 const program = new commander_1.Command();
 program
@@ -130,6 +131,16 @@ program
         apiUrl: g.apiUrl,
     }));
 });
+// ── sf agent [thesisId] ───────────────────────────────────────────────────────
+program
+    .command('agent [thesisId]')
+    .description('Interactive agent mode — natural language interface to SimpleFunctions')
+    .option('--model <model>', 'Model via OpenRouter (default: anthropic/claude-sonnet-4-20250514)')
+    .option('--model-key <key>', 'OpenRouter API key (or set OPENROUTER_API_KEY)')
+    .action(async (thesisId, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, agent_js_1.agentCommand)(thesisId, { model: opts.model, modelKey: opts.modelKey }));
+});
 // ── Error wrapper ─────────────────────────────────────────────────────────────
 async function run(fn) {
     try {

package/dist/kalshi.d.ts

@@ -37,5 +37,19 @@ export interface KalshiPortfolio {
 export declare function getPositions(): Promise<KalshiPosition[] | null>;
 /**
  * Get the current market price for a given ticker (public, no auth).
+ * Returns price in cents (0-100) or null.
  */
 export declare function getMarketPrice(ticker: string): Promise<number | null>;
+/**
+ * Fetch orderbook for a ticker using local Kalshi auth credentials.
+ * Returns simplified spread/depth info or null.
+ */
+export interface LocalOrderbook {
+    bestBid: number;
+    bestAsk: number;
+    spread: number;
+    bidDepth: number;
+    askDepth: number;
+    liquidityScore: 'high' | 'medium' | 'low';
+}
+export declare function getOrderbook(ticker: string): Promise<LocalOrderbook | null>;

package/dist/kalshi.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isKalshiConfigured = isKalshiConfigured;
 exports.getPositions = getPositions;
 exports.getMarketPrice = getMarketPrice;
+exports.getOrderbook = getOrderbook;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
@@ -105,18 +106,32 @@ async function getPositions() {
         const data = await kalshiAuthGet('/portfolio/positions');
         // Kalshi returns { market_positions: [...] } or { positions: [...] }
         const raw = data.market_positions || data.positions || [];
-        return raw.map((p) => ({
-            ticker: p.ticker || p.market_ticker || '',
-            event_ticker: p.event_ticker || '',
-            market_title: p.market_title || p.title || '',
-            side: (p.position_side || p.side || 'yes').toLowerCase(),
-            quantity: p.total_traded || p.quantity || p.position || 0,
-            average_price_paid: p.average_price_paid || p.avg_price || 0,
-            current_value: p.market_value || p.current_value || 0,
-            realized_pnl: p.realized_pnl || 0,
-            unrealized_pnl: p.unrealized_pnl || 0,
-            total_cost: p.total_cost || 0,
-        }));
+        return raw.map((p) => {
+            // Kalshi actual fields:
+            //   position_fp: "795.00" (string, contract count — positive=YES, negative=NO)
+            //   total_traded_dollars: "453.1500" (string, total cost in dollars)
+            //   ticker: "KXWTIMAX-26DEC31-T135"
+            //   event_ticker: "KXWTIMAX-26DEC31"
+            //   market_result: "", resting_orders_count: 0, etc.
+            const positionFp = parseFloat(p.position_fp || '0');
+            const totalTradedDollars = parseFloat(p.total_traded_dollars || '0');
+            const quantity = Math.abs(positionFp);
+            const side = positionFp >= 0 ? 'yes' : 'no';
+            // avg price in cents = (total_traded_dollars / quantity) * 100
+            const avgPriceCents = quantity > 0 ? Math.round((totalTradedDollars / quantity) * 100) : 0;
+            return {
+                ticker: p.ticker || p.market_ticker || '',
+                event_ticker: p.event_ticker || '',
+                market_title: p.market_title || p.title || '',
+                side,
+                quantity,
+                average_price_paid: avgPriceCents,
+                current_value: 0, // will be enriched by live price lookup if needed
+                realized_pnl: Math.round(parseFloat(p.realized_pnl || '0') * 100),
+                unrealized_pnl: 0, // Kalshi doesn't give this directly, needs live price
+                total_cost: Math.round(totalTradedDollars * 100), // dollars → cents
+            };
+        });
     }
     catch (err) {
         console.warn(`[Kalshi] Failed to fetch positions:`, err);
@@ -125,6 +140,7 @@ async function getPositions() {
 }
 /**
  * Get the current market price for a given ticker (public, no auth).
+ * Returns price in cents (0-100) or null.
  */
 async function getMarketPrice(ticker) {
     try {
@@ -134,7 +150,64 @@ async function getMarketPrice(ticker) {
             return null;
         const data = await res.json();
         const m = data.market || data;
-        return m.last_price || m.yes_bid || null;
+        // Try cents fields first, then dollar string fields
+        if (m.last_price && m.last_price > 0)
+            return m.last_price;
+        if (m.yes_bid && m.yes_bid > 0)
+            return m.yes_bid;
+        if (m.last_price_dollars) {
+            const parsed = parseFloat(m.last_price_dollars);
+            if (!isNaN(parsed) && parsed > 0)
+                return Math.round(parsed * 100);
+        }
+        if (m.yes_bid_dollars) {
+            const parsed = parseFloat(m.yes_bid_dollars);
+            if (!isNaN(parsed) && parsed > 0)
+                return Math.round(parsed * 100);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getOrderbook(ticker) {
+    if (!isKalshiConfigured())
+        return null;
+    try {
+        const data = await kalshiAuthGet(`/markets/${ticker}/orderbook`);
+        const ob = data.orderbook_fp || data.orderbook;
+        if (!ob)
+            return null;
+        // Kalshi orderbook_fp uses yes_dollars/no_dollars: [["0.57", "100"], ...]
+        // Fallback to yes/no (cents format)
+        const rawYes = ob.yes_dollars || ob.yes || [];
+        const rawNo = ob.no_dollars || ob.no || [];
+        const isDollar = !!(ob.yes_dollars || ob.no_dollars);
+        // Parse to cents
+        const parsedYes = rawYes.map(l => ({
+            price: isDollar ? Math.round(parseFloat(l[0]) * 100) : Number(l[0]),
+            qty: parseFloat(l[1]),
+        })).filter(l => l.price > 0);
+        const parsedNo = rawNo.map(l => ({
+            price: isDollar ? Math.round(parseFloat(l[0]) * 100) : Number(l[0]),
+            qty: parseFloat(l[1]),
+        })).filter(l => l.price > 0);
+        // Sort descending by price
+        parsedYes.sort((a, b) => b.price - a.price);
+        parsedNo.sort((a, b) => b.price - a.price);
+        const bestBid = parsedYes.length > 0 ? parsedYes[0].price : 0;
+        const bestAsk = parsedNo.length > 0 ? (100 - parsedNo[0].price) : 100;
+        const spread = bestAsk - bestBid;
+        const bidDepth = parsedYes.slice(0, 3).reduce((sum, l) => sum + l.qty, 0);
+        const askDepth = parsedNo.slice(0, 3).reduce((sum, l) => sum + l.qty, 0);
+        const minDepth = Math.min(bidDepth, askDepth);
+        let liquidityScore = 'low';
+        if (spread <= 2 && minDepth >= 500)
+            liquidityScore = 'high';
+        else if (spread <= 5 && minDepth >= 100)
+            liquidityScore = 'medium';
+        return { bestBid, bestAsk, spread, bidDepth, askDepth, liquidityScore };
     }
     catch {
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfunctions/cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI for SimpleFunctions prediction market thesis agent",
   "bin": {
     "sf": "./dist/index.js"
@@ -11,6 +11,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@mariozechner/pi-agent-core": "^0.57.1",
+    "@mariozechner/pi-ai": "^0.57.1",
     "commander": "^12.0.0",
     "kalshi-typescript": "^3.9.0"
   },