kalshi-trading-bot-cli 2.1.0

package/src/controllers/index.ts

@@ -0,0 +1,7 @@
+export { AgentRunnerController } from './agent-runner.js';
+export type { RunQueryResult } from './agent-runner.js';
+export { InputHistoryController } from './input-history.js';
+export { ModelSelectionController } from './model-selection.js';
+export type { AppState, ModelSelectionState, SelectionState } from './model-selection.js';
+export { BrowseController } from './browse.js';
+export type { BrowseState, BrowseAppState, BrowseEventRow, BrowseMarketRow } from './browse.js';

package/src/controllers/input-history.ts

@@ -0,0 +1,76 @@
+import { LongTermChatHistory } from '../utils/long-term-chat-history.js';
+
+type ChangeListener = () => void;
+
+export class InputHistoryController {
+  private store = new LongTermChatHistory();
+  private messages: string[] = [];
+  private historyIndex = -1;
+  private onChange?: ChangeListener;
+
+  constructor(onChange?: ChangeListener) {
+    this.onChange = onChange;
+  }
+
+  async init() {
+    await this.store.load();
+    this.messages = this.store.getMessageStrings();
+    this.emitChange();
+  }
+
+  setOnChange(onChange?: ChangeListener) {
+    this.onChange = onChange;
+  }
+
+  get historyValue(): string | null {
+    return this.historyIndex === -1 ? null : (this.messages[this.historyIndex] ?? null);
+  }
+
+  getMessages(): string[] {
+    return [...this.messages];
+  }
+
+  navigateUp() {
+    if (this.messages.length === 0) {
+      return;
+    }
+    const maxIndex = this.messages.length - 1;
+    if (this.historyIndex === -1) {
+      this.historyIndex = 0;
+    } else if (this.historyIndex < maxIndex) {
+      this.historyIndex += 1;
+    }
+    this.emitChange();
+  }
+
+  navigateDown() {
+    if (this.historyIndex === -1) {
+      return;
+    }
+    if (this.historyIndex === 0) {
+      this.historyIndex = -1;
+    } else {
+      this.historyIndex -= 1;
+    }
+    this.emitChange();
+  }
+
+  resetNavigation() {
+    this.historyIndex = -1;
+    this.emitChange();
+  }
+
+  async saveMessage(message: string) {
+    await this.store.addUserMessage(message);
+    this.messages = this.store.getMessageStrings();
+    this.emitChange();
+  }
+
+  async updateAgentResponse(response: string) {
+    await this.store.updateAgentResponse(response);
+  }
+
+  private emitChange() {
+    this.onChange?.();
+  }
+}

package/src/controllers/model-selection.ts

@@ -0,0 +1,244 @@
+import { getSetting, setSetting } from '../utils/config.js';
+import { trackEvent } from '../utils/telemetry.js';
+import {
+  checkApiKeyExistsForProvider,
+  getProviderDisplayName,
+  saveApiKeyForProvider,
+} from '../utils/env.js';
+import {
+  getDefaultModelForProvider,
+  getModelsForProvider,
+  type Model,
+} from '../utils/model.js';
+import { getOllamaModels } from '../utils/ollama.js';
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from '../model/llm.js';
+import { InMemoryChatHistory } from '../utils/in-memory-chat-history.js';
+
+const SELECTION_STATES = [
+  'provider_select',
+  'model_select',
+  'model_input',
+  'api_key_confirm',
+  'api_key_input',
+] as const;
+
+export type SelectionState = (typeof SELECTION_STATES)[number];
+export type AppState = 'idle' | SelectionState;
+
+export interface ModelSelectionState {
+  appState: AppState;
+  pendingProvider: string | null;
+  pendingModels: Model[];
+}
+
+type ChangeListener = () => void;
+
+export class ModelSelectionController {
+  private providerValue: string;
+  private modelValue: string;
+  private appStateValue: AppState = 'idle';
+  private pendingProviderValue: string | null = null;
+  private pendingModelsValue: Model[] = [];
+  private pendingSelectedModelId: string | null = null;
+  private readonly onError: (message: string) => void;
+  private readonly onChange?: ChangeListener;
+  private readonly chatHistory = new InMemoryChatHistory(DEFAULT_MODEL);
+
+  constructor(onError: (message: string) => void, onChange?: ChangeListener) {
+    this.onError = onError;
+    this.onChange = onChange;
+    this.providerValue = getSetting('provider', DEFAULT_PROVIDER);
+    const savedModel = getSetting('modelId', null) as string | null;
+    this.modelValue =
+      savedModel ?? getDefaultModelForProvider(this.providerValue) ?? DEFAULT_MODEL;
+    this.chatHistory.setModel(this.modelValue);
+  }
+
+  get state(): ModelSelectionState {
+    return {
+      appState: this.appStateValue,
+      pendingProvider: this.pendingProviderValue,
+      pendingModels: this.pendingModelsValue,
+    };
+  }
+
+  get provider(): string {
+    return this.providerValue;
+  }
+
+  get model(): string {
+    return this.modelValue;
+  }
+
+  get inMemoryChatHistory(): InMemoryChatHistory {
+    return this.chatHistory;
+  }
+
+  isInSelectionFlow(): boolean {
+    return this.appStateValue !== 'idle';
+  }
+
+  startSelection() {
+    this.appStateValue = 'provider_select';
+    this.emitChange();
+  }
+
+  cancelSelection() {
+    this.resetPendingState();
+  }
+
+  async handleProviderSelect(providerId: string | null) {
+    if (!providerId) {
+      this.appStateValue = 'idle';
+      this.emitChange();
+      return;
+    }
+
+    this.pendingProviderValue = providerId;
+    if (providerId === 'openrouter') {
+      this.pendingModelsValue = [];
+      this.appStateValue = 'model_input';
+      this.emitChange();
+      return;
+    }
+
+    if (providerId === 'ollama') {
+      const ollamaModelIds = await getOllamaModels();
+      this.pendingModelsValue = ollamaModelIds.map((id) => ({ id, displayName: id }));
+      this.appStateValue = 'model_select';
+      this.emitChange();
+      return;
+    }
+
+    this.pendingModelsValue = getModelsForProvider(providerId);
+    this.appStateValue = 'model_select';
+    this.emitChange();
+  }
+
+  handleModelSelect(modelId: string | null) {
+    if (!modelId || !this.pendingProviderValue) {
+      this.pendingProviderValue = null;
+      this.pendingModelsValue = [];
+      this.pendingSelectedModelId = null;
+      this.appStateValue = 'provider_select';
+      this.emitChange();
+      return;
+    }
+
+    if (this.pendingProviderValue === 'ollama') {
+      this.completeModelSwitch(this.pendingProviderValue, `ollama:${modelId}`);
+      return;
+    }
+
+    if (checkApiKeyExistsForProvider(this.pendingProviderValue)) {
+      this.completeModelSwitch(this.pendingProviderValue, modelId);
+      return;
+    }
+
+    this.pendingSelectedModelId = modelId;
+    this.appStateValue = 'api_key_confirm';
+    this.emitChange();
+  }
+
+  handleModelInputSubmit(modelName: string | null) {
+    if (!modelName || !this.pendingProviderValue) {
+      this.pendingProviderValue = null;
+      this.pendingModelsValue = [];
+      this.pendingSelectedModelId = null;
+      this.appStateValue = 'provider_select';
+      this.emitChange();
+      return;
+    }
+
+    const fullModelId = `${this.pendingProviderValue}:${modelName}`;
+    if (checkApiKeyExistsForProvider(this.pendingProviderValue)) {
+      this.completeModelSwitch(this.pendingProviderValue, fullModelId);
+      return;
+    }
+
+    this.pendingSelectedModelId = fullModelId;
+    this.appStateValue = 'api_key_confirm';
+    this.emitChange();
+  }
+
+  handleApiKeyConfirm(wantsToSet: boolean) {
+    if (wantsToSet) {
+      this.appStateValue = 'api_key_input';
+      this.emitChange();
+      return;
+    }
+
+    if (
+      this.pendingProviderValue &&
+      this.pendingSelectedModelId &&
+      checkApiKeyExistsForProvider(this.pendingProviderValue)
+    ) {
+      this.completeModelSwitch(this.pendingProviderValue, this.pendingSelectedModelId);
+      return;
+    }
+
+    this.onError(
+      `Cannot use ${
+        this.pendingProviderValue ? getProviderDisplayName(this.pendingProviderValue) : 'provider'
+      } without an API key.`,
+    );
+    this.resetPendingState();
+  }
+
+  handleApiKeySubmit(apiKey: string | null) {
+    if (!this.pendingSelectedModelId) {
+      this.onError('No model selected.');
+      this.resetPendingState();
+      return;
+    }
+
+    if (apiKey && this.pendingProviderValue) {
+      const saved = saveApiKeyForProvider(this.pendingProviderValue, apiKey);
+      if (saved) {
+        this.completeModelSwitch(this.pendingProviderValue, this.pendingSelectedModelId);
+      } else {
+        this.onError('Failed to save API key.');
+        this.resetPendingState();
+      }
+      return;
+    }
+
+    if (
+      !apiKey &&
+      this.pendingProviderValue &&
+      checkApiKeyExistsForProvider(this.pendingProviderValue)
+    ) {
+      this.completeModelSwitch(this.pendingProviderValue, this.pendingSelectedModelId);
+      return;
+    }
+
+    this.onError('API key not set. Provider unchanged.');
+    this.resetPendingState();
+  }
+
+  private completeModelSwitch(newProvider: string, newModelId: string) {
+    trackEvent('model_change', { provider: newProvider, model: newModelId });
+    this.providerValue = newProvider;
+    this.modelValue = newModelId;
+    setSetting('provider', newProvider);
+    setSetting('modelId', newModelId);
+    this.chatHistory.setModel(newModelId);
+    this.pendingProviderValue = null;
+    this.pendingModelsValue = [];
+    this.pendingSelectedModelId = null;
+    this.appStateValue = 'idle';
+    this.emitChange();
+  }
+
+  private resetPendingState() {
+    this.pendingProviderValue = null;
+    this.pendingModelsValue = [];
+    this.pendingSelectedModelId = null;
+    this.appStateValue = 'idle';
+    this.emitChange();
+  }
+
+  private emitChange() {
+    this.onChange?.();
+  }
+}

package/src/db/alerts.ts

@@ -0,0 +1,77 @@
+import type { Database } from 'bun:sqlite';
+
+export interface Alert {
+  alert_id: string;
+  ticker?: string | null;
+  alert_type: string;
+  edge?: number | null;
+  message: string;
+  channels?: string | null;
+  status?: string | null;
+  created_at?: number | null;
+}
+
+export function createAlert(db: Database, alert: Alert): void {
+  db.prepare(`
+    INSERT INTO alerts
+      (alert_id, ticker, alert_type, edge, message, channels, status, created_at)
+    VALUES
+      ($alert_id, $ticker, $alert_type, $edge, $message, $channels, $status, $created_at)
+  `).run({
+    $alert_id: alert.alert_id,
+    $ticker: alert.ticker ?? null,
+    $alert_type: alert.alert_type,
+    $edge: alert.edge ?? null,
+    $message: alert.message,
+    $channels: alert.channels ?? null,
+    $status: alert.status ?? 'pending',
+    $created_at: alert.created_at ?? null,
+  });
+}
+
+export function getPendingAlerts(db: Database): Alert[] {
+  return db.query("SELECT * FROM alerts WHERE status = 'pending'").all() as Alert[];
+}
+
+export function markAlertSent(db: Database, alertId: string): void {
+  db.prepare("UPDATE alerts SET status = 'sent' WHERE alert_id = $id").run({
+    $id: alertId,
+  });
+}
+
+export interface AlertQueryOpts {
+  ticker?: string;
+  since?: number;
+  status?: string;
+  alertType?: string;
+  limit?: number;
+}
+
+export function getAllAlerts(db: Database, opts?: AlertQueryOpts): Alert[] {
+  const conditions: string[] = [];
+  const params: Record<string, string | number> = {};
+
+  if (opts?.ticker) {
+    conditions.push('ticker = $ticker');
+    params.$ticker = opts.ticker;
+  }
+  if (opts?.since) {
+    conditions.push('created_at >= $since');
+    params.$since = opts.since;
+  }
+  if (opts?.status) {
+    conditions.push('status = $status');
+    params.$status = opts.status;
+  }
+  if (opts?.alertType) {
+    conditions.push('alert_type = $alertType');
+    params.$alertType = opts.alertType;
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+  const limit = opts?.limit ?? 100;
+
+  return db.prepare(
+    `SELECT * FROM alerts ${where} ORDER BY created_at DESC LIMIT ${limit}`
+  ).all(params) as Alert[];
+}

package/src/db/edge.ts

@@ -0,0 +1,105 @@
+import type { Database } from 'bun:sqlite';
+
+export interface EdgeRow {
+  id?: number;
+  ticker: string;
+  event_ticker: string;
+  timestamp: number;
+  model_prob: number;
+  market_prob: number;
+  edge: number;
+  octagon_report_id?: string | null;
+  drivers_json?: string | null;
+  sources_json?: string | null;
+  catalysts_json?: string | null;
+  cache_hit?: number | null;
+  cache_miss?: number | null;
+  confidence?: string | null;
+}
+
+const CONFIDENCE_RANK: Record<string, number> = {
+  low: 0,
+  moderate: 1,
+  high: 2,
+  very_high: 3,
+};
+
+export function insertEdge(db: Database, edge: EdgeRow): void {
+  db.prepare(`
+    INSERT INTO edge_history
+      (ticker, event_ticker, timestamp, model_prob, market_prob, edge,
+       octagon_report_id, drivers_json, sources_json, catalysts_json, cache_hit, cache_miss, confidence)
+    VALUES
+      ($ticker, $event_ticker, $timestamp, $model_prob, $market_prob, $edge,
+       $octagon_report_id, $drivers_json, $sources_json, $catalysts_json, $cache_hit, $cache_miss, $confidence)
+  `).run({
+    $ticker: edge.ticker,
+    $event_ticker: edge.event_ticker,
+    $timestamp: edge.timestamp,
+    $model_prob: edge.model_prob,
+    $market_prob: edge.market_prob,
+    $edge: edge.edge,
+    $octagon_report_id: edge.octagon_report_id ?? null,
+    $drivers_json: edge.drivers_json ?? null,
+    $sources_json: edge.sources_json ?? null,
+    $catalysts_json: edge.catalysts_json ?? null,
+    $cache_hit: edge.cache_hit ?? 0,
+    $cache_miss: edge.cache_miss ?? 0,
+    $confidence: edge.confidence ?? null,
+  });
+}
+
+export function getLatestEdge(db: Database, ticker: string): EdgeRow | null {
+  return db.query(
+    'SELECT * FROM edge_history WHERE ticker = $ticker ORDER BY timestamp DESC LIMIT 1'
+  ).get({ $ticker: ticker }) as EdgeRow | null;
+}
+
+export function getEdgeHistory(db: Database, ticker: string, since: number): EdgeRow[] {
+  return db.query(
+    'SELECT * FROM edge_history WHERE ticker = $ticker AND timestamp >= $since ORDER BY timestamp ASC'
+  ).all({ $ticker: ticker, $since: since }) as EdgeRow[];
+}
+
+/**
+ * Returns the latest edge per ticker where confidence >= minConfidence.
+ * Confidence levels: low < moderate < high < very_high
+ */
+export function getActionableEdges(db: Database, minConfidence: string): EdgeRow[] {
+  const minRank = CONFIDENCE_RANK[minConfidence];
+  if (minRank === undefined) return [];
+
+  const allowedLevels = Object.entries(CONFIDENCE_RANK)
+    .filter(([, rank]) => rank >= minRank)
+    .map(([level]) => level);
+
+  // Get the latest edge per ticker, then filter to only those with qualifying confidence.
+  // This ensures we don't return stale high-confidence edges when a newer low-confidence one exists.
+  const placeholders = allowedLevels.map(() => '?').join(', ');
+  return db.query(`
+    SELECT e.* FROM edge_history e
+    INNER JOIN (
+      SELECT ticker, MAX(timestamp) as max_ts
+      FROM edge_history
+      GROUP BY ticker
+    ) latest ON e.ticker = latest.ticker AND e.timestamp = latest.max_ts
+    WHERE e.confidence IN (${placeholders})
+    ORDER BY e.timestamp DESC
+  `).all(...allowedLevels) as EdgeRow[];
+}
+
+/**
+ * Returns the latest edge per ticker where confidence is exactly the given level.
+ */
+export function getEdgesByExactConfidence(db: Database, confidence: string): EdgeRow[] {
+  return db.query(`
+    SELECT e.* FROM edge_history e
+    INNER JOIN (
+      SELECT ticker, MAX(timestamp) as max_ts
+      FROM edge_history
+      GROUP BY ticker
+    ) latest ON e.ticker = latest.ticker AND e.timestamp = latest.max_ts
+    WHERE e.confidence = ?
+    ORDER BY e.timestamp DESC
+  `).all(confidence) as EdgeRow[];
+}