@spfunctions/cli 0.1.1 → 0.1.3

package/README.md

@@ -12,7 +12,7 @@ npm install -g @spfunctions/cli
 
 ```bash
 export SF_API_KEY=sf_live_xxx           # required
-export SF_API_URL=https://simplefunctions.com  # optional, defaults to production
+export SF_API_URL=https://simplefunctions.dev  # optional, defaults to production
 ```
 
 Or pass inline:

package/dist/client.js

@@ -12,7 +12,7 @@ exports.kalshiFetchEvents = kalshiFetchEvents;
 exports.kalshiFetchMarket = kalshiFetchMarket;
 exports.kalshiFetchMarketsBySeries = kalshiFetchMarketsBySeries;
 exports.kalshiFetchMarketsByEvent = kalshiFetchMarketsByEvent;
-const DEFAULT_API_URL = 'https://simplefunctions.com';
+const DEFAULT_API_URL = 'https://simplefunctions.dev';
 const KALSHI_BASE = 'https://api.elections.kalshi.com/trade-api/v2';
 // ===== SF API Client =====
 class SFClient {

package/dist/commands/context.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.contextCommand = contextCommand;
 const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
 const utils_js_1 = require("../utils.js");
 async function contextCommand(id, opts) {
     const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
@@ -33,6 +34,22 @@ async function contextCommand(id, opts) {
             console.log(`${indent}${utils_js_1.c.cyan}${node.id}${utils_js_1.c.reset}  ${(0, utils_js_1.pad)(label, 40)} ${(0, utils_js_1.rpad)(prob, 5)}`);
         }
     }
+    // Fetch positions if Kalshi is configured (local only, no server)
+    let positions = null;
+    if ((0, kalshi_js_1.isKalshiConfigured)()) {
+        try {
+            positions = await (0, kalshi_js_1.getPositions)();
+        }
+        catch {
+            // silently skip — positions are optional
+        }
+    }
+    const posMap = new Map();
+    if (positions) {
+        for (const p of positions) {
+            posMap.set(p.ticker, p);
+        }
+    }
     // Top edges (sorted by absolute edge size)
     const edges = ctx.edges;
     if (edges && edges.length > 0) {
@@ -43,10 +60,24 @@ async function contextCommand(id, opts) {
             const edgeColor = edgeSize > 10 ? utils_js_1.c.green : edgeSize > 0 ? utils_js_1.c.yellow : utils_js_1.c.red;
             const mktPrice = edge.marketPrice ?? edge.currentPrice ?? 0;
             const title = edge.market || edge.marketTitle || edge.marketId || '?';
+            // Orderbook info (if enriched by rescan)
+            const ob = edge.orderbook;
+            const obStr = ob ? `  ${utils_js_1.c.dim}spread ${ob.spread}¢ ${ob.liquidityScore}${utils_js_1.c.reset}` : '';
+            // Position overlay (if user has Kalshi positions)
+            const pos = posMap.get(edge.marketId);
+            let posStr = '';
+            if (pos) {
+                const pnl = pos.unrealized_pnl || 0;
+                const pnlColor = pnl > 0 ? utils_js_1.c.green : pnl < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+                const pnlFmt = pnl >= 0 ? `+$${(pnl / 100).toFixed(0)}` : `-$${(Math.abs(pnl) / 100).toFixed(0)}`;
+                posStr = `  ${utils_js_1.c.cyan}← ${pos.quantity}张 @ ${pos.average_price_paid}¢  ${pnlColor}${pnlFmt}${utils_js_1.c.reset}`;
+            }
             console.log(`  ${(0, utils_js_1.pad)(title, 35)}` +
                 `  ${(0, utils_js_1.rpad)(mktPrice.toFixed(0) + '¢', 5)}` +
                 `  ${edgeColor}edge ${edgeSize > 0 ? '+' : ''}${edgeSize.toFixed(1)}${utils_js_1.c.reset}` +
-                `  ${utils_js_1.c.dim}${edge.venue || ''}${utils_js_1.c.reset}`);
+                `  ${utils_js_1.c.dim}${edge.venue || ''}${utils_js_1.c.reset}` +
+                obStr +
+                posStr);
         }
     }
     // Last evaluation summary

package/dist/commands/positions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * sf positions — Show Kalshi positions with thesis edge overlay
+ *
+ * Flow:
+ * 1. Call local kalshi.getPositions() (Kalshi SDK + local private key) → real positions
+ * 2. Call SF API /api/thesis (via SF_API_KEY) → all theses' edge_analysis
+ * 3. Local merge: match position ticker to edge marketId
+ * 4. Output
+ *
+ * No server involvement for positions. Kalshi credentials never leave the machine.
+ */
+interface PositionsOpts {
+    json?: boolean;
+    thesis?: string;
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function positionsCommand(opts: PositionsOpts): Promise<void>;
+export {};

package/dist/commands/positions.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * sf positions — Show Kalshi positions with thesis edge overlay
+ *
+ * Flow:
+ * 1. Call local kalshi.getPositions() (Kalshi SDK + local private key) → real positions
+ * 2. Call SF API /api/thesis (via SF_API_KEY) → all theses' edge_analysis
+ * 3. Local merge: match position ticker to edge marketId
+ * 4. Output
+ *
+ * No server involvement for positions. Kalshi credentials never leave the machine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.positionsCommand = positionsCommand;
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+const utils_js_1 = require("../utils.js");
+async function positionsCommand(opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    // ── Step 1: Fetch Kalshi positions (local) ──
+    let positions = null;
+    if ((0, kalshi_js_1.isKalshiConfigured)()) {
+        console.log(`${utils_js_1.c.dim}Fetching Kalshi positions...${utils_js_1.c.reset}`);
+        positions = await (0, kalshi_js_1.getPositions)();
+    }
+    // ── Step 2: Fetch all theses and their edges (via SF API) ──
+    console.log(`${utils_js_1.c.dim}Fetching thesis edges...${utils_js_1.c.reset}`);
+    let theses = [];
+    try {
+        const data = await client.listTheses();
+        theses = data.theses || [];
+    }
+    catch (err) {
+        console.warn(`${utils_js_1.c.yellow}Warning: Could not fetch theses: ${err}${utils_js_1.c.reset}`);
+    }
+    // If filtering by thesis, only fetch that one's context
+    let allEdges = [];
+    if (opts.thesis) {
+        try {
+            const ctx = await client.getContext(opts.thesis);
+            for (const edge of (ctx.edges || [])) {
+                allEdges.push({
+                    thesisId: ctx.thesisId,
+                    thesisTitle: ctx.thesis || ctx.title || '',
+                    edge,
+                });
+            }
+        }
+        catch (err) {
+            console.warn(`${utils_js_1.c.yellow}Warning: Could not fetch context for ${opts.thesis}: ${err}${utils_js_1.c.reset}`);
+        }
+    }
+    else {
+        // Fetch context for all monitoring theses
+        const monitoringTheses = theses.filter(t => t.status === 'monitoring' || t.status === 'active');
+        for (const thesis of monitoringTheses.slice(0, 5)) { // limit to 5 to avoid rate limits
+            try {
+                const ctx = await client.getContext(thesis.id);
+                for (const edge of (ctx.edges || [])) {
+                    allEdges.push({
+                        thesisId: thesis.id,
+                        thesisTitle: ctx.thesis || ctx.title || thesis.title || '',
+                        edge,
+                    });
+                }
+            }
+            catch {
+                // skip failed
+            }
+        }
+    }
+    // ── Step 3: Merge ──
+    // Build a lookup from ticker → edge
+    const edgeByTicker = new Map();
+    for (const item of allEdges) {
+        const ticker = item.edge.marketId;
+        if (!edgeByTicker.has(ticker))
+            edgeByTicker.set(ticker, []);
+        edgeByTicker.get(ticker).push(item);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            kalshiConfigured: (0, kalshi_js_1.isKalshiConfigured)(),
+            positions: positions || [],
+            edges: allEdges.map(e => ({ ...e.edge, thesisId: e.thesisId })),
+        }, null, 2));
+        return;
+    }
+    // ── Step 4: Display ──
+    // A) Positioned edges (positions that match thesis edges)
+    if (positions && positions.length > 0) {
+        (0, utils_js_1.header)('Your Positions (via Kalshi)');
+        console.log('  ' + utils_js_1.c.bold +
+            (0, utils_js_1.pad)('Ticker', 25) +
+            (0, utils_js_1.rpad)('Side', 5) +
+            (0, utils_js_1.rpad)('Qty', 7) +
+            (0, utils_js_1.rpad)('Avg', 6) +
+            (0, utils_js_1.rpad)('Now', 6) +
+            (0, utils_js_1.rpad)('P&L', 9) +
+            (0, utils_js_1.rpad)('Edge', 7) +
+            '  Signal' +
+            utils_js_1.c.reset);
+        console.log('  ' + utils_js_1.c.dim + '─'.repeat(85) + utils_js_1.c.reset);
+        for (const pos of positions) {
+            // Try to get current price
+            const nowPrice = pos.current_value || null;
+            const avgPrice = pos.average_price_paid || 0;
+            const pnl = pos.unrealized_pnl || 0;
+            const pnlColor = pnl > 0 ? utils_js_1.c.green : pnl < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+            const pnlStr = pnl >= 0 ? `+$${(pnl / 100).toFixed(2)}` : `-$${(Math.abs(pnl) / 100).toFixed(2)}`;
+            // Find matching edge
+            const matchingEdges = edgeByTicker.get(pos.ticker) || [];
+            const topEdge = matchingEdges[0];
+            const edgeSize = topEdge?.edge?.edge ?? topEdge?.edge?.edgeSize ?? 0;
+            const edgeColor = Math.abs(edgeSize) > 10 ? utils_js_1.c.green : Math.abs(edgeSize) > 5 ? utils_js_1.c.yellow : utils_js_1.c.dim;
+            // Signal: HOLD if edge still positive in same direction, WATCH otherwise
+            let signal = 'HOLD';
+            if (topEdge) {
+                const posDirection = pos.side;
+                const edgeDirection = topEdge.edge.direction;
+                if (posDirection === edgeDirection && edgeSize > 3) {
+                    signal = 'HOLD';
+                }
+                else if (edgeSize < -3) {
+                    signal = 'CLOSE';
+                }
+                else {
+                    signal = 'HOLD';
+                }
+            }
+            else {
+                signal = '—';
+            }
+            const signalColor = signal === 'HOLD' ? utils_js_1.c.dim : signal === 'CLOSE' ? utils_js_1.c.red : utils_js_1.c.yellow;
+            console.log('  ' +
+                (0, utils_js_1.pad)(pos.ticker, 25) +
+                (0, utils_js_1.rpad)(pos.side.toUpperCase(), 5) +
+                (0, utils_js_1.rpad)(String(pos.quantity), 7) +
+                (0, utils_js_1.rpad)(`${avgPrice}¢`, 6) +
+                (0, utils_js_1.rpad)(nowPrice ? `${nowPrice}¢` : '-', 6) +
+                `${pnlColor}${(0, utils_js_1.rpad)(pnlStr, 9)}${utils_js_1.c.reset}` +
+                `${edgeColor}${(0, utils_js_1.rpad)(edgeSize ? `${edgeSize > 0 ? '+' : ''}${edgeSize.toFixed(0)}` : '-', 7)}${utils_js_1.c.reset}` +
+                `  ${signalColor}${signal}${utils_js_1.c.reset}`);
+        }
+        console.log('');
+    }
+    else if ((0, kalshi_js_1.isKalshiConfigured)()) {
+        console.log(`\n${utils_js_1.c.dim}No open positions on Kalshi.${utils_js_1.c.reset}\n`);
+    }
+    else {
+        console.log(`\n${utils_js_1.c.yellow}Kalshi not configured.${utils_js_1.c.reset} Set KALSHI_API_KEY_ID and KALSHI_PRIVATE_KEY_PATH to see positions.\n`);
+    }
+    // B) Unpositioned edges (edges without matching positions)
+    const positionedTickers = new Set((positions || []).map(p => p.ticker));
+    const unpositionedEdges = allEdges.filter(e => !positionedTickers.has(e.edge.marketId));
+    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));
+        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 +
+            (0, utils_js_1.pad)('Market', 30) +
+            (0, utils_js_1.rpad)('Mkt', 6) +
+            (0, utils_js_1.rpad)('Thesis', 8) +
+            (0, utils_js_1.rpad)('Edge', 7) +
+            (0, utils_js_1.rpad)('Spread', 8) +
+            (0, utils_js_1.rpad)('Liq', 8) +
+            '  Signal' +
+            utils_js_1.c.reset);
+        console.log('  ' + utils_js_1.c.dim + '─'.repeat(85) + utils_js_1.c.reset);
+        for (const item of unpositionedEdges.slice(0, 20)) {
+            const e = item.edge;
+            const edgeSize = e.edge ?? e.edgeSize ?? 0;
+            const edgeColor = edgeSize > 10 ? utils_js_1.c.green : edgeSize > 5 ? utils_js_1.c.yellow : edgeSize > 0 ? utils_js_1.c.dim : utils_js_1.c.red;
+            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;
+            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;
+            // Signal
+            let signal = 'WATCH';
+            if (edgeSize > 10 && ob?.liquidityScore !== 'low') {
+                signal = 'CONSIDER';
+            }
+            else if (edgeSize > 5 && ob?.liquidityScore === 'high') {
+                signal = 'CONSIDER';
+            }
+            const signalColor = signal === 'CONSIDER' ? utils_js_1.c.green : utils_js_1.c.dim;
+            console.log('  ' +
+                (0, utils_js_1.pad)(title, 30) +
+                (0, utils_js_1.rpad)(`${mktPrice.toFixed(0)}¢`, 6) +
+                (0, utils_js_1.rpad)(`${thesisPrice.toFixed(0)}¢`, 8) +
+                `${edgeColor}${(0, utils_js_1.rpad)(`${edgeSize > 0 ? '+' : ''}${edgeSize.toFixed(0)}`, 7)}${utils_js_1.c.reset}` +
+                (0, utils_js_1.rpad)(spreadStr, 8) +
+                `${liqColor}${(0, utils_js_1.rpad)(liqStr, 8)}${utils_js_1.c.reset}` +
+                `  ${signalColor}${signal}${utils_js_1.c.reset}`);
+        }
+        console.log('');
+    }
+    else if (allEdges.length === 0) {
+        console.log(`\n${utils_js_1.c.dim}No thesis edges found.${utils_js_1.c.reset}\n`);
+    }
+}

package/dist/index.js

@@ -24,6 +24,7 @@ const create_js_1 = require("./commands/create.js");
 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 utils_js_1 = require("./utils.js");
 const program = new commander_1.Command();
 program
@@ -114,6 +115,21 @@ program
         apiUrl: g.apiUrl,
     }));
 });
+// ── sf positions ──────────────────────────────────────────────────────────────
+program
+    .command('positions')
+    .description('Show Kalshi positions with thesis edge overlay (requires KALSHI_API_KEY_ID + KALSHI_PRIVATE_KEY_PATH)')
+    .option('--json', 'JSON output for agents')
+    .option('--thesis <id>', 'Filter by thesis ID')
+    .action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, positions_js_1.positionsCommand)({
+        json: opts.json,
+        thesis: opts.thesis,
+        apiKey: g.apiKey,
+        apiUrl: g.apiUrl,
+    }));
+});
 // ── Error wrapper ─────────────────────────────────────────────────────────────
 async function run(fn) {
     try {

package/dist/kalshi.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Kalshi Authenticated Client (CLI-side only)
+ *
+ * Uses the kalshi-typescript SDK with RSA-PSS private key auth.
+ * Credentials NEVER leave the user's machine — they are read from env vars
+ * pointing to a local PEM file.
+ *
+ * Required env vars:
+ *   KALSHI_API_KEY_ID       — Key ID from Kalshi dashboard
+ *   KALSHI_PRIVATE_KEY_PATH — Path to RSA private key PEM file (e.g. ~/.kalshi/private.pem)
+ */
+/**
+ * Check if Kalshi credentials are configured locally.
+ */
+export declare function isKalshiConfigured(): boolean;
+export interface KalshiPosition {
+    ticker: string;
+    event_ticker: string;
+    market_title: string;
+    side: 'yes' | 'no';
+    quantity: number;
+    average_price_paid: number;
+    current_value: number;
+    realized_pnl: number;
+    unrealized_pnl: number;
+    total_cost: number;
+    settlement_value?: number;
+    [key: string]: unknown;
+}
+export interface KalshiPortfolio {
+    positions: KalshiPosition[];
+}
+/**
+ * Get user's live positions from Kalshi.
+ * Returns null if Kalshi is not configured.
+ */
+export declare function getPositions(): Promise<KalshiPosition[] | null>;
+/**
+ * Get the current market price for a given ticker (public, no auth).
+ */
+export declare function getMarketPrice(ticker: string): Promise<number | null>;

package/dist/kalshi.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Kalshi Authenticated Client (CLI-side only)
+ *
+ * Uses the kalshi-typescript SDK with RSA-PSS private key auth.
+ * Credentials NEVER leave the user's machine — they are read from env vars
+ * pointing to a local PEM file.
+ *
+ * Required env vars:
+ *   KALSHI_API_KEY_ID       — Key ID from Kalshi dashboard
+ *   KALSHI_PRIVATE_KEY_PATH — Path to RSA private key PEM file (e.g. ~/.kalshi/private.pem)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKalshiConfigured = isKalshiConfigured;
+exports.getPositions = getPositions;
+exports.getMarketPrice = getMarketPrice;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const KALSHI_API_BASE = 'https://api.elections.kalshi.com/trade-api/v2';
+// ============================================================================
+// AUTH
+// ============================================================================
+/**
+ * Check if Kalshi credentials are configured locally.
+ */
+function isKalshiConfigured() {
+    return !!(process.env.KALSHI_API_KEY_ID && process.env.KALSHI_PRIVATE_KEY_PATH);
+}
+/**
+ * Load the RSA private key from disk.
+ */
+function loadPrivateKey() {
+    const keyPath = process.env.KALSHI_PRIVATE_KEY_PATH;
+    if (!keyPath)
+        return null;
+    const resolved = keyPath.startsWith('~')
+        ? path_1.default.join(process.env.HOME || '', keyPath.slice(1))
+        : path_1.default.resolve(keyPath);
+    try {
+        const pem = fs_1.default.readFileSync(resolved, 'utf-8');
+        return crypto_1.default.createPrivateKey(pem);
+    }
+    catch (err) {
+        console.warn(`[Kalshi] Failed to load private key from ${resolved}:`, err);
+        return null;
+    }
+}
+/**
+ * Sign a request using RSA-PSS (Kalshi's auth scheme).
+ *
+ * Kalshi expects:
+ *   Header: KALSHI-ACCESS-KEY = API key ID
+ *   Header: KALSHI-ACCESS-SIGNATURE = base64(RSA-PSS-sign(timestamp_ms + method + path))
+ *   Header: KALSHI-ACCESS-TIMESTAMP = milliseconds since epoch (string)
+ */
+function signRequest(method, urlPath, privateKey) {
+    const keyId = process.env.KALSHI_API_KEY_ID;
+    const timestampMs = Date.now().toString();
+    // Kalshi signing payload: timestamp_ms + method + path (no body)
+    const payload = timestampMs + method.toUpperCase() + urlPath;
+    const signature = crypto_1.default.sign('sha256', Buffer.from(payload), {
+        key: privateKey,
+        padding: crypto_1.default.constants.RSA_PKCS1_PSS_PADDING,
+        saltLength: crypto_1.default.constants.RSA_PSS_SALTLEN_DIGEST,
+    });
+    return {
+        headers: {
+            'KALSHI-ACCESS-KEY': keyId,
+            'KALSHI-ACCESS-SIGNATURE': signature.toString('base64'),
+            'KALSHI-ACCESS-TIMESTAMP': timestampMs,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+        },
+    };
+}
+/**
+ * Make an authenticated Kalshi API request.
+ */
+async function kalshiAuthGet(apiPath) {
+    const privateKey = loadPrivateKey();
+    if (!privateKey) {
+        throw new Error('Kalshi private key not loaded. Check KALSHI_PRIVATE_KEY_PATH.');
+    }
+    const url = `${KALSHI_API_BASE}${apiPath}`;
+    const { headers } = signRequest('GET', `/trade-api/v2${apiPath}`, privateKey);
+    const res = await fetch(url, { method: 'GET', headers });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Kalshi API ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+/**
+ * Get user's live positions from Kalshi.
+ * Returns null if Kalshi is not configured.
+ */
+async function getPositions() {
+    if (!isKalshiConfigured())
+        return null;
+    try {
+        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,
+        }));
+    }
+    catch (err) {
+        console.warn(`[Kalshi] Failed to fetch positions:`, err);
+        return null;
+    }
+}
+/**
+ * Get the current market price for a given ticker (public, no auth).
+ */
+async function getMarketPrice(ticker) {
+    try {
+        const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${ticker}`;
+        const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const m = data.market || data;
+        return m.last_price || m.yes_bid || null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfunctions/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CLI for SimpleFunctions prediction market thesis agent",
   "bin": {
     "sf": "./dist/index.js"
@@ -11,12 +11,13 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "commander": "^12.0.0"
+    "commander": "^12.0.0",
+    "kalshi-typescript": "^3.9.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0",
     "tsx": "^4.0.0",
-    "@types/node": "^20.0.0"
+    "typescript": "^5.0.0"
   },
   "files": [
     "dist"