@spfunctions/cli 1.1.3 → 1.1.5

package/dist/client.d.ts

@@ -18,6 +18,8 @@ export declare class SFClient {
     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>;
+    publish(id: string, slug: string, description?: string): Promise<any>;
+    unpublish(id: string): Promise<any>;
 }
 export declare function kalshiFetchAllSeries(): Promise<any[]>;
 export declare function kalshiFetchEvents(seriesTicker: string): Promise<any[]>;

package/dist/client.js

@@ -65,6 +65,12 @@ class SFClient {
     async updateThesis(id, data) {
         return this.request('PATCH', `/api/thesis/${id}`, data);
     }
+    async publish(id, slug, description) {
+        return this.request('POST', `/api/thesis/${id}/publish`, { slug, description });
+    }
+    async unpublish(id) {
+        return this.request('DELETE', `/api/thesis/${id}/publish`);
+    }
 }
 exports.SFClient = SFClient;
 // ===== Kalshi Public API (no auth) =====

package/dist/commands/agent.js

@@ -520,7 +520,7 @@ async function agentCommand(thesisId, opts) {
                     const series = await (0, client_js_1.kalshiFetchAllSeries)();
                     const keywords = params.query.toLowerCase().split(/\s+/);
                     const matched = series
-                        .filter((s) => keywords.some((kw) => (s.title || '').toLowerCase().includes(kw) ||
+                        .filter((s) => keywords.every((kw) => (s.title || '').toLowerCase().includes(kw) ||
                         (s.ticker || '').toLowerCase().includes(kw)))
                         .slice(0, 15);
                     result = matched;
@@ -613,6 +613,29 @@ async function agentCommand(thesisId, opts) {
                 };
             },
         },
+        {
+            name: 'explore_public',
+            label: 'Explore Public Theses',
+            description: 'Browse public theses from other users. No auth required. Pass a slug to get details, or omit to list all.',
+            parameters: Type.Object({
+                slug: Type.Optional(Type.String({ description: 'Specific thesis slug, or empty to list all' })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const base = 'https://simplefunctions.dev';
+                if (params.slug) {
+                    const res = await fetch(`${base}/api/public/thesis/${params.slug}`);
+                    if (!res.ok)
+                        return { content: [{ type: 'text', text: `Not found: ${params.slug}` }], details: {} };
+                    const data = await res.json();
+                    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+                }
+                const res = await fetch(`${base}/api/public/theses`);
+                if (!res.ok)
+                    return { content: [{ type: 'text', text: 'Failed to fetch public theses' }], details: {} };
+                const data = await res.json();
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+            },
+        },
     ];
     // ── System prompt builder ──────────────────────────────────────────────────
     function buildSystemPrompt(ctx) {

package/dist/commands/edges.d.ts

@@ -0,0 +1,21 @@
+/**
+ * sf edges — Top edges across all active theses
+ *
+ * The most important output of the entire system: "what to trade now."
+ *
+ * Flow:
+ * 1. GET /api/thesis → all active theses
+ * 2. For each: GET /api/thesis/:id/context → edges with orderbook
+ * 3. Optional: getPositions() → Kalshi positions with live prices
+ * 4. Merge edges, dedupe by marketId (keep highest edge, note source thesis)
+ * 5. Sort by executableEdge descending
+ * 6. Display table with position overlay + summary
+ */
+interface EdgesOpts {
+    json?: boolean;
+    limit?: string;
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function edgesCommand(opts: EdgesOpts): Promise<void>;
+export {};

package/dist/commands/edges.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * sf edges — Top edges across all active theses
+ *
+ * The most important output of the entire system: "what to trade now."
+ *
+ * Flow:
+ * 1. GET /api/thesis → all active theses
+ * 2. For each: GET /api/thesis/:id/context → edges with orderbook
+ * 3. Optional: getPositions() → Kalshi positions with live prices
+ * 4. Merge edges, dedupe by marketId (keep highest edge, note source thesis)
+ * 5. Sort by executableEdge descending
+ * 6. Display table with position overlay + summary
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edgesCommand = edgesCommand;
+const client_js_1 = require("../client.js");
+const kalshi_js_1 = require("../kalshi.js");
+const utils_js_1 = require("../utils.js");
+async function edgesCommand(opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    const limit = parseInt(opts.limit || '20');
+    // ── Step 1: Fetch all active theses ────────────────────────────────────────
+    console.log(`${utils_js_1.c.dim}Fetching theses...${utils_js_1.c.reset}`);
+    const data = await client.listTheses();
+    const rawTheses = data.theses || data;
+    const theses = (Array.isArray(rawTheses) ? rawTheses : []).filter((t) => t.status === 'active');
+    if (theses.length === 0) {
+        console.log(`${utils_js_1.c.yellow}No active theses found.${utils_js_1.c.reset} Create one: sf create "your thesis"`);
+        return;
+    }
+    // ── Step 2: Fetch context for each thesis (parallel) ───────────────────────
+    console.log(`${utils_js_1.c.dim}Fetching edges from ${theses.length} theses...${utils_js_1.c.reset}`);
+    const allEdges = [];
+    const contextPromises = theses.map(async (t) => {
+        try {
+            const ctx = await client.getContext(t.id);
+            return { thesisId: t.id, edges: ctx.edges || [] };
+        }
+        catch {
+            return { thesisId: t.id, edges: [] };
+        }
+    });
+    const results = await Promise.all(contextPromises);
+    for (const { thesisId, edges } of results) {
+        for (const e of edges) {
+            allEdges.push({
+                marketId: e.marketId || '',
+                market: e.market || e.marketTitle || e.marketId || '',
+                venue: e.venue || 'kalshi',
+                direction: e.direction || 'yes',
+                marketPrice: typeof e.marketPrice === 'number' ? e.marketPrice : 0,
+                thesisPrice: typeof e.thesisPrice === 'number' ? e.thesisPrice : 0,
+                edge: typeof e.edge === 'number' ? e.edge : 0,
+                executableEdge: typeof e.executableEdge === 'number' ? e.executableEdge : null,
+                spread: e.orderbook?.spread ?? null,
+                liquidityScore: e.orderbook?.liquidityScore ?? null,
+                thesisId,
+                position: null,
+            });
+        }
+    }
+    if (allEdges.length === 0) {
+        console.log(`${utils_js_1.c.yellow}No edges found across ${theses.length} theses.${utils_js_1.c.reset}`);
+        return;
+    }
+    // ── Step 3: Dedupe by marketId — keep highest absolute edge ────────────────
+    const deduped = new Map();
+    for (const edge of allEdges) {
+        const key = edge.marketId;
+        if (!key)
+            continue;
+        const existing = deduped.get(key);
+        if (!existing || Math.abs(edge.edge) > Math.abs(existing.edge)) {
+            deduped.set(key, edge);
+        }
+    }
+    let merged = Array.from(deduped.values());
+    // ── Step 4: Fetch positions (optional) ─────────────────────────────────────
+    let positions = null;
+    if ((0, kalshi_js_1.isKalshiConfigured)()) {
+        console.log(`${utils_js_1.c.dim}Fetching Kalshi positions...${utils_js_1.c.reset}`);
+        positions = await (0, kalshi_js_1.getPositions)();
+        if (positions) {
+            // Enrich with live prices
+            for (const pos of positions) {
+                const livePrice = await (0, kalshi_js_1.getMarketPrice)(pos.ticker);
+                if (livePrice !== null) {
+                    pos.current_value = livePrice;
+                    pos.unrealized_pnl = Math.round((livePrice - pos.average_price_paid) * pos.quantity);
+                }
+            }
+            // Match positions to edges
+            for (const edge of merged) {
+                const pos = positions.find(p => p.ticker === edge.marketId ||
+                    (edge.marketId && p.ticker?.includes(edge.marketId)));
+                if (pos) {
+                    edge.position = {
+                        side: pos.side || 'yes',
+                        quantity: pos.quantity,
+                        avgPrice: pos.average_price_paid,
+                        currentValue: pos.current_value,
+                        pnl: pos.unrealized_pnl || 0,
+                        totalCost: pos.total_cost || Math.round(pos.average_price_paid * pos.quantity),
+                    };
+                }
+            }
+        }
+    }
+    // ── Step 5: Sort by executableEdge (or edge) descending ────────────────────
+    merged.sort((a, b) => {
+        const aVal = a.executableEdge !== null ? a.executableEdge : a.edge;
+        const bVal = b.executableEdge !== null ? b.executableEdge : b.edge;
+        return Math.abs(bVal) - Math.abs(aVal);
+    });
+    // Apply limit
+    const display = merged.slice(0, limit);
+    // ── Step 6: JSON output ────────────────────────────────────────────────────
+    if (opts.json) {
+        console.log(JSON.stringify({
+            totalEdges: merged.length,
+            displayed: display.length,
+            thesesScanned: theses.length,
+            edges: display,
+        }, null, 2));
+        return;
+    }
+    // ── Step 6: Pretty output ──────────────────────────────────────────────────
+    console.log();
+    (0, utils_js_1.header)(`Top Edges Across ${theses.length} Theses`);
+    console.log();
+    // Header row
+    const hdr = [
+        (0, utils_js_1.pad)('Market', 32),
+        (0, utils_js_1.rpad)('Mkt', 5),
+        (0, utils_js_1.rpad)('Thesis', 7),
+        (0, utils_js_1.rpad)('Edge', 6),
+        (0, utils_js_1.rpad)('Exec', 6),
+        (0, utils_js_1.rpad)('Sprd', 5),
+        (0, utils_js_1.pad)('Liq', 5),
+        (0, utils_js_1.pad)('Thesis', 10),
+        (0, utils_js_1.pad)('Position', 20),
+    ].join(' ');
+    console.log(`${utils_js_1.c.dim}${hdr}${utils_js_1.c.reset}`);
+    (0, utils_js_1.hr)(100);
+    for (const edge of display) {
+        const name = (0, utils_js_1.trunc)(edge.market, 31);
+        const mktStr = `${edge.marketPrice}¢`;
+        const thesisStr = `${edge.thesisPrice}¢`;
+        const edgeStr = edge.edge > 0 ? `+${edge.edge}` : `${edge.edge}`;
+        const execStr = edge.executableEdge !== null ? (edge.executableEdge > 0 ? `+${edge.executableEdge}` : `${edge.executableEdge}`) : '—';
+        const spreadStr = edge.spread !== null ? `${edge.spread}¢` : '—';
+        const liqStr = edge.liquidityScore || '—';
+        const thesisIdStr = (0, utils_js_1.shortId)(edge.thesisId);
+        // Color the edge values
+        const edgeColor = edge.edge > 0 ? utils_js_1.c.green : edge.edge < 0 ? utils_js_1.c.red : utils_js_1.c.dim;
+        const execColor = edge.executableEdge !== null ? (edge.executableEdge > 0 ? utils_js_1.c.green : utils_js_1.c.red) : utils_js_1.c.dim;
+        const liqColor = liqStr === 'high' ? utils_js_1.c.green : liqStr === 'medium' ? utils_js_1.c.yellow : utils_js_1.c.dim;
+        // Position string
+        let posStr = `${utils_js_1.c.dim}—${utils_js_1.c.reset}`;
+        if (edge.position) {
+            const p = edge.position;
+            const pnlStr = p.pnl >= 0 ? `${utils_js_1.c.green}+$${(p.pnl / 100).toFixed(0)}${utils_js_1.c.reset}` : `${utils_js_1.c.red}-$${(Math.abs(p.pnl) / 100).toFixed(0)}${utils_js_1.c.reset}`;
+            posStr = `${utils_js_1.c.green}${p.quantity}@${p.avgPrice}¢${utils_js_1.c.reset} ${pnlStr}`;
+        }
+        const row = [
+            edge.position ? `${utils_js_1.c.green}${(0, utils_js_1.pad)(name, 32)}${utils_js_1.c.reset}` : (0, utils_js_1.pad)(name, 32),
+            (0, utils_js_1.rpad)(mktStr, 5),
+            (0, utils_js_1.rpad)(thesisStr, 7),
+            `${edgeColor}${(0, utils_js_1.rpad)(edgeStr, 6)}${utils_js_1.c.reset}`,
+            `${execColor}${(0, utils_js_1.rpad)(execStr, 6)}${utils_js_1.c.reset}`,
+            (0, utils_js_1.rpad)(spreadStr, 5),
+            `${liqColor}${(0, utils_js_1.pad)(liqStr, 5)}${utils_js_1.c.reset}`,
+            `${utils_js_1.c.dim}${(0, utils_js_1.pad)(thesisIdStr, 10)}${utils_js_1.c.reset}`,
+            posStr,
+        ].join(' ');
+        console.log(row);
+    }
+    // ── Summary ────────────────────────────────────────────────────────────────
+    (0, utils_js_1.hr)(100);
+    // Positioned summary
+    const positioned = display.filter(e => e.position);
+    if (positioned.length > 0) {
+        let totalCost = 0;
+        let totalPnl = 0;
+        for (const e of positioned) {
+            totalCost += e.position.totalCost;
+            totalPnl += e.position.pnl;
+        }
+        const costStr = `$${(totalCost / 100).toFixed(0)}`;
+        const pnlColor = totalPnl >= 0 ? utils_js_1.c.green : utils_js_1.c.red;
+        const pnlSign = totalPnl >= 0 ? '+' : '-';
+        const pnlStr = `${pnlColor}${pnlSign}$${(Math.abs(totalPnl) / 100).toFixed(0)}${utils_js_1.c.reset}`;
+        console.log(`${utils_js_1.c.bold}Total positioned:${utils_js_1.c.reset} ${costStr} cost | P&L: ${pnlStr}`);
+    }
+    // Top unpositioned
+    const unpositioned = display.filter(e => !e.position && e.edge > 0);
+    if (unpositioned.length > 0) {
+        const top = unpositioned[0];
+        const execLabel = top.executableEdge !== null ? `exec +${top.executableEdge}` : `edge +${top.edge}`;
+        const liq = top.liquidityScore ? `, ${top.liquidityScore} liq` : '';
+        console.log(`${utils_js_1.c.bold}Top unpositioned:${utils_js_1.c.reset} ${(0, utils_js_1.trunc)(top.market, 30)} @ ${top.marketPrice}¢ (${execLabel}${liq})`);
+    }
+    console.log();
+}

package/dist/commands/explore.d.ts

@@ -0,0 +1,13 @@
+/**
+ * sf explore [slug]
+ *
+ * Browse public theses. No authentication required.
+ *
+ * Usage:
+ *   sf explore                     — List all public theses
+ *   sf explore us-iran-war         — View a specific public thesis
+ *   sf explore us-iran-war --json  — JSON output (for agents)
+ */
+export declare function exploreCommand(slug?: string, opts?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/explore.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * sf explore [slug]
+ *
+ * Browse public theses. No authentication required.
+ *
+ * Usage:
+ *   sf explore                     — List all public theses
+ *   sf explore us-iran-war         — View a specific public thesis
+ *   sf explore us-iran-war --json  — JSON output (for agents)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreCommand = exploreCommand;
+const BASE_URL = 'https://simplefunctions.dev';
+async function exploreCommand(slug, opts) {
+    if (!slug) {
+        // List all public theses
+        const res = await fetch(`${BASE_URL}/api/public/theses`);
+        if (!res.ok) {
+            console.error(`  Error: ${res.status} ${await res.text()}`);
+            return;
+        }
+        const { theses } = await res.json();
+        if (opts?.json) {
+            console.log(JSON.stringify(theses, null, 2));
+            return;
+        }
+        console.log('\n  Public Theses\n');
+        if (theses.length === 0) {
+            console.log('  No public theses yet.\n');
+            return;
+        }
+        for (const t of theses) {
+            const conf = t.confidence != null ? Math.round(t.confidence * 100) : '?';
+            const ret = t.impliedReturn != null ? `${t.impliedReturn > 0 ? '+' : ''}${t.impliedReturn}%` : '';
+            console.log(`  ${(t.slug || '').padEnd(35)} ${String(conf).padStart(3)}%  ${ret.padStart(8)}  ${(t.status || '').padEnd(8)} ${(t.title || '').slice(0, 45)}`);
+        }
+        console.log(`\n  ${theses.length} public theses. Use: sf explore <slug>\n`);
+        return;
+    }
+    // View a specific public thesis
+    const res = await fetch(`${BASE_URL}/api/public/thesis/${slug}`);
+    if (!res.ok) {
+        if (res.status === 404) {
+            console.error(`  Not found: ${slug}`);
+        }
+        else {
+            console.error(`  Error: ${res.status} ${await res.text()}`);
+        }
+        return;
+    }
+    const data = await res.json();
+    if (opts?.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Formatted output
+    const t = data.thesis;
+    const ir = data.impliedReturns;
+    console.log(`\n  ${t.title}`);
+    console.log(`  ${t.slug} | ${t.confidence != null ? Math.round(t.confidence * 100) : '?'}% | ${t.status} | published ${t.publishedAt?.slice(0, 10) || '?'}`);
+    if (t.description)
+        console.log(`  ${t.description}`);
+    console.log('');
+    // Causal tree
+    if (data.causalTree?.nodes?.length) {
+        console.log('  Causal Tree');
+        for (const n of data.causalTree.nodes) {
+            const bar = '█'.repeat(Math.round((n.probability || 0) * 10)) + '░'.repeat(10 - Math.round((n.probability || 0) * 10));
+            console.log(`    ${n.id} ${(n.label || '').slice(0, 35).padEnd(35)} ${Math.round((n.probability || 0) * 100)}% ${bar}`);
+            if (n.children) {
+                for (const c of n.children) {
+                    const cbar = '█'.repeat(Math.round((c.probability || 0) * 10)) + '░'.repeat(10 - Math.round((c.probability || 0) * 10));
+                    console.log(`      ${c.id} ${(c.label || '').slice(0, 33).padEnd(33)} ${Math.round((c.probability || 0) * 100)}% ${cbar}`);
+                }
+            }
+        }
+        console.log('');
+    }
+    // Implied returns
+    if (ir && ir.edges?.length > 0) {
+        console.log(`  Implied Returns (equal-weight, since ${ir.trackedSince?.slice(0, 10) || '?'})`);
+        console.log(`  Avg: ${ir.avgReturnPct > 0 ? '+' : ''}${ir.avgReturnPct}% | Win rate: ${ir.winRate}% (${ir.winners}W ${ir.losers}L)`);
+        console.log('');
+        for (const e of ir.edges.slice(0, 10)) {
+            const ret = e.returnPct > 0 ? `+${e.returnPct}%` : `${e.returnPct}%`;
+            console.log(`    ${(e.market || '').slice(0, 35).padEnd(35)} ${e.entryPrice}¢ → ${e.currentPrice}¢  ${ret}`);
+        }
+        console.log('');
+    }
+    // Recent evaluations
+    if (data.confidenceHistory?.length > 0) {
+        console.log('  Recent Evaluations');
+        for (const h of data.confidenceHistory.slice(-5)) {
+            const d = h.delta > 0 ? `+${Math.round(h.delta * 100)}` : `${Math.round(h.delta * 100)}`;
+            console.log(`    ${(h.evaluatedAt || '').slice(0, 16)} ${Math.round(h.confidence * 100)}% (${d}) ${(h.summary || '').slice(0, 60)}`);
+        }
+        console.log('');
+    }
+    // Top edges
+    if (data.edges?.length > 0) {
+        console.log('  Top Edges');
+        const sorted = [...data.edges].sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge)).slice(0, 10);
+        for (const e of sorted) {
+            const liq = e.orderbook?.liquidityScore || '?';
+            console.log(`    ${(e.market || '').slice(0, 35).padEnd(35)} ${e.marketPrice}¢ → ${e.thesisPrice}¢  edge ${e.edge > 0 ? '+' : ''}${e.edge}  ${liq}`);
+        }
+        console.log('');
+    }
+}

package/dist/commands/publish.d.ts

@@ -0,0 +1,15 @@
+/**
+ * sf publish / sf unpublish
+ *
+ * Publish a thesis for public viewing or remove it from public.
+ */
+export declare function publishCommand(thesisId: string, opts: {
+    slug: string;
+    description?: string;
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;
+export declare function unpublishCommand(thesisId: string, opts: {
+    apiKey?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/publish.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * sf publish / sf unpublish
+ *
+ * Publish a thesis for public viewing or remove it from public.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishCommand = publishCommand;
+exports.unpublishCommand = unpublishCommand;
+const client_js_1 = require("../client.js");
+async function publishCommand(thesisId, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    await client.publish(thesisId, opts.slug, opts.description);
+    console.log(`\n  ✓ Published: https://simplefunctions.dev/thesis/${opts.slug}\n`);
+}
+async function unpublishCommand(thesisId, opts) {
+    const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+    await client.unpublish(thesisId);
+    console.log(`\n  ✓ Unpublished thesis ${thesisId}\n`);
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,20 @@
+/**
+ * sf setup — Interactive configuration wizard
+ *
+ * Walks user through:
+ *   1. SF API key (required)
+ *   2. OpenRouter API key (optional, for agent)
+ *   3. Kalshi exchange credentials (optional, for positions)
+ *   4. Tavily API key (optional, for web search)
+ *   5. First thesis creation (if none exist)
+ *
+ * Each key is validated in real-time.
+ * Config is saved to ~/.sf/config.json.
+ */
+interface SetupOpts {
+    check?: boolean;
+    reset?: boolean;
+    key?: string;
+}
+export declare function setupCommand(opts: SetupOpts): Promise<void>;
+export {};