sticky-note-cli 2.9.2 → 3.1.0

package/templates/hooks/session-end.js

@@ -29,15 +29,24 @@ try {
   _safeExit();
 }
 
+let dataBranch = null;
+try { dataBranch = require("./data-branch.js"); } catch (_) {}
+
 const {
   getMemoryPath,
   getConfigPath,
+  getAuditDir,
+  getPresenceDir,
   getUserPresencePath,
   getAllAuditPaths,
+  getTranscriptsDir,
+  getTranscriptPath,
+  redactSecrets,
   loadJson,
   saveJson,
   saveMemoryMerged,
   appendAuditLine,
+  appendAuditLineBoth,
   getUser,
   getBranch,
   detectTool,
@@ -58,6 +67,10 @@ const {
   clearActiveResumeThreadId,
   clearInjectedSet,
   normalizeSep,
+  useCloud,
+  cloudReadThreads,
+  cloudWriteThread,
+  cloudDeletePresence,
   syncStickyNote,
 } = utils;
 
@@ -363,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) {
@@ -715,18 +795,60 @@ function tombstoneSweep(threads, staleDays) {
 
 function clearPresence(user) {
   const presencePath = getUserPresencePath(user);
+  try { fs.unlinkSync(presencePath); } catch (_) {}
+}
+
+// ── 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 {
-    if (fs.existsSync(presencePath)) {
-      fs.unlinkSync(presencePath);
+    const fileMap = {};
+    const memPath = getMemoryPath();
+    if (fs.existsSync(memPath)) {
+      fileMap["sticky-note.json"] = fs.readFileSync(memPath, "utf-8");
     }
-  } catch (_) {
-    // ignore
+
+    _collectDirFiles(getAuditDir(), ".jsonl", "audit/", fileMap);
+    _collectDirFiles(getPresenceDir(), ".json", "presence/", fileMap);
+    _collectDirFiles(getTranscriptsDir(), ".jsonl", "transcripts/", 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() {
+async function main() {
   let hookInput = {};
   try {
     const raw = fs.readFileSync(0, "utf-8");
@@ -742,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 || [];
@@ -832,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) {
@@ -868,7 +1019,7 @@ function main() {
     }
   } else {
     // Create new thread
-    threads.push({
+    existing = {
       id: crypto.randomUUID(),
       user,
       project: memory.project || "",
@@ -893,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();
 
@@ -914,38 +1073,50 @@ 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
     }
   }
 
+  // Commit current data to sticky-note/data branch and push
+  commitAndPushDataBranch();
+
   const fileCount = filesTouched.length;
   const commitCount = commitShas.length;
   const statusLabel = isCopilotCli ? "updated" : "closed";
@@ -958,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

@@ -105,6 +105,10 @@ try {
 // session-start to run.
 try { utils.selfHealHookPaths && utils.selfHealHookPaths(); } catch (_) { /* non-fatal */ }
 
+// Non-fatal: data-branch sync is disabled if the module is missing.
+let dataBranch = null;
+try { dataBranch = require("./data-branch.js"); } catch (_) {}
+
 const {
   getMemoryPath,
   getConfigPath,
@@ -114,6 +118,7 @@ const {
   saveJson,
   saveMemoryMerged,
   appendAuditLine,
+  appendAuditLineBoth,
   getUser,
   getBranch,
   getSessionId,
@@ -126,6 +131,10 @@ const {
   markThreadInjected,
   clearActiveResumeThreadId,
   getActiveResumeThreadId,
+  useCloud,
+  cloudReadThreads,
+  cloudReadPresence,
+  cloudReadConfig,
   normalizeSep,
   detectLostThreads,
 } = utils;
@@ -879,9 +888,50 @@ function ensureEnvironmentProvisioned() {
   if (debug) process.stderr.write("[sticky-note] environment provisioning complete\n");
 }
 
+// ── Data branch fetch-and-merge ───────────────────────────
+
+/**
+ * Fetches the remote sticky-note/data branch and merges into local memory.
+ * Also reads from the LOCAL data branch (fresh clones, offline, tests).
+ * Non-blocking — the session continues with local data on any failure.
+ */
+function fetchAndMergeDataBranch() {
+  if (!dataBranch) return;
+
+  const memPath = getMemoryPath();
+  const mergeFrom = (ref) => {
+    const content = dataBranch.readFileFromBranch(ref, "sticky-note.json");
+    if (content) {
+      dataBranch.mergeAndSaveFromRemote(memPath, content, loadJson, saveJson);
+    }
+  };
+
+  try {
+    const remote = dataBranch.getDefaultRemote();
+
+    if (remote) {
+      const fetchResult = dataBranch.fetchDataBranch(remote);
+      if (!fetchResult.ok) {
+        process.stderr.write(
+          "[STICKY-NOTE] offline — using local thread cache (" +
+            (fetchResult.error || "fetch failed") + ")\n"
+        );
+      } else if (fetchResult.remoteRef) {
+        mergeFrom(fetchResult.remoteRef);
+      }
+    }
+
+    mergeFrom(dataBranch.DATA_REF);
+  } catch (err) {
+    process.stderr.write(
+      "[STICKY-NOTE] offline — using local thread cache (" + err.message + ")\n"
+    );
+  }
+}
+
 // ── Main ──────────────────────────────────────────────────
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     if (!process.stdin.isTTY) {
@@ -892,6 +942,9 @@ function main() {
     hookInput = {};
   }
 
+  // Fetch remote data branch and merge into local cache — before reading memory
+  fetchAndMergeDataBranch();
+
   let sessionId = getSessionId(hookInput);
   const aiTool = detectTool(hookInput);
   const isCopilotCli = aiTool === "copilot-cli" || process.argv.includes("--copilot-cli") || !!process.env.COPILOT_CLI;
@@ -921,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",
@@ -928,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);
@@ -941,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
@@ -1024,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
@@ -1040,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);
 
@@ -1180,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"}