cerebro-code 0.1.0

package/dist/cli.js

@@ -0,0 +1,769 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { serve } from "@hono/node-server";
+
+// src/ingest/index.ts
+import { statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+
+// src/cost/pricing.ts
+var RATES = {
+  opus: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  sonnet: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  haiku: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 }
+};
+function classifyModel(name) {
+  const n = name.toLowerCase();
+  if (n.includes("haiku")) return "haiku";
+  if (n.includes("sonnet")) return "sonnet";
+  if (n.includes("opus")) return "opus";
+  return "opus";
+}
+function dominantClass(models) {
+  if (models.length === 0) return "opus";
+  const counts = { opus: 0, sonnet: 0, haiku: 0 };
+  for (const m of models) counts[classifyModel(m)] += 1;
+  let best = classifyModel(models[0]);
+  let bestCount = counts[best];
+  for (const cls of ["opus", "sonnet", "haiku"]) {
+    if (counts[cls] > bestCount) {
+      best = cls;
+      bestCount = counts[cls];
+    }
+  }
+  return best;
+}
+function computeCost(usage, models) {
+  const r = RATES[dominantClass(models)];
+  return (usage.input * r.input + usage.output * r.output + usage.cacheRead * r.cacheRead + usage.cacheWrite * r.cacheWrite) / 1e6;
+}
+
+// src/ingest/paths.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join } from "path";
+function projectsRoot() {
+  return join(homedir(), ".claude", "projects");
+}
+function decodeRepoKey(repoKey) {
+  const homePrefix = /^-Users-[^-]+-/;
+  let rest = repoKey;
+  if (homePrefix.test(repoKey)) {
+    rest = repoKey.replace(homePrefix, "");
+  } else if (rest.startsWith("-")) {
+    rest = rest.slice(1);
+  }
+  const readable = rest.replace(/-/g, "/").trim();
+  return readable.length > 0 ? readable : repoKey;
+}
+function listSessionFiles() {
+  const root = projectsRoot();
+  if (!existsSync(root)) return [];
+  const out = [];
+  let projectDirs;
+  try {
+    projectDirs = readdirSync(root);
+  } catch {
+    return [];
+  }
+  for (const repoKey of projectDirs) {
+    const repoDir = join(root, repoKey);
+    let entries;
+    try {
+      if (!statSync(repoDir).isDirectory()) continue;
+      entries = readdirSync(repoDir);
+    } catch {
+      continue;
+    }
+    const repo = decodeRepoKey(repoKey);
+    for (const name of entries) {
+      if (!name.endsWith(".jsonl")) continue;
+      const filePath = join(repoDir, name);
+      try {
+        if (!statSync(filePath).isFile()) continue;
+      } catch {
+        continue;
+      }
+      out.push({
+        id: basename(name, ".jsonl"),
+        repoKey,
+        repo,
+        filePath
+      });
+    }
+  }
+  return out;
+}
+function hasSubagents(repoKey, id) {
+  const dir = join(projectsRoot(), repoKey, id, "subagents");
+  try {
+    return statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/ingest/parser.ts
+import { readFileSync } from "fs";
+var TITLE_MAX = 80;
+var PREVIEW_MAX = 280;
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function collapse(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function truncate(s, max) {
+  const c = collapse(s);
+  return c.length > max ? c.slice(0, max - 1) + "\u2026" : c;
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item === "string") {
+      parts.push(item);
+      continue;
+    }
+    if (item && typeof item === "object") {
+      const it = item;
+      if (typeof it.text === "string") parts.push(it.text);
+    }
+  }
+  return parts.join(" ");
+}
+function toolUsePreview(block) {
+  const name = typeof block.name === "string" ? block.name : "tool";
+  const input = block.input;
+  if (input && typeof input === "object") {
+    const obj = input;
+    const hintKey = ["command", "file_path", "path", "query", "skill", "prompt", "pattern", "url"].find(
+      (k) => typeof obj[k] === "string" && obj[k].length > 0
+    );
+    if (hintKey) return truncate(`${name}: ${String(obj[hintKey])}`, PREVIEW_MAX);
+    const keys = Object.keys(obj);
+    if (keys.length > 0) return truncate(`${name}(${keys.join(", ")})`, PREVIEW_MAX);
+  }
+  return name;
+}
+function isRealUserMessage(rec) {
+  if (rec.isMeta === true || rec.isCompactSummary === true) return false;
+  const content = rec.message?.content;
+  if (typeof content === "string") return content.trim().length > 0;
+  if (Array.isArray(content)) {
+    return content.some(
+      (item) => item && typeof item === "object" && item.type === "text"
+    );
+  }
+  return false;
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function* sessionRecords(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch {
+    return;
+  }
+  let start = 0;
+  while (start <= raw.length) {
+    let nl = raw.indexOf("\n", start);
+    if (nl === -1) nl = raw.length;
+    const rec = parseLine(raw.slice(start, nl));
+    if (rec) yield rec;
+    start = nl + 1;
+  }
+}
+function parseSession(filePath) {
+  const usage = emptyUsage();
+  const modelSet = /* @__PURE__ */ new Set();
+  let firstTs = null;
+  let lastTs = null;
+  let userMsgs = 0;
+  let assistantMsgs = 0;
+  let gitBranch = null;
+  let cwd = null;
+  let aiTitle = null;
+  let firstUserText = null;
+  for (const rec of sessionRecords(filePath)) {
+    const ts = rec.timestamp;
+    if (typeof ts === "string" && ts.length > 0) {
+      if (firstTs === null || ts < firstTs) firstTs = ts;
+      if (lastTs === null || ts > lastTs) lastTs = ts;
+    }
+    if (typeof rec.gitBranch === "string" && rec.gitBranch.length > 0) {
+      gitBranch = rec.gitBranch;
+    }
+    if (typeof rec.cwd === "string" && rec.cwd.length > 0) {
+      cwd = rec.cwd;
+    }
+    if (typeof rec.aiTitle === "string" && rec.aiTitle.trim().length > 0) {
+      aiTitle = rec.aiTitle.trim();
+    }
+    const type = rec.type;
+    if (type === "user" && isRealUserMessage(rec)) {
+      userMsgs += 1;
+      if (firstUserText === null) {
+        const t = collapse(textFromContent(rec.message?.content));
+        if (t.length > 0) firstUserText = t;
+      }
+    } else if (type === "assistant") {
+      assistantMsgs += 1;
+      const model = rec.message?.model;
+      if (typeof model === "string" && model.length > 0) modelSet.add(model);
+      const u = rec.message?.usage;
+      if (u && typeof u === "object") {
+        const uu = u;
+        usage.input += num(uu.input_tokens);
+        usage.output += num(uu.output_tokens);
+        usage.cacheRead += num(uu.cache_read_input_tokens);
+        usage.cacheWrite += num(uu.cache_creation_input_tokens);
+      }
+    }
+  }
+  const title = aiTitle ?? (firstUserText ? truncate(firstUserText, TITLE_MAX) : "(untitled)");
+  return {
+    firstTs,
+    lastTs,
+    userMsgs,
+    assistantMsgs,
+    models: [...modelSet],
+    usage,
+    gitBranch,
+    cwd,
+    title
+  };
+}
+function appendTimelineItems(rec, items) {
+  const type = rec.type;
+  const ts = typeof rec.timestamp === "string" ? rec.timestamp : null;
+  const content = rec.message?.content;
+  if (type === "user") {
+    if (rec.isMeta === true) return;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type === "tool_result") {
+          items.push({
+            ts,
+            role: "user",
+            kind: "tool_result",
+            preview: truncate(textFromContent(b.content) || "(tool result)", PREVIEW_MAX)
+          });
+        } else if (b.type === "text" && typeof b.text === "string") {
+          items.push({ ts, role: "user", kind: "text", preview: truncate(b.text, PREVIEW_MAX) });
+        }
+      }
+    } else if (typeof content === "string" && content.trim().length > 0) {
+      items.push({ ts, role: "user", kind: "text", preview: truncate(content, PREVIEW_MAX) });
+    }
+  } else if (type === "assistant") {
+    if (!Array.isArray(content)) return;
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      const bt = b.type;
+      if (bt === "text" && typeof b.text === "string") {
+        if (b.text.trim().length === 0) continue;
+        items.push({ ts, role: "assistant", kind: "text", preview: truncate(b.text, PREVIEW_MAX) });
+      } else if (bt === "thinking" && typeof b.thinking === "string") {
+        if (b.thinking.trim().length === 0) continue;
+        items.push({ ts, role: "assistant", kind: "thinking", preview: truncate(b.thinking, PREVIEW_MAX) });
+      } else if (bt === "tool_use") {
+        items.push({ ts, role: "assistant", kind: "tool_use", preview: toolUsePreview(b) });
+      }
+    }
+  }
+}
+function buildTimeline(filePath) {
+  const items = [];
+  for (const rec of sessionRecords(filePath)) {
+    appendTimelineItems(rec, items);
+  }
+  return items;
+}
+
+// src/ingest/index.ts
+var MS_PER_MIN = 6e4;
+var MS_PER_DAY = 864e5;
+var UNCLOSED_DAYS = 2;
+var STALE_DAYS = 21;
+function daysAgo(mtimeMs, now) {
+  return Math.max(0, (now - mtimeMs) / MS_PER_DAY);
+}
+function durationMinutes(firstTs, lastTs) {
+  if (!firstTs || !lastTs) return 0;
+  const a = Date.parse(firstTs);
+  const b = Date.parse(lastTs);
+  if (Number.isNaN(a) || Number.isNaN(b)) return 0;
+  return Math.max(0, Math.round((b - a) / MS_PER_MIN));
+}
+function compareSessions(a, b, sort) {
+  switch (sort) {
+    case "cost":
+      return b.costUsd - a.costUsd;
+    case "duration":
+      return b.durationMin - a.durationMin;
+    case "messages":
+      return b.userMsgs + b.assistantMsgs - (a.userMsgs + a.assistantMsgs);
+    case "repo":
+      return a.repo.localeCompare(b.repo);
+    case "lastTs":
+    default: {
+      const at = a.lastTs ?? "";
+      const bt = b.lastTs ?? "";
+      return bt.localeCompare(at);
+    }
+  }
+}
+function repoFromCwd(cwd) {
+  if (!cwd) return null;
+  const home = homedir2();
+  if (cwd === home) return "~";
+  const rel = cwd.startsWith(home + "/") ? cwd.slice(home.length + 1) : cwd;
+  return rel.length > 0 ? rel : null;
+}
+async function buildIndex() {
+  const files = listSessionFiles();
+  const now = Date.now();
+  const metas = [];
+  for (const f of files) {
+    let mtimeMs;
+    try {
+      mtimeMs = statSync2(f.filePath).mtimeMs;
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = parseSession(f.filePath);
+    } catch {
+      continue;
+    }
+    const lastActiveDaysAgo = daysAgo(mtimeMs, now);
+    metas.push({
+      id: f.id,
+      repo: repoFromCwd(parsed.cwd) ?? f.repo,
+      repoKey: f.repoKey,
+      cwd: parsed.cwd,
+      title: parsed.title,
+      filePath: f.filePath,
+      models: parsed.models,
+      firstTs: parsed.firstTs,
+      lastTs: parsed.lastTs,
+      durationMin: durationMinutes(parsed.firstTs, parsed.lastTs),
+      userMsgs: parsed.userMsgs,
+      assistantMsgs: parsed.assistantMsgs,
+      usage: parsed.usage,
+      costUsd: computeCost(parsed.usage, parsed.models),
+      gitBranch: parsed.gitBranch,
+      hasSubagents: hasSubagents(f.repoKey, f.id),
+      unclosed: lastActiveDaysAgo < UNCLOSED_DAYS,
+      lastActiveDaysAgo: Math.round(lastActiveDaysAgo * 10) / 10,
+      activityType: null,
+      clusterId: null,
+      summary: null
+    });
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of metas) byId.set(m.id, m);
+  return {
+    overview() {
+      const byModel = {};
+      const repoSet = /* @__PURE__ */ new Set();
+      let totalCostUsd = 0;
+      let unclosed = 0;
+      let staleOver21d = 0;
+      let rangeStart = null;
+      let rangeEnd = null;
+      for (const m of metas) {
+        totalCostUsd += m.costUsd;
+        if (m.unclosed) unclosed += 1;
+        if (m.lastActiveDaysAgo > STALE_DAYS) staleOver21d += 1;
+        repoSet.add(m.repo);
+        for (const model of m.models) {
+          const cls = classifyModel(model);
+          byModel[cls] = (byModel[cls] ?? 0) + 1;
+        }
+        if (m.firstTs && (rangeStart === null || m.firstTs < rangeStart)) rangeStart = m.firstTs;
+        if (m.lastTs && (rangeEnd === null || m.lastTs > rangeEnd)) rangeEnd = m.lastTs;
+      }
+      return {
+        sessions: metas.length,
+        repos: repoSet.size,
+        unclosed,
+        staleOver21d,
+        totalCostUsd: Math.round(totalCostUsd * 100) / 100,
+        rangeStart,
+        rangeEnd,
+        byModel
+      };
+    },
+    list(f) {
+      let rows = metas;
+      if (f.repo) rows = rows.filter((m) => m.repo === f.repo);
+      if (f.type) rows = rows.filter((m) => m.activityType === f.type);
+      if (f.unclosed === true) rows = rows.filter((m) => m.unclosed);
+      if (f.q && f.q.trim().length > 0) {
+        const q = f.q.toLowerCase();
+        rows = rows.filter(
+          (m) => m.title.toLowerCase().includes(q) || m.repo.toLowerCase().includes(q)
+        );
+      }
+      const sorted = [...rows];
+      sorted.sort((a, b) => compareSessions(a, b, f.sort ?? "lastTs"));
+      return { sessions: sorted, total: sorted.length };
+    },
+    get(id) {
+      const meta = byId.get(id);
+      if (!meta) return null;
+      return { meta, timeline: buildTimeline(meta.filePath) };
+    },
+    repos() {
+      const set = /* @__PURE__ */ new Set();
+      for (const m of metas) set.add(m.repo);
+      return [...set].sort((a, b) => a.localeCompare(b));
+    }
+  };
+}
+
+// src/server.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { Hono } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+
+// src/privacy/redact.ts
+var RULES = [
+  {
+    kind: "private-key",
+    re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g
+  },
+  { kind: "aws-key", re: /AKIA[0-9A-Z]{16}/g },
+  { kind: "github-token", re: /gh[pousr]_[A-Za-z0-9]{20,}/g },
+  // sk-ant-... must be tried before bare sk-... but both share one kind.
+  { kind: "api-key", re: /sk-ant-[A-Za-z0-9_-]{20,}/g },
+  { kind: "api-key", re: /sk-[A-Za-z0-9]{20,}/g },
+  { kind: "google-key", re: /AIza[0-9A-Za-z_-]{35}/g },
+  { kind: "slack-token", re: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
+  {
+    kind: "jwt",
+    re: /eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g
+  },
+  { kind: "bearer", re: /Bearer\s+[A-Za-z0-9._-]{20,}/g },
+  // dotenv-style assignment: mask only the value (group 2), keep the key visible.
+  {
+    kind: "env-secret",
+    re: /([A-Za-z0-9_]*(?:SECRET|TOKEN|API[_-]?KEY|PASSWORD|PASSWD|PWD|CREDENTIAL|PRIVATE)[A-Za-z0-9_]*)(\s*=\s*)(['"]?)([^\s'"]+)\3/gi,
+    group: 4
+  }
+];
+function shannonEntropy(s) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const ch of s) freq.set(ch, (freq.get(ch) ?? 0) + 1);
+  let h = 0;
+  const len = s.length;
+  for (const count of freq.values()) {
+    const p = count / len;
+    h -= p * Math.log2(p);
+  }
+  return h;
+}
+var HIGH_ENTROPY_RE = /[A-Za-z0-9+/=_-]{32,}/g;
+function collect(text, rule, taken) {
+  rule.re.lastIndex = 0;
+  let m;
+  while ((m = rule.re.exec(text)) !== null) {
+    let start = m.index;
+    let end = m.index + m[0].length;
+    if (rule.group !== void 0) {
+      const captured = m[rule.group];
+      if (captured === void 0 || captured.length === 0) continue;
+      const rel = m[0].lastIndexOf(captured);
+      start = m.index + rel;
+      end = start + captured.length;
+    }
+    pushIfFree(taken, start, end, rule.kind);
+    if (m[0].length === 0) rule.re.lastIndex += 1;
+  }
+}
+function overlaps(taken, start, end) {
+  for (const s of taken) {
+    if (start < s.end && end > s.start) return true;
+  }
+  return false;
+}
+function pushIfFree(taken, start, end, kind) {
+  if (!overlaps(taken, start, end)) taken.push({ start, end, kind });
+}
+function redact(text) {
+  const taken = [];
+  for (const rule of RULES) collect(text, rule, taken);
+  HIGH_ENTROPY_RE.lastIndex = 0;
+  let hm;
+  while ((hm = HIGH_ENTROPY_RE.exec(text)) !== null) {
+    const token = hm[0];
+    const start = hm.index;
+    const end = start + token.length;
+    if (overlaps(taken, start, end)) continue;
+    if (shannonEntropy(token) > 4) {
+      taken.push({ start, end, kind: "high-entropy" });
+    }
+  }
+  if (taken.length === 0) {
+    return { text, redactions: 0, kinds: [] };
+  }
+  taken.sort((a, b) => a.start - b.start);
+  let out = "";
+  let cursor = 0;
+  const kindSet = /* @__PURE__ */ new Set();
+  for (const span of taken) {
+    out += text.slice(cursor, span.start);
+    out += `[REDACTED:${span.kind}]`;
+    kindSet.add(span.kind);
+    cursor = span.end;
+  }
+  out += text.slice(cursor);
+  return { text: out, redactions: taken.length, kinds: [...kindSet] };
+}
+
+// src/analyze/bridge.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var STDERR_SLICE = 500;
+async function runClaude(prompt, opts) {
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const args = [
+    "-p",
+    prompt,
+    "--output-format",
+    "json",
+    "--permission-mode",
+    "bypassPermissions",
+    "--max-turns",
+    "1"
+  ];
+  if (opts?.model) {
+    args.push("--model", opts.model);
+  }
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
+    const child = spawn("claude", args, { stdio: ["ignore", "pipe", "pipe"] });
+    timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish({ ok: false, text: "", error: "timeout" });
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        finish({
+          ok: false,
+          text: "",
+          error: "claude CLI not found \u2014 is Claude Code installed?"
+        });
+        return;
+      }
+      finish({ ok: false, text: "", error: err.message });
+    });
+    child.on("close", () => {
+      if (settled) return;
+      try {
+        const parsed = JSON.parse(stdout);
+        if (typeof parsed.result === "string") {
+          finish({ ok: true, text: parsed.result });
+          return;
+        }
+        finish({
+          ok: false,
+          text: "",
+          error: (stderr || stdout).slice(0, STDERR_SLICE)
+        });
+      } catch {
+        finish({
+          ok: false,
+          text: "",
+          error: (stderr || stdout).slice(0, STDERR_SLICE)
+        });
+      }
+    });
+  });
+}
+
+// src/analyze/summarize.ts
+var EXCERPT_CAP = 12e3;
+var PREVIEW_CHARS = 600;
+async function summarizeSession(meta, rawText) {
+  const { text: redacted, redactions } = redact(rawText);
+  const egressPreview = redacted.slice(0, PREVIEW_CHARS) + "\n[" + redactions + " secrets redacted before sending]";
+  const excerpt = redacted.slice(0, EXCERPT_CAP);
+  const prompt = [
+    "You are reviewing a Claude Code session transcript excerpt.",
+    "The session title is: " + meta.title,
+    "",
+    "Write a concise 2-3 sentence summary that covers:",
+    "1. What the session accomplished.",
+    "2. Whether the task looked resolved (or was left unfinished).",
+    "3. One suggested next step.",
+    "",
+    "Respond with the summary only \u2014 no preamble, no headings.",
+    "",
+    "Transcript excerpt (secrets already redacted):",
+    "---",
+    excerpt,
+    "---"
+  ].join("\n");
+  const result = await runClaude(prompt);
+  return {
+    summary: result.ok ? result.text : "Could not summarize: " + result.error,
+    egressPreview
+  };
+}
+
+// src/server.ts
+var MAX_FILE_CHARS = 2e5;
+var WEB_ROOT = fileURLToPath(new URL("./web", import.meta.url));
+var MISSING_BUILD_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Cerebro \u2014 build required</title>
+    <style>
+      body { background: #0a0f1e; color: #e7ecf6; font: 15px/1.6 ui-sans-serif, system-ui, sans-serif; margin: 0; display: grid; place-items: center; min-height: 100vh; }
+      .card { background: #121a2e; border: 1px solid #243049; border-radius: 12px; padding: 2rem 2.5rem; max-width: 28rem; }
+      h1 { margin: 0 0 .5rem; font-size: 1.25rem; color: #5891ff; }
+      code { background: #0a0f1e; border: 1px solid #243049; border-radius: 6px; padding: .15rem .4rem; font-family: ui-monospace, monospace; color: #5be1e6; }
+      p { color: #8a97b2; }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <h1>Web bundle not built</h1>
+      <p>The dashboard hasn't been compiled yet. Run <code>npm run build</code> and restart, then refresh this page.</p>
+      <p>The API is live at <code>/api/health</code>.</p>
+    </div>
+  </body>
+</html>`;
+function createServer(index) {
+  const app = new Hono();
+  app.get("/api/health", (c) => c.json({ ok: true }));
+  app.get("/api/overview", (c) => c.json(index.overview()));
+  app.get("/api/repos", (c) => c.json(index.repos()));
+  app.get("/api/sessions", (c) => {
+    const q = c.req.query("q");
+    const repo = c.req.query("repo");
+    const type = c.req.query("type");
+    const sort = c.req.query("sort");
+    const unclosedRaw = c.req.query("unclosed");
+    const filter = {};
+    if (q) filter.q = q;
+    if (repo) filter.repo = repo;
+    if (type) filter.type = type;
+    if (sort) filter.sort = sort;
+    if (unclosedRaw === "1" || unclosedRaw === "true") filter.unclosed = true;
+    return c.json(index.list(filter));
+  });
+  app.get("/api/sessions/:id", (c) => {
+    const detail = index.get(c.req.param("id"));
+    return detail ? c.json(detail) : c.json({ error: "not found" }, 404);
+  });
+  app.post("/api/sessions/:id/summarize", async (c) => {
+    const detail = index.get(c.req.param("id"));
+    if (!detail) return c.json({ error: "not found" }, 404);
+    let text = "";
+    try {
+      text = readFileSync2(detail.meta.filePath, "utf8").slice(0, MAX_FILE_CHARS);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: `could not read session file: ${message}` }, 500);
+    }
+    const result = await summarizeSession(detail.meta, text);
+    return c.json(result);
+  });
+  if (existsSync2(WEB_ROOT)) {
+    const spaFallback = serveStatic({ root: WEB_ROOT, path: "index.html" });
+    app.use(
+      "/*",
+      serveStatic({
+        root: WEB_ROOT,
+        onNotFound: (_path, c) => {
+          c.header("Cache-Control", "no-cache");
+        }
+      })
+    );
+    app.get("/*", spaFallback);
+  } else {
+    app.get("/*", (c) => c.html(MISSING_BUILD_HTML));
+  }
+  return app;
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const opts = { port: 4317, open: true };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--no-open") {
+      opts.open = false;
+    } else if (arg === "--port") {
+      const value = argv[++i];
+      const parsed = Number.parseInt(value ?? "", 10);
+      if (Number.isFinite(parsed) && parsed > 0) opts.port = parsed;
+    } else if (arg.startsWith("--port=")) {
+      const parsed = Number.parseInt(arg.slice("--port=".length), 10);
+      if (Number.isFinite(parsed) && parsed > 0) opts.port = parsed;
+    }
+  }
+  return opts;
+}
+async function main() {
+  const { port, open: shouldOpen } = parseArgs(process.argv.slice(2));
+  console.log("Cerebro \u2014 indexing your Claude Code sessions\u2026");
+  const index = await buildIndex();
+  const app = createServer(index);
+  const url = `http://localhost:${port}`;
+  serve({ fetch: app.fetch, port });
+  console.log(`\u2192 ${url}`);
+  if (shouldOpen) {
+    try {
+      const { default: open } = await import("open");
+      await open(url);
+    } catch {
+    }
+  }
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`
+Cerebro failed to start: ${message}`);
+  console.error("If this looks like a build problem, try: npm run build");
+  process.exitCode = 1;
+});