@agentreel/agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,1148 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync } from "fs";
+function ensureAgentreelDir() {
+  mkdirSync(AGENTREEL_DIR, { recursive: true });
+  mkdirSync(QUEUE_DIR, { recursive: true });
+}
+var HOME, AGENTREEL_DIR, DB_PATH, CONFIG_PATH, QUEUE_DIR, LOG_PATH, CLAUDE_DIR, CLAUDE_SETTINGS_PATH;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    HOME = homedir();
+    AGENTREEL_DIR = join(HOME, ".agentreel");
+    DB_PATH = join(AGENTREEL_DIR, "sessions.db");
+    CONFIG_PATH = join(AGENTREEL_DIR, "config.json");
+    QUEUE_DIR = join(AGENTREEL_DIR, "queue");
+    LOG_PATH = join(AGENTREEL_DIR, "agent.log");
+    CLAUDE_DIR = join(HOME, ".claude");
+    CLAUDE_SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
+  }
+});
+
+// src/hooks/install.ts
+var install_exports = {};
+__export(install_exports, {
+  installClaudeCodeHooks: () => installClaudeCodeHooks,
+  quotePath: () => quotePath,
+  uninstallClaudeCodeHooks: () => uninstallClaudeCodeHooks
+});
+import { readFileSync, writeFileSync, existsSync, copyFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+function readSettings() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  const raw = readFileSync(CLAUDE_SETTINGS_PATH, "utf8");
+  if (!raw.trim()) return {};
+  return JSON.parse(raw);
+}
+function backupSettings() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return null;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backup = `${CLAUDE_SETTINGS_PATH}.agentreel-backup-${stamp}`;
+  copyFileSync(CLAUDE_SETTINGS_PATH, backup);
+  return backup;
+}
+function buildHookEntry(event, hookCommandPrefix) {
+  return {
+    type: "command",
+    command: `${hookCommandPrefix} hook ${event}`,
+    timeout: 5
+  };
+}
+function quotePath(p) {
+  return /[\s'"$`\\]/.test(p) ? `"${p.replace(/"/g, '\\"')}"` : p;
+}
+function installClaudeCodeHooks(hookCommandPrefix) {
+  mkdirSync2(CLAUDE_DIR, { recursive: true });
+  mkdirSync2(dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+  const backup = backupSettings();
+  const settings = readSettings();
+  settings.hooks ??= {};
+  for (const event of HOOK_EVENTS) {
+    const groups = settings.hooks[event] ?? [];
+    const filtered = groups.filter((g) => g.__agentreel !== HOOK_MARKER);
+    filtered.push({
+      matcher: ".*",
+      __agentreel: HOOK_MARKER,
+      hooks: [buildHookEntry(event, hookCommandPrefix)]
+    });
+    settings.hooks[event] = filtered;
+  }
+  writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return { backup, installedEvents: [...HOOK_EVENTS], hookCommandPrefix };
+}
+function uninstallClaudeCodeHooks() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return { backup: null };
+  const backup = backupSettings();
+  const settings = readSettings();
+  if (settings.hooks) {
+    for (const event of Object.keys(settings.hooks)) {
+      const groups = settings.hooks[event] ?? [];
+      const remaining = groups.filter((g) => g.__agentreel !== HOOK_MARKER);
+      if (remaining.length === 0) delete settings.hooks[event];
+      else settings.hooks[event] = remaining;
+    }
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  }
+  writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return { backup };
+}
+var HOOK_MARKER, HOOK_EVENTS;
+var init_install = __esm({
+  "src/hooks/install.ts"() {
+    "use strict";
+    init_paths();
+    HOOK_MARKER = "agentreel:v1";
+    HOOK_EVENTS = [
+      "SessionStart",
+      "SessionEnd",
+      "UserPromptSubmit",
+      "PreToolUse",
+      "PostToolUse",
+      "Notification",
+      "Stop",
+      "SubagentStop",
+      "PreCompact"
+    ];
+  }
+});
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+init_install();
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { sep } from "path";
+import pc from "picocolors";
+
+// src/config.ts
+init_paths();
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, chmodSync } from "fs";
+var DEFAULT = {
+  apiBaseUrl: "https://api.agentreel.dev",
+  schemaVersion: 1
+};
+function readConfig() {
+  if (!existsSync2(CONFIG_PATH)) return { ...DEFAULT };
+  try {
+    const raw = readFileSync2(CONFIG_PATH, "utf8");
+    return { ...DEFAULT, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT };
+  }
+}
+function writeConfig(cfg) {
+  ensureAgentreelDir();
+  writeFileSync2(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  try {
+    chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+
+// src/db.ts
+init_paths();
+import Database from "better-sqlite3";
+var _db = null;
+function getDb() {
+  if (_db) return _db;
+  ensureAgentreelDir();
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  migrate(db);
+  _db = db;
+  return db;
+}
+function migrate(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      tool TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      cwd TEXT,
+      total_cost_cents INTEGER,
+      total_tokens INTEGER
+    );
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      tool TEXT NOT NULL,
+      type TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      cwd TEXT,
+      payload TEXT NOT NULL,
+      uploaded_at INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id, ts);
+    CREATE INDEX IF NOT EXISTS idx_events_pending ON events(uploaded_at) WHERE uploaded_at IS NULL;
+  `);
+}
+function upsertSession(s) {
+  const db = getDb();
+  db.prepare(
+    `INSERT INTO sessions (id, tool, started_at, ended_at, cwd, total_cost_cents, total_tokens)
+     VALUES (@id, @tool, @startedAt, @endedAt, @cwd, @totalCostCents, @totalTokens)
+     ON CONFLICT(id) DO UPDATE SET
+       ended_at = COALESCE(excluded.ended_at, sessions.ended_at),
+       cwd = COALESCE(excluded.cwd, sessions.cwd),
+       total_cost_cents = COALESCE(excluded.total_cost_cents, sessions.total_cost_cents),
+       total_tokens = COALESCE(excluded.total_tokens, sessions.total_tokens)`
+  ).run({
+    id: s.id,
+    tool: s.tool,
+    startedAt: s.startedAt,
+    endedAt: s.endedAt ?? null,
+    cwd: s.cwd ?? null,
+    totalCostCents: s.totalCostCents ?? null,
+    totalTokens: s.totalTokens ?? null
+  });
+}
+function insertEvent(e) {
+  const db = getDb();
+  db.prepare(
+    `INSERT OR IGNORE INTO events (id, session_id, tool, type, ts, cwd, payload)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(e.id, e.sessionId, e.tool, e.type, e.ts, e.cwd ?? null, JSON.stringify(e.payload ?? {}));
+}
+function countEvents() {
+  const db = getDb();
+  const total = db.prepare(`SELECT COUNT(*) AS c FROM events`).get();
+  const pending = db.prepare(`SELECT COUNT(*) AS c FROM events WHERE uploaded_at IS NULL`).get();
+  return { total: total.c, pending: pending.c };
+}
+function listRecentSessions(limit = 10) {
+  const db = getDb();
+  return db.prepare(
+    `SELECT id, tool, started_at, ended_at, cwd
+       FROM sessions ORDER BY started_at DESC LIMIT ?`
+  ).all(limit);
+}
+
+// src/commands/init.ts
+init_paths();
+var PACKAGE_NAME = "@agentreel/agent";
+function resolveAgentBinary() {
+  const here = fileURLToPath(import.meta.url);
+  const real = realpathSync(here);
+  const isEphemeral = real.includes(`${sep}_npx${sep}`) || real.includes("/_npx/");
+  return { absolutePath: real, isEphemeral };
+}
+function chooseHookPrefix(bin) {
+  if (process.env.AGENTREEL_HOOK_COMMAND) {
+    return { prefix: process.env.AGENTREEL_HOOK_COMMAND, mode: "absolute" };
+  }
+  if (bin.isEphemeral) {
+    return { prefix: `npx -y ${PACKAGE_NAME}`, mode: "npx" };
+  }
+  return { prefix: quotePath(bin.absolutePath), mode: "absolute" };
+}
+async function initCommand() {
+  ensureAgentreelDir();
+  getDb();
+  const cfg = readConfig();
+  if (!cfg.installedAt) cfg.installedAt = Date.now();
+  cfg.hooksInstalled = true;
+  writeConfig(cfg);
+  const binary = resolveAgentBinary();
+  const { prefix, mode } = chooseHookPrefix(binary);
+  const result = installClaudeCodeHooks(prefix);
+  console.log(pc.bold(pc.cyan("\n  AgentReel  ")) + pc.dim("Loom for AI coding sessions\n"));
+  console.log(pc.green("\u2713") + " Created ~/.agentreel/sessions.db");
+  console.log(pc.green("\u2713") + " Wrote ~/.agentreel/config.json");
+  console.log(
+    pc.green("\u2713") + ` Installed ${result.installedEvents.length} Claude Code hooks \u2192 ~/.claude/settings.json`
+  );
+  if (result.backup) {
+    console.log(pc.dim(`  (backup: ${result.backup})`));
+  }
+  console.log();
+  console.log(pc.dim("  Hook command: ") + pc.dim(`${prefix} hook <Event>`));
+  if (mode === "npx") {
+    console.log(
+      pc.dim("  ") + pc.yellow("\u2022") + pc.dim(
+        ` Hooks resolve via npx every time Claude Code fires an event.
+    For faster cold starts, run: npm i -g ${PACKAGE_NAME}`
+      )
+    );
+  }
+  console.log();
+  console.log(pc.bold("Next:") + " open Claude Code and run a prompt.");
+  console.log("      then " + pc.cyan("agentreel status") + " to see captured events.\n");
+}
+
+// src/commands/status.ts
+init_paths();
+import pc2 from "picocolors";
+import { existsSync as existsSync3 } from "fs";
+function fmtDuration(ms) {
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+async function statusCommand() {
+  const cfg = readConfig();
+  console.log(pc2.bold(pc2.cyan("AgentReel status\n")));
+  console.log("  config:        " + (existsSync3(CONFIG_PATH) ? CONFIG_PATH : pc2.red("missing")));
+  console.log("  database:      " + (existsSync3(DB_PATH) ? DB_PATH : pc2.red("not initialized")));
+  console.log(
+    "  claude hooks:  " + (existsSync3(CLAUDE_SETTINGS_PATH) ? CLAUDE_SETTINGS_PATH : pc2.red("not installed"))
+  );
+  console.log("  api base:      " + cfg.apiBaseUrl);
+  console.log("  authenticated: " + (cfg.apiKey ? pc2.green("yes") : pc2.yellow("no")));
+  console.log();
+  if (!existsSync3(DB_PATH)) {
+    console.log(pc2.yellow("Run `agentreel init` to install hooks."));
+    return;
+  }
+  const { total, pending } = countEvents();
+  console.log(`  events captured:  ${total}`);
+  console.log(`  pending upload:   ${pending}`);
+  console.log();
+  const sessions = listRecentSessions(5);
+  if (sessions.length === 0) {
+    console.log(pc2.dim("  no sessions yet \u2014 start a Claude Code session to capture one."));
+    return;
+  }
+  console.log(pc2.bold("recent sessions:"));
+  for (const s of sessions) {
+    const dur = s.ended_at ? fmtDuration(s.ended_at - s.started_at) : pc2.dim("active");
+    const ts = new Date(s.started_at).toLocaleString();
+    console.log(`  ${pc2.dim(s.id.slice(0, 8))}  ${s.tool.padEnd(11)}  ${ts}  ${dur}`);
+  }
+}
+
+// src/commands/auth.ts
+import pc3 from "picocolors";
+
+// src/upload/client.ts
+async function postIngest(cfg, body) {
+  if (!cfg.apiKey) {
+    throw new Error("Not linked. Run: agentreel link <key>");
+  }
+  const url = `${cfg.apiBaseUrl.replace(/\/$/, "")}/api/v1/sessions/ingest`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${cfg.apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error(`Ingest returned ${res.status} with non-JSON body`);
+  }
+  if (!res.ok || !data.ok) {
+    throw new Error(
+      `Ingest failed: ${res.status} ${data.error ?? ""} ${data.reason ?? ""}`.trim()
+    );
+  }
+  return data;
+}
+
+// src/commands/auth.ts
+async function logoutCommand() {
+  const cfg = readConfig();
+  cfg.apiKey = void 0;
+  cfg.workspaceId = void 0;
+  writeConfig(cfg);
+  console.log(pc3.green("\u2713") + " Cleared local credentials.");
+}
+async function linkCommand(rawKey, opts) {
+  const key = (rawKey ?? await promptHidden("Paste your AgentReel API key: ")).trim();
+  if (!key) {
+    console.error(pc3.red("\u2717 No key provided."));
+    process.exit(1);
+  }
+  if (!key.startsWith("ar_live_")) {
+    console.error(pc3.red("\u2717 Keys start with `ar_live_`. Did you paste the right value?"));
+    process.exit(1);
+  }
+  const cfg = readConfig();
+  cfg.apiKey = key;
+  if (opts.api) cfg.apiBaseUrl = opts.api;
+  console.log(pc3.dim(`  validating against ${cfg.apiBaseUrl}\u2026`));
+  try {
+    await postIngest(cfg, {});
+  } catch (err) {
+    console.error(pc3.red("\u2717 Validation failed: ") + err.message);
+    process.exit(1);
+  }
+  writeConfig(cfg);
+  console.log(pc3.green("\u2713") + " Linked.");
+  console.log(pc3.dim("  api: ") + cfg.apiBaseUrl);
+  console.log(pc3.dim("  key: ") + key.slice(0, 12) + "\u2026");
+}
+async function uninstallCommand() {
+  const { uninstallClaudeCodeHooks: uninstallClaudeCodeHooks2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+  const { backup } = uninstallClaudeCodeHooks2();
+  console.log(pc3.green("\u2713") + " Removed AgentReel hooks from ~/.claude/settings.json");
+  if (backup) console.log(pc3.dim(`  (backup: ${backup})`));
+}
+var CTRL_C = 3;
+var BACKSPACE = 127;
+var BACKSPACE_ALT = 8;
+var NEWLINE = 10;
+var CARRIAGE = 13;
+function promptHidden(prompt) {
+  return new Promise((resolve2) => {
+    process.stdout.write(prompt);
+    let buf = "";
+    const stdin = process.stdin;
+    stdin.setRawMode?.(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        const code = ch.charCodeAt(0);
+        if (code === NEWLINE || code === CARRIAGE) {
+          stdin.setRawMode?.(false);
+          stdin.pause();
+          stdin.removeListener("data", onData);
+          process.stdout.write("\n");
+          return resolve2(buf);
+        }
+        if (code === CTRL_C) {
+          stdin.setRawMode?.(false);
+          process.exit(130);
+        }
+        if (code === BACKSPACE || code === BACKSPACE_ALT) {
+          buf = buf.slice(0, -1);
+        } else {
+          buf += ch;
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/commands/watch.ts
+import pc4 from "picocolors";
+import { existsSync as existsSync7 } from "fs";
+import { basename as basename2 } from "path";
+
+// src/cursor/paths.ts
+import { homedir as homedir2, platform } from "os";
+import { join as join2 } from "path";
+function defaultCursorHistoryDir() {
+  const home = homedir2();
+  switch (platform()) {
+    case "darwin":
+      return join2(home, "Library", "Application Support", "Cursor", "User", "History");
+    case "win32": {
+      const appData = process.env.APPDATA ?? join2(home, "AppData", "Roaming");
+      return join2(appData, "Cursor", "User", "History");
+    }
+    default:
+      return join2(home, ".config", "Cursor", "User", "History");
+  }
+}
+function cursorHistoryDir() {
+  return process.env.AGENTREEL_CURSOR_HISTORY_DIR ?? defaultCursorHistoryDir();
+}
+
+// src/cursor/watcher.ts
+import chokidar from "chokidar";
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { basename, dirname as dirname3, join as join5 } from "path";
+
+// src/cursor/entries.ts
+import { readFile } from "fs/promises";
+import { existsSync as existsSync4, statSync } from "fs";
+import { join as join3, dirname as dirname2, resolve, sep as sep2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function readEntries(historyFolder) {
+  const path = join3(historyFolder, "entries.json");
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resourceToPath(resource) {
+  if (!resource.startsWith("file://")) return null;
+  try {
+    return fileURLToPath2(resource);
+  } catch {
+    return null;
+  }
+}
+function findWorkspaceRoot(path) {
+  let dir = dirname2(resolve(path));
+  while (dir && dir !== sep2) {
+    const git = join3(dir, ".git");
+    try {
+      if (existsSync4(git)) return dir;
+    } catch {
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function isProbablyBinary(path) {
+  try {
+    const s = statSync(path);
+    if (s.size > 1024 * 1024) return true;
+  } catch {
+    return false;
+  }
+  const text = /\.(ts|tsx|js|jsx|mjs|cjs|json|jsonc|md|mdx|css|scss|html|xml|yaml|yml|toml|sh|bash|zsh|fish|py|rb|go|rs|java|kt|swift|c|cc|cpp|h|hpp|cs|php|sql|prisma|graphql|gql|env|gitignore|dockerfile|tf|hcl|lua|vue|svelte|astro|txt|csv|tsv|log|conf|ini)$/i;
+  return !text.test(path);
+}
+
+// src/cursor/diff.ts
+import { diffLines } from "diff";
+import DiffMatchPatch from "diff-match-patch";
+var dmp = new DiffMatchPatch.diff_match_patch();
+dmp.Diff_Timeout = 1;
+function computeDiff(before, after) {
+  const patches = dmp.patch_make(before, after);
+  const patch = dmp.patch_toText(patches);
+  let added = 0;
+  let removed = 0;
+  for (const part of diffLines(before, after)) {
+    const n = part.count ?? (part.value.match(/\n/g)?.length ?? (part.value.length > 0 ? 1 : 0));
+    if (part.added) added += n;
+    else if (part.removed) removed += n;
+  }
+  return { patch, added, removed };
+}
+
+// src/redact/ignore.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join4, relative, sep as sep3 } from "path";
+import ignore from "ignore";
+var FILENAME = ".agentreelignore";
+var TTL_MS = 5e3;
+var cache = /* @__PURE__ */ new Map();
+function loadFor(workspace) {
+  const path = join4(workspace, FILENAME);
+  if (!existsSync5(path)) return null;
+  try {
+    const raw = readFileSync3(path, "utf8");
+    return ignore({ allowRelativePaths: true }).add(raw);
+  } catch {
+    return null;
+  }
+}
+function getCached(workspace) {
+  const entry = cache.get(workspace);
+  const path = join4(workspace, FILENAME);
+  let mtime = 0;
+  try {
+    mtime = existsSync5(path) ? statSync2(path).mtimeMs : 0;
+  } catch {
+    mtime = 0;
+  }
+  const now = Date.now();
+  if (entry && now - entry.loadedAt < TTL_MS && entry.fileMtime === mtime) {
+    return entry.matcher;
+  }
+  const matcher = loadFor(workspace);
+  cache.set(workspace, { matcher, loadedAt: now, fileMtime: mtime });
+  return matcher;
+}
+function isIgnored(workspace, filePath) {
+  if (!workspace) return false;
+  const matcher = getCached(workspace);
+  if (!matcher) return false;
+  const rel = relative(workspace, filePath);
+  if (!rel || rel.startsWith("..") || rel.startsWith(sep3)) return false;
+  return matcher.ignores(rel.split(sep3).join("/"));
+}
+
+// src/redact/patterns.ts
+var PATTERNS = [
+  // PEM-encoded private keys (multiline, must run early)
+  {
+    name: "pem-private-key",
+    re: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+    replacement: "[REDACTED:private-key]"
+  },
+  // JWT (header.payload.signature) — eyJ-prefixed base64url segments
+  {
+    name: "jwt",
+    re: /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+    replacement: "[REDACTED:jwt]"
+  },
+  // GitHub fine-grained PATs (84 chars after prefix is the official format)
+  {
+    name: "github-fine-grained-pat",
+    re: /\bgithub_pat_[A-Za-z0-9_]{82,}\b/g,
+    replacement: "[REDACTED:gh-fine-pat]"
+  },
+  // GitHub OAuth, PAT, app, server, refresh tokens
+  {
+    name: "github-token",
+    re: /\bgh[pousr]_[A-Za-z0-9]{36,255}\b/g,
+    replacement: "[REDACTED:gh-token]"
+  },
+  // Anthropic
+  {
+    name: "anthropic-key",
+    re: /\bsk-ant-(?:api\d{2}-)?[A-Za-z0-9_-]{40,}\b/g,
+    replacement: "[REDACTED:anthropic-key]"
+  },
+  // OpenAI (sk-proj-..., sk-svcacct-..., legacy sk-...)
+  {
+    name: "openai-key",
+    re: /\bsk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{20,}\b/g,
+    replacement: "[REDACTED:openai-key]"
+  },
+  // Stripe
+  {
+    name: "stripe-secret",
+    re: /\bsk_(?:test|live)_[A-Za-z0-9]{16,}\b/g,
+    replacement: "[REDACTED:stripe-secret]"
+  },
+  {
+    name: "stripe-restricted",
+    re: /\brk_(?:test|live)_[A-Za-z0-9]{16,}\b/g,
+    replacement: "[REDACTED:stripe-restricted]"
+  },
+  {
+    name: "stripe-publishable",
+    re: /\bpk_(?:test|live)_[A-Za-z0-9]{16,}\b/g,
+    replacement: "[REDACTED:stripe-publishable]"
+  },
+  {
+    name: "stripe-webhook",
+    re: /\bwhsec_[A-Za-z0-9]{32,}\b/g,
+    replacement: "[REDACTED:stripe-webhook]"
+  },
+  // AWS access key IDs (and STS / temporary forms)
+  {
+    name: "aws-access-key-id",
+    re: /\b(?:AKIA|ASIA|AGPA|AROA|AIDA|ANPA|ANVA|AIPA)[0-9A-Z]{16}\b/g,
+    replacement: "[REDACTED:aws-key-id]"
+  },
+  // Slack tokens
+  {
+    name: "slack-token",
+    re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+    replacement: "[REDACTED:slack-token]"
+  },
+  // Google API keys
+  {
+    name: "google-api-key",
+    re: /\bAIza[A-Za-z0-9_-]{35}\b/g,
+    replacement: "[REDACTED:google-api-key]"
+  },
+  // npm tokens
+  {
+    name: "npm-token",
+    re: /\bnpm_[A-Za-z0-9]{36}\b/g,
+    replacement: "[REDACTED:npm-token]"
+  },
+  // dotenv-style KEY=VALUE on its own line, where the KEY name looks sensitive.
+  // This is a fallback for arbitrary secrets that don't match a specific
+  // provider pattern. Captures the key, replaces the value.
+  {
+    name: "dotenv-secret",
+    re: /^(\s*(?:export\s+)?[A-Z][A-Z0-9_]*?(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|API|AUTH|CREDENTIAL|PRIVATE|SESSION|COOKIE|BEARER|DSN)[A-Z0-9_]*\s*=\s*)(['"]?)([^\n'"]{4,})\2/gm,
+    replacement: (m) => {
+      const inner = /^(\s*(?:export\s+)?[A-Z][A-Z0-9_]*\s*=\s*)(['"]?)([^\n'"]{4,})\2/.exec(m);
+      if (!inner) return "[REDACTED:dotenv-secret]";
+      const [, prefix, quote] = inner;
+      return `${prefix ?? ""}${quote ?? ""}[REDACTED:dotenv-secret]${quote ?? ""}`;
+    }
+  },
+  // Email addresses
+  {
+    name: "email",
+    re: /\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b/g,
+    replacement: "[REDACTED:email]"
+  },
+  // IPv4 — validates each octet is 0-255 to cut version-string false positives.
+  // Skips three benign forms below in the post-filter.
+  {
+    name: "ipv4",
+    re: /\b(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\b/g,
+    replacement: (m) => {
+      if (m === "0.0.0.0" || m === "127.0.0.1" || m === "255.255.255.255") return m;
+      return "[REDACTED:ip]";
+    }
+  }
+];
+var SENSITIVE_KEY_RE = /(?:^|[_\-.])(?:api[_-]?key|access[_-]?token|secret|password|passwd|pwd|authorization|bearer|credential|private[_-]?key|client[_-]?secret|webhook[_-]?secret|service[_-]?account|refresh[_-]?token)(?:$|[_\-.])/i;
+
+// src/redact/scrubber.ts
+function scrubString(input) {
+  if (!input) return input;
+  let s = input;
+  for (const rule of PATTERNS) {
+    if (typeof rule.replacement === "function") {
+      s = s.replace(rule.re, rule.replacement);
+    } else {
+      s = s.replace(rule.re, rule.replacement);
+    }
+  }
+  return s;
+}
+function scrubAny(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value == null) return value;
+  if (typeof value === "string") return scrubString(value);
+  if (typeof value !== "object") return value;
+  if (seen.has(value)) return value;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((v) => scrubAny(v, seen));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (SENSITIVE_KEY_RE.test(k) && typeof v === "string" && v.length >= 4) {
+      out[k] = "[REDACTED:by-key-name]";
+    } else {
+      out[k] = scrubAny(v, seen);
+    }
+  }
+  return out;
+}
+
+// src/cursor/watcher.ts
+function startCursorWatcher(historyDir, onSnapshot, opts = {}) {
+  const skipFirst = opts.skipFirstObservation ?? true;
+  const watcher = chokidar.watch(historyDir, {
+    ignoreInitial: true,
+    depth: 2,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 120, pollInterval: 40 }
+  });
+  watcher.on("add", async (path) => {
+    try {
+      const folder = dirname3(path);
+      const file = basename(path);
+      if (file === "entries.json") return;
+      const ctx = await waitForEntry(folder, file, 2e3);
+      if (!ctx) return;
+      await processSnapshot(folder, ctx, skipFirst, onSnapshot);
+    } catch (err) {
+      console.error("[agentreel] cursor watcher: error processing", path, err);
+    }
+  });
+  return watcher;
+}
+async function waitForEntry(folder, fileId, totalMs) {
+  const start = Date.now();
+  while (Date.now() - start < totalMs) {
+    const file = await readEntries(folder);
+    if (file) {
+      const idx = file.entries.findIndex((e) => e.id === fileId);
+      if (idx >= 0) {
+        const current = file.entries[idx];
+        if (!current) return null;
+        const previous = idx > 0 ? file.entries[idx - 1] ?? null : null;
+        return { resource: file.resource, current, previous, currentIdx: idx };
+      }
+    }
+    await sleep(150);
+  }
+  return null;
+}
+async function processSnapshot(folder, ctx, skipFirst, onSnapshot) {
+  const filePath = resourceToPath(ctx.resource);
+  if (!filePath) return;
+  if (NOISY_PATH.test(filePath)) return;
+  const workspace = findWorkspaceRoot(filePath);
+  if (isIgnored(workspace, filePath)) return;
+  if (!ctx.previous) {
+    if (skipFirst) return;
+  }
+  const newSnapshot = join5(folder, ctx.current.id);
+  let before = "";
+  let after = "";
+  if (ctx.previous) {
+    const prevPath = join5(folder, ctx.previous.id);
+    if (existsSync6(prevPath)) {
+      before = await safeRead(prevPath);
+    }
+  }
+  if (existsSync6(newSnapshot)) {
+    after = await safeRead(newSnapshot);
+  }
+  if (before === after) return;
+  const binary = isProbablyBinary(filePath);
+  let patch = "";
+  let added = 0;
+  let removed = 0;
+  if (!binary) {
+    const beforeSafe = scrubString(before);
+    const afterSafe = scrubString(after);
+    const result = computeDiff(beforeSafe, afterSafe);
+    patch = result.patch;
+    added = result.added;
+    removed = result.removed;
+  }
+  const source = classifySource(ctx.current.source);
+  onSnapshot({
+    filePath,
+    workspace,
+    source,
+    timestamp: ctx.current.timestamp ?? Date.now(),
+    patch,
+    added,
+    removed,
+    binary
+  });
+}
+function classifySource(raw) {
+  if (!raw) return "cursor-manual";
+  const s = raw.toLowerCase();
+  if (s.includes("composer") || s.includes("ai") || s.includes("chat")) return "cursor-ai";
+  return "cursor-manual";
+}
+async function safeRead(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var NOISY_PATH = /[\\/](node_modules|\.next|\.turbo|dist|build|\.git|coverage|\.cache|\.venv|venv|target|out)[\\/]/;
+
+// src/cursor/session.ts
+import { nanoid } from "nanoid";
+var IDLE_MS = 5 * 60 * 1e3;
+var GLOBAL_KEY = "__global__";
+var CursorSessionManager = class {
+  open = /* @__PURE__ */ new Map();
+  ingest(snapshot) {
+    const key = snapshot.workspace ?? GLOBAL_KEY;
+    const ts = snapshot.timestamp;
+    const cwd = snapshot.workspace ?? "";
+    let session = this.open.get(key);
+    let isNew = false;
+    if (!session || ts - session.lastTs > IDLE_MS) {
+      if (session) this.closeSession(session, session.lastTs);
+      session = {
+        id: `cur_${nanoid(10)}`,
+        startedAt: ts,
+        lastTs: ts,
+        cwd
+      };
+      this.open.set(key, session);
+      isNew = true;
+      upsertSession({
+        id: session.id,
+        tool: "cursor",
+        startedAt: ts,
+        cwd
+      });
+    } else {
+      session.lastTs = ts;
+    }
+    const event = {
+      id: nanoid(),
+      sessionId: session.id,
+      tool: "cursor",
+      type: "tool_use_post",
+      ts,
+      cwd,
+      payload: {
+        tool_name: "Edit",
+        file_path: snapshot.filePath,
+        added: snapshot.added,
+        removed: snapshot.removed,
+        binary: snapshot.binary,
+        source: snapshot.source,
+        patch: snapshot.patch
+      }
+    };
+    insertEvent(event);
+    return { sessionId: session.id, isNew };
+  }
+  /** Stamp ended_at on every open session — call on shutdown. */
+  closeAll() {
+    const now = Date.now();
+    for (const s of this.open.values()) this.closeSession(s, Math.max(s.lastTs, now));
+    this.open.clear();
+  }
+  closeSession(s, endedAt) {
+    upsertSession({
+      id: s.id,
+      tool: "cursor",
+      startedAt: s.startedAt,
+      endedAt,
+      cwd: s.cwd
+    });
+  }
+};
+
+// src/commands/watch.ts
+init_paths();
+async function watchCommand() {
+  ensureAgentreelDir();
+  getDb();
+  const dir = cursorHistoryDir();
+  if (!existsSync7(dir)) {
+    console.error(pc4.red("\u2717 Cursor history directory not found:"));
+    console.error("  " + dir);
+    console.error();
+    console.error(pc4.dim("Open Cursor at least once, edit a file, then re-run."));
+    console.error(pc4.dim("(Or set AGENTREEL_CURSOR_HISTORY_DIR to a custom path.)"));
+    process.exit(1);
+  }
+  console.log(pc4.bold(pc4.cyan("AgentReel \xB7 Cursor watcher\n")));
+  console.log(pc4.dim("  watching ") + dir);
+  console.log(pc4.dim("  press Ctrl+C to stop\n"));
+  const sessions = new CursorSessionManager();
+  const watcher = startCursorWatcher(dir, async (snap) => {
+    const { sessionId, isNew } = sessions.ingest(snap);
+    const ts = new Date(snap.timestamp).toLocaleTimeString();
+    const ws = snap.workspace ? basename2(snap.workspace) : pc4.dim("no-workspace");
+    const file = snap.filePath.split("/").slice(-2).join("/");
+    const sourceLabel = snap.source === "cursor-ai" ? pc4.magenta("ai") : snap.source === "cursor-manual" ? pc4.cyan("man") : pc4.dim("?");
+    const stats = snap.binary ? pc4.dim("binary") : `${pc4.green("+" + snap.added)} ${pc4.red("-" + snap.removed)}`;
+    if (isNew) {
+      console.log(
+        `${pc4.dim(ts)}  ${pc4.yellow("session")}  ${pc4.dim(sessionId)}  ${ws}`
+      );
+    }
+    console.log(`${pc4.dim(ts)}  edit     ${sourceLabel}  ${file.padEnd(36)}  ${stats}`);
+  });
+  const shutdown = async () => {
+    console.log(pc4.dim("\n  closing sessions\u2026"));
+    sessions.closeAll();
+    await watcher.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+// src/commands/push.ts
+import pc5 from "picocolors";
+
+// src/upload/queue.ts
+function takePendingBatch(maxEvents = 500) {
+  const db = getDb();
+  const eventRows = db.prepare(
+    `SELECT id, session_id, tool, type, ts, cwd, payload
+       FROM events
+       WHERE uploaded_at IS NULL
+       ORDER BY ts ASC
+       LIMIT ?`
+  ).all(maxEvents);
+  if (eventRows.length === 0) return { sessions: [], events: [], eventIds: [] };
+  const sessionIds = [...new Set(eventRows.map((e) => e.session_id))];
+  const placeholders = sessionIds.map(() => "?").join(",");
+  const sessionRows = db.prepare(
+    `SELECT id, tool, started_at, ended_at, cwd, total_cost_cents, total_tokens
+       FROM sessions WHERE id IN (${placeholders})`
+  ).all(...sessionIds);
+  const sessions = sessionRows.map((s) => ({
+    id: s.id,
+    tool: s.tool,
+    started_at: s.started_at,
+    ended_at: s.ended_at,
+    cwd: s.cwd,
+    total_cost_cents: s.total_cost_cents,
+    total_tokens: s.total_tokens
+  }));
+  const events = eventRows.map((e) => ({
+    id: e.id,
+    session_id: e.session_id,
+    ts: e.ts,
+    type: e.type,
+    tool: e.tool,
+    cwd: e.cwd,
+    payload: safeParse(e.payload)
+  }));
+  return { sessions, events, eventIds: eventRows.map((r) => r.id) };
+}
+function markUploaded(eventIds) {
+  if (eventIds.length === 0) return;
+  const db = getDb();
+  const now = Date.now();
+  const stmt = db.prepare(`UPDATE events SET uploaded_at = ? WHERE id = ?`);
+  const tx = db.transaction((ids) => {
+    for (const id of ids) stmt.run(now, id);
+  });
+  tx(eventIds);
+}
+function safeParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+
+// src/commands/push.ts
+async function pushCommand() {
+  const cfg = readConfig();
+  if (!cfg.apiKey) {
+    console.error(pc5.red("\u2717 Not linked. Run ") + pc5.cyan("agentreel link <api-key>"));
+    process.exit(1);
+  }
+  let totalSessions = 0;
+  let totalEvents = 0;
+  while (true) {
+    const batch = takePendingBatch(500);
+    if (batch.events.length === 0) break;
+    console.log(
+      pc5.dim(`  uploading ${batch.events.length} events across ${batch.sessions.length} sessions\u2026`)
+    );
+    const res = await postIngest(cfg, { sessions: batch.sessions, events: batch.events });
+    markUploaded(batch.eventIds);
+    totalSessions += res.sessions_written ?? 0;
+    totalEvents += res.events_written ?? 0;
+  }
+  if (totalEvents === 0) {
+    console.log(pc5.green("\u2713") + " queue is empty \u2014 nothing to upload.");
+    return;
+  }
+  console.log(
+    pc5.green("\u2713") + ` uploaded ${totalEvents} events \xB7 ${totalSessions} session rows touched`
+  );
+}
+
+// src/hooks/handler.ts
+import { nanoid as nanoid2 } from "nanoid";
+import { appendFileSync } from "fs";
+init_paths();
+var HOOK_EVENT_TO_TYPE = {
+  SessionStart: "session_start",
+  SessionEnd: "session_end",
+  UserPromptSubmit: "user_prompt_submit",
+  PreToolUse: "tool_use_pre",
+  PostToolUse: "tool_use_post",
+  Notification: "notification",
+  Stop: "stop",
+  SubagentStop: "subagent_stop",
+  PreCompact: "pre_compact"
+};
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function logError(err) {
+  try {
+    ensureAgentreelDir();
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] hook error: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`;
+    appendFileSync(LOG_PATH, line);
+  } catch {
+  }
+}
+async function runHook(eventArg) {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) return;
+    const input = JSON.parse(raw);
+    const hookEventName = input.hook_event_name ?? eventArg ?? "Unknown";
+    const type = HOOK_EVENT_TO_TYPE[hookEventName] ?? "unknown";
+    const ts = Date.now();
+    const sessionId = input.session_id ?? "unknown-session";
+    if (type === "session_start") {
+      upsertSession({
+        id: sessionId,
+        tool: "claude-code",
+        startedAt: ts,
+        cwd: input.cwd
+      });
+    } else if (type === "session_end") {
+      upsertSession({
+        id: sessionId,
+        tool: "claude-code",
+        startedAt: ts,
+        endedAt: ts,
+        cwd: input.cwd
+      });
+    } else {
+      upsertSession({
+        id: sessionId,
+        tool: "claude-code",
+        startedAt: ts,
+        cwd: input.cwd
+      });
+    }
+    const safePayload = scrubAny(input);
+    const event = {
+      id: nanoid2(),
+      sessionId,
+      tool: "claude-code",
+      type,
+      ts,
+      cwd: input.cwd,
+      payload: safePayload
+    };
+    insertEvent(event);
+  } catch (err) {
+    logError(err);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("agentreel").description("AgentReel \u2014 capture Claude Code and Cursor sessions locally").version("0.0.0");
+program.command("init").description("install Claude Code hooks and create the local SQLite buffer").action(async () => {
+  await initCommand();
+});
+program.command("status").description("show local capture status, recent sessions, queue depth").action(async () => {
+  await statusCommand();
+});
+program.command("watch").description("watch Cursor's local history and capture edits as events").action(async () => {
+  await watchCommand();
+});
+program.command("link [api-key]").description("authenticate the local agent with agentreel.dev").option("--api <url>", "override the API base URL (default https://api.agentreel.dev)").action(async (apiKey, opts) => {
+  await linkCommand(apiKey, opts);
+});
+program.command("push").description("upload pending events to agentreel.dev").action(async () => {
+  await pushCommand();
+});
+program.command("logout").description("clear local credentials").action(async () => {
+  await logoutCommand();
+});
+program.command("uninstall").description("remove AgentReel hooks from ~/.claude/settings.json").action(async () => {
+  await uninstallCommand();
+});
+program.command("hook <event>").description("internal: hook handler invoked by Claude Code (reads JSON from stdin)").action(async (event) => {
+  await runHook(event);
+});
+program.parseAsync(process.argv).catch((err) => {
+  const cmd = process.argv[2];
+  if (cmd === "hook") {
+    process.exit(0);
+  }
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map