horizon-code 0.1.2 → 0.3.0

package/bin/horizon.js

@@ -1,2 +1,19 @@
 #!/usr/bin/env bun
-import "../src/index.ts";
+import { checkForUpdates } from "../src/updater.ts";
+
+// Auto-update before loading the app
+const { updated, from, to } = await checkForUpdates();
+if (updated) {
+  // Re-exec so the new version's code loads
+  process.stderr.write(`\x1b[2mUpdated ${from} → ${to}. Restarting...\x1b[0m\n`);
+  const result = Bun.spawnSync(["bun", "run", import.meta.path], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, __HORIZON_SKIP_UPDATE: "1" },
+  });
+  process.exit(result.exitCode ?? 0);
+}
+
+// Load the app
+import("../src/index.ts");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "horizon-code",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "AI-powered trading strategy terminal for Polymarket",
   "type": "module",
   "bin": {

package/src/ai/client.ts

@@ -152,6 +152,7 @@ import { zodSchema } from "@ai-sdk/provider-utils";
 
 function toolsToServerFormat(tools: Record<string, any>): Record<string, any> {
   const result: Record<string, any> = {};
+  let failures = 0;
   for (const [name, tool] of Object.entries(tools)) {
     if (!tool) continue;
     let params: any = { type: "object", properties: {} };
@@ -184,17 +185,26 @@ async function callServer(opts: {
   const config = loadConfig();
   if (!config.api_key) throw new Error("Not authenticated. Type /login.");
 
+  const toolPayload = toolsToServerFormat(opts.tools);
+  const body = JSON.stringify({
+    messages: opts.messages,
+    system: opts.system,
+    model_power: opts.modelPower,
+    tools: toolPayload,
+    response_format: opts.responseFormat,
+  });
+
+  // Use the caller's abort signal, with a fallback 2-min timeout
+  const timeoutSignal = AbortSignal.timeout(120000);
+  const combinedSignal = opts.signal
+    ? AbortSignal.any([opts.signal, timeoutSignal])
+    : timeoutSignal;
+
   const res = await fetch(`${getAuthUrl()}/api/v1/chat`, {
     method: "POST",
-    signal: opts.signal ?? AbortSignal.timeout(120000), // 2 min max
+    signal: combinedSignal,
     headers: { "Authorization": `Bearer ${config.api_key}`, "Content-Type": "application/json" },
-    body: JSON.stringify({
-      messages: opts.messages,
-      system: opts.system,
-      model_power: opts.modelPower,
-      tools: toolsToServerFormat(opts.tools),
-      response_format: opts.responseFormat,
-    }),
+    body,
   });
 
   if (!res.ok) {
@@ -248,7 +258,12 @@ export async function* chat(
         signal,
       });
     } catch (err: any) {
+      if (signal.aborted) {
+        yield { type: "finish" };
+        return;
+      }
       yield { type: "error", message: err.message };
+      yield { type: "finish" };
       return;
     }
 
@@ -262,6 +277,7 @@ export async function* chat(
     let eventCount = 0;
 
     for await (const event of consumeSSE(res)) {
+      if (signal.aborted) break;
       eventCount++;
       if (event.type === "meta") {
         yield {
@@ -323,6 +339,9 @@ export async function* chat(
     if (!hasToolCalls || pendingToolCalls.length === 0) {
       if (eventCount === 0) {
         yield { type: "error", message: "No response from server. Check your connection or try again." };
+      } else if (!hasToolCalls && jsonBuf === "" && emittedResponseLen === 0) {
+        // Server sent events (meta, usage) but no actual content
+        yield { type: "text-delta", textDelta: "*(Server returned no content. This may happen if the model is overloaded. Try again.)*" };
       }
       yield { type: "finish" };
       return;
@@ -351,6 +370,12 @@ export async function* chat(
       }
     }
 
+    // If aborted during tool execution, stop
+    if (signal.aborted) {
+      yield { type: "finish" };
+      return;
+    }
+
     // Add as assistant message — the LLM sees it already ran the tools
     serverMessages.push({ role: "assistant", content: assistantParts.join("\n\n") });
     // Prompt the LLM to continue with its response based on the tool results

package/src/ai/system-prompt.ts

@@ -15,7 +15,7 @@ const MODE_PROMPTS: Record<Mode, string> = {
 
 ## Mode: Research
 
-You have 13 research tools that fetch LIVE data from Polymarket, Kalshi, and the web. Use them.
+You have 29 research tools that fetch LIVE data from Polymarket, Kalshi, stocks, and the web. Use them.
 
 ### CRITICAL RULE
 When the user mentions ANY topic, event, market, or asks about what's happening — ALWAYS call a tool to search for real data. Never answer from your training data alone. Prediction markets change by the minute.
@@ -33,24 +33,66 @@ When the user mentions ANY topic, event, market, or asks about what's happening
 - kalshiEvents(query) — search Kalshi markets
 - webSearch(query) — search the internet for news, facts, context
 - calaKnowledge(query) — deep research on companies, people, industries
+- liquidityScanner(query, limit) — scan top markets ranked by liquidity, spread, volume
 
-**Analyze a specific market (requires a slug from polymarketEvents):**
+**Analyze a specific Polymarket (requires a slug from polymarketEvents):**
 - polymarketEventDetail(slug) — full details, sub-markets, price history, spreads
 - polymarketPriceHistory(slug, interval) — price chart (1h/6h/1d/1w/1m/max)
 - polymarketOrderBook(slug) — bid/ask depth
 - whaleTracker(slug) — large trades, smart money flow
 - newsSentiment(slug) — news sentiment score + articles
-- historicalVolatility(slug, interval) — realized vol, regime detection
+- historicalVolatility(slug, interval) — multi-estimator vol (close-to-close, Parkinson, Garman-Klass, EWMA), regime detection
+- marketMicrostructure(slug) — depth imbalance, effective spread, Kyle's lambda, liquidity score
+
+**Analyze a specific Kalshi market (requires a ticker from kalshiEvents):**
+- kalshiEventDetail(ticker) — full details, all sub-markets, spreads, volumes
+- kalshiOrderBook(ticker) — bid/ask depth for a Kalshi market
+- kalshiPriceHistory(ticker, period) — price chart for a Kalshi market
+
+**Whale & wallet analysis (requires wallet address from whaleTracker results):**
+- walletProfiler(address) — score a wallet: win rate, PnL, Sharpe, edge category (smart_money/neutral/weak_hand/bot)
+- botDetector(slug) — detect bots in a market: classify top traders, identify strategy types (market_maker, grid_bot, momentum, sniper)
+- marketFlow(slug, limit) — deep flow analysis: buy/sell volume, wallet concentration (Herfindahl), top movers
 
 **Quantitative analysis:**
 - evCalculator(slug, side, estimatedEdge, bankroll) — expected value + Kelly sizing
 - probabilityCalculator(slugA, slugB) — joint/conditional probability
 - compareMarkets(topic) — cross-platform price comparison (Polymarket vs Kalshi)
+- correlationAnalysis(slugA, slugB, interval) — price correlation, beta, dual sparklines between two markets
+- riskMetrics(slug, interval, confidenceLevel) — VaR, CVaR, max drawdown, Sharpe, Sortino, Calmar, skewness, kurtosis
+- marketRegime(slug, interval) — Hurst exponent, variance ratio, entropy — detect if market is trending, mean-reverting, or efficient
 
-### Tool Chaining
-When the user refers to a market from a previous result, reuse the SLUG from that result. Don't call polymarketEvents again — go straight to the detail tool. Look at conversation history for slugs.
+**Stock market (Yahoo Finance — free, no API key needed):**
+- stockQuote(symbols) — real-time quotes: price, change, volume, market cap, P/E, 52-week range, moving averages. Comma-separated: "AAPL,MSFT,TSLA"
+- stockChart(symbol, range, interval) — price chart with sparkline. Ranges: 1d, 5d, 1mo, 3mo, 6mo, 1y, 5y, max
+- stockSearch(query) — search tickers by name/keyword: "electric vehicles", "gold ETF"
+- stockScreener(symbols) — compare stocks side-by-side: P/E, market cap, 52-week, moving averages
 
-Use your intelligence to understand what the user wants. If they say "dig deeper into the first one" — that means polymarketEventDetail with the first slug. If they say "what do whales think" — that means whaleTracker. You're smart enough to figure this out without a flowchart.`,
+**Visualization:**
+- openChart(source, identifier, range) — open interactive Chart.js chart in browser. source: "polymarket" or "stock". Great for detailed analysis.
+
+### Tool Chaining
+When the user refers to a market from a previous result, reuse the SLUG (Polymarket) or TICKER (Kalshi) from that result. Don't search again — go straight to the detail tool.
+
+Use your intelligence to understand what the user wants:
+- "dig deeper" → polymarketEventDetail or kalshiEventDetail
+- "what do whales think" → whaleTracker
+- "show me the order book" → polymarketOrderBook or kalshiOrderBook
+- "how liquid is this" → marketMicrostructure
+- "do these markets correlate" → correlationAnalysis
+- "what's the best market to trade" → liquidityScanner
+- "compare Polymarket and Kalshi" → compareMarkets
+- "what's the volatility" → historicalVolatility (now shows 4 estimators)
+- "show me the Kalshi chart" → kalshiPriceHistory
+- "who are the bots" → botDetector
+- "analyze this wallet" → walletProfiler (needs 0x address from whaleTracker)
+- "where is the money flowing" → marketFlow
+- "what's the risk" → riskMetrics (VaR, CVaR, Sharpe, drawdown)
+- "is this market trending" → marketRegime (Hurst exponent, variance ratio)
+- "show me AAPL" → stockQuote("AAPL")
+- "compare big tech" → stockScreener("AAPL,MSFT,GOOG,AMZN,META")
+- "chart this" → openChart (opens interactive chart in browser)
+- "search for AI stocks" → stockSearch("artificial intelligence")`,
 
   strategy: "", // dynamically generated
 

package/src/app.ts

@@ -1,4 +1,4 @@
-import { BoxRenderable, ScrollBoxRenderable, type CliRenderer } from "@opentui/core";
+import { BoxRenderable, TextRenderable, ScrollBoxRenderable, type CliRenderer } from "@opentui/core";
 import { COLORS, setTheme, ULTRA_THEMES } from "./theme/colors.ts";
 import { Footer } from "./components/footer.ts";
 import { Splash } from "./components/splash.ts";
@@ -13,12 +13,14 @@ import { ModeBar } from "./components/mode-bar.ts";
 import { TabBar } from "./components/tab-bar.ts";
 import { InputBar } from "./components/input-bar.ts";
 import { ChatRenderer } from "./chat/renderer.ts";
+import { renderToolWidget } from "./research/widgets.ts";
+import { renderStrategyWidget } from "./strategy/widgets.ts";
 import { KeyHandler } from "./keys/handler.ts";
 import { store } from "./state/store.ts";
 import { createUserMessage } from "./chat/messages.ts";
 import { chat } from "./ai/client.ts";
 import { dashboard } from "./strategy/dashboard.ts";
-import { cleanupStrategyProcesses, runningProcesses } from "./strategy/tools.ts";
+import { cleanupStrategyProcesses, runningProcesses, parseLocalMetrics } from "./strategy/tools.ts";
 import { abortChat } from "./ai/client.ts";
 import type { ModelPower } from "./platform/tiers.ts";
 import { listSavedStrategies, loadStrategy } from "./strategy/persistence.ts";
@@ -26,6 +28,7 @@ import { autoFixStrategyCode } from "./strategy/validator.ts";
 import { CodeFenceDetector, finalizeStrategy, isStrategyCode, extractStrategyName } from "./strategy/code-stream.ts";
 import { loginWithBrowser, loginWithPassword, signOut, isLoggedIn, getUser } from "./platform/supabase.ts";
 import { loadConfig, saveConfig, setEncryptedEnv, removeEncryptedEnv, listEncryptedEnvNames } from "./platform/config.ts";
+import { EXCHANGE_PROFILES, getExchangeStatuses, getExchangeStatus } from "./platform/exchanges.ts";
 import { getTreeSitterClient, destroyTreeSitterClient } from "./syntax/setup.ts";
 import type { Message } from "./chat/types.ts";
 
@@ -33,7 +36,11 @@ import type { Message } from "./chat/types.ts";
 const WIDGET_TOOLS = new Set([
   "polymarketEvents", "polymarketEventDetail", "polymarketPriceHistory",
   "polymarketOrderBook", "whaleTracker", "newsSentiment", "evCalculator",
-  "kalshiEvents", "compareMarkets", "historicalVolatility",
+  "kalshiEvents", "kalshiEventDetail", "kalshiOrderBook", "kalshiPriceHistory",
+  "compareMarkets", "historicalVolatility",
+  "marketMicrostructure", "liquidityScanner", "correlationAnalysis",
+  "walletProfiler", "botDetector", "marketFlow", "riskMetrics", "marketRegime",
+  "stockQuote", "stockChart", "stockSearch", "stockScreener",
   "webSearch", "calaKnowledge", "probabilityCalculator",
   "edit_strategy", "validate_strategy",
   "backtest_strategy", "polymarket_data",
@@ -65,6 +72,8 @@ const SLASH_COMMANDS: Record<string, { description: string; usage: string }> = {
   "/strategies": { description: "List saved strategies", usage: "/strategies" },
   "/load":    { description: "Load a saved strategy", usage: "/load <name>" },
   "/env":     { description: "Manage encrypted API keys", usage: "/env [list|add|remove]" },
+  "/connect": { description: "Connect an exchange", usage: "/connect [polymarket|kalshi|alpaca|...]" },
+  "/exchanges": { description: "Show exchange connection status", usage: "/exchanges" },
   "/quit":    { description: "Exit Horizon", usage: "/quit" },
   "/exit":    { description: "Exit Horizon", usage: "/exit" },
 };
@@ -92,6 +101,7 @@ export class App {
   private inChatMode = false;
   private authenticated = false;
   private _openIdsSaveTimer: ReturnType<typeof setTimeout> | null = null;
+  private _hasLocalMetrics = false;
 
   // Per-tab stream state
   private tabStreams: Map<string, {
@@ -403,6 +413,27 @@ export class App {
           this.codePanel.setStrategy(draft.name, draft.phase);
         }
 
+        // Feed active deployment metrics into the dashboard tab
+        // Skip if local process metrics are active (they take priority)
+        if (!this._hasLocalMetrics) {
+          const state = store.get();
+          const running = state.deployments.find((d) => d.status === "running" || d.status === "starting");
+          if (running) {
+            this.codePanel.setMetrics({
+              name: running.name,
+              status: running.status,
+              dryRun: running.dry_run,
+              metrics: running.metrics,
+              positions: running.positions,
+              orders: running.orders,
+              pnlHistory: running.pnl_history,
+              startedAt: running.started_at,
+            });
+          } else {
+            this.codePanel.setMetrics(null);
+          }
+        }
+
         // Sync code panel visibility to key handler for Tab cycling
         this.keyHandler.codePanelVisible = this.codePanel.visible;
 
@@ -412,28 +443,82 @@ export class App {
 
     renderer.on("resize", () => renderer.requestRender());
 
-    // Poll background processes — update count, live logs, clean dead processes
+    // Poll background processes — update count, live logs, parse metrics, clean dead
     setInterval(() => {
       let alive = 0;
       let latestLogs = "";
       const deadPids: number[] = [];
       const now = Date.now();
+      let localMetricsData: ReturnType<typeof parseLocalMetrics> = null;
+      let localProcessStartedAt = 0;
 
       for (const [pid, m] of runningProcesses) {
         if (m.proc.exitCode === null) {
           alive++;
-          const recent = m.stdout.slice(-30).join("\n");
-          const recentErr = m.stderr.slice(-5).join("\n");
-          latestLogs = recent + (recentErr ? "\n--- stderr ---\n" + recentErr : "");
+          // Filter out __HZ_METRICS__ lines from visible logs
+          const stdoutLines = m.stdout.slice(-30);
+          const stderrLines = m.stderr.slice(-10).filter((l: string) => !l.startsWith("__HZ_METRICS__"));
+          latestLogs = stdoutLines.join("\n") + (stderrLines.length > 0 ? "\n--- stderr ---\n" + stderrLines.join("\n") : "");
+
+          // Parse latest metrics from this process
+          const metrics = parseLocalMetrics(m);
+          if (metrics) {
+            localMetricsData = metrics;
+            localProcessStartedAt = m.startedAt;
+          }
         } else if (now - m.startedAt > 300000) {
-          // Dead for 5+ minutes — clean up
           deadPids.push(pid);
         }
       }
       for (const pid of deadPids) runningProcesses.delete(pid);
 
       this.modeBar.setBgProcessCount(alive);
-      // Only update logs tab if it's visible (avoid unnecessary markdown re-parse)
+
+      // Feed local metrics to the Metrics tab (takes priority over platform deployments)
+      if (localMetricsData) {
+        const draft = store.getActiveSession()?.strategyDraft;
+        this.codePanel.setMetrics({
+          name: draft?.name ?? "Local Strategy",
+          status: "running",
+          dryRun: true,
+          metrics: {
+            total_pnl: localMetricsData.pnl,
+            realized_pnl: localMetricsData.rpnl,
+            unrealized_pnl: localMetricsData.upnl,
+            total_exposure: 0,
+            position_count: localMetricsData.positions,
+            open_order_count: localMetricsData.orders,
+            win_rate: 0,
+            total_trades: 0,
+            max_drawdown_pct: 0,
+            sharpe_ratio: 0,
+            profit_factor: 0,
+            avg_return_per_trade: 0,
+            gross_profit: 0,
+            gross_loss: 0,
+          },
+          positions: (localMetricsData.pos ?? []).map((p) => ({
+            market_id: p.id,
+            slug: p.id,
+            question: "",
+            side: p.side === "Yes" || p.side === "Buy" ? "BUY" as const : "SELL" as const,
+            size: p.sz,
+            avg_entry_price: p.entry,
+            cost_basis: p.sz * p.entry,
+            realized_pnl: p.rpnl,
+            unrealized_pnl: p.upnl,
+          })),
+          orders: [],
+          pnlHistory: localMetricsData.hist ?? [],
+          startedAt: localProcessStartedAt,
+        });
+        this._hasLocalMetrics = true;
+      } else if (this._hasLocalMetrics && alive === 0) {
+        // Local process stopped — clear local metrics, let platform data take over
+        this._hasLocalMetrics = false;
+        store.update({});
+      }
+
       if (alive > 0 && latestLogs && this.codePanel.visible && this.codePanel.activeTab === "logs") {
         this.codePanel.setLogs(latestLogs);
       }
@@ -655,7 +740,7 @@ export class App {
         const code = autoFixStrategyCode(loaded.code);
         store.setStrategyDraft({
           name: arg, code, params: {}, explanation: "", riskConfig: null,
-          validationStatus: "none", validationErrors: [], phase: "generated",
+          validationStatus: "none", validationErrors: [], validationWarnings: [], phase: "generated",
         });
         this.codePanel.setCode(code, "pending");
         this.codePanel.setStrategy(arg, "loaded");
@@ -693,6 +778,50 @@ export class App {
         }
         break;
       }
+      case "/connect": {
+        const exchangeId = arg.trim().toLowerCase();
+        if (!exchangeId) {
+          const statuses = getExchangeStatuses();
+          const lines = statuses.map(s => {
+            const icon = s.status === "connected" ? "●" : s.status === "partial" ? "◐" : "○";
+            const color = s.status === "connected" ? "green" : s.status === "partial" ? "yellow" : "dim";
+            return `  ${icon} ${s.profile.name.padEnd(20)} ${s.status.padEnd(14)} ${s.profile.category}`;
+          });
+          this.showSystemMsg(`Exchange Connections:\n${lines.join("\n")}\n\nUse /connect <exchange> to set up keys.`);
+        } else {
+          const profile = EXCHANGE_PROFILES.find(p => p.id === exchangeId || p.name.toLowerCase() === exchangeId);
+          if (!profile) {
+            const ids = EXCHANGE_PROFILES.map(p => p.id).join(", ");
+            this.showSystemMsg(`Unknown exchange: ${exchangeId}. Available: ${ids}`);
+          } else {
+            const status = getExchangeStatus(profile.id);
+            const lines = profile.keys.map(k => {
+              const isSet = status?.keysSet.includes(k.env);
+              return `  ${isSet ? "●" : "○"} ${k.label.padEnd(18)} ${k.env.padEnd(28)} ${isSet ? "set" : k.required ? "REQUIRED" : "optional"}`;
+            });
+            this.showSystemMsg(
+              `${profile.name} — ${profile.description}\n${lines.join("\n")}\n\n` +
+              `Set keys with: /env add <ENV_NAME> <value>\n` +
+              `Example: /env add ${profile.keys[0].env} <your-key>`
+            );
+          }
+        }
+        break;
+      }
+      case "/exchanges": {
+        const statuses = getExchangeStatuses();
+        const connected = statuses.filter(s => s.status === "connected");
+        const partial = statuses.filter(s => s.status === "partial");
+        const disconnected = statuses.filter(s => s.status === "disconnected");
+
+        let msg = "Exchange Status:\n";
+        if (connected.length > 0) msg += `\nConnected:\n${connected.map(s => `  ● ${s.profile.name} (${s.profile.category})`).join("\n")}`;
+        if (partial.length > 0) msg += `\nPartial:\n${partial.map(s => `  ◐ ${s.profile.name} — missing: ${s.keysMissing.join(", ")}`).join("\n")}`;
+        if (disconnected.length > 0) msg += `\nNot Connected:\n${disconnected.map(s => `  ○ ${s.profile.name}`).join("\n")}`;
+        msg += "\n\nUse /connect <exchange> to set up.";
+        this.showSystemMsg(msg);
+        break;
+      }
       case "/quit":
       case "/exit":
         this.quit();
@@ -1198,7 +1327,33 @@ export class App {
           }
 
           if (WIDGET_TOOLS.has(part.toolName)) {
-            currentBlocks.push({ type: "tool-widget", toolName: part.toolName, widgetData: part.result });
+            const { showWidgets, widgetsInTab } = this.settingsPanel.settings;
+            if (showWidgets && !widgetsInTab) {
+              // Render inline in chat (default)
+              currentBlocks.push({ type: "tool-widget", toolName: part.toolName, widgetData: part.result });
+            } else if (showWidgets && widgetsInTab) {
+              // Render in the widgets tab
+              try {
+                const result = part.result;
+                // Skip error results — they'd render as empty widgets
+                if (result && typeof result === "object" && "error" in (result as any)) {
+                  const errBox = new BoxRenderable(this.renderer, { id: `wt-err-${Date.now()}`, flexDirection: "column" });
+                  errBox.add(new TextRenderable(this.renderer, { id: `wt-err-t-${Date.now()}`, content: `Error: ${(result as any).error}`, fg: COLORS.error }));
+                  this.codePanel.addWidget(part.toolName, errBox);
+                } else {
+                  const widget = renderToolWidget(part.toolName, result, this.renderer)
+                    ?? renderStrategyWidget(part.toolName, result, this.renderer);
+                  if (widget) {
+                    this.codePanel.addWidget(part.toolName, widget);
+                  }
+                }
+                if (!this.codePanel.visible) this.codePanel.show();
+                this.codePanel.setTab("widgets");
+              } catch {
+                // Widget rendering failed silently — don't break the stream
+              }
+            }
+            // else showWidgets=false: skip rendering, LLM still got the data
           }
 
           // Update code panel from edit_strategy/load_saved_strategy results
@@ -1226,12 +1381,10 @@ export class App {
             }
           }
 
-          // Feed dashboard HTML into code panel dashboard tab
+          // Switch to dashboard/metrics tab when dashboard is spawned
           if (part.toolName === "spawn_dashboard") {
             const result = part.result as any;
             if (result?.success) {
-              const html = (part as any).args?.custom_html;
-              if (html) this.codePanel.setDashboardHtml(html);
               this.codePanel.setTab("dashboard");
               if (!this.codePanel.visible) this.codePanel.show();
             }