agent-insights 0.0.1

package/dist/cli.js

@@ -0,0 +1,1017 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/cursor.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+
+// src/config/config.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function configRoot() {
+  return process.env.AGENT_INSIGHTS_HOME ?? join(homedir(), ".agent-insights");
+}
+function configFile() {
+  return join(configRoot(), "config.json");
+}
+function sessionCacheDir() {
+  return join(configRoot(), "session-cache");
+}
+function logsDir() {
+  return join(configRoot(), "logs");
+}
+
+// src/config/config.ts
+function defaultConfig() {
+  return {
+    version: 1,
+    enabled: true,
+    vercel: {
+      team: "vercel-labs",
+      project: "agent-insights"
+    },
+    userConsent: {
+      eventTelemetry: false,
+      transcriptSync: false,
+      sessionAnalysis: false
+    },
+    exporter: {
+      type: "otlp",
+      endpoint: process.env.AGENT_INSIGHTS_OTEL_ENDPOINT ?? "",
+      headers: {},
+      dataset: "agent-insights"
+    },
+    transcriptStore: {
+      type: "blob",
+      tokenEnv: "BLOB_READ_WRITE_TOKEN",
+      prefix: "sessions/"
+    },
+    sessionAnalysis: {
+      enabled: false,
+      analyzerUrl: process.env.AGENT_INSIGHTS_ANALYZER_URL ?? "",
+      secretEnv: "AGENT_INSIGHTS_INGEST_SECRET",
+      githubIssueRepo: "vercel-labs/agent-insights"
+    },
+    agents: {
+      claudeCode: { enabled: false },
+      cursor: { enabled: false }
+    },
+    privacy: {
+      capturePrompts: false,
+      captureMessages: false,
+      captureToolInputs: false,
+      captureFileContents: false
+    }
+  };
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(configFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    return mergeConfig(defaultConfig(), parsed);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+async function saveConfig(cfg) {
+  await ensureDirs();
+  await writeFile(configFile(), `${JSON.stringify(cfg, null, 2)}
+`, "utf8");
+}
+async function ensureDirs() {
+  await mkdir(dirname(configFile()), { recursive: true });
+  await mkdir(sessionCacheDir(), { recursive: true });
+  await mkdir(logsDir(), { recursive: true });
+}
+function mergeConfig(base, patch) {
+  return {
+    ...base,
+    ...patch,
+    vercel: { ...base.vercel, ...patch.vercel ?? {} },
+    userConsent: { ...base.userConsent, ...patch.userConsent ?? {} },
+    exporter: { ...base.exporter, ...patch.exporter ?? {} },
+    transcriptStore: patch.transcriptStore ?? base.transcriptStore,
+    sessionAnalysis: {
+      ...base.sessionAnalysis,
+      ...patch.sessionAnalysis ?? {}
+    },
+    agents: {
+      claudeCode: {
+        ...base.agents.claudeCode,
+        ...patch.agents?.claudeCode ?? {}
+      },
+      cursor: { ...base.agents.cursor, ...patch.agents?.cursor ?? {} }
+    },
+    privacy: base.privacy
+  };
+}
+
+// src/privacy/sanitize.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "prompt",
+  "prompts",
+  "message",
+  "messages",
+  "content",
+  "text",
+  "transcript",
+  "toolinput",
+  "input",
+  "arguments",
+  "args",
+  "params",
+  "file",
+  "filecontent",
+  "filecontents",
+  "diff",
+  "patch",
+  "secret",
+  "secrets",
+  "token",
+  "apikey",
+  "authorization",
+  "password",
+  "credentials"
+]);
+var MAX_STRING_LENGTH = 256;
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[_\-\s]/g, "");
+}
+function truncate(value) {
+  if (value.length <= MAX_STRING_LENGTH) return value;
+  return `${value.slice(0, MAX_STRING_LENGTH)}\u2026[truncated]`;
+}
+function sanitizePrimitive(value) {
+  if (value === null) return null;
+  switch (typeof value) {
+    case "string":
+      return truncate(value);
+    case "number":
+      return Number.isFinite(value) ? value : null;
+    case "boolean":
+      return value;
+    default:
+      return void 0;
+  }
+}
+function sanitize(input) {
+  return sanitizeInner(input);
+}
+function sanitizeInner(value) {
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const item of value) {
+      const sanitizedItem = sanitizeInner(item);
+      if (sanitizedItem !== void 0) {
+        out.push(sanitizedItem);
+      }
+    }
+    return out;
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [rawKey, rawValue] of Object.entries(value)) {
+      if (FORBIDDEN_KEYS.has(normalizeKey(rawKey))) {
+        continue;
+      }
+      if (rawValue && typeof rawValue === "object") {
+        out[rawKey] = sanitizeInner(rawValue);
+      } else {
+        const primitive = sanitizePrimitive(rawValue);
+        if (primitive !== void 0) {
+          out[rawKey] = primitive;
+        }
+      }
+    }
+    return out;
+  }
+  return sanitizePrimitive(value);
+}
+
+// src/util/identity.ts
+import { execSync } from "child_process";
+import { hostname, userInfo } from "os";
+
+// src/privacy/hash.ts
+import { createHash } from "crypto";
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+
+// src/util/identity.ts
+function userHash() {
+  try {
+    const user = userInfo().username;
+    return sha256(`${user}@${hostname()}`);
+  } catch {
+    return sha256("unknown");
+  }
+}
+function repoHash(cwd = process.cwd()) {
+  const remote = tryGit(["config", "--get", "remote.origin.url"], cwd);
+  return sha256(remote ?? cwd);
+}
+function workspaceHash(cwd = process.cwd()) {
+  return sha256(cwd);
+}
+function tryGit(args, cwd) {
+  try {
+    const out = execSync(`git ${args.join(" ")}`, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+      timeout: 1500
+    });
+    const trimmed = out.trim();
+    return trimmed === "" ? void 0 : trimmed;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/util/log.ts
+import kleur from "kleur";
+var log = {
+  info: (msg) => {
+    process.stdout.write(`${msg}
+`);
+  },
+  ok: (msg) => {
+    process.stdout.write(`${kleur.green("\u2713")} ${msg}
+`);
+  },
+  warn: (msg) => {
+    process.stdout.write(`${kleur.yellow("!")} ${msg}
+`);
+  },
+  fail: (msg) => {
+    process.stderr.write(`${kleur.red("\u2717")} ${msg}
+`);
+  },
+  hint: (msg) => {
+    process.stdout.write(`${kleur.dim(msg)}
+`);
+  },
+  json: (obj) => {
+    process.stdout.write(`${JSON.stringify(obj, null, 2)}
+`);
+  }
+};
+function debug(msg, extra) {
+  if (process.env.AGENT_INSIGHTS_DEBUG) {
+    const payload = extra ? ` ${JSON.stringify(extra)}` : "";
+    process.stderr.write(`[agent-insights] ${msg}${payload}
+`);
+  }
+}
+
+// src/commands/cursor.ts
+async function runCursorWrapper(opts) {
+  const cfg = await loadConfig();
+  if (!cfg) {
+    log.fail("agent-insights is not initialized \u2014 run `agent-insights init`");
+    process.exitCode = 1;
+    return;
+  }
+  const path = opts.path ?? process.cwd();
+  const sessionId = randomUUID();
+  const baseEvent = {
+    agent: "cursor",
+    sessionId,
+    userHash: userHash(),
+    repoHash: repoHash(),
+    workspaceHash: workspaceHash()
+  };
+  emit({
+    ...baseEvent,
+    type: "session.start",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const code = await spawnCursor(path);
+  emit({
+    ...baseEvent,
+    type: "session.end",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    outcome: code === 0 ? "success" : "error"
+  });
+  process.exitCode = code;
+}
+function spawnCursor(path) {
+  return new Promise((resolve) => {
+    const child = spawn("cursor", [path], {
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", (err) => {
+      log.fail(`failed to launch cursor: ${err.message}`);
+      resolve(127);
+    });
+    child.on("exit", (code) => resolve(code ?? 0));
+  });
+}
+function emit(event) {
+  debug("cursor wrapper event", {
+    type: event.type,
+    sessionId: event.sessionId
+  });
+  void sanitize(event);
+}
+
+// src/commands/disable.ts
+import { rm } from "fs/promises";
+
+// src/adapters/claude-code.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+var HOOK_COMMAND_NAME = "agent-insights";
+var HOOK_MAP = {
+  SessionStart: "session.start",
+  SessionEnd: "session.end",
+  UserPromptSubmit: "user.prompt.submit",
+  PreToolUse: "tool.start",
+  PostToolUse: "tool.end",
+  PostToolUseFailure: "tool.failure",
+  PermissionRequest: "permission.request",
+  PermissionDenied: "permission.denied",
+  SubagentStart: "subagent.start",
+  SubagentStop: "subagent.end",
+  Stop: "agent.stop",
+  Notification: "notification",
+  PreCompact: "context.compact.start",
+  PostCompact: "context.compact.end"
+};
+var CLAUDE_HOOK_EVENTS = Object.keys(HOOK_MAP);
+var claudeCodeAdapter = {
+  id: "claude-code",
+  agent: "claude-code",
+  label: "Claude Code",
+  settingsFile: ".claude/settings.json",
+  map(payload) {
+    const type = HOOK_MAP[payload.event];
+    if (!type) return void 0;
+    const data = payload.data ?? {};
+    const sessionId = asString(data["session_id"]) ?? asString(data["sessionId"]);
+    const toolName = asString(data["tool_name"]) ?? asString(data["toolName"]) ?? asString(data["tool"]?.["name"]);
+    const transcriptPath = asString(data["transcript_path"]) ?? asString(data["transcriptPath"]);
+    return {
+      type,
+      ...sessionId !== void 0 ? { sessionId } : {},
+      ...toolName !== void 0 ? { toolName } : {},
+      ...transcriptPath !== void 0 ? { transcriptPath } : {}
+    };
+  },
+  async install(repoRoot) {
+    const path = join2(repoRoot, ".claude/settings.json");
+    const settings = await readJson(path);
+    const next = { ...settings ?? {} };
+    const hooks = { ...next.hooks ?? {} };
+    for (const event of CLAUDE_HOOK_EVENTS) {
+      const existing = (hooks[event] ?? []).filter(
+        (h) => !isAgentInsightsCommand(h.command)
+      );
+      existing.push({
+        type: "command",
+        command: `${HOOK_COMMAND_NAME} hook ${event}`
+      });
+      hooks[event] = existing;
+    }
+    next.hooks = hooks;
+    await mkdir2(dirname2(path), { recursive: true });
+    await writeFile2(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    return { written: true, path };
+  },
+  async uninstall(repoRoot) {
+    const path = join2(repoRoot, ".claude/settings.json");
+    const settings = await readJson(path);
+    if (!settings?.hooks) return { removed: false, path };
+    const hooks = { ...settings.hooks };
+    let touched = false;
+    for (const [event, entries] of Object.entries(hooks)) {
+      const filtered = entries.filter(
+        (h) => !isAgentInsightsCommand(h.command)
+      );
+      if (filtered.length !== entries.length) touched = true;
+      if (filtered.length === 0) {
+        delete hooks[event];
+      } else {
+        hooks[event] = filtered;
+      }
+    }
+    settings.hooks = hooks;
+    await writeFile2(path, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+    return { removed: touched, path };
+  },
+  async isInstalled(repoRoot) {
+    const settings = await readJson(
+      join2(repoRoot, ".claude/settings.json")
+    );
+    if (!settings?.hooks) return false;
+    return Object.values(settings.hooks).some(
+      (entries) => entries.some((h) => isAgentInsightsCommand(h.command))
+    );
+  }
+};
+function isAgentInsightsCommand(cmd) {
+  if (!cmd) return false;
+  return cmd.startsWith(`${HOOK_COMMAND_NAME} hook`);
+}
+async function readJson(path) {
+  try {
+    const raw = await readFile2(path, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+
+// src/adapters/cursor.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+var HOOK_COMMAND_NAME2 = "agent-insights";
+var HOOK_MAP2 = {
+  SessionStart: "session.start",
+  SessionEnd: "session.end",
+  UserPromptSubmit: "user.prompt.submit",
+  PreToolUse: "tool.start",
+  PostToolUse: "tool.end",
+  Stop: "agent.stop"
+};
+var CURSOR_HOOK_EVENTS = Object.keys(HOOK_MAP2);
+var cursorAdapter = {
+  id: "cursor",
+  agent: "cursor",
+  label: "Cursor",
+  settingsFile: ".cursor/hooks.json",
+  map(payload) {
+    const type = HOOK_MAP2[payload.event];
+    if (!type) return void 0;
+    const data = payload.data ?? {};
+    const sessionId = asString2(data["session_id"]) ?? asString2(data["sessionId"]);
+    const toolName = asString2(data["tool_name"]) ?? asString2(data["toolName"]);
+    const transcriptPath = asString2(data["transcript_path"]) ?? asString2(data["transcriptPath"]);
+    return {
+      type,
+      ...sessionId !== void 0 ? { sessionId } : {},
+      ...toolName !== void 0 ? { toolName } : {},
+      ...transcriptPath !== void 0 ? { transcriptPath } : {}
+    };
+  },
+  async install(repoRoot) {
+    const path = join3(repoRoot, ".cursor/hooks.json");
+    const settings = await readJson2(path);
+    const next = { ...settings ?? {} };
+    const hooks = { ...next.hooks ?? {} };
+    for (const event of CURSOR_HOOK_EVENTS) {
+      const existing = (hooks[event] ?? []).filter(
+        (h) => !isAgentInsightsCommand2(h.command)
+      );
+      existing.push({ command: `${HOOK_COMMAND_NAME2} hook ${event}` });
+      hooks[event] = existing;
+    }
+    next.hooks = hooks;
+    await mkdir3(dirname3(path), { recursive: true });
+    await writeFile3(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    return { written: true, path };
+  },
+  async uninstall(repoRoot) {
+    const path = join3(repoRoot, ".cursor/hooks.json");
+    const settings = await readJson2(path);
+    if (!settings?.hooks) return { removed: false, path };
+    const hooks = { ...settings.hooks };
+    let touched = false;
+    for (const [event, entries] of Object.entries(hooks)) {
+      const filtered = entries.filter(
+        (h) => !isAgentInsightsCommand2(h.command)
+      );
+      if (filtered.length !== entries.length) touched = true;
+      if (filtered.length === 0) {
+        delete hooks[event];
+      } else {
+        hooks[event] = filtered;
+      }
+    }
+    settings.hooks = hooks;
+    await writeFile3(path, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+    return { removed: touched, path };
+  },
+  async isInstalled(repoRoot) {
+    const settings = await readJson2(
+      join3(repoRoot, ".cursor/hooks.json")
+    );
+    if (!settings?.hooks) return false;
+    return Object.values(settings.hooks).some(
+      (entries) => entries.some((h) => isAgentInsightsCommand2(h.command))
+    );
+  }
+};
+function isAgentInsightsCommand2(cmd) {
+  if (!cmd) return false;
+  return cmd.startsWith(`${HOOK_COMMAND_NAME2} hook`);
+}
+async function readJson2(path) {
+  try {
+    const raw = await readFile3(path, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+function asString2(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+
+// src/adapters/registry.ts
+var adapters = {
+  "claude-code": claudeCodeAdapter,
+  cursor: cursorAdapter
+};
+var adapterList = Object.values(adapters);
+
+// src/commands/disable.ts
+async function runDisable(opts) {
+  const repoRoot = process.cwd();
+  const targets = opts.agent ? [opts.agent] : adapterList.map((a) => a.id);
+  for (const id of targets) {
+    if (id !== "claude-code" && id !== "cursor") {
+      log.warn(`Unknown agent id "${id}"`);
+      continue;
+    }
+    const adapter = adapterList.find((a) => a.id === id);
+    if (!adapter) continue;
+    const { removed, path } = await adapter.uninstall(repoRoot);
+    if (removed) log.ok(`Removed ${adapter.label} hooks from ${path}`);
+    else log.hint(`${adapter.label}: no hooks to remove (${path})`);
+  }
+  const cfg = await loadConfig();
+  if (cfg) {
+    if (!opts.agent || opts.agent === "claude-code") {
+      cfg.agents.claudeCode.enabled = false;
+    }
+    if (!opts.agent || opts.agent === "cursor") {
+      cfg.agents.cursor.enabled = false;
+    }
+    if (!opts.agent) cfg.enabled = false;
+    await saveConfig(cfg);
+  }
+  if (opts.purge) {
+    await rm(configRoot(), { recursive: true, force: true });
+    log.ok(`Purged ${configRoot()}`);
+  }
+}
+
+// src/commands/doctor.ts
+import { existsSync } from "fs";
+import { join as join4 } from "path";
+import kleur2 from "kleur";
+
+// src/transcript/store.ts
+import { readFile as readFile4 } from "fs/promises";
+import { put } from "@vercel/blob";
+var NoopTranscriptStore = class {
+  async upload() {
+    throw new Error("transcript store disabled (transcriptStore.type=none)");
+  }
+  async ping() {
+    return { ok: false, reason: "transcript store disabled" };
+  }
+};
+var BlobTranscriptStore = class {
+  constructor(token, prefix) {
+    this.token = token;
+    this.prefix = prefix;
+  }
+  token;
+  prefix;
+  async upload(input) {
+    const body = await readFile4(input.transcriptPath);
+    const requestedPath = buildPathname(
+      this.prefix,
+      input.userHash,
+      input.sessionId
+    );
+    const blob = await put(requestedPath, body, {
+      access: "public",
+      token: this.token,
+      contentType: "application/jsonl",
+      addRandomSuffix: true
+    });
+    return { pathname: blob.pathname, url: blob.url, size: body.byteLength };
+  }
+  async ping() {
+    if (!this.token) return { ok: false, reason: "missing token" };
+    return { ok: true };
+  }
+};
+function createTranscriptStore(cfg) {
+  if (cfg.type === "none") return new NoopTranscriptStore();
+  const token = process.env[cfg.tokenEnv];
+  if (!token) {
+    throw new Error(
+      `transcript store: env ${cfg.tokenEnv} is not set (run 'vercel env pull .env.local')`
+    );
+  }
+  return new BlobTranscriptStore(token, cfg.prefix);
+}
+function buildPathname(prefix, userHash2, sessionId) {
+  const safePrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+  const safeSession = encodeURIComponent(sessionId);
+  return `${safePrefix}${userHash2}/${safeSession}/transcript.jsonl`;
+}
+
+// src/commands/doctor.ts
+async function runDoctor(opts) {
+  const repoRoot = process.cwd();
+  const checks = [];
+  const cfg = await loadConfig();
+  checks.push({
+    name: "config found",
+    ok: cfg != null,
+    detail: cfg ? configFile() : `missing ${configFile()}`
+  });
+  if (cfg) {
+    checks.push({
+      name: "vercel project linked",
+      ok: existsSync(join4(repoRoot, ".vercel/project.json")),
+      detail: "run `vercel link --scope vercel-labs --project agent-insights`"
+    });
+    if (cfg.userConsent.transcriptSync) {
+      try {
+        const store = createTranscriptStore(cfg.transcriptStore);
+        const ping = await store.ping();
+        if (ping.ok) {
+          checks.push({ name: "transcript store reachable", ok: true });
+        } else {
+          checks.push({
+            name: "transcript store reachable",
+            ok: false,
+            detail: ping.reason
+          });
+        }
+      } catch (err) {
+        checks.push({
+          name: "transcript store reachable",
+          ok: false,
+          detail: err.message
+        });
+      }
+    }
+    for (const adapter of adapterList) {
+      const enabled = adapter.id === "claude-code" ? cfg.agents.claudeCode.enabled : cfg.agents.cursor.enabled;
+      if (!enabled) continue;
+      const installed = await adapter.isInstalled(repoRoot);
+      checks.push({
+        name: `${adapter.label} hooks installed`,
+        ok: installed,
+        detail: installed ? join4(repoRoot, adapter.settingsFile) : "run `agent-insights init`"
+      });
+    }
+  }
+  if (opts.json) {
+    log.json({ ok: checks.every((c) => c.ok), checks });
+  } else {
+    for (const c of checks) {
+      const tag = c.ok ? kleur2.green("\u2713") : kleur2.red("\u2717");
+      const detail = c.detail ? kleur2.dim(`  (${c.detail})`) : "";
+      log.info(`${tag} ${c.name}${detail}`);
+    }
+  }
+  process.exitCode = checks.every((c) => c.ok) ? 0 : 1;
+}
+
+// src/commands/hook.ts
+async function runHook(eventName, opts) {
+  const cfg = await loadConfig();
+  if (!cfg || !cfg.enabled) {
+    debug("hook skipped \u2014 agent-insights not enabled");
+    return;
+  }
+  const stdin = await readStdinSafely();
+  const data = parseJsonObject(stdin);
+  const payload = { event: eventName, data };
+  const adapter = pickAdapter(opts.agent, eventName);
+  if (!adapter) {
+    debug(`no adapter resolved for event ${eventName}`);
+    return;
+  }
+  const mapped = adapter.map(payload);
+  if (!mapped) {
+    debug(`adapter ${adapter.id} did not map event ${eventName}`);
+    return;
+  }
+  const event = buildEvent(adapter, mapped);
+  debug("hook event", {
+    agent: event.agent,
+    type: event.type,
+    sessionId: event.sessionId
+  });
+  if (mapped.type === "session.end" && cfg.userConsent.transcriptSync && mapped.transcriptPath) {
+    try {
+      const store = createTranscriptStore(cfg.transcriptStore);
+      const result = await store.upload({
+        transcriptPath: mapped.transcriptPath,
+        userHash: event.userHash ?? userHash(),
+        sessionId: mapped.sessionId ?? "unknown",
+        agent: adapter.id
+      });
+      debug("transcript uploaded", {
+        size: result.size,
+        pathname: result.pathname
+      });
+      if (cfg.userConsent.sessionAnalysis && cfg.sessionAnalysis.analyzerUrl) {
+        await notifyAnalyzer({
+          analyzerUrl: cfg.sessionAnalysis.analyzerUrl,
+          secretEnv: cfg.sessionAnalysis.secretEnv,
+          payload: {
+            sessionId: mapped.sessionId ?? "unknown",
+            agent: adapter.id,
+            userHash: event.userHash ?? userHash(),
+            blobUrl: result.url,
+            timestamp: event.timestamp
+          }
+        });
+      }
+    } catch (err) {
+      log.fail(`transcript upload failed: ${err.message}`);
+    }
+  }
+  void sanitize(event);
+}
+async function notifyAnalyzer(opts) {
+  try {
+    const headers = {
+      "content-type": "application/json"
+    };
+    const secret = process.env[opts.secretEnv];
+    if (secret) headers["x-agent-insights-secret"] = secret;
+    const url = new URL("/api/sessions", opts.analyzerUrl).toString();
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(opts.payload)
+    });
+    if (!res.ok) {
+      debug(`analyzer notify failed: ${res.status} ${res.statusText}`);
+      return;
+    }
+    debug("analyzer notified", { sessionId: opts.payload.sessionId });
+  } catch (err) {
+    debug(`analyzer notify error: ${err.message}`);
+  }
+}
+function pickAdapter(override, eventName) {
+  if (override) {
+    return adapterList.find((a) => a.id === override);
+  }
+  for (const a of adapterList) {
+    if (a.map({ event: eventName })) return a;
+  }
+  return void 0;
+}
+function buildEvent(adapter, mapped) {
+  return {
+    type: mapped.type,
+    agent: adapter.agent,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...mapped.sessionId !== void 0 ? { sessionId: mapped.sessionId } : {},
+    ...mapped.toolName !== void 0 ? { toolName: mapped.toolName } : {},
+    ...mapped.permissionType !== void 0 ? { permissionType: mapped.permissionType } : {},
+    ...mapped.outcome !== void 0 ? { outcome: mapped.outcome } : {},
+    userHash: userHash(),
+    repoHash: repoHash(),
+    workspaceHash: workspaceHash()
+  };
+}
+var STDIN_TIMEOUT_MS = 200;
+async function readStdinSafely() {
+  if (process.stdin.isTTY) return "";
+  return new Promise((resolve) => {
+    let buf = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      process.stdin.removeAllListeners("data");
+      process.stdin.removeAllListeners("end");
+      process.stdin.removeAllListeners("error");
+      try {
+        process.stdin.pause();
+        process.stdin.unref();
+      } catch {
+      }
+      resolve(buf);
+    };
+    const idle = setTimeout(finish, STDIN_TIMEOUT_MS);
+    idle.unref();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buf += chunk;
+      idle.refresh();
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(idle);
+      finish();
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(idle);
+      finish();
+    });
+  });
+}
+function parseJsonObject(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join5 } from "path";
+import kleur3 from "kleur";
+var CONSENT_TEXT = `Agent Insights is opt-in (internal).
+
+OTLP / lifecycle metrics: event names, timestamps, tool names, outcomes,
+hashed user/repo/workspace IDs \u2014 never prompts, messages, or tool inputs.
+
+Vercel Blob (optional): full session transcripts for internal analysis;
+username stored as SHA256 only.
+
+SessionEnd analysis (optional): an internal LLM reviews transcript for
+tooling gaps; may post to Slack with a GitHub issue link.`;
+async function runInit(opts) {
+  log.info(kleur3.bold("Agent Insights setup\n"));
+  log.hint(CONSENT_TEXT);
+  log.info("");
+  const existing = await loadConfig();
+  if (existing && !opts.force) {
+    log.warn(
+      `Config already exists at ${configFile()} \u2014 re-run with --force to overwrite.`
+    );
+  }
+  const requested = parseAgents(opts.agents);
+  const cfg = existing ?? defaultConfig();
+  cfg.userConsent.transcriptSync = opts.transcripts ?? true;
+  cfg.userConsent.sessionAnalysis = opts.analysis ?? false;
+  cfg.userConsent.eventTelemetry = opts.telemetry ?? false;
+  cfg.agents.claudeCode.enabled = requested.has("claude-code");
+  cfg.agents.cursor.enabled = requested.has("cursor");
+  await saveConfig(cfg);
+  log.ok(`Wrote config to ${configFile()}`);
+  const installHooks = opts.hooks ?? true;
+  const repoRoot = process.cwd();
+  if (installHooks) {
+    for (const adapter of adapterList) {
+      const enabled = adapter.id === "claude-code" && cfg.agents.claudeCode.enabled || adapter.id === "cursor" && cfg.agents.cursor.enabled;
+      if (!enabled) continue;
+      const { path } = await adapter.install(repoRoot);
+      log.ok(`Installed ${adapter.label} hooks \u2192 ${rel(path)}`);
+    }
+  }
+  printVercelHint(repoRoot);
+  log.info("");
+  log.info(`Config root: ${configRoot()}`);
+  log.hint("Run `agent-insights doctor` to verify the setup.");
+}
+function parseAgents(value) {
+  const out = /* @__PURE__ */ new Set();
+  const list = (value ?? "claude-code,cursor").split(",").map((s) => s.trim()).filter(Boolean);
+  for (const id of list) {
+    if (id === "claude-code" || id === "cursor") out.add(id);
+    else log.warn(`Unknown agent id "${id}" \u2014 skipping.`);
+  }
+  return out;
+}
+function printVercelHint(repoRoot) {
+  const linked = existsSync2(join5(repoRoot, ".vercel/project.json"));
+  const envFile = existsSync2(join5(repoRoot, ".env.local"));
+  if (!linked) {
+    log.hint(
+      "Vercel project not linked. Run `vercel link --scope vercel-labs --project agent-insights`."
+    );
+  }
+  if (!envFile) {
+    log.hint(
+      "No .env.local found. Run `vercel env pull .env.local` to fetch BLOB_READ_WRITE_TOKEN."
+    );
+  }
+}
+function rel(p) {
+  const cwd = process.cwd();
+  return p.startsWith(cwd) ? p.slice(cwd.length + 1) : p;
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
+import kleur4 from "kleur";
+async function runStatus(opts) {
+  const cfg = await loadConfig();
+  const repoRoot = process.cwd();
+  if (!cfg) {
+    if (opts.json) log.json({ initialized: false });
+    else log.warn(`No config found at ${configFile()} \u2014 run \`agent-insights init\`.`);
+    return;
+  }
+  const adapterStatus = await Promise.all(
+    adapterList.map(async (a) => ({
+      id: a.id,
+      label: a.label,
+      enabled: a.id === "claude-code" ? cfg.agents.claudeCode.enabled : cfg.agents.cursor.enabled,
+      installed: await a.isInstalled(repoRoot)
+    }))
+  );
+  if (opts.json) {
+    log.json({
+      initialized: true,
+      configPath: configFile(),
+      enabled: cfg.enabled,
+      consent: cfg.userConsent,
+      vercel: {
+        linked: existsSync3(join6(repoRoot, ".vercel/project.json")),
+        envFile: existsSync3(join6(repoRoot, ".env.local"))
+      },
+      adapters: adapterStatus
+    });
+    return;
+  }
+  log.info(kleur4.bold("Agent Insights status\n"));
+  log.info(`config       ${configFile()}`);
+  log.info(`enabled      ${cfg.enabled ? "yes" : "no"}`);
+  log.info("");
+  log.info(kleur4.bold("Consent"));
+  log.info(`  event telemetry   ${yn(cfg.userConsent.eventTelemetry)}`);
+  log.info(`  transcript sync   ${yn(cfg.userConsent.transcriptSync)}`);
+  log.info(`  session analysis  ${yn(cfg.userConsent.sessionAnalysis)}`);
+  log.info("");
+  log.info(kleur4.bold("Adapters"));
+  for (const a of adapterStatus) {
+    log.info(
+      `  ${a.label.padEnd(12)} ${a.enabled ? "enabled" : "disabled"}   hooks ${a.installed ? "installed" : "not installed"}`
+    );
+  }
+  log.info("");
+  log.info(kleur4.bold("Vercel"));
+  log.info(
+    `  linked      ${yn(existsSync3(join6(repoRoot, ".vercel/project.json")))}`
+  );
+  log.info(`  .env.local  ${yn(existsSync3(join6(repoRoot, ".env.local")))}`);
+}
+function yn(v) {
+  return v ? kleur4.green("yes") : kleur4.dim("no");
+}
+
+// src/cli.ts
+var VERSION = "0.0.1";
+var program = new Command();
+program.name("agent-insights").description(
+  "Internal CLI for AI coding agent observability (Claude Code, Cursor)."
+).version(VERSION);
+program.command("init").description("Set up agent-insights in this repo.").option(
+  "--agents <list>",
+  "Comma-separated agent ids (claude-code,cursor)",
+  "claude-code,cursor"
+).option("--transcripts", "Opt into transcript sync to Vercel Blob").option("--no-transcripts", "Skip transcript sync").option("--analysis", "Opt into SessionEnd analysis (Phase 2)").option("--telemetry", "Opt into OTLP event telemetry (Phase 3)").option("--no-hooks", "Skip installing per-agent hooks").option("--force", "Overwrite existing config").action(async (opts) => {
+  await runInit(opts);
+});
+program.command("status").description("Show current config, consent, and adapter state.").option("--json", "Emit machine-readable JSON").action(async (opts) => {
+  await runStatus(opts);
+});
+program.command("doctor").description("Verify config, Vercel link, Blob, and per-agent hook install.").option("--json", "Emit machine-readable JSON").action(async (opts) => {
+  await runDoctor(opts);
+});
+program.command("disable").description("Disable agent-insights and/or remove installed hooks.").option("--agent <name>", "Disable a specific adapter (claude-code|cursor)").option("--purge", "Also delete the local config and caches").action(async (opts) => {
+  await runDisable(opts);
+});
+program.command("hook <eventName>").description("Internal: invoked by an agent's hook configuration.").option("--agent <name>", "Override agent inference (claude-code|cursor)").action(async (eventName, opts) => {
+  await runHook(eventName, opts);
+});
+program.command("cursor [path]").description("Launch Cursor with session start/end emitted (fallback).").action(async (path) => {
+  await runCursorWrapper({ ...path !== void 0 ? { path } : {} });
+});
+program.parseAsync(process.argv).catch((err) => {
+  log.fail(err.message ?? String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map