kalshi-trading-bot-cli 2.1.0

package/src/commands/index.ts

@@ -0,0 +1,287 @@
+import { callKalshiApi } from '../tools/kalshi/api.js';
+import type { KalshiOrder, KalshiPosition } from '../tools/kalshi/types.js';
+import type { KalshiBalanceResponse } from './formatters.js';
+import {
+  formatBalance,
+  formatPositions,
+  formatOrders,
+  formatExchangeStatus,
+  formatOrderConfirmation,
+} from './formatters.js';
+import { handleThemes, formatThemesHuman } from './themes.js';
+import type { ParsedArgs, Subcommand } from './parse-args.js';
+
+function defaultArgs(overrides: Partial<ParsedArgs>): ParsedArgs {
+  return {
+    subcommand: 'chat', positionalArgs: [], json: false,
+    live: false, refresh: false, report: false, dryRun: false,
+    verbose: false, performance: false, resolved: false,
+    unresolved: false, parseErrors: [],
+    ...overrides,
+  };
+}
+import { handleBacktest, formatBacktestHuman } from './backtest.js';
+import { handleAnalyze, formatAnalyzeHuman } from './analyze.js';
+import { handlePortfolio, formatPortfolioHuman } from './portfolio.js';
+import { reviewPortfolio, formatReviewHuman } from './review.js';
+import { buildHelp, validateTradeArgs } from './help.js';
+import { fetchMarketQuote } from './helpers.js';
+import { trackEvent } from '../utils/telemetry.js';
+
+export interface CommandResult {
+  output: string;
+  /** If set, show this as a pending trade requiring approval */
+  pendingTrade?: {
+    ticker: string;
+    action: 'buy' | 'sell';
+    side: 'yes' | 'no';
+    count: number;
+    price: number | undefined;
+  };
+  /** If set, run this async function after showing `output` and append the result */
+  asyncFollowUp?: () => Promise<string>;
+}
+
+export async function handleSlashCommand(input: string): Promise<CommandResult | null> {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith('/')) return null;
+
+  const parts = trimmed.slice(1).trim().split(/\s+/);
+  const command = parts[0]?.toLowerCase();
+  const args = parts.slice(1);
+  trackEvent('slash_command', { command: command ?? '' });
+
+  switch (command) {
+    case 'help': {
+      const result = buildHelp('slash', args[0]);
+      return { output: 'error' in result ? result.error : result.text };
+    }
+
+    // ─── /portfolio (with subviews) ──────────────────────────────────
+    case 'portfolio':
+      return handlePortfolioSlash(args[0]);
+
+    // Hidden aliases → /portfolio <subview>
+    case 'status':
+      return handlePortfolioSlash('status');
+    case 'balance':
+      return handlePortfolioSlash('balance');
+    case 'positions':
+      return handlePortfolioSlash('positions');
+    case 'orders':
+      return handlePortfolioSlash('orders');
+
+    // ─── Trading ─────────────────────────────────────────────────────
+    case 'buy':
+      return handleTradeCommand('buy', args);
+    case 'sell':
+      return handleTradeCommand('sell', args);
+    case 'cancel':
+      return handleCancel(args[0]);
+
+    // ─── /search themes (inline) ─────────────────────────────────────
+    // Note: /search <non-themes> is handled in cli.ts via browseController
+    case 'themes': {
+      const resp = await handleThemes(defaultArgs({ subcommand: 'themes' }));
+      return { output: formatThemesHuman(resp.data) };
+    }
+
+    // ─── /analyze ────────────────────────────────────────────────────
+    case 'analyze':
+      return handleAnalyzeCommand(args);
+
+    // ─── /review ─────────────────────────────────────────────────────
+    case 'review':
+      return handleReviewCommand();
+
+    // ─── /backtest ───────────────────────────────────────────────────
+    case 'backtest': {
+      // Parse backtest-specific flags from slash command args
+      const btArgs: Partial<ParsedArgs> = { subcommand: 'backtest' };
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--resolved') btArgs.resolved = true;
+        else if (a === '--unresolved') btArgs.unresolved = true;
+        else if (a === '--category') btArgs.category = args[++i];
+        else if (a === '--days') { const v = Number(args[++i]); if (Number.isFinite(v) && v > 0) btArgs.days = v; }
+        else if (a === '--max-age') { const v = Number(args[++i]); if (Number.isFinite(v) && v > 0) btArgs.maxAge = v; }
+        else if (a === '--min-edge') { const v = Number(args[++i]?.replace('%', '')); if (Number.isFinite(v)) btArgs.minEdge = v / 100; }
+        else if (a === '--min-volume') { const v = Number(args[++i]); if (Number.isFinite(v) && v >= 0) btArgs.minVolume = v; }
+        else if (a === '--min-price') { const v = Number(args[++i]); if (Number.isFinite(v) && v >= 0 && v <= 100) btArgs.minPrice = v; }
+        else if (a === '--max-price') { const v = Number(args[++i]); if (Number.isFinite(v) && v >= 0 && v <= 100) btArgs.maxPrice = v; }
+        else if (a === '--export') { const v = args[++i]; if (v) btArgs.exportPath = v; }
+      }
+      const mode = btArgs.resolved ? 'resolved markets' : btArgs.unresolved ? 'open markets' : 'resolved + open markets';
+      const daysLabel = btArgs.days ?? 15;
+      return {
+        output: `Running ${daysLabel}-day backtest on ${mode}...`,
+        asyncFollowUp: async () => {
+          const resp = await handleBacktest(defaultArgs(btArgs));
+          if (!resp.ok || !resp.data) return resp.error?.message ?? 'Backtest failed';
+          const text = formatBacktestHuman(resp.data, { minEdge: btArgs.minEdge ?? 0.005 });
+          return btArgs.exportPath
+            ? `${text}\n\nExported per-market detail to ${btArgs.exportPath}`
+            : text;
+        },
+      };
+    }
+
+    case 'config':
+      // Fall through to agent — better handled by the LLM
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+export async function executePendingTrade(trade: NonNullable<CommandResult['pendingTrade']>): Promise<string> {
+  let effectivePrice = trade.price;
+  // When no price given, fetch best quote to simulate a market order
+  if (effectivePrice === undefined) {
+    const quoteResult = await fetchMarketQuote(trade.ticker, trade.action, trade.side);
+    if ('error' in quoteResult) return quoteResult.error;
+    effectivePrice = quoteResult.cents;
+  }
+  const body: Record<string, unknown> = {
+    ticker: trade.ticker,
+    action: trade.action,
+    side: trade.side,
+    type: 'limit',
+    count: trade.count,
+    ...(trade.side === 'no'
+      ? { no_price: effectivePrice }
+      : { yes_price: effectivePrice }),
+  };
+
+  const data = await callKalshiApi('POST', '/portfolio/orders', { body });
+  const order = data.order as Record<string, unknown> | undefined;
+  trackEvent('trade_executed', { action: trade.action, side: trade.side, success: 'true' });
+  if (order) {
+    return `Order placed. ID: ${order.order_id} | Status: ${order.status}`;
+  }
+  return `Order submitted. Response: ${JSON.stringify(data)}`;
+}
+
+// ─── Portfolio subview handler ──────────────────────────────────────────────
+
+async function handlePortfolioSlash(subview?: string): Promise<CommandResult> {
+  const view = subview?.toLowerCase() ?? 'overview';
+
+  try {
+    if (view === 'positions') {
+      const data = await callKalshiApi('GET', '/portfolio/positions');
+      const allPositions = (data.market_positions ?? data.positions ?? []) as KalshiPosition[];
+      const positions = allPositions.filter((p) => {
+        const pos = parseFloat(String(p.position ?? '0'));
+        return pos !== 0;
+      });
+      return { output: formatPositions(positions) };
+    }
+
+    if (view === 'orders') {
+      const data = await callKalshiApi('GET', '/portfolio/orders', { params: { status: 'resting' } });
+      const orders = (data.orders ?? []) as KalshiOrder[];
+      return { output: formatOrders(orders) };
+    }
+
+    if (view === 'balance') {
+      const data = await callKalshiApi('GET', '/portfolio/balance') as unknown as KalshiBalanceResponse;
+      return { output: formatBalance(data) };
+    }
+
+    if (view === 'status') {
+      const data = await callKalshiApi('GET', '/exchange/status');
+      return { output: formatExchangeStatus(data) };
+    }
+
+    // Default: full portfolio overview
+    const resp = await handlePortfolio(defaultArgs({ subcommand: 'portfolio' }));
+    return { output: formatPortfolioHuman(resp.data) };
+  } catch (err) {
+    return { output: `Portfolio error: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+// ─── Analyze ────────────────────────────────────────────────────────────────
+
+async function handleAnalyzeCommand(args: string[]): Promise<CommandResult> {
+  const ticker = args[0];
+  if (!ticker) return { output: 'Usage: /analyze <ticker> [refresh]' };
+  const refresh = args[1]?.toLowerCase() === 'refresh';
+  try {
+    const data = await handleAnalyze(ticker.toUpperCase(), refresh);
+    return { output: formatAnalyzeHuman(data) };
+  } catch (err) {
+    return { output: `Analyze failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+// ─── Trade command ──────────────────────────────────────────────────────────
+
+function parseSide(val: string | undefined): 'yes' | 'no' | null {
+  const v = val?.toLowerCase();
+  if (v === 'yes' || v === 'y') return 'yes';
+  if (v === 'no' || v === 'n') return 'no';
+  return null;
+}
+
+function handleTradeCommand(action: 'buy' | 'sell', args: string[]): CommandResult {
+  const [ticker, countStr, ...rest] = args;
+
+  if (!ticker || !countStr) {
+    return { output: `Usage: /${action} <ticker> <count> [price_in_cents] [yes|no]` };
+  }
+
+  // Extract side and price from remaining args: [price] [side], [side], or nothing
+  let side: 'yes' | 'no' = 'yes';
+  let priceArg: string | undefined;
+
+  if (rest.length >= 2) {
+    // e.g. /buy TICKER 10 50 no
+    priceArg = rest[0];
+    side = parseSide(rest[1]) ?? 'yes';
+  } else if (rest.length === 1) {
+    // Could be price or side: /buy TICKER 10 50  OR  /buy TICKER 10 no
+    const asSide = parseSide(rest[0]);
+    if (asSide) {
+      side = asSide;
+    } else {
+      priceArg = rest[0];
+    }
+  }
+
+  const validated = validateTradeArgs(countStr, priceArg);
+  if ('error' in validated) {
+    return { output: validated.error };
+  }
+
+  const pendingTrade = { ticker: ticker.toUpperCase(), action, side, count: validated.count, price: validated.price };
+
+  return {
+    output: formatOrderConfirmation(ticker.toUpperCase(), action, side, validated.count, validated.price),
+    pendingTrade,
+  };
+}
+
+async function handleReviewCommand(): Promise<CommandResult> {
+  try {
+    const reviews = await reviewPortfolio();
+    return { output: formatReviewHuman(reviews) };
+  } catch (err) {
+    return { output: `Review failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+async function handleCancel(orderId: string | undefined): Promise<CommandResult> {
+  if (!orderId) return { output: 'Usage: /cancel <order_id>' };
+
+  try {
+    await callKalshiApi('DELETE', `/portfolio/orders/${orderId}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const hint = msg.includes('404') ? ' (order not found or already filled)' : '';
+    return { output: `Cancel failed: ${msg}${hint}` };
+  }
+  return { output: `Order ${orderId} canceled.` };
+}

package/src/commands/json.ts

@@ -0,0 +1,43 @@
+export interface CLIResponse<T> {
+  ok: boolean;
+  command: string;
+  timestamp: string;
+  data: T;
+  meta?: {
+    scan_id?: string;
+    theme?: string;
+    events_scanned?: number;
+    actionable?: number;
+    octagon_cache_hits?: number;
+    octagon_fresh_reports?: number;
+    octagon_credits_used?: number;
+    bankroll?: {
+      cash_balance: number;
+      portfolio_value: number;
+      open_exposure: number;
+      available: number;
+      positions_count: number;
+    };
+  };
+  error?: { code: string; message: string };
+}
+
+export function wrapSuccess<T>(command: string, data: T, meta?: CLIResponse<T>['meta']): CLIResponse<T> {
+  return {
+    ok: true,
+    command,
+    timestamp: new Date().toISOString(),
+    data,
+    ...(meta ? { meta } : {}),
+  };
+}
+
+export function wrapError(command: string, code: string, message: string): CLIResponse<never> {
+  return {
+    ok: false,
+    command,
+    timestamp: new Date().toISOString(),
+    data: undefined as never,
+    error: { code, message },
+  };
+}

package/src/commands/parse-args.ts

@@ -0,0 +1,229 @@
+const SUBCOMMANDS = [
+  // Core 6 commands
+  'search', 'portfolio', 'analyze', 'watch',
+  'buy', 'sell', 'cancel', 'help',
+  // Legacy aliases (kept for backward compat)
+  'edge',
+  'alerts', 'config', 'clear-cache', 'chat', 'init', 'status', 'themes',
+  // Backtest
+  'backtest',
+] as const;
+
+export type Subcommand = (typeof SUBCOMMANDS)[number];
+
+export interface ParsedArgs {
+  subcommand: Subcommand;
+  positionalArgs: string[];
+  json: boolean;
+  theme?: string;
+  ticker?: string;
+  interval?: number;
+  since?: string;
+  minConfidence?: string;
+  minEdge?: number;
+  live: boolean;
+  refresh: boolean;
+  report: boolean;
+  side?: 'yes' | 'no';
+  dryRun: boolean;
+  verbose: boolean;
+  performance: boolean;
+  // Backtest-specific
+  resolved: boolean;
+  unresolved: boolean;
+  days?: number;
+  maxAge?: number;
+  category?: string;
+  limit?: number;
+  exportPath?: string;
+  minVolume?: number;
+  minPrice?: number;
+  maxPrice?: number;
+  parseErrors: string[];
+}
+
+export function parseArgs(argv: string[] = process.argv.slice(2)): ParsedArgs {
+  const positionalArgs: string[] = [];
+  let json = false;
+  let theme: string | undefined;
+  let ticker: string | undefined;
+  let interval: number | undefined;
+  let since: string | undefined;
+  let minConfidence: string | undefined;
+  let minEdge: number | undefined;
+  let live = false;
+  let refresh = false;
+  let report = false;
+  let side: 'yes' | 'no' | undefined;
+  const parseErrors: string[] = [];
+  let dryRun = false;
+  let verbose = false;
+  let performance = false;
+  let resolved = false;
+  let unresolved = false;
+  let days: number | undefined;
+  let category: string | undefined;
+  let limit: number | undefined;
+  let exportPath: string | undefined;
+  let maxAge: number | undefined;
+  let minVolume: number | undefined;
+  let minPrice: number | undefined;
+  let maxPrice: number | undefined;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === '--json') {
+      json = true;
+    } else if (arg === '--theme') {
+      const val = argv[++i];
+      if (val != null) {
+        theme = val;
+      } else {
+        parseErrors.push('--theme requires a value');
+      }
+    } else if (arg === '--ticker') {
+      const val = argv[++i];
+      if (val != null) {
+        ticker = val;
+      } else {
+        parseErrors.push('--ticker requires a value');
+      }
+    } else if (arg === '--interval') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric > 0) {
+          interval = numeric;
+        } else {
+          parseErrors.push(`Invalid --interval value: "${raw}" (expected a positive number)`);
+        }
+      } else {
+        parseErrors.push('--interval requires a value');
+      }
+    } else if (arg === '--since') {
+      const val = argv[++i];
+      if (val != null) {
+        since = val;
+      } else {
+        parseErrors.push('--since requires a value');
+      }
+    } else if (arg === '--min-confidence') {
+      const val = argv[++i];
+      if (val != null) {
+        minConfidence = val.toLowerCase();
+      } else {
+        parseErrors.push('--min-confidence requires a value');
+      }
+    } else if (arg === '--min-edge') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw.replace('%', ''));
+        if (Number.isFinite(numeric)) {
+          minEdge = numeric / 100;
+        } else {
+          parseErrors.push(`Invalid --min-edge value: "${raw}" (expected a number like 5 or 5%)`);
+        }
+      } else {
+        parseErrors.push('--min-edge requires a value (e.g., --min-edge 5 or --min-edge 5%)');
+      }
+    } else if (arg === '--side') {
+      const val = argv[++i];
+      if (val == null) {
+        parseErrors.push('--side requires a value (expected "yes" or "no")');
+      } else {
+        const lower = val.toLowerCase();
+        if (lower === 'yes' || lower === 'no') {
+          side = lower;
+        } else {
+          parseErrors.push(`Invalid --side value: "${val}" (expected "yes" or "no")`);
+        }
+      }
+    } else if (arg === '--live') {
+      live = true;
+    } else if (arg === '--refresh') {
+      refresh = true;
+    } else if (arg === '--report') {
+      report = true;
+    } else if (arg === '--dry-run') {
+      dryRun = true;
+    } else if (arg === '--verbose') {
+      verbose = true;
+    } else if (arg === '--performance') {
+      performance = true;
+    } else if (arg === '--resolved') {
+      resolved = true;
+    } else if (arg === '--unresolved') {
+      unresolved = true;
+    } else if (arg === '--category') {
+      const val = argv[++i];
+      if (val != null) { category = val; } else { parseErrors.push('--category requires a value'); }
+    } else if (arg === '--days') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric > 0) { days = numeric; }
+        else { parseErrors.push(`Invalid --days value: "${raw}" (expected a positive number)`); }
+      } else { parseErrors.push('--days requires a value'); }
+    } else if (arg === '--limit') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric > 0) { limit = numeric; }
+        else { parseErrors.push(`Invalid --limit value: "${raw}" (expected a positive number)`); }
+      } else { parseErrors.push('--limit requires a value'); }
+    } else if (arg === '--export') {
+      const val = argv[++i];
+      if (val != null) { exportPath = val; } else { parseErrors.push('--export requires a value'); }
+    } else if (arg === '--max-age') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric > 0) { maxAge = numeric; }
+        else { parseErrors.push(`Invalid --max-age value: "${raw}" (expected a positive number)`); }
+      } else { parseErrors.push('--max-age requires a value'); }
+    } else if (arg === '--min-volume') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric >= 0) { minVolume = numeric; }
+        else { parseErrors.push(`Invalid --min-volume value: "${raw}" (expected a non-negative number)`); }
+      } else { parseErrors.push('--min-volume requires a value'); }
+    } else if (arg === '--min-price') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric >= 0 && numeric <= 100) { minPrice = numeric; }
+        else { parseErrors.push(`Invalid --min-price value: "${raw}" (expected 0-100)`); }
+      } else { parseErrors.push('--min-price requires a value'); }
+    } else if (arg === '--max-price') {
+      const raw = argv[++i];
+      if (raw != null) {
+        const numeric = Number(raw);
+        if (Number.isFinite(numeric) && numeric >= 0 && numeric <= 100) { maxPrice = numeric; }
+        else { parseErrors.push(`Invalid --max-price value: "${raw}" (expected 0-100)`); }
+      } else { parseErrors.push('--max-price requires a value'); }
+    } else if (arg.startsWith('--')) {
+      parseErrors.push(`Unknown flag: ${arg}`);
+    } else {
+      positionalArgs.push(arg);
+    }
+  }
+
+  if (resolved && unresolved) {
+    parseErrors.push('Cannot use --resolved and --unresolved together');
+  }
+
+  const first = positionalArgs.shift();
+  const subcommand: Subcommand =
+    first && (SUBCOMMANDS as readonly string[]).includes(first)
+      ? (first as Subcommand)
+      : 'chat';
+
+  // If first arg wasn't a known subcommand, put it back as a positional
+  if (first && !(SUBCOMMANDS as readonly string[]).includes(first)) {
+    positionalArgs.unshift(first);
+  }
+
+  return { subcommand, positionalArgs, json, theme, ticker, interval, since, minConfidence, minEdge, side, live, refresh, report, dryRun, verbose, performance, resolved, unresolved, days, maxAge, category, limit, exportPath, minVolume, minPrice, maxPrice, parseErrors };
+}