horizon-code 0.1.0

package/src/state/store.ts

@@ -0,0 +1,256 @@
+import type { AppState, Session, StrategyDraft } from "./types.ts";
+import type { Message } from "../chat/types.ts";
+
+export type StateListener = (state: AppState) => void;
+
+function createSession(name: string): Session {
+  const id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  return {
+    id, name, messages: [],
+    createdAt: Date.now(), updatedAt: Date.now(),
+    mode: "research", isStreaming: false, streamingMsgId: null, strategyDraft: null,
+  };
+}
+
+function createInitialState(): AppState {
+  // Start with NO sessions — they load from Supabase or get created on first input
+  return {
+    connection: "connected",
+    operatingMode: "supervised",
+    sessions: [],
+    activeSessionId: "",
+    openTabIds: [],
+    deployments: [],
+  };
+}
+
+class Store {
+  private state: AppState;
+  private listeners: Set<StateListener> = new Set();
+  private notifyPending = false;
+
+  constructor() { this.state = createInitialState(); }
+
+  get(): AppState { return this.state; }
+
+  update(partial: Partial<AppState>): void {
+    this.state = { ...this.state, ...partial };
+    // Ensure openTabIds has no duplicates
+    if (partial.openTabIds) {
+      this.state.openTabIds = [...new Set(this.state.openTabIds)];
+    }
+    this.notify();
+  }
+
+  // ── Session getters ──
+
+  getActiveSession(): Session | undefined {
+    return this.state.sessions.find((s) => s.id === this.state.activeSessionId);
+  }
+
+  getSession(id: string): Session | undefined {
+    return this.state.sessions.find((s) => s.id === id);
+  }
+
+  // ── Message operations (take explicit sessionId) ──
+
+  addMessageTo(sessionId: string, message: Message): void {
+    const sessions = this.state.sessions.map((s) => {
+      if (s.id !== sessionId) return s;
+      return { ...s, messages: [...s.messages, message], updatedAt: Date.now() };
+    });
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  // Convenience: add to active session
+  addMessage(message: Message): void {
+    this.addMessageTo(this.state.activeSessionId, message);
+  }
+
+  updateMessageIn(sessionId: string, messageId: string, updates: Partial<Message>): void {
+    const sessions = this.state.sessions.map((s) => {
+      if (s.id !== sessionId) return s;
+      const messages = s.messages.map((m) => m.id !== messageId ? m : { ...m, ...updates });
+      return { ...s, messages, updatedAt: Date.now() };
+    });
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  updateMessage(messageId: string, updates: Partial<Message>): void {
+    this.updateMessageIn(this.state.activeSessionId, messageId, updates);
+  }
+
+  // ── Session streaming state ──
+
+  setSessionStreaming(sessionId: string, streaming: boolean, msgId?: string | null): void {
+    const sessions = this.state.sessions.map((s) => {
+      if (s.id !== sessionId) return s;
+      return { ...s, isStreaming: streaming, streamingMsgId: msgId ?? null };
+    });
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  isAnyStreaming(): boolean {
+    return this.state.sessions.some((s) => s.isStreaming);
+  }
+
+  // ── Session mode ──
+
+  setSessionMode(sessionId: string, mode: Session["mode"]): void {
+    const sessions = this.state.sessions.map((s) =>
+      s.id === sessionId ? { ...s, mode } : s
+    );
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  // ── Strategy draft (per-session) ──
+
+  setStrategyDraft(draft: StrategyDraft): void {
+    const sid = this.state.activeSessionId;
+    const sessions = this.state.sessions.map((s) =>
+      s.id === sid ? { ...s, strategyDraft: draft } : s
+    );
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  updateStrategyDraft(updates: Partial<StrategyDraft>): void {
+    const sid = this.state.activeSessionId;
+    const sessions = this.state.sessions.map((s) => {
+      if (s.id !== sid || !s.strategyDraft) return s;
+      return { ...s, strategyDraft: { ...s.strategyDraft, ...updates } };
+    });
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  clearStrategyDraft(): void {
+    const sid = this.state.activeSessionId;
+    const sessions = this.state.sessions.map((s) =>
+      s.id === sid ? { ...s, strategyDraft: null } : s
+    );
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  // ── Tab management ──
+
+  newSession(): string {
+    const session = createSession("New chat");
+    this.state = {
+      ...this.state,
+      sessions: [...this.state.sessions, session],
+      activeSessionId: session.id,
+      openTabIds: [...this.state.openTabIds, session.id],
+    };
+    this.notify();
+    return session.id;
+  }
+
+  openTab(sessionId: string): void {
+    if (!this.state.openTabIds.includes(sessionId)) {
+      this.state = {
+        ...this.state,
+        openTabIds: [...this.state.openTabIds, sessionId],
+        activeSessionId: sessionId,
+      };
+    } else {
+      this.state = { ...this.state, activeSessionId: sessionId };
+    }
+    this.notify();
+  }
+
+  closeTab(sessionId: string): void {
+    const tabs = this.state.openTabIds.filter((id) => id !== sessionId);
+    if (tabs.length === 0) {
+      // Always keep at least one tab
+      const newId = this.newSession();
+      return;
+    }
+    const activeId = sessionId === this.state.activeSessionId
+      ? tabs[Math.max(0, this.state.openTabIds.indexOf(sessionId) - 1)] ?? tabs[0]!
+      : this.state.activeSessionId;
+    this.state = { ...this.state, openTabIds: tabs, activeSessionId: activeId };
+    this.notify();
+  }
+
+  nextTab(): void {
+    const { openTabIds, activeSessionId } = this.state;
+    if (openTabIds.length <= 1) return;
+    const idx = openTabIds.indexOf(activeSessionId);
+    const next = openTabIds[(idx + 1) % openTabIds.length]!;
+    this.state = { ...this.state, activeSessionId: next };
+    this.notify();
+  }
+
+  prevTab(): void {
+    const { openTabIds, activeSessionId } = this.state;
+    if (openTabIds.length <= 1) return;
+    const idx = openTabIds.indexOf(activeSessionId);
+    const prev = openTabIds[(idx - 1 + openTabIds.length) % openTabIds.length]!;
+    this.state = { ...this.state, activeSessionId: prev };
+    this.notify();
+  }
+
+  jumpToTab(index: number): void {
+    const tab = this.state.openTabIds[index];
+    if (tab) {
+      this.state = { ...this.state, activeSessionId: tab };
+      this.notify();
+    }
+  }
+
+  // ── Session CRUD ──
+
+  deleteSession(sessionId: string): void {
+    // Close tab if open
+    const tabs = this.state.openTabIds.filter((id) => id !== sessionId);
+    const sessions = this.state.sessions.filter((s) => s.id !== sessionId);
+    if (sessions.length === 0) {
+      const s = createSession("New chat");
+      sessions.push(s);
+      tabs.push(s.id);
+    }
+    const activeId = sessionId === this.state.activeSessionId
+      ? (tabs[0] ?? sessions[0]!.id) : this.state.activeSessionId;
+    this.state = { ...this.state, sessions, openTabIds: tabs, activeSessionId: activeId };
+    this.notify();
+  }
+
+  renameSession(sessionId: string, name: string): void {
+    const sessions = this.state.sessions.map((s) =>
+      s.id === sessionId ? { ...s, name, updatedAt: Date.now() } : s
+    );
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  togglePinSession(sessionId: string): void {
+    const sessions = this.state.sessions.map((s) =>
+      s.id === sessionId ? { ...s, pinned: !s.pinned } : s
+    );
+    this.state = { ...this.state, sessions };
+    this.notify();
+  }
+
+  subscribe(listener: StateListener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private notify(): void {
+    // Batch: collapse multiple synchronous mutations into a single notification
+    if (this.notifyPending) return;
+    this.notifyPending = true;
+    queueMicrotask(() => {
+      this.notifyPending = false;
+      for (const listener of this.listeners) listener(this.state);
+    });
+  }
+}
+
+export const store = new Store();

package/src/state/types.ts

@@ -0,0 +1,109 @@
+import type { Message } from "../chat/types.ts";
+import type { Mode } from "../components/mode-bar.ts";
+
+export type ConnectionStatus = "connected" | "connecting" | "disconnected";
+export type OperatingMode = "dry_run" | "supervised" | "autonomous";
+
+export type DeploymentStatus =
+  | "pending" | "starting" | "running" | "queued" | "restarting"
+  | "scanner_idle" | "stopped" | "error" | "killed" | "stopping";
+
+export interface Position {
+  market_id: string;
+  slug: string;
+  question: string;
+  side: "BUY" | "SELL";
+  size: number;
+  avg_entry_price: number;
+  cost_basis: number;
+  realized_pnl: number;
+  unrealized_pnl: number;
+}
+
+export interface Order {
+  market_id: string;
+  slug: string;
+  side: "BUY" | "SELL";
+  price: number;
+  size: number;
+  filled_size: number;
+  status: "PENDING" | "LIVE" | "PARTIALLY_FILLED" | "FILLED" | "CANCELLED";
+  order_type: "GTC" | "IOC";
+  created_at: number;
+}
+
+export interface DeploymentMetrics {
+  total_pnl: number;
+  realized_pnl: number;
+  unrealized_pnl: number;
+  total_exposure: number;
+  position_count: number;
+  open_order_count: number;
+  win_rate: number;
+  total_trades: number;
+  max_drawdown_pct: number;
+  sharpe_ratio: number;
+  profit_factor: number;
+  avg_return_per_trade: number;
+  gross_profit: number;
+  gross_loss: number;
+}
+
+export interface Deployment {
+  id: string;
+  strategyId: string;  // strategy UUID (used for API calls)
+  name: string;
+  strategy_type: string;
+  status: DeploymentStatus;
+  dry_run: boolean;
+  mode: "manual" | "scanner";
+  metrics: DeploymentMetrics;
+  positions: Position[];
+  orders: Order[];
+  pnl_history: number[];
+  started_at: number;
+}
+
+export interface StrategyDraft {
+  name: string;
+  code: string;
+  params: Record<string, unknown>;
+  explanation: string;
+  riskConfig: {
+    max_position: number;
+    max_notional: number;
+    max_drawdown_pct: number;
+    max_order_size?: number;
+    rate_limit?: number;
+    rate_burst?: number;
+  } | null;
+  validationStatus: "pending" | "valid" | "invalid" | "none";
+  validationErrors: { line: number | null; message: string }[];
+  phase: "generated" | "iterated" | "validated" | "saved" | "deployed";
+  strategyId?: string;
+  filePath?: string;
+}
+
+// Each session is a full independent workspace
+export interface Session {
+  id: string;
+  name: string;
+  messages: Message[];
+  createdAt: number;
+  updatedAt: number;
+  pinned?: boolean;
+  // Per-tab workspace state
+  mode: Mode;
+  isStreaming: boolean;
+  streamingMsgId: string | null;
+  strategyDraft: StrategyDraft | null;
+}
+
+export interface AppState {
+  connection: ConnectionStatus;
+  operatingMode: OperatingMode;
+  sessions: Session[];
+  activeSessionId: string;
+  openTabIds: string[];       // tabs currently open (ordered)
+  deployments: Deployment[];
+}

package/src/strategy/ascii-chart.ts

@@ -0,0 +1,74 @@
+// ASCII equity curve chart using box-drawing characters
+
+const BLOCKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
+/**
+ * Render a multi-line ASCII chart with box frame and Y-axis labels.
+ * Returns an array of strings (one per line).
+ */
+export function renderAsciiChart(
+  values: number[],
+  width = 48,
+  height = 8,
+): string[] {
+  if (values.length === 0) return ["  (no data)"];
+
+  // Resample to fit width
+  const sampled: number[] = [];
+  for (let i = 0; i < width; i++) {
+    const idx = Math.floor((i / width) * values.length);
+    sampled.push(values[idx] ?? 0);
+  }
+
+  const min = Math.min(...sampled);
+  const max = Math.max(...sampled);
+  const range = max - min || 1;
+
+  // Build chart grid (height rows × width cols)
+  // Each cell maps to a sub-block level
+  const grid: string[][] = [];
+  for (let row = 0; row < height; row++) {
+    grid.push(new Array(width).fill(" "));
+  }
+
+  for (let col = 0; col < width; col++) {
+    const normalized = (sampled[col]! - min) / range; // 0..1
+    const totalBlocks = normalized * height;
+    const fullRows = Math.floor(totalBlocks);
+    const partialLevel = Math.round((totalBlocks - fullRows) * (BLOCKS.length - 1));
+
+    // Fill from bottom up
+    for (let row = 0; row < fullRows && row < height; row++) {
+      grid[height - 1 - row]![col] = BLOCKS[BLOCKS.length - 1]!;
+    }
+    if (fullRows < height && partialLevel > 0) {
+      grid[height - 1 - fullRows]![col] = BLOCKS[partialLevel]!;
+    }
+  }
+
+  // Y-axis labels (top, middle, bottom)
+  const fmtVal = (v: number): string => {
+    if (Math.abs(v) >= 1000) return `${(v / 1000).toFixed(1)}k`;
+    if (Math.abs(v) >= 100) return v.toFixed(0);
+    return v.toFixed(1);
+  };
+
+  const topLabel = fmtVal(max).padStart(6);
+  const midLabel = fmtVal((max + min) / 2).padStart(6);
+  const botLabel = fmtVal(min).padStart(6);
+
+  const lines: string[] = [];
+
+  // Top border
+  lines.push(`${topLabel} ┌${"─".repeat(width)}┐`);
+
+  for (let row = 0; row < height; row++) {
+    const label = row === Math.floor(height / 2) ? midLabel : "      ";
+    lines.push(`${label} │${grid[row]!.join("")}│`);
+  }
+
+  // Bottom border
+  lines.push(`${botLabel} └${"─".repeat(width)}┘`);
+
+  return lines;
+}

package/src/strategy/code-stream.ts

@@ -0,0 +1,146 @@
+// Code fence detection + strategy finalization
+// Intercepts ```python fences in LLM text stream and routes code to the panel.
+// 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 { saveStrategy } from "./persistence.ts";
+import { store } from "../state/store.ts";
+import type { StrategyDraft } from "../state/types.ts";
+
+/**
+ * Extract strategy name from code (hz.run or hz.backtest name= arg).
+ */
+export function extractStrategyName(code: string): string {
+  const runMatch = code.match(/hz\.(?:run|backtest)\s*\(\s*(?:[\s\S]*?)?name\s*=\s*["']([^"']+)["']/);
+  if (runMatch) return runMatch[1]!;
+  // Fallback: look for a class name or comment
+  const commentMatch = code.match(/#\s*Strategy:\s*(\S+)/i);
+  if (commentMatch) return commentMatch[1]!;
+  return "Strategy";
+}
+
+/**
+ * Check if code contains hz.run() or hz.backtest() — a real strategy, not a snippet.
+ */
+export function isStrategyCode(code: string): boolean {
+  return /hz\.(run|backtest)\s*\(/.test(code);
+}
+
+/**
+ * Extract risk config from hz.Risk(...) in code.
+ */
+function extractRiskConfig(code: string): StrategyDraft["riskConfig"] {
+  const riskMatch = code.match(/hz\.Risk\(([\s\S]*?)\)/);
+  if (!riskMatch) return null;
+  const riskArgs = riskMatch[1]!.replace(/\n/g, " ").trim();
+
+  const getNum = (key: string) => {
+    const m = riskArgs.match(new RegExp(`${key}\\s*=\\s*([\\d.]+)`));
+    return m ? parseFloat(m[1]!) : undefined;
+  };
+  const rl = getNum("rate_limit");
+  const rb = getNum("rate_burst");
+  return {
+    max_position: getNum("max_position") ?? 100,
+    max_notional: getNum("max_notional") ?? 1000,
+    max_drawdown_pct: getNum("max_drawdown_pct") ?? 5,
+    max_order_size: getNum("max_order_size"),
+    rate_limit: rl !== undefined ? Math.round(rl) : undefined,
+    rate_burst: rb !== undefined ? Math.round(rb) : undefined,
+  };
+}
+
+/**
+ * Extract params dict from code.
+ */
+function extractParams(code: string): Record<string, unknown> {
+  const paramsMatch = code.match(/params\s*=\s*(\{[^}]+\})/);
+  if (!paramsMatch) return {};
+  try { return JSON.parse(paramsMatch[1]!.replace(/'/g, '"')); } catch { return {}; }
+}
+
+/**
+ * Finalize a strategy: auto-fix → validate → extract metadata → save → set draft.
+ * Called when a code fence closes in the text stream.
+ */
+export async function finalizeStrategy(code: string, overrideName?: string): Promise<StrategyDraft> {
+  const fixedCode = autoFixStrategyCode(code);
+  const errors = validateStrategyCode(fixedCode);
+  const name = overrideName ?? extractStrategyName(fixedCode);
+
+  const draft: StrategyDraft = {
+    name,
+    code: fixedCode,
+    params: extractParams(fixedCode),
+    explanation: "",
+    riskConfig: extractRiskConfig(fixedCode),
+    validationStatus: errors.length === 0 ? "valid" : "invalid",
+    validationErrors: errors,
+    phase: "generated",
+  };
+
+  store.setStrategyDraft(draft);
+  await saveStrategy(name, fixedCode).catch(() => null);
+  return draft;
+}
+
+// ── Streaming code fence detector ──
+
+export class CodeFenceDetector {
+  private _inFence = false;
+  private _fenceStart = 0;
+  private _lastSearchPos = 0;
+
+  get inFence(): boolean { return this._inFence; }
+
+  /**
+   * Feed the full accumulated text on each delta.
+   * Returns:
+   *   - null: no code fence event
+   *   - { event: "open" }: fence just opened
+   *   - { event: "delta", code: string }: partial code update
+   *   - { event: "close", code: string }: fence closed, full code available
+   */
+  update(fullText: string): { event: "open" } | { event: "delta"; code: string } | { event: "close"; code: string } | null {
+    if (!this._inFence) {
+      // Look for opening fence
+      const markers = ["```python\n", "```python ", "```py\n", "```py "];
+      for (const marker of markers) {
+        const idx = fullText.indexOf(marker, this._lastSearchPos);
+        if (idx !== -1) {
+          this._inFence = true;
+          this._fenceStart = idx + marker.length;
+          this._lastSearchPos = this._fenceStart;
+          return { event: "open" };
+        }
+      }
+      return null;
+    }
+
+    // In fence — look for closing ```
+    // Match \n``` NOT followed by another backtick (avoids matching `````)
+    const searchFrom = Math.max(this._fenceStart, this._lastSearchPos - 4);
+    const rest = fullText.slice(searchFrom);
+    const closeMatch = rest.match(/\n```(?!`)/);
+
+    if (closeMatch && closeMatch.index !== undefined) {
+      const closeIdx = searchFrom + closeMatch.index;
+      this._inFence = false;
+      const code = fullText.slice(this._fenceStart, closeIdx);
+      this._lastSearchPos = closeIdx + 4;
+      return { event: "close", code };
+    }
+
+    // Still in fence — return partial code
+    this._lastSearchPos = fullText.length;
+    const code = fullText.slice(this._fenceStart);
+    return { event: "delta", code };
+  }
+
+  reset(): void {
+    this._inFence = false;
+    this._fenceStart = 0;
+    this._lastSearchPos = 0;
+  }
+}