sticky-note-cli 3.0.0 → 3.1.1

package/bin/mcp-server.js

@@ -3,9 +3,10 @@
  * sticky-note MCP server — stdio-based
  *
  * Implements Model Context Protocol (JSON-RPC 2.0 over stdin/stdout)
- * with 8 tools for AI assistants:
+ * with 9 tools for AI assistants:
  *
  *   get_session_context(id)              — full thread payload by ID
+ *   get_full_transcript(id)              — full verbatim session transcript(s) for a thread
  *   get_stuck_threads()                  — all stuck threads
  *   search_threads(query)               — keyword search across threads
  *   get_audit_trail(...)                — query per-user JSONL audit logs
@@ -23,6 +24,7 @@
 
 const fs = require("fs");
 const path = require("path");
+const { execFileSync } = require("child_process");
 
 // ──────────────────────────────────────────────
 // Project root resolution
@@ -36,8 +38,113 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
+let _cachedStickyDir = null;
 function stickyDir() {
-  return path.join(PROJECT_ROOT, ".sticky-note");
+  if (_cachedStickyDir) return _cachedStickyDir;
+
+  // V3 default storage lives at <git-dir>/sticky-note (the sticky-note/data
+  // orphan branch's local working copy), not in the project's working tree.
+  // Try that first; fall back to the legacy in-tree .sticky-note/ for repos
+  // that haven't migrated (or aren't git repos at all).
+  try {
+    const gitDir = execFileSync("git", ["rev-parse", "--absolute-git-dir"], {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"], cwd: PROJECT_ROOT,
+    }).trim();
+    const dataBranchDir = path.join(gitDir, "sticky-note");
+    if (fs.existsSync(path.join(dataBranchDir, "sticky-note.json"))) {
+      _cachedStickyDir = dataBranchDir;
+      return _cachedStickyDir;
+    }
+  } catch (_) {
+    // not a git repo, or git unavailable — fall through to legacy path
+  }
+
+  _cachedStickyDir = path.join(PROJECT_ROOT, ".sticky-note");
+  return _cachedStickyDir;
+}
+
+function getTranscriptPath(threadId) {
+  return path.join(stickyDir(), "transcripts", threadId + ".jsonl");
+}
+
+// ──────────────────────────────────────────────
+// Cloud config (V3 optional backend)
+// ──────────────────────────────────────────────
+
+function readEnvSticky() {
+  const envPath = path.join(PROJECT_ROOT, ".env.sticky");
+  const result = {};
+  if (!fs.existsSync(envPath)) return result;
+  for (const line of fs.readFileSync(envPath, "utf-8").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("STICKY_URL=")) result.STICKY_URL = trimmed.slice("STICKY_URL=".length);
+    if (trimmed.startsWith("STICKY_API_KEY=")) result.STICKY_API_KEY = trimmed.slice("STICKY_API_KEY=".length);
+  }
+  return result;
+}
+
+function getCloudConfig() {
+  const envFile = readEnvSticky();
+  return {
+    url: process.env.STICKY_URL || envFile.STICKY_URL || "",
+    apiKey: process.env.STICKY_API_KEY || envFile.STICKY_API_KEY || "",
+  };
+}
+
+function getProjectName() {
+  try {
+    const remote = execFileSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"], cwd: PROJECT_ROOT,
+    }).trim();
+    const match = remote.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (match) return match[1];
+  } catch (_) {}
+  return "default";
+}
+
+let _cloudThreads = null;
+let _cloudPresence = null;
+let _cloudPresenceMap = null;
+
+function buildPresenceMap(presence) {
+  const map = {};
+  for (const entry of presence) {
+    if (entry.user) map[entry.user] = { active_files: entry.active_files || [], last_seen: entry.last_seen };
+  }
+  return map;
+}
+
+async function initCloudCache() {
+  const { url, apiKey } = getCloudConfig();
+  if (!url) return;
+
+  const headers = { "X-Sticky-Project": getProjectName() };
+  if (apiKey) headers["X-Sticky-API-Key"] = apiKey;
+
+  function timedFetch(endpoint) {
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), 5000);
+    return fetch(`${url}${endpoint}`, { headers, signal: controller.signal })
+      .finally(() => clearTimeout(t));
+  }
+
+  try {
+    const [threadsRes, presenceRes] = await Promise.all([
+      timedFetch("/threads"),
+      timedFetch("/presence"),
+    ]);
+    if (threadsRes.ok) {
+      const data = await threadsRes.json();
+      _cloudThreads = data.threads || [];
+    }
+    if (presenceRes.ok) {
+      const data = await presenceRes.json();
+      _cloudPresence = data.presence || [];
+      _cloudPresenceMap = buildPresenceMap(_cloudPresence);
+    }
+  } catch (_) {
+    process.stderr.write("[sticky-note] Cloud unreachable — using local data\n");
+  }
 }
 
 // ──────────────────────────────────────────────
@@ -69,6 +176,7 @@ function getConfig() {
 }
 
 function getThreads() {
+  if (_cloudThreads !== null) return _cloudThreads;
   return getMemory().threads || [];
 }
 
@@ -77,10 +185,11 @@ function getThreads() {
  * Returns { username: { active_files, last_seen } }
  */
 function getAllPresence() {
+  if (_cloudPresenceMap !== null) return _cloudPresenceMap;
+
   const presenceDir = path.join(stickyDir(), "presence");
   const result = {};
   if (!fs.existsSync(presenceDir)) return result;
-
   for (const file of fs.readdirSync(presenceDir)) {
     if (!file.endsWith(".json")) continue;
     const user = file.replace(".json", "");
@@ -156,6 +265,60 @@ function toolGetSessionContext(params) {
   return { thread };
 }
 
+/**
+ * Return the full verbatim transcript(s) captured for a thread — one entry
+ * per contributing session (a resumed thread may have several). Secrets
+ * are redacted before storage (see redactSecrets in sticky-utils.js) unless
+ * a team has disabled redact_transcripts.
+ */
+function toolGetFullTranscript(params) {
+  const { id } = params;
+  if (!id) {
+    return { error: "Missing required parameter: id" };
+  }
+
+  const threads = getThreads();
+  const thread = threads.find((t) => t.id === id || t.id.startsWith(id) || t.session_id === id);
+  if (!thread) {
+    return { error: `No thread found with id: ${id}` };
+  }
+
+  const filePath = getTranscriptPath(thread.id);
+  if (!fs.existsSync(filePath)) {
+    return {
+      thread_id: thread.id,
+      transcript_captured: !!thread.transcript_captured,
+      sessions: [],
+      note: "No transcript captured for this thread — it may predate transcript capture, or capture_transcripts is disabled for this team.",
+    };
+  }
+
+  const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter((l) => l.trim());
+  const sessions = [];
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    sessions.push({
+      session_id: entry.session_id,
+      tool: entry.tool,
+      user: entry.user,
+      captured_at: entry.captured_at,
+      redacted: !!entry.redacted,
+      transcript: entry.transcript,
+    });
+  }
+
+  return {
+    thread_id: thread.id,
+    session_count: sessions.length,
+    sessions,
+  };
+}
+
 function toolGetStuckThreads() {
   const threads = getThreads();
   const stuck = threads.filter((t) => t.status === "stuck");
@@ -515,6 +678,21 @@ const TOOLS = {
     },
     handler: toolGetSessionContext,
   },
+  get_full_transcript: {
+    description:
+      "Get the full verbatim transcript(s) captured for a thread by ID — one entry per contributing session. Secrets are redacted before storage unless a team disabled redact_transcripts. Returns an empty sessions array if no transcript was captured (e.g. capture_transcripts is off, or the thread predates this feature).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Thread ID or session ID to look up",
+        },
+      },
+      required: ["id"],
+    },
+    handler: toolGetFullTranscript,
+  },
   get_stuck_threads: {
     description:
       "Get all threads with status 'stuck'. Returns full payloads including failed approaches and last notes. Call at session start to check for team blockers.",
@@ -634,7 +812,7 @@ const TOOLS = {
 
 const SERVER_INFO = {
   name: "sticky-note",
-  version: "3.0.0",
+  version: "3.1.0",
 };
 
 const CAPABILITIES = {
@@ -746,43 +924,47 @@ function handleRequest(msg) {
 // stdio transport
 // ──────────────────────────────────────────────
 
-let buffer = "";
+(async () => {
+  await initCloudCache();
 
-process.stdin.setEncoding("utf-8");
-process.stdin.on("data", (chunk) => {
-  buffer += chunk;
+  let buffer = "";
 
-  let newlineIdx;
-  while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-    const line = buffer.slice(0, newlineIdx).trim();
-    buffer = buffer.slice(newlineIdx + 1);
+  process.stdin.setEncoding("utf-8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
 
-    if (!line) continue;
+    let newlineIdx;
+    while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, newlineIdx).trim();
+      buffer = buffer.slice(newlineIdx + 1);
 
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
-      const errResp = {
-        jsonrpc: "2.0",
-        id: null,
-        error: { code: -32700, message: "Parse error" },
-      };
-      process.stdout.write(JSON.stringify(errResp) + "\n");
-      continue;
-    }
+      if (!line) continue;
 
-    const response = handleRequest(msg);
-    if (response) {
-      process.stdout.write(JSON.stringify(response) + "\n");
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        const errResp = {
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "Parse error" },
+        };
+        process.stdout.write(JSON.stringify(errResp) + "\n");
+        continue;
+      }
+
+      const response = handleRequest(msg);
+      if (response) {
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
     }
-  }
-});
+  });
 
-process.stdin.on("end", () => {
-  process.exit(0);
-});
+  process.stdin.on("end", () => {
+    process.exit(0);
+  });
 
-process.on("uncaughtException", (err) => {
-  process.stderr.write(`sticky-note MCP server error: ${err.message}\n`);
-});
+  process.on("uncaughtException", (err) => {
+    process.stderr.write(`sticky-note MCP server error: ${err.message}\n`);
+  });
+})();

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "sticky-note-cli",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {
-    "sticky-note": "./bin/cli.js",
-    "sticky-note-cli": "./bin/cli.js",
-    "sticky-note-mcp": "./bin/mcp-server.js"
+    "sticky-note": "bin/cli.js",
+    "sticky-note-cli": "bin/cli.js",
+    "sticky-note-mcp": "bin/mcp-server.js"
   },
   "keywords": [
     "ai",
@@ -21,7 +21,7 @@
   "homepage": "https://github.com/BandaruDheeraj/sticky-note#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/BandaruDheeraj/sticky-note.git"
+    "url": "git+https://github.com/BandaruDheeraj/sticky-note.git"
   },
   "files": [
     "bin/",

package/templates/CLAUDE.md

@@ -33,6 +33,7 @@ cat .sticky-note/sticky-note.json
 | `resumed_by`       | Most recent user to resume this thread (V2.5) |
 | `resumed_at`       | ISO timestamp of most recent resume (V2.5) |
 | `resume_history`   | Full resume chain: user, timestamp, session (V2.5) |
+| `transcript_captured` | Whether a full verbatim session transcript exists for this thread (V3.1) |
 
 ### Status icons
 
@@ -107,6 +108,24 @@ approaches, prompts). Read and present this context to the user immediately —
 do NOT tell them to start a new session. The inject-context hook will also
 pick up the resumed thread on subsequent prompts.
 
+### Full transcript capture (V3.1)
+
+By default, each session's complete verbatim transcript is captured — not
+just the narrative summary — keyed by thread ID and stored alongside audit
+logs and presence data. Secrets are redacted before anything is written
+(best-effort pattern matching, not a guarantee).
+
+- A thread's `transcript_captured` field is `true` once at least one
+  session's transcript has been persisted.
+- Retrieve it with `npx sticky-note transcript <thread-id>` (add `--raw` for
+  the untouched JSONL) or the `get_full_transcript(id)` MCP tool.
+- A team can turn this off with `"capture_transcripts": false` in
+  `sticky-note-config.json` — e.g. for a repo where sessions routinely
+  touch especially sensitive material.
+- When a user asks "what did we actually discuss in that session" (as
+  opposed to "what was the summary"), prefer the transcript over
+  `narrative`/`prompts` — those are truncated summaries, not the full record.
+
 ### File attribution (V2.5)
 
 To see which threads are related to a specific file:
@@ -245,6 +264,10 @@ You have access to a `sticky-note` MCP server. Use it:
 4. **For audit history**: Call `get_audit_trail(file)` to understand who
    changed a file and when.
 
+5. **For the full conversation, not just the summary**: Call
+   `get_full_transcript(id)` to get the verbatim session transcript(s) for
+   a thread, when `narrative` or `prompts` aren't enough detail.
+
 These tools are the primary way sticky-note communicates with you.
 Hook-injected context supplements but does not replace MCP tool calls.
 

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) {