@spfunctions/cli 1.2.1 → 1.4.0

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,261 @@
+"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 = fill.count || 0;
+        const yesPrice = fill.yes_price || 0; // 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"
+            const closeDollars = parseFloat(candle.close_dollars || candle.close || '0');
+            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();
+}