@rejacky/opencode-insights 0.1.0

package/dist/cli.js

@@ -0,0 +1,1360 @@
+#!/usr/bin/env node
+import {
+  resolveCapturePath
+} from "./chunk-G7E4J6OW.js";
+
+// src/cli.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import { pathToFileURL } from "url";
+import { promisify as promisify2 } from "util";
+
+// src/inspect.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function parseJsonlRecords(input) {
+  return input.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+function formatCaptureSummary(records) {
+  if (records.length === 0) return "No capture records found.";
+  const rows = records.map((record) => {
+    const at = new Date(record.timestamp).toISOString();
+    const providerModel = [record.providerID, record.modelID].filter(Boolean).join("/");
+    return [
+      at,
+      record.kind.padEnd(20),
+      (record.sessionID ?? "-").padEnd(16),
+      (record.messageID ?? "-").padEnd(16),
+      providerModel || "-"
+    ].join("  ");
+  });
+  return [
+    ["timestamp".padEnd(24), "kind".padEnd(20), "session".padEnd(16), "message".padEnd(16), "provider/model"].join("  "),
+    ...rows
+  ].join("\n");
+}
+async function readRecentCaptures(options = {}) {
+  const dbPath = resolveCapturePath(options);
+  const sqliteRecords = await readSqliteCaptures(dbPath, options.limit ?? 20);
+  if (sqliteRecords) return sqliteRecords;
+  const jsonlPath = dbPath.endsWith(".sqlite") ? `${dbPath}.jsonl` : dbPath;
+  if (!existsSync(jsonlPath)) return [];
+  const records = parseJsonlRecords(await readFile(jsonlPath, "utf8"));
+  return records.slice(-Math.max(1, options.limit ?? 20)).reverse();
+}
+function buildRequestHistory(records) {
+  const sessions = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  const responses = /* @__PURE__ */ new Map();
+  const responseByParent = /* @__PURE__ */ new Map();
+  const requests = [];
+  const getSession = (sessionID) => {
+    const existing = sessions.get(sessionID);
+    if (existing) return existing;
+    const created = { id: sessionID, messages: [], requests: [] };
+    sessions.set(sessionID, created);
+    return created;
+  };
+  const getMessage = (sessionID, messageID, role = "unknown") => {
+    const key = `${sessionID}:${messageID}`;
+    const existing = messages.get(key);
+    if (existing) {
+      if (existing.role === "unknown" && role !== "unknown") existing.role = role;
+      return existing;
+    }
+    const created = { id: messageID, sessionID, role, text: "", requests: [] };
+    messages.set(key, created);
+    getSession(sessionID).messages.push(created);
+    return created;
+  };
+  const getResponse = (sessionID, messageID, role = "assistant") => {
+    const key = `${sessionID}:${messageID}`;
+    const existing = responses.get(key);
+    if (existing) {
+      if (existing.role === "unknown" && role !== "unknown") existing.role = role;
+      return existing;
+    }
+    const created = { id: messageID, sessionID, role, text: "", reasoning: "", events: [] };
+    responses.set(key, created);
+    return created;
+  };
+  for (const record of records.slice().sort((a, b) => a.timestamp - b.timestamp)) {
+    if (record.sessionID) getSession(record.sessionID);
+    if (record.kind === "chat.message") {
+      const message = historyMessageFromChatMessage(record);
+      if (message) {
+        const existing = getMessage(message.sessionID, message.id, message.role);
+        existing.createdAt = message.createdAt ?? existing.createdAt;
+        existing.text = message.text || existing.text;
+      }
+    }
+    if (record.kind === "chat.params" || record.kind === "experimental.chat.messages.transform" || record.kind === "experimental.chat.system.transform") {
+      const request = historyRequestFromCapture(record);
+      if (!request.messageID && request.sessionID) {
+        request.messageID = latestUserMessageBefore(messages, request.sessionID, request.timestamp)?.id;
+      }
+      requests.push(request);
+      if (request.sessionID) {
+        getSession(request.sessionID).requests.push(request);
+        if (request.messageID) getMessage(request.sessionID, request.messageID, "user").requests.push(request);
+      }
+    }
+    if (record.kind === "chat.headers") {
+      attachHeadersToRequest(requests, record);
+    }
+    if (record.kind !== "event") continue;
+    const event = record.payload.event;
+    if (!isRecord(event)) continue;
+    const type = optionalString(event.type);
+    const properties = isRecord(event.properties) ? event.properties : {};
+    if (type === "session.updated" || type === "session.created") {
+      const info = isRecord(properties.info) ? properties.info : {};
+      const sessionID = optionalString(info.id) ?? optionalString(properties.sessionID);
+      if (!sessionID) continue;
+      const session = getSession(sessionID);
+      session.title = optionalString(info.title) ?? session.title;
+      session.updatedAt = numberFromPath(info.time, "updated") ?? session.updatedAt;
+      continue;
+    }
+    if (type === "message.updated") {
+      const info = isRecord(properties.info) ? properties.info : {};
+      const sessionID = optionalString(info.sessionID) ?? optionalString(properties.sessionID);
+      const messageID = optionalString(info.id);
+      if (!sessionID || !messageID) continue;
+      const role = optionalString(info.role) ?? "unknown";
+      if (role === "assistant") {
+        const response = getResponse(sessionID, messageID, role);
+        response.createdAt = numberFromPath(info.time, "created") ?? response.createdAt;
+        response.completedAt = numberFromPath(info.time, "completed") ?? response.completedAt;
+        response.parentID = optionalString(info.parentID) ?? response.parentID;
+        response.tokens = info.tokens ?? response.tokens;
+        response.cost = typeof info.cost === "number" ? info.cost : response.cost;
+        response.finish = optionalString(info.finish) ?? response.finish;
+        response.events.push(record.payload);
+        if (response.parentID) responseByParent.set(`${sessionID}:${response.parentID}`, response);
+        continue;
+      }
+      const message = getMessage(sessionID, messageID, role);
+      message.createdAt = numberFromPath(info.time, "created") ?? message.createdAt;
+      message.completedAt = numberFromPath(info.time, "completed") ?? message.completedAt;
+      continue;
+    }
+    if (type === "message.part.updated" || type === "message.part.delta") {
+      const part = isRecord(properties.part) ? properties.part : {};
+      const sessionID = optionalString(part.sessionID) ?? optionalString(properties.sessionID);
+      const messageID = optionalString(part.messageID) ?? optionalString(properties.messageID);
+      if (!sessionID || !messageID) continue;
+      const partType = optionalString(part.type);
+      const field = optionalString(properties.field);
+      const delta = optionalString(properties.delta);
+      const text = optionalString(part.text);
+      const reasonText = optionalString(part.text) ?? optionalString(part.markdown);
+      const targetResponse = responses.get(`${sessionID}:${messageID}`);
+      if (targetResponse) {
+        targetResponse.events.push(record.payload);
+        if (partType === "text" && text !== void 0) targetResponse.text = text;
+        if (partType === "reasoning" && reasonText !== void 0) targetResponse.reasoning = reasonText;
+        if (type === "message.part.delta" && field === "text" && delta !== void 0) targetResponse.text += delta;
+        continue;
+      }
+      if (partType !== "text" && partType !== "reasoning") continue;
+      if (text === void 0) continue;
+      const message = getMessage(sessionID, messageID);
+      message.text = text;
+    }
+  }
+  for (const session of sessions.values()) {
+    for (const message of session.messages) {
+      message.response = responseByParent.get(`${message.sessionID}:${message.id}`);
+      for (const request of message.requests) {
+        if (requestShouldOwnAssistantResponse(request)) request.response = message.response;
+      }
+    }
+    session.messages.sort((a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0));
+    session.requests.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  return {
+    sessions: [...sessions.values()].sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)),
+    requests: requests.sort((a, b) => b.timestamp - a.timestamp)
+  };
+}
+async function readSqliteCaptures(path, limit) {
+  if (!existsSync(path)) return void 0;
+  try {
+    const mod = await import("bun:sqlite").catch(() => void 0);
+    if (!mod) return readSqliteCapturesWithCli(path, limit);
+    const db = new mod.Database(path, { readonly: true });
+    try {
+      const rows = db.query(recentCaptureSql(Math.max(1, limit))).all();
+      return dedupeRows(rows).map(rowToCapture);
+    } finally {
+      db.close();
+    }
+  } catch {
+    return readSqliteCapturesWithCli(path, limit);
+  }
+}
+async function readSqliteCapturesWithCli(path, limit) {
+  if (!existsSync(path)) return void 0;
+  try {
+    const { stdout } = await execFileAsync("sqlite3", ["-json", path, recentCaptureSql(Math.max(1, Math.trunc(limit)))], {
+      maxBuffer: 128 * 1024 * 1024
+    });
+    if (!stdout.trim()) return [];
+    return dedupeRows(JSON.parse(stdout)).map(rowToCapture);
+  } catch {
+    return void 0;
+  }
+}
+function recentCaptureSql(limit) {
+  return `select id, kind, timestamp, session_id, message_id, provider_id, model_id, payload_json
+          from captures
+          where id in (
+            select id from captures order by timestamp desc limit ${limit}
+          )
+          or id in (
+            select id from captures
+            where kind in (
+              'chat.params',
+              'chat.message',
+              'experimental.chat.messages.transform',
+              'experimental.chat.system.transform'
+            )
+            order by timestamp desc
+            limit ${limit}
+          )
+          or id in (
+            select id from captures
+            where kind = 'event'
+              and json_extract(payload_json, '$.event.type') in ('message.updated', 'message.part.updated', 'message.part.delta')
+            order by timestamp desc
+            limit ${limit}
+          )
+          order by timestamp desc`;
+}
+function dedupeRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((row) => {
+    if (seen.has(row.id)) return false;
+    seen.add(row.id);
+    return true;
+  });
+}
+function rowToCapture(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    timestamp: row.timestamp,
+    sessionID: row.session_id ?? void 0,
+    messageID: row.message_id ?? void 0,
+    providerID: row.provider_id ?? void 0,
+    modelID: row.model_id ?? void 0,
+    payload: JSON.parse(row.payload_json)
+  };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function historyRequestFromCapture(record) {
+  const input = isRecord(record.payload.input) ? record.payload.input : {};
+  const agent = agentFromCapture(record, input);
+  return {
+    id: record.id,
+    sessionID: record.sessionID,
+    messageID: messageIDForCapture(record, input),
+    timestamp: record.timestamp,
+    agent,
+    purpose: purposeFromAgent(agent),
+    providerID: record.providerID,
+    modelID: record.modelID,
+    summary: summarizePayload(record.payload),
+    payload: record.payload
+  };
+}
+function requestShouldOwnAssistantResponse(request) {
+  return request.agent !== "title";
+}
+function purposeFromAgent(agent) {
+  if (agent === "title") return "Generate or update the session title. This is not the assistant reply shown in the conversation.";
+  if (agent === "build") return "Generate the assistant response for the user message.";
+  if (agent === "messages.transform") return "Capture the final conversation messages OpenCode prepared before model execution.";
+  if (agent === "system.transform") return "Capture the system prompt strings OpenCode prepared before model execution.";
+  if (agent) return `Run the ${agent} agent for this message.`;
+  return "Run an OpenCode model request for this message.";
+}
+function agentFromCapture(record, input) {
+  if (record.kind === "experimental.chat.messages.transform") return "messages.transform";
+  if (record.kind === "experimental.chat.system.transform") return "system.transform";
+  return optionalString(input.agent);
+}
+function messageIDForCapture(record, input) {
+  if (record.kind === "experimental.chat.messages.transform") {
+    return latestUserMessageIDFromTransform(record.payload.output) ?? record.messageID;
+  }
+  return record.messageID ?? messageIDFromPayload(input.message);
+}
+function latestUserMessageIDFromTransform(output) {
+  if (!isRecord(output) || !Array.isArray(output.messages)) return void 0;
+  for (const message of output.messages.slice().reverse()) {
+    if (!isRecord(message) || !isRecord(message.info)) continue;
+    if (optionalString(message.info.role) === "user") return optionalString(message.info.id);
+  }
+  return void 0;
+}
+function latestUserMessageBefore(messages, sessionID, timestamp) {
+  let latest;
+  for (const message of messages.values()) {
+    if (message.sessionID !== sessionID || message.role !== "user") continue;
+    if ((message.createdAt ?? Number.NEGATIVE_INFINITY) > timestamp) continue;
+    if (!latest || (message.createdAt ?? 0) > (latest.createdAt ?? 0)) latest = message;
+  }
+  return latest;
+}
+function summarizePayload(payload) {
+  const input = isRecord(payload.input) ? payload.input : {};
+  const message = isRecord(input.message) ? input.message : {};
+  const text = textFromMessagePayload(message) ?? findFirstString(input, ["prompt", "input"]);
+  if (!text) return "LLM request";
+  return text.replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function historyMessageFromChatMessage(record) {
+  const output = isRecord(record.payload.output) ? record.payload.output : {};
+  const message = isRecord(output.message) ? output.message : {};
+  const sessionID = record.sessionID ?? optionalString(message.sessionID);
+  const messageID = optionalString(message.id);
+  if (!sessionID || !messageID) return void 0;
+  return {
+    id: messageID,
+    sessionID,
+    role: optionalString(message.role) ?? "user",
+    createdAt: numberFromPath(message.time, "created") ?? record.timestamp,
+    completedAt: numberFromPath(message.time, "completed"),
+    text: textFromChatMessageOutput(output),
+    requests: []
+  };
+}
+function attachHeadersToRequest(requests, record) {
+  const input = isRecord(record.payload.input) ? record.payload.input : {};
+  const agent = optionalString(input.agent);
+  const messageID = record.messageID ?? messageIDFromPayload(input.message);
+  const match = requests.slice().reverse().find((request) => {
+    return request.sessionID === record.sessionID && request.messageID === messageID && request.agent === agent && request.providerID === record.providerID && request.modelID === record.modelID && request.timestamp <= record.timestamp && !request.headers;
+  });
+  if (!match) return;
+  match.headers = { id: record.id, timestamp: record.timestamp, payload: record.payload };
+}
+function textFromChatMessageOutput(output) {
+  const parts = Array.isArray(output.parts) ? output.parts : [];
+  return parts.map((part) => isRecord(part) ? optionalString(part.text) ?? optionalString(part.content) : void 0).filter((text) => !!text).join("\n");
+}
+function textFromMessagePayload(message) {
+  const direct = findFirstString(message, ["text", "content"]);
+  if (direct) return direct;
+  const parts = Array.isArray(message.parts) ? message.parts : [];
+  const joined = parts.map((part) => isRecord(part) ? optionalString(part.text) ?? optionalString(part.content) : void 0).filter((text) => !!text).join("\n");
+  return joined || void 0;
+}
+function messageIDFromPayload(message) {
+  return isRecord(message) ? optionalString(message.id) ?? optionalString(message.messageID) ?? optionalString(message.messageId) : void 0;
+}
+function findFirstString(value, keys) {
+  for (const key of keys) {
+    const item = value[key];
+    if (typeof item === "string" && item.length > 0) return item;
+  }
+  return void 0;
+}
+function numberFromPath(value, key) {
+  if (!isRecord(value)) return void 0;
+  const item = value[key];
+  return typeof item === "number" && Number.isFinite(item) ? item : void 0;
+}
+
+// src/viewer.ts
+import { createServer } from "http";
+async function serveViewer(options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 8765;
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url ?? "/", `http://${host}:${port}`);
+    if (url.pathname === "/api/history") {
+      const history = await readHistory(options);
+      sendJson(response, history);
+      return;
+    }
+    if (url.pathname === "/" || url.pathname === "/index.html") {
+      sendHtml(response, renderViewerHtml(resolveCapturePath(options)));
+      return;
+    }
+    response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+    response.end("Not found");
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  return {
+    url: `http://${host}:${port}`,
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+async function readHistory(options = {}) {
+  const readOptions = {
+    dataDir: options.dataDir,
+    dbPath: options.dbPath,
+    limit: options.limit ?? 5e3
+  };
+  const records = await readRecentCaptures(readOptions);
+  return buildRequestHistory(records);
+}
+function sendJson(response, value) {
+  response.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+  response.end(JSON.stringify(value));
+}
+function sendHtml(response, html) {
+  response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+  response.end(html);
+}
+function renderViewerHtml(dbPath) {
+  const escapedDbPath = escapeHtml(dbPath);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>OpenCode Insights</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --bg: #101214;
+      --panel: #171a1d;
+      --panel-2: #20242a;
+      --line: #30363d;
+      --text: #eef2f5;
+      --muted: #9aa6b2;
+      --accent: #7dd3fc;
+      --ok: #86efac;
+      --warn: #fbbf24;
+      --bad: #fca5a5;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      background: var(--bg);
+      color: var(--text);
+      font: 13px/1.45 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+    }
+    header {
+      height: 56px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      padding: 0 18px;
+      border-bottom: 1px solid var(--line);
+      background: #0d0f11;
+    }
+    h1 { margin: 0; font-size: 15px; font-weight: 700; }
+    main {
+      display: grid;
+      grid-template-columns: 300px minmax(340px, 0.95fr) minmax(460px, 1.25fr);
+      height: calc(100vh - 56px);
+      min-height: 540px;
+    }
+    section { min-width: 0; overflow: auto; border-right: 1px solid var(--line); }
+    section:last-child { border-right: 0; }
+    .toolbar {
+      position: sticky;
+      top: 0;
+      display: flex;
+      gap: 8px;
+      padding: 10px;
+      background: var(--panel);
+      border-bottom: 1px solid var(--line);
+      z-index: 2;
+    }
+    input {
+      width: 100%;
+      border: 1px solid var(--line);
+      background: #0d0f11;
+      color: var(--text);
+      border-radius: 6px;
+      padding: 8px 10px;
+      font: inherit;
+    }
+    button {
+      border: 1px solid var(--line);
+      background: var(--panel-2);
+      color: var(--text);
+      border-radius: 6px;
+      padding: 8px 10px;
+      font: inherit;
+      cursor: pointer;
+    }
+    button:hover { border-color: var(--accent); }
+    button:disabled { cursor: wait; opacity: 0.6; }
+    .item {
+      width: 100%;
+      display: block;
+      border: 0;
+      border-bottom: 1px solid var(--line);
+      border-radius: 0;
+      background: transparent;
+      text-align: left;
+      padding: 11px 12px;
+    }
+    .item:hover, .item.active { background: var(--panel-2); }
+    .request-item { padding-left: 28px; }
+    .title { color: var(--text); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+    .meta {
+      margin-top: 4px;
+      color: var(--muted);
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .muted { color: var(--muted); }
+    .pill {
+      color: #0d0f11;
+      background: var(--accent);
+      border-radius: 999px;
+      padding: 1px 6px;
+      font-weight: 700;
+    }
+    .pill.msg { background: var(--ok); }
+    .pill.missing { background: var(--warn); }
+    .detail { padding: 14px; }
+    .tabs { display: flex; gap: 6px; margin-bottom: 10px; flex-wrap: wrap; }
+    .tabs button.active { border-color: var(--accent); color: var(--accent); }
+    .tabs .json-control { display: none; margin-left: auto; }
+    .tabs .json-control + .json-control { margin-left: 0; }
+    .tabs.json-mode .json-control { display: inline-block; }
+    .panel, pre {
+      margin: 0;
+      padding: 14px;
+      overflow: auto;
+      white-space: pre-wrap;
+      word-break: break-word;
+      background: #0b0d0f;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      min-height: 220px;
+    }
+    .empty { color: var(--muted); padding: 16px; }
+    .status { color: var(--muted); min-width: 220px; text-align: right; }
+    .status.error { color: var(--bad); }
+    .kv { display: grid; grid-template-columns: 140px minmax(0, 1fr); gap: 8px 12px; }
+    .kv div:nth-child(odd) { color: var(--muted); }
+    .explain {
+      margin: 0 0 12px;
+      color: var(--muted);
+    }
+    .subhead {
+      margin: 16px 0 8px;
+      color: var(--text);
+      font-weight: 700;
+    }
+    .json-tree { font-size: 12px; line-height: 1.55; }
+    .json-tree details { margin-left: 14px; }
+    .json-tree summary { cursor: pointer; color: var(--accent); }
+    .json-tree .leaf { margin-left: 14px; }
+    .json-key { color: #bae6fd; }
+    .json-string { color: #bbf7d0; }
+    .json-number { color: #fde68a; }
+    .json-boolean { color: #f0abfc; }
+    .json-null { color: var(--muted); }
+    @media (max-width: 1000px) {
+      main { grid-template-columns: 1fr; height: auto; }
+      section { min-height: 360px; border-right: 0; border-bottom: 1px solid var(--line); }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>OpenCode Insights</h1>
+    <div>
+      <div class="meta">${escapedDbPath}</div>
+      <div id="status" class="status">Loading history...</div>
+    </div>
+  </header>
+  <main>
+    <section>
+      <div class="toolbar"><input id="session-filter" placeholder="Filter sessions"></div>
+      <div id="sessions"></div>
+    </section>
+    <section>
+      <div class="toolbar"><input id="timeline-filter" placeholder="Filter messages and hooks"></div>
+      <div id="timeline"></div>
+    </section>
+    <section>
+      <div class="toolbar">
+        <button id="copy">Copy JSON</button>
+        <button id="refresh">Refresh</button>
+      </div>
+      <div class="detail">
+        <div class="tabs">
+          <button data-tab="summary" class="active">Summary</button>
+          <button data-tab="request">Request</button>
+          <button data-tab="response">Response</button>
+          <button data-tab="raw">Raw</button>
+          <button id="expand-json" class="json-control">Expand All</button>
+          <button id="collapse-json" class="json-control">Collapse All</button>
+        </div>
+        <div id="detail" class="panel">Select a message or request.</div>
+      </div>
+    </section>
+  </main>
+  <script>
+    const state = {
+      history: { sessions: [], requests: [] },
+      sessionID: null,
+      messageID: null,
+      requestID: null,
+      tab: "summary",
+      loading: true,
+      error: null,
+      loadedMs: 0
+    };
+
+    const qs = (id) => document.getElementById(id);
+    const fmt = (ms) => ms ? new Date(ms).toLocaleString() : "-";
+    const short = (value, size = 90) => {
+      const text = String(value || "").replace(/\\s+/g, " ").trim();
+      return text.length > size ? text.slice(0, size - 1) + "..." : text;
+    };
+
+    async function load() {
+      state.loading = true;
+      state.error = null;
+      renderStatus();
+      qs("sessions").innerHTML = '<div class="empty">Loading sessions and hooks...</div>';
+      qs("timeline").innerHTML = '<div class="empty">Waiting for history data...</div>';
+      try {
+        const started = performance.now();
+        const res = await fetch("/api/history");
+        if (!res.ok) throw new Error("HTTP " + res.status + " " + res.statusText);
+        state.history = await res.json();
+        state.loadedMs = Math.round(performance.now() - started);
+        if (!state.sessionID && state.history.sessions[0]) state.sessionID = state.history.sessions[0].id;
+        if (state.sessionID && !state.history.sessions.some((session) => session.id === state.sessionID)) {
+          state.sessionID = state.history.sessions[0]?.id || null;
+          state.messageID = null;
+          state.requestID = null;
+        }
+        const session = selectedSession();
+        if (session && !state.messageID && session.messages[0]) state.messageID = session.messages[0].id;
+      } catch (error) {
+        state.error = error instanceof Error ? error.message : String(error);
+      } finally {
+        state.loading = false;
+        render();
+      }
+    }
+
+    function selectedSession() {
+      return state.history.sessions.find((session) => session.id === state.sessionID);
+    }
+
+    function selectedMessage() {
+      const session = selectedSession();
+      return session?.messages.find((message) => message.id === state.messageID) || null;
+    }
+
+    function selectedRequest() {
+      const message = selectedMessage();
+      return message?.requests.find((request) => request.id === state.requestID)
+        || state.history.requests.find((request) => request.id === state.requestID)
+        || null;
+    }
+
+    function activeContext() {
+      const message = selectedMessage();
+      const request = selectedRequest();
+      return { message, request: request || message?.requests[0] || null };
+    }
+
+    function render() {
+      renderStatus();
+      if (state.error) {
+        qs("sessions").innerHTML = '<div class="empty">Failed to load history.</div>';
+        qs("timeline").innerHTML = '<div class="empty">' + escapeHtml(state.error) + '</div>';
+        qs("detail").textContent = "Refresh after checking the viewer server.";
+        return;
+      }
+      renderSessions();
+      renderTimeline();
+      renderDetail();
+    }
+
+    function renderStatus() {
+      const status = qs("status");
+      status.classList.toggle("error", Boolean(state.error));
+      if (state.error) status.textContent = "Load failed";
+      else if (state.loading) status.textContent = "Loading history...";
+      else status.textContent = state.history.sessions.length + " sessions \xB7 " + state.history.requests.length + " hooks \xB7 " + state.loadedMs + "ms";
+      qs("refresh").disabled = state.loading;
+      qs("refresh").textContent = state.loading ? "Loading..." : "Refresh";
+    }
+
+    function renderSessions() {
+      const filter = qs("session-filter").value.toLowerCase();
+      const sessions = state.history.sessions.filter((session) =>
+        [session.id, session.title].filter(Boolean).join(" ").toLowerCase().includes(filter)
+      );
+      qs("sessions").innerHTML = sessions.length ? sessions.map((session) =>
+        '<button class="item ' + (session.id === state.sessionID ? "active" : "") + '" data-session="' + escapeAttr(session.id) + '">' +
+          '<div class="title">' + escapeHtml(session.title || session.id) + '</div>' +
+          '<div class="meta">' + session.messages.length + ' messages \xB7 ' + session.requests.length + ' hooks \xB7 ' + fmt(session.updatedAt) + '</div>' +
+        '</button>'
+      ).join("") : '<div class="empty">No sessions found.</div>';
+      for (const item of document.querySelectorAll("[data-session]")) {
+        item.onclick = () => {
+          state.sessionID = item.dataset.session;
+          const session = selectedSession();
+          state.messageID = session?.messages[0]?.id || null;
+          state.requestID = null;
+          render();
+        };
+      }
+    }
+
+    function renderTimeline() {
+      const session = selectedSession();
+      if (!session) {
+        qs("timeline").innerHTML = '<div class="empty">Select a session.</div>';
+        return;
+      }
+      const filter = qs("timeline-filter").value.toLowerCase();
+      const blocks = [];
+      for (const message of session.messages) {
+        const searchable = JSON.stringify(message).toLowerCase();
+        if (filter && !searchable.includes(filter)) continue;
+        blocks.push(
+          '<button class="item ' + (message.id === state.messageID && !state.requestID ? "active" : "") + '" data-message="' + escapeAttr(message.id) + '">' +
+            '<div class="title"><span class="pill msg">MSG</span> ' + escapeHtml(message.role) + ' \xB7 ' + escapeHtml(short(message.text || message.id, 110)) + '</div>' +
+            '<div class="meta">' + message.requests.length + ' hooks \xB7 response ' + (message.response?.text ? "captured" : "missing") + ' \xB7 ' + fmt(message.createdAt) + '</div>' +
+          '</button>'
+        );
+        for (const request of message.requests) {
+          blocks.push(
+            '<button class="item request-item ' + (request.id === state.requestID ? "active" : "") + '" data-message="' + escapeAttr(message.id) + '" data-request="' + escapeAttr(request.id) + '">' +
+              '<div class="title"><span class="pill">HOOK</span> ' + escapeHtml(request.agent || "agent") + ' \xB7 ' + escapeHtml([request.providerID, request.modelID].filter(Boolean).join("/") || "-") + '</div>' +
+              '<div class="meta">' + escapeHtml(short(request.summary, 120)) + ' \xB7 ' + (request.headers ? "headers" : "no headers") + ' \xB7 ' + (request.response?.text ? "response" : "no response") + '</div>' +
+            '</button>'
+          );
+        }
+      }
+      qs("timeline").innerHTML = blocks.length ? blocks.join("") : '<div class="empty">No messages or hooks found.</div>';
+      for (const item of document.querySelectorAll("[data-message]")) {
+        item.onclick = () => {
+          state.messageID = item.dataset.message;
+          state.requestID = item.dataset.request || null;
+          render();
+        };
+      }
+    }
+
+    function renderDetail() {
+      const { message, request } = activeContext();
+      document.querySelector(".tabs").classList.toggle("json-mode", state.tab !== "summary");
+      if (!message && !request) {
+        qs("detail").textContent = "Select a message or request.";
+        return;
+      }
+
+      if (state.tab === "summary") {
+        const response = request?.response || message?.response;
+        qs("detail").innerHTML = '<div class="kv">' +
+          kv("Message", message?.id || "-") +
+          kv("Message text", message?.text || "(no user text captured)") +
+          kv("Selected hook", request?.id || "-") +
+          kv("Agent", request?.agent || "-") +
+          kv("Purpose", request?.purpose || "-") +
+          kv("Provider/model", [request?.providerID, request?.modelID].filter(Boolean).join("/") || "-") +
+          kv("Request time", fmt(request?.timestamp)) +
+          kv("Headers hook", request?.headers ? "captured" : "empty / not captured") +
+          kv("Direct response", request?.response?.text ? "captured" : request ? "none for this hook" : "-") +
+          kv("Message response", response?.id || "-") +
+          kv("Response text", response?.text || "(no assistant text captured)") +
+          kv("Finish", response?.finish || "-") +
+          kv("Cost", response?.cost === undefined ? "-" : String(response.cost)) +
+        '</div>';
+        return;
+      }
+
+      if (state.tab === "request") {
+        renderRequestDetail(request);
+        return;
+      }
+
+      if (state.tab === "response") {
+        const response = state.requestID ? request?.response : message?.response;
+        renderJson(response || {
+          status: "missing",
+          note: request?.agent === "title"
+            ? "The title request does not produce the assistant reply. Select the build request or MSG row to inspect the conversation response."
+            : "No assistant response events were captured for this message yet."
+        });
+        return;
+      }
+
+      renderJson({ message, request });
+    }
+
+    function kv(key, value) {
+      return '<div>' + escapeHtml(key) + '</div><div>' + escapeHtml(value) + '</div>';
+    }
+
+    function renderJson(value) {
+      qs("detail").innerHTML = '<div class="json-tree">' + jsonNode(value, "root", true) + '</div>';
+    }
+
+    function renderRequestDetail(request) {
+      if (!request) {
+        renderJson({ status: "missing", note: "Select a hook row to inspect hook details." });
+        return;
+      }
+      const payload = request.payload || {};
+      const hookInput = payload.input || {};
+      const hookOutput = payload.output || {};
+      const headerOutput = request.headers?.payload?.output || null;
+      qs("detail").innerHTML =
+        '<p class="explain">These are OpenCode plugin hook values, not a raw HTTP request. <b>Hook input</b> is the context OpenCode passed to the plugin before the model call. <b>Hook output</b> is the model settings returned by the plugin hook. <b>Headers output</b> is the provider headers hook result.</p>' +
+        '<div class="kv">' +
+          kv("Hook id", request.id) +
+          kv("Agent", request.agent || "-") +
+          kv("Purpose", request.purpose || "-") +
+          kv("Provider/model", [request.providerID, request.modelID].filter(Boolean).join("/") || "-") +
+          kv("User message id", request.messageID || "-") +
+          kv("Time", fmt(request.timestamp)) +
+        '</div>' +
+        '<div class="subhead">Hook Input: context OpenCode supplied</div>' +
+        '<div class="json-tree">' + jsonNode(summarizeHookInput(hookInput), "hookInput", true) + '</div>' +
+        '<div class="subhead">Hook Output: model-call settings</div>' +
+        '<div class="json-tree">' + jsonNode(hookOutput, "hookOutput", true) + '</div>' +
+        '<div class="subhead">Headers Hook Output</div>' +
+        '<div class="json-tree">' + jsonNode(headerOutput, "headersOutput", true) + '</div>' +
+        '<div class="subhead">Raw Full-Fidelity Payload</div>' +
+        '<div class="json-tree">' + jsonNode({ params: request.payload, headers: request.headers?.payload || null }, "raw", false) + '</div>';
+    }
+
+    function summarizeHookInput(input) {
+      return {
+        sessionID: input?.sessionID,
+        agent: input?.agent,
+        model: input?.model ? {
+          id: input.model.id,
+          providerID: input.model.providerID,
+          name: input.model.name,
+          family: input.model.family,
+          api: input.model.api,
+          limit: input.model.limit,
+          capabilities: input.model.capabilities,
+          cost: input.model.cost
+        } : null,
+        provider: input?.provider ? {
+          id: input.provider.id,
+          source: input.provider.source,
+          name: input.provider.name,
+          env: input.provider.env,
+          options: input.provider.options,
+          key: input.provider.key
+        } : null,
+        message: input?.message || null
+      };
+    }
+
+    function setJsonExpanded(expanded) {
+      for (const node of qs("detail").querySelectorAll("details")) node.open = expanded;
+    }
+
+    function jsonNode(value, key, open) {
+      if (value === null) return leaf(key, '<span class="json-null">null</span>');
+      if (Array.isArray(value)) {
+        const children = value.map((item, index) => jsonNode(item, String(index), false)).join("");
+        return '<details ' + (open ? "open" : "") + '><summary>' + label(key) + ' Array(' + value.length + ')</summary>' + children + '</details>';
+      }
+      if (typeof value === "object") {
+        const keys = Object.keys(value);
+        const children = keys.map((childKey) => jsonNode(value[childKey], childKey, false)).join("");
+        return '<details ' + (open ? "open" : "") + '><summary>' + label(key) + ' Object(' + keys.length + ')</summary>' + children + '</details>';
+      }
+      if (typeof value === "string") return leaf(key, '<span class="json-string">' + escapeHtml(JSON.stringify(value)) + '</span>');
+      if (typeof value === "number") return leaf(key, '<span class="json-number">' + value + '</span>');
+      if (typeof value === "boolean") return leaf(key, '<span class="json-boolean">' + value + '</span>');
+      return leaf(key, escapeHtml(String(value)));
+    }
+
+    function label(key) {
+      return '<span class="json-key">' + escapeHtml(key) + '</span>: ';
+    }
+
+    function leaf(key, value) {
+      return '<div class="leaf">' + label(key) + value + '</div>';
+    }
+
+    function escapeHtml(value) {
+      return String(value ?? "").replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[char]));
+    }
+
+    function escapeAttr(value) {
+      return escapeHtml(value).replace(new RegExp(String.fromCharCode(96), "g"), "&#96;");
+    }
+
+    qs("session-filter").oninput = render;
+    qs("timeline-filter").oninput = render;
+    qs("refresh").onclick = load;
+    qs("expand-json").onclick = () => setJsonExpanded(true);
+    qs("collapse-json").onclick = () => setJsonExpanded(false);
+    qs("copy").onclick = async () => {
+      const { message, request } = activeContext();
+      const value = state.tab === "request" ? { params: request?.payload || null, headers: request?.headers?.payload || null }
+        : state.tab === "response" ? (request?.response || message?.response || null)
+        : state.tab === "raw" ? { message, request }
+        : { messageID: message?.id, requestID: request?.id };
+      await navigator.clipboard.writeText(JSON.stringify(value, null, 2));
+    };
+    for (const tab of document.querySelectorAll("[data-tab]")) {
+      tab.onclick = () => {
+        state.tab = tab.dataset.tab;
+        for (const item of document.querySelectorAll("[data-tab]")) item.classList.toggle("active", item === tab);
+        renderDetail();
+      };
+    }
+    load();
+  </script>
+</body>
+</html>`;
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => {
+    if (char === "&") return "&amp;";
+    if (char === "<") return "&lt;";
+    if (char === ">") return "&gt;";
+    if (char === '"') return "&quot;";
+    return "&#39;";
+  });
+}
+
+// src/cli.ts
+var execFileAsync2 = promisify2(execFile2);
+var DEFAULT_RECENT_LIMIT = 20;
+var DEFAULT_HISTORY_LIMIT = 5e3;
+var SERVER_PLUGIN_SPEC = "@rejacky/opencode-insights";
+var TUI_PLUGIN_SPEC = "@rejacky/opencode-insights/tui";
+async function main(argv) {
+  const command = argv[2] ?? "recent";
+  const options = parseOptions(argv.slice(3));
+  const positionals = parsePositionals(argv.slice(3));
+  if (command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(`${usage()}
+`);
+    return;
+  }
+  if (command === "recent") {
+    const records = await readRecentCaptures({ ...options, limit: options.limitProvided ? options.limit : DEFAULT_RECENT_LIMIT });
+    process.stdout.write(options.json ? `${JSON.stringify(records, null, 2)}
+` : `${formatCaptureSummary(records)}
+`);
+    return;
+  }
+  if (command === "history") {
+    const records = await readRecentCaptures(historyReadOptions(options));
+    const history = buildRequestHistory(records);
+    process.stdout.write(`${JSON.stringify(history, null, 2)}
+`);
+    return;
+  }
+  if (command === "sessions") {
+    const records = await readRecentCaptures(historyReadOptions(options));
+    const history = buildRequestHistory(records);
+    const rows = summarizeSessions(history.sessions);
+    process.stdout.write(options.json ? `${JSON.stringify(rows, null, 2)}
+` : `${formatSessionSummary(rows)}
+`);
+    return;
+  }
+  if (command === "show") {
+    const sessionID = positionals[0];
+    if (!sessionID) throw new Error("Missing session id. Usage: opencode-insights show <session-id>");
+    const session = await readSession(sessionID, options);
+    process.stdout.write(`${JSON.stringify(session, null, 2)}
+`);
+    return;
+  }
+  if (command === "export") {
+    const sessionID = positionals[0];
+    if (!sessionID) throw new Error("Missing session id. Usage: opencode-insights export <session-id> [--output PATH]");
+    const session = await readSession(sessionID, options);
+    const json = `${JSON.stringify(session, null, 2)}
+`;
+    if (options.output) {
+      await mkdir(dirname(options.output), { recursive: true });
+      await writeFile(options.output, json, "utf8");
+      process.stdout.write(`Exported ${sessionID} to ${options.output}
+`);
+    } else {
+      process.stdout.write(json);
+    }
+    return;
+  }
+  if (command === "serve") {
+    const viewer = await serveViewer({ ...options, limit: options.limitProvided ? options.limit : DEFAULT_HISTORY_LIMIT });
+    process.stdout.write(`OpenCode Insights viewer listening at ${viewer.url}
+`);
+    return;
+  }
+  if (command === "open") {
+    const viewer = await serveViewer({ ...options, limit: options.limitProvided ? options.limit : DEFAULT_HISTORY_LIMIT });
+    await openBrowser(viewer.url);
+    process.stdout.write(`OpenCode Insights viewer listening at ${viewer.url}
+`);
+    return;
+  }
+  if (command === "doctor") {
+    process.stdout.write(`${await runDoctor(options)}
+`);
+    return;
+  }
+  if (command === "vacuum") {
+    process.stdout.write(`${await vacuumDatabase(options)}
+`);
+    return;
+  }
+  if (command === "configure") {
+    process.stdout.write(`${await configureOpenCode(options)}
+`);
+    return;
+  }
+  {
+    process.stderr.write(`Unknown command: ${command}
+`);
+    process.stderr.write(`${usage()}
+`);
+    process.exitCode = 1;
+  }
+}
+function parseOptions(args) {
+  const options = { limit: DEFAULT_RECENT_LIMIT, limitProvided: false, json: false, dryRun: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--db") {
+      const value = args[index + 1];
+      if (value) options.dbPath = value;
+      index += 1;
+    } else if (arg === "--data-dir") {
+      const value = args[index + 1];
+      if (value) options.dataDir = value;
+      index += 1;
+    } else if (arg === "--limit") {
+      options.limit = Number.parseInt(args[index + 1] ?? "20", 10);
+      options.limitProvided = true;
+      index += 1;
+    } else if (arg === "--host") {
+      const value = args[index + 1];
+      if (value) options.host = value;
+      index += 1;
+    } else if (arg === "--port") {
+      options.port = Number.parseInt(args[index + 1] ?? "8765", 10);
+      index += 1;
+    } else if (arg === "--output" || arg === "-o") {
+      const value = args[index + 1];
+      if (value) options.output = value;
+      index += 1;
+    } else if (arg === "--config-dir") {
+      const value = args[index + 1];
+      if (value) options.configDir = value;
+      index += 1;
+    }
+  }
+  if (!Number.isFinite(options.limit) || options.limit < 1) options.limit = DEFAULT_RECENT_LIMIT;
+  if (options.port !== void 0 && (!Number.isFinite(options.port) || options.port < 1)) options.port = 8765;
+  return options;
+}
+function parsePositionals(args) {
+  const positionals = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg.startsWith("--")) {
+      if (["--db", "--data-dir", "--limit", "--host", "--port", "--output", "--config-dir"].includes(arg)) index += 1;
+      continue;
+    }
+    if (arg === "-o") {
+      index += 1;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return positionals;
+}
+function historyReadOptions(options) {
+  return { ...options, limit: options.limitProvided ? options.limit : DEFAULT_HISTORY_LIMIT };
+}
+async function readSession(sessionID, options) {
+  const records = await readRecentCaptures(historyReadOptions(options));
+  const session = buildRequestHistory(records).sessions.find((item) => item.id === sessionID);
+  if (!session) {
+    throw new Error(
+      `Session not found in the latest ${historyReadOptions(options).limit} capture rows: ${sessionID}. Try --limit 20000 or check opencode-insights sessions.`
+    );
+  }
+  return session;
+}
+function summarizeSessions(sessions) {
+  return sessions.map((session) => {
+    const hookCount = session.requests.length;
+    const responseCount = session.messages.filter((message) => message.response).length;
+    const updatedAt = session.updatedAt ?? Math.max(0, ...session.messages.map((message) => message.completedAt ?? message.createdAt ?? 0));
+    return {
+      id: session.id,
+      title: session.title ?? "",
+      updatedAt: updatedAt || void 0,
+      messages: session.messages.length,
+      hooks: hookCount,
+      responses: responseCount
+    };
+  });
+}
+function formatSessionSummary(rows) {
+  if (rows.length === 0) return "No sessions found.";
+  const header = ["updated".padEnd(24), "messages".padStart(8), "hooks".padStart(6), "responses".padStart(9), "session".padEnd(28), "title"].join(
+    "  "
+  );
+  const body = rows.map(
+    (row) => [
+      (row.updatedAt ? new Date(row.updatedAt).toISOString() : "-").padEnd(24),
+      String(row.messages).padStart(8),
+      String(row.hooks).padStart(6),
+      String(row.responses).padStart(9),
+      row.id.padEnd(28),
+      row.title || "-"
+    ].join("  ")
+  );
+  return [header, ...body].join("\n");
+}
+async function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    await execFileAsync2("open", [url]);
+    return;
+  }
+  if (platform === "win32") {
+    await execFileAsync2("cmd", ["/c", "start", "", url]);
+    return;
+  }
+  await execFileAsync2("xdg-open", [url]);
+}
+async function runDoctor(options) {
+  const dbPath = resolveCapturePath(options);
+  const jsonlPath = dbPath.endsWith(".sqlite") ? `${dbPath}.jsonl` : dbPath;
+  const rows = [
+    `OpenCode Insights doctor`,
+    `DB path: ${dbPath}`,
+    `DB exists: ${existsSync2(dbPath) ? "yes" : "no"}`,
+    `JSONL fallback exists: ${existsSync2(jsonlPath) ? "yes" : "no"}`
+  ];
+  if (existsSync2(dbPath)) {
+    rows.push(...await sqliteDiagnostics(dbPath));
+  } else if (existsSync2(jsonlPath)) {
+    const records = await readRecentCaptures({ ...options, limit: options.limitProvided ? options.limit : DEFAULT_HISTORY_LIMIT });
+    rows.push(`Readable fallback records: ${records.length}`);
+  }
+  return rows.join("\n");
+}
+async function sqliteDiagnostics(dbPath) {
+  const diagnostics = [];
+  try {
+    const tableRows = await sqliteJsonQuery(dbPath, "select name from sqlite_master where type='table' order by name;");
+    const tables = tableRows.filter((row) => typeof row.name === "string").map((row) => row.name);
+    diagnostics.push(`SQLite CLI: yes`);
+    diagnostics.push(`Tables: ${tables.join(", ") || "-"}`);
+    if (tables.includes("captures")) {
+      const captureRows = await sqliteJsonQuery(dbPath, "select count(*) as captures from captures;");
+      const kindRows = await sqliteJsonQuery(dbPath, "select kind, count(*) as count from captures group by kind order by kind;");
+      const captureRow = captureRows.find((row) => typeof row.captures === "number");
+      diagnostics.push(`Capture rows: ${captureRow?.captures ?? "unknown"}`);
+      diagnostics.push(`Capture kinds: ${kindRows.map((row) => `${row.kind}=${row.count}`).join(", ") || "-"}`);
+    } else {
+      diagnostics.push("Capture rows: unavailable (missing captures table)");
+    }
+    const integrityRows = await sqliteJsonQuery(dbPath, "pragma integrity_check;");
+    const integrity = integrityRows.find((row) => typeof row.integrity_check === "string");
+    diagnostics.push(`Integrity: ${integrity?.integrity_check ?? "unknown"}`);
+  } catch (error) {
+    diagnostics.push(`SQLite CLI: unavailable or failed (${error instanceof Error ? error.message : String(error)})`);
+    const records = await readRecentCaptures({ dbPath, limit: DEFAULT_RECENT_LIMIT });
+    diagnostics.push(`Readable records via fallback: ${records.length}`);
+  }
+  return diagnostics;
+}
+async function sqliteJsonQuery(dbPath, sql) {
+  const { stdout } = await execFileAsync2("sqlite3", ["-json", dbPath, sql], { maxBuffer: 128 * 1024 * 1024 });
+  return stdout.trim() ? JSON.parse(stdout) : [];
+}
+async function vacuumDatabase(options) {
+  const dbPath = resolveCapturePath(options);
+  if (!existsSync2(dbPath)) return `No SQLite DB found at ${dbPath}`;
+  await execFileAsync2("sqlite3", [dbPath, "vacuum;"]);
+  return `Vacuumed ${dbPath}`;
+}
+async function configureOpenCode(options) {
+  const configDir = options.configDir ?? defaultOpenCodeConfigDir();
+  const opencodePath = resolveOpenCodeConfigPath(configDir);
+  const tuiPath = join(configDir, "tui.json");
+  const opencodeConfig = await readJsonConfig(opencodePath, { plugin: [] });
+  const tuiConfig = await readJsonConfig(tuiPath, { plugin: [] });
+  const opencodeChanged = addUniquePlugin(opencodeConfig, SERVER_PLUGIN_SPEC);
+  const tuiChanged = addUniquePlugin(tuiConfig, TUI_PLUGIN_SPEC);
+  const lines = [
+    `OpenCode config: ${opencodePath}`,
+    `TUI config: ${tuiPath}`,
+    `Server plugin: ${opencodeChanged ? "added" : "already present"} (${SERVER_PLUGIN_SPEC})`,
+    `TUI plugin: ${tuiChanged ? "added" : "already present"} (${TUI_PLUGIN_SPEC})`
+  ];
+  if (options.dryRun) {
+    lines.push("Dry run: no files written.");
+    return lines.join("\n");
+  }
+  await mkdir(configDir, { recursive: true });
+  if (opencodeChanged || !existsSync2(opencodePath)) await writeJsonConfig(opencodePath, opencodeConfig);
+  if (tuiChanged || !existsSync2(tuiPath)) await writeJsonConfig(tuiPath, tuiConfig);
+  lines.push("Configuration written. Restart OpenCode to load the plugin.");
+  return lines.join("\n");
+}
+function defaultOpenCodeConfigDir() {
+  const override = process.env.OPENCODE_CONFIG_DIR;
+  if (override) return override;
+  if (process.platform === "win32") return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "opencode");
+  return join(homedir(), ".config", "opencode");
+}
+function resolveOpenCodeConfigPath(configDir) {
+  const jsoncPath = join(configDir, "opencode.jsonc");
+  if (existsSync2(jsoncPath)) return jsoncPath;
+  const jsonPath = join(configDir, "opencode.json");
+  if (existsSync2(jsonPath)) return jsonPath;
+  return jsonPath;
+}
+async function readJsonConfig(path, fallback) {
+  if (!existsSync2(path)) return { ...fallback };
+  const content = await readFile2(path, "utf8");
+  const trimmed = content.trim();
+  if (!trimmed) return { ...fallback };
+  try {
+    const parsed = JSON.parse(stripJsonCommentsAndTrailingCommas(trimmed));
+    return isJsonObject(parsed) ? parsed : { ...fallback };
+  } catch (error) {
+    throw new Error(`Could not parse ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function stripJsonCommentsAndTrailingCommas(input) {
+  let output = "";
+  let inString = false;
+  let quote = "";
+  let escaped = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const current = input[index] ?? "";
+    const next = input[index + 1] ?? "";
+    if (inString) {
+      output += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (current === quote) {
+        inString = false;
+      }
+      continue;
+    }
+    if (current === '"' || current === "'") {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      while (index < input.length && input[index] !== "\n") index += 1;
+      output += "\n";
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      index += 2;
+      while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) index += 1;
+      index += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output.replace(/,\s*([}\]])/g, "$1");
+}
+function isJsonObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function addUniquePlugin(config, plugin) {
+  const current = Array.isArray(config.plugin) ? config.plugin : [];
+  if (current.includes(plugin)) {
+    config.plugin = current;
+    return false;
+  }
+  config.plugin = [...current, plugin];
+  return true;
+}
+async function writeJsonConfig(path, config) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function usage() {
+  return [
+    "Usage:",
+    "  opencode-insights configure [--config-dir DIR] [--dry-run]",
+    "  opencode-insights recent [--db PATH] [--data-dir DIR] [--limit N] [--json]",
+    "  opencode-insights sessions [--db PATH] [--data-dir DIR] [--limit N] [--json]",
+    "  opencode-insights history [--db PATH] [--data-dir DIR] [--limit N]",
+    "  opencode-insights show <session-id> [--db PATH] [--data-dir DIR] [--limit N]",
+    "  opencode-insights export <session-id> [--output PATH] [--db PATH] [--data-dir DIR] [--limit N]",
+    "  opencode-insights serve [--db PATH] [--data-dir DIR] [--limit N] [--host HOST] [--port PORT]",
+    "  opencode-insights open [--db PATH] [--data-dir DIR] [--limit N] [--host HOST] [--port PORT]",
+    "  opencode-insights doctor [--db PATH] [--data-dir DIR]",
+    "  opencode-insights vacuum [--db PATH] [--data-dir DIR]"
+  ].join("\n");
+}
+function isDirectRun() {
+  const entry = process.argv[1];
+  return !!entry && pathToFileURL(entry).href === import.meta.url;
+}
+if (isDirectRun()) {
+  main(process.argv).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  addUniquePlugin,
+  configureOpenCode,
+  defaultOpenCodeConfigDir,
+  formatSessionSummary,
+  parseOptions,
+  resolveOpenCodeConfigPath,
+  stripJsonCommentsAndTrailingCommas,
+  summarizeSessions
+};
+//# sourceMappingURL=cli.js.map