sticky-note-cli 3.1.14 → 3.1.16

package/templates/hooks/session-end.js

@@ -76,9 +76,14 @@ const {
   syncStickyNote,
 } = utils;
 
+// ── AI event writer ───────────────────────────────────────
+
+let eventWriter = null;
+try { eventWriter = require("./event-writer.js"); } catch (_) {}
+
 // ── Constants ─────────────────────────────────────────────
 
-const WRITE_TOOLS = new Set([
+const WRITE_TOOLS = (eventWriter && eventWriter.WRITE_TOOLS) || new Set([
   "Write", "Edit", "MultiEdit",
   "write", "edit", "multi_edit",
 ]);
@@ -378,17 +383,140 @@ function extractFailedApproaches(hookInput) {
   return extractFailedFromEntries(entries);
 }
 
+// ── AI event extraction for AI blame ─────────────────────
+
+/**
+ * Parse Claude Code's transcript JSONL to extract ai_thinking,
+ * ai_response, and context_compressed events for the AI blame stream.
+ * Returns an array of structured events ordered by their appearance.
+ */
+function extractAiEventsFromTranscript(transcriptPath, sessionId) {
+  if (!eventWriter) return [];
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return [];
+
+  const events = [];
+  let raw;
+  try {
+    raw = fs.readFileSync(transcriptPath, "utf-8");
+  } catch (_) {
+    return [];
+  }
+
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try { entry = JSON.parse(trimmed); } catch (_) { continue; }
+
+    // Context compression: Claude Code emits entries with a summary field
+    // when the context window is compacted.
+    if (entry.type === "summary" && entry.summary) {
+      events.push(eventWriter.buildEvent(
+        eventWriter.EVENT_TYPES.CONTEXT_COMPRESSED,
+        {
+          summary: String(entry.summary).substring(0, 1000),
+          tokens_before: entry.tokens_before || null,
+          tokens_after: entry.tokens_after || null,
+        },
+        sessionId
+      ));
+      continue;
+    }
+
+    const message = entry.message;
+    if (!message || typeof message !== "object") continue;
+    const role = message.role || entry.role || "";
+    if (role !== "assistant") continue;
+
+    const contentBlocks = _getContentBlocks(entry);
+    if (!Array.isArray(contentBlocks)) continue;
+
+    for (const block of contentBlocks) {
+      if (!block || typeof block !== "object") continue;
+
+      if (block.type === "thinking" && block.thinking) {
+        events.push(eventWriter.buildEvent(
+          eventWriter.EVENT_TYPES.AI_THINKING,
+          { content: block.thinking },
+          sessionId
+        ));
+      }
+
+      if (block.type === "text" && block.text && block.text.trim()) {
+        events.push(eventWriter.buildEvent(
+          eventWriter.EVENT_TYPES.AI_RESPONSE,
+          { content: block.text },
+          sessionId
+        ));
+      }
+    }
+
+    // Token usage may appear on the entry itself (Claude Code's format)
+    if (entry.usage && eventWriter) {
+      const last = events[events.length - 1];
+      if (last && last.type === eventWriter.EVENT_TYPES.AI_RESPONSE) {
+        last.data.input_tokens = entry.usage.input_tokens || null;
+        last.data.output_tokens = entry.usage.output_tokens || null;
+        last.data.cache_read_tokens = entry.usage.cache_read_input_tokens || null;
+      }
+    }
+  }
+
+  return events;
+}
+
+/**
+ * Collect all events for this session from the audit JSONL files
+ * (tool_call, tool_result, tool_error, tool_denied, user_prompt, session_open)
+ * plus the provided pre-extracted AI events.
+ * Sort by ts. Returns an array ready to push to the Worker.
+ *
+ * Callers must extract AI events separately (via extractAiEventsFromTranscript)
+ * so the same extraction can be reused for local audit writes — avoiding a
+ * second transcript parse.
+ */
+function collectSessionEvents(sessionId, aiEvents) {
+  const events = [];
+
+  // Gather structured events from audit (written by hooks during the session)
+  const typesForBlame = new Set([
+    "tool_call", "tool_result", "tool_error", "tool_denied",
+    "user_prompt", "session_open", "checkpoint",
+  ]);
+
+  for (const auditPath of getAllAuditPaths()) {
+    try {
+      const raw = fs.readFileSync(auditPath, "utf-8");
+      for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let entry;
+        try { entry = JSON.parse(trimmed); } catch (_) { continue; }
+        if (entry.session_id === sessionId && typesForBlame.has(entry.type)) {
+          events.push(entry);
+        }
+      }
+    } catch (_) {
+      // ignore unreadable audit file
+    }
+  }
+
+  events.push(...aiEvents);
+
+  // Sort by ts ascending
+  events.sort((a, b) => {
+    if (a.ts < b.ts) return -1;
+    if (a.ts > b.ts) return 1;
+    return 0;
+  });
+
+  return events;
+}
+
 // ── Transcript capture ────────────────────────────────────
-// Persists the full verbatim session transcript (Claude Code's native
-// transcript_path JSONL file) into sticky-note/data storage, keyed by
-// thread ID rather than commit SHA — a thread's transcript belongs to the
-// whole session, which may span zero, one, or many commits. Appended as
-// one entry per contributing session so resumed threads accumulate their
-// full history rather than overwriting it.
-//
-// Opt-out: set "capture_transcripts": false in sticky-note-config.json.
-// Secrets are redacted (best-effort — see redactSecrets in sticky-utils.js)
-// before anything is written to disk or committed.
+// Keyed by thread ID rather than commit SHA — a session may span zero or many
+// commits. Appended (not overwritten) so resumed threads accumulate history.
+// Opt-out: "capture_transcripts": false in sticky-note-config.json.
 
 function captureTranscript(hookInput, threadId, sessionId, aiTool, user, now, config) {
   if (!threadId) return false;
@@ -800,6 +928,19 @@ function clearPresence(user) {
   try { fs.unlinkSync(presencePath); } catch (_) {}
 }
 
+// ── Cloud helpers ─────────────────────────────────────────
+
+function _makeCloudHeaders() {
+  const { url, apiKey } = getCloudConfig();
+  const projectName = getProjectName();
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Sticky-Project": projectName,
+  };
+  if (apiKey) headers["X-Sticky-API-Key"] = apiKey;
+  return { url, headers };
+}
+
 // ── Data-branch commit/push ───────────────────────────────
 
 /** Collect files from a directory matching an extension into fileMap. */
@@ -920,7 +1061,7 @@ async function main() {
   memory.threads = threads;
   let existing = null;
 
-  // V2.5: Check for active resumed thread (set by resume-thread command)
+  // Check for active resumed thread (set by resume-thread command)
   const activeResumeId = getActiveResumeThreadId();
 
   // Check for resumed thread (V2 resume signal or V2.5 active resume)
@@ -952,7 +1093,7 @@ async function main() {
         });
       }
 
-      // V2.5: Update contributors and resume metadata
+      // Update contributors and resume metadata
       const contributors = existing.contributors || [];
       if (!contributors.includes(user)) {
         contributors.push(user);
@@ -1069,13 +1210,7 @@ async function main() {
           .filter(Boolean)
           .find(e => e.session_id === sessionId);
         if (entry) {
-          const { url: stickyUrl, apiKey: stickyApiKey } = getCloudConfig();
-          const projectName = getProjectName();
-          const headers = {
-            "Content-Type": "application/json",
-            "X-Sticky-Project": projectName,
-          };
-          if (stickyApiKey) headers["X-Sticky-API-Key"] = stickyApiKey;
+          const { url: stickyUrl, headers } = _makeCloudHeaders();
           fetch(`${stickyUrl}/transcripts/${existing.id}`, {
             method: "POST",
             headers,
@@ -1086,7 +1221,37 @@ async function main() {
     } catch (_) {} // transcript cloud sync is non-fatal
   }
 
-  // V2.5: Capture commit SHAs for attribution engine
+  // Extract AI events once — used for both local audit writes and the Worker push.
+  let aiEvents = [];
+  try {
+    aiEvents = extractAiEventsFromTranscript(hookInput.transcript_path || "", sessionId);
+    for (const ev of aiEvents) {
+      try { appendAuditLineBoth(ev, cloud); } catch (_) {}
+    }
+  } catch (_) {
+    // non-fatal — AI event extraction must never interrupt session-end
+  }
+
+  // Push complete event stream to Worker for team-wide AI blame.
+  // This is a no-op if cloud is not configured or the endpoint doesn't exist yet.
+  if (cloud && existing && existing.id) {
+    try {
+      const allEvents = collectSessionEvents(sessionId, aiEvents);
+      if (allEvents.length > 0) {
+        const { url: stickyUrl, headers } = _makeCloudHeaders();
+        fetch(`${stickyUrl}/threads/${existing.id}/events`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ events: allEvents }),
+          signal: AbortSignal.timeout(10000),
+        }).catch(() => {}); // non-fatal
+      }
+    } catch (_) {
+      // non-fatal — Worker endpoint may not exist until Plan 2 ships
+    }
+  }
+
+  // Capture commit SHAs for attribution engine
   const commitShas = getSessionCommitShas();
 
   // Housekeeping
@@ -1106,7 +1271,7 @@ async function main() {
   }
   appendAuditLineBoth(auditEntry, cloud);
 
-  // V2.5: Also write individual commit_sha audit entries for bridge lookup
+  // Also write individual commit_sha audit entries for bridge lookup
   for (const sha of commitShas) {
     const commitEntry = {
       type: "commit",

package/templates/hooks/session-start.js

@@ -1248,6 +1248,33 @@ async function main() {
   if (configContext) parts.push(configContext);
   if (presenceContext) parts.push(presenceContext);
 
+  // Write session_open event for AI blame
+  let eventWriter = null;
+  try { eventWriter = require("./event-writer.js"); } catch (_) {}
+  if (eventWriter) {
+    try {
+      const pkg = (() => {
+        try { return require("../../package.json"); } catch (_) { return {}; }
+      })();
+      const openEvent = eventWriter.buildEvent(
+        eventWriter.EVENT_TYPES.SESSION_OPEN,
+        {
+          model: hookInput.model || (hookInput.api_info && hookInput.api_info.model) || null,
+          branch: getBranch(),
+          user: getUser(),
+          sticky_version: pkg.version || null,
+          mcp_servers: (config.mcp_servers || [])
+            .map(s => (typeof s === "object" ? s.name : s))
+            .filter(Boolean),
+        },
+        getSessionId(hookInput)
+      );
+      appendAuditLineBoth(openEvent, cloud);
+    } catch (_) {
+      // best-effort — never break the hook
+    }
+  }
+
   const output = parts.join("\n").trim();
   _emit(output);
 }

package/templates/hooks/sticky-utils.js

@@ -82,10 +82,10 @@ let _cachedStickyDir = null;
 function _stickyDir() {
   if (_cachedStickyDir) return _cachedStickyDir;
   try {
-    const gitDir = execFileSync("git", ["rev-parse", "--absolute-git-dir"], {
+    const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
     }).trim();
-    _cachedStickyDir = path.resolve(gitDir, "sticky-note");
+    _cachedStickyDir = path.join(root, ".sticky-note");
     return _cachedStickyDir;
   } catch (_) {
     // Fallback for non-git environments (e.g., unit tests without git init)
@@ -1341,6 +1341,15 @@ async function cloudFetch(method, endpoint, body) {
   try {
     const resp = await fetch(`${url}${endpoint}`, opts);
     if (!resp.ok) {
+      if (!_cloudWarned) {
+        _cloudWarned = true;
+        const hint = resp.status === 401
+          ? " (check STICKY_API_KEY in .env.sticky)"
+          : ` (HTTP ${resp.status})`;
+        process.stderr.write(
+          `[STICKY-NOTE] Cloud sync failed${hint} — using local/git fallback\n`
+        );
+      }
       return null;
     }
     const text = await resp.text();
@@ -1349,7 +1358,7 @@ async function cloudFetch(method, endpoint, body) {
     if (!_cloudWarned) {
       _cloudWarned = true;
       process.stderr.write(
-        "[STICKY-NOTE] Cloud unreachable, using local fallback\n"
+        "[STICKY-NOTE] Cloud unreachable, using local/git fallback\n"
       );
     }
     return null;

package/templates/hooks/track-work.js

@@ -35,6 +35,9 @@ try {
   gitNotes = null;
 }
 
+let eventWriter = null;
+try { eventWriter = require("./event-writer.js"); } catch (_) {}
+
 const {
   getConfigPath,
   getMemoryPath,
@@ -53,7 +56,8 @@ const {
 } = utils;
 
 const WRITE_TOOLS = new Set([
-  "edit", "Edit", "create", "Create", "Write", "write", "MultiEdit", "multi_edit",
+  ...(eventWriter && eventWriter.WRITE_TOOLS ? eventWriter.WRITE_TOOLS : ["Edit", "edit", "Write", "write", "MultiEdit", "multi_edit"]),
+  "create", "Create",
 ]);
 
 function _debugPath() {
@@ -147,7 +151,7 @@ function autoDetectMcp(toolName) {
   return null;
 }
 
-// ── V2.5: Line-level change tracking ─────────────────────
+// ── Line-level change tracking ───────────────────────────
 
 /**
  * After a write tool completes, capture exact line ranges changed.
@@ -257,10 +261,10 @@ function main() {
   }
 
   const user = getUser();
-  const now = new Date().toISOString();
   const isWriteTool = WRITE_TOOLS.has(toolName);
 
-  // V2.5: Capture line-level changes for write tools
+  // Capture line-level changes for write tools before timestamping the entry,
+  // so the ts reflects when the audit record is actually written.
   let lineRanges = null;
   let checkpoint = null;
   if (isWriteTool && filePath) {
@@ -270,6 +274,9 @@ function main() {
     }
   }
 
+  const now = new Date().toISOString();
+
+  // Legacy entry — kept for backward compat with existing audit queries
   const entry = {
     type: "tool_use",
     user,
@@ -277,17 +284,51 @@ function main() {
     tool: toolName,
     session_id: sessionId,
   };
-  if (filePath) {
-    entry.file = filePath;
-  }
-  if (lineRanges) {
-    entry.lines_changed = lineRanges.map((r) => `${r.start}-${r.end}`);
-  }
-  if (checkpoint) {
-    entry.checkpoint_topic = checkpoint.topic;
-  }
+  if (filePath) entry.file = filePath;
+  if (lineRanges) entry.lines_changed = lineRanges.map((r) => `${r.start}-${r.end}`);
+  if (checkpoint) entry.checkpoint_topic = checkpoint.topic;
   appendAuditLineBoth(entry, cloud);
 
+  // New enriched events for AI blame
+  if (eventWriter) {
+    try {
+      const rawArgs = hookInput.tool_input || {};
+      const sanitizedArgs = eventWriter.sanitizeToolArgs(toolName, rawArgs);
+      const callEvent = eventWriter.buildEvent(
+        eventWriter.EVENT_TYPES.TOOL_CALL,
+        { tool: toolName, args: sanitizedArgs },
+        sessionId
+      );
+      appendAuditLineBoth(callEvent, cloud);
+
+      // tool_response may be a string or object
+      let rawResult = hookInput.tool_response;
+      if (rawResult && typeof rawResult === "object" && "output" in rawResult) {
+        rawResult = rawResult.output;
+      } else if (rawResult && typeof rawResult === "object") {
+        rawResult = JSON.stringify(rawResult);
+      }
+      const cappedResult = eventWriter.capResult(
+        typeof rawResult === "string" ? rawResult : JSON.stringify(rawResult)
+      );
+      const resultData = {
+        tool: toolName,
+        result: cappedResult,
+      };
+      if (lineRanges) {
+        resultData.lines_changed = lineRanges.map((r) => `${r.start}-${r.end}`);
+      }
+      const resultEvent = eventWriter.buildEvent(
+        eventWriter.EVENT_TYPES.TOOL_RESULT,
+        resultData,
+        sessionId
+      );
+      appendAuditLineBoth(resultEvent, cloud);
+    } catch (_) {
+      // enrichment is best-effort — never break the hook
+    }
+  }
+
   updatePresence(user, filePath);
   if (cloud) {
     cloudWritePresence({
@@ -298,7 +339,6 @@ function main() {
     }).catch(() => {});
   }
 
-  // V2.5: Write Git Note for write tools
   if (isWriteTool && filePath) {
     writeEditNote(sessionId, user, filePath, lineRanges, checkpoint);
   }