horizon-code 0.5.1 → 0.6.0

package/src/research/tools.ts

@@ -10,6 +10,7 @@ import {
   exaSearch, exaSentiment, calaSearch, evCalculator, probabilityCalc,
 } from "./apis.ts";
 import { yahooQuote, yahooChart, yahooSearch } from "./stock-apis.ts";
+import { scanOpportunities, computeCorrelations, formatCorrelationMatrix } from "./scanner.ts";
 
 const t = tool as any;
 
@@ -1114,4 +1115,61 @@ ${volumes.length > 0 ? `new Chart(document.getElementById('vol'),{type:'bar',dat
       };
     },
   }),
+
+  // ── Market scanning tools ──
+
+  scan_opportunities: t({
+    description: "Scan top Polymarket markets for trading opportunities: wide spreads (market making), high volume (edge), and mispricings. Returns ranked list with scores.",
+    parameters: z.object({
+      limit: z.number().optional().describe("Max opportunities to return (default 20)"),
+    }),
+    execute: async (args: any) => {
+      try {
+        return await scanOpportunities(args.limit ?? 20);
+      } catch (err) {
+        return { error: `Scan failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  scan_correlations: t({
+    description: "Compute pairwise correlations between markets you're trading. Identifies concentration risk and hedging opportunities. Pass market slugs from your strategy or portfolio.",
+    parameters: z.object({
+      slugs: z.array(z.string()).describe("Market slugs to analyze (2-8 markets)"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const slugs: string[] = args.slugs;
+        if (slugs.length < 2) return { error: "Need at least 2 markets to compute correlations" };
+        if (slugs.length > 8) return { error: "Maximum 8 markets for correlation analysis" };
+
+        // Fetch price history for each market
+        const { clobPriceHistory } = await import("./apis.ts");
+        const marketPrices: { slug: string; prices: number[] }[] = [];
+
+        for (const slug of slugs) {
+          try {
+            const data = await clobPriceHistory(slug, "1w", 60);
+            const prices = (data.priceHistory ?? []).map((p: any) => typeof p.p === "number" ? p.p : parseFloat(p.p));
+            if (prices.length >= 3) {
+              marketPrices.push({ slug, prices });
+            }
+          } catch {}
+        }
+
+        if (marketPrices.length < 2) {
+          return { error: "Could not fetch enough price data. Need at least 2 markets with history." };
+        }
+
+        const result = computeCorrelations(marketPrices);
+        return {
+          ...result,
+          ascii_matrix: formatCorrelationMatrix(result),
+          summary: result.high_correlation_warning ?? `${result.pairs.length} pairs analyzed. No concentration risk detected.`,
+        };
+      } catch (err) {
+        return { error: `Correlation analysis failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
 };

package/src/strategy/alerts.ts

@@ -0,0 +1,190 @@
+// Event-driven alerts — monitor running strategies and trigger actions
+// Conditions checked against live metrics in the app polling loop
+
+export type AlertCondition =
+  | { type: "max_dd_exceeds"; threshold: number }
+  | { type: "pnl_below"; threshold: number }
+  | { type: "exposure_above"; threshold: number }
+  | { type: "win_rate_below"; threshold: number }
+  | { type: "loss_streak"; threshold: number };
+
+export type AlertAction =
+  | { type: "log"; message?: string }
+  | { type: "stop_process" }
+  | { type: "webhook"; url: string };
+
+export interface Alert {
+  id: string;
+  strategyName: string;
+  condition: AlertCondition;
+  action: AlertAction;
+  createdAt: number;
+  triggeredAt: number | null;
+  triggerCount: number;
+  enabled: boolean;
+  cooldownMs: number; // minimum time between triggers
+}
+
+export interface AlertEvalMetrics {
+  pnl: number;
+  max_dd: number;
+  exposure: number;
+  win_rate: number;
+  trades: number;
+  loss_streak?: number;
+}
+
+// Global alert store (in-memory, persisted to disk on change)
+const alerts = new Map<string, Alert>();
+let _alertIdCounter = 0;
+
+/** Create a new alert */
+export function createAlert(
+  strategyName: string,
+  condition: AlertCondition,
+  action: AlertAction,
+  cooldownMs: number = 60_000,
+): Alert {
+  const id = `alert-${++_alertIdCounter}-${Date.now()}`;
+  const alert: Alert = {
+    id,
+    strategyName,
+    condition,
+    action,
+    createdAt: Date.now(),
+    triggeredAt: null,
+    triggerCount: 0,
+    enabled: true,
+    cooldownMs,
+  };
+  alerts.set(id, alert);
+  return alert;
+}
+
+/** Remove an alert */
+export function removeAlert(id: string): boolean {
+  return alerts.delete(id);
+}
+
+/** List all alerts, optionally filtered by strategy */
+export function listAlerts(strategyName?: string): Alert[] {
+  const all = [...alerts.values()];
+  if (strategyName) return all.filter(a => a.strategyName === strategyName);
+  return all;
+}
+
+/** Evaluate a condition against metrics */
+function evaluateCondition(condition: AlertCondition, metrics: AlertEvalMetrics): boolean {
+  switch (condition.type) {
+    case "max_dd_exceeds":
+      return metrics.max_dd > condition.threshold;
+    case "pnl_below":
+      return metrics.pnl < condition.threshold;
+    case "exposure_above":
+      return metrics.exposure > condition.threshold;
+    case "win_rate_below":
+      return metrics.win_rate < condition.threshold;
+    case "loss_streak":
+      return (metrics.loss_streak ?? 0) >= condition.threshold;
+    default:
+      return false;
+  }
+}
+
+/** Format condition as human-readable string */
+export function formatCondition(condition: AlertCondition): string {
+  switch (condition.type) {
+    case "max_dd_exceeds": return `Max DD > ${condition.threshold}%`;
+    case "pnl_below": return `P&L < $${condition.threshold}`;
+    case "exposure_above": return `Exposure > $${condition.threshold}`;
+    case "win_rate_below": return `Win Rate < ${(condition.threshold * 100).toFixed(0)}%`;
+    case "loss_streak": return `Loss streak >= ${condition.threshold}`;
+  }
+}
+
+/** Format action as human-readable string */
+export function formatAction(action: AlertAction): string {
+  switch (action.type) {
+    case "log": return "Log message";
+    case "stop_process": return "Stop strategy";
+    case "webhook": return `Webhook → ${action.url}`;
+  }
+}
+
+export interface AlertTriggerResult {
+  alert: Alert;
+  triggered: boolean;
+  actionTaken: string | null;
+}
+
+/**
+ * Check all alerts against current metrics. Returns triggered alerts.
+ * Called from the app polling loop.
+ */
+export async function checkAlerts(
+  strategyName: string,
+  metrics: AlertEvalMetrics,
+  stopProcessFn?: () => void,
+): Promise<AlertTriggerResult[]> {
+  const results: AlertTriggerResult[] = [];
+  const now = Date.now();
+
+  for (const alert of alerts.values()) {
+    if (!alert.enabled) continue;
+    if (alert.strategyName !== strategyName) continue;
+
+    // Cooldown check
+    if (alert.triggeredAt && (now - alert.triggeredAt) < alert.cooldownMs) continue;
+
+    const triggered = evaluateCondition(alert.condition, metrics);
+    if (!triggered) {
+      results.push({ alert, triggered: false, actionTaken: null });
+      continue;
+    }
+
+    // Execute action
+    alert.triggeredAt = now;
+    alert.triggerCount++;
+    let actionTaken: string | null = null;
+
+    switch (alert.action.type) {
+      case "log":
+        actionTaken = `[ALERT] ${formatCondition(alert.condition)} — ${alert.action.message ?? "threshold breached"}`;
+        break;
+      case "stop_process":
+        if (stopProcessFn) {
+          stopProcessFn();
+          actionTaken = `[ALERT] ${formatCondition(alert.condition)} — process stopped`;
+        }
+        break;
+      case "webhook":
+        try {
+          await fetch(alert.action.url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              alert_id: alert.id,
+              strategy: alert.strategyName,
+              condition: formatCondition(alert.condition),
+              metrics,
+              timestamp: new Date().toISOString(),
+            }),
+            signal: AbortSignal.timeout(5000),
+          });
+          actionTaken = `[ALERT] ${formatCondition(alert.condition)} — webhook sent`;
+        } catch (e: any) {
+          actionTaken = `[ALERT] ${formatCondition(alert.condition)} — webhook failed: ${e.message}`;
+        }
+        break;
+    }
+
+    results.push({ alert, triggered: true, actionTaken });
+  }
+
+  return results;
+}
+
+/** Clear all alerts */
+export function clearAlerts(): void {
+  alerts.clear();
+}

package/src/strategy/export.ts

@@ -0,0 +1,159 @@
+// Strategy export/import — .hz format for sharing strategies
+// Format: JSON with code, params, risk config, backtest results, metadata
+
+import { homedir } from "os";
+import { resolve, join } from "path";
+import { existsSync } from "fs";
+import { createHash } from "crypto";
+import { getHistory } from "./ledger.ts";
+import { listVersions } from "./versioning.ts";
+
+const EXPORT_DIR = resolve(homedir(), ".horizon", "workspace", "exports");
+
+export interface HorizonStrategyFile {
+  format: "horizon-strategy-v1";
+  exported_at: string;
+  strategy: {
+    name: string;
+    code: string;
+    code_hash: string;
+    params: Record<string, unknown>;
+    risk_config: string | null;
+  };
+  performance?: {
+    total_runs: number;
+    best_sharpe: number;
+    best_pnl: number;
+    avg_win_rate: number;
+    last_backtest?: {
+      sharpe: number;
+      pnl: number;
+      win_rate: number;
+      max_dd: number;
+      trades: number;
+    };
+  };
+  metadata: {
+    versions: number;
+    horizon_version: string;
+  };
+}
+
+function codeHash(code: string): string {
+  return createHash("sha256").update(code).digest("hex").slice(0, 12);
+}
+
+/** Export a strategy to .hz format */
+export async function exportStrategy(
+  name: string,
+  code: string,
+  params: Record<string, unknown>,
+  riskConfig: string | null,
+): Promise<{ path: string; size: number }> {
+  if (!existsSync(EXPORT_DIR)) {
+    const { mkdirSync } = await import("fs");
+    mkdirSync(EXPORT_DIR, { recursive: true });
+  }
+
+  // Gather performance data from ledger
+  const history = getHistory(name);
+  const versions = await listVersions(name);
+
+  let performance: HorizonStrategyFile["performance"] = undefined;
+  if (history.length > 0) {
+    const sharpes = history.map(e => e.metrics.sharpe).filter(v => isFinite(v));
+    const pnls = history.map(e => e.metrics.pnl).filter(v => isFinite(v));
+    const winRates = history.map(e => e.metrics.win_rate).filter(v => isFinite(v));
+    const avg = (arr: number[]) => arr.length > 0 ? arr.reduce((a, b) => a + b, 0) / arr.length : 0;
+
+    const lastBacktest = history.find(e => e.type === "backtest");
+
+    performance = {
+      total_runs: history.length,
+      best_sharpe: sharpes.length > 0 ? Math.max(...sharpes) : 0,
+      best_pnl: pnls.length > 0 ? Math.max(...pnls) : 0,
+      avg_win_rate: avg(winRates),
+      last_backtest: lastBacktest ? {
+        sharpe: lastBacktest.metrics.sharpe,
+        pnl: lastBacktest.metrics.pnl,
+        win_rate: lastBacktest.metrics.win_rate,
+        max_dd: lastBacktest.metrics.max_dd,
+        trades: lastBacktest.metrics.trades,
+      } : undefined,
+    };
+  }
+
+  const pkg = await import("../../package.json");
+
+  const file: HorizonStrategyFile = {
+    format: "horizon-strategy-v1",
+    exported_at: new Date().toISOString(),
+    strategy: {
+      name,
+      code,
+      code_hash: codeHash(code),
+      params,
+      risk_config: riskConfig,
+    },
+    performance,
+    metadata: {
+      versions: versions.length,
+      horizon_version: (pkg as any).version ?? "unknown",
+    },
+  };
+
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  const fileName = `${slug}.hz`;
+  const filePath = join(EXPORT_DIR, fileName);
+
+  await Bun.write(filePath, JSON.stringify(file, null, 2));
+  const stat = await import("fs").then(fs => fs.statSync(filePath));
+
+  return { path: `exports/${fileName}`, size: stat.size };
+}
+
+/** Import a strategy from .hz file */
+export async function importStrategy(path: string): Promise<{
+  name: string;
+  code: string;
+  params: Record<string, unknown>;
+  riskConfig: string | null;
+  performance?: HorizonStrategyFile["performance"];
+}> {
+  // Resolve path — accept workspace-relative or absolute
+  let absolutePath: string;
+  if (path.startsWith("/") || path.startsWith("~")) {
+    absolutePath = path.startsWith("~") ? resolve(homedir(), path.slice(2)) : path;
+  } else {
+    absolutePath = resolve(homedir(), ".horizon", "workspace", path);
+  }
+
+  if (!existsSync(absolutePath)) {
+    throw new Error(`File not found: ${path}`);
+  }
+
+  const content = await Bun.file(absolutePath).text();
+  let file: HorizonStrategyFile;
+
+  try {
+    file = JSON.parse(content);
+  } catch {
+    throw new Error("Invalid .hz file: not valid JSON");
+  }
+
+  if (file.format !== "horizon-strategy-v1") {
+    throw new Error(`Unsupported format: ${file.format}`);
+  }
+
+  if (!file.strategy?.code || !file.strategy?.name) {
+    throw new Error("Invalid .hz file: missing strategy code or name");
+  }
+
+  return {
+    name: file.strategy.name,
+    code: file.strategy.code,
+    params: file.strategy.params ?? {},
+    riskConfig: file.strategy.risk_config,
+    performance: file.performance,
+  };
+}

package/src/strategy/health.ts

@@ -0,0 +1,127 @@
+// Strategy health score — 0-100 quality rating for strategy code
+// Computed from code analysis: risk config, feed guards, pipeline quality, etc.
+
+export interface HealthCheck {
+  category: string;
+  name: string;
+  points: number;
+  maxPoints: number;
+  passed: boolean;
+  detail: string;
+}
+
+export interface HealthReport {
+  score: number;
+  maxScore: number;
+  grade: string; // A, B, C, D, F
+  checks: HealthCheck[];
+  summary: string;
+}
+
+function check(category: string, name: string, maxPoints: number, passed: boolean, detail: string): HealthCheck {
+  return { category, name, points: passed ? maxPoints : 0, maxPoints, passed, detail };
+}
+
+/** Compute health score for strategy code */
+export function computeHealthScore(code: string): HealthReport {
+  const checks: HealthCheck[] = [];
+
+  // ── Risk Configuration (20 pts) ──
+
+  checks.push(check("risk", "has_risk_config", 5, /hz\.Risk\s*\(/.test(code),
+    "Strategy uses hz.Risk() for risk management"));
+
+  checks.push(check("risk", "max_drawdown", 5, /max_drawdown_pct\s*=/.test(code),
+    "max_drawdown_pct is configured"));
+
+  checks.push(check("risk", "max_position", 5, /max_position\s*=/.test(code),
+    "max_position limit is set"));
+
+  checks.push(check("risk", "max_notional", 5, /max_notional\s*=/.test(code) || /max_order_size\s*=/.test(code),
+    "max_notional or max_order_size is set"));
+
+  // ── Feed Staleness Guards (15 pts) ──
+
+  checks.push(check("feeds", "staleness_check", 10, /is_stale\s*\(/.test(code),
+    "Feed staleness is checked with is_stale()"));
+
+  checks.push(check("feeds", "feed_null_check", 5,
+    /if\s+(not\s+)?feed/.test(code) || /feed\s+(is\s+None|==\s*None|is\s+not)/.test(code),
+    "Feed null/None check before use"));
+
+  // ── Pipeline Quality (20 pts) ──
+
+  const pipelineMatch = code.match(/pipeline\s*=\s*\[([\s\S]*?)\]/);
+  const pipelineFns = pipelineMatch
+    ? pipelineMatch[1]!.split(",").map(s => s.trim()).filter(s => s && !s.startsWith("#"))
+    : [];
+
+  checks.push(check("pipeline", "has_pipeline", 5, pipelineFns.length > 0,
+    `Pipeline has ${pipelineFns.length} function(s)`));
+
+  checks.push(check("pipeline", "multi_stage", 5, pipelineFns.length >= 2,
+    "Pipeline has 2+ stages (signal + quoting)"));
+
+  checks.push(check("pipeline", "returns_quotes", 5, /return\s+.*quotes|return\s+\[\]/.test(code),
+    "Pipeline returns list[Quote] or []"));
+
+  checks.push(check("pipeline", "hz_run_call", 5, /hz\.run\s*\(/.test(code),
+    "Strategy has hz.run() call"));
+
+  // ── Parameter Tunability (10 pts) ──
+
+  checks.push(check("params", "uses_ctx_params", 5, /ctx\.params/.test(code),
+    "Uses ctx.params for tunable values"));
+
+  checks.push(check("params", "params_dict", 5, /params\s*=\s*\{/.test(code),
+    "params={} dictionary defined in hz.run()"));
+
+  // ── Mode Safety (10 pts) ──
+
+  checks.push(check("safety", "paper_mode", 5, /mode\s*=\s*["']paper["']/.test(code),
+    "Strategy uses mode='paper' for safety"));
+
+  checks.push(check("safety", "no_hardcoded_slugs", 5,
+    !/markets\s*=\s*\["[a-z]/.test(code) || /ctx\.market\.slug/.test(code) || /ctx\.params/.test(code),
+    "Market slugs not hardcoded or use ctx.params"));
+
+  // ── Market & Feeds (10 pts) ──
+
+  checks.push(check("markets", "has_feeds", 5, /feeds\s*=\s*\[/.test(code),
+    "Feed sources configured"));
+
+  checks.push(check("markets", "has_markets", 5, /markets\s*=\s*\[/.test(code),
+    "Market slugs configured"));
+
+  // ── Error Handling (15 pts) ──
+
+  checks.push(check("robustness", "empty_return", 5, /return\s+\[\]/.test(code),
+    "Has empty return [] for edge cases"));
+
+  checks.push(check("robustness", "try_except", 5, /try\s*:/.test(code) || /except/.test(code) || /if\s+not\s+/.test(code),
+    "Has error handling or guard clauses"));
+
+  checks.push(check("robustness", "inventory_check", 5,
+    /ctx\.inventory/.test(code) || /net_for_market/.test(code),
+    "Checks inventory for position awareness"));
+
+  // ── Compute Score ──
+
+  const score = checks.reduce((sum, c) => sum + c.points, 0);
+  const maxScore = checks.reduce((sum, c) => sum + c.maxPoints, 0);
+  const pct = (score / maxScore) * 100;
+
+  let grade: string;
+  if (pct >= 90) grade = "A";
+  else if (pct >= 80) grade = "B";
+  else if (pct >= 65) grade = "C";
+  else if (pct >= 50) grade = "D";
+  else grade = "F";
+
+  const failed = checks.filter(c => !c.passed);
+  const summary = failed.length === 0
+    ? `Perfect score! All ${checks.length} checks passed.`
+    : `${score}/${maxScore} (${grade}). Missing: ${failed.map(c => c.name.replace(/_/g, " ")).join(", ")}.`;
+
+  return { score, maxScore, grade, checks, summary };
+}