horizon-code 0.1.1 → 0.2.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,10 +1,10 @@
 {
   "name": "horizon-code",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "AI-powered trading strategy terminal for Polymarket",
   "type": "module",
   "bin": {
-    "horizon": "./bin/horizon.js"
+    "hzcode": "./bin/horizon.js"
   },
   "files": [
     "src",

package/src/app.ts

@@ -18,7 +18,7 @@ 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";
@@ -92,6 +92,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 +404,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 +434,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 +731,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");
@@ -1226,12 +1302,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();
             }

package/src/components/code-panel.ts

@@ -12,9 +12,32 @@ import {
 } from "@opentui/core";
 type TreeSitterClient = any;
 import { COLORS } from "../theme/colors.ts";
+import { store } from "../state/store.ts";
+import type { DeploymentMetrics, Position, Order } from "../state/types.ts";
 
 const h = (hex: string) => RGBA.fromHex(hex);
 
+function sparkline(values: number[], width: number): string {
+  if (values.length < 2) return "";
+  const chars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+  const step = values.length / width;
+  let result = "";
+  for (let i = 0; i < width && i * step < values.length; i++) {
+    const idx = Math.min(Math.floor(i * step), values.length - 1);
+    const normalized = (values[idx]! - min) / range;
+    const charIdx = Math.min(Math.floor(normalized * (chars.length - 1)), chars.length - 1);
+    result += chars[charIdx];
+  }
+  return result;
+}
+
+function pad(s: string, width: number): string {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+
 // Python syntax colors (matches highlights.scm groups)
 const syntaxStyle = SyntaxStyle.fromStyles({
   "@keyword":          { fg: h("#C586C0") },          // purple
@@ -59,7 +82,16 @@ export class CodePanel {
   private _name = "";
   private _phase = "";
   private _logs = "";
-  private _dashboardHtml = "";
+  private _metricsData: {
+    name: string;
+    status: string;
+    dryRun: boolean;
+    metrics: DeploymentMetrics;
+    positions: Position[];
+    orders: Order[];
+    pnlHistory: number[];
+    startedAt: number;
+  } | null = null;
   private _validationStatus: "pending" | "valid" | "invalid" | "none" = "none";
 
   constructor(private renderer: CliRenderer) {
@@ -95,7 +127,7 @@ export class CodePanel {
     const tabs: { id: PanelTab; label: string }[] = [
       { id: "code", label: "Code" },
       { id: "logs", label: "Logs" },
-      { id: "dashboard", label: "Dashboard" },
+      { id: "dashboard", label: "Metrics" },
     ];
     for (const tab of tabs) {
       const text = new TextRenderable(renderer, {
@@ -157,7 +189,7 @@ export class CodePanel {
     this.dashScroll.visible = false;
     this.dashMd = new MarkdownRenderable(renderer, {
       id: "dash-md",
-      content: "*no dashboard generated*\n\n*Ask the LLM to build a dashboard.*",
+      content: "*no active deployment*\n\n*Deploy a strategy to see live metrics here.*",
       syntaxStyle,
     });
     this.dashScroll.add(this.dashMd);
@@ -234,8 +266,17 @@ export class CodePanel {
     if (this._activeTab === "logs") this.updateLogsContent();
   }
 
-  setDashboardHtml(html: string): void {
-    this._dashboardHtml = html;
+  setMetrics(data: {
+    name: string;
+    status: string;
+    dryRun: boolean;
+    metrics: DeploymentMetrics;
+    positions: Position[];
+    orders: Order[];
+    pnlHistory: number[];
+    startedAt: number;
+  } | null): void {
+    this._metricsData = data;
     if (this._activeTab === "dashboard") this.updateDashContent();
   }
 
@@ -262,16 +303,17 @@ export class CodePanel {
 
   private updateTabBar(): void {
     for (const [id, text] of this.tabTexts) {
+      const label = id === "code" ? (this._name || "Code")
+        : id === "dashboard" ? "Metrics"
+        : id.charAt(0).toUpperCase() + id.slice(1);
       if (id === this._activeTab) {
         text.fg = "#212121";
         text.bg = COLORS.accent;
-        text.content = id === "code"
-          ? ` ${this._name || "Code"} `
-          : ` ${id.charAt(0).toUpperCase() + id.slice(1)} `;
+        text.content = ` ${label} `;
       } else {
         text.fg = COLORS.textMuted;
         text.bg = undefined;
-        text.content = ` ${id.charAt(0).toUpperCase() + id.slice(1)} `;
+        text.content = ` ${label} `;
       }
     }
   }
@@ -304,7 +346,20 @@ export class CodePanel {
         this.codeMd.content = "*no strategy loaded*\n\n*Describe a strategy in the chat to get started.*";
       }
     } else {
-      this.codeMd.content = "```python\n" + this._code + "\n```";
+      let content = "```python\n" + this._code + "\n```";
+
+      // Show warnings if any
+      const draft = store.getActiveSession()?.strategyDraft;
+      if (draft?.validationWarnings?.length) {
+        content += "\n\n---\n";
+        for (const w of draft.validationWarnings) {
+          const icon = w.severity === "warning" ? "!" : "i";
+          const lineRef = w.line ? ` (line ${w.line})` : "";
+          content += `\n${icon} ${w.message}${lineRef}`;
+        }
+      }
+
+      this.codeMd.content = content;
     }
     this.renderer.requestRender();
   }
@@ -319,11 +374,83 @@ export class CodePanel {
   }
 
   private updateDashContent(): void {
-    if (!this._dashboardHtml) {
-      this.dashMd.content = "*no dashboard generated*\n\n*Ask the LLM to build a dashboard.*";
-    } else {
-      this.dashMd.content = "```html\n" + this._dashboardHtml + "\n```";
+    if (!this._metricsData) {
+      this.dashMd.content = "*no active deployment*\n\n*Deploy a strategy to see live metrics here.*";
+      this.renderer.requestRender();
+      return;
     }
+
+    const d = this._metricsData;
+    const m = d.metrics;
+    const statusIcon = d.status === "running" ? "\u25CF" : d.status === "error" ? "x" : "\u25CB";
+    const modeLabel = d.dryRun ? "paper" : "LIVE";
+
+    // Uptime
+    const uptimeMs = Date.now() - d.startedAt;
+    const hours = Math.floor(uptimeMs / 3600000);
+    const mins = Math.floor((uptimeMs % 3600000) / 60000);
+    const uptime = hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+
+    // Sparkline from pnl history
+    const spark = sparkline(d.pnlHistory, 30);
+
+    // Format helpers
+    const pnl = (v: number) => (v >= 0 ? `+$${v.toFixed(2)}` : `-$${Math.abs(v).toFixed(2)}`);
+    const pct = (v: number) => `${v.toFixed(1)}%`;
+
+    const lines: string[] = [];
+    lines.push(`**${d.name}**  ${statusIcon} ${d.status}  |  ${modeLabel}  |  ${uptime}`);
+    lines.push("---");
+    lines.push("");
+
+    // P&L section
+    lines.push("```");
+    lines.push(`  Total P&L     ${pad(pnl(m.total_pnl), 12)}    Realized    ${pad(pnl(m.realized_pnl), 12)}`);
+    lines.push(`  Unrealized    ${pad(pnl(m.unrealized_pnl), 12)}    Exposure    ${pad("$" + m.total_exposure.toFixed(2), 12)}`);
+    lines.push("");
+    lines.push(`  Sharpe        ${pad(m.sharpe_ratio.toFixed(2), 12)}    Win Rate    ${pad(pct(m.win_rate * 100), 12)}`);
+    lines.push(`  Max DD        ${pad(pct(m.max_drawdown_pct), 12)}    Trades      ${pad(String(m.total_trades), 12)}`);
+    lines.push(`  Profit F      ${pad(m.profit_factor.toFixed(2), 12)}    Avg Return  ${pad(pnl(m.avg_return_per_trade), 12)}`);
+    lines.push("```");
+    lines.push("");
+
+    // Equity sparkline
+    if (spark) {
+      lines.push("**Equity**");
+      lines.push("```");
+      lines.push("  " + spark);
+      lines.push("```");
+      lines.push("");
+    }
+
+    // Positions
+    if (d.positions.length > 0) {
+      lines.push(`**Positions** (${d.positions.length})`);
+      lines.push("```");
+      for (const p of d.positions.slice(0, 8)) {
+        const side = p.side === "BUY" ? "BUY " : "SELL";
+        const slug = p.slug.length > 24 ? p.slug.slice(0, 24) + "..." : p.slug;
+        lines.push(`  ${side}  ${pad(slug, 28)} ${pad(String(p.size), 5)} @ ${p.avg_entry_price.toFixed(2)}  ${pnl(p.unrealized_pnl)}`);
+      }
+      if (d.positions.length > 8) lines.push(`  ... and ${d.positions.length - 8} more`);
+      lines.push("```");
+      lines.push("");
+    }
+
+    // Recent orders
+    if (d.orders.length > 0) {
+      lines.push(`**Recent Orders** (${d.orders.length})`);
+      lines.push("```");
+      for (const o of d.orders.slice(0, 5)) {
+        const time = new Date(o.created_at).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" });
+        const side = o.side === "BUY" ? "BUY " : "SELL";
+        const slug = o.slug.length > 20 ? o.slug.slice(0, 20) + "..." : o.slug;
+        lines.push(`  ${time}  ${side}  ${pad(String(o.size), 4)} @ ${o.price.toFixed(2)}  ${pad(o.status, 10)}  ${slug}`);
+      }
+      lines.push("```");
+    }
+
+    this.dashMd.content = lines.join("\n");
     this.renderer.requestRender();
   }
 }

package/src/platform/session-sync.ts

@@ -50,7 +50,7 @@ export async function loadSessions(): Promise<void> {
         mode: (dbs.mode as any) ?? "research",
         isStreaming: false,
         streamingMsgId: null,
-        strategyDraft: dbs.strategy_draft ?? null,
+        strategyDraft: dbs.strategy_draft ? { ...dbs.strategy_draft, validationWarnings: dbs.strategy_draft.validationWarnings ?? [] } : null,
       });
 
       // Mark all loaded messages as synced

package/src/state/types.ts

@@ -79,6 +79,7 @@ export interface StrategyDraft {
   } | null;
   validationStatus: "pending" | "valid" | "invalid" | "none";
   validationErrors: { line: number | null; message: string }[];
+  validationWarnings: { line: number | null; message: string; severity: "warning" | "info" }[];
   phase: "generated" | "iterated" | "validated" | "saved" | "deployed";
   strategyId?: string;
   filePath?: string;

package/src/strategy/code-stream.ts

@@ -3,7 +3,7 @@
 // This replaces propose_strategy/update_strategy tools — the LLM writes code
 // directly in its response, and we catch it and handle validation/saving.
 
-import { validateStrategyCode, autoFixStrategyCode } from "./validator.ts";
+import { validateStrategyCode, autoFixStrategyCode, getStrategyWarnings } from "./validator.ts";
 import { saveStrategy } from "./persistence.ts";
 import { store } from "../state/store.ts";
 import type { StrategyDraft } from "../state/types.ts";
@@ -67,6 +67,7 @@ function extractParams(code: string): Record<string, unknown> {
 export async function finalizeStrategy(code: string, overrideName?: string): Promise<StrategyDraft> {
   const fixedCode = autoFixStrategyCode(code);
   const errors = validateStrategyCode(fixedCode);
+  const warnings = getStrategyWarnings(fixedCode);
   const name = overrideName ?? extractStrategyName(fixedCode);
 
   const draft: StrategyDraft = {
@@ -77,6 +78,7 @@ export async function finalizeStrategy(code: string, overrideName?: string): Pro
     riskConfig: extractRiskConfig(fixedCode),
     validationStatus: errors.length === 0 ? "valid" : "invalid",
     validationErrors: errors,
+    validationWarnings: warnings,
     phase: "generated",
   };