kalshi-trading-bot-cli 2.1.0

package/src/db/schema.ts

@@ -0,0 +1,227 @@
+import type { Database } from 'bun:sqlite';
+
+/**
+ * Run all CREATE TABLE IF NOT EXISTS statements and indexes.
+ * Safe to call on every startup — idempotent.
+ */
+export function migrate(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS themes (
+      theme_id        TEXT PRIMARY KEY,
+      name            TEXT NOT NULL,
+      filter_query    TEXT,
+      tickers         TEXT,
+      last_resolved_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+      ticker      TEXT PRIMARY KEY,
+      category    TEXT,
+      expiry      INTEGER,
+      vol_24h     REAL,
+      theme_id    TEXT REFERENCES themes,
+      active      INTEGER DEFAULT 1,
+      updated_at  INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS edge_history (
+      id                INTEGER PRIMARY KEY AUTOINCREMENT,
+      ticker            TEXT NOT NULL,
+      event_ticker      TEXT NOT NULL,
+      timestamp         INTEGER NOT NULL,
+      model_prob        REAL NOT NULL,
+      market_prob       REAL NOT NULL,
+      edge              REAL NOT NULL,
+      octagon_report_id TEXT,
+      drivers_json      TEXT,
+      sources_json      TEXT,
+      catalysts_json    TEXT,
+      cache_hit         INTEGER,
+      cache_miss        INTEGER DEFAULT 0,
+      confidence        TEXT,
+      UNIQUE(ticker, timestamp)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_edge_ticker_ts
+      ON edge_history(ticker, timestamp DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_edge_confidence
+      ON edge_history(confidence, timestamp DESC);
+
+    CREATE TABLE IF NOT EXISTS octagon_reports (
+      report_id                TEXT PRIMARY KEY,
+      ticker                   TEXT NOT NULL,
+      event_ticker             TEXT NOT NULL,
+      model_prob               REAL NOT NULL,
+      market_prob              REAL,
+      mispricing_signal        TEXT,
+      drivers_json             TEXT,
+      catalysts_json           TEXT,
+      sources_json             TEXT,
+      resolution_history_json  TEXT,
+      contract_snapshot_json   TEXT,
+      raw_response             TEXT,
+      model_accuracy           REAL,
+      variant_used             TEXT,
+      fetched_at               INTEGER NOT NULL,
+      expires_at               INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_octagon_ticker
+      ON octagon_reports(ticker, fetched_at DESC);
+
+    CREATE TABLE IF NOT EXISTS positions (
+      position_id  TEXT PRIMARY KEY,
+      ticker       TEXT NOT NULL,
+      event_ticker TEXT NOT NULL,
+      direction    TEXT NOT NULL,
+      size         REAL NOT NULL,
+      entry_price  REAL NOT NULL,
+      entry_edge   REAL,
+      entry_kelly  REAL,
+      current_pnl  REAL DEFAULT 0,
+      status       TEXT DEFAULT 'open',
+      opened_at    INTEGER,
+      closed_at    INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS trades (
+      trade_id     TEXT PRIMARY KEY,
+      position_id  TEXT REFERENCES positions,
+      order_id     TEXT,
+      ticker       TEXT NOT NULL,
+      action       TEXT NOT NULL,
+      side         TEXT NOT NULL,
+      size         REAL NOT NULL,
+      price        REAL NOT NULL,
+      fill_status  TEXT,
+      kalshi_response TEXT,
+      created_at   INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS risk_snapshots (
+      id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp           INTEGER NOT NULL,
+      cash_balance        REAL,
+      portfolio_value     REAL,
+      open_exposure       REAL,
+      available_bankroll  REAL,
+      daily_pnl           REAL,
+      drawdown_current    REAL,
+      drawdown_max        REAL,
+      correlation_max     REAL,
+      positions_count     INTEGER,
+      circuit_breaker_on  INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS alerts (
+      alert_id    TEXT PRIMARY KEY,
+      ticker      TEXT,
+      alert_type  TEXT NOT NULL,
+      edge        REAL,
+      message     TEXT NOT NULL,
+      channels    TEXT,
+      status      TEXT DEFAULT 'pending',
+      created_at  INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS brier_scores (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      ticker          TEXT NOT NULL,
+      event_ticker    TEXT NOT NULL,
+      category        TEXT NOT NULL,
+      model_prob      REAL NOT NULL,
+      actual_outcome  INTEGER NOT NULL,
+      brier_score     REAL NOT NULL,
+      settled_at      INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_brier_category
+      ON brier_scores(category, settled_at DESC);
+
+    CREATE TABLE IF NOT EXISTS event_index (
+      event_ticker   TEXT PRIMARY KEY,
+      series_ticker  TEXT,
+      title          TEXT NOT NULL,
+      category       TEXT,
+      strike_date    TEXT,
+      sub_title      TEXT,
+      tags           TEXT,
+      markets_json   TEXT,
+      indexed_at     INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_event_index_title
+      ON event_index(title);
+    CREATE INDEX IF NOT EXISTS idx_event_index_series
+      ON event_index(series_ticker);
+    CREATE INDEX IF NOT EXISTS idx_event_index_category
+      ON event_index(category);
+
+    CREATE TABLE IF NOT EXISTS event_index_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS octagon_history (
+      id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+      history_id          INTEGER NOT NULL,
+      event_ticker        TEXT NOT NULL,
+      captured_at         TEXT NOT NULL,
+      model_probability   REAL NOT NULL,
+      market_probability  REAL NOT NULL,
+      edge_pp             REAL,
+      confidence_score    REAL,
+      series_category     TEXT,
+      close_time          TEXT,
+      name                TEXT,
+      outcome_probabilities_json TEXT,
+      UNIQUE(event_ticker, history_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_history_event
+      ON octagon_history(event_ticker, captured_at);
+  `);
+
+  // Schema migrations for columns added after initial release
+  const edgeCols = db.query(`PRAGMA table_info(edge_history)`).all() as Array<{ name: string }>;
+  if (!edgeCols.some((c) => c.name === 'cache_miss')) {
+    db.exec(`ALTER TABLE edge_history ADD COLUMN cache_miss INTEGER DEFAULT 0`);
+  }
+
+  const reportCols = db.query(`PRAGMA table_info(octagon_reports)`).all() as Array<{ name: string }>;
+  if (!reportCols.some((c) => c.name === 'raw_response')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN raw_response TEXT`);
+  }
+
+  const eventIndexCols = db.query(`PRAGMA table_info(event_index)`).all() as Array<{ name: string }>;
+  if (!eventIndexCols.some((c) => c.name === 'tags')) {
+    db.exec(`ALTER TABLE event_index ADD COLUMN tags TEXT`);
+    // Force re-index so tags get populated on next ensureIndex() call
+    db.exec(`DELETE FROM event_index_meta WHERE key = 'last_refresh'`);
+  }
+
+  if (!reportCols.some((c) => c.name === 'has_history')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN has_history INTEGER DEFAULT 0`);
+  }
+  if (!reportCols.some((c) => c.name === 'mutually_exclusive')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN mutually_exclusive INTEGER DEFAULT 0`);
+  }
+  if (!reportCols.some((c) => c.name === 'series_category')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN series_category TEXT`);
+  }
+  if (!reportCols.some((c) => c.name === 'confidence_score')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN confidence_score REAL`);
+  }
+  if (!reportCols.some((c) => c.name === 'outcome_probabilities_json')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN outcome_probabilities_json TEXT`);
+  }
+  if (!reportCols.some((c) => c.name === 'close_time')) {
+    db.exec(`ALTER TABLE octagon_reports ADD COLUMN close_time TEXT`);
+  }
+
+  const historyCols = db.query(`PRAGMA table_info(octagon_history)`).all() as Array<{ name: string }>;
+  if (!historyCols.some((c) => c.name === 'outcome_probabilities_json')) {
+    db.exec(`ALTER TABLE octagon_history ADD COLUMN outcome_probabilities_json TEXT`);
+  }
+}

package/src/db/themes.ts

@@ -0,0 +1,34 @@
+import type { Database } from 'bun:sqlite';
+
+export interface Theme {
+  theme_id: string;
+  name: string;
+  filter_query?: string | null;
+  tickers?: string | null;
+  last_resolved_at?: number | null;
+}
+
+export function upsertTheme(db: Database, theme: Theme): void {
+  db.prepare(`
+    INSERT OR REPLACE INTO themes (theme_id, name, filter_query, tickers, last_resolved_at)
+    VALUES ($theme_id, $name, $filter_query, $tickers, $last_resolved_at)
+  `).run({
+    $theme_id: theme.theme_id,
+    $name: theme.name,
+    $filter_query: theme.filter_query ?? null,
+    $tickers: theme.tickers ?? null,
+    $last_resolved_at: theme.last_resolved_at ?? null,
+  });
+}
+
+export function getActiveThemes(db: Database): Theme[] {
+  return db.query('SELECT * FROM themes').all() as Theme[];
+}
+
+export function getThemeTickers(db: Database, themeId: string): string[] {
+  const row = db.query('SELECT tickers FROM themes WHERE theme_id = $id').get({
+    $id: themeId,
+  }) as { tickers: string | null } | null;
+  if (!row?.tickers) return [];
+  return JSON.parse(row.tickers) as string[];
+}

package/src/db/trades.ts

@@ -0,0 +1,50 @@
+import type { Database } from 'bun:sqlite';
+
+export interface Trade {
+  trade_id: string;
+  position_id?: string | null;
+  order_id?: string | null;
+  ticker: string;
+  action: string;
+  side: string;
+  size: number;
+  price: number;
+  fill_status?: string | null;
+  kalshi_response?: string | null;
+  created_at?: number | null;
+}
+
+export function logTrade(db: Database, trade: Trade): void {
+  db.prepare(`
+    INSERT INTO trades
+      (trade_id, position_id, order_id, ticker, action, side, size, price,
+       fill_status, kalshi_response, created_at)
+    VALUES
+      ($trade_id, $position_id, $order_id, $ticker, $action, $side, $size, $price,
+       $fill_status, $kalshi_response, $created_at)
+  `).run({
+    $trade_id: trade.trade_id,
+    $position_id: trade.position_id ?? null,
+    $order_id: trade.order_id ?? null,
+    $ticker: trade.ticker,
+    $action: trade.action,
+    $side: trade.side,
+    $size: trade.size,
+    $price: trade.price,
+    $fill_status: trade.fill_status ?? null,
+    $kalshi_response: trade.kalshi_response ?? null,
+    $created_at: trade.created_at ?? null,
+  });
+}
+
+export function getTradesForPosition(db: Database, positionId: string): Trade[] {
+  return db.query('SELECT * FROM trades WHERE position_id = $id').all({
+    $id: positionId,
+  }) as Trade[];
+}
+
+export function getRecentTrades(db: Database, limit: number): Trade[] {
+  return db.query('SELECT * FROM trades ORDER BY created_at DESC LIMIT $limit').all({
+    $limit: limit,
+  }) as Trade[];
+}

package/src/eval/brier.ts

@@ -0,0 +1,90 @@
+import type { Database } from 'bun:sqlite';
+import { auditTrail } from '../audit/index.js';
+
+/**
+ * Pure Brier score: (forecast - outcome)²
+ */
+export function computeBrier(modelProb: number, actualOutcome: 0 | 1): number {
+  return (modelProb - actualOutcome) ** 2;
+}
+
+export interface SettlementResult {
+  brierScore: number;
+  isUnderperforming: boolean;
+}
+
+/**
+ * Record a market settlement: compute Brier score from the latest edge_history
+ * row for the ticker, persist to brier_scores, and flag underperforming categories.
+ */
+export function recordSettlement(
+  ticker: string,
+  actualOutcome: 0 | 1,
+  db: Database,
+): SettlementResult {
+  const edge = db.query(
+    'SELECT * FROM edge_history WHERE ticker = $ticker ORDER BY timestamp DESC LIMIT 1',
+  ).get({ $ticker: ticker }) as {
+    event_ticker: string;
+    model_prob: number;
+  } | null;
+
+  if (!edge) {
+    throw new Error(`No edge_history found for ticker: ${ticker}`);
+  }
+
+  const eventTicker = edge.event_ticker;
+  const category = eventTicker.split('-')[0] ?? 'unknown';
+  const brierScore = computeBrier(edge.model_prob, actualOutcome);
+
+  db.prepare(`
+    INSERT INTO brier_scores (ticker, event_ticker, category, model_prob, actual_outcome, brier_score, settled_at)
+    VALUES ($ticker, $event_ticker, $category, $model_prob, $actual_outcome, $brier_score, $settled_at)
+  `).run({
+    $ticker: ticker,
+    $event_ticker: eventTicker,
+    $category: category,
+    $model_prob: edge.model_prob,
+    $actual_outcome: actualOutcome,
+    $brier_score: brierScore,
+    $settled_at: Date.now(),
+  });
+
+  const accuracy = getCategoryAccuracy(category, db);
+
+  if (accuracy.isUnderperforming) {
+    auditTrail.log({
+      type: 'CONFIG_CHANGE',
+      category,
+      avg_brier: accuracy.avgBrier,
+      trigger: 'auto_calibration',
+      recommendation: `Category "${category}" avg Brier ${accuracy.avgBrier.toFixed(3)} > 0.30 threshold — review model inputs`,
+    });
+  }
+
+  return { brierScore, isUnderperforming: accuracy.isUnderperforming };
+}
+
+export interface CategoryAccuracy {
+  avgBrier: number;
+  count: number;
+  isUnderperforming: boolean;
+}
+
+/**
+ * Aggregate Brier score stats for a category.
+ */
+export function getCategoryAccuracy(category: string, db: Database): CategoryAccuracy {
+  const row = db.query(
+    'SELECT AVG(brier_score) as avg_brier, COUNT(*) as count FROM brier_scores WHERE category = $category',
+  ).get({ $category: category }) as { avg_brier: number | null; count: number };
+
+  const avgBrier = row.avg_brier ?? 0;
+  const count = row.count;
+
+  return {
+    avgBrier,
+    count,
+    isUnderperforming: avgBrier > 0.30,
+  };
+}

package/src/eval/index.ts

@@ -0,0 +1,4 @@
+export { computeBrier, recordSettlement, getCategoryAccuracy } from './brier.js';
+export type { SettlementResult, CategoryAccuracy } from './brier.js';
+export { computePerformance } from './performance.js';
+export type { PerformanceStats } from './performance.js';

package/src/eval/performance.ts

@@ -0,0 +1,87 @@
+import type { Database } from 'bun:sqlite';
+
+export interface PerformanceStats {
+  sharpeRatio: number | null;
+  winRate: number | null;
+  totalPnl: number;
+  brierByCategory: Record<string, number>;
+  pnlByCategory: Record<string, number>;
+  underperformingCategories: string[];
+}
+
+export function computePerformance(db: Database): PerformanceStats {
+  // Closed positions for win rate / P&L
+  const closedPositions = db.query(
+    "SELECT * FROM positions WHERE status = 'closed'",
+  ).all() as Array<{ current_pnl: number | null; event_ticker: string }>;
+
+  const wins = closedPositions.filter((p) => (p.current_pnl ?? 0) > 0).length;
+  const winRate = closedPositions.length > 0 ? wins / closedPositions.length : null;
+  const totalPnl = closedPositions.reduce((sum, p) => sum + (p.current_pnl ?? 0), 0);
+
+  // P&L by category
+  const pnlByCategory: Record<string, number> = {};
+  for (const p of closedPositions) {
+    const cat = p.event_ticker.split('-')[0] ?? 'unknown';
+    pnlByCategory[cat] = (pnlByCategory[cat] ?? 0) + (p.current_pnl ?? 0);
+  }
+
+  // Sharpe from risk snapshots
+  const snapshots = db.query(
+    'SELECT daily_pnl FROM risk_snapshots WHERE daily_pnl IS NOT NULL ORDER BY timestamp ASC',
+  ).all() as Array<{ daily_pnl: number }>;
+
+  let sharpeRatio: number | null = null;
+  if (snapshots.length >= 2) {
+    const pnls = snapshots.map((s) => s.daily_pnl);
+    const mean = pnls.reduce((a, b) => a + b, 0) / pnls.length;
+    const variance = pnls.reduce((sum, p) => sum + (p - mean) ** 2, 0) / pnls.length;
+    const std = Math.sqrt(variance);
+    if (std > 0) {
+      sharpeRatio = (mean / std) * Math.sqrt(252); // annualized
+    }
+  }
+
+  // Brier scores by category — prefer brier_scores table, fall back to edge_history proxy
+  const brierByCategory: Record<string, number> = {};
+  const underperformingCategories: string[] = [];
+
+  const brierRows = db.query(
+    'SELECT category, AVG(brier_score) as avg_brier FROM brier_scores GROUP BY category',
+  ).all() as Array<{ category: string; avg_brier: number }>;
+
+  if (brierRows.length > 0) {
+    for (const row of brierRows) {
+      brierByCategory[row.category] = Math.round(row.avg_brier * 1000) / 1000;
+      if (row.avg_brier > 0.30) {
+        underperformingCategories.push(row.category);
+      }
+    }
+  } else {
+    // Fallback: derive from edge_history + positions (P&L proxy)
+    const resolvedEdges = db.query(`
+      SELECT eh.model_prob, eh.event_ticker, p.current_pnl
+      FROM edge_history eh
+      JOIN positions p ON eh.ticker = p.ticker
+      WHERE p.status = 'closed'
+    `).all() as Array<{ model_prob: number; event_ticker: string; current_pnl: number }>;
+
+    const catGroups: Record<string, Array<{ modelProb: number; outcome: number }>> = {};
+    for (const row of resolvedEdges) {
+      const cat = row.event_ticker.split('-')[0] ?? 'unknown';
+      if (!catGroups[cat]) catGroups[cat] = [];
+      const outcome = (row.current_pnl ?? 0) > 0 ? 1 : 0;
+      catGroups[cat].push({ modelProb: row.model_prob, outcome });
+    }
+
+    for (const [cat, entries] of Object.entries(catGroups)) {
+      const brier = entries.reduce((sum, e) => sum + (e.modelProb - e.outcome) ** 2, 0) / entries.length;
+      brierByCategory[cat] = Math.round(brier * 1000) / 1000;
+      if (brier > 0.30) {
+        underperformingCategories.push(cat);
+      }
+    }
+  }
+
+  return { sharpeRatio, winRate, totalPnl, brierByCategory, pnlByCategory, underperformingCategories };
+}