sticky-note-cli 2.6.14 → 2.6.15

package/bin/cli.js

@@ -91,6 +91,116 @@ function makeExecutable(filePath) {
   }
 }
 
+const STICKY_PRE_COMMIT_MARKER = "# [sticky-note:auto-stage]";
+const STICKY_PRE_COMMIT_END    = "# [/sticky-note:auto-stage]";
+
+/**
+ * Install a pre-commit git hook that auto-stages .sticky-note/ tracked files.
+ * If an existing pre-commit hook is present, our block is prepended (or updated)
+ * so it chains cleanly with linters, husky, etc.
+ */
+function installPreCommitHook() {
+  try {
+    const gitDir = path.join(process.cwd(), ".git");
+    if (!fs.existsSync(gitDir)) return false;
+    const hooksDir = path.join(gitDir, "hooks");
+    mkdirSafe(hooksDir);
+    const dest = path.join(hooksDir, "pre-commit");
+
+    const stickyBlock = [
+      STICKY_PRE_COMMIT_MARKER,
+      '# Auto-stage .sticky-note/ files so they ride along with every commit.',
+      '_sn_root="$(git rev-parse --show-toplevel 2>/dev/null)"',
+      'if [ -d "$_sn_root/.sticky-note" ]; then',
+      '  [ -f "$_sn_root/.sticky-note/sticky-note.json" ] && git add "$_sn_root/.sticky-note/sticky-note.json" 2>/dev/null || true',
+      '  [ -d "$_sn_root/.sticky-note/audit" ] && git add "$_sn_root/.sticky-note/audit/" 2>/dev/null || true',
+      '  [ -d "$_sn_root/.sticky-note/presence" ] && git add "$_sn_root/.sticky-note/presence/" 2>/dev/null || true',
+      'fi',
+      STICKY_PRE_COMMIT_END,
+    ].join("\n");
+
+    if (fs.existsSync(dest)) {
+      let existing = fs.readFileSync(dest, "utf-8");
+      const startIdx = existing.indexOf(STICKY_PRE_COMMIT_MARKER);
+      const endIdx   = existing.indexOf(STICKY_PRE_COMMIT_END);
+
+      if (startIdx !== -1 && endIdx !== -1) {
+        // Update our existing block in-place
+        existing = existing.slice(0, startIdx) + stickyBlock + existing.slice(endIdx + STICKY_PRE_COMMIT_END.length);
+      } else {
+        // Prepend our block after the shebang (or at the top)
+        const shebangMatch = existing.match(/^#!.*\n/);
+        if (shebangMatch) {
+          existing = shebangMatch[0] + stickyBlock + "\n" + existing.slice(shebangMatch[0].length);
+        } else {
+          existing = "#!/bin/sh\n" + stickyBlock + "\n" + existing;
+        }
+      }
+      fs.writeFileSync(dest, existing, "utf-8");
+    } else {
+      // No existing hook — create a fresh one
+      fs.writeFileSync(dest, "#!/bin/sh\n" + stickyBlock + "\n", "utf-8");
+    }
+    makeExecutable(dest);
+    return true;
+  } catch (err) {
+    debugLog("installPreCommitHook failed: " + (err.message || err));
+    return false;
+  }
+}
+
+const STICKY_POST_COMMIT_MARKER = "# [sticky-note:auto-sync]";
+const STICKY_POST_COMMIT_END    = "# [/sticky-note:auto-sync]";
+
+/**
+ * Install a post-commit git hook that auto-commits leftover .sticky-note/ changes.
+ * Uses the same prepend/update strategy as installPreCommitHook.
+ */
+function installPostCommitHook() {
+  try {
+    const gitDir = path.join(process.cwd(), ".git");
+    if (!fs.existsSync(gitDir)) return false;
+    const hooksDir = path.join(gitDir, "hooks");
+    mkdirSafe(hooksDir);
+    const dest = path.join(hooksDir, "post-commit");
+    const src = path.join(TEMPLATES_DIR, "hooks", "post-commit");
+    const template = fs.existsSync(src) ? fs.readFileSync(src, "utf-8") : "";
+
+    // Extract just the body (skip shebang + first comment line from template)
+    const bodyLines = template.split("\n").filter(l => !l.startsWith("#!/"));
+    const stickyBlock = [
+      STICKY_POST_COMMIT_MARKER,
+      ...bodyLines,
+      STICKY_POST_COMMIT_END,
+    ].join("\n");
+
+    if (fs.existsSync(dest)) {
+      let existing = fs.readFileSync(dest, "utf-8");
+      const startIdx = existing.indexOf(STICKY_POST_COMMIT_MARKER);
+      const endIdx   = existing.indexOf(STICKY_POST_COMMIT_END);
+
+      if (startIdx !== -1 && endIdx !== -1) {
+        existing = existing.slice(0, startIdx) + stickyBlock + existing.slice(endIdx + STICKY_POST_COMMIT_END.length);
+      } else {
+        const shebangMatch = existing.match(/^#!.*\n/);
+        if (shebangMatch) {
+          existing = shebangMatch[0] + stickyBlock + "\n" + existing.slice(shebangMatch[0].length);
+        } else {
+          existing = "#!/bin/sh\n" + stickyBlock + "\n" + existing;
+        }
+      }
+      fs.writeFileSync(dest, existing, "utf-8");
+    } else {
+      fs.writeFileSync(dest, "#!/bin/sh\n" + stickyBlock + "\n", "utf-8");
+    }
+    makeExecutable(dest);
+    return true;
+  } catch (err) {
+    debugLog("installPostCommitHook failed: " + (err.message || err));
+    return false;
+  }
+}
+
 function installGitHook(hookName) {
   try {
     const gitDir = path.join(process.cwd(), ".git");
@@ -640,6 +750,16 @@ async function cmdInit() {
     print("  [OK] .git/hooks/post-rewrite (attribution survives rebase)");
   }
 
+  // Install pre-commit hook (auto-stage .sticky-note/ files)
+  if (installPreCommitHook()) {
+    print("  [OK] .git/hooks/pre-commit (auto-stage .sticky-note/ files)");
+  }
+
+  // Install post-commit hook (auto-commit leftover .sticky-note/ changes)
+  if (installPostCommitHook()) {
+    print("  [OK] .git/hooks/post-commit (auto-sync .sticky-note/ after commit)");
+  }
+
   // Force-add .claude/hooks/ and .claude/settings.json so git tracks them
   // (needed if .claude/ was previously in .gitignore)
   try {
@@ -710,6 +830,12 @@ function cmdUpdate() {
   if (installGitHook("post-rewrite")) {
     print("  [OK] .git/hooks/post-rewrite (attribution survives rebase)");
   }
+  if (installPreCommitHook()) {
+    print("  [OK] .git/hooks/pre-commit (auto-stage .sticky-note/ files)");
+  }
+  if (installPostCommitHook()) {
+    print("  [OK] .git/hooks/post-commit (auto-sync .sticky-note/ after commit)");
+  }
 
   // Update hook_version in config
   const configPath = path.join(stickyDir, "sticky-note-config.json");
@@ -2246,6 +2372,63 @@ function cmdGc() {
   print("");
 }
 
+// ──────────────────────────────────────────────
+// sync — commit and optionally push .sticky-note/ files
+// ──────────────────────────────────────────────
+
+function cmdSync() {
+  const args = process.argv.slice(3);
+  const doPush = args.includes("--push");
+  const stickyDir = path.join(process.cwd(), ".sticky-note");
+  if (!fs.existsSync(stickyDir)) {
+    print("  [ERR] No .sticky-note/ directory found. Run 'npx sticky-note init' first.");
+    process.exit(1);
+  }
+
+  printBanner();
+  print("  Syncing .sticky-note/ files...\n");
+
+  try {
+    const status = execSync(
+      'git status --porcelain -- ".sticky-note/sticky-note.json" ".sticky-note/audit/" ".sticky-note/presence/"',
+      { encoding: "utf-8", cwd: process.cwd() }
+    ).trim();
+    if (!status) {
+      print("  [OK] Nothing to sync — .sticky-note/ files are clean.");
+      print("");
+      return;
+    }
+
+    // Write recursion guard
+    const guardPath = path.join(stickyDir, ".sticky-syncing");
+    fs.writeFileSync(guardPath, process.pid.toString(), "utf-8");
+
+    try {
+      execFileSync("git", [
+        "add", "--", ".sticky-note/sticky-note.json",
+        ".sticky-note/audit/", ".sticky-note/presence/"
+      ], { cwd: process.cwd(), timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+
+      execFileSync("git", [
+        "commit", "--no-verify", "-m", "chore(sticky-note): sync thread data"
+      ], { cwd: process.cwd(), timeout: 15000, stdio: ["pipe", "pipe", "pipe"] });
+      print("  ✅ Committed .sticky-note/ changes.");
+
+      if (doPush) {
+        execFileSync("git", ["push"], {
+          cwd: process.cwd(), timeout: 30000, stdio: ["pipe", "pipe", "pipe"],
+        });
+        print("  ✅ Pushed to remote.");
+      }
+    } finally {
+      try { fs.unlinkSync(guardPath); } catch (_) {}
+    }
+  } catch (err) {
+    print("  ⚠️  Sync failed: " + (err.message || err));
+  }
+  print("");
+}
+
 // ──────────────────────────────────────────────
 // Main
 // ──────────────────────────────────────────────
@@ -2300,6 +2483,9 @@ async function main() {
     case "claim":
       cmdClaim();
       break;
+    case "sync":
+      cmdSync();
+      break;
     case "--version":
     case "-v":
       print(`sticky-note v${VERSION}`);
@@ -2325,6 +2511,7 @@ async function main() {
       print("    checkpoint         Set work-topic checkpoint for attribution (--topic, --show, --clear)");
       print("    overlap            Detect file overlaps with open/stuck threads");
       print("    claim              Claim ownership of files you're working on (--list, --clear)");
+      print("    sync               Commit .sticky-note/ changes to git (--push to also push)");
       print("");
       print("  Options:");
       print("    --version  Show version");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.6.14",
+  "version": "2.6.15",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {

package/templates/hooks/on-error.js

@@ -88,27 +88,10 @@ function main() {
     if (existing.failed_approaches.length > 5) {
       existing.failed_approaches = existing.failed_approaches.slice(-5);
     }
-  } else {
-    const thread = {
-      id: crypto.randomUUID(),
-      user: user,
-      project: memory.project || "",
-      status: "stuck",
-      branch: "",
-      created_at: now,
-      closed_at: null,
-      last_activity_at: now,
-      files_touched: [],
-      last_note: errorMsg,
-      narrative: "",
-      failed_approaches: [{ description: errorMsg.substring(0, 150), error: errorMsg.substring(0, 100) }],
-      handoff_summary: "",
-      related_session_ids: [],
-      tool: toolName,
-      session_id: sessionId,
-    };
-    threads.push(thread);
   }
+  // If no thread exists for this session, skip — session-start.js creates the
+  // thread now. Creating standalone "stuck" threads from tool failures produced
+  // garbage entries (tool="Bash"/"Glob", no branch, no context).
 
   appendAuditLine({
     type: "error",
@@ -131,6 +114,7 @@ function main() {
 
 try {
   main();
-} catch (_) {
+} catch (err) {
+  try { utils.logHookError("on-error", err); } catch (_) {}
   _safeExit();
 }

package/templates/hooks/on-stop.js

@@ -217,7 +217,7 @@ async function main() {
   let found = false;
 
   for (const thread of threads) {
-    if (thread.session_id === sessionId && (thread.status === "open" || thread.status === "stuck")) {
+    if (thread.session_id === sessionId) {
       thread.last_activity_at = now;
       // Enrich with extracted data
       if (allFiles.length) {
@@ -250,35 +250,9 @@ async function main() {
       break;
     }
   }
-
-  if (!found && sessionId !== "unknown") {
-    const storedPrompts = (auditData.prompts || []).slice(0, 20).map((p) => p.substring(0, 300));
-    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: allFiles,
-      last_note: reason ? reason.substring(0, 200) : (narrative || "Session stopped"),
-      narrative,
-      failed_approaches: [],
-      handoff_summary: "",
-      related_session_ids: [],
-      tool: detectTool(hookInput),
-      session_id: sessionId,
-      work_type: workType,
-      tool_calls: auditData.tools || {},
-      prompts: storedPrompts,
-      contributors: [user],
-      resume_history: [],
-    };
-    thread.handoff_summary = buildHandoffSummary(thread, reason);
-    threads.push(thread);
-  }
+  // If no thread exists for this session, skip — session-start.js creates the
+  // thread now. Creating standalone threads from Stop events produced duplicates
+  // when session-end.js had already closed the thread (status filter mismatch).
 
   const auditEntry = {
     type: "stop",
@@ -310,4 +284,7 @@ async function main() {
   process.exit(0);
 }
 
-main().catch(() => safeExit());
+main().catch((err) => {
+  try { utils.logHookError("on-stop", err); } catch (_) {}
+  safeExit();
+});

package/templates/hooks/post-commit

@@ -0,0 +1,36 @@
+#!/bin/sh
+# Sticky Note — post-commit hook
+# Auto-commits .sticky-note/ changes that weren't included in the user's commit.
+# Installed by `npx sticky-note init`. Safe to remove if you prefer manual sync.
+
+_sn_root="$(git rev-parse --show-toplevel 2>/dev/null)"
+[ -z "$_sn_root" ] && exit 0
+
+# Recursion guard — if we're already syncing, bail out
+_sn_guard="$_sn_root/.sticky-note/.sticky-syncing"
+[ -f "$_sn_guard" ] && exit 0
+
+# Check for dirty .sticky-note/ files (unstaged changes that weren't in the commit)
+_sn_dirty="$(git status --porcelain -- \
+  "$_sn_root/.sticky-note/sticky-note.json" \
+  "$_sn_root/.sticky-note/audit/" \
+  "$_sn_root/.sticky-note/presence/" 2>/dev/null)"
+[ -z "$_sn_dirty" ] && exit 0
+
+# Write guard file
+echo $$ > "$_sn_guard"
+
+# Stage and commit
+git add -- \
+  "$_sn_root/.sticky-note/sticky-note.json" \
+  "$_sn_root/.sticky-note/audit/" \
+  "$_sn_root/.sticky-note/presence/" 2>/dev/null
+
+git commit --no-verify -m "chore(sticky-note): sync thread data" -- \
+  "$_sn_root/.sticky-note/sticky-note.json" \
+  "$_sn_root/.sticky-note/audit/" \
+  "$_sn_root/.sticky-note/presence/" 2>/dev/null
+
+# Clean up guard
+rm -f "$_sn_guard" 2>/dev/null
+exit 0

package/templates/hooks/session-end.js

@@ -58,6 +58,7 @@ const {
   clearActiveResumeThreadId,
   clearInjectedSet,
   normalizeSep,
+  syncStickyNote,
 } = utils;
 
 // ── Constants ─────────────────────────────────────────────
@@ -935,6 +936,16 @@ function main() {
   }
   saveMemoryMerged(memoryPath, memory);
 
+  // Auto-sync: commit (and optionally push) .sticky-note/ changes
+  const config = loadJson(getConfigPath(), {});
+  if (config.auto_sync !== false) {
+    try {
+      syncStickyNote({ push: config.auto_push === true });
+    } catch (_) {
+      // Non-fatal — sync failure shouldn't block session-end
+    }
+  }
+
   const fileCount = filesTouched.length;
   const commitCount = commitShas.length;
   const statusLabel = isCopilotCli ? "updated" : "closed";
@@ -949,6 +960,7 @@ function main() {
 
 try {
   main();
-} catch (_) {
+} catch (err) {
+  try { utils.logHookError("session-end", err); } catch (_) {}
   _safeExit();
 }

package/templates/hooks/session-start.js

@@ -50,6 +50,7 @@ const {
   saveMemoryMerged,
   appendAuditLine,
   getUser,
+  getBranch,
   getSessionId,
   getResumeThreadId,
   findThreadById,
@@ -493,6 +494,46 @@ function main() {
     }
   }
 
+  // ── Create "open" thread for this session ──────────────
+  // Ensures a thread exists even if SessionEnd never fires (Ctrl+C, crash).
+  // session-end.js, on-stop.js, and on-error.js will find and update this
+  // thread by session_id. Copilot CLI fires SessionStart per-turn, so skip
+  // creation on subsequent turns (thread already exists from the first turn).
+  if (!resumedThread) {
+    const threads = (memory.threads || []).filter(Boolean);
+    memory.threads = threads;
+    const existingForSession = threads.find((t) => t.session_id === sessionId);
+    if (!existingForSession) {
+      const user = getUser();
+      const branch = getBranch();
+      threads.push({
+        id: crypto.randomUUID(),
+        user,
+        project: memory.project || "",
+        status: "open",
+        branch,
+        created_at: new Date().toISOString(),
+        closed_at: null,
+        last_activity_at: new Date().toISOString(),
+        files_touched: [],
+        last_note: "",
+        narrative: "",
+        failed_approaches: [],
+        handoff_summary: "",
+        related_session_ids: [],
+        resume_chain: [],
+        tool: aiTool,
+        session_id: sessionId,
+        work_type: "",
+        activities: [],
+        tool_calls: {},
+        prompts: [],
+        contributors: [user],
+        resume_history: [],
+      });
+    }
+  }
+
   // ── Build context pieces ──────────────────────────────
   const threadResult = formatThreadsForInjection((memory.threads || []).filter(Boolean));
   const threadContext = threadResult.text;
@@ -618,6 +659,7 @@ function main() {
 
 try {
   main();
-} catch (_) {
+} catch (err) {
+  try { utils.logHookError("session-start", err); } catch (_) {}
   _safeExit();
 }

package/templates/hooks/sticky-utils.js

@@ -42,6 +42,21 @@ function _stickyDir() {
   return path.join(scriptDir, "..", "..", ".sticky-note");
 }
 
+// ── Error logging ─────────────────────────────────────────
+
+function logHookError(hookName, error) {
+  try {
+    const logPath = path.join(_stickyDir(), ".sticky-errors.log");
+    const ts = new Date().toISOString();
+    const msg = error instanceof Error ? error.stack || error.message : String(error);
+    const line = `[${ts}] ${hookName}: ${msg}\n`;
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, line, "utf-8");
+  } catch (_) {
+    // Last resort — can't even log the error
+  }
+}
+
 const _paths = {
   memory: "sticky-note.json",
   config: "sticky-note-config.json",
@@ -125,6 +140,73 @@ function clearSessionFile() {
   }
 }
 
+// ── Git sync (auto-commit/push .sticky-note/ files) ──────
+
+function _gitRepoRoot() {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Stage, commit, and optionally push .sticky-note/ files.
+ * Returns { committed: bool, pushed: bool, skipped: bool, error?: string }
+ */
+function syncStickyNote(opts) {
+  const push = opts && opts.push;
+  const result = { committed: false, pushed: false, skipped: false };
+  try {
+    const root = _gitRepoRoot();
+    if (!root) { result.skipped = true; return result; }
+
+    const syncGuard = path.join(_stickyDir(), ".sticky-syncing");
+    if (fs.existsSync(syncGuard)) { result.skipped = true; return result; }
+
+    // Check for dirty .sticky-note/ files (staged or unstaged)
+    const status = execFileSync("git", [
+      "status", "--porcelain", "--", ".sticky-note/sticky-note.json",
+      ".sticky-note/audit/", ".sticky-note/presence/"
+    ], { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
+
+    if (!status) { result.skipped = true; return result; }
+
+    // Write guard to prevent recursive post-commit triggers
+    fs.writeFileSync(syncGuard, process.pid.toString(), "utf-8");
+
+    try {
+      // Stage the relevant files
+      execFileSync("git", [
+        "add", "--", ".sticky-note/sticky-note.json",
+        ".sticky-note/audit/", ".sticky-note/presence/"
+      ], { timeout: 10000, stdio: ["pipe", "pipe", "pipe"] });
+
+      // Commit only what was staged
+      execFileSync("git", [
+        "commit", "-m", "chore(sticky-note): sync thread data", "--no-verify"
+      ], { timeout: 15000, stdio: ["pipe", "pipe", "pipe"] });
+      result.committed = true;
+
+      // Push if requested
+      if (push) {
+        execFileSync("git", ["push"], {
+          timeout: 30000, stdio: ["pipe", "pipe", "pipe"],
+        });
+        result.pushed = true;
+      }
+    } finally {
+      try { fs.unlinkSync(syncGuard); } catch (_) {}
+    }
+  } catch (err) {
+    result.error = err.message;
+    logHookError("syncStickyNote", err);
+  }
+  return result;
+}
+
 // ── Git HEAD snapshot (for files_touched fallback) ────────
 
 function saveHeadSha() {
@@ -671,6 +753,7 @@ module.exports = {
   ERROR_PATTERNS,
   RETRY_PATTERNS,
   FILE_PATH_PATTERN,
+  logHookError,
   getMemoryPath,
   getConfigPath,
   getAuditPath,
@@ -731,5 +814,7 @@ module.exports = {
   markOverlapDismissed,
   // V2.5: cross-platform path helper
   normalizeSep,
+  // V2.7: auto-sync
+  syncStickyNote,
 };
 // tier1 test

package/templates/hooks/track-work.js

@@ -37,12 +37,16 @@ try {
 
 const {
   getConfigPath,
+  getMemoryPath,
   getUserPresencePath,
   loadJson,
   saveJson,
+  saveMemoryMerged,
   appendAuditLine,
   getUser,
+  getBranch,
   getSessionId,
+  normalizeSep,
 } = utils;
 
 const WRITE_TOOLS = new Set([
@@ -302,6 +306,35 @@ function main() {
     }
   }
 
+  // ── Progressive thread update ────────────────────────────
+  // Update the session's open thread with files_touched and branch changes
+  // so data survives even if SessionEnd never fires (Ctrl+C, crash).
+  if (filePath) {
+    try {
+      const memoryPath = getMemoryPath();
+      const memory = loadJson(memoryPath, { version: "2", project: "", threads: [] });
+      const threads = (memory.threads || []).filter(Boolean);
+      const sessionThread = threads.find((t) => t.session_id === sessionId);
+      if (sessionThread) {
+        const normalized = normalizeSep(filePath);
+        const touched = sessionThread.files_touched || [];
+        if (!touched.includes(normalized)) {
+          touched.push(normalized);
+          sessionThread.files_touched = touched;
+        }
+        // Update branch if it changed mid-session
+        const currentBranch = getBranch();
+        if (currentBranch && currentBranch !== sessionThread.branch) {
+          sessionThread.branch = currentBranch;
+        }
+        sessionThread.last_activity_at = now;
+        saveMemoryMerged(memoryPath, memory);
+      }
+    } catch (_) {
+      // Best-effort — don't break the hook if thread update fails
+    }
+  }
+
   // Build status message for transparency
   const linePart = lineRanges && lineRanges.length > 0 ? ` (lines ${lineRanges.map(r => `${r.start}-${r.end}`).join(", ")})` : "";
   const statusMsg = `[STICKY-NOTE] Tracked ${toolName}${filePath ? " on " + filePath : ""}${linePart}`;
@@ -316,6 +349,7 @@ function main() {
 
 try {
   main();
-} catch (_) {
+} catch (err) {
+  try { utils.logHookError("track-work", err); } catch (_) {}
   safeExit();
 }

package/templates/sticky-note-config.json

@@ -2,6 +2,8 @@
   "stale_days": 14,
   "copilot_cli_auto_close_hours": 24,
   "inject_token_budget": 1000,
+  "auto_sync": true,
+  "auto_push": false,
   "mcp_servers": [],
   "skills": [],
   "conventions": [],