horizon-code 0.1.0

package/src/components/widgets/sparkline.ts

@@ -0,0 +1,57 @@
+import { TextRenderable, type CliRenderer } from "@opentui/core";
+import { COLORS } from "../../theme/colors.ts";
+import { ICONS } from "../../theme/icons.ts";
+
+const BLOCKS = ICONS.spark;
+
+export class Sparkline {
+  private text: TextRenderable;
+
+  constructor(
+    renderer: CliRenderer,
+    id: string,
+    private width: number = 16,
+  ) {
+    this.text = new TextRenderable(renderer, {
+      id,
+      content: "",
+      fg: COLORS.textMuted,
+    });
+  }
+
+  get renderable(): TextRenderable {
+    return this.text;
+  }
+
+  setData(values: number[], color?: string): void {
+    if (values.length === 0) {
+      this.text.content = "";
+      return;
+    }
+
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+
+    const sampled: number[] = [];
+    for (let i = 0; i < this.width; i++) {
+      const idx = Math.floor((i / this.width) * values.length);
+      sampled.push(values[idx] ?? min);
+    }
+
+    const chars = sampled.map((v) => {
+      const normalized = (v - min) / range;
+      const blockIdx = Math.min(Math.floor(normalized * BLOCKS.length), BLOCKS.length - 1);
+      return BLOCKS[blockIdx];
+    });
+
+    this.text.content = chars.join("");
+    if (color) {
+      this.text.fg = color;
+    } else {
+      const last = values[values.length - 1]!;
+      const first = values[0]!;
+      this.text.fg = last >= first ? COLORS.success : COLORS.error;
+    }
+  }
+}

package/src/hooks/executor.ts

@@ -0,0 +1,109 @@
+// Hooks — user-defined bash commands at strategy lifecycle points
+// Each hook requires user approval before executing
+
+import { loadConfig, saveConfig } from "../platform/config.ts";
+
+export type HookEvent =
+  | "before_generate" | "after_generate"
+  | "before_validate" | "after_validate"
+  | "before_backtest" | "after_backtest"
+  | "before_run" | "after_run"
+  | "before_deploy" | "after_deploy"
+  | "before_stop" | "after_stop";
+
+export const HOOK_EVENTS: HookEvent[] = [
+  "before_generate", "after_generate",
+  "before_validate", "after_validate",
+  "before_backtest", "after_backtest",
+  "before_run", "after_run",
+  "before_deploy", "after_deploy",
+  "before_stop", "after_stop",
+];
+
+export interface HookConfig {
+  event: HookEvent;
+  command: string;
+  enabled: boolean;
+  label?: string;
+}
+
+export interface HookResult {
+  event: HookEvent;
+  command: string;
+  approved: boolean;
+  exitCode?: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+// Tool name → before/after hook events
+export const TOOL_BEFORE_HOOK: Record<string, HookEvent> = {
+  edit_strategy: "before_generate",
+  validate_strategy: "before_validate",
+  backtest_strategy: "before_backtest",
+  run_strategy: "before_run",
+  deploy_strategy: "before_deploy",
+  stop_strategy: "before_stop",
+};
+
+export const TOOL_AFTER_HOOK: Record<string, HookEvent> = {
+  edit_strategy: "after_generate",
+  validate_strategy: "after_validate",
+  backtest_strategy: "after_backtest",
+  run_strategy: "after_run",
+  deploy_strategy: "after_deploy",
+  stop_strategy: "after_stop",
+};
+
+export function loadHooks(): HookConfig[] {
+  return (loadConfig().hooks as HookConfig[] | undefined) ?? [];
+}
+
+export function saveHooks(hooks: HookConfig[]): void {
+  const config = loadConfig();
+  config.hooks = hooks as any;
+  saveConfig(config);
+}
+
+export function getHooksForEvent(event: HookEvent): HookConfig[] {
+  return loadHooks().filter((h) => h.event === event && h.enabled);
+}
+
+export async function executeHook(hook: HookConfig): Promise<HookResult> {
+  try {
+    // Restricted env — no secrets (hooks are user-defined shell commands)
+    const hookEnv: Record<string, string> = {};
+    for (const k of ["PATH", "HOME", "LANG", "LC_ALL", "TERM", "SHELL", "USER"]) {
+      if (process.env[k]) hookEnv[k] = process.env[k]!;
+    }
+    const proc = Bun.spawn(["bash", "-c", hook.command], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: hookEnv,
+    });
+
+    const stdout = await Promise.race([
+      new Response(proc.stdout).text(),
+      new Promise<string>((_, reject) => setTimeout(() => { proc.kill(); reject(new Error("timeout")); }, 30000)),
+    ]);
+    const stderr = await new Response(proc.stderr).text();
+    await proc.exited;
+
+    return {
+      event: hook.event,
+      command: hook.command,
+      approved: true,
+      exitCode: proc.exitCode ?? 1,
+      stdout: stdout.slice(0, 1000),
+      stderr: stderr.slice(0, 500),
+    };
+  } catch (err) {
+    return {
+      event: hook.event,
+      command: hook.command,
+      approved: true,
+      exitCode: 1,
+      stderr: err instanceof Error ? err.message : "Hook execution failed",
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+import { createCliRenderer } from "@opentui/core";
+import { App } from "./app.ts";
+import { initMCP, closeMCP } from "./ai/client.ts";
+import { saveActiveSession, stopAutoSave } from "./platform/session-sync.ts";
+
+// Connect to Horizon MCP server (non-blocking)
+initMCP().catch(() => {});
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+  targetFps: 10,
+  useAlternateScreen: true,
+});
+
+// App handles auth restore, session loading, and sync startup internally
+new App(renderer);
+
+process.on("beforeExit", () => {
+  saveActiveSession().catch(() => {});
+  stopAutoSave();
+  closeMCP();
+});

package/src/keys/handler.ts

@@ -0,0 +1,198 @@
+import type { CliRenderer, KeyEvent } from "@opentui/core";
+
+export class KeyHandler {
+  private quitCallback: (() => void) | null = null;
+  private clearCallback: (() => void) | null = null;
+  private sessionsCallback: (() => void) | null = null;
+  private deploymentsCallback: (() => void) | null = null;
+  private scrollCallback: ((delta: number) => void) | null = null;
+  private cancelCallback: (() => void) | null = null;
+  private anyKeyCallback: (() => void) | null = null;
+  private modeCycleCallback: (() => void) | null = null;
+  private privacyCallback: (() => void) | null = null;
+  private metricsCallback: (() => void) | null = null;
+  private codePanelCallback: (() => void) | null = null;
+  private codeTabCallback: ((tab: number) => void) | null = null;
+  private tutorialNavCallback: ((dir: "left" | "right") => void) | null = null;
+  private settingsNavCallback: ((delta: number) => void) | null = null;
+  private tabNextCallback: (() => void) | null = null;
+  private tabPrevCallback: (() => void) | null = null;
+  private tabCloseCallback: (() => void) | null = null;
+  private tabNewCallback: (() => void) | null = null;
+  private acNavCallback: ((dir: "up" | "down" | "accept" | "dismiss") => void) | null = null;
+  acActive = false; // set by app when autocomplete is visible
+
+  // Panel navigation (shared by session & strategy panels)
+  private panelNavCallback: ((delta: number) => void) | null = null;
+  private panelSelectCallback: (() => void) | null = null;
+  private panelNewCallback: (() => void) | null = null;
+  private panelCloseCallback: (() => void) | null = null;
+  private panelActionCallback: ((key: string) => void) | null = null;
+
+  panelActive: "sessions" | "deployments" | null = null;
+  panelRenaming = false; // when true, let keys flow to the inline rename input
+  codePanelVisible = false; // set by app when code panel is visible
+
+  constructor(private renderer: CliRenderer) {
+    this.renderer.keyInput.on("keypress", (key: KeyEvent) => this.handle(key));
+  }
+
+  onQuit(cb: () => void): void { this.quitCallback = cb; }
+  onClear(cb: () => void): void { this.clearCallback = cb; }
+  onSessions(cb: () => void): void { this.sessionsCallback = cb; }
+  onDeployments(cb: () => void): void { this.deploymentsCallback = cb; }
+  onScroll(cb: (delta: number) => void): void { this.scrollCallback = cb; }
+  onCancel(cb: () => void): void { this.cancelCallback = cb; }
+  onAnyKey(cb: () => void): void { this.anyKeyCallback = cb; }
+  onModeCycle(cb: () => void): void { this.modeCycleCallback = cb; }
+  onPrivacy(cb: () => void): void { this.privacyCallback = cb; }
+  onMetrics(cb: () => void): void { this.metricsCallback = cb; }
+  onCodePanel(cb: () => void): void { this.codePanelCallback = cb; }
+  onCodeTab(cb: (tab: number) => void): void { this.codeTabCallback = cb; }
+  onTutorialNav(cb: (dir: "left" | "right") => void): void { this.tutorialNavCallback = cb; }
+  onSettingsNav(cb: (delta: number) => void): void { this.settingsNavCallback = cb; }
+  onTabNext(cb: () => void): void { this.tabNextCallback = cb; }
+  onTabPrev(cb: () => void): void { this.tabPrevCallback = cb; }
+  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; }
+
+  onPanelNav(cb: (delta: number) => void): void { this.panelNavCallback = cb; }
+  onPanelSelect(cb: () => void): void { this.panelSelectCallback = cb; }
+  onPanelNew(cb: () => void): void { this.panelNewCallback = cb; }
+  onPanelClose(cb: () => void): void { this.panelCloseCallback = cb; }
+  onPanelAction(cb: (key: string) => void): void { this.panelActionCallback = cb; }
+
+  private handle(key: KeyEvent): void {
+    this.anyKeyCallback?.();
+
+    // Ctrl+C — quit or cancel
+    if (key.ctrl && key.name === "c") {
+      if (this.panelActive) { this.panelCloseCallback?.(); return; }
+      this.cancelCallback?.();
+      return;
+    }
+
+    // Ctrl+E — sessions
+    if (key.ctrl && key.name === "e") {
+      this.sessionsCallback?.();
+      return;
+    }
+
+    // Ctrl+P — privacy toggle
+    if (key.ctrl && key.name === "p") {
+      this.privacyCallback?.();
+      return;
+    }
+
+    // Ctrl+T — metrics toggle
+    if (key.ctrl && key.name === "t") {
+      this.metricsCallback?.();
+      return;
+    }
+
+    // Tab navigation — Ctrl+J next, Ctrl+K prev
+    if (key.ctrl && key.name === "j") { this.tabNextCallback?.(); return; }
+    if (key.ctrl && key.name === "k") { this.tabPrevCallback?.(); return; }
+    // Ctrl+W — close tab
+    if (key.ctrl && key.name === "w") { this.tabCloseCallback?.(); return; }
+    // Ctrl+N — new tab
+    if (key.ctrl && key.name === "n") { this.tabNewCallback?.(); return; }
+
+    // Ctrl+G — code panel toggle
+    if (key.ctrl && key.name === "g") {
+      this.codePanelCallback?.();
+      return;
+    }
+
+    // Ctrl+1/2/3 — code panel tab switching (some terminals support this)
+    if (key.ctrl && (key.name === "1" || key.name === "2" || key.name === "3")) {
+      this.codeTabCallback?.(parseInt(key.name));
+      return;
+    }
+
+    // Tab key — cycle code panel tabs when code panel is visible
+    if (key.name === "tab" && !this.acActive && !this.panelActive && this.codePanelVisible) {
+      this.codeTabCallback?.(0); // 0 = cycle to next tab
+      return;
+    }
+
+    // Ctrl+D — deployments
+    if (key.ctrl && key.name === "d") {
+      this.deploymentsCallback?.();
+      return;
+    }
+
+    // Ctrl+L — next tab (was clear, now tab navigation)
+    if (key.ctrl && key.name === "l") {
+      if (this.panelActive === "sessions") { this.panelNewCallback?.(); return; }
+      this.tabNextCallback?.();
+      return;
+    }
+
+    // Ctrl+H — prev tab
+    if (key.ctrl && key.name === "h") {
+      this.tabPrevCallback?.();
+      return;
+    }
+
+    // Renaming mode — Escape cancels rename, everything else goes to the rename input
+    if (this.panelActive && this.panelRenaming) {
+      if (key.name === "escape") {
+        this.panelRenaming = false;
+        // Cancel rename — panelAction handler will sync state
+        this.panelActionCallback?.("rename-cancel");
+      }
+      return;
+    }
+
+    // Panel mode — route nav keys
+    if (this.panelActive) {
+      switch (key.name) {
+        case "j": case "down":
+          this.panelNavCallback?.(1); return;
+        case "k": case "up":
+          this.panelNavCallback?.(-1); return;
+        case "return":
+          this.panelSelectCallback?.(); return;
+        case "escape":
+          this.panelCloseCallback?.(); return;
+        case "n":
+          if (this.panelActive === "sessions") this.panelNewCallback?.();
+          return;
+        case "d": case "p": case "r": case "o":
+          if (this.panelActive === "sessions") this.panelActionCallback?.(key.name!);
+          if (this.panelActive === "deployments") this.panelActionCallback?.(key.name!);
+          return;
+        case "k":
+          if (this.panelActive === "deployments") this.panelActionCallback?.(key.name!);
+          return;
+      }
+      return;
+    }
+
+    // Autocomplete navigation (when dropdown is visible)
+    if (this.acActive) {
+      if (key.name === "up") { this.acNavCallback?.("up"); return; }
+      if (key.name === "down") { this.acNavCallback?.("down"); return; }
+      if (key.name === "tab") { this.acNavCallback?.("accept"); return; }
+      if (key.name === "escape") { this.acNavCallback?.("dismiss"); return; }
+    }
+
+    // Ctrl+R — cycle mode
+    if (key.ctrl && key.name === "r") {
+      this.modeCycleCallback?.();
+      return;
+    }
+
+    // Arrow keys for tutorial/settings panel navigation
+    if (key.name === "left") { this.tutorialNavCallback?.("left"); return; }
+    if (key.name === "right") { this.tutorialNavCallback?.("right"); return; }
+    if (key.name === "up") { this.settingsNavCallback?.(-1); return; }
+    if (key.name === "down") { this.settingsNavCallback?.(1); return; }
+
+    if (key.name === "pageup") { this.scrollCallback?.(-10); return; }
+    if (key.name === "pagedown") { this.scrollCallback?.(10); return; }
+    if (key.name === "escape") { this.cancelCallback?.(); return; }
+  }
+}

package/src/platform/auth.ts

@@ -0,0 +1,36 @@
+import { saveConfig, loadConfig, getApiKey } from "./config.ts";
+import { platform } from "./client.ts";
+
+export type AuthStatus = "authenticated" | "no_key" | "invalid_key";
+
+export async function checkAuth(): Promise<AuthStatus> {
+  const key = getApiKey();
+  if (!key) return "no_key";
+
+  try {
+    // Validate the key by making a lightweight request
+    await platform.listStrategies();
+    return "authenticated";
+  } catch (err: any) {
+    if (err?.status === 401 || err?.status === 403) return "invalid_key";
+    // Network error or server down — assume key is fine
+    return "authenticated";
+  }
+}
+
+export function login(apiKey: string): void {
+  const config = loadConfig();
+  config.api_key = apiKey;
+  saveConfig(config);
+  platform.setApiKey(apiKey);
+}
+
+export function logout(): void {
+  const config = loadConfig();
+  delete config.api_key;
+  saveConfig(config);
+}
+
+export function isAuthenticated(): boolean {
+  return getApiKey() !== null;
+}

package/src/platform/client.ts

@@ -0,0 +1,159 @@
+import { getApiKey, getPlatformUrl } from "./config.ts";
+import type {
+  PlatformStrategy,
+  PlatformDeployment,
+  PlatformMetrics,
+  PlatformLog,
+} from "./types.ts";
+
+class PlatformError extends Error {
+  constructor(public status: number, message: string) {
+    super(message);
+    this.name = "PlatformError";
+  }
+}
+
+class PlatformClient {
+  private baseUrl: string;
+  private apiKey: string | null;
+
+  constructor() {
+    this.baseUrl = getPlatformUrl();
+    this.apiKey = getApiKey();
+  }
+
+  get authenticated(): boolean {
+    return this.apiKey !== null;
+  }
+
+  setApiKey(key: string): void {
+    this.apiKey = key;
+  }
+
+  private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
+    // Re-read API key on every request (it may have been set after construction via /login)
+    const apiKey = this.apiKey || getApiKey();
+    if (!apiKey) throw new PlatformError(401, "Not authenticated. Set HORIZON_API_KEY or run horizon auth login.");
+
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      ...options,
+      signal: AbortSignal.timeout(15000),
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new PlatformError(res.status, `${res.status} ${res.statusText}: ${body}`);
+    }
+
+    return res.json() as Promise<T>;
+  }
+
+  // ── Strategies ──
+
+  async listStrategies(): Promise<PlatformStrategy[]> {
+    const res = await this.request<{ data: PlatformStrategy[] } | PlatformStrategy[]>("/api/v1/strategies");
+    return Array.isArray(res) ? res : (res as any).data ?? [];
+  }
+
+  async getStrategy(id: string): Promise<PlatformStrategy> {
+    return this.request<PlatformStrategy>(`/api/v1/strategies/${id}`);
+  }
+
+  async createStrategy(opts: {
+    name: string;
+    code: string;
+    params?: Record<string, unknown>;
+    risk_config?: Record<string, unknown>;
+  }): Promise<PlatformStrategy> {
+    return this.request<PlatformStrategy>("/api/v1/strategies", {
+      method: "POST",
+      body: JSON.stringify(opts),
+    });
+  }
+
+  // ── Deployments ──
+
+  async listDeployments(strategyId: string): Promise<PlatformDeployment[]> {
+    const res = await this.request<{ data: PlatformDeployment[] } | PlatformDeployment[]>(`/api/v1/strategies/${strategyId}/deployments`);
+    return Array.isArray(res) ? res : (res as any).data ?? [];
+  }
+
+  async deploy(strategyId: string, opts: {
+    credentialId: string;
+    dryRun: boolean;
+    targetMarkets?: Array<{ slug: string; tokenId: string }>;
+    deploymentMode?: "manual" | "scanner";
+  }): Promise<{ deployment: PlatformDeployment }> {
+    return this.request(`/api/v1/strategies/${strategyId}/deploy`, {
+      method: "POST",
+      body: JSON.stringify({
+        credential_id: opts.credentialId,
+        mode: opts.dryRun ? "paper" : "live",
+        markets: opts.targetMarkets ?? [],
+        deployment_mode: opts.deploymentMode ?? "manual",
+      }),
+    });
+  }
+
+  async stop(strategyId: string): Promise<{ success: boolean }> {
+    return this.request(`/api/v1/strategies/${strategyId}/stop`, {
+      method: "POST",
+    });
+  }
+
+  // ── Metrics ──
+
+  async getMetrics(strategyId: string, limit = 50): Promise<{
+    latest: PlatformMetrics | null;
+    history: PlatformMetrics[];
+  }> {
+    const res = await this.request<{ data: { latest: PlatformMetrics | null; history: PlatformMetrics[] } }>(
+      `/api/v1/strategies/${strategyId}/metrics?limit=${limit}`
+    );
+    return res.data;
+  }
+
+  // ── Logs ──
+
+  async getLogs(strategyId: string, limit = 100): Promise<PlatformLog[]> {
+    const res = await this.request<{ data: PlatformLog[] }>(
+      `/api/v1/strategies/${strategyId}/logs?limit=${limit}`
+    );
+    return res.data;
+  }
+
+  // ── Credentials ──
+
+  async listCredentials(): Promise<Array<{ id: string; label: string; exchange: string; wallet_address: string | null; created_at: string }>> {
+    const res = await this.request<{ data: any[] }>("/api/v1/credentials");
+    return res.data ?? [];
+  }
+
+  async createCredential(opts: { label: string; exchange: string; private_key: string; wallet_address?: string }): Promise<{ id: string; label: string; exchange: string }> {
+    const res = await this.request<{ data: any }>("/api/v1/credentials", {
+      method: "POST",
+      body: JSON.stringify(opts),
+    });
+    return res.data;
+  }
+
+  // ── Validate ──
+
+  async validateCode(code: string, strategyId?: string): Promise<{
+    valid: boolean;
+    errors: string[];
+  }> {
+    return this.request("/api/strategies/validate", {
+      method: "POST",
+      body: JSON.stringify({ code, strategyId }),
+    });
+  }
+}
+
+export const platform = new PlatformClient();