@spfunctions/cli 1.1.5 → 1.1.6

package/dist/commands/schedule.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleCommand = scheduleCommand;
+const utils_js_1 = require("../utils.js");
+const KALSHI_API_BASE = 'https://api.elections.kalshi.com/trade-api/v2';
+async function scheduleCommand(opts) {
+    const statusRes = await fetch(`${KALSHI_API_BASE}/exchange/status`, {
+        headers: { 'Accept': 'application/json' },
+    });
+    if (!statusRes.ok)
+        throw new Error(`Exchange API ${statusRes.status}`);
+    const status = await statusRes.json();
+    let schedule = null;
+    try {
+        const schedRes = await fetch(`${KALSHI_API_BASE}/exchange/schedule`, {
+            headers: { 'Accept': 'application/json' },
+        });
+        if (schedRes.ok)
+            schedule = await schedRes.json();
+    }
+    catch { /* schedule endpoint may not exist */ }
+    if (opts.json) {
+        console.log(JSON.stringify({ status, schedule }, null, 2));
+        return;
+    }
+    const trading = status.exchange_active ? `${utils_js_1.c.green}OPEN${utils_js_1.c.reset}` : `${utils_js_1.c.red}CLOSED${utils_js_1.c.reset}`;
+    console.log();
+    console.log(`  ${utils_js_1.c.bold}${utils_js_1.c.cyan}Exchange Status${utils_js_1.c.reset}`);
+    console.log(`  ${utils_js_1.c.dim}${'─'.repeat(30)}${utils_js_1.c.reset}`);
+    console.log(`  Trading: ${trading}`);
+    if (status.trading_active !== undefined) {
+        console.log(`  Trading Active: ${status.trading_active ? 'yes' : 'no'}`);
+    }
+    if (schedule?.schedule) {
+        console.log(`  Schedule: ${JSON.stringify(schedule.schedule).slice(0, 100)}`);
+    }
+    console.log();
+}

package/dist/commands/settlements.d.ts

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

package/dist/commands/settlements.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settlementsCommand = settlementsCommand;
+const kalshi_js_1 = require("../kalshi.js");
+const client_js_1 = require("../client.js");
+const utils_js_1 = require("../utils.js");
+async function settlementsCommand(opts) {
+    // Paginate through all settlements
+    const all = [];
+    let cursor = '';
+    do {
+        const result = await (0, kalshi_js_1.getSettlements)({ limit: 200, cursor: cursor || undefined });
+        if (!result)
+            throw new Error('Kalshi not configured. Set KALSHI_API_KEY_ID + KALSHI_PRIVATE_KEY_PATH.');
+        all.push(...result.settlements);
+        cursor = result.cursor;
+    } while (cursor);
+    let filtered = all;
+    if (opts.thesis) {
+        const client = new client_js_1.SFClient(opts.apiKey, opts.apiUrl);
+        const ctx = await client.getContext(opts.thesis);
+        const edgeTickers = new Set((ctx.edges || []).map((e) => e.marketId));
+        filtered = all.filter((s) => edgeTickers.has(s.ticker));
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+    if (filtered.length === 0) {
+        console.log(`${utils_js_1.c.dim}No settlements found.${utils_js_1.c.reset}`);
+        return;
+    }
+    console.log(`${utils_js_1.c.bold}${utils_js_1.c.cyan}Settlements${utils_js_1.c.reset}`);
+    console.log(`${utils_js_1.c.dim}${'─'.repeat(80)}${utils_js_1.c.reset}`);
+    console.log(`${utils_js_1.c.bold}${'Ticker'.padEnd(35)} ${'Result'.padEnd(8)} ${'Revenue'.padEnd(10)} ${'Cost'.padEnd(10)} P&L${utils_js_1.c.reset}`);
+    let totalPnl = 0;
+    for (const s of filtered.slice(0, 50)) {
+        const revenue = parseFloat(s.revenue || s.revenue_dollars || '0');
+        const cost = parseFloat(s.yes_total_cost || s.yes_total_cost_dollars || '0') +
+            parseFloat(s.no_total_cost || s.no_total_cost_dollars || '0');
+        const pnl = revenue - cost;
+        totalPnl += pnl;
+        const pnlStr = pnl >= 0 ? `${utils_js_1.c.green}+$${pnl.toFixed(2)}${utils_js_1.c.reset}` : `${utils_js_1.c.red}-$${Math.abs(pnl).toFixed(2)}${utils_js_1.c.reset}`;
+        const result = s.market_result || '-';
+        console.log(`  ${(s.ticker || '').slice(0, 33).padEnd(35)} ${result.padEnd(8)} $${revenue.toFixed(2).padEnd(9)} $${cost.toFixed(2).padEnd(9)} ${pnlStr}`);
+    }
+    console.log(`${utils_js_1.c.dim}${'─'.repeat(80)}${utils_js_1.c.reset}`);
+    const totalStr = totalPnl >= 0 ? `${utils_js_1.c.green}+$${totalPnl.toFixed(2)}${utils_js_1.c.reset}` : `${utils_js_1.c.red}-$${Math.abs(totalPnl).toFixed(2)}${utils_js_1.c.reset}`;
+    console.log(`  Total: ${totalStr}  (${filtered.length} settlements)`);
+}

package/dist/commands/setup.d.ts

@@ -15,6 +15,8 @@ interface SetupOpts {
     check?: boolean;
     reset?: boolean;
     key?: string;
+    enableTrading?: boolean;
+    disableTrading?: boolean;
 }
 export declare function setupCommand(opts: SetupOpts): Promise<void>;
 export {};

package/dist/commands/setup.js

@@ -147,6 +147,21 @@ async function setupCommand(opts) {
         ok(`保存到 ${(0, config_js_1.getConfigPath)()}`);
         return;
     }
+    // ── sf setup --enable-trading / --disable-trading ────────────────────────
+    if (opts.enableTrading) {
+        const existing = (0, config_js_1.loadFileConfig)();
+        (0, config_js_1.saveConfig)({ ...existing, tradingEnabled: true });
+        ok('Trading enabled. sf buy / sf sell / sf cancel now available.');
+        blank();
+        return;
+    }
+    if (opts.disableTrading) {
+        const existing = (0, config_js_1.loadFileConfig)();
+        (0, config_js_1.saveConfig)({ ...existing, tradingEnabled: false });
+        ok('Trading disabled.');
+        blank();
+        return;
+    }
     // ── Full interactive wizard ───────────────────────────────────────────────
     return runWizard();
 }
@@ -185,6 +200,13 @@ async function showCheck() {
     else {
         info(`${dim('○')} TAVILY            ${dim('跳过')}`);
     }
+    // Trading
+    if (config.tradingEnabled) {
+        ok('TRADING           已启用');
+    }
+    else {
+        info(`${dim('○')} TRADING           ${dim('未启用 — sf setup --enable-trading')}`);
+    }
     blank();
     console.log(`  ${dim('配置文件: ' + (0, config_js_1.getConfigPath)())}`);
     blank();
@@ -303,6 +325,26 @@ async function runWizard() {
     if (config.tavilyKey)
         process.env.TAVILY_API_KEY = config.tavilyKey;
     // ════════════════════════════════════════════════════════════════════════════
+    // Step 5: Trading
+    // ════════════════════════════════════════════════════════════════════════════
+    if (config.kalshiKeyId) {
+        console.log(`  ${bold('第 5 步：交易功能（可选）')}`);
+        blank();
+        info('⚠️  启用后 sf buy / sf sell / sf cancel 可用。');
+        info('你的 Kalshi API key 必须有 read+write 权限。');
+        blank();
+        const enableTrading = await promptYN('  启用交易功能？(y/N) ', false);
+        config.tradingEnabled = enableTrading;
+        if (enableTrading) {
+            ok('交易功能已启用');
+        }
+        else {
+            info(dim('跳过。之后可以 sf setup --enable-trading 启用。'));
+        }
+        blank();
+        (0, config_js_1.saveConfig)(config);
+    }
+    // ════════════════════════════════════════════════════════════════════════════
     // Summary
     // ════════════════════════════════════════════════════════════════════════════
     console.log(`  ${dim('─'.repeat(25))}`);
@@ -433,7 +475,7 @@ async function promptForTavily() {
     blank();
     return answer;
 }
-// ─── Step 5: Thesis ──────────────────────────────────────────────────────────
+// ─── Step 6: Thesis ──────────────────────────────────────────────────────────
 async function handleThesisStep(config) {
     try {
         const client = new client_js_1.SFClient(config.apiKey, config.apiUrl);
@@ -441,7 +483,7 @@ async function handleThesisStep(config) {
         const theses = data.theses || [];
         const activeTheses = theses.filter((t) => t.status === 'active');
         if (activeTheses.length > 0) {
-            console.log(`  ${bold('第 5 步：论文')}`);
+            console.log(`  ${bold('第 6 步：论文')}`);
             blank();
             ok(`已有 ${activeTheses.length} 个活跃论文：`);
             for (const t of activeTheses.slice(0, 5)) {
@@ -482,7 +524,7 @@ async function handleThesisStep(config) {
             return;
         }
         // No theses — offer to create one
-        console.log(`  ${bold('第 5 步：创建你的第一个论文')}`);
+        console.log(`  ${bold('第 6 步：创建你的第一个论文')}`);
         blank();
         info('论文是你对市场的一个核心判断。系统会基于它构建因果模型，');
         info('然后持续扫描预测市场寻找被错误定价的合约。');

package/dist/commands/signal.js

@@ -14,5 +14,16 @@ async function signalCommand(id, content, opts) {
     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}`);
+    // Calculate minutes until next 15-min cron cycle (runs at :00, :15, :30, :45)
+    const now = new Date();
+    const minute = now.getMinutes();
+    const nextCycleMin = Math.ceil((minute + 1) / 15) * 15;
+    const minutesUntil = nextCycleMin - minute;
+    const nextRun = new Date(now);
+    nextRun.setMinutes(nextCycleMin % 60, 0, 0);
+    if (nextCycleMin >= 60)
+        nextRun.setHours(nextRun.getHours() + 1);
+    const timeStr = nextRun.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    console.log(`\n${utils_js_1.c.dim}Signal queued. Next monitor cycle in ~${minutesUntil}min (${timeStr}).${utils_js_1.c.reset}`);
+    console.log(`${utils_js_1.c.dim}Or run ${utils_js_1.c.reset}sf evaluate ${id}${utils_js_1.c.dim} to consume immediately.${utils_js_1.c.reset}`);
 }

package/dist/commands/strategies.d.ts

@@ -0,0 +1,11 @@
+/**
+ * sf strategies — List strategies across theses
+ *
+ * Usage:
+ *   sf strategies                    — all active strategies across all theses
+ *   sf strategies f582bf76           — strategies for a specific thesis
+ *   sf strategies --status executed  — filter by status
+ *   sf strategies --all              — all statuses
+ */
+import { Command } from 'commander';
+export declare function registerStrategies(program: Command): void;

package/dist/commands/strategies.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * sf strategies — List strategies across theses
+ *
+ * Usage:
+ *   sf strategies                    — all active strategies across all theses
+ *   sf strategies f582bf76           — strategies for a specific thesis
+ *   sf strategies --status executed  — filter by status
+ *   sf strategies --all              — all statuses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStrategies = registerStrategies;
+const client_js_1 = require("../client.js");
+const STATUS_COLORS = {
+    active: '\x1b[32m', // green
+    watching: '\x1b[33m', // yellow
+    executed: '\x1b[36m', // cyan
+    cancelled: '\x1b[90m', // gray
+    review: '\x1b[31m', // red
+};
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+function formatStrategy(s, showThesis = false) {
+    const statusColor = STATUS_COLORS[s.status] || '';
+    const lines = [];
+    // Header line
+    const thesisPrefix = showThesis ? `${DIM}${s.thesisTitle || s.thesisId?.slice(0, 8)}${RESET}  ` : '';
+    lines.push(`  ${thesisPrefix}${statusColor}[${s.status}]${RESET}  ${BOLD}${s.marketId}${RESET} ${s.direction.toUpperCase()}  ${DIM}${s.horizon}${RESET}  priority ${s.priority || 0}`);
+    // Entry conditions
+    const entryParts = [];
+    if (s.entryBelow != null)
+        entryParts.push(`ask ≤ ${s.entryBelow}¢`);
+    if (s.entryAbove != null)
+        entryParts.push(`ask ≥ ${s.entryAbove}¢`);
+    const stopPart = s.stopLoss != null ? `Stop: ${s.stopLoss}¢` : '';
+    const tpPart = s.takeProfit != null ? `TP: ${s.takeProfit}¢` : '';
+    const maxPart = `Max: ${s.maxQuantity || 500}`;
+    const filledPart = `Filled: ${s.executedQuantity || 0}/${s.maxQuantity || 500}`;
+    const conditionLine = [
+        entryParts.length > 0 ? `Entry: ${entryParts.join(', ')}` : null,
+        stopPart || null,
+        tpPart || null,
+        maxPart,
+        filledPart,
+    ].filter(Boolean).join('  |  ');
+    lines.push(`    ${conditionLine}`);
+    // Soft conditions
+    if (s.softConditions) {
+        lines.push(`    ${DIM}Soft: ${s.softConditions}${RESET}`);
+    }
+    // Review warning
+    if (s.status === 'review') {
+        lines.push(`    \x1b[31m⚠️  Needs review${RESET}`);
+    }
+    // Rationale (truncated)
+    if (s.rationale) {
+        const truncated = s.rationale.length > 120 ? s.rationale.slice(0, 117) + '...' : s.rationale;
+        lines.push(`    ${DIM}${truncated}${RESET}`);
+    }
+    // Footer
+    const createdBy = s.createdBy || 'user';
+    const date = s.createdAt ? new Date(s.createdAt).toLocaleDateString('en-US', { month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : '';
+    lines.push(`    ${DIM}created by ${createdBy} · ${date}${RESET}`);
+    return lines.join('\n');
+}
+function registerStrategies(program) {
+    program
+        .command('strategies')
+        .argument('[thesisId]', 'thesis ID or prefix (omit for all theses)')
+        .option('--status <status>', 'filter by status (active|watching|executed|cancelled|review)')
+        .option('--all', 'show all statuses (default: active only)')
+        .description('List strategies across theses')
+        .action(async (thesisId, opts) => {
+        try {
+            const client = new client_js_1.SFClient();
+            if (thesisId) {
+                // Strategies for a specific thesis
+                const statusParam = opts?.all ? '' : (opts?.status || 'active');
+                const url = statusParam
+                    ? `/api/thesis/${thesisId}/strategies?status=${statusParam}`
+                    : `/api/thesis/${thesisId}/strategies`;
+                const data = await client.getStrategies(thesisId, opts?.all ? undefined : (opts?.status || 'active'));
+                const strategies = data.strategies || [];
+                if (strategies.length === 0) {
+                    console.log(`\n  No strategies found for thesis ${thesisId}`);
+                    if (!opts?.all && !opts?.status) {
+                        console.log(`  ${DIM}Try --all to see all statuses${RESET}`);
+                    }
+                    console.log();
+                    return;
+                }
+                console.log(`\n  Strategies for ${thesisId}\n`);
+                for (const s of strategies) {
+                    console.log(formatStrategy(s));
+                    console.log();
+                }
+            }
+            else {
+                // All strategies across all theses
+                const { theses } = await client.listTheses();
+                let totalStrategies = 0;
+                for (const thesis of theses) {
+                    const statusFilter = opts?.all ? undefined : (opts?.status || 'active');
+                    const data = await client.getStrategies(thesis.id, statusFilter);
+                    const strategies = data.strategies || [];
+                    if (strategies.length === 0)
+                        continue;
+                    totalStrategies += strategies.length;
+                    console.log(`\n  ${BOLD}${thesis.title}${RESET}  ${DIM}(${thesis.id.slice(0, 8)})${RESET}\n`);
+                    for (const s of strategies) {
+                        console.log(formatStrategy(s));
+                        console.log();
+                    }
+                }
+                if (totalStrategies === 0) {
+                    console.log(`\n  No strategies found`);
+                    if (!opts?.all && !opts?.status) {
+                        console.log(`  ${DIM}Try --all to see all statuses${RESET}`);
+                    }
+                    console.log();
+                }
+            }
+        }
+        catch (err) {
+            console.error(`\x1b[31mError:\x1b[0m ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/trade.d.ts

@@ -0,0 +1,12 @@
+export declare function buyCommand(ticker: string, qty: string, opts: {
+    price?: string;
+    market?: boolean;
+    side?: string;
+    yesIAmSure?: boolean;
+}): Promise<void>;
+export declare function sellCommand(ticker: string, qty: string, opts: {
+    price?: string;
+    market?: boolean;
+    side?: string;
+    yesIAmSure?: boolean;
+}): Promise<void>;

package/dist/commands/trade.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buyCommand = buyCommand;
+exports.sellCommand = sellCommand;
+const kalshi_js_1 = require("../kalshi.js");
+const config_js_1 = require("../config.js");
+const utils_js_1 = require("../utils.js");
+async function buyCommand(ticker, qty, opts) {
+    (0, config_js_1.requireTrading)();
+    await executeOrder(ticker, qty, 'buy', opts);
+}
+async function sellCommand(ticker, qty, opts) {
+    (0, config_js_1.requireTrading)();
+    await executeOrder(ticker, qty, 'sell', opts);
+}
+async function executeOrder(ticker, qty, action, opts) {
+    const quantity = parseInt(qty);
+    if (isNaN(quantity) || quantity <= 0)
+        throw new Error('Quantity must be a positive integer');
+    const side = (opts.side || 'yes');
+    const orderType = opts.market ? 'market' : 'limit';
+    if (orderType === 'limit' && !opts.price) {
+        throw new Error('Limit order requires --price <cents>. Use --market for market orders.');
+    }
+    const priceCents = opts.price ? parseInt(opts.price) : undefined;
+    if (priceCents !== undefined && (priceCents < 1 || priceCents > 99)) {
+        throw new Error('Price must be 1-99 cents.');
+    }
+    const priceDollars = priceCents ? (priceCents / 100).toFixed(2) : undefined;
+    const maxCost = ((priceCents || 99) * quantity / 100).toFixed(2);
+    console.log();
+    console.log(`  ${utils_js_1.c.bold}${utils_js_1.c.cyan}${action.toUpperCase()} Order${utils_js_1.c.reset}`);
+    console.log(`  ${utils_js_1.c.dim}${'─'.repeat(35)}${utils_js_1.c.reset}`);
+    console.log(`  Ticker:    ${ticker}`);
+    console.log(`  Side:      ${side === 'yes' ? utils_js_1.c.green + 'YES' + utils_js_1.c.reset : utils_js_1.c.red + 'NO' + utils_js_1.c.reset}`);
+    console.log(`  Quantity:  ${quantity}`);
+    console.log(`  Type:      ${orderType}`);
+    if (priceDollars)
+        console.log(`  Price:     ${priceCents}¢`);
+    console.log(`  Max cost:  $${maxCost}`);
+    console.log();
+    if (!opts.yesIAmSure) {
+        for (let i = 3; i > 0; i--) {
+            process.stdout.write(`  Executing in ${i}...  (Ctrl+C to cancel)\r`);
+            await new Promise(r => setTimeout(r, 1000));
+        }
+        process.stdout.write('  Executing...                              \n');
+    }
+    try {
+        const result = await (0, kalshi_js_1.createOrder)({
+            ticker,
+            side,
+            action,
+            type: orderType,
+            count: quantity,
+            ...(priceDollars ? { yes_price: priceDollars } : {}),
+        });
+        const order = result.order || result;
+        console.log();
+        console.log(`  ${utils_js_1.c.green}✓${utils_js_1.c.reset} Order placed: ${order.order_id || 'OK'}`);
+        if (order.status)
+            console.log(`  Status: ${order.status}`);
+        if (order.fill_count_fp)
+            console.log(`  Filled: ${order.fill_count_fp}/${order.initial_count_fp || quantity}`);
+        console.log();
+    }
+    catch (err) {
+        const msg = err.message || String(err);
+        if (msg.includes('403')) {
+            console.error(`\n  ${utils_js_1.c.red}✗${utils_js_1.c.reset} 403 Forbidden — your Kalshi key lacks write permission.`);
+            console.error(`  Get a read+write key at https://kalshi.com/account/api-keys\n`);
+        }
+        else {
+            console.error(`\n  ${utils_js_1.c.red}✗${utils_js_1.c.reset} ${msg}\n`);
+        }
+        process.exit(1);
+    }
+}

package/dist/config.d.ts

@@ -15,6 +15,7 @@ export interface SFConfig {
     kalshiPrivateKeyPath?: string;
     tavilyKey?: string;
     model?: string;
+    tradingEnabled?: boolean;
     configuredAt?: string;
 }
 /**
@@ -47,4 +48,5 @@ export declare function applyConfig(): void;
  * Check if SF API key is configured (from any source).
  */
 export declare function isConfigured(): boolean;
+export declare function requireTrading(): void;
 export declare function getConfigPath(): string;

package/dist/config.js

@@ -18,6 +18,7 @@ exports.saveConfig = saveConfig;
 exports.resetConfig = resetConfig;
 exports.applyConfig = applyConfig;
 exports.isConfigured = isConfigured;
+exports.requireTrading = requireTrading;
 exports.getConfigPath = getConfigPath;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -51,6 +52,7 @@ function loadConfig() {
         kalshiPrivateKeyPath: process.env.KALSHI_PRIVATE_KEY_PATH || file.kalshiPrivateKeyPath,
         tavilyKey: process.env.TAVILY_API_KEY || file.tavilyKey,
         model: process.env.SF_MODEL || file.model || DEFAULT_MODEL,
+        tradingEnabled: file.tradingEnabled || false,
     };
 }
 /**
@@ -112,6 +114,17 @@ function isConfigured() {
     const config = loadConfig();
     return !!config.apiKey;
 }
+function requireTrading() {
+    const config = loadConfig();
+    if (!config.tradingEnabled) {
+        console.error('\n  ⚠️  Trading is disabled. Run: sf setup --enable-trading\n');
+        process.exit(1);
+    }
+    if (!config.kalshiKeyId && !process.env.KALSHI_API_KEY_ID) {
+        console.error('\n  ⚠️  Kalshi API key not configured. Run: sf setup\n');
+        process.exit(1);
+    }
+}
 function getConfigPath() {
     return CONFIG_PATH;
 }