@spfunctions/cli 1.3.0 → 1.4.1

package/dist/commands/dashboard.js

@@ -9,24 +9,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dashboardCommand = dashboardCommand;
 const client_js_1 = require("../client.js");
 const kalshi_js_1 = require("../kalshi.js");
-// ── Risk category mapping by Kalshi ticker prefix ────────────────────────────
-const RISK_CATEGORIES = {
-    KXWTIMAX: 'Oil',
-    KXWTI: 'Oil',
-    KXRECSSNBER: 'Recession',
-    KXAAAGASM: 'Gas',
-    KXCPI: 'Inflation',
-    KXINXY: 'S&P 500',
-    KXFEDDECISION: 'Fed Rate',
-    KXUNEMPLOYMENT: 'Unemployment',
-    KXCLOSEHORMUZ: 'Hormuz',
-};
+const topics_js_1 = require("../topics.js");
 function categorize(ticker) {
     // Match longest prefix first
-    const sorted = Object.keys(RISK_CATEGORIES).sort((a, b) => b.length - a.length);
+    const sorted = Object.keys(topics_js_1.RISK_CATEGORIES).sort((a, b) => b.length - a.length);
     for (const prefix of sorted) {
         if (ticker.startsWith(prefix))
-            return RISK_CATEGORIES[prefix];
+            return topics_js_1.RISK_CATEGORIES[prefix];
     }
     return 'Other';
 }

package/dist/commands/liquidity.d.ts

@@ -0,0 +1,12 @@
+/**
+ * sf liquidity — Market liquidity scanner by topic and horizon
+ *
+ * Scans known series, fetches public orderbooks, and displays
+ * spread/depth/slippage data grouped by topic and horizon.
+ */
+export declare function liquidityCommand(opts: {
+    topic?: string;
+    horizon?: string;
+    minDepth?: number;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/liquidity.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * sf liquidity — Market liquidity scanner by topic and horizon
+ *
+ * Scans known series, fetches public orderbooks, and displays
+ * spread/depth/slippage data grouped by topic and horizon.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liquidityCommand = liquidityCommand;
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+const topics_js_1 = require("../topics.js");
+const utils_js_1 = require("../utils.js");
+// ── Horizon classification ───────────────────────────────────────────────────
+function classifyHorizon(closeTime) {
+    const now = Date.now();
+    const close = new Date(closeTime).getTime();
+    const daysAway = (close - now) / (1000 * 60 * 60 * 24);
+    if (daysAway < 7)
+        return 'weekly';
+    if (daysAway <= 35)
+        return 'monthly';
+    return 'long-term';
+}
+function horizonLabel(h) {
+    switch (h) {
+        case 'weekly': return 'weekly (<7d)';
+        case 'monthly': return 'monthly (7-35d)';
+        case 'long-term': return 'long-term (>35d)';
+    }
+}
+// ── Slippage calculation ─────────────────────────────────────────────────────
+/**
+ * Calculate weighted average price to buy `qty` YES contracts
+ * by eating NO bids (selling NO = buying YES).
+ *
+ * no_dollars are sorted low→high by price. The best NO bid
+ * (highest price) is the cheapest YES ask.
+ */
+function calcSlippage100(noDollars, qty) {
+    // Sort descending by price (highest no bid = cheapest yes ask)
+    const levels = noDollars
+        .map(([price, amount]) => ({
+        noPrice: parseFloat(price),
+        yesAsk: 1.0 - parseFloat(price),
+        qty: parseFloat(amount),
+    }))
+        .filter(l => l.noPrice > 0 && l.qty > 0)
+        .sort((a, b) => b.noPrice - a.noPrice); // highest no price first = lowest yes ask
+    let remaining = qty;
+    let totalCost = 0;
+    for (const level of levels) {
+        if (remaining <= 0)
+            break;
+        const fill = Math.min(remaining, level.qty);
+        totalCost += fill * level.yesAsk;
+        remaining -= fill;
+    }
+    if (remaining > 0)
+        return '∞';
+    const avgPrice = totalCost / qty;
+    return (avgPrice * 100).toFixed(1) + '¢';
+}
+// ── Batch concurrency helper ─────────────────────────────────────────────────
+async function batchProcess(items, fn, batchSize, delayMs) {
+    const results = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        const settled = await Promise.allSettled(batch.map(fn));
+        for (const s of settled) {
+            results.push(s.status === 'fulfilled' ? s.value : null);
+        }
+        if (i + batchSize < items.length) {
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+    }
+    return results;
+}
+// ── Main command ─────────────────────────────────────────────────────────────
+async function liquidityCommand(opts) {
+    // Determine which topics to scan
+    const allTopics = Object.keys(topics_js_1.TOPIC_SERIES);
+    const topics = opts.topic
+        ? allTopics.filter(t => t.toLowerCase() === opts.topic.toLowerCase())
+        : allTopics;
+    if (topics.length === 0) {
+        const valid = allTopics.join(', ');
+        console.error(`Unknown topic: ${opts.topic}. Valid topics: ${valid}`);
+        process.exit(1);
+    }
+    // Fetch held positions if Kalshi is configured
+    let heldTickers = new Set();
+    if ((0, kalshi_js_1.isKalshiConfigured)()) {
+        try {
+            const positions = await (0, kalshi_js_1.getPositions)();
+            if (positions) {
+                heldTickers = new Set(positions.map(p => p.ticker));
+            }
+        }
+        catch {
+            // ignore — positions are optional decoration
+        }
+    }
+    // Collect all markets per topic
+    const topicMarkets = {};
+    for (const topic of topics) {
+        const series = topics_js_1.TOPIC_SERIES[topic];
+        const markets = [];
+        for (const seriesTicker of series) {
+            try {
+                const m = await (0, client_js_1.kalshiFetchMarketsBySeries)(seriesTicker);
+                markets.push(...m);
+            }
+            catch {
+                // skip failed series
+            }
+        }
+        if (markets.length > 0) {
+            topicMarkets[topic] = markets;
+        }
+    }
+    // Filter by horizon if specified, classify all markets
+    const horizonFilter = opts.horizon;
+    const marketInfos = [];
+    for (const [topic, markets] of Object.entries(topicMarkets)) {
+        for (const m of markets) {
+            const closeTime = m.close_time || m.expiration_time || '';
+            if (!closeTime)
+                continue;
+            const horizon = classifyHorizon(closeTime);
+            if (horizonFilter && horizon !== horizonFilter)
+                continue;
+            marketInfos.push({ ticker: m.ticker, closeTime, topic, horizon });
+        }
+    }
+    if (marketInfos.length === 0) {
+        console.log('No markets found matching filters.');
+        return;
+    }
+    // Fetch orderbooks in batches of 5, 100ms between batches
+    const orderbooks = await batchProcess(marketInfos, async (info) => {
+        const ob = await (0, kalshi_js_1.getPublicOrderbook)(info.ticker);
+        return { info, ob };
+    }, 5, 100);
+    // Build liquidity rows
+    const rows = [];
+    for (const result of orderbooks) {
+        if (!result || !result.ob)
+            continue;
+        const { info, ob } = result;
+        const yesDollars = ob.yes_dollars.map(([p, q]) => ({
+            price: Math.round(parseFloat(p) * 100),
+            qty: parseFloat(q),
+        })).filter(l => l.price > 0);
+        const noDollars = ob.no_dollars.map(([p, q]) => ({
+            price: Math.round(parseFloat(p) * 100),
+            qty: parseFloat(q),
+        })).filter(l => l.price > 0);
+        // Sort descending
+        yesDollars.sort((a, b) => b.price - a.price);
+        noDollars.sort((a, b) => b.price - a.price);
+        const bestBid = yesDollars.length > 0 ? yesDollars[0].price : 0;
+        const bestAsk = noDollars.length > 0 ? (100 - noDollars[0].price) : 100;
+        const spread = bestAsk - bestBid;
+        const bidDepth = yesDollars.reduce((sum, l) => sum + l.qty, 0);
+        const askDepth = noDollars.reduce((sum, l) => sum + l.qty, 0);
+        const slippage100 = calcSlippage100(ob.no_dollars, 100);
+        // Filter by minDepth
+        if (opts.minDepth && (bidDepth + askDepth) < opts.minDepth)
+            continue;
+        rows.push({
+            ticker: info.ticker,
+            shortTicker: info.ticker, // will abbreviate per-group below
+            horizon: info.horizon,
+            closeTime: info.closeTime,
+            bestBid,
+            bestAsk,
+            spread,
+            bidDepth,
+            askDepth,
+            slippage100,
+            held: heldTickers.has(info.ticker),
+        });
+    }
+    // ── JSON output ────────────────────────────────────────────────────────────
+    if (opts.json) {
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+    }
+    // ── Formatted output ───────────────────────────────────────────────────────
+    const now = new Date().toISOString().slice(0, 10);
+    console.log();
+    console.log(`${utils_js_1.c.bold}Liquidity Scanner${utils_js_1.c.reset} ${utils_js_1.c.dim}(${now} UTC)${utils_js_1.c.reset}`);
+    console.log(utils_js_1.c.dim + '─'.repeat(68) + utils_js_1.c.reset);
+    // Group rows by topic → horizon
+    const grouped = {};
+    for (const row of rows) {
+        // find which topic this ticker belongs to
+        let topic = 'OTHER';
+        for (const [t, series] of Object.entries(topics_js_1.TOPIC_SERIES)) {
+            for (const s of series) {
+                if (row.ticker.toUpperCase().startsWith(s)) {
+                    topic = t.toUpperCase();
+                    break;
+                }
+            }
+            if (topic !== 'OTHER')
+                break;
+        }
+        if (!grouped[topic])
+            grouped[topic] = {};
+        if (!grouped[topic][row.horizon])
+            grouped[topic][row.horizon] = [];
+        grouped[topic][row.horizon].push(row);
+    }
+    let totalMarkets = 0;
+    let thinMarkets = 0;
+    let heldCount = 0;
+    const horizonOrder = ['weekly', 'monthly', 'long-term'];
+    for (const [topic, horizons] of Object.entries(grouped)) {
+        for (const h of horizonOrder) {
+            const marketRows = horizons[h];
+            if (!marketRows || marketRows.length === 0)
+                continue;
+            // Find common prefix for abbreviation within this group
+            const commonPrefix = findCommonPrefix(marketRows.map(r => r.ticker));
+            // Abbreviate tickers
+            for (const row of marketRows) {
+                row.shortTicker = commonPrefix.length > 0
+                    ? row.ticker.slice(commonPrefix.length).replace(/^-/, '')
+                    : row.ticker;
+                if (row.shortTicker.length === 0)
+                    row.shortTicker = row.ticker;
+            }
+            // Sort by ticker
+            marketRows.sort((a, b) => a.ticker.localeCompare(b.ticker));
+            console.log();
+            console.log(`${utils_js_1.c.bold}${utils_js_1.c.cyan}${topic}${utils_js_1.c.reset} ${utils_js_1.c.dim}— ${horizonLabel(h)}${utils_js_1.c.reset}`);
+            console.log(`${utils_js_1.c.dim}${(0, utils_js_1.pad)('Ticker', 20)} ${(0, utils_js_1.rpad)('Bid¢', 5)} ${(0, utils_js_1.rpad)('Ask¢', 5)} ${(0, utils_js_1.rpad)('Spread', 6)} ${(0, utils_js_1.rpad)('BidDep', 6)} ${(0, utils_js_1.rpad)('AskDep', 6)} ${(0, utils_js_1.rpad)('Slip100', 7)}${utils_js_1.c.reset}`);
+            for (const row of marketRows) {
+                totalMarkets++;
+                if (row.held)
+                    heldCount++;
+                const thin = row.spread > 5;
+                if (thin)
+                    thinMarkets++;
+                // Color spread
+                let spreadStr;
+                if (row.spread <= 2) {
+                    spreadStr = `${utils_js_1.c.green}${row.spread}¢${utils_js_1.c.reset}`;
+                }
+                else if (row.spread <= 5) {
+                    spreadStr = `${utils_js_1.c.yellow}${row.spread}¢${utils_js_1.c.reset}`;
+                }
+                else {
+                    spreadStr = `${utils_js_1.c.red}${row.spread}¢${utils_js_1.c.reset}`;
+                }
+                const thinMark = thin ? ' \u26A0\uFE0F' : '';
+                const heldMark = row.held ? `  ${utils_js_1.c.magenta}\u2190 held${utils_js_1.c.reset}` : '';
+                // Pad spread field accounting for ANSI codes
+                const spreadPadded = (0, utils_js_1.rpad)(`${row.spread}¢`, 6);
+                const spreadColored = row.spread <= 2
+                    ? `${utils_js_1.c.green}${spreadPadded}${utils_js_1.c.reset}`
+                    : row.spread <= 5
+                        ? `${utils_js_1.c.yellow}${spreadPadded}${utils_js_1.c.reset}`
+                        : `${utils_js_1.c.red}${spreadPadded}${utils_js_1.c.reset}`;
+                console.log(`${(0, utils_js_1.pad)(row.shortTicker, 20)} ${(0, utils_js_1.rpad)(String(row.bestBid), 5)} ${(0, utils_js_1.rpad)(String(row.bestAsk), 5)} ${spreadColored} ${(0, utils_js_1.rpad)(String(Math.round(row.bidDepth)), 6)} ${(0, utils_js_1.rpad)(String(Math.round(row.askDepth)), 6)} ${(0, utils_js_1.rpad)(row.slippage100, 7)}${thinMark}${heldMark}`);
+            }
+        }
+    }
+    // Summary
+    console.log();
+    console.log(`${utils_js_1.c.dim}Summary: ${totalMarkets} markets | ${thinMarkets} thin (spread>5¢) | ${heldCount} held${utils_js_1.c.reset}`);
+    console.log();
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function findCommonPrefix(strings) {
+    if (strings.length === 0)
+        return '';
+    if (strings.length === 1)
+        return '';
+    let prefix = strings[0];
+    for (let i = 1; i < strings.length; i++) {
+        while (!strings[i].startsWith(prefix)) {
+            prefix = prefix.slice(0, -1);
+            if (prefix.length === 0)
+                return '';
+        }
+    }
+    // Don't strip if it would leave nothing for some tickers
+    // Also strip trailing hyphen from prefix for cleaner display
+    return prefix;
+}

package/dist/commands/performance.d.ts

@@ -0,0 +1,8 @@
+/**
+ * sf performance — Portfolio P&L over time with thesis event annotations
+ */
+export declare function performanceCommand(opts: {
+    ticker?: string;
+    since?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/performance.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * sf performance — Portfolio P&L over time with thesis event annotations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performanceCommand = performanceCommand;
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+const config_js_1 = require("../config.js");
+const utils_js_1 = require("../utils.js");
+/** Abbreviate ticker: KXWTIMAX-26DEC31-T135 -> T135 */
+function abbrevTicker(ticker) {
+    const parts = ticker.split('-');
+    return parts[parts.length - 1] || ticker;
+}
+/** Format date as "Mar 01" */
+function fmtDate(d) {
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    return `${months[d.getMonth()]} ${String(d.getDate()).padStart(2, '0')}`;
+}
+/** Format dollar amount: positive -> +$12.30, negative -> -$12.30 */
+function fmtDollar(cents) {
+    const abs = Math.abs(cents / 100);
+    if (cents >= 0)
+        return `+$${abs.toFixed(cents === 0 ? 2 : abs >= 100 ? 1 : 2)}`;
+    return `-$${abs.toFixed(abs >= 100 ? 1 : 2)}`;
+}
+/** Date string key YYYY-MM-DD from a Date */
+function dateKey(d) {
+    return d.toISOString().slice(0, 10);
+}
+async function performanceCommand(opts) {
+    if (!(0, kalshi_js_1.isKalshiConfigured)()) {
+        console.log(`${utils_js_1.c.yellow}Kalshi not configured.${utils_js_1.c.reset} Run ${utils_js_1.c.cyan}sf setup --kalshi${utils_js_1.c.reset} first.`);
+        return;
+    }
+    // 1. Fetch fills
+    const fillsResult = await (0, kalshi_js_1.getFills)({ limit: 500 });
+    if (!fillsResult || fillsResult.fills.length === 0) {
+        console.log(`${utils_js_1.c.dim}No fills found.${utils_js_1.c.reset}`);
+        return;
+    }
+    const fills = fillsResult.fills;
+    const tickerMap = new Map();
+    for (const fill of fills) {
+        const ticker = fill.ticker || fill.market_ticker || '';
+        if (!ticker)
+            continue;
+        const side = fill.side || 'yes';
+        const action = fill.action || 'buy';
+        const count = Math.round(parseFloat(fill.count_fp || fill.count || '0'));
+        const yesPrice = Math.round(parseFloat(fill.yes_price_dollars || '0') * 100); // dollars string → cents int
+        // Determine direction: buy yes = +count, sell yes = -count
+        let delta = count;
+        if (action === 'sell')
+            delta = -count;
+        const info = tickerMap.get(ticker) || {
+            ticker,
+            netQty: 0,
+            totalCostCents: 0,
+            totalContracts: 0,
+            earliestFillTs: Infinity,
+        };
+        info.netQty += delta;
+        if (delta > 0) {
+            // Buying: accumulate cost
+            info.totalCostCents += yesPrice * count;
+            info.totalContracts += count;
+        }
+        // Track earliest fill
+        const fillTime = fill.created_time || fill.ts || fill.created_at;
+        if (fillTime) {
+            const ts = Math.floor(new Date(fillTime).getTime() / 1000);
+            if (ts < info.earliestFillTs)
+                info.earliestFillTs = ts;
+        }
+        tickerMap.set(ticker, info);
+    }
+    // 3. Filter out fully closed positions (net qty = 0)
+    let tickers = [...tickerMap.values()].filter(t => t.netQty !== 0);
+    // 4. Apply --ticker fuzzy filter
+    if (opts.ticker) {
+        const needle = opts.ticker.toLowerCase();
+        tickers = tickers.filter(t => t.ticker.toLowerCase().includes(needle));
+    }
+    if (tickers.length === 0) {
+        console.log(`${utils_js_1.c.dim}No open positions found${opts.ticker ? ` matching "${opts.ticker}"` : ''}.${utils_js_1.c.reset}`);
+        return;
+    }
+    // Determine date range
+    const sinceTs = opts.since
+        ? Math.floor(new Date(opts.since).getTime() / 1000)
+        : Math.min(...tickers.map(t => t.earliestFillTs === Infinity ? Math.floor(Date.now() / 1000) - 30 * 86400 : t.earliestFillTs));
+    const nowTs = Math.floor(Date.now() / 1000);
+    // 5. Fetch candlesticks
+    const candleData = await (0, kalshi_js_1.getBatchCandlesticks)({
+        tickers: tickers.map(t => t.ticker),
+        startTs: sinceTs,
+        endTs: nowTs,
+        periodInterval: 1440,
+    });
+    // Build candlestick lookup: ticker -> dateKey -> close price (cents)
+    const candleMap = new Map();
+    for (const mc of candleData) {
+        const priceByDate = new Map();
+        for (const candle of (mc.candlesticks || [])) {
+            // close_dollars is a string like "0.4800"
+            // price object may be empty; use midpoint of yes_bid.close and yes_ask.close
+            const bidClose = parseFloat(candle.yes_bid?.close_dollars || '0');
+            const askClose = parseFloat(candle.yes_ask?.close_dollars || '0');
+            const mid = bidClose > 0 && askClose > 0 ? (bidClose + askClose) / 2 : bidClose || askClose;
+            const closeDollars = parseFloat(candle.price?.close_dollars || '0') || mid;
+            const closeCents = Math.round(closeDollars * 100);
+            const ts = candle.end_period_ts || candle.period_end_ts || candle.ts;
+            if (ts) {
+                const d = new Date(ts * 1000);
+                priceByDate.set(dateKey(d), closeCents);
+            }
+        }
+        candleMap.set(mc.market_ticker, priceByDate);
+    }
+    // 6. Build daily P&L matrix
+    // Collect all unique dates across all tickers
+    const allDates = new Set();
+    for (const [, priceByDate] of candleMap) {
+        for (const dk of priceByDate.keys()) {
+            allDates.add(dk);
+        }
+    }
+    const sortedDates = [...allDates].sort();
+    // For each ticker compute entry price
+    const entryPrices = new Map();
+    for (const t of tickers) {
+        const avgEntry = t.totalContracts > 0 ? Math.round(t.totalCostCents / t.totalContracts) : 0;
+        entryPrices.set(t.ticker, avgEntry);
+    }
+    const dailyRows = [];
+    for (const dk of sortedDates) {
+        const pnlByTicker = new Map();
+        let total = 0;
+        for (const t of tickers) {
+            const prices = candleMap.get(t.ticker);
+            const closePrice = prices?.get(dk);
+            if (closePrice !== undefined) {
+                const entry = entryPrices.get(t.ticker) || 0;
+                const pnl = (closePrice - entry) * t.netQty;
+                pnlByTicker.set(t.ticker, pnl);
+                total += pnl;
+            }
+        }
+        dailyRows.push({ date: dk, pnlByTicker, total });
+    }
+    const events = [];
+    try {
+        const config = (0, config_js_1.loadConfig)();
+        const client = new client_js_1.SFClient(config.apiKey, config.apiUrl);
+        const feedData = await client.getFeed(720);
+        const feedItems = feedData?.items || feedData?.events || feedData || [];
+        if (Array.isArray(feedItems)) {
+            for (const item of feedItems) {
+                const confDelta = item.confidenceDelta ?? item.confidence_delta ?? 0;
+                if (Math.abs(confDelta) > 0.03) {
+                    const itemDate = item.createdAt || item.created_at || item.timestamp || '';
+                    if (itemDate) {
+                        events.push({
+                            date: dateKey(new Date(itemDate)),
+                            direction: confDelta > 0 ? 'up' : 'down',
+                            deltaPct: Math.round(confDelta * 100),
+                            summary: item.summary || item.title || item.description || '',
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Feed unavailable — continue without events
+    }
+    // Compute summary
+    const totalCostCents = tickers.reduce((sum, t) => sum + t.totalCostCents, 0);
+    const lastRow = dailyRows.length > 0 ? dailyRows[dailyRows.length - 1] : null;
+    const currentPnlCents = lastRow?.total ?? 0;
+    const currentValueCents = totalCostCents + currentPnlCents;
+    const pnlPct = totalCostCents > 0 ? (currentPnlCents / totalCostCents) * 100 : 0;
+    // 8. Output
+    if (opts.json) {
+        console.log(JSON.stringify({
+            daily: dailyRows.map(row => {
+                const tickerPnl = {};
+                for (const [tk, pnl] of row.pnlByTicker) {
+                    tickerPnl[tk] = pnl;
+                }
+                return { date: row.date, tickers: tickerPnl, total: row.total };
+            }),
+            events,
+            summary: {
+                cost: totalCostCents,
+                current: currentValueCents,
+                pnl: currentPnlCents,
+                pnlPct: Math.round(pnlPct * 10) / 10,
+            },
+        }, null, 2));
+        return;
+    }
+    // Formatted output
+    const startDate = sortedDates.length > 0 ? fmtDate(new Date(sortedDates[0])) : '?';
+    const endDate = fmtDate(new Date());
+    console.log();
+    console.log(`  ${utils_js_1.c.bold}Portfolio Performance${utils_js_1.c.reset} ${utils_js_1.c.dim}(${startDate} -> ${endDate})${utils_js_1.c.reset}`);
+    console.log(`  ${utils_js_1.c.dim}${'─'.repeat(50)}${utils_js_1.c.reset}`);
+    console.log();
+    // Column headers
+    const abbrevs = tickers.map(t => abbrevTicker(t.ticker));
+    const colWidth = 9;
+    const dateCol = 'Date'.padEnd(12);
+    const headerCols = abbrevs.map(a => (0, utils_js_1.rpad)(a, colWidth)).join('');
+    const totalCol = (0, utils_js_1.rpad)('Total', colWidth);
+    console.log(`  ${utils_js_1.c.dim}${dateCol}${headerCols}${totalCol}${utils_js_1.c.reset}`);
+    // Rows — show at most ~30 rows, sample if more
+    const maxRows = 30;
+    let rowsToShow = dailyRows;
+    if (dailyRows.length > maxRows) {
+        // Sample evenly + always include first and last
+        const step = Math.ceil(dailyRows.length / maxRows);
+        rowsToShow = dailyRows.filter((_, i) => i === 0 || i === dailyRows.length - 1 || i % step === 0);
+    }
+    for (const row of rowsToShow) {
+        const d = new Date(row.date);
+        const dateStr = fmtDate(d).padEnd(12);
+        const cols = tickers.map(t => {
+            const pnl = row.pnlByTicker.get(t.ticker);
+            if (pnl === undefined)
+                return (0, utils_js_1.rpad)('--', colWidth);
+            const str = fmtDollar(pnl);
+            const color = pnl > 0 ? utils_js_1.c.green : pnl < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+            return color + (0, utils_js_1.rpad)(str, colWidth) + utils_js_1.c.reset;
+        }).join('');
+        const totalStr = fmtDollar(row.total);
+        const totalColor = row.total > 0 ? utils_js_1.c.green : row.total < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+        console.log(`  ${dateStr}${cols}${totalColor}${(0, utils_js_1.rpad)(totalStr, colWidth)}${utils_js_1.c.reset}`);
+    }
+    // Events
+    if (events.length > 0) {
+        console.log();
+        // Match events to date range
+        const dateSet = new Set(sortedDates);
+        const relevantEvents = events.filter(e => dateSet.has(e.date));
+        for (const ev of relevantEvents.slice(0, 10)) {
+            const arrow = ev.direction === 'up' ? `${utils_js_1.c.green}▲${utils_js_1.c.reset}` : `${utils_js_1.c.red}▼${utils_js_1.c.reset}`;
+            const dateFmt = fmtDate(new Date(ev.date));
+            const sign = ev.deltaPct > 0 ? '+' : '';
+            const summary = ev.summary.length > 60 ? ev.summary.slice(0, 59) + '...' : ev.summary;
+            console.log(`  ${arrow} ${utils_js_1.c.dim}${dateFmt}${utils_js_1.c.reset}  ${sign}${ev.deltaPct}% -> ${summary}`);
+        }
+    }
+    // Summary line
+    console.log();
+    const costStr = `$${(totalCostCents / 100).toFixed(0)}`;
+    const currentStr = `$${(currentValueCents / 100).toFixed(0)}`;
+    const pnlStr = fmtDollar(currentPnlCents);
+    const pnlPctStr = `${pnlPct >= 0 ? '+' : ''}${pnlPct.toFixed(1)}%`;
+    const pnlColor = currentPnlCents >= 0 ? utils_js_1.c.green : utils_js_1.c.red;
+    console.log(`  ${utils_js_1.c.dim}Cost:${utils_js_1.c.reset} ${costStr}  ${utils_js_1.c.dim}|  Current:${utils_js_1.c.reset} ${currentStr}  ${utils_js_1.c.dim}|  P&L:${utils_js_1.c.reset} ${pnlColor}${pnlStr} (${pnlPctStr})${utils_js_1.c.reset}`);
+    console.log();
+}

package/dist/index.js

@@ -50,6 +50,8 @@ const schedule_js_1 = require("./commands/schedule.js");
 const rfq_js_1 = require("./commands/rfq.js");
 const announcements_js_1 = require("./commands/announcements.js");
 const history_js_1 = require("./commands/history.js");
+const performance_js_1 = require("./commands/performance.js");
+const liquidity_js_1 = require("./commands/liquidity.js");
 const utils_js_1 = require("./utils.js");
 // ── Apply ~/.sf/config.json to process.env BEFORE any command ────────────────
 // This means client.ts, kalshi.ts, agent.ts keep reading process.env and just work.
@@ -62,7 +64,7 @@ program
     .option('--api-key <key>', 'API key (or set SF_API_KEY env var)')
     .option('--api-url <url>', 'API base URL (or set SF_API_URL env var)');
 // ── Pre-action guard: check configuration ────────────────────────────────────
-const NO_CONFIG_COMMANDS = new Set(['setup', 'help', 'scan', 'explore', 'milestones', 'forecast', 'settlements', 'balance', 'orders', 'fills', 'schedule', 'announcements', 'history']);
+const NO_CONFIG_COMMANDS = new Set(['setup', 'help', 'scan', 'explore', 'milestones', 'forecast', 'settlements', 'balance', 'orders', 'fills', 'schedule', 'announcements', 'history', 'liquidity']);
 program.hook('preAction', (thisCommand, actionCommand) => {
     const cmdName = actionCommand.name();
     if (NO_CONFIG_COMMANDS.has(cmdName))
@@ -386,6 +388,27 @@ program
     .action(async (ticker, opts) => {
     await run(() => (0, history_js_1.historyCommand)(ticker, opts));
 });
+// ── sf performance ───────────────────────────────────────────────────────────
+program
+    .command('performance')
+    .description('Portfolio P&L over time with thesis event annotations')
+    .option('--ticker <ticker>', 'Filter by ticker (fuzzy match)')
+    .option('--since <date>', 'Start date (ISO, e.g. 2026-03-01)')
+    .option('--json', 'JSON output')
+    .action(async (opts) => {
+    await run(() => (0, performance_js_1.performanceCommand)(opts));
+});
+// ── sf liquidity ─────────────────────────────────────────────────────────────
+program
+    .command('liquidity')
+    .description('Market liquidity scanner by topic and horizon')
+    .option('--topic <topic>', 'Filter topic (oil, recession, fed, cpi, gas, sp500)')
+    .option('--horizon <horizon>', 'Filter horizon (weekly, monthly, long-term)')
+    .option('--min-depth <depth>', 'Minimum bid+ask depth', parseInt)
+    .option('--json', 'JSON output')
+    .action(async (opts) => {
+    await run(() => (0, liquidity_js_1.liquidityCommand)(opts));
+});
 // ── sf strategies ─────────────────────────────────────────────────────────────
 (0, strategies_js_1.registerStrategies)(program);
 // ── Error wrapper ─────────────────────────────────────────────────────────────

package/dist/kalshi.d.ts

@@ -58,6 +58,15 @@ export interface LocalOrderbook {
     liquidityScore: 'high' | 'medium' | 'low';
 }
 export declare function getOrderbook(ticker: string): Promise<LocalOrderbook | null>;
+export interface PublicOrderbook {
+    yes_dollars: Array<[string, string]>;
+    no_dollars: Array<[string, string]>;
+}
+/**
+ * Fetch orderbook for a ticker using the public (unauthenticated) endpoint.
+ * Returns raw yes_dollars/no_dollars arrays or null on failure.
+ */
+export declare function getPublicOrderbook(ticker: string, depth?: number): Promise<PublicOrderbook | null>;
 export declare function getSettlements(params?: {
     limit?: number;
     cursor?: string;
@@ -116,6 +125,15 @@ export declare function amendOrder(orderId: string, params: {
 }): Promise<{
     order: any;
 }>;
+export declare function getBatchCandlesticks(params: {
+    tickers: string[];
+    startTs: number;
+    endTs: number;
+    periodInterval?: number;
+}): Promise<{
+    market_ticker: string;
+    candlesticks: any[];
+}[]>;
 export declare function createRFQ(params: {
     market_ticker: string;
     contracts: number;

package/dist/kalshi.js

@@ -19,6 +19,7 @@ exports.getPositions = getPositions;
 exports.kalshiPriceCents = kalshiPriceCents;
 exports.getMarketPrice = getMarketPrice;
 exports.getOrderbook = getOrderbook;
+exports.getPublicOrderbook = getPublicOrderbook;
 exports.getSettlements = getSettlements;
 exports.getBalance = getBalance;
 exports.getOrders = getOrders;
@@ -30,6 +31,7 @@ exports.createOrder = createOrder;
 exports.cancelOrder = cancelOrder;
 exports.batchCancelOrders = batchCancelOrders;
 exports.amendOrder = amendOrder;
+exports.getBatchCandlesticks = getBatchCandlesticks;
 exports.createRFQ = createRFQ;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -278,6 +280,27 @@ async function getOrderbook(ticker) {
         return null;
     }
 }
+/**
+ * Fetch orderbook for a ticker using the public (unauthenticated) endpoint.
+ * Returns raw yes_dollars/no_dollars arrays or null on failure.
+ */
+async function getPublicOrderbook(ticker, depth = 20) {
+    try {
+        const url = `${KALSHI_API_BASE}/markets/${ticker}/orderbook?depth=${depth}`;
+        const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const ob = data.orderbook_fp || data.orderbook || data;
+        return {
+            yes_dollars: ob.yes_dollars || ob.yes || [],
+            no_dollars: ob.no_dollars || ob.no || [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
 // ============================================================================
 // SETTLEMENTS (Authenticated)
 // ============================================================================
@@ -450,6 +473,26 @@ async function amendOrder(orderId, params) {
     }
     return res.json();
 }
+// ============================================================================
+// CANDLESTICKS (Authenticated)
+// ============================================================================
+async function getBatchCandlesticks(params) {
+    if (!isKalshiConfigured())
+        return [];
+    try {
+        const searchParams = new URLSearchParams();
+        searchParams.set('market_tickers', params.tickers.join(','));
+        searchParams.set('start_ts', params.startTs.toString());
+        searchParams.set('end_ts', params.endTs.toString());
+        searchParams.set('period_interval', (params.periodInterval ?? 1440).toString());
+        const data = await kalshiAuthGet(`/markets/candlesticks?${searchParams.toString()}`);
+        return data.markets || [];
+    }
+    catch (err) {
+        console.warn('[Kalshi] Failed to fetch candlesticks:', err);
+        return [];
+    }
+}
 async function createRFQ(params) {
     return kalshiAuthPost('/communications/rfqs', params);
 }

package/dist/topics.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Topic → Kalshi series mapping
+ *
+ * Shared between dashboard, liquidity scanner, and other commands
+ * that need to categorize markets by topic.
+ */
+export declare const TOPIC_SERIES: Record<string, string[]>;
+/** Map a series prefix to a human-readable category name (for dashboard display) */
+export declare const RISK_CATEGORIES: Record<string, string>;
+/**
+ * Given a ticker string, return the topic name (uppercased).
+ * Matches longest prefix first to avoid ambiguity (e.g. KXWTIMAX before KXWTI).
+ */
+export declare function tickerToTopic(ticker: string): string;

package/dist/topics.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Topic → Kalshi series mapping
+ *
+ * Shared between dashboard, liquidity scanner, and other commands
+ * that need to categorize markets by topic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RISK_CATEGORIES = exports.TOPIC_SERIES = void 0;
+exports.tickerToTopic = tickerToTopic;
+exports.TOPIC_SERIES = {
+    oil: ['KXWTIMAX', 'KXWTIW', 'KXWTID'],
+    recession: ['KXRECSSNBER'],
+    fed: ['KXFEDDECISION'],
+    cpi: ['KXCPI'],
+    gas: ['KXAAAGASM'],
+    sp500: ['KXINXY'],
+};
+/** Map a series prefix to a human-readable category name (for dashboard display) */
+exports.RISK_CATEGORIES = {
+    KXWTIMAX: 'Oil',
+    KXWTI: 'Oil',
+    KXRECSSNBER: 'Recession',
+    KXAAAGASM: 'Gas',
+    KXCPI: 'Inflation',
+    KXINXY: 'S&P 500',
+    KXFEDDECISION: 'Fed Rate',
+    KXUNEMPLOYMENT: 'Unemployment',
+    KXCLOSEHORMUZ: 'Hormuz',
+};
+/**
+ * Given a ticker string, return the topic name (uppercased).
+ * Matches longest prefix first to avoid ambiguity (e.g. KXWTIMAX before KXWTI).
+ */
+function tickerToTopic(ticker) {
+    const sorted = Object.entries(exports.TOPIC_SERIES)
+        .flatMap(([topic, series]) => series.map(s => ({ prefix: s, topic })))
+        .sort((a, b) => b.prefix.length - a.prefix.length);
+    for (const { prefix, topic } of sorted) {
+        if (ticker.toUpperCase().startsWith(prefix))
+            return topic.toUpperCase();
+    }
+    return 'OTHER';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfunctions/cli",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Prediction market intelligence CLI. Causal thesis model, 24/7 Kalshi/Polymarket scan, live orderbook, edge detection. Interactive agent mode with tool calling.",
   "bin": {
     "sf": "./dist/index.js"