evrex-mcp 0.3.0 → 0.5.0

package/dist/capture.js

@@ -0,0 +1,1012 @@
+#!/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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  evrexApi: () => evrexApi
+});
+function headers() {
+  const base = { "Content-Type": "application/json" };
+  if (EVREX_TOKEN) base.Authorization = `Bearer ${EVREX_TOKEN}`;
+  return base;
+}
+function describeFailure(method, path, status, statusText) {
+  if (status === 401 || status === 403) {
+    return EVREX_TOKEN ? `${method} ${path} -> ${status}: the EVREX_TOKEN this server was started with was rejected. It may be revoked or expired.` : `${method} ${path} -> ${status}: this evrex backend requires a credential, but no EVREX_TOKEN is set for this MCP server.`;
+  }
+  return `${method} ${path} -> ${status} ${statusText}`;
+}
+async function request(method, path, { body, absentIsAnswer } = {}) {
+  const res = await fetch(`${API_BASE_URL}${path}`, {
+    method,
+    headers: headers(),
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+  if (res.status === 404 && absentIsAnswer) return null;
+  if (!res.ok) throw new Error(describeFailure(method, path, res.status, res.statusText));
+  return await res.json();
+}
+var DEFAULT_API_BASE_URL, API_BASE_URL, EVREX_TOKEN, get, getOrNull, post, evrexApi;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    DEFAULT_API_BASE_URL = "https://api.evrex.ai";
+    API_BASE_URL = (process.env.EVREX_API_BASE_URL ?? process.env.EVREX_API_URL ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+    EVREX_TOKEN = process.env.EVREX_TOKEN ?? process.env.EVREX_API_TOKEN ?? null;
+    get = (path) => request("GET", path);
+    getOrNull = (path) => request("GET", path, { absentIsAnswer: true });
+    post = (path, body) => request("POST", path, { body });
+    evrexApi = {
+      baseUrl: API_BASE_URL,
+      repos: () => get("/repos"),
+      commits: (repoPath) => get(`/commits?repoPath=${encodeURIComponent(repoPath)}`),
+      // Abbreviated shas resolve server-side, so a value pasted from `git log`
+      // works here (apps/backend/src/reads/reads.service.ts#resolveSha).
+      commit: (sha) => getOrNull(`/commits/${encodeURIComponent(sha)}`),
+      sessions: (repoPath) => get(`/sessions?repoPath=${encodeURIComponent(repoPath)}`),
+      session: (id) => getOrNull(`/sessions/${encodeURIComponent(id)}`),
+      ask: (repoPath, text, filePaths) => post("/ask", { repoPath, text, filePaths }),
+      // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
+      // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
+      // which wants ranked hits fast, not a synthesized paragraph.
+      search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths })
+    };
+  }
+});
+
+// src/capture.ts
+import { statSync as statSync3 } from "node:fs";
+import { homedir as homedir2, hostname } from "node:os";
+import { join as join2 } from "node:path";
+
+// ../../packages/ingest-core/src/git-history.ts
+import { execFileSync } from "node:child_process";
+function gitQuiet(repoPath, args) {
+  return execFileSync("git", args, {
+    cwd: repoPath,
+    maxBuffer: 1024 * 1024 * 8,
+    stdio: ["ignore", "pipe", "ignore"]
+  }).toString("utf-8");
+}
+function normalizeRepoRemote(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  let host;
+  let path;
+  const scpLike = /^(?:[^/@]+@)?([^/:@]+\.[^/:@]+):(?!\/)(.+)$/.exec(trimmed);
+  if (scpLike?.[1] && scpLike[2]) {
+    host = scpLike[1];
+    path = scpLike[2];
+  } else {
+    let parsed;
+    try {
+      parsed = new URL(trimmed);
+    } catch {
+      return null;
+    }
+    if (parsed.protocol === "file:" || !parsed.hostname) return null;
+    host = parsed.hostname;
+    path = parsed.pathname;
+  }
+  const cleanedPath = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+  if (!cleanedPath) return null;
+  return `${host}/${cleanedPath}`.toLowerCase();
+}
+function repoIdFromRemote(url) {
+  const normalized = normalizeRepoRemote(url);
+  return normalized ? `remote:${normalized}` : null;
+}
+function repoIdFromRootCommit(sha) {
+  return `root:${sha}`;
+}
+function repoIdFromPath(repoPath) {
+  return `path:${repoPath}`;
+}
+function firstRemoteUrl(repoPath) {
+  try {
+    const origin = gitQuiet(repoPath, ["remote", "get-url", "origin"]).trim();
+    if (origin) return origin;
+  } catch {
+  }
+  try {
+    const names = gitQuiet(repoPath, ["remote"]).split("\n").map((n) => n.trim()).filter(Boolean).sort();
+    for (const name of names) {
+      const url = gitQuiet(repoPath, ["remote", "get-url", name]).trim();
+      if (url) return url;
+    }
+  } catch {
+  }
+  return null;
+}
+function rootCommitSha(repoPath) {
+  try {
+    const shas = gitQuiet(repoPath, ["rev-list", "--max-parents=0", "HEAD"]).split("\n").map((s) => s.trim()).filter(Boolean).sort();
+    return shas[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function deriveRepoId(repoPath) {
+  const remote = firstRemoteUrl(repoPath);
+  if (remote) {
+    const fromRemote = repoIdFromRemote(remote);
+    if (fromRemote) return fromRemote;
+  }
+  const root = rootCommitSha(repoPath);
+  if (root) return repoIdFromRootCommit(root);
+  return repoIdFromPath(repoPath);
+}
+
+// ../../packages/ingest-core/src/claude-sessions.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+
+// ../../packages/ingest-core/src/redact.ts
+var PATTERNS = [
+  { type: "private_key", regex: /-----BEGIN(?: [A-Z]+)? PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z]+)? PRIVATE KEY-----/g },
+  { type: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/g },
+  { type: "github_token", regex: /gh[pousr]_[A-Za-z0-9]{36,}/g },
+  { type: "slack_token", regex: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
+  { type: "stripe_key", regex: /sk_(live|test)_[A-Za-z0-9]{24,}/g },
+  { type: "openai_key", regex: /sk-[A-Za-z0-9]{20,}/g },
+  { type: "anthropic_key", regex: /sk-ant-[A-Za-z0-9-_]{20,}/g },
+  { type: "jwt", regex: /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g },
+  { type: "bearer_token", regex: /Bearer\s+[A-Za-z0-9\-_.]{20,}/g },
+  {
+    type: "env_secret",
+    regex: /\b([A-Z0-9_]*(?:_KEY|_SECRET|_TOKEN|_PASSWORD|PASSWD)[A-Z0-9_]*)\s*[:=]\s*["']?[^\s"'\n]{6,}["']?/g
+  }
+];
+function redactJsonValue(value) {
+  let count = 0;
+  const walk = (v) => {
+    if (typeof v === "string") {
+      const r = redactSecrets(v);
+      count += r.count;
+      return r.text;
+    }
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, val] of Object.entries(v)) {
+        out[k] = walk(val);
+      }
+      return out;
+    }
+    return v;
+  };
+  return { value: walk(value), count };
+}
+function redactSecrets(input) {
+  let text = input;
+  let count = 0;
+  for (const { type, regex } of PATTERNS) {
+    text = text.replace(regex, (match, group1) => {
+      count += 1;
+      if (type === "env_secret" && group1) {
+        return `${group1}=[REDACTED:${type}]`;
+      }
+      return `[REDACTED:${type}]`;
+    });
+  }
+  return { text, count };
+}
+
+// ../../packages/ingest-core/src/subject-linking.ts
+function committedSubjects(command) {
+  const out = [];
+  const invocation = /\bgit\s+(?:-C\s+\S+\s+)?commit\b/g;
+  for (let found = invocation.exec(command); found !== null; found = invocation.exec(command)) {
+    const rest = command.slice(found.index + found[0].length);
+    const heredoc = /^[^\n]*<<-?\s*(['"]?)(\w+)\1[^\n]*\r?\n([^\n]*)/.exec(rest);
+    if (heredoc) {
+      const subject = heredoc[3].trim();
+      if (subject) out.push(subject);
+      continue;
+    }
+    const inline = /^[^\n]*?-m\s+(['"])([\s\S]*?)\1/.exec(rest);
+    if (inline) {
+      const subject = inline[2].split("\n")[0].trim();
+      if (subject) out.push(subject);
+    }
+  }
+  return out;
+}
+
+// ../../packages/ingest-core/src/types.ts
+var CONVERSATION_KINDS = [
+  "claude-code",
+  "cursor",
+  "codex",
+  "gemini",
+  "slack"
+];
+var REFERENCE_KINDS = ["linear", "jira", "confluence"];
+var SOURCE_KINDS = [
+  ...CONVERSATION_KINDS,
+  ...REFERENCE_KINDS
+];
+var EMPTY_USAGE = {
+  inputTokens: null,
+  outputTokens: null,
+  cacheReadTokens: null,
+  cacheWriteTokens: null,
+  model: null
+};
+
+// ../../packages/ingest-core/src/claude-sessions.ts
+var MIN_MEANINGFUL_LINE_LENGTH = 6;
+function meaningfulLines(lines) {
+  return lines.map((l) => l.trim()).filter((l) => l.length >= MIN_MEANINGFUL_LINE_LENGTH);
+}
+function extractEditedLines(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return null;
+  const r = toolUseResult;
+  if (!r.filePath) return null;
+  const added = [];
+  const removed = [];
+  if (Array.isArray(r.structuredPatch) && r.structuredPatch.length > 0) {
+    for (const hunk of r.structuredPatch) {
+      for (const line of hunk.lines ?? []) {
+        if (line.startsWith("+")) added.push(line.slice(1));
+        else if (line.startsWith("-")) removed.push(line.slice(1));
+      }
+    }
+  } else if (r.type === "create" && typeof r.content === "string") {
+    added.push(...r.content.split("\n"));
+  } else {
+    return null;
+  }
+  const meaningfulAdded = meaningfulLines(added);
+  const meaningfulRemoved = meaningfulLines(removed);
+  if (meaningfulAdded.length === 0 && meaningfulRemoved.length === 0) return null;
+  return { path: r.filePath, added: meaningfulAdded, removed: meaningfulRemoved };
+}
+var MAX_TURN_TEXT_LENGTH = 4e3;
+var FILE_PATH_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "NotebookEdit"]);
+var PATH_TOKEN_RE = /(?:[.~]?\/)?(?:[\w-]+\/)+[\w.-]+/g;
+function extractPathsFromText(text) {
+  const matches = text.match(PATH_TOKEN_RE) ?? [];
+  return [...new Set(matches)].filter((p) => p.length > 3 && p.length < 300);
+}
+function blockText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => typeof c === "string" ? c : c?.text ?? "").filter(Boolean).join("\n");
+  }
+  return "";
+}
+function extractFromAssistantContent(content) {
+  const textParts = [];
+  const filesTouched = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      textParts.push(block.text);
+      for (const p of extractPathsFromText(block.text)) {
+        filesTouched.push({ path: p, source: "prose" });
+      }
+    } else if (block.type === "tool_use") {
+      const name = block.name ?? "tool";
+      const input = block.input ?? {};
+      if (FILE_PATH_TOOLS.has(name) && typeof input.file_path === "string") {
+        textParts.push(`[tool_call: ${name}] ${input.file_path}`);
+        filesTouched.push({ path: input.file_path, source: "tool_path", tool: name });
+      } else if (name === "Bash" && typeof input.command === "string") {
+        const desc = typeof input.description === "string" ? input.description : input.command;
+        textParts.push(`[tool_call: Bash] ${desc}`);
+        for (const p of extractPathsFromText(input.command)) {
+          filesTouched.push({ path: p, source: "tool_bash", tool: "Bash" });
+        }
+      } else {
+        textParts.push(`[tool_call: ${name}]`);
+      }
+    }
+  }
+  return { text: textParts.join("\n"), filesTouched };
+}
+var SYNTHETIC_CONTENT_RE = /^\s*(<task-notification>|<system-reminder>|\[SYSTEM NOTIFICATION)/;
+function extractFromUserContent(content) {
+  if (typeof content === "string") {
+    return {
+      text: content,
+      filesTouched: extractPathsFromText(content).map((path) => ({ path, source: "prose" })),
+      isSyntheticInput: SYNTHETIC_CONTENT_RE.test(content)
+    };
+  }
+  if (Array.isArray(content)) {
+    const toolParts = [];
+    const textParts = [];
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        toolParts.push(blockText(block.content));
+      } else if (block.type === "text" && typeof block.text === "string") {
+        textParts.push(block.text);
+      }
+    }
+    if (toolParts.length > 0) {
+      return {
+        text: toolParts.join("\n"),
+        filesTouched: [],
+        isSyntheticInput: true
+      };
+    }
+    const text = textParts.join("\n");
+    return {
+      text,
+      // Same treatment the string branch gives prose, so a path a person
+      // names in a block-formatted message is found too.
+      filesTouched: extractPathsFromText(text).map((path) => ({
+        path,
+        source: "prose"
+      })),
+      isSyntheticInput: SYNTHETIC_CONTENT_RE.test(text)
+    };
+  }
+  return { text: "", filesTouched: [], isSyntheticInput: false };
+}
+function usageOnce(record, billed) {
+  const message = record.message;
+  const raw = message?.usage;
+  if (!raw || typeof raw !== "object") return { ...EMPTY_USAGE };
+  const messageId = message?.id;
+  if (!messageId || billed.has(messageId)) return { ...EMPTY_USAGE };
+  billed.add(messageId);
+  const num = (key) => {
+    const value = raw[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  };
+  return {
+    inputTokens: num("input_tokens"),
+    outputTokens: num("output_tokens"),
+    cacheReadTokens: num("cache_read_input_tokens"),
+    cacheWriteTokens: num("cache_creation_input_tokens"),
+    model: typeof message?.model === "string" ? message.model : null
+  };
+}
+function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
+  const raw = readFileSync(filePath, "utf-8");
+  const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+  const turns = [];
+  const billedMessages = /* @__PURE__ */ new Set();
+  let sessionId = null;
+  const cwd = repoPath;
+  let aiTitle = null;
+  let totalRedactions = 0;
+  for (const line of lines) {
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.type === "ai-title" && typeof record.aiTitle === "string") {
+      aiTitle = record.aiTitle;
+      continue;
+    }
+    if (record.type !== "user" && record.type !== "assistant") continue;
+    const id = record.uuid;
+    const ts = record.timestamp;
+    if (!id || !ts) continue;
+    sessionId ??= record.sessionId ?? record.session_id ?? null;
+    let text = "";
+    let filesTouched = [];
+    let editedLines = [];
+    let isSyntheticInput = false;
+    if (record.type === "assistant") {
+      const content = record.message?.content;
+      if (Array.isArray(content)) {
+        const extracted = extractFromAssistantContent(content);
+        text = extracted.text;
+        filesTouched = extracted.filesTouched;
+      }
+    } else {
+      const extracted = extractFromUserContent(record.message?.content);
+      text = extracted.text;
+      filesTouched = extracted.filesTouched;
+      isSyntheticInput = extracted.isSyntheticInput;
+      const edited = extractEditedLines(record.toolUseResult);
+      if (edited) editedLines = [edited];
+    }
+    const redacted = redactSecrets(text);
+    totalRedactions += redacted.count;
+    turns.push({
+      id,
+      sessionId: sessionId ?? "unknown",
+      role: record.type,
+      ts,
+      text: redacted.text.slice(0, MAX_TURN_TEXT_LENGTH),
+      filesTouched,
+      editedLines,
+      parentUuid: record.parentUuid ?? null,
+      isSidechain: Boolean(record.isSidechain),
+      redacted: redacted.count > 0,
+      isSyntheticInput,
+      usage: usageOnce(record, billedMessages)
+    });
+  }
+  if (!sessionId || turns.length === 0) return null;
+  const sortedTs = turns.map((t) => t.ts).sort();
+  const rawContent = lines.map((line) => {
+    try {
+      return JSON.stringify(redactJsonValue(JSON.parse(line)).value);
+    } catch {
+      return redactSecrets(line).text;
+    }
+  }).join("\n");
+  if (totalRedactions > 0) {
+    console.log(`[ingest-core] redacted ${totalRedactions} potential secret(s) in session ${sessionId}`);
+  }
+  return {
+    id: sessionId,
+    agentKind: "claude-code",
+    repoId,
+    cwd,
+    startedAt: sortedTs[0] ?? null,
+    endedAt: sortedTs[sortedTs.length - 1] ?? null,
+    turnCount: turns.length,
+    aiTitle,
+    author: null,
+    // filled in by the caller — see getGitUserName in git-history.ts
+    sourceFile: filePath,
+    redactionCount: totalRedactions,
+    committedSubjects: collectCommittedSubjects(lines),
+    rawContent,
+    rawFormat: "jsonl",
+    turns
+  };
+}
+function collectCommittedSubjects(lines) {
+  const subjects = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (!line.includes("git commit")) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const content = record?.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (block?.type !== "tool_use") continue;
+      const command = block?.input?.command;
+      if (typeof command !== "string") continue;
+      for (const subject of committedSubjects(command)) subjects.add(subject);
+    }
+  }
+  return [...subjects];
+}
+
+// ../../packages/ingest-core/src/derive-uuid.ts
+import { createHash } from "node:crypto";
+function deriveUuid(name) {
+  const h = createHash("sha1").update(name).digest("hex");
+  const variant = (parseInt(h.slice(16, 17) || "0", 16) & 3 | 8).toString(16);
+  const s = h.slice(0, 12) + // time-low + time-mid
+  "5" + // version 5 (name-based, SHA-1)
+  h.slice(13, 16) + variant + h.slice(17, 32);
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+}
+
+// ../../packages/ingest-core/src/codex-sessions.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+function deriveUuid2(name) {
+  const h = createHash2("sha1").update(name).digest("hex");
+  const variant = (parseInt(h.slice(16, 17) || "0", 16) & 3 | 8).toString(16);
+  const s = h.slice(0, 12) + "5" + h.slice(13, 16) + variant + h.slice(17, 32);
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+}
+function deriveCodexTurnId(sessionId, ordinal) {
+  return deriveUuid2(`evrex-codex-turn\0${sessionId}\0${ordinal}`);
+}
+function parseLines(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+function payloadType(line) {
+  const t = line.payload?.type;
+  return typeof t === "string" ? t : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function conversationEvents(lines) {
+  const out = [];
+  let pending = null;
+  let model = null;
+  lines.forEach((line, index) => {
+    if (line.type === "turn_context") {
+      model = asString(line.payload?.model) ?? model;
+      return;
+    }
+    if (line.type !== "event_msg") return;
+    const kind = payloadType(line);
+    if (kind === "token_count") {
+      const delta = lastUsage(line.payload);
+      if (delta) pending = addUsage(pending, delta);
+      return;
+    }
+    if (kind !== "user_message" && kind !== "agent_message") return;
+    const text = asString(line.payload?.message);
+    if (!text) return;
+    const role = kind === "user_message" ? "user" : "assistant";
+    const usage = role === "assistant" && pending ? { ...pending, model: pending.model ?? model } : { ...EMPTY_USAGE };
+    if (role === "assistant") pending = null;
+    out.push({ role, text, ts: asString(line.timestamp), ordinal: index, usage });
+  });
+  return out;
+}
+function lastUsage(payload) {
+  const info = payload?.info;
+  const last = info?.last_token_usage;
+  if (!last) return null;
+  const num = (key) => {
+    const value = last[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+  };
+  const cached = num("cached_input_tokens");
+  return {
+    inputTokens: Math.max(0, num("input_tokens") - cached),
+    outputTokens: num("output_tokens"),
+    cacheReadTokens: cached,
+    // Codex reports no cache-write figure; unknown rather than zero.
+    cacheWriteTokens: null,
+    model: null
+  };
+}
+function addUsage(into, next) {
+  if (!into) return { ...next };
+  const sum = (a, b) => a === null && b === null ? null : (a ?? 0) + (b ?? 0);
+  return {
+    inputTokens: sum(into.inputTokens, next.inputTokens),
+    outputTokens: sum(into.outputTokens, next.outputTokens),
+    cacheReadTokens: sum(into.cacheReadTokens, next.cacheReadTokens),
+    cacheWriteTokens: sum(into.cacheWriteTokens, next.cacheWriteTokens),
+    model: into.model ?? next.model
+  };
+}
+function committedSubjectsFromToolCalls(lines) {
+  const subjects = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (line.type !== "response_item") continue;
+    if (payloadType(line) !== "custom_tool_call") continue;
+    const input = asString(line.payload?.input);
+    if (!input) continue;
+    for (const subject of committedSubjects(input)) subjects.add(subject);
+  }
+  return [...subjects];
+}
+function filesFromToolCalls(lines) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.type !== "response_item") continue;
+    if (payloadType(line) !== "custom_tool_call") continue;
+    const input = asString(line.payload?.input);
+    if (!input) continue;
+    const tool = asString(line.payload?.name) ?? "exec";
+    for (const path of extractPathsFromText(input)) {
+      if (!byPath.has(path)) byPath.set(path, { path, source: "tool_bash", tool });
+    }
+  }
+  return [...byPath.values()];
+}
+function parseCodexSessionFile(filePath, repoPath, repoId) {
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = parseLines(raw);
+  const meta = lines.find((l) => l.type === "session_meta")?.payload;
+  if (!meta) return null;
+  const cwd = asString(meta.cwd);
+  if (!cwd) return null;
+  if (cwd.replace(/\/+$/, "") !== repoPath.replace(/\/+$/, "")) return null;
+  const sessionId = asString(meta.session_id) ?? asString(meta.id);
+  if (!sessionId) return null;
+  const events = conversationEvents(lines);
+  if (events.length === 0) return null;
+  const filesTouched = filesFromToolCalls(lines);
+  let redactionCount = 0;
+  const turns = events.map((event, i) => {
+    const { text, count } = redactSecrets(event.text);
+    redactionCount += count;
+    return {
+      id: deriveCodexTurnId(sessionId, event.ordinal),
+      sessionId,
+      role: event.role,
+      ts: event.ts ?? asString(meta.timestamp) ?? (/* @__PURE__ */ new Date()).toISOString(),
+      text,
+      // Attributed to the assistant turns, which are the ones that ran the
+      // tools; a user turn touched no files.
+      filesTouched: event.role === "assistant" && i === events.length - 1 ? filesTouched : [],
+      editedLines: [],
+      parentUuid: null,
+      isSidechain: false,
+      redacted: count > 0,
+      isSyntheticInput: false,
+      usage: event.usage
+    };
+  });
+  const { content: rawContent, count: rawRedactions } = redactRollout(raw);
+  redactionCount += rawRedactions;
+  const firstUser = events.find((e) => e.role === "user");
+  return {
+    id: sessionId,
+    agentKind: "codex",
+    // Codex records the remote itself, so identity survives a moved or deleted
+    // checkout. Falls back to the caller's derivation when it is absent.
+    repoId: repoIdFromMeta(meta) ?? repoId,
+    cwd,
+    startedAt: asString(meta.timestamp) ?? events[0]?.ts ?? null,
+    endedAt: events[events.length - 1]?.ts ?? null,
+    turnCount: turns.length,
+    committedSubjects: committedSubjectsFromToolCalls(lines),
+    aiTitle: firstUser ? firstUser.text.slice(0, 120).trim() : null,
+    author: null,
+    sourceFile: filePath,
+    redactionCount,
+    turns,
+    rawContent,
+    rawFormat: "jsonl"
+  };
+}
+function repoIdFromMeta(meta) {
+  const git = meta.git;
+  if (typeof git !== "object" || git === null) return null;
+  const url = asString(git.repository_url);
+  if (!url) return null;
+  const normalized = normalizeRepoRemote(url);
+  return normalized ? `remote:${normalized}` : null;
+}
+function redactRollout(raw) {
+  let count = 0;
+  const lines = raw.split("\n").map((line) => {
+    if (!line.trim()) return line;
+    const { text, count: n } = redactSecrets(line);
+    count += n;
+    return text;
+  });
+  return { content: lines.join("\n"), count };
+}
+
+// ../../packages/ingest-core/src/sanitize.ts
+var NUL = String.fromCharCode(0);
+
+// ../../packages/ingest-core/src/gemini-sessions.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+var SYNTHETIC = /^\s*<session_context>/;
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map(
+    (part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : ""
+  ).filter(Boolean).join("\n");
+}
+function parseGeminiSessionFile(filePath, repoPath, repoId) {
+  let raw;
+  try {
+    raw = readFileSync3(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const records = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  const meta = records.find((r) => r.sessionId && r.startTime);
+  if (!meta?.sessionId) return null;
+  let messages = [];
+  for (const record of records) {
+    const next = record.$set?.messages ?? record.messages;
+    if (Array.isArray(next)) messages = next;
+  }
+  let redactionCount = 0;
+  const turns = [];
+  messages.forEach((record, index) => {
+    const role = record.type === "user" ? "user" : record.type === "gemini" || record.type === "model" ? "assistant" : null;
+    if (!role) return;
+    const text = textOf(record.content ?? record.displayContent);
+    if (!text.trim()) return;
+    const { text: safe, count } = redactSecrets(text);
+    redactionCount += count;
+    turns.push({
+      // Gemini's own record id when it has one, so a re-read lands on the same
+      // row; a derived id keyed on position otherwise, which is stable for an
+      // append-only file.
+      id: record.id ? deriveUuid(`evrex-gemini-turn ${meta.sessionId} ${record.id}`) : deriveUuid(`evrex-gemini-turn ${meta.sessionId} ${index}`),
+      sessionId: deriveUuid(`evrex-gemini-session ${meta.sessionId}`),
+      role,
+      ts: record.timestamp ?? meta.startTime ?? (/* @__PURE__ */ new Date()).toISOString(),
+      text: safe,
+      filesTouched: [],
+      editedLines: [],
+      parentUuid: null,
+      isSidechain: false,
+      redacted: count > 0,
+      // Gemini opens every session with a `<session_context>` block delivered
+      // as a user message. Attributing that to the person is the same bug this
+      // repo already fixed once for Claude Code's tool results.
+      isSyntheticInput: role === "user" && SYNTHETIC.test(text),
+      // Gemini records a model per message but no token counts in the
+      // transcript; unknown rather than zero.
+      usage: { ...EMPTY_USAGE, model: record.model ?? null }
+    });
+  });
+  if (turns.length === 0) return null;
+  const { text: rawContent, count: rawRedactions } = redactSecrets(raw);
+  const firstUser = turns.find((t) => t.role === "user" && !t.isSyntheticInput);
+  return {
+    id: deriveUuid(`evrex-gemini-session ${meta.sessionId}`),
+    agentKind: "gemini",
+    repoId,
+    cwd: meta.directories?.[0] ?? repoPath,
+    startedAt: meta.startTime ?? turns[0]?.ts ?? null,
+    endedAt: turns[turns.length - 1]?.ts ?? null,
+    turnCount: turns.length,
+    committedSubjects: [],
+    aiTitle: firstUser ? firstUser.text.slice(0, 120).trim() : null,
+    author: null,
+    sourceFile: filePath,
+    redactionCount: redactionCount + rawRedactions,
+    turns,
+    rawContent,
+    rawFormat: "jsonl"
+  };
+}
+
+// ../../packages/ingest-core/src/transcript-parsers.ts
+var PARSERS = [parseSessionFile, parseCodexSessionFile, parseGeminiSessionFile];
+function parseTranscriptFile(path, repoPath, repoId) {
+  for (const parse of PARSERS) {
+    const parsed = parse(path, repoPath, repoId);
+    if (parsed) return parsed;
+  }
+  return null;
+}
+
+// src/capture-state.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var EMPTY = { sessions: {} };
+function stateDir(home = homedir()) {
+  return join(home, ".evrex");
+}
+function statePath(home = homedir()) {
+  return join(stateDir(home), "capture-state.json");
+}
+function readState(path) {
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || typeof parsed.sessions !== "object") {
+      return { sessions: {} };
+    }
+    return { sessions: parsed.sessions ?? {} };
+  } catch {
+    return { sessions: {} };
+  }
+}
+function writeState(path, state) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(state), { mode: 384 });
+    renameSync(tmp, path);
+  } catch {
+  }
+}
+function orphaned(state, exceptSessionId) {
+  return Object.entries(state.sessions).filter(([id, s]) => !s.archived && id !== exceptSessionId).map(([, s]) => s).filter((s) => existsSync3(s.transcriptPath));
+}
+
+// src/spool.ts
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var MAX_SPOOL_BYTES = 32 * 1024 * 1024;
+function append(spoolPath, post2) {
+  try {
+    mkdirSync2(dirname2(spoolPath), { recursive: true });
+    if (existsSync4(spoolPath) && sizeOf(spoolPath) >= MAX_SPOOL_BYTES) return;
+    appendFileSync(spoolPath, `${JSON.stringify(post2)}
+`, { mode: 384 });
+  } catch {
+  }
+}
+function read(spoolPath) {
+  try {
+    return readFileSync5(spoolPath, "utf8").split("\n").filter((line) => line.trim().length > 0).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function clear(spoolPath) {
+  try {
+    unlinkSync(spoolPath);
+  } catch {
+  }
+}
+function keep(spoolPath, remaining) {
+  try {
+    if (remaining.length === 0) return clear(spoolPath);
+    writeFileSync2(spoolPath, remaining.map((p) => `${JSON.stringify(p)}
+`).join(""), {
+      mode: 384
+    });
+  } catch {
+  }
+}
+function sizeOf(path) {
+  try {
+    return readFileSync5(path).byteLength;
+  } catch {
+    return 0;
+  }
+}
+
+// src/capture.ts
+var DEADLINE_MS = 6e3;
+var MAX_TRANSCRIPT_BYTES = 256 * 1024 * 1024;
+function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => raw += c);
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+function withDeadline(work, ms) {
+  return Promise.race([
+    work.catch(() => null),
+    new Promise((r) => setTimeout(() => r(null), ms))
+  ]);
+}
+function parseTranscript(path, cwd) {
+  try {
+    const stat = statSync3(path);
+    if (!stat.isFile() || stat.size > MAX_TRANSCRIPT_BYTES) return null;
+    return parseTranscriptFile(path, cwd, deriveRepoId(cwd));
+  } catch {
+    return null;
+  }
+}
+async function drainSpool(spoolPath, deps) {
+  const queued = read(spoolPath);
+  if (queued.length === 0) return { sent: 0, kept: 0 };
+  let sent = 0;
+  for (const post2 of queued) {
+    if (!await deps.post(post2.path, post2.body)) break;
+    sent += 1;
+  }
+  const remaining = queued.slice(sent);
+  keep(spoolPath, remaining);
+  return { sent, kept: remaining.length };
+}
+async function deliver(spoolPath, path, body, deps) {
+  const ok = await deps.post(path, body);
+  if (!ok) {
+    append(spoolPath, { path, body, queuedAt: deps.now().toISOString() });
+  }
+  return ok;
+}
+async function handleEvent(event, deps) {
+  const name = event.hook_event_name;
+  const sessionId = event.session_id;
+  if (!name || !sessionId) return null;
+  const spoolPath = join2(stateDir(deps.home), "spool.jsonl");
+  const drained = await drainSpool(spoolPath, deps);
+  const path = statePath(deps.home);
+  const state = readState(path) ?? EMPTY;
+  const prior = state.sessions[sessionId];
+  const transcriptPath = event.transcript_path ?? prior?.transcriptPath;
+  if (name === "SessionStart") {
+    for (const open of orphaned(state, sessionId)) {
+      const parsed2 = parseTranscript(open.transcriptPath, event.cwd ?? process.cwd());
+      if (!parsed2) continue;
+      await deliver(spoolPath, "/ingest/sessions", { sessions: [parsed2] }, deps);
+    }
+  }
+  if (!transcriptPath) {
+    return { event: name, turnsSent: 0, archived: false, spoolDrained: drained.sent };
+  }
+  const parsed = parseTranscript(transcriptPath, event.cwd ?? process.cwd());
+  const sentThrough = prior?.sentThrough ?? 0;
+  let turnsSent = 0;
+  if (parsed && parsed.turnCount > sentThrough) {
+    const ok = await deliver(
+      spoolPath,
+      "/ingest/sessions",
+      { sessions: [parsed] },
+      deps
+    );
+    turnsSent = ok ? parsed.turnCount - sentThrough : 0;
+  }
+  const ending = name === "SessionEnd";
+  let archived = prior?.archived ?? false;
+  if (ending && !archived && parsed?.rawContent) {
+    archived = await deliver(
+      spoolPath,
+      `/ingest/sessions/${sessionId}/transcript`,
+      { rawContent: parsed.rawContent, rawFormat: parsed.rawFormat ?? "jsonl" },
+      deps
+    );
+  }
+  state.sessions[sessionId] = {
+    transcriptPath,
+    sentThrough: parsed?.turnCount ?? sentThrough,
+    startedAt: prior?.startedAt ?? deps.now().toISOString(),
+    archived
+  };
+  writeState(path, state);
+  return { event: name, turnsSent, archived, spoolDrained: drained.sent };
+}
+async function main() {
+  const raw = await withDeadline(readStdin(), DEADLINE_MS);
+  if (!raw) return;
+  let event;
+  try {
+    event = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const { evrexApi: evrexApi2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const deps = {
+    now: () => /* @__PURE__ */ new Date(),
+    home: homedir2(),
+    machine: hostname(),
+    post: async (path, body) => {
+      try {
+        const res = await fetch(`${evrexApi2.baseUrl}${path}`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...process.env.EVREX_TOKEN ? { authorization: `Bearer ${process.env.EVREX_TOKEN}` } : {}
+          },
+          body: JSON.stringify(body)
+        });
+        return res.ok;
+      } catch {
+        return false;
+      }
+    }
+  };
+  await withDeadline(handleEvent(event, deps), DEADLINE_MS);
+}
+main().then(
+  () => process.exit(0),
+  () => process.exit(0)
+);
+export {
+  drainSpool,
+  handleEvent,
+  parseTranscript
+};