sticky-note-cli 3.1.42 → 3.1.44

package/bin/cli.js

@@ -744,6 +744,29 @@ async function cmdInit() {
         v3Mode ? "y" : "N"
       );
       wantsCloud = cloudAnswer.toLowerCase() === "y" || cloudAnswer.toLowerCase() === "yes";
+
+      // Always ask for STICKY_PUSH_TOKEN — needed for data branch push from hook
+      // processes regardless of whether cloud backend is configured.
+      print("\n  A GitHub Personal Access Token (PAT) is needed so sticky-note can push");
+      print("  thread data in the background without requiring interactive credential access.");
+      print("  Create one at https://github.com/settings/tokens with 'repo' scope (or");
+      print("  'contents: write' for fine-grained tokens).");
+      const pushTokenAnswer = await ask(rl, "Enter your STICKY_PUSH_TOKEN (GitHub PAT, leave blank to skip)", "");
+      if (pushTokenAnswer.trim()) {
+        const envStickyPath = path.join(process.cwd(), ".env.sticky");
+        let envContent = "";
+        try { envContent = fs.readFileSync(envStickyPath, "utf-8"); } catch (_) {}
+        if (!envContent.endsWith("\n") && envContent.length > 0) envContent += "\n";
+        if (!/^STICKY_PUSH_TOKEN=/m.test(envContent)) {
+          envContent += `STICKY_PUSH_TOKEN=${pushTokenAnswer.trim()}\n`;
+        } else {
+          envContent = envContent.replace(/^STICKY_PUSH_TOKEN=.+$/m, `STICKY_PUSH_TOKEN=${pushTokenAnswer.trim()}`);
+        }
+        fs.writeFileSync(envStickyPath, envContent, "utf-8");
+        print("  [OK] STICKY_PUSH_TOKEN written to .env.sticky");
+      } else {
+        print("  ⏭️  No PAT entered — data branch push will rely on system credential helper");
+      }
     }
 
     rl.close();
@@ -877,6 +900,19 @@ async function cmdInit() {
           print(`    wrangler secret put GITHUB_REPO  # value: ${repo.trim()}`);
         }
       }
+      // Also write STICKY_PUSH_TOKEN to .env.sticky so session-end hook can
+      // push the data branch from background processes without a credential helper.
+      try {
+        const envStickyPath = path.join(process.cwd(), ".env.sticky");
+        let envContent = "";
+        try { envContent = fs.readFileSync(envStickyPath, "utf-8"); } catch (_) {}
+        if (!envContent.endsWith("\n") && envContent.length > 0) envContent += "\n";
+        if (!/^STICKY_PUSH_TOKEN=/m.test(envContent)) {
+          envContent += `STICKY_PUSH_TOKEN=${pat.trim()}\n`;
+          fs.writeFileSync(envStickyPath, envContent, "utf-8");
+          print("  ✓ STICKY_PUSH_TOKEN written to .env.sticky (data branch push)");
+        }
+      } catch (_) {}
     }
     rl2.close();
 
@@ -1071,10 +1107,11 @@ async function cmdInit() {
     print("  ⏭️  .gitignore already configured");
   }
 
-  // Add .gitattributes merge strategy
+  // Add .gitattributes merge strategy for both thread data and config
   const gitattrsPath = path.join(process.cwd(), ".gitattributes");
   const oldMergeRule = ".sticky-note/sticky-note.json merge=union";
   const mergeRule = ".sticky-note/sticky-note.json merge=sticky-note";
+  const configMergeRule = ".sticky-note/sticky-note-config.json merge=sticky-note";
   let gitattrsContent = "";
   if (fs.existsSync(gitattrsPath)) {
     gitattrsContent = fs.readFileSync(gitattrsPath, "utf-8");
@@ -1089,10 +1126,18 @@ async function cmdInit() {
       ? `\n# Sticky Note - JSON-aware thread merge\n${mergeRule}\n`
       : `\n\n# Sticky Note - JSON-aware thread merge\n${mergeRule}\n`;
     fs.appendFileSync(gitattrsPath, addition);
+    gitattrsContent += addition;
     print("  [OK] .gitattributes updated (merge=sticky-note)");
   } else {
     print("  ⏭️  .gitattributes already configured");
   }
+  // Also protect sticky-note-config.json — merge conflicts here silently break
+  // cloud transport and hook loading for the entire team.
+  if (!gitattrsContent.includes(configMergeRule)) {
+    const addition = `${configMergeRule}\n`;
+    fs.appendFileSync(gitattrsPath, addition);
+    print("  [OK] .gitattributes: sticky-note-config.json protected from merge conflicts");
+  }
 
   // Install merge driver script and git config
   const mergeDriverSrc = path.join(TEMPLATES_DIR, "merge-driver.js");
@@ -1452,14 +1497,25 @@ async function cmdUpdate() {
     }
   }
 
-  if (fs.existsSync(gitattrsPath)) {
-    let gitattrsContent = fs.readFileSync(gitattrsPath, "utf-8");
+  {
+    let gitattrsContent = fs.existsSync(gitattrsPath)
+      ? fs.readFileSync(gitattrsPath, "utf-8") : "";
     const oldRule = ".sticky-note/sticky-note.json merge=union";
     const newRule = ".sticky-note/sticky-note.json merge=sticky-note";
+    const configRule = ".sticky-note/sticky-note-config.json merge=sticky-note";
     if (gitattrsContent.includes(oldRule)) {
       gitattrsContent = gitattrsContent.replace(oldRule, newRule);
       fs.writeFileSync(gitattrsPath, gitattrsContent, "utf-8");
       print("  [OK] .gitattributes upgraded (merge=union -> merge=sticky-note)");
+    } else if (!gitattrsContent.includes(newRule)) {
+      const addition = `\n# Sticky Note - JSON-aware thread merge\n${newRule}\n`;
+      fs.appendFileSync(gitattrsPath, addition);
+      gitattrsContent += addition;
+      print("  [OK] .gitattributes updated (merge=sticky-note)");
+    }
+    if (!gitattrsContent.includes(configRule)) {
+      fs.appendFileSync(gitattrsPath, `${configRule}\n`);
+      print("  [OK] .gitattributes: sticky-note-config.json protected from merge conflicts");
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "3.1.42",
+  "version": "3.1.44",
   "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/session-end.js

@@ -954,7 +954,7 @@ function _collectDirFiles(dir, ext, prefix, fileMap) {
 }
 
 function commitAndPushDataBranch() {
-  if (!dataBranch) return;
+  if (!dataBranch) return null;
   try {
     const fileMap = {};
     const memPath = getMemoryPath();
@@ -966,7 +966,7 @@ function commitAndPushDataBranch() {
     _collectDirFiles(getPresenceDir(), ".json", "presence/", fileMap);
     _collectDirFiles(getTranscriptsDir(), ".jsonl", "transcripts/", fileMap);
 
-    if (Object.keys(fileMap).length === 0) return;
+    if (Object.keys(fileMap).length === 0) return null;
 
     dataBranch.commitFilesToBranch(dataBranch.DATA_BRANCH, fileMap);
 
@@ -976,16 +976,18 @@ function commitAndPushDataBranch() {
         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"
-        );
+        const hint = pushResult.error && pushResult.error.includes("authentication")
+          ? " Add STICKY_PUSH_TOKEN=<github_pat> to .env.sticky to fix."
+          : "";
+        const msg = `[STICKY-NOTE] ⚠️ data branch push failed — ${pushResult.error}${hint}`;
+        logHookError("data-branch-push", new Error(pushResult.error));
+        return msg;
       }
     }
+    return null;
   } catch (err) {
-    process.stderr.write(
-      "[STICKY-NOTE] warning: data branch sync failed — " + err.message + "\n"
-    );
+    logHookError("data-branch-sync", err);
+    return `[STICKY-NOTE] ⚠️ data branch sync failed — ${err.message}`;
   }
 }
 
@@ -1306,7 +1308,9 @@ async function main() {
   if (cloud) {
     const threadToSync = threads.find(t => t.session_id === sessionId);
     if (threadToSync) {
-      cloudWriteThread(threadToSync).catch(() => {});
+      cloudWriteThread(threadToSync).catch(err => {
+        logHookError("session-end:cloud-write", err);
+      });
     }
   }
 
@@ -1320,14 +1324,15 @@ async function main() {
   }
 
   // Commit current data to sticky-note/data branch and push
-  commitAndPushDataBranch();
+  const dataBranchWarning = commitAndPushDataBranch();
 
   const fileCount = filesTouched.length;
   const commitCount = commitShas.length;
   const statusLabel = isCopilotCli ? "updated" : "closed";
   const statusMsg = `[STICKY-NOTE] Session ${statusLabel} - thread ${isCopilotCli ? "updated" : "created"} (${fileCount} file${fileCount !== 1 ? "s" : ""}${commitCount > 0 ? ", " + commitCount + " commit" + (commitCount !== 1 ? "s" : "") : ""})`;
+  const fullOutput = dataBranchWarning ? `${statusMsg}\n${dataBranchWarning}` : statusMsg;
   try {
-    process.stdout.write(JSON.stringify({ output: statusMsg }) + "\n");
+    process.stdout.write(JSON.stringify({ output: fullOutput }) + "\n");
   } catch (_) {
     process.stdout.write('{"output":""}\n');
   }

package/templates/hooks/session-start.js

@@ -69,15 +69,38 @@ function _installedCliVersion() {
 }
 function formatVersionWarning(config) {
   try {
-    const min = config && config.min_version;
-    if (!min) return "";
     const installed = _installedCliVersion();
     if (!installed) return "";
-    if (_cmpSemver(installed, min) >= 0) return "";
-    const msg =
-      `[STICKY-NOTE] ⚠️ Installed sticky-note-cli v${installed} is below ` +
-      `this project's min_version v${min}. Run \`npm i -D sticky-note-cli@latest\` ` +
-      `to update — features and schema may differ until you do.`;
+    const warnings = [];
+
+    // Check 1: installed version is below the project's required minimum.
+    const min = config && config.min_version;
+    if (min && _cmpSemver(installed, min) < 0) {
+      warnings.push(
+        `[STICKY-NOTE] ⚠️ sticky-note-cli v${installed} is below this project's ` +
+        `min_version v${min}. Run \`npm i -g sticky-note-cli@latest\` to update — ` +
+        `features and bug fixes are missing until you do.`
+      );
+    }
+
+    // Check 2: hook scripts in .claude/hooks/ are older than the installed CLI.
+    // This means the teammate installed a newer CLI but never ran `npx sticky-note update`
+    // to refresh the hook files — they're running old code with new expectations.
+    const hookVer = config && config.hook_version;
+    if (hookVer && _cmpSemver(installed, hookVer) > 0) {
+      const iv = _parseSemver(installed), hv = _parseSemver(hookVer);
+      // Warn on any minor or major gap — patch-only differences are usually safe.
+      if (iv && hv && (iv[0] !== hv[0] || iv[1] !== hv[1])) {
+        warnings.push(
+          `[STICKY-NOTE] ⚠️ Hook scripts are v${hookVer} but sticky-note-cli v${installed} ` +
+          `is installed. Run \`npx sticky-note update\` to get the latest fixes ` +
+          `(data branch push, identity, credential handling).`
+        );
+      }
+    }
+
+    if (warnings.length === 0) return "";
+    const msg = warnings.join("\n");
     try { process.stderr.write(msg + "\n"); } catch (_) { /* non-fatal */ }
     return msg;
   } catch (_) {

package/templates/hooks/sticky-utils.js

@@ -450,6 +450,20 @@ function clearResumeSignal() {
 function loadJson(filePath, defaultVal) {
   try {
     const raw = fs.readFileSync(filePath, "utf-8");
+    // Detect unresolved git merge conflict markers — JSON.parse would silently
+    // swallow the SyntaxError and return the default, hiding the real problem.
+    // This breaks useCloud(), thread loading, and config reading with no trace.
+    if (raw.includes("<<<<<<<") || raw.includes(">>>>>>>")) {
+      logHookError(
+        "loadJson",
+        new Error(
+          `Unresolved git merge conflict in ${filePath}. ` +
+          `Resolve the conflict and commit, or restore the file with ` +
+          `\`git checkout HEAD -- ${path.relative(process.cwd(), filePath) || filePath}\``
+        )
+      );
+      return defaultVal !== undefined ? defaultVal : {};
+    }
     return JSON.parse(raw);
   } catch (_) {
     return defaultVal !== undefined ? defaultVal : {};