kalshi-trading-bot-cli 2.1.0

package/src/components/select-list.ts

@@ -0,0 +1,155 @@
+import { Container, Input, SelectList, Text, type SelectItem, getEditorKeybindings, truncateToWidth } from '@mariozechner/pi-tui';
+import { PROVIDERS, type Model } from '../utils/model.js';
+import type { ApprovalDecision } from '../agent/types.js';
+import { selectListTheme, theme } from '../theme.js';
+
+export class VimSelectList extends SelectList {
+  handleInput(keyData: string): void {
+    if (keyData === 'j') {
+      super.handleInput('\u001b[B');
+      return;
+    }
+    if (keyData === 'k') {
+      super.handleInput('\u001b[A');
+      return;
+    }
+    // Number keys: jump to item and select it (1-indexed)
+    if (keyData >= '1' && keyData <= '9') {
+      const idx = parseInt(keyData, 10) - 1;
+      const items = (this as any).items as SelectItem[];
+      if (idx < items.length) {
+        this.setSelectedIndex(idx);
+        this.onSelect?.(items[idx]);
+        return;
+      }
+    }
+    super.handleInput(keyData);
+  }
+}
+
+class EmptyModelSelector extends Container {
+  private readonly onCancel: () => void;
+
+  constructor(providerId: string, onCancel: () => void) {
+    super();
+    this.onCancel = onCancel;
+    this.addChild(new Text(theme.muted('No models available.'), 0, 0));
+    if (providerId === 'ollama') {
+      this.addChild(
+        new Text(theme.muted('Make sure Ollama is running and you have models downloaded.'), 0, 0),
+      );
+    }
+    this.addChild(new Text(theme.muted('esc to go back'), 0, 0));
+  }
+
+  handleInput(keyData: string): void {
+    const kb = getEditorKeybindings();
+    if (kb.matches(keyData, 'selectCancel')) {
+      this.onCancel();
+    }
+  }
+}
+
+export function createProviderSelector(
+  currentProvider: string | undefined,
+  onSelect: (providerId: string | null) => void,
+) {
+  const items: SelectItem[] = PROVIDERS.map((provider, index) => ({
+    value: provider.providerId,
+    label: `${index + 1}. ${provider.displayName}${currentProvider === provider.providerId ? ' ✓' : ''}`,
+  }));
+  const list = new VimSelectList(items, 8, selectListTheme);
+  list.onSelect = (item) => onSelect(item.value);
+  list.onCancel = () => onSelect(null);
+  return list;
+}
+
+export function createModelSelector(
+  models: Model[],
+  currentModel: string | undefined,
+  onSelect: (modelId: string | null) => void,
+  providerId?: string,
+) {
+  if (models.length === 0) {
+    return new EmptyModelSelector(providerId ?? '', () => onSelect(null));
+  }
+  const items: SelectItem[] = models.map((model, index) => ({
+    value: model.id,
+    label: `${index + 1}. ${model.displayName}${currentModel === model.id ? ' ✓' : ''}`,
+  }));
+  const list = new VimSelectList(items, 10, selectListTheme);
+  list.onSelect = (item) => onSelect(item.value);
+  list.onCancel = () => onSelect(null);
+  return list;
+}
+
+export function createApprovalSelector(onSelect: (decision: ApprovalDecision) => void) {
+  const items: SelectItem[] = [
+    { value: 'allow-once', label: '1. Yes' },
+    { value: 'allow-session', label: '2. Yes, allow all edits this session' },
+    { value: 'deny', label: '3. No' },
+  ];
+  const list = new VimSelectList(items, 5, selectListTheme);
+  list.onSelect = (item) => onSelect(item.value as ApprovalDecision);
+  list.onCancel = () => onSelect('deny');
+  return list;
+}
+
+export function createApiKeyConfirmSelector(onConfirm: (wantsToSet: boolean) => void) {
+  const items: SelectItem[] = [
+    { value: 'yes', label: '1. Yes' },
+    { value: 'no', label: '2. No' },
+  ];
+  const list = new VimSelectList(items, 4, selectListTheme);
+  list.onSelect = (item) => onConfirm(item.value === 'yes');
+  list.onCancel = () => onConfirm(false);
+  return list;
+}
+
+export class ApiKeyInputComponent {
+  private readonly input = new Input();
+  private readonly masked: boolean;
+  onSubmit?: (apiKey: string | null) => void;
+  onCancel?: () => void;
+
+  constructor(masked = false) {
+    this.masked = masked;
+  }
+
+  invalidate() {
+    this.input.invalidate();
+  }
+
+  render(width: number): string[] {
+    const maxContent = Math.max(10, width - 4); // account for "> " prefix
+    const lines = this.input.render(maxContent);
+    const raw = lines[0] ?? '';
+    let display: string;
+    if (this.masked) {
+      const len = this.input.getValue().length;
+      display = len === 0 ? '█' : '*'.repeat(Math.min(len, maxContent));
+    } else {
+      display = raw;
+    }
+    return [
+      truncateToWidth(`${theme.primary('> ')}${display}`, width),
+    ];
+  }
+
+  handleInput(keyData: string): void {
+    const kb = getEditorKeybindings();
+    if (kb.matches(keyData, 'submit')) {
+      this.onSubmit?.(this.input.getValue().trim() || null);
+      return;
+    }
+    if (kb.matches(keyData, 'selectCancel')) {
+      this.onCancel?.();
+      return;
+    }
+    this.input.handleInput(keyData);
+  }
+
+  getValue(): string {
+    return this.input.getValue();
+  }
+}

package/src/components/tool-event.ts

@@ -0,0 +1,127 @@
+import { Container, Spacer, Text } from '@mariozechner/pi-tui';
+import type { ApprovalDecision } from '../agent/types.js';
+import { theme } from '../theme.js';
+
+function formatToolName(name: string): string {
+  return name
+    .split('_')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+function truncateAtWord(str: string, maxLength: number): string {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  const lastSpace = str.lastIndexOf(' ', maxLength);
+  if (lastSpace > maxLength * 0.5) {
+    return `${str.slice(0, lastSpace)}...`;
+  }
+  return `${str.slice(0, maxLength)}...`;
+}
+
+function formatArgs(tool: string, args: Record<string, unknown>): string {
+  if ('query' in args) {
+    const query = String(args.query);
+    return theme.muted(`"${truncateAtWord(query, 60)}"`);
+  }
+  if (tool === 'memory_update') {
+    const text = String(args.content ?? args.old_text ?? '').replace(/\n/g, ' ');
+    if (text) return theme.muted(truncateAtWord(text, 80));
+  }
+  return theme.muted(
+    Object.entries(args)
+      .map(([key, value]) => `${key}=${truncateAtWord(String(value).replace(/\n/g, '\\n'), 60)}`)
+      .join(', '),
+  );
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function approvalLabel(decision: ApprovalDecision): string {
+  switch (decision) {
+    case 'allow-once':
+      return 'Approved';
+    case 'allow-session':
+      return 'Approved (session)';
+    case 'deny':
+      return 'Denied';
+  }
+}
+
+export class ToolEventComponent extends Container {
+  private readonly header: Text;
+  private completedDetails: Text[] = [];
+  private activeDetail: Text | null = null;
+
+  constructor(_tui: unknown, tool: string, args: Record<string, unknown>) {
+    super();
+    this.addChild(new Spacer(1));
+    const title = `${formatToolName(tool)}${args ? `${theme.muted('(')}${formatArgs(tool, args)}${theme.muted(')')}` : ''}`;
+    this.header = new Text(`⏺ ${title}`, 0, 0);
+    this.addChild(this.header);
+  }
+
+  setActive(progressMessage?: string) {
+    this.clearDetail();
+    const message = progressMessage || 'Searching...';
+    this.activeDetail = new Text(`${theme.muted('⎿  ')}${message}`, 0, 0);
+    this.addChild(this.activeDetail);
+  }
+
+  setComplete(summary: string, duration: number) {
+    this.clearDetail();
+    const detail = new Text(
+      `${theme.muted('⎿  ')}${summary}${theme.muted(` in ${formatDuration(duration)}`)}`,
+      0,
+      0
+    );
+    this.completedDetails.push(detail);
+    this.addChild(detail);
+  }
+
+  setError(error: string) {
+    this.clearDetail();
+    const detail = new Text(`${theme.muted('⎿  ')}${theme.error(`Error: ${truncateAtWord(error, 80)}`)}`, 0, 0);
+    this.completedDetails.push(detail);
+    this.addChild(detail);
+  }
+
+  setLimitWarning(warning?: string) {
+    this.clearDetail();
+    this.activeDetail = new Text(
+      `${theme.muted('⎿  ')}${theme.warning(truncateAtWord(warning || 'Approaching suggested limit', 100))}`,
+      0,
+      0,
+    );
+    this.addChild(this.activeDetail);
+  }
+
+  setDenied(path: string, tool: string) {
+    this.clearDetail();
+    const action = tool === 'write_file' ? 'write to' : tool === 'edit_file' ? 'edit of' : tool;
+    const detail = new Text(`${theme.muted('⎿  ')}${theme.warning(`User denied ${action} ${path}`)}`, 0, 0);
+    this.completedDetails.push(detail);
+    this.addChild(detail);
+  }
+
+  setApproval(decision: ApprovalDecision) {
+    this.clearDetail();
+    const color = decision !== 'deny' ? theme.primary : theme.warning;
+    const detail = new Text(`${theme.muted('⎿  ')}${color(approvalLabel(decision))}`, 0, 0);
+    this.completedDetails.push(detail);
+    this.addChild(detail);
+  }
+
+  private clearDetail() {
+    if (this.activeDetail) {
+      this.removeChild(this.activeDetail);
+      this.activeDetail = null;
+    }
+  }
+}

package/src/components/user-query.ts

@@ -0,0 +1,18 @@
+import { Container, Spacer, Text } from '@mariozechner/pi-tui';
+import { theme } from '../theme.js';
+
+export class UserQueryComponent extends Container {
+  private readonly body: Text;
+
+  constructor(query: string) {
+    super();
+    this.addChild(new Spacer(1));
+    this.body = new Text('', 0, 0);
+    this.addChild(this.body);
+    this.setQuery(query);
+  }
+
+  setQuery(query: string) {
+    this.body.setText(`${theme.queryBg(theme.white(`❯ ${query} `))}`);
+  }
+}

package/src/components/working-indicator.ts

@@ -0,0 +1,87 @@
+import { Container, Loader, type TUI } from '@mariozechner/pi-tui';
+import type { WorkingState } from '../types.js';
+import { getRandomThinkingVerb } from '../utils/thinking-verbs.js';
+import { theme } from '../theme.js';
+
+export class WorkingIndicatorComponent extends Container {
+  private readonly tui: TUI;
+  private loader: Loader | null = null;
+  private state: WorkingState = { status: 'idle' };
+  private thinkingVerb = getRandomThinkingVerb();
+  private prevStatus: WorkingState['status'] = 'idle';
+
+  constructor(tui: TUI) {
+    super();
+    this.tui = tui;
+    this.renderIdle();
+  }
+
+  setState(state: WorkingState) {
+    const isThinking =
+      state.status === 'thinking' || state.status === 'tool' || state.status === 'approval';
+    const wasThinking =
+      this.prevStatus === 'thinking' ||
+      this.prevStatus === 'tool' ||
+      this.prevStatus === 'approval';
+    if (isThinking && !wasThinking) {
+      this.thinkingVerb = getRandomThinkingVerb();
+    }
+    this.prevStatus = state.status;
+    this.state = state;
+    if (state.status === 'idle') {
+      this.stopLoader();
+      this.renderIdle();
+      return;
+    }
+    this.renderBusy();
+  }
+
+  dispose() {
+    this.stopLoader();
+  }
+
+  private renderIdle() {
+    this.clear();
+  }
+
+  private renderBusy() {
+    this.clear();
+    this.ensureLoader();
+    this.updateMessage();
+  }
+
+  private ensureLoader() {
+    if (this.loader) {
+      this.addChild(this.loader);
+      return;
+    }
+    this.loader = new Loader(
+      this.tui,
+      (spinner) => theme.primary(spinner),
+      (text) => theme.primary(text),
+      '',
+    );
+    // Use larger braille block characters for a more visible spinner (ora's "dots2" style)
+    (this.loader as any).frames = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+    this.addChild(this.loader);
+  }
+
+  private stopLoader() {
+    if (!this.loader) {
+      return;
+    }
+    this.loader.stop();
+    this.loader = null;
+  }
+
+  private updateMessage() {
+    if (!this.loader || this.state.status === 'idle') {
+      return;
+    }
+    if (this.state.status === 'approval') {
+      this.loader.setMessage('Waiting for approval... (esc to interrupt)');
+      return;
+    }
+    this.loader.setMessage(`${this.thinkingVerb}... (esc to interrupt)`);
+  }
+}

package/src/controllers/agent-runner.ts

@@ -0,0 +1,283 @@
+import { Agent } from '../agent/agent.js';
+import type { InMemoryChatHistory } from '../utils/in-memory-chat-history.js';
+import type {
+  AgentConfig,
+  AgentEvent,
+  ApprovalDecision,
+  DoneEvent,
+} from '../agent/index.js';
+import type { DisplayEvent } from '../agent/types.js';
+import type { HistoryItem, HistoryItemStatus, WorkingState } from '../types.js';
+import { trackEvent } from '../utils/telemetry.js';
+
+type ChangeListener = () => void;
+
+export interface RunQueryResult {
+  answer: string;
+}
+
+export class AgentRunnerController {
+  private historyValue: HistoryItem[] = [];
+  private workingStateValue: WorkingState = { status: 'idle' };
+  private errorValue: string | null = null;
+  private pendingApprovalValue: { tool: string; args: Record<string, unknown> } | null = null;
+  private readonly agentConfig: AgentConfig;
+  private readonly inMemoryChatHistory: InMemoryChatHistory;
+  private readonly onChange?: ChangeListener;
+  private abortController: AbortController | null = null;
+  private approvalResolve: ((decision: ApprovalDecision) => void) | null = null;
+  private sessionApprovedTools = new Set<string>();
+
+  constructor(
+    agentConfig: AgentConfig,
+    inMemoryChatHistory: InMemoryChatHistory,
+    onChange?: ChangeListener,
+  ) {
+    this.agentConfig = agentConfig;
+    this.inMemoryChatHistory = inMemoryChatHistory;
+    this.onChange = onChange;
+  }
+
+  get history(): HistoryItem[] {
+    return this.historyValue;
+  }
+
+  get workingState(): WorkingState {
+    return this.workingStateValue;
+  }
+
+  get error(): string | null {
+    return this.errorValue;
+  }
+
+  get pendingApproval(): { tool: string; args: Record<string, unknown> } | null {
+    return this.pendingApprovalValue;
+  }
+
+  get isProcessing(): boolean {
+    return (
+      this.historyValue.length > 0 && this.historyValue[this.historyValue.length - 1]?.status === 'processing'
+    );
+  }
+
+  setError(error: string | null) {
+    this.errorValue = error;
+    this.emitChange();
+  }
+
+  respondToApproval(decision: ApprovalDecision) {
+    if (!this.approvalResolve) {
+      return;
+    }
+    this.approvalResolve(decision);
+    this.approvalResolve = null;
+    this.pendingApprovalValue = null;
+    if (decision !== 'deny') {
+      this.workingStateValue = { status: 'thinking' };
+    }
+    this.emitChange();
+  }
+
+  cancelExecution() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    if (this.approvalResolve) {
+      this.approvalResolve('deny');
+      this.approvalResolve = null;
+      this.pendingApprovalValue = null;
+    }
+    this.markLastProcessing('interrupted');
+    this.workingStateValue = { status: 'idle' };
+    this.emitChange();
+  }
+
+  async runQuery(query: string): Promise<RunQueryResult | undefined> {
+    this.abortController = new AbortController();
+    let finalAnswer: string | undefined;
+
+    const startTime = Date.now();
+    const item: HistoryItem = {
+      id: String(startTime),
+      query,
+      events: [],
+      answer: '',
+      status: 'processing',
+      startTime,
+    };
+    this.historyValue = [...this.historyValue, item];
+    this.inMemoryChatHistory.saveUserQuery(query);
+    this.errorValue = null;
+    this.workingStateValue = { status: 'thinking' };
+    this.emitChange();
+
+    try {
+      trackEvent('agent_query_start', { model: this.agentConfig.model ?? '' });
+      const agent = await Agent.create({
+        ...this.agentConfig,
+        signal: this.abortController.signal,
+        requestToolApproval: this.requestToolApproval,
+        sessionApprovedTools: this.sessionApprovedTools,
+      });
+      const stream = agent.run(query, this.inMemoryChatHistory);
+      for await (const event of stream) {
+        if (event.type === 'done') {
+          finalAnswer = (event as DoneEvent).answer;
+        }
+        await this.handleEvent(event);
+      }
+      if (finalAnswer) {
+        trackEvent('agent_query_complete', { model: this.agentConfig.model ?? '', duration_ms: Date.now() - startTime, success: 'true' });
+        return { answer: finalAnswer };
+      }
+      return undefined;
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        trackEvent('agent_query_complete', { model: this.agentConfig.model ?? '', duration_ms: Date.now() - startTime, success: 'false', interrupted: 'true' });
+        this.markLastProcessing('interrupted');
+        this.workingStateValue = { status: 'idle' };
+        this.emitChange();
+        return undefined;
+      }
+      trackEvent('agent_query_complete', { model: this.agentConfig.model ?? '', duration_ms: Date.now() - startTime, success: 'false', interrupted: 'false' });
+      const message = error instanceof Error ? error.message : String(error);
+      this.errorValue = message;
+      this.markLastProcessing('error');
+      this.workingStateValue = { status: 'idle' };
+      this.emitChange();
+      return undefined;
+    } finally {
+      this.abortController = null;
+    }
+  }
+
+  private requestToolApproval = (request: { tool: string; args: Record<string, unknown> }) => {
+    return new Promise<ApprovalDecision>((resolve) => {
+      this.approvalResolve = resolve;
+      this.pendingApprovalValue = request;
+      this.workingStateValue = { status: 'approval', toolName: request.tool };
+      this.emitChange();
+    });
+  };
+
+  private async handleEvent(event: AgentEvent) {
+    switch (event.type) {
+      case 'thinking':
+        this.workingStateValue = { status: 'thinking' };
+        this.pushEvent({
+          id: `thinking-${Date.now()}`,
+          event,
+          completed: true,
+        });
+        break;
+      case 'tool_start': {
+        const toolId = `tool-${event.tool}-${Date.now()}`;
+        this.workingStateValue = { status: 'tool', toolName: event.tool };
+        this.updateLastItem((last) => ({
+          ...last,
+          activeToolId: toolId,
+          events: [
+            ...last.events,
+            {
+              id: toolId,
+              event,
+              completed: false,
+            } as DisplayEvent,
+          ],
+        }));
+        break;
+      }
+      case 'tool_progress':
+        this.updateLastItem((last) => ({
+          ...last,
+          events: last.events.map((entry) =>
+            entry.id === last.activeToolId ? { ...entry, progressMessage: event.message } : entry,
+          ),
+        }));
+        break;
+      case 'tool_end':
+        this.finishToolEvent(event);
+        this.workingStateValue = { status: 'thinking' };
+        break;
+      case 'tool_error':
+        this.finishToolEvent(event);
+        this.workingStateValue = { status: 'thinking' };
+        break;
+      case 'tool_approval':
+        this.pushEvent({
+          id: `approval-${event.tool}-${Date.now()}`,
+          event,
+          completed: true,
+        });
+        break;
+      case 'tool_denied':
+        this.pushEvent({
+          id: `denied-${event.tool}-${Date.now()}`,
+          event,
+          completed: true,
+        });
+        break;
+      case 'tool_limit':
+      case 'context_cleared':
+        this.pushEvent({
+          id: `${event.type}-${Date.now()}`,
+          event,
+          completed: true,
+        });
+        break;
+      case 'done': {
+        const done = event as DoneEvent;
+        if (done.answer) {
+          await this.inMemoryChatHistory.saveAnswer(done.answer).catch(() => {});
+        }
+        this.updateLastItem((last) => ({
+          ...last,
+          answer: done.answer,
+          status: 'complete',
+          duration: done.totalTime,
+          tokenUsage: done.tokenUsage,
+          tokensPerSecond: done.tokensPerSecond,
+        }));
+        this.workingStateValue = { status: 'idle' };
+        break;
+      }
+    }
+    this.emitChange();
+  }
+
+  private finishToolEvent(event: AgentEvent) {
+    this.updateLastItem((last) => ({
+      ...last,
+      activeToolId: undefined,
+      events: last.events.map((entry) =>
+        entry.id === last.activeToolId ? { ...entry, completed: true, endEvent: event } : entry,
+      ),
+    }));
+  }
+
+  private pushEvent(displayEvent: DisplayEvent) {
+    this.updateLastItem((last) => ({ ...last, events: [...last.events, displayEvent] }));
+  }
+
+  private updateLastItem(updater: (item: HistoryItem) => HistoryItem) {
+    const last = this.historyValue[this.historyValue.length - 1];
+    if (!last || last.status !== 'processing') {
+      return;
+    }
+    const next = updater(last);
+    this.historyValue = [...this.historyValue.slice(0, -1), next];
+  }
+
+  private markLastProcessing(status: HistoryItemStatus) {
+    const last = this.historyValue[this.historyValue.length - 1];
+    if (!last || last.status !== 'processing') {
+      return;
+    }
+    this.historyValue = [...this.historyValue.slice(0, -1), { ...last, status }];
+  }
+
+  private emitChange() {
+    this.onChange?.();
+  }
+}