sticky-note-cli 2.5.0

package/templates/hooks/on-stop.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * on-stop.js — Handoff Summary Generation (V2)
+ *
+ * Hook: Stop (Claude Code)
+ * Generates a structured handoff_summary on the current thread.
+ */
+
+const crypto = require("crypto");
+
+function safeExit() {
+  try {
+    process.stdout.write(JSON.stringify({ output: "" }) + "\n");
+  } catch (_) {
+    process.stdout.write('{"output":""}\n');
+  }
+  process.exit(0);
+}
+
+let utils;
+try {
+  utils = require("./sticky-utils.js");
+} catch (_) {
+  safeExit();
+}
+
+const {
+  getMemoryPath,
+  loadJson,
+  saveJson,
+  appendAuditLine,
+  getUser,
+  getBranch,
+  getSessionId,
+  detectTool,
+} = utils;
+
+function buildHandoffSummary(thread, reason) {
+  const parts = [];
+  const files = thread.files_touched || [];
+  const workType = thread.work_type || "general";
+  const note = thread.last_note || "";
+
+  if (files.length) {
+    parts.push(`What done: ${workType} on ${files.slice(0, 5).join(", ")}`);
+  } else if (note) {
+    parts.push(`What done: ${note}`);
+  }
+
+  const failed = thread.failed_approaches || [];
+  if (failed.length) {
+    const descs = failed.slice(0, 3).map((a) => (a.description || "").substring(0, 60));
+    parts.push(`What failed: ${descs.join("; ")}`);
+  }
+
+  const narrative = thread.narrative || "";
+  if (narrative) {
+    parts.push(`Status: ${narrative.substring(0, 150)}`);
+  }
+
+  if (reason) {
+    parts.push(`Next: ${reason.substring(0, 100)}`);
+  }
+
+  return parts.length ? parts.join(" | ") : "Session stopped -- no summary available";
+}
+
+function main() {
+  let hookInput = {};
+  try {
+    if (!process.stdin.isTTY) {
+      const raw = require("fs").readFileSync(0, "utf-8").trim();
+      if (raw) {
+        hookInput = JSON.parse(raw);
+      }
+    }
+  } catch (_) {
+    hookInput = {};
+  }
+
+  const sessionId = getSessionId(hookInput);
+  const user = getUser();
+  const now = new Date().toISOString();
+  const reason = hookInput.reason || "";
+
+  const memoryPath = getMemoryPath();
+  const memory = loadJson(memoryPath, { version: "2", project: "", threads: [] });
+
+  const threads = memory.threads || [];
+  let found = false;
+
+  for (const thread of threads) {
+    if (thread.session_id === sessionId && (thread.status === "open" || thread.status === "stuck")) {
+      thread.last_activity_at = now;
+      thread.handoff_summary = buildHandoffSummary(thread, reason);
+      if (reason) {
+        thread.last_note = reason.substring(0, 200);
+      }
+      found = true;
+      break;
+    }
+  }
+
+  if (!found && sessionId !== "unknown") {
+    const thread = {
+      id: crypto.randomUUID(),
+      user,
+      project: memory.project || "",
+      status: "closed",
+      branch: getBranch(),
+      created_at: now,
+      closed_at: now,
+      last_activity_at: now,
+      files_touched: [],
+      last_note: reason ? reason.substring(0, 200) : "Session stopped",
+      narrative: "",
+      failed_approaches: [],
+      handoff_summary: buildHandoffSummary({}, reason),
+      related_session_ids: [],
+      tool: detectTool(hookInput),
+      session_id: sessionId,
+    };
+    threads.push(thread);
+  }
+
+  appendAuditLine({
+    type: "stop",
+    user,
+    ts: now,
+    session_id: sessionId,
+    reason: reason ? reason.substring(0, 200) : "stop_checkpoint",
+  });
+
+  saveJson(memoryPath, memory);
+  const reasonStr = reason ? reason.substring(0, 60) : "checkpoint";
+  const statusMsg = `[STICKY-NOTE] Session stopped - handoff saved (${reasonStr})`;
+  try {
+    process.stdout.write(JSON.stringify({ output: statusMsg }) + "\n");
+  } catch (_) {
+    process.stdout.write('{"output":""}\n');
+  }
+  process.exit(0);
+}
+
+try {
+  main();
+} catch (_) {
+  safeExit();
+}

package/templates/hooks/parse-transcript.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * parse-transcript.js — Standalone Transcript Parser (V2)
+ *
+ * Extracts narrative + failed_approaches from a session transcript file.
+ * Used by sticky-codex.sh to process Codex stdout/stderr logs.
+ * Also usable standalone: node parse-transcript.js <transcript_path>
+ *
+ * Outputs JSON to stdout: {"narrative": "...", "failed_approaches": [...]}
+ */
+
+const fs = require("fs");
+const {
+  parseJsonlFile,
+  extractNarrativeFromEntries,
+  extractNarrativeFromText,
+  extractFailedFromEntries,
+  extractFailedFromText,
+} = require("./sticky-utils.js");
+
+function parsePlaintextTranscript(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8").split(/\r?\n/);
+  } catch (_) {
+    return [];
+  }
+}
+
+function parseTranscript(filePath) {
+  const entries = parseJsonlFile(filePath);
+  if (entries.length) {
+    return {
+      narrative: extractNarrativeFromEntries(entries),
+      failed_approaches: extractFailedFromEntries(entries),
+    };
+  }
+
+  const lines = parsePlaintextTranscript(filePath);
+  if (lines.length) {
+    return {
+      narrative: extractNarrativeFromText(lines),
+      failed_approaches: extractFailedFromText(lines),
+    };
+  }
+
+  return { narrative: "", failed_approaches: [] };
+}
+
+function main() {
+  if (process.argv.length < 3) {
+    process.stderr.write("Usage: parse-transcript.js <transcript_path>\n");
+    process.exit(1);
+  }
+
+  const transcriptPath = process.argv[2];
+  if (!fs.existsSync(transcriptPath)) {
+    process.stderr.write(`Warning: transcript file not found: ${transcriptPath}\n`);
+    console.log(JSON.stringify({ narrative: "", failed_approaches: [] }));
+    return;
+  }
+
+  const result = parseTranscript(transcriptPath);
+  console.log(JSON.stringify(result));
+}
+
+main();

package/templates/hooks/post-rewrite.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * post-rewrite.js — Git post-rewrite hook for Sticky Note
+ *
+ * Copies Git Notes from old commit SHAs to new SHAs when commits
+ * are rewritten via rebase or amend. This keeps session attribution
+ * alive through history rewrites.
+ *
+ * Install: place in .git/hooks/post-rewrite (or use core.hooksPath)
+ * Git calls this with: post-rewrite <command>
+ * Stdin receives: <old-sha> <new-sha>\n per rewritten commit
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+let gitNotes;
+try {
+  // Try hooks dir first (deployed)
+  gitNotes = require(path.join(__dirname, "..", ".claude", "hooks", "sticky-git-notes.js"));
+} catch (_) {
+  try {
+    // Try relative to .git/hooks/
+    gitNotes = require(path.join(__dirname, "..", "..", ".claude", "hooks", "sticky-git-notes.js"));
+  } catch (_) {
+    try {
+      // Try templates
+      gitNotes = require(path.join(__dirname, "..", "..", "templates", "hooks", "sticky-git-notes.js"));
+    } catch (_) {
+      // Can't load git-notes module — exit silently
+      process.exit(0);
+    }
+  }
+}
+
+function main() {
+  // Read stdin: "old_sha new_sha\n" pairs
+  let stdin = "";
+  try {
+    stdin = fs.readFileSync(0, "utf-8");
+  } catch (_) {
+    process.exit(0);
+  }
+
+  if (!stdin.trim()) process.exit(0);
+
+  const pairs = gitNotes.parsePostRewriteInput(stdin);
+  if (pairs.length === 0) process.exit(0);
+
+  const copied = gitNotes.copyNotesForRewrite(pairs);
+
+  if (copied > 0 && process.env.STICKY_NOTE_DEBUG) {
+    process.stderr.write(`[sticky-note] Copied ${copied} note(s) to rewritten commits\n`);
+  }
+}
+
+try {
+  main();
+} catch (_) {
+  // Never fail a git hook
+  process.exit(0);
+}

package/templates/hooks/pre-tool-use.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * pre-tool-use.js — Lazy Injection via PreToolUse Hook (V2.5)
+ *
+ * Hook: PreToolUse (Claude Code) / preToolUse (Copilot CLI)
+ * Fires BEFORE each tool call. If the tool targets a file, runs
+ * git blame → attribution engine to find threads that authored
+ * lines in that file, and injects them as system context with
+ * line-range detail.
+ *
+ * Dedup: each thread is only injected once per session via the
+ * .sticky-injected tracking file.
+ *
+ * No external dependencies — uses built-in git blame.
+ */
+
+// ── Output helpers ────────────────────────────────────────
+
+function _isCopilotCli() {
+  return process.argv.includes("--copilot-cli") || !!process.env.COPILOT_CLI;
+}
+
+function _emit(text) {
+  if (text === undefined) text = "";
+  if (_isCopilotCli()) {
+    process.stdout.write(JSON.stringify({ additionalContext: text }) + "\n");
+  } else {
+    process.stdout.write(JSON.stringify({ output: text }) + "\n");
+  }
+}
+
+function _safeExit() {
+  try {
+    _emit("");
+  } catch (_) {
+    process.stdout.write('{"output": ""}\n');
+  }
+  process.exit(0);
+}
+
+// ── Import dependencies ───────────────────────────────────
+
+let utils, attribution;
+try {
+  utils = require("./sticky-utils.js");
+} catch (_) {
+  _safeExit();
+}
+
+try {
+  attribution = require("./sticky-attribution.js");
+} catch (_) {
+  // Attribution engine not available — skip lazy injection
+  _safeExit();
+}
+
+const {
+  getSessionId,
+  getUser,
+  appendAuditLine,
+  isThreadInjected,
+  markThreadInjected,
+} = utils;
+
+// ── File path extraction from tool input ──────────────────
+
+function extractFilePath(hookInput) {
+  const toolInput = hookInput.tool_input || hookInput.input || hookInput.toolArgs || {};
+
+  if (typeof toolInput === "object" && toolInput !== null) {
+    for (const key of ["file_path", "filePath", "path", "file", "filename"]) {
+      if (toolInput[key] && typeof toolInput[key] === "string") {
+        return toolInput[key];
+      }
+    }
+    if (toolInput.command && typeof toolInput.command === "string") {
+      return extractFileFromCommand(toolInput.command);
+    }
+  }
+
+  return null;
+}
+
+function extractFileFromCommand(command) {
+  const tokens = command.split(/\s+/);
+  for (const token of tokens) {
+    if (token.includes("/") || token.includes("\\")) {
+      if (/\.\w{1,10}$/.test(token)) {
+        return token;
+      }
+    }
+  }
+  return null;
+}
+
+// ── Thread formatting for injection ───────────────────────
+
+function formatThreadForInjection(threadData, file) {
+  const thread = threadData.thread || threadData;
+  const lineRanges = threadData.line_ranges || threadData._line_ranges || [];
+  const tier = threadData.tier || threadData._tier || "";
+
+  const user = thread.user || thread.author || "unknown";
+  const status = thread.status || "open";
+  const statusTag = status === "stuck" ? "[STUCK]" : status === "open" ? "[OPEN]" : "[CLOSED]";
+  const branch = thread.branch || "";
+  const branchStr = branch ? ` (${branch})` : "";
+
+  const lineStr = lineRanges.length > 0 ? ` [lines ${lineRanges.join(", ")}]` : "";
+
+  const lines = [
+    `[STICKY-NOTE] ${statusTag} ${user}'s thread on ${file}${lineStr}${branchStr}:`,
+  ];
+
+  if (thread.narrative) {
+    lines.push(thread.narrative.substring(0, 200));
+  } else if (thread.last_note) {
+    lines.push(thread.last_note.substring(0, 150));
+  }
+
+  const failed = thread.failed_approaches || [];
+  if (failed.length > 0) {
+    lines.push(`[!] ${failed.length} failed approach(es) - check thread ${(thread.id || "").substring(0, 8)} for details`);
+  }
+
+  if (thread.handoff_summary) {
+    lines.push(`Handoff: ${thread.handoff_summary.substring(0, 150)}`);
+  }
+
+  return lines.join("\n");
+}
+
+// ── Main ──────────────────────────────────────────────────
+
+function main() {
+  let hookInput = {};
+  try {
+    const raw = require("fs").readFileSync(0, "utf-8");
+    if (raw.trim()) {
+      hookInput = JSON.parse(raw);
+    }
+  } catch (_) {
+    hookInput = {};
+  }
+
+  const sessionId = getSessionId(hookInput);
+
+  // Extract file path from tool input
+  const filePath = extractFilePath(hookInput);
+  if (!filePath) {
+    _emit("");
+    return;
+  }
+
+  // Run attribution engine: get threads for this file with line ranges
+  let fileAttr;
+  try {
+    fileAttr = attribution.getFileAttribution(filePath);
+  } catch (_) {
+    _emit("");
+    return;
+  }
+
+  if (!fileAttr || !fileAttr.threads || fileAttr.threads.length === 0) {
+    _emit("");
+    return;
+  }
+
+  // Filter out already-injected threads
+  const newThreads = fileAttr.threads.filter(
+    (t) => !isThreadInjected(t.thread ? t.thread.id : t.id)
+  );
+
+  if (newThreads.length === 0) {
+    _emit("");
+    return;
+  }
+
+  // Build injection output with line-range detail
+  const outputParts = [];
+  for (const threadData of newThreads) {
+    const threadId = threadData.thread ? threadData.thread.id : threadData.id;
+    outputParts.push(formatThreadForInjection(threadData, filePath));
+    markThreadInjected(threadId, sessionId);
+  }
+
+  const output = outputParts.join("\n\n");
+
+  // Audit the injection
+  try {
+    appendAuditLine({
+      type: "lazy_inject",
+      user: getUser(),
+      ts: new Date().toISOString(),
+      session_id: sessionId,
+      file: filePath,
+      threads_injected: newThreads.length,
+      thread_ids: newThreads.map((t) => {
+        const id = t.thread ? t.thread.id : t.id;
+        return (id || "").substring(0, 8);
+      }),
+    });
+  } catch (_) {
+    // ignore
+  }
+
+  _emit(output);
+}
+
+// ── Entry point ───────────────────────────────────────────
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (_) {
+    _safeExit();
+  }
+}