kalshi-trading-bot-cli 2.1.2 → 2.1.4

package/src/db/event-index.ts

@@ -17,8 +17,18 @@ export interface IndexedEvent {
  * Search the local event index using keyword matching.
  * All keywords must match against title, event_ticker, series_ticker, or category.
  * Returns up to `limit` results.
+ *
+ * By default, only events with at least one active (open/active status, not past
+ * close_time) market are returned, and expired markets are stripped from each
+ * event's `markets_json`. Pass `{ includeExpired: true }` to disable both filters.
  */
-export function searchEventIndex(db: Database, query: string, limit = 50): IndexedEvent[] {
+export function searchEventIndex(
+  db: Database,
+  query: string,
+  limit = 50,
+  options: { includeExpired?: boolean } = {},
+): IndexedEvent[] {
+  const { includeExpired = false } = options;
   const keywords = query
     .toLowerCase()
     .split(/\s+/)
@@ -30,11 +40,21 @@ export function searchEventIndex(db: Database, query: string, limit = 50): Index
   const conditions = keywords.map((_, i) => `(search_text LIKE $kw${i})`);
   const whereClause = conditions.join(' AND ');
 
-  const params: Record<string, string | number> = { $limit: limit, $now: new Date().toISOString() };
+  const now = new Date().toISOString();
+  const params: Record<string, string | number> = { $limit: limit, $now: now };
   keywords.forEach((kw, i) => {
     params[`$kw${i}`] = `%${kw}%`;
   });
 
+  // Require at least one active market unless caller opts in to expired events.
+  const activeMarketsClause = includeExpired
+    ? ''
+    : `AND EXISTS (
+        SELECT 1 FROM json_each(markets_json)
+        WHERE json_extract(value, '$.status') IN ('open','active')
+          AND (json_extract(value, '$.close_time') IS NULL OR json_extract(value, '$.close_time') > $now)
+      )`;
+
   // Use a CTE to compute search_text, filter expired markets, and rank by open-market volume descending
   const fullSql = `
     WITH indexed AS (
@@ -46,6 +66,7 @@ export function searchEventIndex(db: Database, query: string, limit = 50): Index
       SELECT event_ticker, series_ticker, title, category, strike_date, sub_title, tags, markets_json, indexed_at
       FROM indexed
       WHERE ${whereClause}
+        ${activeMarketsClause}
     )
     SELECT *
     FROM matched
@@ -62,7 +83,62 @@ export function searchEventIndex(db: Database, query: string, limit = 50): Index
     LIMIT $limit
   `;
 
-  return db.query(fullSql).all(params) as IndexedEvent[];
+  const rows = db.query(fullSql).all(params) as IndexedEvent[];
+  if (includeExpired) return rows;
+
+  // Strip expired markets from each event's markets_json so callers never see them.
+  return rows.map((r) => ({
+    ...r,
+    markets_json: filterActiveMarketsJson(r.markets_json, now),
+  }));
+}
+
+/**
+ * Predicate shared by every call site that filters expired markets.
+ * "Active" means status in ('open','active') AND (no close_time or close_time > now).
+ */
+function isActiveMarketRecord(record: Record<string, unknown>, nowIso: string): boolean {
+  const status = record.status;
+  if (status !== 'open' && status !== 'active') return false;
+  const closeTime = record.close_time;
+  if (closeTime != null && typeof closeTime === 'string' && closeTime <= nowIso) return false;
+  return true;
+}
+
+/**
+ * Parse markets_json from the index into an array of object records.
+ * Returns [] on parse failure or non-array payloads, and drops any non-object entries.
+ */
+function parseMarketsJsonSafe(markets_json: string | null): Array<Record<string, unknown>> {
+  if (!markets_json) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(markets_json);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((m): m is Record<string, unknown> => typeof m === 'object' && m !== null);
+}
+
+/**
+ * Parse markets_json, drop markets that aren't currently active, and re-serialize.
+ * Returns the original string on parse failure (so callers don't lose data they could re-parse).
+ */
+function filterActiveMarketsJson(markets_json: string | null, nowIso: string): string | null {
+  if (!markets_json) return markets_json;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(markets_json);
+  } catch {
+    return markets_json;
+  }
+  if (!Array.isArray(parsed)) return markets_json;
+  const active = parsed.filter(
+    (m): m is Record<string, unknown> =>
+      typeof m === 'object' && m !== null && isActiveMarketRecord(m as Record<string, unknown>, nowIso),
+  );
+  return JSON.stringify(active);
 }
 
 /**
@@ -235,10 +311,20 @@ export function setLastRefresh(db: Database, timestamp: number): void {
 /**
  * Reconstruct KalshiEvent[] from the local index for given event tickers.
  * Parses markets_json back into nested market objects.
+ *
+ * By default, expired markets (status not open/active, or past close_time) are
+ * stripped from each event. Pass `{ includeExpired: true }` to keep them.
  */
-export function getEventsFromIndex(db: Database, eventTickers: string[]): KalshiEvent[] {
+export function getEventsFromIndex(
+  db: Database,
+  eventTickers: string[],
+  options: { includeExpired?: boolean } = {},
+): KalshiEvent[] {
   if (eventTickers.length === 0) return [];
 
+  const { includeExpired = false } = options;
+  const nowIso = new Date().toISOString();
+
   const placeholders = eventTickers.map(() => '?').join(',');
   const rows = db
     .query(
@@ -248,25 +334,22 @@ export function getEventsFromIndex(db: Database, eventTickers: string[]): Kalshi
     )
     .all(...eventTickers) as IndexedEvent[];
 
-  return rows
-    .map((r) => {
-      let markets: unknown[] = [];
-      try {
-        markets = r.markets_json ? JSON.parse(r.markets_json) : [];
-      } catch {
-        // Corrupted markets_json — skip markets for this event
-      }
-      return {
-        event_ticker: r.event_ticker,
-        series_ticker: r.series_ticker ?? '',
-        title: r.title,
-        category: r.category ?? '',
-        sub_title: r.sub_title ?? '',
-        strike_date: r.strike_date ?? '',
-        mutually_exclusive: false,
-        markets,
-      } as KalshiEvent;
-    });
+  return rows.map((r) => {
+    let markets = parseMarketsJsonSafe(r.markets_json);
+    if (!includeExpired) {
+      markets = markets.filter((m) => isActiveMarketRecord(m, nowIso));
+    }
+    return {
+      event_ticker: r.event_ticker,
+      series_ticker: r.series_ticker ?? '',
+      title: r.title,
+      category: r.category ?? '',
+      sub_title: r.sub_title ?? '',
+      strike_date: r.strike_date ?? '',
+      mutually_exclusive: false,
+      markets: markets as unknown as KalshiMarket[],
+    } as KalshiEvent;
+  });
 }
 
 /**
@@ -284,14 +367,9 @@ export function getTopEventsByVolume(db: Database, limit: number): KalshiEvent[]
 
   const events: Array<{ event: KalshiEvent; totalVolume: number }> = [];
   for (const r of rows) {
-    let markets: any[] = [];
-    try {
-      markets = r.markets_json ? JSON.parse(r.markets_json) : [];
-    } catch {
-      // Corrupted markets_json — treat as no markets
-    }
+    const markets = parseMarketsJsonSafe(r.markets_json);
     const totalVolume = markets.reduce(
-      (sum: number, m: any) => sum + (parseFloat(m.volume) || parseFloat(m.volume_fp) || 0),
+      (sum, m) => sum + (parseFloat(String(m.volume ?? '')) || parseFloat(String(m.volume_fp ?? '')) || 0),
       0,
     );
     events.push({
@@ -303,7 +381,7 @@ export function getTopEventsByVolume(db: Database, limit: number): KalshiEvent[]
         sub_title: r.sub_title ?? '',
         strike_date: r.strike_date ?? '',
         mutually_exclusive: false,
-        markets,
+        markets: markets as unknown as KalshiMarket[],
       } as KalshiEvent,
       totalVolume,
     });

package/src/db/schema.ts

@@ -181,6 +181,24 @@ export function migrate(db: Database): void {
 
     CREATE INDEX IF NOT EXISTS idx_history_event
       ON octagon_history(event_ticker, captured_at);
+
+    CREATE TABLE IF NOT EXISTS editorial_themes (
+      name           TEXT PRIMARY KEY,
+      description    TEXT,
+      search_volume  INTEGER,
+      created_at     INTEGER NOT NULL,
+      updated_at     INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS editorial_theme_series (
+      theme_name     TEXT NOT NULL,
+      series_ticker  TEXT NOT NULL,
+      PRIMARY KEY (theme_name, series_ticker),
+      FOREIGN KEY (theme_name) REFERENCES editorial_themes(name) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ets_series
+      ON editorial_theme_series(series_ticker);
   `);
 
   // Schema migrations for columns added after initial release

package/src/gateway/commands/handler.ts

@@ -23,8 +23,12 @@ function makeArgs(overrides: Partial<ParsedArgs>): ParsedArgs {
     performance: false,
     resolved: false,
     unresolved: false,
-
-
+    behavioral: false,
+    ranked: false,
+    showCluster: false,
+    activeOnly: false,
+    cells: false,
+    autoProbs: false,
     parseErrors: [],
     ...overrides,
   };

package/src/model/llm.ts

@@ -9,11 +9,11 @@ import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { StructuredToolInterface } from '@langchain/core/tools';
 import { Runnable } from '@langchain/core/runnables';
 import { z } from 'zod';
-import { DEFAULT_SYSTEM_PROMPT } from '@/agent/prompts';
-import type { TokenUsage } from '@/agent/types';
-import { logger } from '@/utils';
-import { classifyError, isNonRetryableError } from '@/utils/errors';
-import { resolveProvider, getProviderById } from '@/providers';
+import { DEFAULT_SYSTEM_PROMPT } from '../agent/prompts.js';
+import type { TokenUsage } from '../agent/types.js';
+import { logger } from '../utils/index.js';
+import { classifyError, isNonRetryableError } from '../utils/errors.js';
+import { resolveProvider, getProviderById } from '../providers.js';
 
 export const DEFAULT_PROVIDER = 'openai';
 export const DEFAULT_MODEL = process.env.DEFAULT_MODEL ?? 'gpt-5.4';

package/src/scan/octagon-events-api.ts

@@ -48,6 +48,61 @@ const EVENTS_API_BASE = 'https://api.octagonai.co/v1';
 const PAGE_LIMIT = 200;
 const TIMEOUT_MS = 60_000;
 
+/**
+ * Fetch a single page of events with optional filters. Useful for CLI commands
+ * that don't need the full universe — e.g. `events list --limit 50`.
+ */
+export async function fetchOctagonEventsPage(opts?: {
+  limit?: number;
+  cursor?: string | null;
+  hasHistory?: boolean;
+}): Promise<{ data: OctagonEventEntry[]; next_cursor: string | null; has_more: boolean }> {
+  const apiKey = process.env.OCTAGON_API_KEY;
+  if (!apiKey) throw new Error('OCTAGON_API_KEY not set');
+
+  const params = new URLSearchParams({ limit: String(opts?.limit ?? PAGE_LIMIT) });
+  if (opts?.hasHistory) params.set('has_history', 'true');
+  if (opts?.cursor) params.set('cursor', opts.cursor);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  let resp: Response;
+  try {
+    resp = await fetch(`${EVENTS_API_BASE}/prediction-markets/events?${params}`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal,
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => '');
+    throw new Error(`Octagon events API ${resp.status}: ${body.slice(0, 200)}`);
+  }
+  const page = (await resp.json()) as { data?: OctagonEventEntry[]; next_cursor?: string | null; has_more?: boolean };
+  return {
+    data: Array.isArray(page.data) ? page.data : [],
+    next_cursor: page.next_cursor ?? null,
+    has_more: !!page.has_more,
+  };
+}
+
+/**
+ * Look up a single event by ticker. Scans pages until found (universe is small).
+ * Returns null if not found.
+ */
+export async function fetchOctagonEventByTicker(eventTicker: string): Promise<OctagonEventEntry | null> {
+  let cursor: string | null = null;
+  do {
+    const page: { data: OctagonEventEntry[]; next_cursor: string | null; has_more: boolean } =
+      await fetchOctagonEventsPage({ cursor });
+    const hit = page.data.find((e) => e.event_ticker === eventTicker);
+    if (hit) return hit;
+    cursor = page.has_more ? page.next_cursor : null;
+  } while (cursor);
+  return null;
+}
+
 /**
  * Fetch all events from the Octagon Prediction Markets Events API,
  * paginating through all pages.