sticky-note-cli 2.9.1 → 3.0.0

package/bin/mcp-server.js

@@ -234,7 +234,7 @@ function toolGetPresence() {
   const active = entries
     .filter(([_user, data]) => {
       const lastSeen = new Date(data.last_seen || 0);
-      return now - lastSeen < 15 * 60 * 1000;
+      return now - lastSeen < 60 * 60 * 1000;
     })
     .map(([user, data]) => ({
       user,
@@ -298,7 +298,7 @@ function toolCheckOverlaps(params) {
   for (const [user, data] of Object.entries(presence)) {
     if (user === currentUser) continue;
     const lastSeen = new Date(data.last_seen || 0);
-    if (now - lastSeen > 15 * 60 * 1000) continue;
+    if (now - lastSeen > 60 * 60 * 1000) continue;
 
     const presenceFiles = (data.active_files || []).map((f) =>
       f.replace(/\\/g, "/")
@@ -576,7 +576,7 @@ const TOOLS = {
   },
   get_presence: {
     description:
-      "Get current developer presence — who is actively working and on which files. Only shows users seen in the last 15 minutes.",
+      "Get current developer presence — who is actively working and on which files. Only shows users seen in the last hour.",
     inputSchema: {
       type: "object",
       properties: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.9.1",
+  "version": "3.0.0",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {
@@ -32,5 +32,8 @@
   },
   "scripts": {
     "test": "node test/smoke.test.js"
+  },
+  "devDependencies": {
+    "sticky-note-cli": "^2.9.1"
   }
 }

package/templates/CLAUDE.md

@@ -159,6 +159,7 @@ Example format:
 - `.sticky-note/.sticky-head` — transient HEAD snapshot
 - `.sticky-note/.sticky-injected` — transient injection tracking (V2.5)
 - `.sticky-note/.sticky-active-resume` — transient active resume marker (V2.5)
+- `.sticky-note/.sticky-banner-shown` — transient startup banner dedup
 
 When a session ends or the user asks to commit, **always include
 `sticky-note.json` and the `audit/` and `presence/` directories**

package/templates/copilot-instructions.md

@@ -162,6 +162,7 @@ Example format:
 - `.sticky-note/.sticky-head` — transient HEAD snapshot
 - `.sticky-note/.sticky-injected` — transient injection tracking (V2.5)
 - `.sticky-note/.sticky-active-resume` — transient active resume marker (V2.5)
+- `.sticky-note/.sticky-banner-shown` — transient startup banner dedup
 
 When a session ends or the user asks to commit, **always include
 `sticky-note.json` and the `audit/` and `presence/` directories**

package/templates/gitignore-additions.txt

@@ -1,3 +1,6 @@
+# Sticky Note - data moved to sticky-note/data branch (.git/sticky-note/ cache)
+.sticky-note/
+
 # Sticky Note - local overrides
 .claude/settings.local.json
 
@@ -8,6 +11,7 @@
 .sticky-note/.sticky-injected
 .sticky-note/.sticky-active-resume
 .sticky-note/.sticky-checkpoint
+.sticky-note/.sticky-banner-shown
 
 # Sticky Note - debug log
 .sticky-note/hook-debug.log

package/templates/hooks/data-branch.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * data-branch.js — Git plumbing for the sticky-note/data orphan branch.
+ *
+ * Reads/writes files via git plumbing (hash-object, update-index, write-tree,
+ * commit-tree, update-ref). No working-tree checkout is ever performed.
+ * All operations are synchronous; callers receive result objects on failure.
+ */
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+const { execFileSync } = require("child_process");
+
+const DATA_BRANCH = "sticky-note/data";
+const DATA_REF = "refs/heads/" + DATA_BRANCH;
+
+const GIT_OPTS = { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] };
+
+// ── Git helpers ───────────────────────────────────────────
+
+function getDefaultRemote() {
+  try {
+    const out = execFileSync("git", ["remote"], {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return out.split(/\r?\n/)[0] || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+/** Returns file content from a git ref as a string, or null if not found. */
+function readFileFromBranch(ref, filePath) {
+  try {
+    return execFileSync("git", ["show", ref + ":" + filePath], GIT_OPTS);
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Commit { relativePath: content } to a branch using git plumbing.
+ * Does not touch the working tree or the main index. Returns the new commit SHA.
+ */
+function commitFilesToBranch(branchName, fileMap) {
+  const branchRef = "refs/heads/" + branchName;
+  const tmpIndex = path.join(
+    os.tmpdir(),
+    "sticky-idx-" + process.pid + "-" + crypto.randomBytes(4).toString("hex")
+  );
+
+  try {
+    let parentSha = null;
+    try {
+      parentSha = execFileSync("git", ["rev-parse", "--verify", branchRef], {
+        encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+    } catch (_) {
+      // Branch doesn't exist yet — first commit creates it as orphan
+    }
+
+    const indexEnv = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+
+    if (parentSha) {
+      execFileSync("git", ["read-tree", parentSha], {
+        timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+        env: indexEnv,
+      });
+    }
+
+    for (const [filePath, content] of Object.entries(fileMap)) {
+      const blobSha = execFileSync("git", ["hash-object", "-w", "--stdin"], {
+        input: content,
+        encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+
+      execFileSync(
+        "git",
+        ["update-index", "--add", "--cacheinfo", "100644," + blobSha + "," + filePath],
+        { timeout: 5000, stdio: ["pipe", "pipe", "pipe"], env: indexEnv }
+      );
+    }
+
+    const treeSha = execFileSync("git", ["write-tree"], {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      env: indexEnv,
+    }).trim();
+
+    const commitArgs = ["commit-tree", treeSha, "-m", "chore(sticky-note): sync thread data"];
+    if (parentSha) {
+      commitArgs.push("-p", parentSha);
+    }
+
+    const commitSha = execFileSync("git", commitArgs, GIT_OPTS).trim();
+
+    execFileSync("git", ["update-ref", branchRef, commitSha], {
+      timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    return commitSha;
+  } finally {
+    try { fs.unlinkSync(tmpIndex); } catch (_) {}
+  }
+}
+
+// ── Fetch ─────────────────────────────────────────────────
+
+/**
+ * Fetch the remote data branch into a local remote-tracking ref.
+ * Returns { ok, sha, error, remoteRef }.
+ */
+function fetchDataBranch(remote, branchName) {
+  branchName = branchName || DATA_BRANCH;
+  remote = remote || getDefaultRemote();
+  if (!remote) return { ok: false, sha: null, error: "no remote configured", remoteRef: null };
+
+  const remoteRef = "refs/remotes/" + remote + "/" + branchName;
+  try {
+    execFileSync(
+      "git",
+      ["fetch", remote, branchName + ":" + remoteRef],
+      { timeout: 10000, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    let sha = null;
+    try {
+      sha = execFileSync("git", ["rev-parse", "--verify", remoteRef], {
+        encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+    } catch (_) {}
+    return { ok: true, sha, error: null, remoteRef };
+  } catch (err) {
+    return { ok: false, sha: null, error: err.message, remoteRef };
+  }
+}
+
+// ── Push with retry ────────────────────────────────────────
+
+/**
+ * Push the local data branch to the remote, retrying on rejection.
+ * On non-fast-forward rejection, fetches and merges before retrying.
+ * Returns { ok, error }.
+ */
+function pushDataBranch(remote, branchName, maxRetries, localMemPath, loadJsonFn, saveJsonFn) {
+  branchName = branchName || DATA_BRANCH;
+  remote = remote || getDefaultRemote();
+  maxRetries = maxRetries || 3;
+  if (!remote) return { ok: false, error: "no remote configured" };
+
+  const pushSpec = DATA_REF + ":" + DATA_REF;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      execFileSync("git", ["push", remote, pushSpec], {
+        timeout: 30000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      return { ok: true, error: null };
+    } catch (err) {
+      if (attempt === maxRetries) {
+        return { ok: false, error: err.message };
+      }
+
+      // Fetch, merge, and re-commit so the next push attempt advances the ref
+      try {
+        const fetchResult = fetchDataBranch(remote, branchName);
+        if (fetchResult.ok && fetchResult.remoteRef && localMemPath) {
+          const remoteContent = readFileFromBranch(fetchResult.remoteRef, "sticky-note.json");
+          if (remoteContent) {
+            mergeAndSaveFromRemote(localMemPath, remoteContent, loadJsonFn, saveJsonFn);
+            const mergedContent = fs.readFileSync(localMemPath, "utf-8");
+            commitFilesToBranch(branchName, { "sticky-note.json": mergedContent });
+          }
+        }
+      } catch (_) {}
+
+      // Brief exponential backoff (busy-wait — synchronous context)
+      const end = Date.now() + Math.pow(2, attempt) * 300;
+      while (Date.now() < end) {}
+    }
+  }
+  return { ok: false, error: "max retries exceeded" };
+}
+
+// ── Thread merge ──────────────────────────────────────────
+
+function _mostRecentTimestamp(thread) {
+  return thread.last_activity_at || thread.updated_at || thread.created_at || "";
+}
+
+/**
+ * Merge two thread arrays, preferring the more-recently-active copy
+ * when both contain the same thread ID.
+ */
+function mergeThreadArrays(localThreads, remoteThreads) {
+  const merged = new Map();
+
+  for (const t of (localThreads || [])) {
+    if (t && t.id) merged.set(t.id, t);
+  }
+
+  for (const t of (remoteThreads || [])) {
+    if (!t || !t.id) continue;
+    const existing = merged.get(t.id);
+    if (!existing || _mostRecentTimestamp(t) > _mostRecentTimestamp(existing)) {
+      merged.set(t.id, t);
+    }
+  }
+
+  return Array.from(merged.values());
+}
+
+const EMPTY_MEMORY = { version: "2", project: "", threads: [] };
+
+/**
+ * Merge remote sticky-note.json content into the local memory file.
+ * Uses loadJsonFn/saveJsonFn when provided, otherwise reads/writes directly.
+ */
+function mergeAndSaveFromRemote(localMemPath, remoteContent, loadJsonFn, saveJsonFn) {
+  let remoteMemory;
+  try {
+    remoteMemory = JSON.parse(remoteContent);
+  } catch (_) {
+    return; // corrupt remote — skip
+  }
+
+  const localMemory = loadJsonFn
+    ? loadJsonFn(localMemPath, { ...EMPTY_MEMORY })
+    : { ...EMPTY_MEMORY };
+
+  const localThreads = Array.isArray(localMemory.threads) ? localMemory.threads.filter(Boolean) : [];
+  const remoteThreads = Array.isArray(remoteMemory.threads) ? remoteMemory.threads.filter(Boolean) : [];
+  localMemory.threads = mergeThreadArrays(localThreads, remoteThreads);
+
+  if (saveJsonFn) {
+    saveJsonFn(localMemPath, localMemory);
+  } else {
+    fs.mkdirSync(path.dirname(localMemPath), { recursive: true });
+    fs.writeFileSync(localMemPath, JSON.stringify(localMemory, null, 2) + "\n", "utf-8");
+  }
+}
+
+// ── Exports ───────────────────────────────────────────────
+
+module.exports = {
+  DATA_BRANCH,
+  DATA_REF,
+  getDefaultRemote,
+  readFileFromBranch,
+  commitFilesToBranch,
+  fetchDataBranch,
+  pushDataBranch,
+  mergeThreadArrays,
+  mergeAndSaveFromRemote,
+};

package/templates/hooks/inject-context.js

@@ -39,10 +39,20 @@ function _safeExit() {
 let utils;
 try {
   utils = require("./sticky-utils.js");
-} catch (_) {
+} catch (err) {
+  try {
+    process.stderr.write(
+      `[STICKY-NOTE] UserPromptSubmit hook error: failed to load sticky-utils.js — ${err.message}\n` +
+      `[STICKY-NOTE]   hint: re-run \`npx sticky-note init\` to restore .claude/hooks/.\n`
+    );
+  } catch (_) { /* ignore */ }
   _safeExit();
 }
 
+// Issue #13: also self-heal from this hook (Copilot CLI doesn't fire
+// SessionStart, so inject-context may be the first hook to run successfully).
+try { utils.selfHealHookPaths && utils.selfHealHookPaths(); } catch (_) { /* non-fatal */ }
+
 let gitNotes;
 try {
   gitNotes = require("./sticky-git-notes.js");
@@ -626,6 +636,9 @@ if (require.main === module) {
   try {
     main();
   } catch (exc) {
+    try {
+      utils.reportHookError("UserPromptSubmit", exc);
+    } catch (_) { /* ignore */ }
     try {
       appendAuditLine({
         type: "inject_result",

package/templates/hooks/on-stop.js

@@ -22,7 +22,13 @@ function safeExit() {
 let utils;
 try {
   utils = require("./sticky-utils.js");
-} catch (_) {
+} catch (err) {
+  try {
+    process.stderr.write(
+      `[STICKY-NOTE] Stop hook error: failed to load sticky-utils.js — ${err.message}\n` +
+      `[STICKY-NOTE]   hint: re-run \`npx sticky-note init\` to restore .claude/hooks/.\n`
+    );
+  } catch (_) { /* ignore */ }
   safeExit();
 }
 
@@ -285,6 +291,8 @@ async function main() {
 }
 
 main().catch((err) => {
-  try { utils.logHookError("on-stop", err); } catch (_) {}
+  try { utils.reportHookError("Stop", err); } catch (_) {
+    try { utils.logHookError("on-stop", err); } catch (_) {}
+  }
   safeExit();
 });

package/templates/hooks/session-end.js

@@ -29,9 +29,14 @@ try {
   _safeExit();
 }
 
+let dataBranch = null;
+try { dataBranch = require("./data-branch.js"); } catch (_) {}
+
 const {
   getMemoryPath,
   getConfigPath,
+  getAuditDir,
+  getPresenceDir,
   getUserPresencePath,
   getAllAuditPaths,
   loadJson,
@@ -724,6 +729,53 @@ function clearPresence(user) {
   }
 }
 
+// ── Data-branch commit/push ───────────────────────────────
+
+/** Collect files from a directory matching an extension into fileMap. */
+function _collectDirFiles(dir, ext, prefix, fileMap) {
+  if (!dir || !fs.existsSync(dir)) return;
+  for (const file of fs.readdirSync(dir)) {
+    if (file.endsWith(ext)) {
+      fileMap[prefix + file] = fs.readFileSync(path.join(dir, file), "utf-8");
+    }
+  }
+}
+
+function commitAndPushDataBranch() {
+  if (!dataBranch) return;
+  try {
+    const fileMap = {};
+    const memPath = getMemoryPath();
+    if (fs.existsSync(memPath)) {
+      fileMap["sticky-note.json"] = fs.readFileSync(memPath, "utf-8");
+    }
+
+    _collectDirFiles(getAuditDir(), ".jsonl", "audit/", fileMap);
+    _collectDirFiles(getPresenceDir(), ".json", "presence/", fileMap);
+
+    if (Object.keys(fileMap).length === 0) return;
+
+    dataBranch.commitFilesToBranch(dataBranch.DATA_BRANCH, fileMap);
+
+    const remote = dataBranch.getDefaultRemote();
+    if (remote) {
+      const pushResult = dataBranch.pushDataBranch(
+        remote, dataBranch.DATA_BRANCH, 3, getMemoryPath(), loadJson, saveJson
+      );
+      if (!pushResult.ok) {
+        process.stderr.write(
+          "[STICKY-NOTE] warning: failed to push data branch — " + pushResult.error + "\n" +
+          "[STICKY-NOTE] your data is safe locally in .git/sticky-note/\n"
+        );
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      "[STICKY-NOTE] warning: data branch sync failed — " + err.message + "\n"
+    );
+  }
+}
+
 // ── Main ──────────────────────────────────────────────────
 
 function main() {
@@ -946,6 +998,9 @@ function main() {
     }
   }
 
+  // Commit current data to sticky-note/data branch and push
+  commitAndPushDataBranch();
+
   const fileCount = filesTouched.length;
   const commitCount = commitShas.length;
   const statusLabel = isCopilotCli ? "updated" : "closed";