horizon-code 0.5.0 → 0.6.0

package/package.json

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

package/src/ai/client.ts

@@ -335,6 +335,12 @@ export async function* chat(
       }
     }
 
+    // If structured output was active but we never extracted a "response" field,
+    // the model likely responded with plain text — flush jsonBuf as text
+    if (structuredActive && jsonBuf && emittedResponseLen === 0) {
+      yield { type: "text-delta", textDelta: jsonBuf };
+    }
+
     // If no tool calls, we're done
     if (!hasToolCalls || pendingToolCalls.length === 0) {
       if (eventCount === 0) {

package/src/ai/system-prompt.ts

@@ -1,10 +1,12 @@
 import type { Mode } from "../components/mode-bar.ts";
 import { buildGeneratePrompt } from "../strategy/prompts.ts";
+import { store } from "../state/store.ts";
 
 const BASE = `You are Horizon, an AI trading research assistant running in a CLI terminal.
 
 Rules:
 - Concise and direct. You're a terminal, not a chatbot.
+- NEVER use emojis in your responses. No emoji characters whatsoever. Use plain text only.
 - Tool results render as rich CLI widgets automatically — do NOT reformat the data as tables. Just add 1-2 sentences of insight after the widget.
 - NEVER suggest switching modes.
 - Format: $102,450 not 102450.
@@ -122,7 +124,25 @@ const VERBOSITY_PREFIX: Record<string, string> = {
 
 export function getSystemPrompt(mode: Mode, verbosity: string = "normal"): string {
   // Strategy mode has its own verbosity rules — don't override
-  if (mode === "strategy") return buildGeneratePrompt();
+  if (mode === "strategy") {
+    let prompt = buildGeneratePrompt();
+    // Inject user profile context if available
+    try {
+      const { buildProfileContext } = require("../platform/profile.ts");
+      const profileCtx = buildProfileContext();
+      if (profileCtx) prompt += "\n\n" + profileCtx;
+    } catch {}
+    // Inject active strategy context so research tools auto-scope
+    const draft = store.getActiveSession()?.strategyDraft;
+    if (draft?.code) {
+      const marketsMatch = draft.code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+      const slugs = marketsMatch ? [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!) : [];
+      if (slugs.length > 0) {
+        prompt += `\n\n## Active Strategy Context\nThe user is working on "${draft.name}" trading these markets: ${slugs.join(", ")}. When they ask about "the market" or "what's happening", scope to these markets first. Use these slugs for polymarket_data, scan_correlations, etc.`;
+      }
+    }
+    return prompt;
+  }
   const prefix = VERBOSITY_PREFIX[verbosity] ?? "";
   return MODE_PROMPTS[mode] + prefix;
 }

package/src/app.ts

@@ -76,6 +76,17 @@ const SLASH_COMMANDS: Record<string, { description: string; usage: string }> = {
   "/exchanges": { description: "Show exchange connection status", usage: "/exchanges" },
   "/quit":    { description: "Exit Horizon", usage: "/quit" },
   "/exit":    { description: "Exit Horizon", usage: "/exit" },
+  "/bt":      { description: "Backtest current strategy", usage: "/bt" },
+  "/backtest": { description: "Backtest current strategy", usage: "/backtest" },
+  "/run":     { description: "Run current strategy", usage: "/run" },
+  "/dash":    { description: "Open strategy dashboard", usage: "/dash" },
+  "/dashboard": { description: "Open strategy dashboard", usage: "/dashboard" },
+  "/save":    { description: "Save current strategy", usage: "/save [name]" },
+  "/health":  { description: "Check strategy health score", usage: "/health" },
+  "/versions": { description: "List strategy versions", usage: "/versions [name]" },
+  "/export":  { description: "Export strategy to file", usage: "/export" },
+  "/report":  { description: "Generate strategy ledger report", usage: "/report [name]" },
+  "/session-export": { description: "Export chat session to markdown", usage: "/session-export" },
 };
 
 export class App {
@@ -304,6 +315,18 @@ export class App {
     this.keyHandler.onClear(() => {});
     this.keyHandler.onSessions(() => this.togglePanel("sessions"));
     this.keyHandler.onDeployments(() => this.togglePanel("deployments"));
+    this.keyHandler.onOpenDashboard(() => {
+      if (dashboard.running) {
+        Bun.spawn(["open", dashboard.url]);
+      } else {
+        // Auto-start built-in dashboard if processes running
+        const hasLocal = [...runningProcesses.values()].some(m => m.proc.exitCode === null);
+        if (hasLocal) {
+          const url = dashboard.start("local", 0, true);
+          Bun.spawn(["open", url]);
+        }
+      }
+    });
     this.keyHandler.onTabNext(() => { store.nextTab(); this.switchToActiveTab(); });
     this.keyHandler.onTabPrev(() => { store.prevTab(); this.switchToActiveTab(); });
     this.keyHandler.onTabClose(() => { store.closeTab(store.get().activeSessionId); this.switchToActiveTab(); });
@@ -527,6 +550,49 @@ export class App {
           startedAt: localProcessStartedAt,
         });
         this._hasLocalMetrics = true;
+
+        // Check alerts against current local metrics (fire-and-forget — setInterval is not async)
+        ((metrics) => {
+          (async () => {
+            try {
+              const { checkAlerts } = await import("./strategy/alerts.ts");
+              const draft = store.getActiveSession()?.strategyDraft;
+              const alertResults = await checkAlerts(
+                draft?.name ?? "local",
+                {
+                  pnl: metrics.pnl,
+                  max_dd: metrics.max_dd ?? 0,
+                  exposure: metrics.exposure ?? 0,
+                  win_rate: metrics.win_rate ?? 0,
+                  trades: metrics.trades ?? 0,
+                },
+                () => {
+                  // Stop all running processes
+                  for (const [pid, m] of runningProcesses) {
+                    if (m.proc.exitCode === null) m.cleanup?.();
+                  }
+                },
+              );
+              for (const r of alertResults) {
+                if (r.triggered && r.actionTaken) {
+                  this.codePanel.appendLog(r.actionTaken);
+                }
+              }
+            } catch {}
+          })();
+        })(localMetricsData);
+
+        // Record replay metrics (fire-and-forget)
+        ((metrics) => {
+          (async () => {
+            try {
+              const { recordMetrics, isRecording } = await import("./strategy/replay.ts");
+              for (const [pid] of runningProcesses) {
+                if (isRecording(pid)) recordMetrics(pid, metrics as any);
+              }
+            } catch {}
+          })();
+        })(localMetricsData);
       } else if (this._hasLocalMetrics && alive === 0) {
         // Local process stopped — clear local metrics, let platform data take over
         this._hasLocalMetrics = false;
@@ -845,6 +911,81 @@ export class App {
       case "/exit":
         this.quit();
         break;
+      case "/bt":
+      case "/backtest": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.backtest_strategy;
+        const result = await tool.execute({});
+        this.codePanel.appendLog(typeof result === "object" ? JSON.stringify(result, null, 2) : String(result));
+        this.codePanel.setTab("logs");
+        break;
+      }
+      case "/run": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.run_strategy;
+        const result = await tool.execute({});
+        this.codePanel.appendLog(typeof result === "object" ? JSON.stringify(result, null, 2) : String(result));
+        this.codePanel.setTab("logs");
+        break;
+      }
+      case "/dash":
+      case "/dashboard": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.spawn_dashboard;
+        const result = await tool.execute({ strategy_id: "local" });
+        if (result?.url) Bun.spawn(["open", result.url]);
+        break;
+      }
+      case "/save": {
+        const tool = (await import("./strategy/tools.ts")).strategyTools.save_strategy;
+        const draft = store.getActiveSession()?.strategyDraft;
+        const result = await tool.execute({ name: draft?.name ?? arg ?? "untitled" });
+        this.codePanel.appendLog(`Saved: ${JSON.stringify(result)}`);
+        break;
+      }
+      case "/health": {
+        const { computeHealthScore } = await import("./strategy/health.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        if (!draft?.code) { this.codePanel.appendLog("No strategy loaded"); break; }
+        const report = computeHealthScore(draft.code);
+        this.codePanel.appendLog(`Health: ${report.score}/${report.maxScore} (${report.grade}) — ${report.summary}`);
+        break;
+      }
+      case "/versions": {
+        const { listVersions } = await import("./strategy/versioning.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        const versions = await listVersions(draft?.name ?? arg ?? "");
+        this.codePanel.appendLog(versions.length === 0 ? "No versions found" : versions.map(v => `v${v.version} [${v.hash}] ${v.label} — ${v.timestamp}`).join("\n"));
+        break;
+      }
+      case "/export": {
+        const { exportStrategy } = await import("./strategy/export.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        if (!draft?.code) { this.codePanel.appendLog("No strategy loaded"); break; }
+        const result = await exportStrategy(draft.name, draft.code, draft.params ?? {}, null);
+        this.codePanel.appendLog(`Exported to ${result.path} (${result.size} bytes)`);
+        break;
+      }
+      case "/report": {
+        const { generateReport } = await import("./strategy/ledger.ts");
+        const draft = store.getActiveSession()?.strategyDraft;
+        const report = generateReport(draft?.name ?? arg ?? "");
+        this.codePanel.appendLog(report.summary);
+        break;
+      }
+      case "/session-export": {
+        const session = store.getActiveSession();
+        if (!session) break;
+        const { writeWorkspaceFile } = await import("./strategy/workspace.ts");
+        const lines: string[] = [];
+        lines.push(`# ${session.id} — ${new Date().toISOString()}\n`);
+        for (const msg of session.messages) {
+          const role = msg.role === "user" ? "**User**" : "**Horizon**";
+          const text = msg.content.map((b: any) => b.text ?? b.markdown ?? "").join("\n");
+          lines.push(`### ${role}\n${text}\n`);
+        }
+        const fileName = `session_${Date.now()}.md`;
+        await writeWorkspaceFile(`exports/${fileName}`, lines.join("\n"));
+        this.codePanel.appendLog(`Session exported to exports/${fileName}`);
+        break;
+      }
       default: {
         // Unknown command — show as system message
         const msg: Message = {
@@ -1158,6 +1299,23 @@ export class App {
       contextParts.push(`Active strategy: ${draft.name} (${draft.phase}, ${draft.validationStatus})`);
     }
 
+    // Preserve strategy context through compaction
+    if (draft?.code) {
+      contextParts.push(`\nActive strategy code hash: ${draft.code.length} chars`);
+      // Preserve active market slugs
+      const marketsMatch = draft.code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+      if (marketsMatch) {
+        const slugs2 = [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!);
+        contextParts.push(`Active markets: ${slugs2.join(", ")}`);
+      }
+    }
+
+    // Preserve running process info
+    const pids = [...runningProcesses.keys()].filter(pid => runningProcesses.get(pid)?.proc.exitCode === null);
+    if (pids.length > 0) {
+      contextParts.push(`Running processes: PIDs ${pids.join(", ")}`);
+    }
+
     contextParts.push("");
     contextParts.push("Conversation summary:");
     contextParts.push(...summaryParts.slice(-15)); // last 15 exchanges max

package/src/components/footer.ts

@@ -33,7 +33,7 @@ export class Footer {
 
     this.hintsText = new TextRenderable(renderer, {
       id: "footer-hints",
-      content: "esc stop  ^N new chat  ^L ^H switch  ^W close  ^R mode  ^E chats  ^D bots  / cmd",
+      content: "esc stop  ^N new  ^L ^H switch  ^W close  ^R mode  ^E chats  ^D bots  ^O dash  / cmd",
       fg: COLORS.borderDim,
     });
     this.container.add(this.hintsText);

package/src/keys/handler.ts

@@ -20,6 +20,7 @@ export class KeyHandler {
   private tabCloseCallback: (() => void) | null = null;
   private tabNewCallback: (() => void) | null = null;
   private acNavCallback: ((dir: "up" | "down" | "accept" | "dismiss") => void) | null = null;
+  private openDashboardCallback: (() => void) | null = null;
   acActive = false; // set by app when autocomplete is visible
 
   // Panel navigation (shared by session & strategy panels)
@@ -56,6 +57,7 @@ export class KeyHandler {
   onTabClose(cb: () => void): void { this.tabCloseCallback = cb; }
   onTabNew(cb: () => void): void { this.tabNewCallback = cb; }
   onAcNav(cb: (dir: "up" | "down" | "accept" | "dismiss") => void): void { this.acNavCallback = cb; }
+  onOpenDashboard(cb: () => void): void { this.openDashboardCallback = cb; }
 
   onPanelNav(cb: (delta: number) => void): void { this.panelNavCallback = cb; }
   onPanelSelect(cb: () => void): void { this.panelSelectCallback = cb; }
@@ -123,6 +125,12 @@ export class KeyHandler {
       return;
     }
 
+    // Ctrl+O — open dashboard in browser
+    if (key.ctrl && key.name === "o") {
+      this.openDashboardCallback?.();
+      return;
+    }
+
     // Ctrl+L — next tab (was clear, now tab navigation)
     if (key.ctrl && key.name === "l") {
       if (this.panelActive === "sessions") { this.panelNewCallback?.(); return; }

package/src/platform/profile.ts

@@ -0,0 +1,202 @@
+// Cumulative user profile — learns preferences over time
+// Storage: ~/.horizon/profile.json
+
+import { homedir } from "os";
+import { resolve } from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+const PROFILE_PATH = resolve(homedir(), ".horizon", "profile.json");
+
+export interface UserProfile {
+  // Trading preferences
+  preferred_markets: string[];          // most-used market slugs
+  preferred_exchanges: string[];        // polymarket, kalshi, etc.
+  risk_tolerance: "conservative" | "moderate" | "aggressive";
+  typical_spread: number;               // average spread parameter used
+  typical_position_size: number;        // average max_position used
+  always_paper_first: boolean;          // always tests in paper before live
+
+  // Workflow patterns
+  strategies_created: number;
+  strategies_deployed: number;
+  backtests_run: number;
+  total_sessions: number;
+  preferred_strategy_types: string[];   // mm, momentum, arb, etc.
+  avg_pipeline_depth: number;           // average number of pipeline functions
+
+  // Usage stats
+  first_seen: string;
+  last_seen: string;
+  total_interactions: number;
+}
+
+const DEFAULT_PROFILE: UserProfile = {
+  preferred_markets: [],
+  preferred_exchanges: [],
+  risk_tolerance: "moderate",
+  typical_spread: 0.04,
+  typical_position_size: 100,
+  always_paper_first: true,
+  strategies_created: 0,
+  strategies_deployed: 0,
+  backtests_run: 0,
+  total_sessions: 0,
+  preferred_strategy_types: [],
+  avg_pipeline_depth: 2,
+  first_seen: new Date().toISOString(),
+  last_seen: new Date().toISOString(),
+  total_interactions: 0,
+};
+
+/** Load profile from disk */
+export function loadProfile(): UserProfile {
+  if (!existsSync(PROFILE_PATH)) return { ...DEFAULT_PROFILE };
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_PATH, "utf-8"));
+    return { ...DEFAULT_PROFILE, ...data };
+  } catch {
+    return { ...DEFAULT_PROFILE };
+  }
+}
+
+/** Save profile to disk */
+export function saveProfile(profile: UserProfile): void {
+  profile.last_seen = new Date().toISOString();
+  writeFileSync(PROFILE_PATH, JSON.stringify(profile, null, 2));
+}
+
+/** Update profile based on strategy code analysis */
+export function learnFromStrategy(code: string): void {
+  const profile = loadProfile();
+
+  // Extract market slugs
+  const marketsMatch = code.match(/markets\s*=\s*\[([\s\S]*?)\]/);
+  if (marketsMatch) {
+    const slugs = [...marketsMatch[1]!.matchAll(/["']([^"']+)["']/g)].map(m => m[1]!);
+    for (const slug of slugs) {
+      if (!profile.preferred_markets.includes(slug)) {
+        profile.preferred_markets.push(slug);
+        if (profile.preferred_markets.length > 20) profile.preferred_markets.shift();
+      }
+    }
+  }
+
+  // Extract exchange
+  const exchangeMatch = code.match(/exchange\s*=\s*hz\.(\w+)/);
+  if (exchangeMatch) {
+    const exchange = exchangeMatch[1]!.toLowerCase();
+    if (!profile.preferred_exchanges.includes(exchange)) {
+      profile.preferred_exchanges.push(exchange);
+    }
+  }
+
+  // Extract spread
+  const spreadMatch = code.match(/spread\s*[=:]\s*([\d.]+)/);
+  if (spreadMatch) {
+    const spread = parseFloat(spreadMatch[1]!);
+    if (spread > 0 && spread < 1) {
+      profile.typical_spread = (profile.typical_spread + spread) / 2;
+    }
+  }
+
+  // Extract max_position
+  const posMatch = code.match(/max_position\s*=\s*(\d+)/);
+  if (posMatch) {
+    const pos = parseInt(posMatch[1]!);
+    profile.typical_position_size = Math.round((profile.typical_position_size + pos) / 2);
+  }
+
+  // Detect risk tolerance from risk config
+  const ddMatch = code.match(/max_drawdown_pct\s*=\s*([\d.]+)/);
+  if (ddMatch) {
+    const dd = parseFloat(ddMatch[1]!);
+    if (dd <= 5) profile.risk_tolerance = "conservative";
+    else if (dd <= 15) profile.risk_tolerance = "moderate";
+    else profile.risk_tolerance = "aggressive";
+  }
+
+  // Detect strategy type
+  const codeLC = code.toLowerCase();
+  const types: string[] = [];
+  if (/market.?mak|mm_|spread/.test(codeLC)) types.push("market_making");
+  if (/momentum|trend|signal/.test(codeLC)) types.push("momentum");
+  if (/arb|arbitrage/.test(codeLC)) types.push("arbitrage");
+  if (/mean.?rev|revert/.test(codeLC)) types.push("mean_reversion");
+  if (/scalp/.test(codeLC)) types.push("scalper");
+
+  for (const t of types) {
+    if (!profile.preferred_strategy_types.includes(t)) {
+      profile.preferred_strategy_types.push(t);
+      if (profile.preferred_strategy_types.length > 10) profile.preferred_strategy_types.shift();
+    }
+  }
+
+  // Pipeline depth
+  const pipelineMatch = code.match(/pipeline\s*=\s*\[([\s\S]*?)\]/);
+  if (pipelineMatch) {
+    const fns = pipelineMatch[1]!.split(",").filter(s => s.trim() && !s.trim().startsWith("#"));
+    if (fns.length > 0) {
+      profile.avg_pipeline_depth = Math.round((profile.avg_pipeline_depth + fns.length) / 2);
+    }
+  }
+
+  // Paper mode preference
+  if (/mode\s*=\s*["']paper["']/.test(code)) {
+    profile.always_paper_first = true;
+  }
+
+  profile.strategies_created++;
+  profile.total_interactions++;
+
+  saveProfile(profile);
+}
+
+/** Record a backtest run */
+export function recordBacktest(): void {
+  const profile = loadProfile();
+  profile.backtests_run++;
+  profile.total_interactions++;
+  saveProfile(profile);
+}
+
+/** Record a deployment */
+export function recordDeploy(): void {
+  const profile = loadProfile();
+  profile.strategies_deployed++;
+  profile.total_interactions++;
+  saveProfile(profile);
+}
+
+/** Record a session start */
+export function recordSession(): void {
+  const profile = loadProfile();
+  profile.total_sessions++;
+  saveProfile(profile);
+}
+
+/** Build a context string for the LLM system prompt */
+export function buildProfileContext(): string {
+  const p = loadProfile();
+  if (p.total_interactions === 0) return "";
+
+  const parts: string[] = [];
+  parts.push("## User Profile (learned from usage)");
+
+  if (p.preferred_markets.length > 0) {
+    parts.push(`- Frequently traded markets: ${p.preferred_markets.slice(-5).join(", ")}`);
+  }
+  if (p.preferred_exchanges.length > 0) {
+    parts.push(`- Preferred exchanges: ${p.preferred_exchanges.join(", ")}`);
+  }
+  if (p.preferred_strategy_types.length > 0) {
+    parts.push(`- Strategy style: ${p.preferred_strategy_types.join(", ")}`);
+  }
+  parts.push(`- Risk tolerance: ${p.risk_tolerance} (typical spread: ${p.typical_spread.toFixed(3)}, typical max_position: ${p.typical_position_size})`);
+  parts.push(`- Experience: ${p.strategies_created} strategies created, ${p.backtests_run} backtests, ${p.strategies_deployed} deployments`);
+
+  if (p.always_paper_first) {
+    parts.push("- Always uses paper mode first (respect this preference)");
+  }
+
+  return parts.join("\n");
+}