sticky-note-cli 2.9.2 → 3.1.0

package/templates/hooks/inject-context.js

@@ -62,8 +62,9 @@ try {
 const {
   getMemoryPath, loadJson, saveJson, saveMemoryMerged, getUser, getBranch,
   getResumeThreadId, findThreadById, getSessionId,
-  appendAuditLine, detectTool, getConfigPath,
+  appendAuditLine, appendAuditLineBoth, detectTool, getConfigPath,
   isThreadInjected, markThreadInjected, normalizeSep,
+  useCloud, cloudReadThreads, cloudWriteThread,
 } = utils;
 
 // ── Git helpers ───────────────────────────────────────────
@@ -367,7 +368,7 @@ function formatThread(thread, detailed) {
 
 // ── Main ──────────────────────────────────────────────────
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     const raw = require("fs").readFileSync(0, "utf-8");
@@ -385,6 +386,7 @@ function main() {
   }
 
   const sessionId = getSessionId(hookInput);
+  const cloud = useCloud();
 
   function _auditInject(result, threadsScored, threadsInjected, topScores, error) {
     threadsScored = threadsScored || 0;
@@ -402,7 +404,7 @@ function main() {
       };
       if (topScores) entry.top_scores = topScores;
       if (error) entry.error = String(error).substring(0, 200);
-      appendAuditLine(entry);
+      appendAuditLineBoth(entry, cloud);
     } catch (_) {
       // ignore
     }
@@ -410,13 +412,14 @@ function main() {
 
   // Audit the user prompt
   try {
-    appendAuditLine({
+    const promptAudit = {
       type: "user_prompt",
       user: getUser(),
       ts: new Date().toISOString(),
       session_id: sessionId,
       prompt: prompt.substring(0, 500),
-    });
+    };
+    appendAuditLineBoth(promptAudit, cloud);
   } catch (_) {
     // ignore
   }
@@ -436,7 +439,12 @@ function main() {
     }
   }
 
-  const memory = loadJson(getMemoryPath(), { version: "2", threads: [] });
+  const memoryPath = getMemoryPath();
+  const memory = loadJson(memoryPath, { version: "2", threads: [] });
+  if (cloud) {
+    const cloudThreads = await cloudReadThreads();
+    if (cloudThreads) memory.threads = cloudThreads;
+  }
   const threads = (memory.threads || []).filter(Boolean);
 
   const live = threads.filter(
@@ -504,7 +512,13 @@ function main() {
 
   if (memoryDirty) {
     try {
-      saveMemoryMerged(getMemoryPath(), memory);
+      saveMemoryMerged(memoryPath, memory);
+      if (cloud && resumeThreadId) {
+        const resumed = findThreadById(threads, resumeThreadId);
+        if (resumed) {
+          cloudWriteThread(resumed).catch(() => {});
+        }
+      }
     } catch (_) {
       // ignore
     }
@@ -610,7 +624,9 @@ function main() {
   outputLines.unshift(header);
 
   let output = outputLines.join("\n").trim();
-  output += scoringBlock;
+  if (process.env.STICKY_DEBUG) {
+    output += scoringBlock;
+  }
 
   // Prepend overlap warning if other users' threads touch the same files
   const overlapWarning = detectAndFormatOverlaps(threads, currentUser);
@@ -633,9 +649,7 @@ function main() {
 // ── Entry point ───────────────────────────────────────────
 
 if (require.main === module) {
-  try {
-    main();
-  } catch (exc) {
+  main().catch((exc) => {
     try {
       utils.reportHookError("UserPromptSubmit", exc);
     } catch (_) { /* ignore */ }
@@ -650,5 +664,5 @@ if (require.main === module) {
       // ignore
     }
     _safeExit();
-  }
+  });
 }

package/templates/hooks/on-error.js

@@ -19,7 +19,7 @@ function _safeExit() {
   process.exit(0);
 }
 
-let getMemoryPath, loadJson, saveJson, saveMemoryMerged, appendAuditLine, getUser, detectTool, getSessionId;
+let getMemoryPath, loadJson, saveJson, saveMemoryMerged, appendAuditLine, appendAuditLineBoth, getUser, detectTool, getSessionId, useCloud, cloudReadThreads, cloudWriteThread;
 try {
   ({
     getMemoryPath,
@@ -27,15 +27,19 @@ try {
     saveJson,
     saveMemoryMerged,
     appendAuditLine,
+    appendAuditLineBoth,
     getUser,
     detectTool,
     getSessionId,
+    useCloud,
+    cloudReadThreads,
+    cloudWriteThread,
   } = require("./sticky-utils.js"));
 } catch (_) {
   _safeExit();
 }
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     if (!process.stdin.isTTY) {
@@ -57,9 +61,15 @@ function main() {
   const user = getUser();
   const now = new Date().toISOString();
 
+  const cloud = useCloud();
   const memoryPath = getMemoryPath();
   const memory = loadJson(memoryPath, { version: "2", project: "", threads: [] });
 
+  if (cloud) {
+    const cloudThreads = await cloudReadThreads();
+    if (cloudThreads) memory.threads = cloudThreads;
+  }
+
   if (!Array.isArray(memory.threads)) {
     memory.threads = [];
   }
@@ -93,16 +103,21 @@ function main() {
   // thread now. Creating standalone "stuck" threads from tool failures produced
   // garbage entries (tool="Bash"/"Glob", no branch, no context).
 
-  appendAuditLine({
+  const auditEntry = {
     type: "error",
     user: user,
     ts: now,
     session_id: sessionId,
     error: errorMsg,
     tool: toolName,
-  });
+  };
+  appendAuditLineBoth(auditEntry, cloud);
 
   saveMemoryMerged(memoryPath, memory);
+  if (cloud) {
+    const threadToSync = existing || threads[threads.length - 1];
+    cloudWriteThread(threadToSync).catch(() => {});
+  }
   const statusMsg = `[STICKY-NOTE] Marked thread as STUCK - ${errorMsg.substring(0, 80)}`;
   try {
     process.stdout.write(JSON.stringify({ output: statusMsg }) + "\n");
@@ -112,9 +127,7 @@ function main() {
   process.exit(0);
 }
 
-try {
-  main();
-} catch (err) {
-  try { utils.logHookError("on-error", err); } catch (_) {}
+main().catch((err) => {
+  try { logHookError("on-error", err); } catch (_) {}
   _safeExit();
-}
+});

package/templates/hooks/on-stop.js

@@ -34,10 +34,12 @@ try {
 
 const {
   getMemoryPath,
+  getConfigPath,
   loadJson,
   saveJson,
   saveMemoryMerged,
   appendAuditLine,
+  appendAuditLineBoth,
   getUser,
   getBranch,
   getSessionId,
@@ -45,10 +47,10 @@ const {
   extractSessionFromAudit,
   readHeadSha,
   normalizeSep,
+  redactSecrets,
   useCloud,
   cloudReadThreads,
   cloudWriteThread,
-  cloudAppendAudit,
 } = utils;
 
 // Files that belong to sticky-note internals — exclude from files_touched.
@@ -204,6 +206,8 @@ async function main() {
   const cloud = useCloud();
   const memoryPath = getMemoryPath();
   const memory = loadJson(memoryPath, { version: "2", project: "", threads: [] });
+  const config = loadJson(getConfigPath(), {});
+  const shouldRedact = config.redact_transcripts !== false;
 
   if (cloud) {
     const cloudThreads = await cloudReadThreads();
@@ -216,7 +220,8 @@ async function main() {
   const auditFiles = auditData.files || [];
   const gitFiles = getGitFilesTouched();
   const allFiles = [...new Set([...auditFiles, ...gitFiles])];
-  const narrative = buildNarrativeFromAudit(auditData);
+  let narrative = buildNarrativeFromAudit(auditData);
+  if (shouldRedact) narrative = redactSecrets(narrative);
   const workType = classifyWorkType(auditData);
 
   const threads = (memory.threads || []).filter(Boolean);
@@ -243,7 +248,10 @@ async function main() {
       }
       thread.tool_calls = prevCalls;
       // Store prompts if not already present
-      const storedPrompts = (auditData.prompts || []).slice(0, 20).map((p) => p.substring(0, 300));
+      const storedPrompts = (auditData.prompts || []).slice(0, 20).map((p) => {
+        const trimmed = p.substring(0, 300);
+        return shouldRedact ? redactSecrets(trimmed) : trimmed;
+      });
       if (storedPrompts.length && !(thread.prompts || []).length) {
         thread.prompts = storedPrompts;
       }
@@ -267,10 +275,7 @@ async function main() {
     session_id: sessionId,
     reason: reason ? reason.substring(0, 200) : "stop_checkpoint",
   };
-  appendAuditLine(auditEntry);
-  if (cloud) {
-    cloudAppendAudit(auditEntry).catch(() => {});
-  }
+  appendAuditLineBoth(auditEntry, cloud);
 
   saveMemoryMerged(memoryPath, memory);
   if (cloud) {

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

@@ -59,10 +59,11 @@ const {
   getSessionId,
   getUser,
   appendAuditLine,
+  appendAuditLineBoth,
   isThreadInjected,
   markThreadInjected,
-  isOverlapWarned,
-  markOverlapWarned,
+  useCloud,
+  cloudReadPresence,
   getMemoryPath,
   loadJson,
   normalizeSep,
@@ -137,47 +138,41 @@ function formatThreadForInjection(threadData, file) {
   return lines.join("\n");
 }
 
-// ── Overlap deny via COPILOT_LOADER_PID (Copilot CLI only) ──
-// Each Copilot CLI session has a unique COPILOT_LOADER_PID env var.
-// On the first tool call, if overlaps exist, deny with the warning.
-// The warned state is keyed by PID so concurrent sessions don't interfere.
-
-const { execSync } = require("child_process");
-
-function _getRecentlyModifiedFiles() {
-  const files = new Set();
-  for (const target of ["HEAD~5", "HEAD~1"]) {
-    try {
-      const result = execSync(`git diff --name-only ${target}`, {
-        encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
-      });
-      for (const f of result.trim().split(/\r?\n/)) {
-        if (f.trim()) files.add(f.trim());
-      }
-      break;
-    } catch (_) { /* target doesn't exist */ }
-  }
+let _presenceCache = null;
+let _presenceCacheTs = 0;
+const PRESENCE_CACHE_TTL_MS = 60000;
+
+async function _checkConflict(filePath) {
+  if (!filePath || !useCloud()) return "";
   try {
-    const result = execSync("git diff --name-only", {
-      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    const now = Date.now();
+    if (!_presenceCache || (now - _presenceCacheTs) > PRESENCE_CACHE_TTL_MS) {
+      _presenceCache = await cloudReadPresence();
+      _presenceCacheTs = now;
+    }
+    const presence = _presenceCache;
+    if (!presence) return "";
+    const currentUser = getUser();
+    const conflicting = presence.filter(p => {
+      if (!p.user || p.user === currentUser) return false;
+      return (p.active_files || []).some(f =>
+        f === filePath || filePath.endsWith(f) || f.endsWith(filePath)
+      );
     });
-    for (const f of result.trim().split(/\r?\n/)) {
-      if (f.trim()) files.add(f.trim());
+    if (conflicting.length > 0) {
+      const names = conflicting.map(p => p.user).join(", ");
+      return `⚠️ [STICKY-NOTE] Conflict warning: ${names} also editing ${filePath}`;
     }
-  } catch (_) { /* ignore */ }
-  return files;
+  } catch (_) {
+    // ignore
+  }
+  return "";
 }
 
-function _checkOverlapsAndDeny() {
-  // Overlap alerting is now handled by the MCP server's check_overlaps tool.
-  // This deny-based approach was unreliable (deny reason consumed silently).
-  // Kept as no-op to avoid breaking the call site.
-  return null;
-}
 
 // ── Main ──────────────────────────────────────────────────
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     const raw = require("fs").readFileSync(0, "utf-8");
@@ -189,6 +184,7 @@ function main() {
   }
 
   const sessionId = getSessionId(hookInput);
+  const cloud = useCloud();
 
   // ── Auto-sync before git pull/merge/rebase ──
   // Prevents "local changes would be overwritten" errors for .sticky-note/ files
@@ -201,14 +197,6 @@ function main() {
     }
   }
 
-  // ── Overlap deny gate (Copilot CLI only) ──
-  // Detect overlaps and deny on first tool call, keyed by COPILOT_LOADER_PID.
-  const denyResult = _checkOverlapsAndDeny();
-  if (denyResult) {
-    process.stdout.write(JSON.stringify(denyResult) + "\n");
-    return;
-  }
-
   // Extract file path from tool input
   const filePath = extractFilePath(hookInput);
   if (!filePath) {
@@ -216,7 +204,6 @@ function main() {
     return;
   }
 
-  // Run attribution engine: get threads for this file with line ranges
   let fileAttr;
   try {
     fileAttr = attribution.getFileAttribution(filePath);
@@ -226,6 +213,10 @@ function main() {
   }
 
   if (!fileAttr || !fileAttr.threads || fileAttr.threads.length === 0) {
+    if (cloud) {
+      const warning = await _checkConflict(filePath);
+      if (warning) { _emit(warning); return; }
+    }
     _emit("");
     return;
   }
@@ -236,6 +227,10 @@ function main() {
   );
 
   if (newThreads.length === 0) {
+    if (cloud) {
+      const warning = await _checkConflict(filePath);
+      if (warning) { _emit(warning); return; }
+    }
     _emit("");
     return;
   }
@@ -248,11 +243,11 @@ function main() {
     markThreadInjected(threadId, sessionId);
   }
 
-  const output = outputParts.join("\n\n");
+  let output = outputParts.join("\n\n");
 
   // Audit the injection
   try {
-    appendAuditLine({
+    const auditEntry = {
       type: "lazy_inject",
       user: getUser(),
       ts: new Date().toISOString(),
@@ -263,20 +258,22 @@ function main() {
         const id = t.thread ? t.thread.id : t.id;
         return (id || "").substring(0, 8);
       }),
-    });
+    };
+    appendAuditLineBoth(auditEntry, cloud);
   } catch (_) {
     // ignore
   }
 
+  if (cloud) {
+    const warning = await _checkConflict(filePath);
+    if (warning) output += "\n\n" + warning;
+  }
+
   _emit(output);
 }
 
 // ── Entry point ───────────────────────────────────────────
 
 if (require.main === module) {
-  try {
-    main();
-  } catch (_) {
-    _safeExit();
-  }
+  main().catch(() => _safeExit());
 }