@spfunctions/cli 0.1.0

package/README.md

@@ -0,0 +1,100 @@
+# SimpleFunctions CLI (`sf`)
+
+Prediction market thesis agent CLI. Pure HTTP client — no project dependencies.
+
+## Install
+
+```bash
+npm install -g simplefunctions
+```
+
+## Configuration
+
+```bash
+export SF_API_KEY=sf_live_xxx           # required
+export SF_API_URL=https://simplefunctions.com  # optional, defaults to production
+```
+
+Or pass inline:
+```bash
+sf --api-key sf_live_xxx list
+```
+
+## Commands
+
+### `sf list`
+List all theses.
+```
+ID          Status  Conf    Updated         Title
+f582bf76    active   82%    Mar 12 11:13    Trump cannot exit the Iran war...
+```
+
+### `sf get <id>`
+Full thesis details: causal tree, edge analysis, positions, last evaluation.
+```bash
+sf get f582bf76
+sf get f582bf76 --json
+```
+
+### `sf context <id>`
+**Primary command for agents.** Returns a compact context snapshot: thesis, confidence, causal tree nodes, top edges, positions, last evaluation summary.
+```bash
+sf context f582bf76
+sf context f582bf76 --json   # machine-readable for agent parsing
+```
+
+### `sf create "thesis text"`
+Create a new thesis. Sync by default (waits for formation agent to complete).
+```bash
+sf create "Trump cannot exit the Iran war gracefully before 2027"
+sf create "..." --async   # return immediately
+```
+
+### `sf signal <id> "content"`
+Inject a signal into the thesis queue. Queued for next monitor cycle.
+```bash
+sf signal f582bf76 "Oil closes at $95 today"
+sf signal f582bf76 "Iran closes Strait of Hormuz" --type news
+sf signal f582bf76 "My read: escalation likely" --type user_note
+```
+Signal types: `news` | `user_note` | `external` (default: `user_note`)
+
+### `sf evaluate <id>`
+Trigger a deep evaluation using the heavy model (Claude Opus).
+```bash
+sf evaluate f582bf76
+```
+
+### `sf scan "keywords"`
+Explore Kalshi markets directly (no auth required).
+```bash
+sf scan "oil recession iran"
+sf scan --series KXWTIMAX
+sf scan --market KXWTIMAX-26DEC31-T140
+sf scan "oil" --json
+```
+
+## For AI Agents (OpenClaw etc.)
+
+After `npm install -g simplefunctions` and setting `SF_API_KEY`:
+
+```
+You can use the sf CLI to interact with SimpleFunctions:
+- sf context <id> --json    Get current thesis state (JSON)
+- sf signal <id> "content"  Inject an observation note
+- sf list                   List all theses
+- sf scan "keywords"        Explore Kalshi markets
+```
+
+Agents should call `sf context <id> --json` periodically to get the latest state, then decide whether to inject signals or alert the user.
+
+## Local Development
+
+```bash
+cd cli
+npm install
+npm run dev -- list          # run without building
+npm run build                # compile to dist/
+npm link                     # install as global 'sf' command
+sf list
+```

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+/**
+ * SimpleFunctions HTTP Client
+ *
+ * Pure fetch-based client. Zero project dependencies.
+ * Talks to the SF API (authenticated) and Kalshi public API (no auth).
+ */
+export declare class SFClient {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey?: string, baseUrl?: string);
+    private request;
+    listTheses(): Promise<{
+        theses: any[];
+    }>;
+    getThesis(id: string): Promise<any>;
+    getContext(id: string): Promise<any>;
+    createThesis(rawThesis: string, sync?: boolean): Promise<any>;
+    injectSignal(id: string, type: string, content: string, source?: string): Promise<any>;
+    evaluate(id: string): Promise<any>;
+    updateThesis(id: string, data: Record<string, unknown>): Promise<any>;
+}
+export declare function kalshiFetchAllSeries(): Promise<any[]>;
+export declare function kalshiFetchEvents(seriesTicker: string): Promise<any[]>;
+export declare function kalshiFetchMarket(ticker: string): Promise<any>;
+export declare function kalshiFetchMarketsBySeries(seriesTicker: string): Promise<any[]>;
+export declare function kalshiFetchMarketsByEvent(eventTicker: string): Promise<any[]>;

package/dist/client.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * SimpleFunctions HTTP Client
+ *
+ * Pure fetch-based client. Zero project dependencies.
+ * Talks to the SF API (authenticated) and Kalshi public API (no auth).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFClient = void 0;
+exports.kalshiFetchAllSeries = kalshiFetchAllSeries;
+exports.kalshiFetchEvents = kalshiFetchEvents;
+exports.kalshiFetchMarket = kalshiFetchMarket;
+exports.kalshiFetchMarketsBySeries = kalshiFetchMarketsBySeries;
+exports.kalshiFetchMarketsByEvent = kalshiFetchMarketsByEvent;
+const DEFAULT_API_URL = 'https://simplefunctions.com';
+const KALSHI_BASE = 'https://api.elections.kalshi.com/trade-api/v2';
+// ===== SF API Client =====
+class SFClient {
+    apiKey;
+    baseUrl;
+    constructor(apiKey, baseUrl) {
+        this.apiKey = apiKey || process.env.SF_API_KEY || '';
+        this.baseUrl = (baseUrl || process.env.SF_API_URL || DEFAULT_API_URL).replace(/\/$/, '');
+        if (!this.apiKey) {
+            throw new Error('API key required. Set SF_API_KEY or use --api-key');
+        }
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text}`);
+        }
+        return res.json();
+    }
+    // ── Thesis operations ──
+    async listTheses() {
+        return this.request('GET', '/api/thesis');
+    }
+    // GET /api/thesis/:id returns { ...thesisRow, positions: [] } — flat, NOT { thesis, positions }
+    async getThesis(id) {
+        return this.request('GET', `/api/thesis/${id}`);
+    }
+    async getContext(id) {
+        return this.request('GET', `/api/thesis/${id}/context`);
+    }
+    async createThesis(rawThesis, sync = true) {
+        return this.request('POST', `/api/thesis/create?sync=${sync}`, { rawThesis });
+    }
+    async injectSignal(id, type, content, source = 'cli') {
+        return this.request('POST', `/api/thesis/${id}/signal`, { type, content, source });
+    }
+    async evaluate(id) {
+        return this.request('POST', `/api/thesis/${id}/evaluate`);
+    }
+    async updateThesis(id, data) {
+        return this.request('PATCH', `/api/thesis/${id}`, data);
+    }
+}
+exports.SFClient = SFClient;
+// ===== Kalshi Public API (no auth) =====
+async function kalshiGet(path, params) {
+    const url = new URL(`${KALSHI_BASE}${path}`);
+    if (params) {
+        for (const [k, v] of Object.entries(params)) {
+            if (v !== undefined && v !== '')
+                url.searchParams.set(k, v);
+        }
+    }
+    const res = await fetch(url.toString());
+    if (!res.ok) {
+        throw new Error(`Kalshi API ${res.status}: ${await res.text()}`);
+    }
+    return res.json();
+}
+async function kalshiFetchAllSeries() {
+    const data = await kalshiGet('/series', { include_volume: 'true' });
+    return data.series || [];
+}
+async function kalshiFetchEvents(seriesTicker) {
+    const data = await kalshiGet('/events', {
+        series_ticker: seriesTicker,
+        status: 'open',
+        with_nested_markets: 'true',
+        limit: '200',
+    });
+    return data.events || [];
+}
+async function kalshiFetchMarket(ticker) {
+    const data = await kalshiGet(`/markets/${ticker}`);
+    return data.market || data;
+}
+async function kalshiFetchMarketsBySeries(seriesTicker) {
+    const data = await kalshiGet('/markets', {
+        series_ticker: seriesTicker,
+        status: 'open',
+        limit: '200',
+    });
+    return data.markets || [];
+}
+async function kalshiFetchMarketsByEvent(eventTicker) {
+    const data = await kalshiGet('/markets', {
+        event_ticker: eventTicker,
+        status: 'open',
+        limit: '1000',
+    });
+    return data.markets || [];
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,5 @@
+export declare function contextCommand(id: string, opts: {
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/context.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextCommand = contextCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function contextCommand(id, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const ctx = await client.getContext(id);
+    if (opts.json) {
+        console.log(JSON.stringify(ctx, null, 2));
+        return;
+    }
+    // Context API shape:
+    // { thesisId, thesis, title, status, confidence (number|null),
+    //   causalTree: { nodes: FlatNode[] }, edges: Edge[], edgeMeta,
+    //   lastEvaluation: { summary, confidenceDelta, ... }, updatedAt, ... }
+    // Thesis header
+    console.log(`\n${utils_js_1.c.bold}Thesis:${utils_js_1.c.reset} ${ctx.thesis || ctx.rawThesis || '(unknown)'}`);
+    const confStr = ctx.confidence !== null && ctx.confidence !== undefined ? (0, utils_js_1.pct)(ctx.confidence) : '-';
+    const confDelta = ctx.lastEvaluation?.confidenceDelta;
+    const deltaStr = confDelta ? ` (${(0, utils_js_1.delta)(confDelta)} since last eval)` : '';
+    console.log(`${utils_js_1.c.bold}Confidence:${utils_js_1.c.reset} ${confStr}${deltaStr}`);
+    console.log(`${utils_js_1.c.bold}Status:${utils_js_1.c.reset} ${ctx.status}`);
+    console.log(`${utils_js_1.c.bold}Last Updated:${utils_js_1.c.reset} ${(0, utils_js_1.shortDate)(ctx.updatedAt)}`);
+    // Causal tree nodes (flat array from API)
+    const nodes = ctx.causalTree?.nodes;
+    if (nodes && nodes.length > 0) {
+        (0, utils_js_1.header)('Causal Tree');
+        for (const node of nodes) {
+            const indent = '  '.repeat((node.depth || 0) + 1);
+            const prob = node.probability !== undefined ? (0, utils_js_1.pct)(node.probability) : '-';
+            const label = node.label || node.id;
+            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)}`);
+        }
+    }
+    // Top edges (sorted by absolute edge size)
+    const edges = ctx.edges;
+    if (edges && edges.length > 0) {
+        (0, utils_js_1.header)('Top Edges (by edge size)');
+        const sorted = [...edges].sort((a, b) => Math.abs(b.edge ?? b.edgeSize ?? 0) - Math.abs(a.edge ?? a.edgeSize ?? 0));
+        for (const edge of sorted.slice(0, 10)) {
+            const edgeSize = edge.edge ?? edge.edgeSize ?? 0;
+            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 || '?';
+            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}`);
+        }
+    }
+    // Last evaluation summary
+    if (ctx.lastEvaluation?.summary) {
+        (0, utils_js_1.header)('Last Evaluation');
+        console.log(`  ${utils_js_1.c.dim}${(0, utils_js_1.shortDate)(ctx.lastEvaluation.evaluatedAt)} | model: ${ctx.lastEvaluation.model || ''}${utils_js_1.c.reset}`);
+        console.log(`  ${ctx.lastEvaluation.summary}`);
+        if (ctx.lastEvaluation.positionRecommendations?.length > 0) {
+            console.log(`\n  ${utils_js_1.c.bold}Position Recommendations:${utils_js_1.c.reset}`);
+            for (const pr of ctx.lastEvaluation.positionRecommendations) {
+                const recColor = pr.recommendation === 'hold' ? utils_js_1.c.dim : pr.recommendation === 'close' ? utils_js_1.c.red : utils_js_1.c.yellow;
+                console.log(`    [${(pr.positionId || '').slice(0, 8)}] ${recColor}${pr.recommendation}${utils_js_1.c.reset} — ${pr.reason}`);
+            }
+        }
+    }
+    // Edge meta (last rescan time)
+    if (ctx.edgeMeta?.lastRescanAt) {
+        console.log(`\n${utils_js_1.c.dim}Last rescan: ${(0, utils_js_1.shortDate)(ctx.edgeMeta.lastRescanAt)}${utils_js_1.c.reset}`);
+    }
+    console.log('');
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,5 @@
+export declare function createCommand(thesis: string, opts: {
+    async?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/create.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommand = createCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function createCommand(thesis, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const sync = !opts.async;
+    if (sync) {
+        console.log(`${utils_js_1.c.dim}Creating thesis (sync mode — waiting for formation)...${utils_js_1.c.reset}`);
+    }
+    else {
+        console.log(`${utils_js_1.c.dim}Creating thesis (async mode)...${utils_js_1.c.reset}`);
+    }
+    const result = await client.createThesis(thesis, sync);
+    console.log(`\n${utils_js_1.c.green}✓${utils_js_1.c.reset} Thesis created`);
+    console.log(`  ${utils_js_1.c.bold}ID:${utils_js_1.c.reset}     ${result.thesis?.id || result.id}`);
+    console.log(`  ${utils_js_1.c.bold}Status:${utils_js_1.c.reset} ${result.thesis?.status || result.status}`);
+    if (result.thesis?.confidence) {
+        console.log(`  ${utils_js_1.c.bold}Confidence:${utils_js_1.c.reset} ${Math.round(parseFloat(result.thesis.confidence) * 100)}%`);
+    }
+    if (result.thesis?.causalTree?.nodes) {
+        console.log(`  ${utils_js_1.c.bold}Nodes:${utils_js_1.c.reset}  ${result.thesis.causalTree.nodes.length}`);
+    }
+    if (result.thesis?.edgeAnalysis?.edges) {
+        console.log(`  ${utils_js_1.c.bold}Edges:${utils_js_1.c.reset}  ${result.thesis.edgeAnalysis.edges.length}`);
+    }
+    const id = result.thesis?.id || result.id;
+    console.log(`\n${utils_js_1.c.dim}View: sf get ${(0, utils_js_1.shortId)(id)}${utils_js_1.c.reset}`);
+    console.log(`${utils_js_1.c.dim}Context: sf context ${(0, utils_js_1.shortId)(id)}${utils_js_1.c.reset}`);
+}

package/dist/commands/evaluate.d.ts

@@ -0,0 +1,4 @@
+export declare function evaluateCommand(id: string, opts: {
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/evaluate.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCommand = evaluateCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function evaluateCommand(id, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    console.log(`${utils_js_1.c.dim}Triggering deep evaluation (heavy model)...${utils_js_1.c.reset}`);
+    const result = await client.evaluate(id);
+    console.log(`\n${utils_js_1.c.green}✓${utils_js_1.c.reset} Evaluation complete`);
+    if (result.evaluation) {
+        const ev = result.evaluation;
+        if (ev.confidenceDelta !== undefined) {
+            const d = ev.confidenceDelta;
+            const dColor = d > 0 ? utils_js_1.c.green : d < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+            console.log(`  ${utils_js_1.c.bold}Confidence:${utils_js_1.c.reset} ${(0, utils_js_1.pct)(ev.previousConfidence)} → ${(0, utils_js_1.pct)(ev.newConfidence)} ${dColor}(${(0, utils_js_1.delta)(d)})${utils_js_1.c.reset}`);
+        }
+        if (ev.summary) {
+            console.log(`\n  ${ev.summary}`);
+        }
+        if (ev.positionUpdates && ev.positionUpdates.length > 0) {
+            console.log(`\n  ${utils_js_1.c.bold}Position Recommendations:${utils_js_1.c.reset}`);
+            for (const pu of ev.positionUpdates) {
+                const recColor = pu.recommendation === 'hold' ? utils_js_1.c.dim : pu.recommendation === 'close' ? utils_js_1.c.red : utils_js_1.c.yellow;
+                console.log(`    [${pu.positionId.slice(0, 8)}] ${recColor}${pu.recommendation}${utils_js_1.c.reset} — ${pu.reason}`);
+            }
+        }
+    }
+    console.log('');
+}

package/dist/commands/get.d.ts

@@ -0,0 +1,5 @@
+export declare function getCommand(id: string, opts: {
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/get.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommand = getCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function getCommand(id, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    // GET /api/thesis/:id returns { ...thesisRow, positions: [] }
+    // Fields are spread at top-level (NOT nested under .thesis)
+    const data = await client.getThesis(id);
+    if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // data is the flat thesis row + positions array
+    const t = data; // thesis fields are at top level
+    const positions = data.positions || [];
+    (0, utils_js_1.header)(`Thesis: ${(t.id || id).slice(0, 8)}`);
+    (0, utils_js_1.hr)();
+    console.log(`${utils_js_1.c.bold}Status:${utils_js_1.c.reset}     ${t.status || '-'}`);
+    const conf = t.confidence ? (0, utils_js_1.pct)(parseFloat(t.confidence)) : '-';
+    console.log(`${utils_js_1.c.bold}Confidence:${utils_js_1.c.reset} ${conf}`);
+    const createdAt = t.createdAt instanceof Date ? t.createdAt.toISOString() : t.createdAt;
+    const updatedAt = t.updatedAt instanceof Date ? t.updatedAt.toISOString() : t.updatedAt;
+    console.log(`${utils_js_1.c.bold}Created:${utils_js_1.c.reset}    ${(0, utils_js_1.shortDate)(createdAt)}`);
+    console.log(`${utils_js_1.c.bold}Updated:${utils_js_1.c.reset}    ${(0, utils_js_1.shortDate)(updatedAt)}`);
+    if (t.title) {
+        console.log(`${utils_js_1.c.bold}Title:${utils_js_1.c.reset}      ${t.title}`);
+    }
+    console.log(`${utils_js_1.c.bold}Thesis:${utils_js_1.c.reset}     ${t.rawThesis || '-'}`);
+    if (t.webhookUrl) {
+        console.log(`${utils_js_1.c.bold}Webhook:${utils_js_1.c.reset}    ${t.webhookUrl}`);
+    }
+    // Causal tree
+    const causalTree = t.causalTree;
+    if (causalTree && causalTree.nodes) {
+        (0, utils_js_1.header)('Causal Tree');
+        printNodes(causalTree.nodes, 0);
+    }
+    // Edge analysis
+    const edgeAnalysis = t.edgeAnalysis;
+    if (edgeAnalysis && edgeAnalysis.edges) {
+        (0, utils_js_1.header)('Edge Analysis');
+        console.log(`${utils_js_1.c.dim}Analyzed: ${(0, utils_js_1.shortDate)(edgeAnalysis.analyzedAt)}${utils_js_1.c.reset}`);
+        if (edgeAnalysis.lastRescanAt) {
+            console.log(`${utils_js_1.c.dim}Last rescan: ${(0, utils_js_1.shortDate)(edgeAnalysis.lastRescanAt)}${utils_js_1.c.reset}`);
+        }
+        for (const edge of edgeAnalysis.edges) {
+            const edgeSize = edge.edgeSize ?? 0;
+            const edgeColor = edgeSize > 10 ? utils_js_1.c.green : edgeSize > 0 ? utils_js_1.c.yellow : utils_js_1.c.red;
+            console.log(`  ${edge.marketTitle || edge.marketId}` +
+                `  ${utils_js_1.c.dim}${edge.venue}${utils_js_1.c.reset}` +
+                `  price: ${(edge.marketPrice ?? 0).toFixed(0)}¢` +
+                `  ${edgeColor}edge: ${edgeSize > 0 ? '+' : ''}${edgeSize.toFixed(1)}${utils_js_1.c.reset}`);
+        }
+    }
+    // Positions
+    if (positions.length > 0) {
+        (0, utils_js_1.header)('Positions');
+        for (const p of positions) {
+            if (!p)
+                continue;
+            const statusIcon = p.status === 'open' ? utils_js_1.c.green + '●' : utils_js_1.c.dim + '○';
+            console.log(`  ${statusIcon}${utils_js_1.c.reset} [${(p.id || '?').slice(0, 8)}] "${p.marketTitle || '?'}" ` +
+                `${p.direction || '?'}@${p.entryPrice || '?'}→${p.currentPrice || p.entryPrice || '?'} ` +
+                `${utils_js_1.c.dim}(${p.venue || '?'})${utils_js_1.c.reset}`);
+        }
+    }
+    // Last evaluation
+    const lastEval = t.lastEvaluation;
+    if (lastEval) {
+        (0, utils_js_1.header)('Last Evaluation');
+        const evalAt = lastEval.evaluatedAt instanceof Date ? lastEval.evaluatedAt.toISOString() : lastEval.evaluatedAt;
+        console.log(`${utils_js_1.c.dim}${(0, utils_js_1.shortDate)(evalAt)} | model: ${lastEval.model || '-'}${utils_js_1.c.reset}`);
+        if (lastEval.confidenceDelta !== undefined) {
+            const d = lastEval.confidenceDelta;
+            const dColor = d > 0 ? utils_js_1.c.green : d < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+            console.log(`Confidence: ${(0, utils_js_1.pct)(lastEval.previousConfidence)} → ${(0, utils_js_1.pct)(lastEval.newConfidence)} ${dColor}(${(0, utils_js_1.delta)(d)})${utils_js_1.c.reset}`);
+        }
+        if (lastEval.summary) {
+            console.log(`\n${lastEval.summary}`);
+        }
+    }
+    console.log('');
+}
+function printNodes(nodes, depth) {
+    for (const node of nodes) {
+        if (!node)
+            continue;
+        const indent = '  '.repeat(depth + 1);
+        const prob = node.probability !== undefined ? (0, utils_js_1.pct)(node.probability) : '-';
+        const imp = node.importance !== undefined ? ` imp:${node.importance}` : '';
+        console.log(`${indent}${utils_js_1.c.cyan}${node.id}${utils_js_1.c.reset}  ${node.label}  ${utils_js_1.c.dim}(${prob}${imp})${utils_js_1.c.reset}`);
+        if (node.children && node.children.length > 0) {
+            printNodes(node.children, depth + 1);
+        }
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,4 @@
+export declare function listCommand(opts: {
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function listCommand(opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const { theses } = await client.listTheses();
+    if (theses.length === 0) {
+        console.log(`${utils_js_1.c.dim}No theses found.${utils_js_1.c.reset}`);
+        return;
+    }
+    console.log(`\n${utils_js_1.c.bold}` +
+        (0, utils_js_1.pad)('ID', 12) +
+        (0, utils_js_1.pad)('Status', 10) +
+        (0, utils_js_1.rpad)('Conf', 6) +
+        '  ' +
+        (0, utils_js_1.pad)('Updated', 14) +
+        '  Title' +
+        utils_js_1.c.reset);
+    (0, utils_js_1.hr)(90);
+    for (const t of theses) {
+        const statusColor = t.status === 'active' ? utils_js_1.c.green : t.status === 'forming' ? utils_js_1.c.yellow : utils_js_1.c.dim;
+        const conf = t.confidence ? (0, utils_js_1.pct)(parseFloat(t.confidence)) : '-';
+        console.log((0, utils_js_1.pad)((0, utils_js_1.shortId)(t.id), 12) +
+            statusColor + (0, utils_js_1.pad)(t.status, 10) + utils_js_1.c.reset +
+            (0, utils_js_1.rpad)(conf, 6) +
+            '  ' +
+            utils_js_1.c.dim + (0, utils_js_1.pad)((0, utils_js_1.shortDate)(t.updatedAt), 14) + utils_js_1.c.reset +
+            '  ' +
+            (0, utils_js_1.trunc)(t.title || t.rawThesis.slice(0, 60), 50));
+    }
+    console.log(`\n${utils_js_1.c.dim}${theses.length} thesis(es)${utils_js_1.c.reset}`);
+}

package/dist/commands/scan.d.ts

@@ -0,0 +1,9 @@
+interface ScanOpts {
+    series?: string;
+    market?: string;
+    json?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function scanCommand(query: string, opts: ScanOpts): Promise<void>;
+export {};

package/dist/commands/scan.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCommand = scanCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function scanCommand(query, opts) {
+    // Mode 1: --market TICKER — single market detail
+    if (opts.market) {
+        await showMarket(opts.market.toUpperCase(), opts.json);
+        return;
+    }
+    // Mode 2: --series TICKER — list events + markets for a series
+    if (opts.series) {
+        await showSeries(opts.series.toUpperCase(), opts.json);
+        return;
+    }
+    // Mode 3: keyword scan across all series
+    await keywordScan(query, opts.json);
+}
+async function showMarket(ticker, json) {
+    console.log(`${utils_js_1.c.dim}Fetching market ${ticker}...${utils_js_1.c.reset}`);
+    const m = await (0, client_js_1.kalshiFetchMarket)(ticker);
+    if (json) {
+        console.log(JSON.stringify(m, null, 2));
+        return;
+    }
+    (0, utils_js_1.header)(`${m.title || m.ticker}`);
+    if (m.subtitle)
+        console.log(`${utils_js_1.c.dim}${m.subtitle}${utils_js_1.c.reset}`);
+    console.log(`Event: ${m.event_ticker}  Status: ${m.status}`);
+    console.log('');
+    console.log(`Yes Ask: ${(0, utils_js_1.cents)(m.yes_ask_dollars)}  (size: ${m.yes_ask_size_fp || '-'})`);
+    console.log(`Yes Bid: ${(0, utils_js_1.cents)(m.yes_bid_dollars)}  (size: ${m.yes_bid_size_fp || '-'})`);
+    console.log(`No Ask:  ${(0, utils_js_1.cents)(m.no_ask_dollars)}`);
+    console.log(`No Bid:  ${(0, utils_js_1.cents)(m.no_bid_dollars)}`);
+    console.log(`Last:    ${(0, utils_js_1.cents)(m.last_price_dollars)}`);
+    console.log('');
+    console.log(`Volume:     ${(0, utils_js_1.vol)(m.volume_fp)}`);
+    console.log(`Vol 24h:    ${(0, utils_js_1.vol)(m.volume_24h_fp)}`);
+    console.log(`Open Int:   ${(0, utils_js_1.vol)(m.open_interest_fp)}`);
+    console.log(`Liquidity:  ${(0, utils_js_1.vol)(m.liquidity_dollars)}`);
+    console.log('');
+    console.log(`Open:    ${m.open_time}`);
+    console.log(`Close:   ${m.close_time}`);
+    if (m.rules_primary) {
+        console.log(`\nRules: ${m.rules_primary.slice(0, 300)}`);
+    }
+}
+async function showSeries(seriesTicker, json) {
+    console.log(`${utils_js_1.c.dim}Fetching events for series ${seriesTicker}...${utils_js_1.c.reset}`);
+    let events = await (0, client_js_1.kalshiFetchEvents)(seriesTicker);
+    if (events.length === 0) {
+        // Fallback: direct market lookup by series
+        const markets = await (0, client_js_1.kalshiFetchMarketsBySeries)(seriesTicker);
+        if (json) {
+            console.log(JSON.stringify(markets, null, 2));
+            return;
+        }
+        if (markets.length === 0) {
+            console.log(`${utils_js_1.c.dim}No open markets found for series ${seriesTicker}.${utils_js_1.c.reset}`);
+            return;
+        }
+        (0, utils_js_1.header)(`${seriesTicker} — ${markets.length} markets`);
+        printMarketsTable(markets);
+        return;
+    }
+    if (json) {
+        console.log(JSON.stringify(events, null, 2));
+        return;
+    }
+    for (const event of events) {
+        (0, utils_js_1.header)(`${event.title || event.event_ticker}`);
+        console.log(`${utils_js_1.c.dim}${event.event_ticker} | ${event.category || '-'} | strike: ${event.strike_date || '-'}${utils_js_1.c.reset}`);
+        const markets = event.markets && event.markets.length > 0
+            ? event.markets
+            : await (0, client_js_1.kalshiFetchMarketsByEvent)(event.event_ticker);
+        printMarketsTable(markets);
+    }
+}
+async function keywordScan(query, json) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    console.log(`${utils_js_1.c.dim}Scanning Kalshi for: "${query}"...${utils_js_1.c.reset}`);
+    const allSeries = await (0, client_js_1.kalshiFetchAllSeries)();
+    // Score each series
+    const thesisKeywords = [
+        'oil', 'wti', 'gas', 'recession', 'gdp', 'fed', 'inflation',
+        'unemployment', 'cpi', 'interest rate', 'congress', 'election',
+        'iran', 'hormuz', 'war', 'tariff', 'trade', 'rate',
+    ];
+    const matches = [];
+    for (const s of allSeries) {
+        const text = `${s.title} ${s.ticker} ${(s.tags || []).join(' ')} ${s.category}`.toLowerCase();
+        let score = 0;
+        for (const term of terms) {
+            if (text.includes(term))
+                score += 10;
+        }
+        for (const kw of thesisKeywords) {
+            if (text.includes(kw))
+                score += 5;
+        }
+        const v = parseFloat(s.volume_fp || '0');
+        if (v > 1_000_000)
+            score += 3;
+        else if (v > 100_000)
+            score += 1;
+        if (score > 0)
+            matches.push({ series: s, score });
+    }
+    matches.sort((a, b) => b.score - a.score);
+    const topSeries = matches.slice(0, 15);
+    console.log(`\n${utils_js_1.c.bold}Found ${matches.length} relevant series. Top ${topSeries.length}:${utils_js_1.c.reset}\n`);
+    for (const { series: s, score } of topSeries) {
+        console.log(`  ${utils_js_1.c.dim}[${score}]${utils_js_1.c.reset} ${(0, utils_js_1.pad)(s.ticker, 25)} ${s.title}`);
+    }
+    // Fetch live markets for top 10
+    console.log(`\n${utils_js_1.c.dim}Fetching live markets...${utils_js_1.c.reset}\n`);
+    const allMarkets = [];
+    for (const { series: s } of topSeries.slice(0, 10)) {
+        try {
+            const events = await (0, client_js_1.kalshiFetchEvents)(s.ticker);
+            for (const event of events) {
+                const markets = event.markets || [];
+                for (const m of markets) {
+                    if (m.status === 'open' || m.status === 'active') {
+                        allMarkets.push({
+                            seriesTicker: s.ticker,
+                            ticker: m.ticker,
+                            title: m.title || m.subtitle || '',
+                            yesAsk: parseFloat(m.yes_ask_dollars || '0'),
+                            lastPrice: parseFloat(m.last_price_dollars || '0'),
+                            volume24h: parseFloat(m.volume_24h_fp || '0'),
+                            liquidity: parseFloat(m.liquidity_dollars || '0'),
+                        });
+                    }
+                }
+            }
+            await new Promise(r => setTimeout(r, 150));
+        }
+        catch {
+            // skip failed series
+        }
+    }
+    allMarkets.sort((a, b) => b.liquidity - a.liquidity);
+    if (json) {
+        console.log(JSON.stringify(allMarkets, null, 2));
+        return;
+    }
+    (0, utils_js_1.header)(`${allMarkets.length} Live Markets`);
+    console.log(utils_js_1.c.bold +
+        (0, utils_js_1.pad)('Ticker', 35) +
+        (0, utils_js_1.rpad)('Yes', 6) +
+        (0, utils_js_1.rpad)('Last', 6) +
+        (0, utils_js_1.rpad)('Vol24h', 10) +
+        (0, utils_js_1.rpad)('Liq', 10) +
+        '  Title' +
+        utils_js_1.c.reset);
+    (0, utils_js_1.hr)(110);
+    for (const m of allMarkets.slice(0, 50)) {
+        console.log((0, utils_js_1.pad)(m.ticker, 35) +
+            (0, utils_js_1.rpad)(`${Math.round(m.yesAsk * 100)}¢`, 6) +
+            (0, utils_js_1.rpad)(`${Math.round(m.lastPrice * 100)}¢`, 6) +
+            (0, utils_js_1.rpad)((0, utils_js_1.vol)(m.volume24h), 10) +
+            (0, utils_js_1.rpad)((0, utils_js_1.vol)(m.liquidity), 10) +
+            `  ${m.title.slice(0, 55)}`);
+    }
+    console.log('');
+}
+function printMarketsTable(markets) {
+    if (markets.length === 0) {
+        console.log(`  ${utils_js_1.c.dim}(no markets)${utils_js_1.c.reset}`);
+        return;
+    }
+    markets.sort((a, b) => {
+        const pa = parseFloat(a.yes_ask_dollars || a.last_price_dollars || '0');
+        const pb = parseFloat(b.yes_ask_dollars || b.last_price_dollars || '0');
+        return pb - pa;
+    });
+    console.log('  ' + utils_js_1.c.bold +
+        (0, utils_js_1.pad)('Ticker', 35) +
+        (0, utils_js_1.rpad)('YesAsk', 8) +
+        (0, utils_js_1.rpad)('Last', 8) +
+        (0, utils_js_1.rpad)('Vol24h', 10) +
+        (0, utils_js_1.rpad)('Liq', 12) +
+        '  Title' +
+        utils_js_1.c.reset);
+    console.log('  ' + utils_js_1.c.dim + '─'.repeat(100) + utils_js_1.c.reset);
+    for (const m of markets) {
+        console.log('  ' +
+            (0, utils_js_1.pad)(m.ticker || '', 35) +
+            (0, utils_js_1.rpad)((0, utils_js_1.cents)(m.yes_ask_dollars), 8) +
+            (0, utils_js_1.rpad)((0, utils_js_1.cents)(m.last_price_dollars), 8) +
+            (0, utils_js_1.rpad)((0, utils_js_1.vol)(m.volume_24h_fp), 10) +
+            (0, utils_js_1.rpad)((0, utils_js_1.vol)(m.liquidity_dollars), 12) +
+            `  ${(m.title || m.subtitle || '').slice(0, 55)}`);
+    }
+    console.log('');
+}

package/dist/commands/signal.d.ts

@@ -0,0 +1,5 @@
+export declare function signalCommand(id: string, content: string, opts: {
+    type?: string;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/signal.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalCommand = signalCommand;
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function signalCommand(id, content, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const type = opts.type || 'user_note';
+    const result = await client.injectSignal(id, type, content, 'cli');
+    console.log(`${utils_js_1.c.green}✓${utils_js_1.c.reset} Signal injected`);
+    console.log(`  ${utils_js_1.c.bold}Type:${utils_js_1.c.reset}    ${type}`);
+    console.log(`  ${utils_js_1.c.bold}Source:${utils_js_1.c.reset}  cli`);
+    console.log(`  ${utils_js_1.c.bold}Content:${utils_js_1.c.reset} ${content}`);
+    if (result.signalId) {
+        console.log(`  ${utils_js_1.c.bold}ID:${utils_js_1.c.reset}      ${result.signalId}`);
+    }
+    console.log(`\n${utils_js_1.c.dim}Signal queued for next monitor cycle.${utils_js_1.c.reset}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * SimpleFunctions CLI — sf
+ *
+ * Prediction market thesis agent CLI.
+ * Zero heavy dependencies: commander + native fetch.
+ *
+ * Usage:
+ *   sf list
+ *   sf get <id>
+ *   sf context <id> [--json]
+ *   sf create "thesis text" [--async]
+ *   sf signal <id> "content" [--type news|user_note|external]
+ *   sf evaluate <id>
+ *   sf scan "keywords" [--series TICKER] [--market TICKER] [--json]
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * SimpleFunctions CLI — sf
+ *
+ * Prediction market thesis agent CLI.
+ * Zero heavy dependencies: commander + native fetch.
+ *
+ * Usage:
+ *   sf list
+ *   sf get <id>
+ *   sf context <id> [--json]
+ *   sf create "thesis text" [--async]
+ *   sf signal <id> "content" [--type news|user_note|external]
+ *   sf evaluate <id>
+ *   sf scan "keywords" [--series TICKER] [--market TICKER] [--json]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const list_js_1 = require("./commands/list.js");
+const get_js_1 = require("./commands/get.js");
+const context_js_1 = require("./commands/context.js");
+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 utils_js_1 = require("./utils.js");
+const program = new commander_1.Command();
+program
+    .name('sf')
+    .description('SimpleFunctions CLI — prediction market thesis agent')
+    .version('0.1.0')
+    .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)');
+// Helper to extract global opts from any command's opts chain
+function globalOpts(opts) {
+    // Commander merges parent opts into child opts when using .optsWithGlobals()
+    return {
+        apiKey: opts.apiKey || opts.parent?.apiKey,
+        apiUrl: opts.apiUrl || opts.parent?.apiUrl,
+    };
+}
+// ── sf list ──────────────────────────────────────────────────────────────────
+program
+    .command('list')
+    .description('List all theses')
+    .action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, list_js_1.listCommand)({ apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf get <id> ───────────────────────────────────────────────────────────────
+program
+    .command('get <id>')
+    .description('Get full thesis details')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, get_js_1.getCommand)(id, { json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf context <id> ───────────────────────────────────────────────────────────
+program
+    .command('context <id>')
+    .description('Get thesis context snapshot (primary command for agents)')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, context_js_1.contextCommand)(id, { json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf create <thesis> ────────────────────────────────────────────────────────
+program
+    .command('create <thesis>')
+    .description('Create a new thesis (sync by default — waits for formation)')
+    .option('--async', 'Async mode — return immediately without waiting')
+    .action(async (thesis, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, create_js_1.createCommand)(thesis, { async: opts.async, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf signal <id> <content> ──────────────────────────────────────────────────
+program
+    .command('signal <id> <content>')
+    .description('Inject a signal into the thesis queue')
+    .option('--type <type>', 'Signal type: news | user_note | external', 'user_note')
+    .action(async (id, content, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, signal_js_1.signalCommand)(id, content, { type: opts.type, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf evaluate <id> ──────────────────────────────────────────────────────────
+program
+    .command('evaluate <id>')
+    .description('Trigger a deep evaluation (heavy model, force-heavy mode)')
+    .action(async (id, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    await run(() => (0, evaluate_js_1.evaluateCommand)(id, { apiKey: g.apiKey, apiUrl: g.apiUrl }));
+});
+// ── sf scan [query] ───────────────────────────────────────────────────────────
+program
+    .command('scan [query]')
+    .description('Explore Kalshi markets (no auth required)')
+    .option('--series <ticker>', 'List events + markets for a series (e.g. KXWTIMAX)')
+    .option('--market <ticker>', 'Get single market detail (e.g. KXWTIMAX-26DEC31-T140)')
+    .option('--json', 'Output raw JSON')
+    .action(async (query, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const q = query || '';
+    if (!q && !opts.series && !opts.market) {
+        console.error('Usage: sf scan "keywords"  OR  sf scan --series TICKER  OR  sf scan --market TICKER');
+        process.exit(1);
+    }
+    await run(() => (0, scan_js_1.scanCommand)(q, {
+        series: opts.series,
+        market: opts.market,
+        json: opts.json,
+        apiKey: g.apiKey,
+        apiUrl: g.apiUrl,
+    }));
+});
+// ── Error wrapper ─────────────────────────────────────────────────────────────
+async function run(fn) {
+    try {
+        await fn();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, utils_js_1.die)(msg);
+    }
+}
+program.parse();

package/dist/utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CLI formatting utilities
+ *
+ * ANSI escape codes only — no chalk dependency.
+ */
+export declare const c: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+};
+/** Format a number as volume string: 1234567 → "1.2M", 12345 → "12K" */
+export declare function vol(n: number | string | null | undefined): string;
+/** Format a dollar amount as cents: 0.55 → "55¢" */
+export declare function cents(n: number | string | null | undefined): string;
+/** Format a probability as percentage: 0.82 → "82%" */
+export declare function pct(n: number | string | null | undefined): string;
+/** Format a confidence delta with arrow: +0.10 → "↑ +10%", -0.05 → "↓ -5%" */
+export declare function delta(n: number): string;
+/** Format ISO date string to short form: "2026-03-12T11:13:00Z" → "Mar 12 11:13" */
+export declare function shortDate(iso: string | null | undefined): string;
+/** Pad/truncate a string to exact width */
+export declare function pad(s: string, width: number): string;
+/** Right-align a string to exact width */
+export declare function rpad(s: string, width: number): string;
+/** Print a horizontal rule */
+export declare function hr(width?: number): void;
+/** Print an error and exit */
+export declare function die(msg: string): never;
+/** Print a section header */
+export declare function header(title: string): void;
+/** Truncate a string with ellipsis */
+export declare function trunc(s: string, maxLen: number): string;
+/** Short ID: first 8 chars of a UUID */
+export declare function shortId(id: string): string;

package/dist/utils.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * CLI formatting utilities
+ *
+ * ANSI escape codes only — no chalk dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c = void 0;
+exports.vol = vol;
+exports.cents = cents;
+exports.pct = pct;
+exports.delta = delta;
+exports.shortDate = shortDate;
+exports.pad = pad;
+exports.rpad = rpad;
+exports.hr = hr;
+exports.die = die;
+exports.header = header;
+exports.trunc = trunc;
+exports.shortId = shortId;
+// ===== ANSI Colors =====
+exports.c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
+// ===== Formatting helpers =====
+/** Format a number as volume string: 1234567 → "1.2M", 12345 → "12K" */
+function vol(n) {
+    if (n === null || n === undefined)
+        return '-';
+    const v = typeof n === 'string' ? parseFloat(n) : n;
+    if (isNaN(v))
+        return '-';
+    if (v >= 1_000_000)
+        return `${(v / 1_000_000).toFixed(1)}M`;
+    if (v >= 1_000)
+        return `${(v / 1_000).toFixed(0)}K`;
+    return v.toString();
+}
+/** Format a dollar amount as cents: 0.55 → "55¢" */
+function cents(n) {
+    if (n === null || n === undefined)
+        return '-';
+    const v = typeof n === 'string' ? parseFloat(n) : n;
+    if (isNaN(v))
+        return '-';
+    return `${Math.round(v * 100)}¢`;
+}
+/** Format a probability as percentage: 0.82 → "82%" */
+function pct(n) {
+    if (n === null || n === undefined)
+        return '-';
+    const v = typeof n === 'string' ? parseFloat(n) : n;
+    if (isNaN(v))
+        return '-';
+    return `${Math.round(v * 100)}%`;
+}
+/** Format a confidence delta with arrow: +0.10 → "↑ +10%", -0.05 → "↓ -5%" */
+function delta(n) {
+    const arrow = n > 0 ? '↑' : n < 0 ? '↓' : '→';
+    const sign = n > 0 ? '+' : '';
+    return `${arrow} ${sign}${Math.round(n * 100)}%`;
+}
+/** Format ISO date string to short form: "2026-03-12T11:13:00Z" → "Mar 12 11:13" */
+function shortDate(iso) {
+    if (!iso)
+        return '-';
+    try {
+        const d = new Date(iso);
+        const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+        const month = months[d.getMonth()];
+        const day = d.getDate();
+        const hours = d.getHours().toString().padStart(2, '0');
+        const mins = d.getMinutes().toString().padStart(2, '0');
+        return `${month} ${day} ${hours}:${mins}`;
+    }
+    catch {
+        return iso.slice(0, 16);
+    }
+}
+/** Pad/truncate a string to exact width */
+function pad(s, width) {
+    if (s.length >= width)
+        return s.slice(0, width);
+    return s + ' '.repeat(width - s.length);
+}
+/** Right-align a string to exact width */
+function rpad(s, width) {
+    if (s.length >= width)
+        return s.slice(0, width);
+    return ' '.repeat(width - s.length) + s;
+}
+/** Print a horizontal rule */
+function hr(width = 80) {
+    console.log(exports.c.dim + '─'.repeat(width) + exports.c.reset);
+}
+/** Print an error and exit */
+function die(msg) {
+    console.error(`${exports.c.red}Error:${exports.c.reset} ${msg}`);
+    process.exit(1);
+}
+/** Print a section header */
+function header(title) {
+    console.log(`\n${exports.c.bold}${exports.c.cyan}${title}${exports.c.reset}`);
+}
+/** Truncate a string with ellipsis */
+function trunc(s, maxLen) {
+    if (s.length <= maxLen)
+        return s;
+    return s.slice(0, maxLen - 1) + '…';
+}
+/** Short ID: first 8 chars of a UUID */
+function shortId(id) {
+    return id.slice(0, 8);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@spfunctions/cli",
+  "version": "0.1.0",
+  "description": "CLI for SimpleFunctions prediction market thesis agent",
+  "bin": {
+    "sf": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "prediction-markets",
+    "thesis-agent",
+    "kalshi",
+    "polymarket",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/simplefunctions/simplefunctions"
+  }
+}