kalshi-trading-bot-cli 2.1.0

package/src/commands/status.ts

@@ -0,0 +1,70 @@
+import { callKalshiApi } from '../tools/kalshi/api.js';
+import { PROVIDERS } from '@/providers';
+import { getDefaultModelForProvider } from '@/utils/model';
+
+/**
+ * Verify setup: check API keys, exchange connectivity, and optional services.
+ * Designed to be the first command a new user runs after `cp env.example .env`.
+ */
+export async function handleStatus(): Promise<string> {
+  const lines: string[] = [];
+  let allGood = true;
+
+  lines.push('Checking setup...');
+  lines.push('');
+
+  // 1. Kalshi API key
+  const hasKalshiKey = !!process.env.KALSHI_API_KEY;
+  const hasKalshiPem = !!(process.env.KALSHI_PRIVATE_KEY_FILE || process.env.KALSHI_PRIVATE_KEY);
+  lines.push(hasKalshiKey ? '✓ KALSHI_API_KEY set' : '✗ KALSHI_API_KEY missing');
+  lines.push(hasKalshiPem ? '✓ Kalshi private key configured' : '✗ Kalshi private key missing (set KALSHI_PRIVATE_KEY_FILE or KALSHI_PRIVATE_KEY)');
+  if (!hasKalshiKey || !hasKalshiPem) allGood = false;
+
+  // 2. Exchange connectivity
+  if (hasKalshiKey && hasKalshiPem) {
+    try {
+      const data = await callKalshiApi('GET', '/exchange/status');
+      const active = (data as any).exchange_active;
+      const trading = (data as any).trading_active;
+      lines.push(active ? '✓ Exchange reachable' : '✗ Exchange not active');
+      lines.push(trading ? '✓ Trading enabled' : '⚠ Trading paused');
+      if (!active) allGood = false;
+    } catch (e: any) {
+      lines.push(`✗ Cannot reach Kalshi API: ${e.message}`);
+      allGood = false;
+    }
+  }
+
+  // 3. LLM provider — detect which provider is configured and show its default model
+  const configuredProvider = PROVIDERS.find(
+    (p) => p.apiKeyEnvVar && process.env[p.apiKeyEnvVar],
+  );
+  const defaultModel =
+    process.env.DEFAULT_MODEL ??
+    (configuredProvider ? getDefaultModelForProvider(configuredProvider.id) : undefined);
+  const llmKey = !!configuredProvider;
+  lines.push(
+    llmKey
+      ? `✓ LLM provider configured (${configuredProvider!.displayName}${defaultModel ? `, default model: ${defaultModel}` : ''})`
+      : '✗ No LLM API key set (need at least one: OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.)',
+  );
+  if (!llmKey) allGood = false;
+
+  // 4. Octagon
+  const hasOctagon = !!process.env.OCTAGON_API_KEY;
+  lines.push(hasOctagon ? '✓ OCTAGON_API_KEY set' : '⚠ OCTAGON_API_KEY missing — /scan and deep research will not work');
+
+  // 5. Optional: Tavily
+  const hasTavily = !!process.env.TAVILY_API_KEY;
+  lines.push(hasTavily ? '✓ TAVILY_API_KEY set (web search enabled)' : '  TAVILY_API_KEY not set (web search disabled — optional)');
+
+  // 6. Demo mode
+  if (process.env.KALSHI_USE_DEMO === 'true') {
+    lines.push('⚠ KALSHI_USE_DEMO=true — using demo environment (no real money)');
+  }
+
+  lines.push('');
+  lines.push(allGood ? '✓ All good — ready to trade.' : '✗ Fix the issues above before continuing.');
+
+  return lines.join('\n');
+}

package/src/commands/themes.ts

@@ -0,0 +1,117 @@
+import { getDb } from '../db/index.js';
+import { getActiveThemes } from '../db/themes.js';
+import { CATEGORY_MAP, fetchSubcategories } from '../scan/theme-resolver.js';
+import { formatTable } from './scan-formatters.js';
+import { wrapSuccess } from './json.js';
+import type { CLIResponse } from './json.js';
+import type { ParsedArgs } from './parse-args.js';
+
+export interface ThemeInfo {
+  id: string;
+  name: string;
+  type: 'built-in' | 'category' | 'custom';
+  subcategories?: string[];
+  tickerCount?: number;
+}
+
+export interface ThemesResult {
+  themes: ThemeInfo[];
+}
+
+export async function handleThemes(args: ParsedArgs): Promise<CLIResponse<ThemesResult>> {
+  const themes: ThemeInfo[] = [];
+
+  // Special built-in theme
+  themes.push({ id: 'top50', name: 'Top 50 markets by 24h volume', type: 'built-in' });
+
+  // Fetch subcategories from Kalshi API
+  let subcatMap: Record<string, string[]> = {};
+  try {
+    subcatMap = await fetchSubcategories();
+  } catch {
+    // API unavailable — show categories without subcategories
+  }
+
+  // All Kalshi categories with their subcategories
+  for (const [id, label] of Object.entries(CATEGORY_MAP)) {
+    const subs = subcatMap[label] ?? [];
+    themes.push({
+      id,
+      name: label,
+      type: 'category',
+      ...(subs.length > 0 ? { subcategories: subs } : {}),
+    });
+  }
+
+  // Custom themes from DB
+  try {
+    const db = getDb();
+    const custom = getActiveThemes(db);
+    for (const t of custom) {
+      const tickers = t.tickers ? JSON.parse(t.tickers) as string[] : [];
+      themes.push({
+        id: t.theme_id,
+        name: t.name,
+        type: 'custom',
+        tickerCount: tickers.length,
+      });
+    }
+  } catch {
+    // DB not initialized yet — just show built-in themes
+  }
+
+  return wrapSuccess('themes', { themes });
+}
+
+/** Wrap a comma-separated list into lines of at most `maxWidth` characters */
+function wrapSubs(subs: string[], maxWidth: number): string[] {
+  if (subs.length === 0) return [''];
+  const wrapped: string[] = [];
+  let line = '';
+  for (const s of subs) {
+    const addition = line ? `, ${s}` : s;
+    if (line && (line + addition).length > maxWidth) {
+      wrapped.push(line);
+      line = s;
+    } else {
+      line += addition;
+    }
+  }
+  if (line) wrapped.push(line);
+  return wrapped;
+}
+
+export function formatThemesHuman(data: ThemesResult): string {
+  const lines: string[] = [];
+  const SUB_WIDTH = 55;
+
+  const rows: string[][] = [];
+
+  // Built-in special themes
+  for (const t of data.themes.filter((t) => t.type === 'built-in')) {
+    rows.push([t.id, t.name]);
+  }
+
+  // Categories — main row, then one subcategory per line
+  for (const t of data.themes.filter((t) => t.type === 'category')) {
+    rows.push([t.id, t.name]);
+    for (const s of t.subcategories ?? []) {
+      rows.push(['', `  ${t.id}:${s.toLowerCase()}`]);
+    }
+  }
+
+  // Custom themes
+  for (const t of data.themes.filter((t) => t.type === 'custom')) {
+    const extra = t.tickerCount !== undefined ? `${t.name} (${t.tickerCount} tickers)` : t.name;
+    rows.push([t.id, extra]);
+  }
+
+  lines.push(formatTable(['Theme', 'Description / Subcategories'], rows));
+
+  lines.push('');
+  lines.push('Usage: search crypto');
+  lines.push('       search crypto:btc');
+  lines.push('       analyze <TICKER>');
+
+  return lines.join('\n');
+}

package/src/commands/watch.ts

@@ -0,0 +1,295 @@
+import type { ParsedArgs } from './parse-args.js';
+import { wrapSuccess, wrapError } from './json.js';
+import { getDb } from '../db/index.js';
+import { auditTrail } from '../audit/index.js';
+import { ScanLoop } from '../scan/loop.js';
+import { createOctagonInvoker } from '../scan/invoker.js';
+import { formatScanTable } from './scan-formatters.js';
+import { callKalshiApi } from '../tools/kalshi/api.js';
+import { getBotSetting } from '../utils/bot-config.js';
+import type { ScanResult } from '../scan/loop.js';
+
+export async function handleWatch(args: ParsedArgs): Promise<void> {
+  const db = getDb();
+  const invoker = createOctagonInvoker();
+  const loop = new ScanLoop(db, auditTrail, invoker);
+
+  const rawMinInterval = Number(getBotSetting('watch.min_interval_minutes'));
+  const minIntervalMinutes = Number.isFinite(rawMinInterval) && rawMinInterval > 0 ? rawMinInterval : 15;
+  const intervalMinutes = args.live
+    ? minIntervalMinutes
+    : Math.max(minIntervalMinutes, args.interval ?? 60);
+  const intervalMs = intervalMinutes * 60_000;
+  const theme = args.theme ?? 'top50';
+
+  let totalCycles = 0;
+  let totalEdges = 0;
+  const startTime = Date.now();
+  let stopped = false;
+  let timer: ReturnType<typeof setInterval>;
+
+  const shutdown = () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(timer);
+
+    const durationSec = ((Date.now() - startTime) / 1000).toFixed(0);
+    if (args.json) {
+      console.log(JSON.stringify({
+        event: 'watch_stopped',
+        totalCycles,
+        totalEdges,
+        durationSeconds: Number(durationSec),
+      }));
+    } else {
+      console.log('');
+      console.log(`Watch stopped. ${totalCycles} cycles, ${totalEdges} edges found in ${durationSec}s`);
+    }
+    process.exit(0);
+  };
+
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+
+  if (!args.json) {
+    console.log(`Watching theme "${theme}" every ${intervalMinutes}m (Ctrl+C to stop)\n`);
+  }
+
+  const runCycle = async (): Promise<void> => {
+    try {
+      const result = await loop.runOnce({ theme, dryRun: args.dryRun });
+      totalCycles++;
+      totalEdges += result.edgeSnapshots.length;
+
+      if (args.json) {
+        const actionable = result.edgeSnapshots.filter(
+          (s) => s.confidence === 'high' || s.confidence === 'very_high'
+        ).length;
+        console.log(JSON.stringify(wrapSuccess('watch', result, {
+          scan_id: result.scanId,
+          theme,
+          events_scanned: result.eventsScanned,
+          actionable,
+          octagon_credits_used: result.octagonCreditsUsed,
+        })));
+      } else {
+        console.clear();
+        console.log(`Watch cycle #${totalCycles} — theme "${theme}" — every ${intervalMinutes}m\n`);
+        console.log(formatScanTable(result));
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (args.json) {
+        console.log(JSON.stringify(wrapError('watch', 'SCAN_ERROR', message)));
+      } else {
+        console.error(`[watch] Scan error: ${message}`);
+      }
+    }
+  };
+
+  // Run first cycle immediately
+  await runCycle();
+
+  // Continue running on interval until stopped
+  timer = setInterval(() => {
+    if (stopped) return;
+    runCycle().catch((err) => {
+      console.error(`[watch] Scan cycle failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }, intervalMs);
+
+  // Keep process alive — the SIGINT handler will exit
+  await new Promise<void>(() => {});
+}
+
+// ─── Per-ticker watch mode ──────────────────────────────────────────────────
+
+interface TickerSnapshot {
+  ticker: string;
+  lastPrice: string;
+  yesAsk: string;
+  yesBid: string;
+  noAsk: string;
+  noBid: string;
+  spread: string;
+  volume: string;
+  openInterest: string;
+  orderbook: { price: string; quantity: number }[];
+  timestamp: string;
+}
+
+function parseDollarField(val: string | number | undefined | null, isCentField = false): number {
+  if (val === undefined || val === null) return 0;
+  const n = typeof val === 'number' ? val : parseFloat(val as string);
+  if (isNaN(n)) return 0;
+  return isCentField ? n / 100 : n;
+}
+
+/** Format a value already in dollars (0.00–1.00) */
+function fmtDollars(val: number): string {
+  return `$${val.toFixed(2)}`;
+}
+
+/** Format a cent integer (1–99) as dollars */
+function fmtCents(val: number): string {
+  return `$${(val / 100).toFixed(2)}`;
+}
+
+function fmtNum(n: number | string | undefined | null): string {
+  if (n === undefined || n === null) return '-';
+  const val = typeof n === 'number' ? n : parseFloat(n as string);
+  if (isNaN(val)) return '-';
+  return val.toLocaleString();
+}
+
+async function fetchTickerSnapshot(ticker: string): Promise<TickerSnapshot> {
+  // Fetch market data
+  const market = await callKalshiApi('GET', `/markets/${ticker}`) as any;
+  const m = market.market ?? market;
+
+  const hasDollarYesAsk = m.yes_ask_dollars != null || m.dollar_yes_ask != null;
+  const hasDollarYesBid = m.yes_bid_dollars != null || m.dollar_yes_bid != null;
+  const hasDollarNoAsk = m.no_ask_dollars != null || m.dollar_no_ask != null;
+  const hasDollarNoBid = m.no_bid_dollars != null || m.dollar_no_bid != null;
+  const yesAsk = parseDollarField(m.yes_ask_dollars ?? m.dollar_yes_ask ?? m.yes_ask, !hasDollarYesAsk);
+  const yesBid = parseDollarField(m.yes_bid_dollars ?? m.dollar_yes_bid ?? m.yes_bid, !hasDollarYesBid);
+  const noAsk = parseDollarField(m.no_ask_dollars ?? m.dollar_no_ask ?? m.no_ask, !hasDollarNoAsk);
+  const noBid = parseDollarField(m.no_bid_dollars ?? m.dollar_no_bid ?? m.no_bid, !hasDollarNoBid);
+  const spread = yesAsk - yesBid;
+
+  // Fetch orderbook
+  let orderbook: { price: string; quantity: number }[] = [];
+  try {
+    const ob = await callKalshiApi('GET', `/markets/${ticker}/orderbook`) as any;
+    const book = ob.orderbook ?? ob;
+    const rawEntries = Array.isArray(book.yes) ? book.yes : [];
+    orderbook = rawEntries
+      .filter((entry: unknown): entry is [number, number] =>
+        Array.isArray(entry) && entry.length === 2 &&
+        typeof entry[0] === 'number' && typeof entry[1] === 'number'
+      )
+      .slice(0, 5)
+      .map(([price, qty]: [number, number]) => ({
+        price: fmtCents(price),
+        quantity: qty,
+      }));
+  } catch {
+    // Orderbook not available for all markets
+  }
+
+  // Resolve last price — dollar string fields are already in dollars; last_price is cents
+  const dollarLastStr = m.last_price_dollars ?? m.dollar_last_price;
+  const parsedDollarLast = dollarLastStr != null ? parseFloat(dollarLastStr) : NaN;
+  const lastPriceDollars = Number.isFinite(parsedDollarLast)
+    ? parsedDollarLast
+    : (m.last_price != null ? m.last_price / 100 : NaN);
+
+  return {
+    ticker,
+    lastPrice: Number.isFinite(lastPriceDollars) ? fmtDollars(lastPriceDollars) : '-',
+    yesAsk: fmtDollars(yesAsk),
+    yesBid: fmtDollars(yesBid),
+    noAsk: fmtDollars(noAsk),
+    noBid: fmtDollars(noBid),
+    spread: `$${spread.toFixed(4)}`,
+    volume: fmtNum(m.volume_fp ?? m.volume),
+    openInterest: fmtNum(m.open_interest_fp ?? m.open_interest),
+    orderbook,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function formatTickerDashboard(snap: TickerSnapshot, tick: number): string {
+  const lines: string[] = [];
+  lines.push(`  ${snap.ticker}  (tick #${tick})  ${new Date(snap.timestamp).toLocaleTimeString()}`);
+  lines.push('');
+  lines.push(`  Last Price:     ${snap.lastPrice}`);
+  lines.push(`  YES Bid / Ask:  ${snap.yesBid} / ${snap.yesAsk}   Spread: ${snap.spread}`);
+  lines.push(`  NO  Bid / Ask:  ${snap.noBid} / ${snap.noAsk}`);
+  lines.push(`  Volume:         ${snap.volume}   Open Interest: ${snap.openInterest}`);
+
+  if (snap.orderbook.length > 0) {
+    lines.push('');
+    lines.push('  Orderbook (YES, top 5):');
+    for (const level of snap.orderbook) {
+      lines.push(`    ${level.price}  ×${level.quantity}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export async function handleWatchTicker(ticker: string, args: ParsedArgs): Promise<void> {
+  let totalTicks = 0;
+  const startTime = Date.now();
+  let stopped = false;
+  let timer: ReturnType<typeof setInterval>;
+
+  const shutdown = () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(timer);
+
+    const durationSec = ((Date.now() - startTime) / 1000).toFixed(0);
+    if (args.json) {
+      console.log(JSON.stringify({
+        event: 'watch_stopped',
+        ticker,
+        totalTicks,
+        durationSeconds: Number(durationSec),
+      }));
+    } else {
+      console.log('');
+      console.log(`Watch stopped. ${totalTicks} ticks in ${durationSec}s`);
+    }
+    process.exit(0);
+  };
+
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+
+  const rawTickerInterval = Number(getBotSetting('watch.ticker_interval_seconds'));
+  const tickerIntervalMs = (Number.isFinite(rawTickerInterval) && rawTickerInterval > 0 ? rawTickerInterval : 5) * 1000;
+  const intervalMs = args.interval ? args.interval * 1000 : tickerIntervalMs;
+  const intervalLabel = intervalMs >= 60_000 ? `${(intervalMs / 60_000).toFixed(0)}m` : `${(intervalMs / 1000).toFixed(0)}s`;
+
+  if (!args.json) {
+    console.log(`Watching ${ticker} every ${intervalLabel} (Ctrl+C to stop)\n`);
+  }
+
+  const runTick = async (): Promise<void> => {
+    try {
+      const snap = await fetchTickerSnapshot(ticker);
+      totalTicks++;
+
+      if (args.json) {
+        console.log(JSON.stringify(wrapSuccess('watch:ticker', snap)));
+      } else {
+        console.clear();
+        console.log(formatTickerDashboard(snap, totalTicks));
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (args.json) {
+        console.log(JSON.stringify(wrapError('watch:ticker', 'FETCH_ERROR', message)));
+      } else {
+        console.error(`[watch] Error: ${message}`);
+      }
+    }
+  };
+
+  // First tick immediately
+  await runTick();
+
+  // Continue on interval
+  timer = setInterval(() => {
+    if (stopped) return;
+    runTick().catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[watch-ticker] Tick failed: ${message}`);
+    });
+  }, intervalMs);
+
+  // Keep process alive
+  await new Promise<void>(() => {});
+}

package/src/components/answer-box.ts

@@ -0,0 +1,57 @@
+import { Container, Markdown, Spacer, type TUI } from '@mariozechner/pi-tui';
+import { formatResponse } from '../utils/markdown-table.js';
+import { markdownTheme, theme } from '../theme.js';
+
+const SPINNER_FRAMES = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+const SPINNER_INTERVAL_MS = 80;
+
+export class AnswerBoxComponent extends Container {
+  private readonly body: Markdown;
+  private value = '';
+  private spinnerInterval: ReturnType<typeof setInterval> | null = null;
+  private spinnerFrame = 0;
+  private tui: TUI | null = null;
+
+  constructor(initialText = '') {
+    super();
+    this.addChild(new Spacer(1));
+    this.body = new Markdown('', 0, 0, markdownTheme, { color: (line) => line });
+    this.addChild(this.body);
+    this.setText(initialText);
+  }
+
+  setText(text: string) {
+    this.value = text;
+    this.render_();
+  }
+
+  /** Start an animated spinner prefix. Call stopSpinner() when done. */
+  startSpinner(tui: TUI) {
+    this.tui = tui;
+    this.spinnerFrame = 0;
+    if (this.spinnerInterval) return;
+    this.spinnerInterval = setInterval(() => {
+      this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
+      this.render_();
+      this.tui?.requestRender();
+    }, SPINNER_INTERVAL_MS);
+  }
+
+  /** Stop the spinner and revert to static ⏺ prefix. */
+  stopSpinner() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
+    this.render_();
+  }
+
+  private render_() {
+    const rendered = formatResponse(this.value);
+    const normalized = rendered.replace(/^\n+/, '');
+    const prefix = this.spinnerInterval
+      ? theme.primary(SPINNER_FRAMES[this.spinnerFrame])
+      : theme.primary('⏺');
+    this.body.setText(`${prefix}\n${normalized}`);
+  }
+}

package/src/components/approval-prompt.ts

@@ -0,0 +1,34 @@
+import { Container, Text } from '@mariozechner/pi-tui';
+import type { ApprovalDecision } from '../agent/types.js';
+import { createApprovalSelector } from './select-list.js';
+import { theme } from '../theme.js';
+
+function formatToolLabel(tool: string): string {
+  return tool
+    .split('_')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+export class ApprovalPromptComponent extends Container {
+  readonly selector: any;
+  onSelect?: (decision: ApprovalDecision) => void;
+
+  constructor(tool: string, args: Record<string, unknown>) {
+    super();
+    this.selector = createApprovalSelector((decision) => this.onSelect?.(decision));
+    const width = Math.max(20, process.stdout.columns ?? 80);
+    const border = theme.warning('─'.repeat(width));
+    const path = (args.path as string) || '<unknown>';
+
+    this.addChild(new Text(border, 0, 0));
+    this.addChild(new Text(theme.warning(theme.bold('Permission required')), 0, 0));
+    this.addChild(new Text(`${formatToolLabel(tool)} ${path}`, 0, 0));
+    this.addChild(new Text(theme.muted('Do you want to allow this?'), 0, 0));
+    this.addChild(new Text('', 0, 0));
+    this.addChild(this.selector);
+    this.addChild(new Text('', 0, 0));
+    this.addChild(new Text(theme.muted('Enter to confirm · esc to deny'), 0, 0));
+    this.addChild(new Text(border, 0, 0));
+  }
+}