horizon-code 0.5.0 → 0.6.0

package/src/research/scanner.ts

@@ -0,0 +1,212 @@
+// Market scanner + correlation analysis
+// Scans for trading opportunities across Polymarket markets
+
+import { gammaEvents } from "./apis.ts";
+
+export interface MarketOpportunity {
+  slug: string;
+  title: string;
+  type: "wide_spread" | "high_volume" | "mispricing" | "volatile";
+  score: number; // 0-100
+  spread?: number;
+  volume?: number;
+  price?: number;
+  detail: string;
+}
+
+export interface CorrelationResult {
+  marketA: string;
+  marketB: string;
+  correlation: number;   // -1 to 1
+  direction: string;     // "positive", "negative", "neutral"
+  strength: string;      // "strong", "moderate", "weak"
+}
+
+export interface CorrelationMatrix {
+  markets: string[];
+  matrix: number[][];
+  pairs: CorrelationResult[];
+  high_correlation_warning: string | null;
+}
+
+/**
+ * Scan top Polymarket markets for trading opportunities.
+ * Returns ranked list of opportunities for market making, edge trading, or arbitrage.
+ */
+export async function scanOpportunities(limit: number = 30): Promise<{
+  opportunities: MarketOpportunity[];
+  total_scanned: number;
+  summary: string;
+}> {
+  // Fetch active events
+  const events = await gammaEvents({ query: "", limit: limit * 2 });
+  if (!events || events.length === 0) {
+    return { opportunities: [], total_scanned: 0, summary: "No markets available." };
+  }
+
+  const opportunities: MarketOpportunity[] = [];
+
+  for (const event of events) {
+    const markets = event.markets ?? [event];
+
+    for (const market of markets) {
+      const slug = market.slug ?? market.conditionId ?? "";
+      const title = market.question ?? market.title ?? slug;
+      const spread = market.spread ?? (market.bestAsk && market.bestBid ? market.bestAsk - market.bestBid : null);
+      const volume = market.volume ?? market.volumeNum ?? 0;
+      const price = market.lastTradePrice ?? market.outcomePrices?.[0] ?? 0.5;
+      const priceNum = typeof price === "string" ? parseFloat(price) : price;
+
+      // Wide spread opportunity (market making)
+      if (spread && spread > 0.04) {
+        const score = Math.min(100, Math.round(spread * 500));
+        opportunities.push({
+          slug, title, type: "wide_spread", score, spread, volume: volume,
+          detail: `Spread ${(spread * 100).toFixed(1)}c — room for market making`,
+        });
+      }
+
+      // High volume but price near 50% (uncertain market = good for MM)
+      if (volume > 50000 && priceNum > 0.3 && priceNum < 0.7) {
+        const uncertainty = 1 - Math.abs(priceNum - 0.5) * 2;
+        const score = Math.min(100, Math.round(uncertainty * 60 + (volume / 100000) * 40));
+        opportunities.push({
+          slug, title, type: "high_volume", score, volume, price: priceNum,
+          detail: `$${(volume / 1000).toFixed(0)}K vol, price ${(priceNum * 100).toFixed(0)}c — high uncertainty`,
+        });
+      }
+
+      // Extreme prices that might indicate mispricing
+      if (priceNum > 0.02 && priceNum < 0.08) {
+        opportunities.push({
+          slug, title, type: "mispricing", score: 65, price: priceNum,
+          detail: `Low price ${(priceNum * 100).toFixed(1)}c — potential long tail value`,
+        });
+      }
+      if (priceNum > 0.92 && priceNum < 0.98) {
+        opportunities.push({
+          slug, title, type: "mispricing", score: 55, price: priceNum,
+          detail: `High price ${(priceNum * 100).toFixed(1)}c — potential short opportunity`,
+        });
+      }
+    }
+  }
+
+  // Sort by score descending and deduplicate by slug
+  const seen = new Set<string>();
+  const unique = opportunities
+    .sort((a, b) => b.score - a.score)
+    .filter(o => {
+      if (seen.has(o.slug)) return false;
+      seen.add(o.slug);
+      return true;
+    })
+    .slice(0, limit);
+
+  const byType = {
+    wide_spread: unique.filter(o => o.type === "wide_spread").length,
+    high_volume: unique.filter(o => o.type === "high_volume").length,
+    mispricing: unique.filter(o => o.type === "mispricing").length,
+  };
+
+  const summary = `Scanned ${events.length} markets. Found ${unique.length} opportunities: ` +
+    `${byType.wide_spread} wide spreads, ${byType.high_volume} high volume, ${byType.mispricing} mispricings.`;
+
+  return { opportunities: unique, total_scanned: events.length, summary };
+}
+
+/**
+ * Compute pairwise correlations between a set of markets.
+ * Uses simple price-based correlation from available data.
+ */
+export function computeCorrelations(
+  marketPrices: { slug: string; prices: number[] }[],
+): CorrelationMatrix {
+  const n = marketPrices.length;
+  const matrix: number[][] = Array.from({ length: n }, () => Array(n).fill(0));
+  const pairs: CorrelationResult[] = [];
+
+  for (let i = 0; i < n; i++) {
+    matrix[i]![i] = 1.0;
+    for (let j = i + 1; j < n; j++) {
+      const corr = pearsonCorrelation(marketPrices[i]!.prices, marketPrices[j]!.prices);
+      matrix[i]![j] = corr;
+      matrix[j]![i] = corr;
+
+      const absCorr = Math.abs(corr);
+      pairs.push({
+        marketA: marketPrices[i]!.slug,
+        marketB: marketPrices[j]!.slug,
+        correlation: Math.round(corr * 100) / 100,
+        direction: corr > 0.1 ? "positive" : corr < -0.1 ? "negative" : "neutral",
+        strength: absCorr > 0.7 ? "strong" : absCorr > 0.4 ? "moderate" : "weak",
+      });
+    }
+  }
+
+  // Find high correlations that indicate concentration risk
+  const highCorr = pairs.filter(p => Math.abs(p.correlation) > 0.7);
+  const warning = highCorr.length > 0
+    ? `WARNING: ${highCorr.length} pair(s) with >0.7 correlation — portfolio is concentrated: ${highCorr.map(p => `${p.marketA}/${p.marketB} (${p.correlation})`).join(", ")}`
+    : null;
+
+  return {
+    markets: marketPrices.map(m => m.slug),
+    matrix,
+    pairs: pairs.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation)),
+    high_correlation_warning: warning,
+  };
+}
+
+/** Pearson correlation between two arrays */
+function pearsonCorrelation(x: number[], y: number[]): number {
+  const n = Math.min(x.length, y.length);
+  if (n < 3) return 0;
+
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += x[i]!;
+    sumY += y[i]!;
+    sumXY += x[i]! * y[i]!;
+    sumX2 += x[i]! * x[i]!;
+    sumY2 += y[i]! * y[i]!;
+  }
+
+  const numerator = n * sumXY - sumX * sumY;
+  const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+
+  if (denominator === 0) return 0;
+  return numerator / denominator;
+}
+
+/** Build ASCII correlation matrix for terminal display */
+export function formatCorrelationMatrix(result: CorrelationMatrix): string {
+  const { markets, matrix } = result;
+  const n = markets.length;
+  const maxSlugLen = Math.min(12, Math.max(...markets.map(m => m.length)));
+
+  const lines: string[] = [];
+
+  // Header
+  const header = " ".repeat(maxSlugLen + 2) + markets.map(m => m.slice(0, 6).padStart(7)).join("");
+  lines.push(header);
+  lines.push("-".repeat(header.length));
+
+  // Rows
+  for (let i = 0; i < n; i++) {
+    const slug = markets[i]!.slice(0, maxSlugLen).padEnd(maxSlugLen);
+    const vals = matrix[i]!.map((v, j) => {
+      if (i === j) return "  1.00";
+      const str = v.toFixed(2);
+      return (v >= 0 ? " " : "") + str;
+    }).map(s => s.padStart(7)).join("");
+    lines.push(`${slug}  ${vals}`);
+  }
+
+  if (result.high_correlation_warning) {
+    lines.push("");
+    lines.push(result.high_correlation_warning);
+  }
+
+  return lines.join("\n");
+}

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,
+  };
+}