kalshi-trading-bot-cli 2.1.0

package/src/components/browse-list.ts

@@ -0,0 +1,134 @@
+import { Container, Text, type SelectItem } from '@mariozechner/pi-tui';
+import { VimSelectList } from './select-list.js';
+import { selectListTheme, theme } from '../theme.js';
+import type { BrowseEventRow, BrowseMarketRow } from '../controllers/browse.js';
+
+function pad(s: string, len: number): string {
+  return s.length > len ? s.slice(0, len - 1) + '…' : s.padEnd(len);
+}
+
+function fmtPct(val: number | null): string {
+  if (val === null) return '--';
+  return `${(val * 100).toFixed(1)}%`;
+}
+
+function buildMarketItems(events: BrowseEventRow[]): SelectItem[] {
+  const items: SelectItem[] = [];
+  for (const ev of events) {
+    for (const m of ev.markets) {
+      const ticker = pad(m.ticker, 20);
+      const title = pad(m.title, 48);
+      const mktPct = pad(fmtPct(m.marketProb), 7);
+      const isPending = ev.pending === true;
+      const modelPct = pad(isPending && m.modelProb === null ? '...' : fmtPct(m.modelProb), 7);
+      const edgeStr = pad(isPending && m.edge === null ? '...' : (m.edge !== null ? `${m.edge > 0 ? '+' : ''}${(m.edge * 100).toFixed(1)}%` : '--'), 7);
+      const conf = pad(isPending && m.confidence === null ? 'pending' : (m.confidence ?? '--'), 8);
+
+      items.push({
+        value: JSON.stringify({ eventTicker: ev.eventTicker, marketTicker: m.ticker }),
+        label: `${ticker} ${title} ${mktPct} ${modelPct} ${edgeStr} ${conf}`,
+      });
+    }
+  }
+  return items;
+}
+
+/** Update an existing browse selector's item labels in-place (preserves scroll/selection). */
+export function updateBrowseMarketSelector(
+  container: Container,
+  events: BrowseEventRow[],
+): void {
+  const list = (container as any)._browseList as VimSelectList | undefined;
+  if (!list) return;
+  const newItems = buildMarketItems(events);
+  // Access private arrays via any cast to update labels without recreating the list
+  const items = (list as any).items as SelectItem[];
+  const filtered = (list as any).filteredItems as SelectItem[];
+  for (let i = 0; i < items.length && i < newItems.length; i++) {
+    items[i].label = newItems[i].label;
+  }
+  for (let i = 0; i < filtered.length && i < newItems.length; i++) {
+    filtered[i].label = newItems[i].label;
+  }
+}
+
+export function createBrowseMarketSelector(
+  events: BrowseEventRow[],
+  onSelect: (eventTicker: string, marketTicker: string) => void,
+  onCancel: () => void,
+  errorMessage?: string | null,
+  progressMessage?: string | null,
+): Container {
+  const items = buildMarketItems(events);
+
+  const container = new Container();
+
+  // Progress message (shown above header)
+  if (progressMessage) {
+    container.addChild(new Text(theme.muted(progressMessage), 0, 0));
+  }
+
+  // Error message (shown above header so it's always visible)
+  if (errorMessage) {
+    container.addChild(new Text(theme.bold(theme.warning(errorMessage)), 0, 0));
+  }
+
+  // Header row
+  const header = `${pad('Ticker', 20)} ${pad('Title', 48)} ${pad('Mkt %', 7)} ${pad('Model%', 7)} ${pad('Edge', 7)} ${pad('Conf', 8)}`;
+  container.addChild(new Text(theme.muted(header), 0, 0));
+
+  if (items.length === 0) {
+    container.addChild(new Text(theme.muted('No markets found.'), 0, 0));
+    container.addChild(new Text(theme.muted('esc to go back'), 0, 0));
+    return container;
+  }
+
+  const list = new VimSelectList(items, Math.min(items.length, 20), selectListTheme);
+  list.onSelect = (item) => {
+    let parsed: { eventTicker: string; marketTicker: string };
+    try {
+      parsed = JSON.parse(item.value);
+    } catch {
+      return;
+    }
+    onSelect(parsed.eventTicker, parsed.marketTicker);
+  };
+  list.onCancel = () => onCancel();
+  container.addChild(list);
+
+  // Store list reference for focus
+  (container as any)._browseList = list;
+
+  return container;
+}
+
+export function createBrowseActionSelector(
+  onSelect: (action: string) => void,
+  onCancel: () => void,
+  hasReport = true,
+  directMode = false,
+): Container {
+  const items: SelectItem[] = [];
+  let n = 1;
+  if (hasReport) {
+    items.push({ value: 'view_report', label: `${n++}. View research report` });
+  } else {
+    items.push({ value: 'no_report', label: theme.muted(`${n++}. No cached report available`) });
+  }
+  items.push({ value: 'refresh', label: `${n++}. Refresh this research report (costs credits)` });
+  if (!directMode) {
+    items.push({ value: 'refresh_all', label: `${n++}. Refresh all research reports for this theme (costs credits)` });
+  }
+  items.push({ value: 'trade', label: `${n++}. Make a trade` });
+  items.push({ value: 'back', label: `${n++}. Back` });
+
+  const list = new VimSelectList(items, items.length, selectListTheme);
+  list.onSelect = (item) => onSelect(item.value);
+  list.onCancel = () => onCancel();
+
+  const container = new Container();
+  container.addChild(list);
+  (container as any)._browseList = list;
+
+  return container;
+}

package/src/components/chat-log.ts

@@ -0,0 +1,291 @@
+import { Container, Spacer, Text, type TUI } from '@mariozechner/pi-tui';
+import type { TokenUsage } from '../agent/types.js';
+import { theme } from '../theme.js';
+import { AnswerBoxComponent } from './answer-box.js';
+import { ToolEventComponent } from './tool-event.js';
+import { UserQueryComponent } from './user-query.js';
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return `${Math.round(ms)}ms`;
+  }
+  const totalSeconds = Math.round(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0) {
+    return `${seconds}s`;
+  }
+  return `${minutes}m ${seconds}s`;
+}
+
+function truncateUrl(url: string, maxLen = 45): string {
+  try {
+    const parsed = new URL(url);
+    const display = parsed.hostname + parsed.pathname;
+    return display.length <= maxLen ? display : `${display.slice(0, maxLen)}...`;
+  } catch {
+    return url.length > maxLen ? `${url.slice(0, maxLen)}...` : url;
+  }
+}
+
+function formatBrowserStep(args: Record<string, unknown>): string | null {
+  const action = args.action as string | undefined;
+  const url = args.url as string | undefined;
+  switch (action) {
+    case 'open':
+      return `Opening ${truncateUrl(url || '')}`;
+    case 'navigate':
+      return `Navigating to ${truncateUrl(url || '')}`;
+    case 'snapshot':
+      return 'Reading page structure';
+    case 'read':
+      return 'Extracting page text';
+    case 'close':
+      return 'Closing browser';
+    case 'act':
+      return null;
+    default:
+      return null;
+  }
+}
+
+interface ToolDisplayComponent {
+  setActive(progressMessage?: string): void;
+  setComplete(summary: string, duration: number): void;
+  setError(error: string): void;
+  setLimitWarning(warning?: string): void;
+  setApproval(decision: 'allow-once' | 'allow-session' | 'deny'): void;
+  setDenied(path: string, tool: string): void;
+}
+
+class BrowserSessionComponent extends Container implements ToolDisplayComponent {
+  private readonly header: Text;
+  private detail: Text | null = null;
+  private currentStep: string | null = null;
+
+  constructor(_tui: TUI) {
+    super();
+    this.addChild(new Spacer(1));
+    this.header = new Text('⏺ Browser', 0, 0);
+    this.addChild(this.header);
+  }
+
+  setStep(args: Record<string, unknown>) {
+    const step = formatBrowserStep(args);
+    if (step) {
+      this.currentStep = step;
+    }
+  }
+
+  setActive(progressMessage?: string): void {
+    this.clearDetail();
+    const message = progressMessage || this.currentStep || 'Searching...';
+    this.detail = new Text(`${theme.muted('⎿  ')}${message}`, 0, 0);
+    this.addChild(this.detail);
+  }
+
+  setComplete(summary: string, duration: number): void {
+    this.clearDetail();
+    const text = this.currentStep || `${summary}${theme.muted(` in ${formatDuration(duration)}`)}`;
+    this.detail = new Text(`${theme.muted('⎿  ')}${text}`, 0, 0);
+    this.addChild(this.detail);
+  }
+
+  setError(error: string): void {
+    this.clearDetail();
+    this.detail = new Text(`${theme.muted('⎿  ')}${theme.error(`Error: ${error}`)}`, 0, 0);
+    this.addChild(this.detail);
+  }
+
+  setLimitWarning(warning?: string): void {
+    this.clearDetail();
+    this.detail = new Text(`${theme.muted('⎿  ')}${theme.warning(warning || 'Approaching suggested limit')}`, 0, 0);
+    this.addChild(this.detail);
+  }
+
+  setApproval(decision: 'allow-once' | 'allow-session' | 'deny'): void {
+    this.clearDetail();
+    const label =
+      decision === 'allow-once'
+        ? 'Approved'
+        : decision === 'allow-session'
+          ? 'Approved (session)'
+          : 'Denied';
+    const color = decision === 'deny' ? theme.warning : theme.primary;
+    this.detail = new Text(`${theme.muted('⎿  ')}${color(label)}`, 0, 0);
+    this.addChild(this.detail);
+  }
+
+  setDenied(path: string, tool: string): void {
+    this.clearDetail();
+    const action = tool === 'write_file' ? 'write to' : tool === 'edit_file' ? 'edit of' : tool;
+    this.detail = new Text(`${theme.muted('⎿  ')}${theme.warning(`User denied ${action} ${path}`)}`, 0, 0);
+    this.addChild(this.detail);
+  }
+
+  private clearDetail() {
+    if (this.detail) {
+      this.removeChild(this.detail);
+      this.detail = null;
+    }
+  }
+}
+
+export class ChatLogComponent extends Container {
+  private readonly tui: TUI;
+  private readonly toolById = new Map<string, ToolDisplayComponent>();
+  private currentBrowserSession: BrowserSessionComponent | null = null;
+  private activeAnswer: AnswerBoxComponent | null = null;
+  private lastToolName: string | null = null;
+  private lastToolComponent: ToolDisplayComponent | null = null;
+
+  constructor(tui: TUI) {
+    super();
+    this.tui = tui;
+  }
+
+  clearAll() {
+    this.clear();
+    this.toolById.clear();
+    this.currentBrowserSession = null;
+    this.activeAnswer = null;
+    this.lastToolName = null;
+    this.lastToolComponent = null;
+  }
+
+  addQuery(query: string) {
+    this.addChild(new UserQueryComponent(query));
+  }
+
+  resetToolGrouping() {
+    this.lastToolName = null;
+    this.lastToolComponent = null;
+  }
+
+  addInterrupted() {
+    this.addChild(new Text(`${theme.muted('⎿  Interrupted · What should the agent do instead?')}`, 0, 0));
+  }
+
+  startTool(toolCallId: string, toolName: string, args: Record<string, unknown>) {
+    if (toolName !== 'browser') {
+      this.currentBrowserSession = null;
+    }
+
+    const existing = this.toolById.get(toolCallId);
+    if (existing) {
+      existing.setActive();
+      return existing;
+    }
+
+    if (toolName === 'browser') {
+      if (!this.currentBrowserSession) {
+        this.currentBrowserSession = new BrowserSessionComponent(this.tui);
+        this.addChild(this.currentBrowserSession);
+      }
+      this.currentBrowserSession.setStep(args);
+      this.currentBrowserSession.setActive();
+      this.toolById.set(toolCallId, this.currentBrowserSession);
+      this.lastToolName = null;
+      this.lastToolComponent = null;
+      return this.currentBrowserSession;
+    }
+
+    if (this.lastToolName === toolName && this.lastToolComponent) {
+      this.lastToolComponent.setActive();
+      this.toolById.set(toolCallId, this.lastToolComponent);
+      return this.lastToolComponent;
+    }
+
+    const component = new ToolEventComponent(this.tui, toolName, args);
+    component.setActive();
+    this.toolById.set(toolCallId, component);
+    this.addChild(component);
+    this.lastToolName = toolName;
+    this.lastToolComponent = component;
+    return component;
+  }
+
+  updateToolProgress(toolCallId: string, message: string) {
+    const existing = this.toolById.get(toolCallId);
+    if (!existing) {
+      return;
+    }
+    existing.setActive(message);
+  }
+
+  completeTool(toolCallId: string, summary: string, duration: number) {
+    const existing = this.toolById.get(toolCallId);
+    if (!existing) {
+      return;
+    }
+    existing.setComplete(summary, duration);
+  }
+
+  errorTool(toolCallId: string, error: string) {
+    const existing = this.toolById.get(toolCallId);
+    if (!existing) {
+      return;
+    }
+    existing.setError(error);
+  }
+
+  limitTool(toolCallId: string, warning?: string) {
+    const existing = this.toolById.get(toolCallId);
+    if (!existing) {
+      return;
+    }
+    existing.setLimitWarning(warning);
+  }
+
+  approveTool(toolCallId: string, decision: 'allow-once' | 'allow-session' | 'deny') {
+    const existing = this.toolById.get(toolCallId);
+    if (!existing) {
+      return;
+    }
+    existing.setApproval(decision);
+  }
+
+  denyTool(toolCallId: string, path: string, tool: string) {
+    const existing = this.toolById.get(toolCallId);
+    if (!existing) {
+      return;
+    }
+    existing.setDenied(path, tool);
+  }
+
+  finalizeAnswer(text: string): AnswerBoxComponent {
+    if (!this.activeAnswer) {
+      const box = new AnswerBoxComponent(text);
+      this.addChild(box);
+      return box;
+    }
+    this.activeAnswer.setText(text);
+    const box = this.activeAnswer;
+    this.activeAnswer = null;
+    return box;
+  }
+
+  addContextCleared(clearedCount: number, keptCount: number) {
+    this.addChild(
+      new Text(
+        `${theme.muted(
+          `⏺ Context threshold reached - cleared ${clearedCount} old tool result${clearedCount !== 1 ? 's' : ''}, kept ${keptCount} most recent`,
+        )}`,
+        0,
+        0,
+      ),
+    );
+  }
+
+  addPerformanceStats(duration: number, tokenUsage?: TokenUsage, tokensPerSecond?: number) {
+    const parts = [formatDuration(duration)];
+    if (tokenUsage && tokenUsage.totalTokens > 20_000) {
+      parts.push(`${tokenUsage.totalTokens.toLocaleString()} tokens`);
+      if (tokensPerSecond !== undefined) {
+        parts.push(`(${tokensPerSecond.toFixed(1)} tok/s)`);
+      }
+    }
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(`${theme.muted('✻ ')}${theme.muted(parts.join(' · '))}`, 0, 0));
+  }
+}

package/src/components/custom-editor.ts

@@ -0,0 +1,18 @@
+import { Editor, Key, matchesKey } from '@mariozechner/pi-tui';
+
+export class CustomEditor extends Editor {
+  onEscape?: () => void;
+  onCtrlC?: () => void;
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.escape) && this.onEscape) {
+      this.onEscape();
+      return;
+    }
+    if (matchesKey(data, Key.ctrl('c')) && this.onCtrlC) {
+      this.onCtrlC();
+      return;
+    }
+    super.handleInput(data);
+  }
+}

package/src/components/debug-panel.ts

@@ -0,0 +1,52 @@
+import { Box, Container, Text } from '@mariozechner/pi-tui';
+import { logger, type LogEntry, type LogLevel } from '../utils/logger.js';
+import { theme } from '../theme.js';
+
+const LEVEL_COLORS: Record<LogLevel, (text: string) => string> = {
+  debug: theme.mutedDark,
+  info: theme.info,
+  warn: theme.warning,
+  error: theme.error,
+};
+
+export class DebugPanelComponent extends Container {
+  private readonly box: Box;
+  private readonly maxLines: number;
+  private readonly show: boolean;
+  private logs: LogEntry[] = [];
+  private unsubscribe: (() => void) | null = null;
+
+  constructor(maxLines = 8, show = true) {
+    super();
+    this.maxLines = maxLines;
+    this.show = show;
+    this.box = new Box(1, 0, () => '');
+    this.addChild(this.box);
+    this.unsubscribe = logger.subscribe((entries) => {
+      this.logs = entries;
+      this.refresh();
+    });
+    this.refresh();
+  }
+
+  dispose() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+
+  private refresh() {
+    this.box.clear();
+    if (!this.show || this.logs.length === 0) {
+      return;
+    }
+
+    this.box.addChild(new Text(theme.dim('─ Debug ─'), 0, 0));
+    const displayLogs = this.logs.slice(-this.maxLines);
+    for (const entry of displayLogs) {
+      const level = `[${entry.level.toUpperCase().padEnd(5)}]`;
+      const prefix = LEVEL_COLORS[entry.level](level);
+      const data = entry.data !== undefined ? ` ${theme.mutedDark(JSON.stringify(entry.data))}` : '';
+      this.box.addChild(new Text(`${prefix} ${entry.message}${data}`, 0, 0));
+    }
+  }
+}

package/src/components/index.ts

@@ -0,0 +1,17 @@
+export { AnswerBoxComponent } from './answer-box.js';
+export { ApprovalPromptComponent } from './approval-prompt.js';
+export { ChatLogComponent } from './chat-log.js';
+export { DebugPanelComponent } from './debug-panel.js';
+export { CustomEditor } from './custom-editor.js';
+export { IntroComponent } from './intro.js';
+export {
+  ApiKeyInputComponent,
+  createApiKeyConfirmSelector,
+  createApprovalSelector,
+  createModelSelector,
+  createProviderSelector,
+} from './select-list.js';
+export { ToolEventComponent } from './tool-event.js';
+export { UserQueryComponent } from './user-query.js';
+export { WorkingIndicatorComponent } from './working-indicator.js';
+export { createBrowseMarketSelector, updateBrowseMarketSelector, createBrowseActionSelector } from './browse-list.js';

package/src/components/intro.ts

@@ -0,0 +1,92 @@
+import { Container, Spacer, Text } from '@mariozechner/pi-tui';
+import packageJson from '../../package.json';
+import { theme } from '../theme.js';
+import { getModelDisplayName } from '../utils/model.js';
+
+const INTRO_WIDTH = 60;
+
+export class IntroComponent extends Container {
+  private readonly modelText: Text;
+
+  constructor(model: string) {
+    super();
+
+    const isDemo = process.env.KALSHI_USE_DEMO === 'true';
+    const welcomeText = isDemo ? 'Kalshi Trading Bot CLI  [DEMO MODE]' : 'Kalshi Trading Bot CLI';
+    const versionText = ` v${packageJson.version}`;
+    const fullText = welcomeText + versionText;
+    const padding = Math.max(0, Math.floor((INTRO_WIDTH - fullText.length - 2) / 2));
+    const trailing = Math.max(0, INTRO_WIDTH - fullText.length - padding - 2);
+
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(theme.primary('═'.repeat(INTRO_WIDTH)), 0, 0));
+    this.addChild(
+      new Text(
+        theme.primary(
+          `║${' '.repeat(padding)}${theme.bold(welcomeText)}${theme.muted(versionText)}${' '.repeat(
+            trailing,
+          )}║`,
+        ),
+        0,
+        0,
+      ),
+    );
+    this.addChild(new Text(theme.primary('═'.repeat(INTRO_WIDTH)), 0, 0));
+    this.addChild(new Spacer(1));
+
+    this.addChild(
+      new Text(
+        theme.bold(
+          theme.primary(
+            `
+ ██████╗  ██████╗████████╗ █████╗  ██████╗  ██████╗ ███╗   ██╗
+██╔═══██╗██╔════╝╚══██╔══╝██╔══██╗██╔════╝ ██╔═══██╗████╗  ██║
+██║   ██║██║        ██║   ███████║██║  ███╗██║   ██║██╔██╗ ██║
+██║   ██║██║        ██║   ██╔══██║██║   ██║██║   ██║██║╚██╗██║
+╚██████╔╝╚██████╗   ██║   ██║  ██║╚██████╔╝╚██████╔╝██║ ╚████║
+ ╚═════╝  ╚═════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝`,
+          ),
+        ),
+        0,
+        0,
+      ),
+    );
+
+    if (isDemo) {
+      this.addChild(new Spacer(1));
+      this.addChild(
+        new Text(
+          theme.warning('  ⚠  DEMO MODE — orders are simulated, no real money at risk  ⚠'),
+          0,
+          0,
+        ),
+      );
+    }
+
+    this.addChild(new Spacer(1));
+    this.addChild(new Text('AI-powered prediction market terminal.', 0, 0));
+    this.addChild(new Spacer(1));
+    const cmd = (label: string) => theme.muted(label.padEnd(11));
+    this.addChild(new Text(cmd('/search') + 'Search events by theme, ticker, or free-text; /search edge for edge scan', 0, 0));
+    this.addChild(new Text(cmd('/portfolio') + 'Overview, positions, orders, balance, status', 0, 0));
+    this.addChild(new Text(cmd('/analyze') + '<ticker>  Full analysis: edge, research, Kelly sizing', 0, 0));
+    this.addChild(new Text(cmd('/watch') + '<ticker>  Live price/orderbook feed', 0, 0));
+    this.addChild(new Text(cmd('/backtest') + 'Model accuracy scorecard + live edge scanner', 0, 0));
+    this.addChild(new Text(cmd('/buy /sell') + '<ticker> <n> [price]   /cancel <order_id>', 0, 0));
+    this.addChild(new Text(cmd('/help') + '[command]  Show help (/help <command> for details)', 0, 0));
+    this.addChild(new Text(cmd('/quit') + 'Quit CLI session', 0, 0));
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(theme.muted('Ask anything: ') + '"analyze KXBTC"  "search crypto"  "show my portfolio"', 0, 0));
+    this.modelText = new Text('', 0, 0);
+    this.addChild(this.modelText);
+    this.setModel(model);
+  }
+
+  setModel(model: string) {
+    this.modelText.setText(
+      `${theme.muted('Model: ')}${theme.primary(getModelDisplayName(model))}${theme.muted(
+        '. Type /model to change.',
+      )}`,
+    );
+  }
+}