@spfunctions/cli 1.4.4 → 1.4.5

package/dist/telegram/commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Telegram slash command handlers — direct API calls, zero LLM cost
+ */
+import { SFClient } from '../client.js';
+export declare function handleContext(client: SFClient, thesisId: string): Promise<string>;
+export declare function handlePositions(): Promise<string>;
+export declare function handleEdges(client: SFClient): Promise<string>;
+export declare function handleBalance(): Promise<string>;
+export declare function handleOrders(): Promise<string>;
+export declare function handleEval(client: SFClient, thesisId: string): Promise<string>;
+export declare function handleList(client: SFClient): Promise<string>;

package/dist/telegram/commands.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Telegram slash command handlers — direct API calls, zero LLM cost
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleContext = handleContext;
+exports.handlePositions = handlePositions;
+exports.handleEdges = handleEdges;
+exports.handleBalance = handleBalance;
+exports.handleOrders = handleOrders;
+exports.handleEval = handleEval;
+exports.handleList = handleList;
+const kalshi_js_1 = require("../kalshi.js");
+const format_js_1 = require("./format.js");
+async function handleContext(client, thesisId) {
+    const ctx = await client.getContext(thesisId);
+    const conf = typeof ctx.confidence === 'number' ? Math.round(ctx.confidence * 100) : '?';
+    const thesis = ctx.thesis || ctx.rawThesis || 'N/A';
+    let text = `📋 <b>${(0, format_js_1.escapeHtml)(thesis.slice(0, 80))}</b>\n`;
+    text += `Confidence: <b>${conf}%</b> | Status: ${ctx.status}\n\n`;
+    const edges = (ctx.edges || []).slice(0, 8);
+    if (edges.length > 0) {
+        text += `<b>Top Edges:</b>\n<pre>`;
+        for (const e of edges) {
+            const name = (e.market || e.marketTitle || '???').slice(0, 35);
+            text += `${name.padEnd(36)} ${String(e.edge || 0).padStart(3)}¢ ${e.direction || 'yes'}\n`;
+        }
+        text += `</pre>`;
+    }
+    return text;
+}
+async function handlePositions() {
+    if (!(0, kalshi_js_1.isKalshiConfigured)())
+        return '⚠️ Kalshi not configured. Run <code>sf setup --kalshi</code>';
+    const positions = await (0, kalshi_js_1.getPositions)();
+    if (!positions || positions.length === 0)
+        return 'No open positions.';
+    // Enrich with live prices
+    let totalPnlCents = 0;
+    const lines = [];
+    for (const pos of positions) {
+        const livePrice = await (0, kalshi_js_1.getMarketPrice)(pos.ticker);
+        const current = livePrice ?? pos.average_price_paid;
+        const pnlCents = (current - pos.average_price_paid) * pos.quantity;
+        totalPnlCents += pnlCents;
+        const pnl = (0, format_js_1.fmtDollar)(pnlCents);
+        lines.push(`${pos.ticker.slice(0, 28).padEnd(29)} ${String(pos.quantity).padStart(5)} ${String(pos.average_price_paid).padStart(3)}¢→${String(current).padStart(3)}¢ ${pnl}`);
+    }
+    let text = `📊 <b>Positions</b>\n<pre>`;
+    text += lines.join('\n');
+    text += `\n${'─'.repeat(50)}\nTotal P&L: ${(0, format_js_1.fmtDollar)(totalPnlCents)}`;
+    text += `</pre>`;
+    return text;
+}
+async function handleEdges(client) {
+    const { theses } = await client.listTheses();
+    const active = (theses || []).filter((t) => t.status === 'active');
+    const results = await Promise.allSettled(active.map(async (t) => {
+        const ctx = await client.getContext(t.id);
+        return (ctx.edges || []).map((e) => ({ ...e, thesisId: t.id }));
+    }));
+    const allEdges = [];
+    for (const r of results) {
+        if (r.status === 'fulfilled')
+            allEdges.push(...r.value);
+    }
+    allEdges.sort((a, b) => Math.abs(b.edge || 0) - Math.abs(a.edge || 0));
+    const top = allEdges.slice(0, 10);
+    if (top.length === 0)
+        return 'No edges found.';
+    let text = `📈 <b>Top Edges</b>\n<pre>`;
+    for (const e of top) {
+        const name = (e.market || '???').slice(0, 35);
+        const liq = e.orderbook?.liquidityScore || '?';
+        text += `${name.padEnd(36)} +${String(e.edge || 0).padStart(2)}¢ ${liq}\n`;
+    }
+    text += `</pre>`;
+    return text;
+}
+async function handleBalance() {
+    if (!(0, kalshi_js_1.isKalshiConfigured)())
+        return '⚠️ Kalshi not configured.';
+    const bal = await (0, kalshi_js_1.getBalance)();
+    if (!bal)
+        return '⚠️ Failed to fetch balance.';
+    return `💰 Balance: <b>$${bal.balance.toFixed(2)}</b> | Portfolio: <b>$${bal.portfolioValue.toFixed(2)}</b>`;
+}
+async function handleOrders() {
+    if (!(0, kalshi_js_1.isKalshiConfigured)())
+        return '⚠️ Kalshi not configured.';
+    const result = await (0, kalshi_js_1.getOrders)({ status: 'resting', limit: 20 });
+    if (!result || !result.orders || result.orders.length === 0)
+        return 'No resting orders.';
+    let text = `📋 <b>Resting Orders</b>\n<pre>`;
+    for (const o of result.orders) {
+        const qty = Math.round(parseFloat(o.remaining_count_fp || '0'));
+        const price = Math.round(parseFloat(o.yes_price_dollars || '0') * 100);
+        const ticker = (o.ticker || '???').slice(0, 25);
+        text += `${o.action} ${qty}x ${ticker} @ ${price}¢\n`;
+    }
+    text += `</pre>`;
+    return text;
+}
+async function handleEval(client, thesisId) {
+    await client.evaluate(thesisId);
+    return '⚡ Evaluation triggered. Results in ~2 minutes.';
+}
+async function handleList(client) {
+    const { theses } = await client.listTheses();
+    if (!theses || theses.length === 0)
+        return 'No theses.';
+    let text = `📝 <b>Theses</b>\n<pre>`;
+    for (const t of theses) {
+        const conf = typeof t.confidence === 'number' ? Math.round(t.confidence * 100) : 0;
+        const title = (t.rawThesis || t.thesis || '').slice(0, 50);
+        text += `${t.id.slice(0, 8)} ${String(conf).padStart(3)}% ${t.status.padEnd(8)} ${title}\n`;
+    }
+    text += `</pre>`;
+    return text;
+}

package/dist/telegram/format.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Telegram message formatting utilities
+ */
+/** Split long text into chunks under Telegram's 4096 char limit */
+export declare function splitMessage(text: string, maxLen?: number): string[];
+/** Format a number as dollars */
+export declare function fmtDollar(cents: number): string;
+/** Simple sparkline */
+export declare function sparkline(values: number[]): string;
+/** Escape HTML special characters for Telegram HTML parse mode */
+export declare function escapeHtml(s: string): string;

package/dist/telegram/format.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Telegram message formatting utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitMessage = splitMessage;
+exports.fmtDollar = fmtDollar;
+exports.sparkline = sparkline;
+exports.escapeHtml = escapeHtml;
+/** Split long text into chunks under Telegram's 4096 char limit */
+function splitMessage(text, maxLen = 4000) {
+    if (text.length <= maxLen)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLen) {
+            chunks.push(remaining);
+            break;
+        }
+        // Find a good split point (newline near maxLen)
+        let splitAt = remaining.lastIndexOf('\n', maxLen);
+        if (splitAt < maxLen * 0.5)
+            splitAt = maxLen;
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt);
+    }
+    return chunks;
+}
+/** Format a number as dollars */
+function fmtDollar(cents) {
+    const d = cents / 100;
+    return d >= 0 ? `+$${d.toFixed(2)}` : `-$${Math.abs(d).toFixed(2)}`;
+}
+/** Simple sparkline */
+function sparkline(values) {
+    if (values.length === 0)
+        return '';
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+    const blocks = '▁▂▃▄▅▆▇█';
+    return values.map(v => {
+        const idx = Math.round(((v - min) / range) * 7);
+        return blocks[idx];
+    }).join('');
+}
+/** Escape HTML special characters for Telegram HTML parse mode */
+function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/dist/telegram/format.test.d.ts

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

package/dist/telegram/format.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const format_js_1 = require("./format.js");
+(0, vitest_1.describe)('splitMessage', () => {
+    (0, vitest_1.it)('returns single chunk for short text', () => {
+        (0, vitest_1.expect)((0, format_js_1.splitMessage)('short text')).toEqual(['short text']);
+    });
+    (0, vitest_1.it)('splits long text at newlines', () => {
+        const lines = Array.from({ length: 50 }, (_, i) => `Line ${i}`).join('\n');
+        const chunks = (0, format_js_1.splitMessage)(lines, 100);
+        for (const chunk of chunks) {
+            (0, vitest_1.expect)(chunk.length).toBeLessThanOrEqual(100);
+        }
+        (0, vitest_1.expect)(chunks.join('')).toBe(lines);
+    });
+    (0, vitest_1.it)('splits at maxLen when no good newline found', () => {
+        const long = 'x'.repeat(200);
+        const chunks = (0, format_js_1.splitMessage)(long, 100);
+        (0, vitest_1.expect)(chunks.length).toBe(2);
+        (0, vitest_1.expect)(chunks[0].length).toBe(100);
+    });
+    (0, vitest_1.it)('handles empty string', () => {
+        (0, vitest_1.expect)((0, format_js_1.splitMessage)('')).toEqual(['']);
+    });
+});
+(0, vitest_1.describe)('fmtDollar', () => {
+    (0, vitest_1.it)('formats positive cents', () => {
+        (0, vitest_1.expect)((0, format_js_1.fmtDollar)(550)).toBe('+$5.50');
+    });
+    (0, vitest_1.it)('formats negative cents', () => {
+        (0, vitest_1.expect)((0, format_js_1.fmtDollar)(-200)).toBe('-$2.00');
+    });
+    (0, vitest_1.it)('formats zero', () => {
+        (0, vitest_1.expect)((0, format_js_1.fmtDollar)(0)).toBe('+$0.00');
+    });
+});
+(0, vitest_1.describe)('sparkline', () => {
+    (0, vitest_1.it)('generates sparkline of correct length', () => {
+        const result = (0, format_js_1.sparkline)([1, 5, 3, 8, 2]);
+        (0, vitest_1.expect)(result.length).toBe(5);
+    });
+    (0, vitest_1.it)('returns empty for empty array', () => {
+        (0, vitest_1.expect)((0, format_js_1.sparkline)([])).toBe('');
+    });
+    (0, vitest_1.it)('handles single value', () => {
+        const result = (0, format_js_1.sparkline)([5]);
+        (0, vitest_1.expect)(result.length).toBe(1);
+    });
+    (0, vitest_1.it)('handles equal values', () => {
+        const result = (0, format_js_1.sparkline)([3, 3, 3]);
+        (0, vitest_1.expect)(result.length).toBe(3);
+    });
+    (0, vitest_1.it)('uses correct block chars for min/max', () => {
+        const result = (0, format_js_1.sparkline)([0, 100]);
+        (0, vitest_1.expect)(result[0]).toBe('▁');
+        (0, vitest_1.expect)(result[1]).toBe('█');
+    });
+});
+(0, vitest_1.describe)('escapeHtml', () => {
+    (0, vitest_1.it)('escapes ampersands', () => {
+        (0, vitest_1.expect)((0, format_js_1.escapeHtml)('a&b')).toBe('a&b');
+    });
+    (0, vitest_1.it)('escapes angle brackets', () => {
+        (0, vitest_1.expect)((0, format_js_1.escapeHtml)('<div>')).toBe('&lt;div&gt;');
+    });
+    (0, vitest_1.it)('escapes multiple characters', () => {
+        (0, vitest_1.expect)((0, format_js_1.escapeHtml)('<script>alert("xss")&</script>')).toBe('&lt;script&gt;alert("xss")&amp;&lt;/script&gt;');
+    });
+    (0, vitest_1.it)('leaves safe strings unchanged', () => {
+        (0, vitest_1.expect)((0, format_js_1.escapeHtml)('hello world')).toBe('hello world');
+    });
+});

package/dist/telegram/poller.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Delta API poller — push confidence changes to Telegram
+ */
+import type { Bot } from 'grammy';
+import { SFClient } from '../client.js';
+export declare function startPoller(bot: Bot, chatId: number, client: SFClient, thesisId: string): NodeJS.Timeout;

package/dist/telegram/poller.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Delta API poller — push confidence changes to Telegram
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startPoller = startPoller;
+const format_js_1 = require("./format.js");
+function startPoller(bot, chatId, client, thesisId) {
+    let lastCheck = new Date().toISOString();
+    return setInterval(async () => {
+        try {
+            const changes = await client.getChanges(thesisId, lastCheck);
+            lastCheck = new Date().toISOString();
+            if (!changes || !changes.changed)
+                return;
+            const delta = changes.confidenceDelta ?? changes.delta ?? 0;
+            if (Math.abs(delta) < 0.02)
+                return;
+            const conf = typeof changes.confidence === 'number' ? Math.round(changes.confidence * 100) : '?';
+            const arrow = delta > 0 ? '📈' : '📉';
+            const sign = delta > 0 ? '+' : '';
+            const summary = changes.summary || changes.latestSummary || '';
+            let text = `${arrow} <b>Confidence ${sign}${Math.round(delta * 100)}% → ${conf}%</b>\n`;
+            if (summary)
+                text += `${(0, format_js_1.escapeHtml)(summary.slice(0, 200))}`;
+            await bot.api.sendMessage(chatId, text, { parse_mode: 'HTML' });
+        }
+        catch {
+            // Silent — polling errors should not crash the bot
+        }
+    }, 60_000); // every 60 seconds
+}

package/dist/topics.test.d.ts

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

package/dist/topics.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const topics_js_1 = require("./topics.js");
+(0, vitest_1.describe)('tickerToTopic', () => {
+    (0, vitest_1.it)('matches oil tickers (longest prefix first)', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXWTIMAX-26DEC31-T135')).toBe('OIL');
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXWTID-something')).toBe('OIL');
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXWTIW-2026')).toBe('OIL');
+    });
+    (0, vitest_1.it)('matches recession', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXRECSSNBER-26')).toBe('RECESSION');
+    });
+    (0, vitest_1.it)('matches fed', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXFEDDECISION-2026')).toBe('FED');
+    });
+    (0, vitest_1.it)('matches cpi', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXCPI-26MAY-T0.4')).toBe('CPI');
+    });
+    (0, vitest_1.it)('matches gas', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXAAAGASM-26MAR31-4.40')).toBe('GAS');
+    });
+    (0, vitest_1.it)('matches sp500', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('KXINXY-26DEC31H1600-T4000')).toBe('SP500');
+    });
+    (0, vitest_1.it)('returns OTHER for unknown tickers', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('UNKNOWN-TICKER')).toBe('OTHER');
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('RANDOMSERIES-123')).toBe('OTHER');
+    });
+    (0, vitest_1.it)('is case-insensitive', () => {
+        (0, vitest_1.expect)((0, topics_js_1.tickerToTopic)('kxwtimax-lower')).toBe('OIL');
+    });
+});
+(0, vitest_1.describe)('TOPIC_SERIES', () => {
+    (0, vitest_1.it)('has expected topics', () => {
+        (0, vitest_1.expect)(Object.keys(topics_js_1.TOPIC_SERIES)).toEqual(vitest_1.expect.arrayContaining(['oil', 'recession', 'fed', 'cpi', 'gas', 'sp500']));
+    });
+    (0, vitest_1.it)('each topic has at least one series', () => {
+        for (const [, series] of Object.entries(topics_js_1.TOPIC_SERIES)) {
+            (0, vitest_1.expect)(series.length).toBeGreaterThan(0);
+        }
+    });
+});
+(0, vitest_1.describe)('RISK_CATEGORIES', () => {
+    (0, vitest_1.it)('maps KXWTIMAX to Oil', () => {
+        (0, vitest_1.expect)(topics_js_1.RISK_CATEGORIES['KXWTIMAX']).toBe('Oil');
+    });
+    (0, vitest_1.it)('maps KXRECSSNBER to Recession', () => {
+        (0, vitest_1.expect)(topics_js_1.RISK_CATEGORIES['KXRECSSNBER']).toBe('Recession');
+    });
+    (0, vitest_1.it)('maps KXFEDDECISION to Fed Rate', () => {
+        (0, vitest_1.expect)(topics_js_1.RISK_CATEGORIES['KXFEDDECISION']).toBe('Fed Rate');
+    });
+});

package/dist/tui/border.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Border drawing — thin box-drawing characters
+ */
+import type { ScreenBuffer } from './screen.js';
+import type { Region } from './layout.js';
+export declare const rgb: (r: number, g: number, b: number) => string;
+export declare const bgRgb: (r: number, g: number, b: number) => string;
+export declare const CLR: {
+    border: string;
+    borderDim: string;
+    title: string;
+    text: string;
+    dim: string;
+    veryDim: string;
+    emerald: string;
+    green: string;
+    red: string;
+    yellow: string;
+    white: string;
+    bg: string;
+    bgPanel: string;
+};
+/** Draw a bordered box with title */
+export declare function drawBorder(screen: ScreenBuffer, region: Region, title?: string): void;
+/** Draw a horizontal divider across a region at a relative row */
+export declare function drawHDivider(screen: ScreenBuffer, region: Region, relRow: number): void;
+/** Pad/truncate string to exact width */
+export declare function fit(s: string, width: number, align?: 'left' | 'right'): string;
+/** Build sparkline from values */
+export declare function sparkline(values: number[], colorFn?: (v: number) => string): Array<{
+    text: string;
+    fg?: string;
+}>;

package/dist/tui/border.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Border drawing — thin box-drawing characters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLR = exports.bgRgb = exports.rgb = void 0;
+exports.drawBorder = drawBorder;
+exports.drawHDivider = drawHDivider;
+exports.fit = fit;
+exports.sparkline = sparkline;
+// 24-bit RGB ANSI helpers
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+exports.rgb = rgb;
+const bgRgb = (r, g, b) => `\x1b[48;2;${r};${g};${b}m`;
+exports.bgRgb = bgRgb;
+// Color palette (matching landing page: emerald on near-black)
+exports.CLR = {
+    border: (0, exports.rgb)(63, 63, 70), // zinc-700
+    borderDim: (0, exports.rgb)(39, 39, 42), // zinc-800
+    title: (0, exports.rgb)(161, 161, 170), // zinc-400
+    text: (0, exports.rgb)(212, 212, 216), // zinc-300
+    dim: (0, exports.rgb)(113, 113, 122), // zinc-500
+    veryDim: (0, exports.rgb)(63, 63, 70), // zinc-700
+    emerald: (0, exports.rgb)(16, 185, 129), // emerald-500
+    green: (0, exports.rgb)(52, 211, 153), // emerald-400
+    red: (0, exports.rgb)(239, 68, 68), // red-500
+    yellow: (0, exports.rgb)(250, 204, 21), // yellow-400
+    white: (0, exports.rgb)(244, 244, 245), // zinc-100
+    bg: (0, exports.bgRgb)(10, 10, 10), // #0a0a0a
+    bgPanel: (0, exports.bgRgb)(13, 13, 13), // #0d0d0d
+};
+/** Draw a bordered box with title */
+function drawBorder(screen, region, title) {
+    const { row, col, width, height } = region;
+    if (width < 3 || height < 3)
+        return;
+    const fg = exports.CLR.borderDim;
+    // Top
+    screen.write(row, col, '┌', fg);
+    for (let c = col + 1; c < col + width - 1; c++)
+        screen.write(row, c, '─', fg);
+    screen.write(row, col + width - 1, '┐', fg);
+    // Title
+    if (title) {
+        screen.write(row, col + 2, ` ${title} `, exports.CLR.title);
+    }
+    // Sides
+    for (let r = row + 1; r < row + height - 1; r++) {
+        screen.write(r, col, '│', fg);
+        screen.write(r, col + width - 1, '│', fg);
+    }
+    // Bottom
+    screen.write(row + height - 1, col, '└', fg);
+    for (let c = col + 1; c < col + width - 1; c++)
+        screen.write(row + height - 1, c, '─', fg);
+    screen.write(row + height - 1, col + width - 1, '┘', fg);
+}
+/** Draw a horizontal divider across a region at a relative row */
+function drawHDivider(screen, region, relRow) {
+    const r = region.row + relRow;
+    const fg = exports.CLR.borderDim;
+    screen.write(r, region.col, '├', fg);
+    for (let c = region.col + 1; c < region.col + region.width - 1; c++)
+        screen.write(r, c, '─', fg);
+    screen.write(r, region.col + region.width - 1, '┤', fg);
+}
+/** Pad/truncate string to exact width */
+function fit(s, width, align = 'left') {
+    if (s.length > width)
+        return s.slice(0, width - 1) + '…';
+    if (align === 'right')
+        return s.padStart(width);
+    return s.padEnd(width);
+}
+/** Build sparkline from values */
+function sparkline(values, colorFn) {
+    if (values.length === 0)
+        return [];
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+    const blocks = '▁▂▃▄▅▆▇█';
+    return values.map(v => {
+        const idx = Math.round(((v - min) / range) * 7);
+        return { text: blocks[idx], fg: colorFn ? colorFn(v) : exports.CLR.dim };
+    });
+}

package/dist/tui/chart.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ASCII area chart using block characters
+ *
+ * Uses ▁▂▃▄▅▆▇█ to draw a filled area chart that fills the width.
+ * Much cleaner than box-drawing line charts for small datasets.
+ */
+import type { ScreenBuffer } from './screen.js';
+/**
+ * Draw an area chart at the given position.
+ *
+ * @param screen  - ScreenBuffer to write to
+ * @param row     - Top-left row of chart area
+ * @param col     - Left column (after Y-axis labels)
+ * @param width   - Total width including Y-axis labels
+ * @param height  - Total height including X-axis row
+ * @param values  - Data points (raw numbers)
+ * @param labels  - Optional X-axis labels
+ */
+export declare function drawChart(screen: ScreenBuffer, row: number, col: number, width: number, height: number, values: number[], labels?: string[]): void;

package/dist/tui/chart.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * ASCII area chart using block characters
+ *
+ * Uses ▁▂▃▄▅▆▇█ to draw a filled area chart that fills the width.
+ * Much cleaner than box-drawing line charts for small datasets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawChart = drawChart;
+const border_js_1 = require("./border.js");
+/**
+ * Draw an area chart at the given position.
+ *
+ * @param screen  - ScreenBuffer to write to
+ * @param row     - Top-left row of chart area
+ * @param col     - Left column (after Y-axis labels)
+ * @param width   - Total width including Y-axis labels
+ * @param height  - Total height including X-axis row
+ * @param values  - Data points (raw numbers)
+ * @param labels  - Optional X-axis labels
+ */
+function drawChart(screen, row, col, width, height, values, labels) {
+    if (values.length === 0 || width < 10 || height < 4)
+        return;
+    const yLabelWidth = 8;
+    const chartWidth = width - yLabelWidth - 1;
+    const chartHeight = height - 2; // reserve bottom for x-axis + labels
+    if (chartWidth < 4 || chartHeight < 2)
+        return;
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+    // Interpolate values to fill chart width
+    const interpolated = [];
+    for (let c = 0; c < chartWidth; c++) {
+        const t = (c / (chartWidth - 1)) * (values.length - 1);
+        const lo = Math.floor(t);
+        const hi = Math.min(lo + 1, values.length - 1);
+        const frac = t - lo;
+        interpolated.push(values[lo] * (1 - frac) + values[hi] * frac);
+    }
+    // Y-axis: show 3 labels (top, zero if in range, bottom)
+    const chartCol = col + yLabelWidth + 1;
+    const yLabels = [
+        { row: 0, value: max },
+        { row: chartHeight - 1, value: min },
+    ];
+    // Add zero line if range crosses zero
+    let zeroChartRow = -1;
+    if (min < 0 && max > 0) {
+        zeroChartRow = Math.round((max / range) * (chartHeight - 1));
+        if (zeroChartRow > 0 && zeroChartRow < chartHeight - 1) {
+            yLabels.push({ row: zeroChartRow, value: 0 });
+        }
+    }
+    // Draw Y-axis
+    for (let r = 0; r < chartHeight; r++) {
+        screen.write(row + r, col + yLabelWidth, '│', border_js_1.CLR.borderDim);
+    }
+    for (const yl of yLabels) {
+        const fmt = Math.abs(yl.value) >= 100
+            ? `$${(yl.value >= 0 ? '+' : '') + yl.value.toFixed(0)}`
+            : `$${(yl.value >= 0 ? '+' : '') + yl.value.toFixed(1)}`;
+        screen.write(row + yl.row, col, fmt.padStart(yLabelWidth), border_js_1.CLR.dim);
+    }
+    // Zero line (dashed)
+    if (zeroChartRow >= 0 && zeroChartRow < chartHeight) {
+        for (let c = 0; c < chartWidth; c++) {
+            screen.write(row + zeroChartRow, chartCol + c, '╌', border_js_1.CLR.veryDim);
+        }
+    }
+    // Draw area chart using block characters
+    // Each column: compute how high the bar should go
+    const blocks = ' ▁▂▃▄▅▆▇█';
+    for (let c = 0; c < chartWidth; c++) {
+        const val = interpolated[c];
+        // Normalize to 0..1 (0=min, 1=max)
+        const norm = (val - min) / range;
+        // Height in sub-rows (chartHeight * 8 granularity levels)
+        const barHeight = norm * chartHeight * 8;
+        const color = val >= 0 ? border_js_1.CLR.green : border_js_1.CLR.red;
+        // Fill from bottom up
+        for (let r = chartHeight - 1; r >= 0; r--) {
+            const rowFromBottom = chartHeight - 1 - r;
+            const fillLevel = barHeight - rowFromBottom * 8;
+            if (fillLevel >= 8) {
+                // Full block
+                screen.write(row + r, chartCol + c, '█', color);
+            }
+            else if (fillLevel > 0) {
+                // Partial block
+                const idx = Math.round(Math.max(1, Math.min(fillLevel, 8)));
+                screen.write(row + r, chartCol + c, blocks[idx], color);
+            }
+            // else: empty (space), already default
+        }
+    }
+    // X-axis
+    const xRow = row + chartHeight;
+    screen.write(xRow, col + yLabelWidth, '└', border_js_1.CLR.borderDim);
+    for (let c = 0; c < chartWidth; c++) {
+        screen.write(xRow, chartCol + c, '─', border_js_1.CLR.borderDim);
+    }
+    // X-axis labels
+    if (labels && labels.length > 0) {
+        const labelRow = row + chartHeight + 1;
+        const numLabels = Math.min(labels.length, 6);
+        for (let i = 0; i < numLabels; i++) {
+            const srcIdx = Math.round(i * (labels.length - 1) / Math.max(numLabels - 1, 1));
+            const xPos = chartCol + Math.round(srcIdx * (chartWidth - 1) / Math.max(labels.length - 1, 1));
+            const label = labels[srcIdx] || '';
+            if (xPos >= chartCol && xPos + label.length < col + width) {
+                screen.write(labelRow, xPos, label.slice(0, 5), border_js_1.CLR.dim);
+            }
+        }
+    }
+}

package/dist/tui/dashboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TUI Dashboard Engine — main loop
+ *
+ * Manages the render loop, data loading, keypress handling, and mode transitions.
+ * This is NOT the commander entry point — see commands/dashboard.ts for that.
+ */
+import { type DashboardState } from './state.js';
+export declare function loadAllData(state: DashboardState): Promise<void>;
+export declare function startDashboard(): Promise<void>;