sticky-note-cli 3.0.0 → 3.1.1

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());
 }

package/templates/hooks/session-end.js

@@ -39,10 +39,14 @@ const {
   getPresenceDir,
   getUserPresencePath,
   getAllAuditPaths,
+  getTranscriptsDir,
+  getTranscriptPath,
+  redactSecrets,
   loadJson,
   saveJson,
   saveMemoryMerged,
   appendAuditLine,
+  appendAuditLineBoth,
   getUser,
   getBranch,
   detectTool,
@@ -63,6 +67,10 @@ const {
   clearActiveResumeThreadId,
   clearInjectedSet,
   normalizeSep,
+  useCloud,
+  cloudReadThreads,
+  cloudWriteThread,
+  cloudDeletePresence,
   syncStickyNote,
 } = utils;
 
@@ -368,6 +376,73 @@ function extractFailedApproaches(hookInput) {
   return extractFailedFromEntries(entries);
 }
 
+// ── Transcript capture ────────────────────────────────────
+// Persists the full verbatim session transcript (Claude Code's native
+// transcript_path JSONL file) into sticky-note/data storage, keyed by
+// thread ID rather than commit SHA — a thread's transcript belongs to the
+// whole session, which may span zero, one, or many commits. Appended as
+// one entry per contributing session so resumed threads accumulate their
+// full history rather than overwriting it.
+//
+// Opt-out: set "capture_transcripts": false in sticky-note-config.json.
+// Secrets are redacted (best-effort — see redactSecrets in sticky-utils.js)
+// before anything is written to disk or committed.
+
+function captureTranscript(hookInput, threadId, sessionId, aiTool, user, now, config) {
+  if (!threadId) return false;
+  if (config.capture_transcripts === false) return false;
+
+  const transcriptPath = hookInput.transcript_path || "";
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return false;
+
+  let raw;
+  try {
+    raw = fs.readFileSync(transcriptPath, "utf-8");
+  } catch (_) {
+    return false;
+  }
+  if (!raw || !raw.trim()) return false;
+
+  const redact = config.redact_transcripts !== false;
+  const transcript = redact ? redactSecrets(raw) : raw;
+
+  const entry = {
+    session_id: sessionId,
+    tool: aiTool,
+    user,
+    captured_at: now,
+    redacted: redact,
+    transcript,
+  };
+
+  try {
+    const dir = getTranscriptsDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = getTranscriptPath(threadId);
+
+    // Avoid duplicating the same session's transcript on repeated
+    // session-end fires (e.g. Copilot CLI's per-turn SessionEnd).
+    let existingLines = [];
+    if (fs.existsSync(filePath)) {
+      existingLines = fs.readFileSync(filePath, "utf-8")
+        .split(/\r?\n/)
+        .filter((l) => l.trim());
+    }
+    const filtered = existingLines.filter((line) => {
+      try {
+        return JSON.parse(line).session_id !== sessionId;
+      } catch (_) {
+        return true;
+      }
+    });
+    filtered.push(JSON.stringify(entry));
+    fs.writeFileSync(filePath, filtered.join("\n") + "\n", "utf-8");
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
 // ── Last note extraction ──────────────────────────────────
 
 function extractLastNote(hookInput, narrative, sessionAnalysis, auditData) {
@@ -720,13 +795,7 @@ function tombstoneSweep(threads, staleDays) {
 
 function clearPresence(user) {
   const presencePath = getUserPresencePath(user);
-  try {
-    if (fs.existsSync(presencePath)) {
-      fs.unlinkSync(presencePath);
-    }
-  } catch (_) {
-    // ignore
-  }
+  try { fs.unlinkSync(presencePath); } catch (_) {}
 }
 
 // ── Data-branch commit/push ───────────────────────────────
@@ -752,6 +821,7 @@ function commitAndPushDataBranch() {
 
     _collectDirFiles(getAuditDir(), ".jsonl", "audit/", fileMap);
     _collectDirFiles(getPresenceDir(), ".json", "presence/", fileMap);
+    _collectDirFiles(getTranscriptsDir(), ".jsonl", "transcripts/", fileMap);
 
     if (Object.keys(fileMap).length === 0) return;
 
@@ -778,7 +848,7 @@ function commitAndPushDataBranch() {
 
 // ── Main ──────────────────────────────────────────────────
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     const raw = fs.readFileSync(0, "utf-8");
@@ -794,17 +864,43 @@ function main() {
   const now = new Date().toISOString();
   const branch = getBranch();
 
+  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;
+  }
   const config = loadJson(getConfigPath(), { stale_days: 14 });
   const staleDays = config.stale_days || 14;
 
   let filesTouched = extractFilesTouched(hookInput);
   const auditData = extractSessionFromAudit(sessionId);
   const sessionAnalysis = analyzeSessionActivities(hookInput, auditData);
-  const narrative = extractNarrative(hookInput);
-  const failed = extractFailedApproaches(hookInput);
-  const lastNote = extractLastNote(hookInput, narrative, sessionAnalysis, auditData);
+  let narrative = extractNarrative(hookInput);
+  let failed = extractFailedApproaches(hookInput);
+  let lastNote = extractLastNote(hookInput, narrative, sessionAnalysis, auditData);
+
+  // Redact secrets from these summary fields too — they're pulled from the
+  // same raw transcript as the full-transcript capture below, and land in
+  // sticky-note.json, which syncs to the whole team the same way the
+  // transcript store does. Without this, redact_transcripts would protect
+  // the verbatim copy while leaving the same secret sitting in plain sight
+  // in narrative/last_note/prompts.
+  if (config.redact_transcripts !== false) {
+    narrative = redactSecrets(narrative);
+    lastNote = redactSecrets(lastNote);
+    failed = failed.map((f) => {
+      if (typeof f === "string") return redactSecrets(f);
+      if (f && typeof f === "object") {
+        const copy = { ...f };
+        if (typeof copy.description === "string") copy.description = redactSecrets(copy.description);
+        if (typeof copy.error === "string") copy.error = redactSecrets(copy.error);
+        return copy;
+      }
+      return f;
+    });
+  }
 
   // Merge audit-discovered files
   const auditFiles = auditData.files || [];
@@ -884,7 +980,10 @@ function main() {
   // Prompts from audit
   const prompts = auditData.prompts || [];
   const storedPrompts = prompts.length
-    ? prompts.slice(0, 20).map((p) => p.substring(0, 300))
+    ? prompts.slice(0, 20).map((p) => {
+        const trimmed = p.substring(0, 300);
+        return config.redact_transcripts !== false ? redactSecrets(trimmed) : trimmed;
+      })
     : [];
 
   if (existing) {
@@ -920,7 +1019,7 @@ function main() {
     }
   } else {
     // Create new thread
-    threads.push({
+    existing = {
       id: crypto.randomUUID(),
       user,
       project: memory.project || "",
@@ -945,9 +1044,17 @@ function main() {
       // V2.5 fields
       contributors: [user],
       resume_history: [],
-    });
+    };
+    threads.push(existing);
   }
 
+  // Persist the full verbatim transcript for this session, keyed by
+  // thread ID. Opt-out via capture_transcripts: false in team config.
+  const transcriptCaptured = captureTranscript(
+    hookInput, existing.id, sessionId, aiTool, user, now, config
+  );
+  if (transcriptCaptured) existing.transcript_captured = true;
+
   // V2.5: Capture commit SHAs for attribution engine
   const commitShas = getSessionCommitShas();
 
@@ -966,33 +1073,42 @@ function main() {
   if (commitShas.length > 0) {
     auditEntry.commit_shas = commitShas;
   }
-  appendAuditLine(auditEntry);
+  appendAuditLineBoth(auditEntry, cloud);
 
   // V2.5: Also write individual commit_sha audit entries for bridge lookup
   for (const sha of commitShas) {
-    appendAuditLine({
+    const commitEntry = {
       type: "commit",
       user,
       ts: now,
       session_id: sessionId,
       commit_sha: sha,
-    });
+    };
+    appendAuditLineBoth(commitEntry, cloud);
   }
   // Only clear transient files for true session end (Claude Code).
   // Copilot CLI fires per-turn; clearing would break state across turns.
   if (!isCopilotCli) {
     clearPresence(user);
+    if (cloud) {
+      cloudDeletePresence(user).catch(() => {});
+    }
     clearSessionFile();
     clearHeadFile();
     clearInjectedSet();
   }
   saveMemoryMerged(memoryPath, memory);
+  if (cloud) {
+    const threadToSync = threads.find(t => t.session_id === sessionId);
+    if (threadToSync) {
+      cloudWriteThread(threadToSync).catch(() => {});
+    }
+  }
 
   // Auto-sync: commit (and optionally push) .sticky-note/ changes
-  const syncConfig = loadJson(getConfigPath(), {});
-  if (syncConfig.auto_sync !== false) {
+  if (config.auto_sync !== false) {
     try {
-      syncStickyNote({ push: syncConfig.auto_push === true });
+      syncStickyNote({ push: config.auto_push === true });
     } catch (_) {
       // Non-fatal — sync failure shouldn't block session-end
     }
@@ -1013,9 +1129,7 @@ function main() {
   process.exit(0);
 }
 
-try {
-  main();
-} catch (err) {
+main().catch((err) => {
   try { utils.logHookError("session-end", err); } catch (_) {}
   _safeExit();
-}
+});

package/templates/hooks/session-start.js

@@ -118,6 +118,7 @@ const {
   saveJson,
   saveMemoryMerged,
   appendAuditLine,
+  appendAuditLineBoth,
   getUser,
   getBranch,
   getSessionId,
@@ -130,6 +131,10 @@ const {
   markThreadInjected,
   clearActiveResumeThreadId,
   getActiveResumeThreadId,
+  useCloud,
+  cloudReadThreads,
+  cloudReadPresence,
+  cloudReadConfig,
   normalizeSep,
   detectLostThreads,
 } = utils;
@@ -926,7 +931,7 @@ function fetchAndMergeDataBranch() {
 
 // ── Main ──────────────────────────────────────────────────
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     if (!process.stdin.isTTY) {
@@ -969,6 +974,7 @@ function main() {
   // Auto-register sticky-note MCP server in .mcp.json
   ensureMcpServerRegistered();
 
+  const cloud = useCloud();
   const memoryPath = getMemoryPath();
   const memory = loadJson(memoryPath, {
     version: "2",
@@ -976,6 +982,12 @@ function main() {
     threads: [],
   });
 
+  let cloudThreads = null, cloudConfig = null;
+  if (cloud) {
+    [cloudThreads, cloudConfig] = await Promise.all([cloudReadThreads(), cloudReadConfig()]);
+  }
+  if (cloudThreads) memory.threads = cloudThreads;
+
   // Rollback detection: warn if threads went missing (e.g., after git reset)
   try {
     const lost = detectLostThreads(memoryPath);
@@ -989,7 +1001,7 @@ function main() {
     }
   } catch (_) { /* rollback detection must not break session */ }
 
-  const config = loadJson(getConfigPath(), { stale_days: 14 });
+  const config = cloudConfig || loadJson(getConfigPath(), { stale_days: 14 });
   const staleDays = config.stale_days != null ? config.stale_days : 14;
   const autoCloseHours =
     config.copilot_cli_auto_close_hours != null
@@ -1072,7 +1084,20 @@ function main() {
   const threadResult = formatThreadsForInjection((memory.threads || []).filter(Boolean));
   const threadContext = threadResult.text;
   const configContext = formatConfigForInjection(config);
-  const presenceData = loadAllPresence();
+  let presenceData;
+  if (cloud) {
+    const cloudPresence = await cloudReadPresence();
+    if (cloudPresence) {
+      presenceData = {};
+      for (const entry of cloudPresence) {
+        const u = entry.user || entry.name;
+        if (u) presenceData[u] = entry;
+      }
+    }
+  }
+  if (!presenceData) {
+    presenceData = loadAllPresence();
+  }
   const presenceContext = formatPresence(presenceData, (memory.threads || []).filter(Boolean));
   const overlapContext = formatOverlapWarnings(
     (memory.threads || []).filter(Boolean), getUser(), memory
@@ -1088,12 +1113,13 @@ function main() {
     }
   }
 
-  appendAuditLine({
+  const auditEntry = {
     type: "session_start",
     user: getUser(),
     ts: new Date().toISOString(),
     session_id: sessionId,
-  });
+  };
+  appendAuditLineBoth(auditEntry, cloud);
 
   saveMemoryMerged(memoryPath, memory);
 
@@ -1228,11 +1254,9 @@ function main() {
 
 // ── Entry point ───────────────────────────────────────────
 
-try {
-  main();
-} catch (err) {
+main().catch((err) => {
   try { utils.reportHookError("session-start", err); } catch (_) {
     try { utils.logHookError("session-start", err); } catch (_) {}
   }
   _safeExit();
-}
+});

package/templates/hooks/sticky-codex.ps1

@@ -1,17 +1,17 @@
-# sticky-codex.ps1 - Codex wrapper for Sticky Note V2 (Windows)
+# sticky-codex.ps1 - Codex wrapper for Sticky Note V3 (Windows)
 #
 # Captures Codex stdout/stderr to a temp session log.
 # On exit: calls session-end.js with the transcript for
 # narrative + failed_approaches extraction.
 #
+# V3: If STICKY_URL is set, reads cloud context before session start
+# and writes session data to cloud on exit (via hook scripts).
+#
 # Usage:
 #   .\sticky-codex.ps1 [codex args...]
 #
 # Setup:
 #   npx sticky-note init --codex
-#
-# Limitation: Context is printed to terminal after Codex exits,
-# not injected into the Codex window. Per-prompt surfacing not available.
 
 param(
     [Parameter(ValueFromRemainingArguments = $true)]
@@ -34,6 +34,22 @@ Write-Host ""
 Write-Host "[STICKY-NOTE] Injecting context for Codex session $SessionId"
 Write-Host ""
 
+# Load .env.sticky if it exists (for STICKY_URL and STICKY_API_KEY)
+$EnvStickyFile = Join-Path (Split-Path -Parent (Split-Path -Parent $ScriptDir)) ".env.sticky"
+if (Test-Path $EnvStickyFile) {
+    Get-Content $EnvStickyFile | ForEach-Object {
+        $line = $_.Trim()
+        if ($line -and -not $line.StartsWith("#")) {
+            $eq = $line.IndexOf("=")
+            if ($eq -gt 0) {
+                $key = $line.Substring(0, $eq).Trim()
+                $val = $line.Substring($eq + 1).Trim()
+                [Environment]::SetEnvironmentVariable($key, $val, "Process")
+            }
+        }
+    }
+}
+
 $MemoryFile = Join-Path $StickyDir "sticky-note.json"
 if (Test-Path $MemoryFile) {
     try {

package/templates/hooks/sticky-codex.sh

@@ -1,19 +1,19 @@
 #!/usr/bin/env bash
-# sticky-codex.sh — Codex wrapper for Sticky Note V2
+# sticky-codex.sh — Codex wrapper for Sticky Note V3
 #
 # Captures Codex stdout/stderr to a temp session log.
 # On exit: calls session-end.js with the transcript for
 # narrative + failed_approaches extraction.
 #
+# V3: If STICKY_URL is set, reads cloud context before session start
+# and writes session data to cloud on exit (via hook scripts).
+#
 # Usage:
 #   sticky-codex [codex args...]
 #
 # Setup:
 #   npx sticky-note init --codex
 #   alias sticky-codex="/path/to/.claude/hooks/sticky-codex.sh"
-#
-# Limitation: Context is printed to terminal after Codex exits,
-# not injected into the Codex window. Per-prompt surfacing not available.
 
 set -euo pipefail
 
@@ -28,9 +28,18 @@ mkdir -p "$STICKY_DIR"
 
 # Print context from sticky-note before starting Codex
 echo ""
-echo "📌 Sticky Note — injecting context for Codex session $SESSION_ID"
+echo "[STICKY-NOTE] Injecting context for Codex session $SESSION_ID"
 echo ""
 
+# Load .env.sticky if it exists (for STICKY_URL and STICKY_API_KEY)
+ENV_STICKY="$(cd "$SCRIPT_DIR/../.." && pwd)/.env.sticky"
+if [ -f "$ENV_STICKY" ]; then
+    set -a
+    # shellcheck disable=SC1090
+    source "$ENV_STICKY"
+    set +a
+fi
+
 if [ -f "$STICKY_DIR/sticky-note.json" ]; then
     node "$SCRIPT_DIR/session-start.js" <<EOF 2>/dev/null || true
 {"session_id": "$SESSION_ID"}