oxtail 0.7.1 → 0.9.1

package/scripts/install-hook.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-// Install the oxtail PreToolUse hook into ~/.claude/settings.json.
+// Install the oxtail hooks (PreToolUse + Stop) into ~/.claude/settings.json.
 //
-// Idempotent: re-running on an installed system reports "already installed"
+// Idempotent: re-running on an up-to-date system reports "already installed"
 // and exits 0 without writing. Format-preserving: edits use jsonc-parser so
 // unrelated keys, whitespace, and comments survive.
 //
@@ -16,16 +16,17 @@ import {
   SETTINGS_PATH,
   HOOK_MARKER_KEY,
   HOOK_MARKER_VERSION,
-  HOOK_SCRIPT_PATH,
-  HOOK_COMMAND,
+  MANAGED_HOOKS,
   scriptHash,
 } from "./hook-constants.mjs";
 
-const SHIPPED_HOOK_PATH = new URL("../assets/pretooluse.sh", import.meta.url).pathname;
 const FORMATTING = { tabSize: 2, insertSpaces: true };
 
-function findOxtailHookIndex(parsed) {
-  const arr = parsed?.hooks?.PreToolUse;
+// Find an oxtail-managed hook entry by its installed script filename
+// (e.g. "oxtail/hooks/pretooluse.sh"). Loose substring match tolerates the
+// "$HOME/..."-quoted command form. -F (fixed-string) is unsafe.
+function findOxtailHookIndex(parsed, event, asset) {
+  const arr = parsed?.hooks?.[event];
   if (!Array.isArray(arr)) return -1;
   return arr.findIndex((entry) => {
     if (!entry || typeof entry !== "object") return false;
@@ -35,55 +36,64 @@ function findOxtailHookIndex(parsed) {
         h &&
         typeof h === "object" &&
         typeof h.command === "string" &&
-        // Loose match: any command referencing our installed script path.
-        h.command.includes("oxtail/hooks/pretooluse.sh"),
+        h.command.includes(`oxtail/hooks/${asset}`),
     );
   });
 }
 
 export async function install() {
-  const shipped = await readFile(SHIPPED_HOOK_PATH, "utf8");
-  const wantHash = scriptHash(shipped);
+  // Read shipped scripts + compute hashes up front.
+  const shipped = [];
+  for (const hook of MANAGED_HOOKS) {
+    const shippedPath = new URL(`../assets/${hook.asset}`, import.meta.url).pathname;
+    const text = await readFile(shippedPath, "utf8");
+    shipped.push({ ...hook, text, hash: scriptHash(text) });
+  }
 
   let source = "{}\n";
   if (existsSync(SETTINGS_PATH)) source = await readFile(SETTINGS_PATH, "utf8");
   const parsed = parse(source) ?? {};
 
   const marker = parsed[HOOK_MARKER_KEY];
-  const existingIdx = findOxtailHookIndex(parsed);
+  const markerHashes = (marker && typeof marker === "object" && marker.hashes) || {};
   const upToDate =
     marker &&
     typeof marker === "object" &&
     marker.version === HOOK_MARKER_VERSION &&
-    marker.scriptHash === wantHash &&
-    existingIdx >= 0 &&
-    existsSync(HOOK_SCRIPT_PATH);
-  if (upToDate) {
-    console.log(
-      `oxtail hook already installed (v${HOOK_MARKER_VERSION}, hash ${wantHash.slice(0, 8)}). No changes.`,
+    shipped.every(
+      (h) =>
+        markerHashes[h.id] === h.hash &&
+        findOxtailHookIndex(parsed, h.event, h.asset) >= 0 &&
+        existsSync(h.scriptPath),
     );
+  if (upToDate) {
+    console.log(`oxtail hooks already installed (v${HOOK_MARKER_VERSION}). No changes.`);
     return;
   }
 
-  // Detect competing PreToolUse hooks (e.g. Terminator's _terminatorHook).
-  // Behavior under multi-hook coexistence is determined live in Step 5
-  // case 11 — for now, warn so users know install order may matter.
-  const otherHooks = (parsed?.hooks?.PreToolUse ?? []).filter((entry, idx) => {
-    if (idx === existingIdx) return false;
-    if (!entry || !Array.isArray(entry.hooks)) return false;
-    return entry.hooks.some(
-      (h) => h && typeof h.command === "string" && !h.command.includes("oxtail/hooks/pretooluse.sh"),
-    );
-  });
-  if (otherHooks.length > 0) {
+  // Detect competing hooks on the same events (e.g. Terminator's _terminatorHook).
+  // Behavior under multi-hook coexistence is determined live; for now, warn.
+  let otherCount = 0;
+  for (const h of shipped) {
+    const arr = parsed?.hooks?.[h.event] ?? [];
+    const mine = findOxtailHookIndex(parsed, h.event, h.asset);
+    otherCount += arr.filter((entry, idx) => {
+      if (idx === mine) return false;
+      if (!entry || !Array.isArray(entry.hooks)) return false;
+      return entry.hooks.some(
+        (x) => x && typeof x.command === "string" && !x.command.includes("oxtail/hooks/"),
+      );
+    }).length;
+  }
+  if (otherCount > 0) {
     console.warn(
-      `[oxtail] note: ${otherHooks.length} other PreToolUse hook(s) already installed. ` +
+      `[oxtail] note: ${otherCount} other hook(s) already present on managed events. ` +
       `Multi-hook coexistence is supported but install order may matter; ` +
       `see README "Hook coexistence" for details.`,
     );
   }
 
-  // Back up settings.json before mutating it (Skeptic M4).
+  // Back up settings.json before mutating it.
   if (existsSync(SETTINGS_PATH)) {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     const backup = `${SETTINGS_PATH}.oxtail-backup.${stamp}`;
@@ -91,42 +101,42 @@ export async function install() {
     console.log(`Backed up existing settings to ${backup}`);
   }
 
-  // Install the shipped script atomically.
-  const hooksDir = path.dirname(HOOK_SCRIPT_PATH);
-  await mkdir(hooksDir, { recursive: true, mode: 0o755 });
-  const scriptTmp = `${HOOK_SCRIPT_PATH}.tmp-${randomBytes(6).toString("hex")}`;
-  await writeFile(scriptTmp, shipped, { mode: 0o755 });
-  // writeFile's `mode` option only applies on file creation; an existing
-  // tmp file would keep its previous perms. Explicit chmod for belt+braces.
-  await chmod(scriptTmp, 0o755);
-  await rename(scriptTmp, HOOK_SCRIPT_PATH);
+  // Install each shipped script atomically.
+  for (const h of shipped) {
+    const hooksDir = path.dirname(h.scriptPath);
+    await mkdir(hooksDir, { recursive: true, mode: 0o755 });
+    const scriptTmp = `${h.scriptPath}.tmp-${randomBytes(6).toString("hex")}`;
+    // writeFile's `mode` only applies on creation; explicit chmod for belt+braces.
+    await writeFile(scriptTmp, h.text, { mode: 0o755 });
+    await chmod(scriptTmp, 0o755);
+    await rename(scriptTmp, h.scriptPath);
+  }
 
-  // Edit settings.json. Replace any prior oxtail entry; else append.
+  // Edit settings.json: replace any prior oxtail entry per event, else append.
+  // Re-parse each iteration so indices reflect the prior edit. The two events
+  // are independent, but re-parsing keeps append indices correct regardless.
   let text = source;
-  const newEntry = { hooks: [{ type: "command", command: HOOK_COMMAND }] };
-  const arr = parsed?.hooks?.PreToolUse;
-  if (existingIdx >= 0) {
+  for (const h of shipped) {
+    const cur = parse(text) ?? {};
+    const existingIdx = findOxtailHookIndex(cur, h.event, h.asset);
+    const arr = cur?.hooks?.[h.event];
+    const targetIdx = existingIdx >= 0 ? existingIdx : (Array.isArray(arr) ? arr.length : 0);
+    const newEntry = { hooks: [{ type: "command", command: h.command }] };
     text = applyEdits(
       text,
-      modify(text, ["hooks", "PreToolUse", existingIdx], newEntry, { formattingOptions: FORMATTING }),
-    );
-  } else {
-    const insertIdx = Array.isArray(arr) ? arr.length : 0;
-    text = applyEdits(
-      text,
-      modify(text, ["hooks", "PreToolUse", insertIdx], newEntry, { formattingOptions: FORMATTING }),
+      modify(text, ["hooks", h.event, targetIdx], newEntry, { formattingOptions: FORMATTING }),
     );
   }
+
+  // Write the marker with per-hook hashes.
+  const hashes = {};
+  for (const h of shipped) hashes[h.id] = h.hash;
   text = applyEdits(
     text,
     modify(
       text,
       [HOOK_MARKER_KEY],
-      {
-        version: HOOK_MARKER_VERSION,
-        installedAt: new Date().toISOString(),
-        scriptHash: wantHash,
-      },
+      { version: HOOK_MARKER_VERSION, installedAt: new Date().toISOString(), hashes },
       { formattingOptions: FORMATTING },
     ),
   );
@@ -137,7 +147,9 @@ export async function install() {
   await writeFile(settingsTmp, text, "utf8");
   await rename(settingsTmp, SETTINGS_PATH);
 
-  console.log(`Installed oxtail PreToolUse hook in ${SETTINGS_PATH}.`);
+  console.log(
+    `Installed oxtail hooks (${MANAGED_HOOKS.map((h) => h.event).join(", ")}) in ${SETTINGS_PATH}.`,
+  );
   console.log("Reverse with: npx oxtail uninstall-hook");
 }
 

package/scripts/uninstall-hook.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-// Remove the oxtail PreToolUse hook entry and marker from
-// ~/.claude/settings.json, and delete the installed ~/.oxtail/hooks/pretooluse.sh.
+// Remove the oxtail hook entries (PreToolUse + Stop) and marker from
+// ~/.claude/settings.json, and delete the installed scripts under
+// ~/.oxtail/hooks/.
 //
 // Idempotent: a clean run on an uninstalled system exits 0 with "nothing to do."
 
@@ -12,13 +13,13 @@ import { applyEdits, modify, parse } from "jsonc-parser";
 import {
   SETTINGS_PATH,
   HOOK_MARKER_KEY,
-  HOOK_SCRIPT_PATH,
+  MANAGED_HOOKS,
 } from "./hook-constants.mjs";
 
 const FORMATTING = { tabSize: 2, insertSpaces: true };
 
-function findOxtailHookIndex(parsed) {
-  const arr = parsed?.hooks?.PreToolUse;
+function findOxtailHookIndex(parsed, event, asset) {
+  const arr = parsed?.hooks?.[event];
   if (!Array.isArray(arr)) return -1;
   return arr.findIndex((entry) => {
     if (!entry || typeof entry !== "object") return false;
@@ -28,44 +29,58 @@ function findOxtailHookIndex(parsed) {
         h &&
         typeof h === "object" &&
         typeof h.command === "string" &&
-        h.command.includes("oxtail/hooks/pretooluse.sh"),
+        h.command.includes(`oxtail/hooks/${asset}`),
     );
   });
 }
 
+async function removeScripts() {
+  for (const h of MANAGED_HOOKS) {
+    if (!existsSync(h.scriptPath)) continue;
+    try {
+      await unlink(h.scriptPath);
+      console.log(`Removed ${h.scriptPath}.`);
+    } catch (err) {
+      console.warn(`Could not remove ${h.scriptPath}: ${err?.message ?? err}`);
+    }
+  }
+}
+
 export async function uninstall() {
   if (!existsSync(SETTINGS_PATH)) {
     console.log(`No ${SETTINGS_PATH} — nothing to do.`);
-    // Still try to remove the installed script in case it's a leftover.
-    if (existsSync(HOOK_SCRIPT_PATH)) {
-      try {
-        await unlink(HOOK_SCRIPT_PATH);
-        console.log(`Removed ${HOOK_SCRIPT_PATH}.`);
-      } catch (err) {
-        console.warn(`Could not remove ${HOOK_SCRIPT_PATH}: ${err?.message ?? err}`);
-      }
-    }
+    // Still try to remove installed scripts in case they're leftovers.
+    await removeScripts();
     return;
   }
 
   const source = await readFile(SETTINGS_PATH, "utf8");
   const parsed = parse(source) ?? {};
 
-  const idx = findOxtailHookIndex(parsed);
   const hasMarker =
     parsed[HOOK_MARKER_KEY] && typeof parsed[HOOK_MARKER_KEY] === "object";
+  const anyEntry = MANAGED_HOOKS.some(
+    (h) => findOxtailHookIndex(parsed, h.event, h.asset) >= 0,
+  );
+  const anyScript = MANAGED_HOOKS.some((h) => existsSync(h.scriptPath));
 
-  if (idx < 0 && !hasMarker && !existsSync(HOOK_SCRIPT_PATH)) {
-    console.log("oxtail hook not installed — nothing to do.");
+  if (!anyEntry && !hasMarker && !anyScript) {
+    console.log("oxtail hooks not installed — nothing to do.");
     return;
   }
 
+  // Remove each event's oxtail entry. Re-parse per iteration so indices stay
+  // valid after the prior edit.
   let text = source;
-  if (idx >= 0) {
-    text = applyEdits(
-      text,
-      modify(text, ["hooks", "PreToolUse", idx], undefined, { formattingOptions: FORMATTING }),
-    );
+  for (const h of MANAGED_HOOKS) {
+    const cur = parse(text) ?? {};
+    const idx = findOxtailHookIndex(cur, h.event, h.asset);
+    if (idx >= 0) {
+      text = applyEdits(
+        text,
+        modify(text, ["hooks", h.event, idx], undefined, { formattingOptions: FORMATTING }),
+      );
+    }
   }
   if (hasMarker) {
     text = applyEdits(
@@ -78,16 +93,9 @@ export async function uninstall() {
   await mkdir(path.dirname(SETTINGS_PATH), { recursive: true });
   await writeFile(settingsTmp, text, "utf8");
   await rename(settingsTmp, SETTINGS_PATH);
-  console.log(`Removed oxtail PreToolUse hook from ${SETTINGS_PATH}.`);
+  console.log(`Removed oxtail hooks from ${SETTINGS_PATH}.`);
 
-  if (existsSync(HOOK_SCRIPT_PATH)) {
-    try {
-      await unlink(HOOK_SCRIPT_PATH);
-      console.log(`Removed ${HOOK_SCRIPT_PATH}.`);
-    } catch (err) {
-      console.warn(`Could not remove ${HOOK_SCRIPT_PATH}: ${err?.message ?? err}`);
-    }
-  }
+  await removeScripts();
 }
 
 const invokedDirectly =