horizon-code 0.1.0

package/src/platform/sync.ts

@@ -0,0 +1,149 @@
+import { platform } from "./client.ts";
+import { isLoggedIn } from "./supabase.ts";
+import { store } from "../state/store.ts";
+import type { Deployment, DeploymentMetrics, Position, Order, DeploymentStatus } from "../state/types.ts";
+import type { PlatformStrategy, PlatformDeployment, PlatformMetrics } from "./types.ts";
+
+const pnlHistories: Map<string, number[]> = new Map();
+
+export class PlatformSync {
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  async start(intervalMs = 30000): Promise<void> {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn && !platform.authenticated) return;
+
+    await this.poll();
+    this.timer = setInterval(() => this.poll(), intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+  }
+
+  private async poll(): Promise<void> {
+    try {
+      const strategies = await platform.listStrategies();
+
+      // Parallel fetch: deployments for all strategies at once
+      const depResults = await Promise.allSettled(
+        strategies.map((s) => platform.listDeployments(s.id))
+      );
+
+      // Identify which strategies need metrics (running/starting only)
+      const stratWithDeps = strategies.map((strat, i) => {
+        const deps = depResults[i]?.status === "fulfilled" ? depResults[i].value : [];
+        const latestDep = deps.find((d) => d.status === "running")
+          ?? deps.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0]
+          ?? null;
+
+        let status: DeploymentStatus = "stopped";
+        if (latestDep) status = latestDep.status as DeploymentStatus;
+        else if (strat.status === "error") status = "error";
+        else if (strat.status === "deployed") status = "running";
+
+        return { strat, latestDep, status };
+      });
+
+      // Parallel fetch: metrics only for running strategies
+      const running = stratWithDeps.filter((s) => s.status === "running" || s.status === "starting");
+      const metricsResults = await Promise.allSettled(
+        running.map((s) => platform.getMetrics(s.strat.id, 1))
+      );
+      const metricsMap = new Map<string, typeof metricsResults[0]>();
+      running.forEach((s, i) => metricsMap.set(s.strat.id, metricsResults[i]!));
+
+      const deployments: Deployment[] = stratWithDeps.map(({ strat, latestDep, status }) => {
+        let metrics: DeploymentMetrics = emptyMetrics();
+        let positions: Position[] = [];
+        let orders: Order[] = [];
+
+        const mr = metricsMap.get(strat.id);
+        if (mr?.status === "fulfilled" && mr.value.latest) {
+          const m = mr.value.latest;
+          metrics = mapMetrics(m);
+          positions = mapPositions(m.positions ?? []);
+          orders = mapOrders(m.recent_orders ?? []);
+
+          let hist = pnlHistories.get(strat.id) ?? [];
+          hist.push(m.total_pnl);
+          if (hist.length > 60) hist = hist.slice(-60);
+          pnlHistories.set(strat.id, hist);
+        }
+
+        return {
+          id: latestDep?.id ?? strat.id,
+          strategyId: strat.id,
+          name: strat.name,
+          strategy_type: inferType(strat),
+          status,
+          dry_run: latestDep?.dry_run ?? true,
+          mode: latestDep?.deployment_mode ?? "manual",
+          metrics,
+          positions,
+          orders,
+          pnl_history: pnlHistories.get(strat.id) ?? [],
+          started_at: latestDep?.started_at ? new Date(latestDep.started_at).getTime() : new Date(strat.created_at).getTime(),
+        };
+      });
+
+      store.update({ deployments, connection: "connected" });
+    } catch {
+      store.update({ connection: "disconnected" });
+    }
+  }
+}
+
+function emptyMetrics(): DeploymentMetrics {
+  return {
+    total_pnl: 0, realized_pnl: 0, unrealized_pnl: 0,
+    total_exposure: 0, position_count: 0, open_order_count: 0,
+    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,
+  };
+}
+
+function mapMetrics(m: PlatformMetrics): DeploymentMetrics {
+  const gp = m.gross_profit || 0;
+  const gl = m.gross_loss || 0;
+  return {
+    total_pnl: m.total_pnl ?? 0, realized_pnl: m.realized_pnl ?? 0,
+    unrealized_pnl: m.unrealized_pnl ?? 0, total_exposure: m.total_exposure ?? 0,
+    position_count: m.position_count ?? 0, open_order_count: m.open_order_count ?? 0,
+    win_rate: m.win_rate ?? 0, total_trades: m.total_trades ?? 0,
+    max_drawdown_pct: m.max_drawdown_pct ?? 0, sharpe_ratio: 0,
+    profit_factor: gl > 0 ? gp / gl : 0, avg_return_per_trade: m.avg_return_per_trade ?? 0,
+    gross_profit: gp, gross_loss: gl,
+  };
+}
+
+function mapPositions(raw: PlatformMetrics["positions"]): Position[] {
+  return (raw ?? []).map((p) => ({
+    market_id: p.market_id ?? "", slug: p.slug ?? "", question: p.question ?? "",
+    side: p.side, size: p.size, avg_entry_price: p.avg_entry_price,
+    cost_basis: p.cost_basis, realized_pnl: p.realized_pnl, unrealized_pnl: p.unrealized_pnl,
+  }));
+}
+
+function mapOrders(raw: PlatformMetrics["recent_orders"]): Order[] {
+  return (raw ?? []).map((o) => ({
+    market_id: o.market_id ?? "", slug: o.slug ?? "", side: o.side,
+    price: o.price, size: o.size, filled_size: o.filled_size,
+    status: o.status, order_type: o.order_type,
+    created_at: new Date(o.created_at).getTime(),
+  }));
+}
+
+function inferType(strat: PlatformStrategy): string {
+  const name = strat.name.toLowerCase();
+  if (name.includes("mm") || name.includes("market")) return "market_making";
+  if (name.includes("arb")) return "arbitrage";
+  if (name.includes("direct")) return "directional";
+  if (name.includes("event") || name.includes("snip") || name.includes("bond")) return "event_driven";
+  if (name.includes("moment") || name.includes("trend") || name.includes("fade")) return "momentum";
+  if (name.includes("mean") || name.includes("revert")) return "mean_reversion";
+  return "custom";
+}
+
+export const platformSync = new PlatformSync();

package/src/platform/tiers.ts

@@ -0,0 +1,103 @@
+// Tier configuration — plans, models, budgets, rate limits
+
+export type PlanTier = "free" | "pro" | "ultra";
+export type ModelPower = "fast" | "standard" | "pro" | "ultra";
+
+export interface TierConfig {
+  tokenBudget: number;          // weighted tokens per 5-hour window
+  ratePerMinute: number;
+  allowedModels: ModelPower[];
+  defaultModel: ModelPower;
+  overflowToFast: boolean;      // when budget exhausted, allow unlimited Fast
+}
+
+// OpenRouter model IDs
+export const MODEL_IDS: Record<ModelPower, string> = {
+  fast: "openrouter/hunter-alpha",
+  standard: "anthropic/claude-haiku-4.5",
+  pro: "anthropic/claude-sonnet-4.6",
+  ultra: "anthropic/claude-opus-4.6",
+};
+
+// Higher models drain budget faster
+export const MODEL_MULTIPLIER: Record<ModelPower, number> = {
+  fast: 0.25,
+  standard: 1,
+  pro: 2,
+  ultra: 4,
+};
+
+export const TIER_CONFIG: Record<PlanTier, TierConfig> = {
+  free: {
+    tokenBudget: 50_000,
+    ratePerMinute: 5,
+    allowedModels: ["fast"],
+    defaultModel: "fast",
+    overflowToFast: false,       // free users get blocked
+  },
+  pro: {
+    tokenBudget: 500_000,
+    ratePerMinute: 30,
+    allowedModels: ["fast", "standard", "pro"],
+    defaultModel: "standard",
+    overflowToFast: true,        // overflow to unlimited Fast
+  },
+  ultra: {
+    tokenBudget: 5_000_000,
+    ratePerMinute: 120,
+    allowedModels: ["fast", "standard", "pro", "ultra"],
+    defaultModel: "pro",
+    overflowToFast: true,        // overflow to unlimited Fast
+  },
+};
+
+export const WINDOW_SECONDS = 5 * 60 * 60; // 18000 = 5 hours
+
+export function getWindowBounds(now: Date = new Date()): { start: Date; end: Date } {
+  const epoch = Math.floor(now.getTime() / 1000);
+  const windowStart = Math.floor(epoch / WINDOW_SECONDS) * WINDOW_SECONDS;
+  return {
+    start: new Date(windowStart * 1000),
+    end: new Date((windowStart + WINDOW_SECONDS) * 1000),
+  };
+}
+
+export function formatTimeRemaining(ms: number): string {
+  if (ms <= 0) return "now";
+  const h = Math.floor(ms / 3_600_000);
+  const m = Math.ceil((ms % 3_600_000) / 60_000);
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+export function resolveModel(tier: PlanTier, power: ModelPower, budgetExhausted: boolean): {
+  modelId: string;
+  effectivePower: ModelPower;
+  downgraded: boolean;
+} {
+  const config = TIER_CONFIG[tier];
+
+  // Budget exhausted: paid users overflow to fast, free users blocked
+  if (budgetExhausted) {
+    if (config.overflowToFast) {
+      return { modelId: MODEL_IDS.fast, effectivePower: "fast", downgraded: true };
+    }
+    // Free users: handled by caller (blocked)
+    return { modelId: MODEL_IDS.fast, effectivePower: "fast", downgraded: true };
+  }
+
+  // Model not allowed on this tier: downgrade to highest allowed
+  if (!config.allowedModels.includes(power)) {
+    const best = config.allowedModels[config.allowedModels.length - 1]!;
+    return { modelId: MODEL_IDS[best], effectivePower: best, downgraded: true };
+  }
+
+  return { modelId: MODEL_IDS[power], effectivePower: power, downgraded: false };
+}
+
+// Tools that require Pro or higher — free users don't see them
+export const PREMIUM_TOOLS: Record<string, PlanTier> = {
+  newsSentiment: "pro",
+  calaKnowledge: "pro",
+};
+

package/src/platform/tools.ts

@@ -0,0 +1,163 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { platform } from "./client.ts";
+
+const t = tool as any;
+
+export const portfolioTools: Record<string, any> = {
+  list_strategies: t({
+    description: "List all the user's strategies with their status (draft, validated, deployed, stopped, error).",
+    parameters: z.object({}),
+    execute: async () => {
+      const strategies = await platform.listStrategies();
+      return strategies.map((s) => ({
+        id: s.id,
+        name: s.name,
+        description: s.description,
+        status: s.status,
+        class_name: s.class_name,
+        circuit_breaker: s.circuit_breaker_enabled,
+        created_at: s.created_at,
+        updated_at: s.updated_at,
+      }));
+    },
+  }),
+
+  get_strategy: t({
+    description: "Get detailed info about a specific strategy including its parameters, risk config, and code.",
+    parameters: z.object({
+      strategy_id: z.string().describe("Strategy UUID"),
+    }),
+    execute: async (args: any) => platform.getStrategy(args.strategy_id),
+  }),
+
+  list_deployments: t({
+    description: "List all deployments for a strategy — active, stopped, errored. Shows status, dry_run (paper/live), mode, timestamps.",
+    parameters: z.object({
+      strategy_id: z.string().describe("Strategy UUID"),
+    }),
+    execute: async (args: any) => {
+      const deps = await platform.listDeployments(args.strategy_id);
+      return deps.map((d) => ({
+        id: d.id,
+        strategy_id: d.strategy_id,
+        status: d.status,
+        dry_run: d.dry_run,
+        mode: d.deployment_mode,
+        error: d.error_message,
+        started_at: d.started_at,
+        stopped_at: d.stopped_at,
+      }));
+    },
+  }),
+
+  get_metrics: t({
+    description: "Get the latest performance metrics for a strategy's active deployment: P&L, positions, orders, win rate, drawdown, exposure.",
+    parameters: z.object({
+      strategy_id: z.string().describe("Strategy UUID"),
+      limit: z.number().optional().describe("Number of historical snapshots (default 10)"),
+    }),
+    execute: async (args: any) => {
+      const data = await platform.getMetrics(args.strategy_id, args.limit ?? 10);
+      return {
+        latest: data.latest ? {
+          total_pnl: data.latest.total_pnl,
+          realized_pnl: data.latest.realized_pnl,
+          unrealized_pnl: data.latest.unrealized_pnl,
+          total_exposure: data.latest.total_exposure,
+          position_count: data.latest.position_count,
+          open_order_count: data.latest.open_order_count,
+          win_rate: data.latest.win_rate,
+          total_trades: data.latest.total_trades,
+          max_drawdown_pct: data.latest.max_drawdown_pct,
+          gross_profit: data.latest.gross_profit,
+          gross_loss: data.latest.gross_loss,
+          positions: data.latest.positions,
+          recent_orders: data.latest.recent_orders,
+        } : null,
+        history_count: data.history.length,
+        pnl_history: data.history.map((h) => ({
+          total_pnl: h.total_pnl,
+          created_at: h.created_at,
+        })),
+      };
+    },
+  }),
+
+  get_logs: t({
+    description: "Get recent deployment logs for a strategy — stdout/stderr from the running bot.",
+    parameters: z.object({
+      strategy_id: z.string().describe("Strategy UUID"),
+      limit: z.number().optional().describe("Number of log entries (default 50)"),
+    }),
+    execute: async (args: any) => platform.getLogs(args.strategy_id, args.limit ?? 50),
+  }),
+
+  deploy_strategy: t({
+    description: "Deploy a strategy to the Horizon cloud. Call list_credentials first to get a credential_id. Always start with dry_run=true (paper mode).",
+    parameters: z.object({
+      strategy_id: z.string().describe("Strategy UUID (from save_strategy result)"),
+      credential_id: z.string().describe("Exchange credential UUID (from list_credentials)"),
+      dry_run: z.boolean().describe("true for paper trading (recommended), false for live"),
+    }),
+    execute: async (args: any) => {
+      if (!args.dry_run) {
+        return { error: "Live mode requires explicit confirmation. Call with dry_run=true first, then ask the user to confirm before switching to live." };
+      }
+      try {
+        return await platform.deploy(args.strategy_id, {
+          credentialId: args.credential_id,
+          dryRun: args.dry_run,
+        });
+      } catch (e: any) { return { error: e.message }; }
+    },
+  }),
+
+  stop_strategy: t({
+    description: "Stop an active cloud deployment. Sends SIGTERM to the running process.",
+    parameters: z.object({
+      strategy_id: z.string().describe("Strategy UUID"),
+    }),
+    execute: async (args: any) => {
+      try { return await platform.stop(args.strategy_id); }
+      catch (e: any) { return { error: e.message }; }
+    },
+  }),
+
+  list_credentials: t({
+    description: "List the user's saved exchange credentials (wallet keys). Needed before deploy — provides the credential_id.",
+    parameters: z.object({}),
+    execute: async () => {
+      try {
+        const creds = await platform.listCredentials();
+        if (creds.length === 0) {
+          return { credentials: [], hint: "No credentials found. The user needs to add one with add_credential or from the platform web UI." };
+        }
+        return { credentials: creds.map((c) => ({ id: c.id, label: c.label, exchange: c.exchange, wallet: c.wallet_address })) };
+      } catch (e: any) { return { error: e.message }; }
+    },
+  }),
+
+  add_credential: t({
+    description: "Add an exchange credential. Tell the user to run `/credential` in the TUI — private keys must NEVER be typed in the chat (they would be sent to the LLM). This tool only explains the process.",
+    parameters: z.object({}),
+    execute: async () => {
+      return {
+        message: "For security, private keys cannot be added through chat. Tell the user to run the /credential command, which prompts for the key directly without sending it to the AI.",
+        hint: "Type: /credential add <label> <exchange> — then paste the private key when prompted.",
+      };
+    },
+  }),
+
+  validate_code: t({
+    description: "Validate strategy code on the platform's server-side validator.",
+    parameters: z.object({
+      code: z.string().describe("Python strategy code to validate"),
+    }),
+    execute: async (args: any) => {
+      try { return await platform.validateCode(args.code); }
+      catch (e: any) { return { error: e.message }; }
+    },
+  }),
+
+};

package/src/platform/types.ts

@@ -0,0 +1,86 @@
+export interface PlatformStrategy {
+  id: string;
+  name: string;
+  description: string;
+  status: "draft" | "validated" | "deployed" | "stopped" | "error";
+  class_name: string | null;
+  params: Record<string, unknown>;
+  sdk_risk_config: SdkRiskConfig | null;
+  circuit_breaker_enabled: boolean;
+  circuit_breaker_max_drawdown: number | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SdkRiskConfig {
+  max_position: number;
+  max_position_per_market: number;
+  max_notional: number;
+  max_drawdown_pct: number;
+  max_order_size: number;
+  rate_limit: number;
+  rate_burst: number;
+}
+
+export interface PlatformDeployment {
+  id: string;
+  strategy_id: string;
+  credential_id: string;
+  status: string;
+  dry_run: boolean;
+  deployment_mode: "manual" | "scanner";
+  worker_process_id: string | null;
+  error_message: string | null;
+  started_at: string | null;
+  stopped_at: string | null;
+  created_at: string;
+}
+
+export interface PlatformMetrics {
+  total_pnl: number;
+  unrealized_pnl: number;
+  realized_pnl: number;
+  total_exposure: number;
+  position_count: number;
+  open_order_count: number;
+  win_rate: number;
+  total_trades: number;
+  gross_profit: number;
+  gross_loss: number;
+  max_drawdown_pct: number;
+  avg_return_per_trade: number;
+  positions: PlatformPosition[];
+  recent_orders: PlatformOrder[];
+  created_at: string;
+}
+
+export interface PlatformPosition {
+  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 PlatformOrder {
+  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: string;
+}
+
+export interface PlatformLog {
+  level: string;
+  message: string;
+  source: string;
+  logged_at: string;
+}