backthread 0.1.2 → 0.1.4

package/dist-bundle/backthread.js

@@ -7380,6 +7380,104 @@ function sessionTimestamp(records) {
   }
   return latestIso;
 }
+function stripLeadingSlashes(p) {
+  let i = 0;
+  while (i < p.length && p[i] === "/") i += 1;
+  return p.slice(i);
+}
+function isAbsolute(p) {
+  return p.startsWith("/");
+}
+function isForeignRelativePath(p) {
+  if (p.startsWith("~")) return true;
+  if (p.startsWith("\\")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(p)) return true;
+  const stripped = p.replace(/^(?:\.[\\/])+/, "");
+  return /^\.\.(?:[\\/]|$)/.test(stripped);
+}
+function normalizeRepoRelative(rel) {
+  const out = [];
+  for (const seg of rel.split(/[\\/]/)) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length === 0) return null;
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+function relativizeUnder(abs, root) {
+  const trimmedRoot = root.replace(/\/+$/, "");
+  if (trimmedRoot.length === 0) return null;
+  if (abs === trimmedRoot) return "";
+  const prefix = trimmedRoot + "/";
+  if (!abs.startsWith(prefix)) return null;
+  return stripLeadingSlashes(abs.slice(trimmedRoot.length));
+}
+function pathsFromRecord(rec) {
+  if (!rec || typeof rec !== "object") return [];
+  const out = [];
+  const r = rec;
+  const pushFromInput = (input) => {
+    if (!input || typeof input !== "object") return;
+    const i = input;
+    for (const v of [i.file_path, i.path, i.notebook_path, i.cwd]) {
+      if (typeof v === "string" && v.trim().length > 0) out.push(v.trim());
+    }
+  };
+  const content = r.message?.content;
+  if (Array.isArray(content)) {
+    for (const raw of content) {
+      if (!raw || typeof raw !== "object") continue;
+      const block = raw;
+      if (block.type === "tool_use") pushFromInput(block.input);
+    }
+  }
+  if (r.payload && typeof r.payload === "object" && r.payload.type === "function_call") {
+    const args = r.payload.arguments;
+    if (typeof args === "string") {
+      try {
+        pushFromInput(JSON.parse(args));
+      } catch {
+      }
+    } else {
+      pushFromInput(args);
+    }
+  }
+  return out;
+}
+function codexSessionCwd(records) {
+  for (const raw of records) {
+    if (!raw || typeof raw !== "object") continue;
+    const rec = raw;
+    if (rec.type !== "session_meta") continue;
+    const cwd = rec.payload?.cwd;
+    if (typeof cwd === "string" && cwd.trim().length > 0) return cwd.trim();
+  }
+  return null;
+}
+function sessionPaths(records, repoRoot) {
+  const root = (repoRoot && repoRoot.trim().length > 0 ? repoRoot.trim() : codexSessionCwd(records)) ?? null;
+  const seen = /* @__PURE__ */ new Set();
+  for (const rec of records) {
+    for (const p of pathsFromRecord(rec)) {
+      if (isAbsolute(p)) {
+        if (root === null) continue;
+        const rel = relativizeUnder(p, root);
+        if (rel === null || rel.length === 0) continue;
+        const norm = normalizeRepoRelative(rel);
+        if (norm === null || norm.length === 0) continue;
+        seen.add(norm);
+      } else if (!isForeignRelativePath(p)) {
+        const norm = normalizeRepoRelative(p.replace(/^(?:\.\/)+/, ""));
+        if (norm !== null && norm.length > 0) seen.add(norm);
+      }
+    }
+  }
+  return Array.from(seen).sort();
+}
 
 // src/repo.ts
 import { execFileSync } from "node:child_process";
@@ -7459,6 +7557,7 @@ async function serverInfer(transcript, config2, opts = {}) {
     body.persist = true;
     body.repo = { owner: opts.repo.owner, name: opts.repo.name };
     if (opts.decidedAt) body.decidedAt = opts.decidedAt;
+    if (opts.filePaths && opts.filePaths.length > 0) body.filePaths = opts.filePaths;
   }
   let res;
   try {
@@ -7808,7 +7907,9 @@ var TRUST_COPY = [
   "    code blocks replaced with [code redacted] \u2014 to Backthread's Worker, never source.",
   "  Full details: https://app.backthread.dev/security"
 ].join("\n");
-var HOOK_COMMAND = "npx backthread capture";
+var HOOK_COMMAND = "npx backthread capture --from-hook --agent claude-code --detach";
+var LEGACY_HOOK_COMMANDS = ["npx backthread capture"];
+var OUR_HOOK_COMMANDS = /* @__PURE__ */ new Set([HOOK_COMMAND, ...LEGACY_HOOK_COMMANDS]);
 async function registerHook(cwd, deps = {}) {
   const doReadFile = deps.readFileImpl ?? ((p) => readFile3(p, "utf8"));
   const doWriteFile = deps.writeFileImpl ?? ((p, d) => writeFile3(p, d));
@@ -7854,21 +7955,43 @@ function isNotFound2(err) {
 function mergeSessionEndHook(settings) {
   const hooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? { ...settings.hooks } : {};
   const sessionEnd = Array.isArray(hooks.SessionEnd) ? [...hooks.SessionEnd] : [];
-  if (sessionEnd.some(groupHasOurCommand)) return null;
-  sessionEnd.push({
-    hooks: [{ type: "command", command: HOOK_COMMAND }]
+  if (sessionEnd.some((g) => groupHasCommand(g, HOOK_COMMAND))) return null;
+  let migrated = false;
+  const nextSessionEnd = sessionEnd.map((group) => {
+    const rewritten = rewriteLegacyCommand(group);
+    if (rewritten !== group) migrated = true;
+    return rewritten;
   });
-  hooks.SessionEnd = sessionEnd;
+  if (!migrated) {
+    nextSessionEnd.push({ hooks: [{ type: "command", command: HOOK_COMMAND }] });
+  }
+  hooks.SessionEnd = nextSessionEnd;
   return { ...settings, hooks };
 }
-function groupHasOurCommand(group) {
+function groupHasCommand(group, command) {
   if (!group || typeof group !== "object") return false;
   const inner = group.hooks;
   if (!Array.isArray(inner)) return false;
   return inner.some(
-    (h) => h && typeof h === "object" && h.command === HOOK_COMMAND
+    (h) => h && typeof h === "object" && h.command === command
   );
 }
+function rewriteLegacyCommand(group) {
+  if (!group || typeof group !== "object") return group;
+  const inner = group.hooks;
+  if (!Array.isArray(inner)) return group;
+  let changed = false;
+  const nextInner = inner.map((h) => {
+    if (!h || typeof h !== "object") return h;
+    const cmd = h.command;
+    if (typeof cmd === "string" && cmd !== HOOK_COMMAND && OUR_HOOK_COMMANDS.has(cmd)) {
+      changed = true;
+      return { ...h, command: HOOK_COMMAND };
+    }
+    return h;
+  });
+  return changed ? { ...group, hooks: nextInner } : group;
+}
 async function runInstall(opts = {}, deps = {}) {
   const env = opts.env ?? process.env;
   const log = opts.log ?? ((m) => console.error(m));
@@ -8263,6 +8386,7 @@ async function runCapture(input, deps = {}) {
     const records = parseJsonl(rawTranscript);
     const redacted = redactTranscript(records);
     const decidedAt = sessionTimestamp(records) ?? void 0;
+    const filePaths = sessionPaths(records, input.cwd);
     const sessionId = redacted.sessionId ?? input.session_id ?? null;
     if (redacted.turns.length === 0) {
       return {
@@ -8281,6 +8405,7 @@ async function runCapture(input, deps = {}) {
       env,
       fetchImpl: deps.fetchImpl,
       decidedAt,
+      filePaths,
       ...repo ? { persist: true, repo } : {}
     });
     if (!result.ok) {

package/hooks/hooks.json

@@ -1,12 +1,12 @@
 {
-  "$comment": "The SessionEnd capture hook, declared in the PLUGIN MANIFEST (referenced from .claude-plugin/plugin.json). When Backthread is installed as a Claude Code plugin, this registers the hook automatically — no mutation of the user's .claude/settings.json. `npx backthread capture` reads the SessionEnd payload off stdin, derives this session's decisions LOCALLY-redacted, and persists them best-effort; it always exits 0 so a capture hiccup can never disrupt the session. Mirrored by the .claude/settings.json fallback that `backthread install` writes for the bare-npx (non-plugin) path. We register ONLY SessionEnd (once per session) on purpose — `runCapture` also handles a Stop payload, but Stop fires on every turn-end, which would capture far too aggressively, so Stop is intentionally NOT registered here.",
+  "$comment": "The SessionEnd capture hook, declared in the PLUGIN MANIFEST (referenced from .claude-plugin/plugin.json). When Backthread is installed as a Claude Code plugin, this registers the hook automatically — no mutation of the user's .claude/settings.json. The command routes through the shared `--from-hook` entrypoint with `--detach`: it reads the SessionEnd payload off stdin, then re-spawns a DETACHED worker that does the slow LOCALLY-redacted redact→infer→persist round-trip and returns immediately — so a ≥30s inference can't be SIGTERM'd by CC's SessionEnd hook timeout (or reaped on session exit). Best-effort, never blocks/delays the session, always exits 0 (ARP-682). `--agent claude-code` selects the CC payload shape. Mirrored by the .claude/settings.json fallback that `backthread install` writes for the bare-npx (non-plugin) path. We register ONLY SessionEnd (once per session) on purpose — `runCapture` also handles a Stop payload, but Stop fires on every turn-end, which would capture far too aggressively, so Stop is intentionally NOT registered here.",
   "hooks": {
     "SessionEnd": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "npx backthread capture"
+            "command": "npx backthread capture --from-hook --agent claude-code --detach"
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backthread",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Backthread CLI — capture the why behind your AI-coded changes from your Claude Code sessions, and ask how your codebase works without leaving the terminal. Source code and tool I/O are redacted locally before anything leaves your machine.",
   "license": "MIT",
   "author": "Backthread",