cf-memory-mcp 3.47.0 → 3.49.0

package/bin/cf-memory-mcp.js

@@ -2612,6 +2612,66 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Path for the on-disk implicit-session cache (keyed by cwd hash).
+     * Lets the bridge survive restarts without losing the implicit
+     * session — otherwise a fresh process would create a duplicate
+     * session for the same cwd.
+     */
+    getImplicitSessionDiskPath() {
+        try {
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            const crypto = require('crypto');
+            const hash = crypto.createHash('sha256').update(cwd).digest('hex').slice(0, 16);
+            return path.join(os.homedir(), '.cf-memory', `implicit-${hash}.json`);
+        } catch (_) { return null; }
+    }
+
+    /**
+     * Load the disk-persisted implicit session for the current cwd, if any.
+     * Stale entries (>1 day old) are ignored — sessions that haven't been
+     * touched in a day are probably not "implicitly active" anymore.
+     */
+    loadImplicitSessionFromDisk() {
+        try {
+            const p = this.getImplicitSessionDiskPath();
+            if (!p || !fs.existsSync(p)) return null;
+            const entry = JSON.parse(fs.readFileSync(p, 'utf8'));
+            const ageMs = Date.now() - new Date(entry.cached_at).getTime();
+            if (ageMs > 24 * 60 * 60 * 1000) return null; // stale
+            return entry.session_id || null;
+        } catch (_) { return null; }
+    }
+
+    /**
+     * Persist the current implicit session id to disk. Called from
+     * getOrCreateImplicitSession and cacheImplicitSessionFromResponse.
+     * Atomic via .tmp + rename, same as the resume cache.
+     */
+    saveImplicitSessionToDisk(sessionId) {
+        try {
+            const p = this.getImplicitSessionDiskPath();
+            if (!p) return;
+            const dir = path.dirname(p);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            const entry = {
+                cached_at: new Date().toISOString(),
+                cwd: process.env.CF_MEMORY_WATCH_PATH || process.cwd(),
+                session_id: sessionId,
+            };
+            const tmp = `${p}.tmp.${process.pid}`;
+            try {
+                fs.writeFileSync(tmp, JSON.stringify(entry, null, 2));
+                fs.renameSync(tmp, p);
+            } catch (renameErr) {
+                try { fs.unlinkSync(tmp); } catch (_) { /* ignore */ }
+                fs.writeFileSync(p, JSON.stringify(entry, null, 2));
+            }
+        } catch (err) {
+            this.logDebug(`saveImplicitSessionToDisk failed: ${err && err.message}`);
+        }
+    }
+
     /**
      * Return the implicit session_id for the current cwd, creating one via
      * start_session when no session is active. Lets agents skip explicit
@@ -2621,6 +2681,7 @@ class CFMemoryMCP {
      * The cache is keyed by cwd so multiple bridge processes for different
      * repos don't share state. Sessions finalized via end_session WITHOUT
      * keep_open clear the implicit cache so the next call starts fresh.
+     * Persists to disk so bridge restarts don't churn new sessions.
      */
     async getOrCreateImplicitSession() {
         try {
@@ -2628,6 +2689,13 @@ class CFMemoryMCP {
             if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
             const cached = this._implicitSessionByCwd.get(cwd);
             if (cached) return cached;
+            // Try disk cache (survives bridge restarts).
+            const fromDisk = this.loadImplicitSessionFromDisk();
+            if (fromDisk) {
+                this._implicitSessionByCwd.set(cwd, fromDisk);
+                _mcpTrace('IMPLICIT_SESSION', `restored implicit session=${fromDisk} from disk for cwd=${cwd}`);
+                return fromDisk;
+            }
 
             // Lazily start a session, tagged with the same repo metadata as
             // start_session would auto-attach if called explicitly.
@@ -2652,6 +2720,7 @@ class CFMemoryMCP {
             } catch (_) { /* malformed response */ }
             if (sessionId) {
                 this._implicitSessionByCwd.set(cwd, sessionId);
+                this.saveImplicitSessionToDisk(sessionId);
                 _mcpTrace('IMPLICIT_SESSION', `created implicit session=${sessionId} for cwd=${cwd}`);
             }
             return sessionId;
@@ -2678,6 +2747,7 @@ class CFMemoryMCP {
             const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
             if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
             this._implicitSessionByCwd.set(cwd, sessionId);
+            this.saveImplicitSessionToDisk(sessionId);
             _mcpTrace('IMPLICIT_SESSION', `cached implicit session=${sessionId} for cwd=${cwd}`);
         } catch (err) {
             this.logDebug(`cacheImplicitSessionFromResponse failed: ${err && err.message}`);
@@ -2708,6 +2778,12 @@ class CFMemoryMCP {
                 this._implicitSessionByCwd.delete(cwd);
                 _mcpTrace('IMPLICIT_SESSION', `cleared implicit session for cwd=${cwd}`);
             }
+            // Also drop the on-disk persistent cache so a future restart
+            // doesn't pick the just-finalized session back up.
+            try {
+                const p = this.getImplicitSessionDiskPath();
+                if (p && fs.existsSync(p)) fs.unlinkSync(p);
+            } catch (_) { /* ignore */ }
         } catch (err) {
             this.logDebug(`clearImplicitSessionIfFinalized failed: ${err && err.message}`);
         }
@@ -3981,6 +4057,14 @@ function parseCliArgs(rest) {
             flags.branch_only = true;
         } else if (a === '--repo-only') {
             flags.repo_only = true;
+        } else if (a === '--fields') {
+            flags.fields = rest[++i];
+        } else if (a.startsWith('--fields=')) {
+            flags.fields = a.slice('--fields='.length);
+        } else if (a === '--diff') {
+            flags.diff = rest[++i];
+        } else if (a.startsWith('--diff=')) {
+            flags.diff = a.slice('--diff='.length);
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4175,6 +4259,43 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --fields a,b,c: multi-field extract. Print each field on its
+        // own line (or as `name=value` for shell scripting). Supports
+        // any top-level handoff field plus envelope metadata.
+        if (flags.fields) {
+            const envelope = payload.resume_handoff;
+            if (!envelope) process.exit(3);
+            const handoff = envelope.handoff || {};
+            const fieldLookup = (name) => {
+                switch (name) {
+                    case 'session_id': return envelope.session_id;
+                    case 'age_minutes': return envelope.handoff_age_minutes;
+                    case 'quality_score': return envelope.quality_score;
+                    case 'match_confidence': return envelope.match_confidence;
+                    case 'match_reason': return envelope.match_reason;
+                    case 'stale': return envelope.stale ? 'true' : 'false';
+                    default: return handoff[name];
+                }
+            };
+            const wantNames = flags.fields.split(',').map(s => s.trim()).filter(Boolean);
+            if (wantNames.length === 0) process.exit(3);
+            const lines = [];
+            for (const name of wantNames) {
+                const v = fieldLookup(name);
+                if (v === undefined || v === null) continue;
+                if (Array.isArray(v)) {
+                    lines.push(`${name}=${v.length} item${v.length === 1 ? '' : 's'}`);
+                } else if (typeof v === 'object') {
+                    lines.push(`${name}=${JSON.stringify(v)}`);
+                } else {
+                    lines.push(`${name}=${v}`);
+                }
+            }
+            if (lines.length === 0) process.exit(3);
+            process.stdout.write(lines.join('\n') + '\n');
+            process.exit(0);
+        }
+
         // --age: print just handoff_age_minutes (single integer).
         if (flags.age) {
             const ageMin = payload.resume_handoff?.handoff_age_minutes;
@@ -4275,6 +4396,65 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --diff <other-id>: compare two handoffs. Shows added/removed
+        // next_steps, branch shift, status change, files diff. Useful
+        // for "what changed between yesterday's session and today's?".
+        if (flags.diff) {
+            if (!found) {
+                process.stderr.write('No source handoff available to diff against.\n');
+                process.exit(3);
+            }
+            const otherRes = await server.makeRequest({
+                jsonrpc: '2.0', id: `cli-diff-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: flags.diff } },
+            });
+            const otherText = otherRes?.result?.content?.[0]?.text;
+            const otherPayload = JSON.parse(otherText || '{}');
+            const otherHandoff = otherPayload.resume_handoff?.handoff;
+            if (!otherHandoff) {
+                process.stderr.write(`Could not fetch handoff "${flags.diff}" to diff against.\n`);
+                process.exit(3);
+            }
+            const h = payload.resume_handoff.handoff;
+            const setOf = (arr, key) =>
+                new Set((arr || []).map(x => typeof x === 'string' ? x : x[key]).filter(Boolean));
+            const diffArr = (label, a, b, key) => {
+                const A = setOf(a, key); const B = setOf(b, key);
+                const added = [...A].filter(x => !B.has(x));
+                const removed = [...B].filter(x => !A.has(x));
+                const lines = [];
+                if (added.length) lines.push(`  + ${label}: ${added.join(', ')}`);
+                if (removed.length) lines.push(`  - ${label}: ${removed.join(', ')}`);
+                return lines.join('\n');
+            };
+
+            const aShort = (payload.resume_handoff.session_id || '').slice(0, 8);
+            const bShort = (otherPayload.resume_handoff.session_id || '').slice(0, 8);
+            const lines = [`Diff: ${aShort} (this) vs ${bShort} (other)`, ''];
+            // Scalar fields
+            const scalars = ['goal', 'status', 'branch', 'repo_path'];
+            for (const f of scalars) {
+                if (h[f] !== otherHandoff[f]) {
+                    lines.push(`  ~ ${f}: "${otherHandoff[f] || ''}" → "${h[f] || ''}"`);
+                }
+            }
+            // Array fields
+            const arrDiff = diffArr('next_steps', h.next_steps, otherHandoff.next_steps);
+            if (arrDiff) lines.push(arrDiff);
+            const blockerDiff = diffArr('blockers', h.blockers, otherHandoff.blockers);
+            if (blockerDiff) lines.push(blockerDiff);
+            const decisionDiff = diffArr('decisions', h.decisions, otherHandoff.decisions);
+            if (decisionDiff) lines.push(decisionDiff);
+            const fileDiff = diffArr('files_touched', h.files_touched, otherHandoff.files_touched, 'path');
+            if (fileDiff) lines.push(fileDiff);
+            const anchorDiff = diffArr('code_anchors', h.code_anchors, otherHandoff.code_anchors, 'file_path');
+            if (anchorDiff) lines.push(anchorDiff);
+            if (lines.length === 2) lines.push('  (no differences)');
+            process.stdout.write(lines.join('\n') + '\n');
+            process.exit(0);
+        }
+
         // --validate: verify the handoff's file references still exist
         // on disk. Resolves each path relative to the handoff's repo_path
         // (or cwd). Reports per-path status. Useful before resuming to
@@ -4981,6 +5161,7 @@ const PER_COMMAND_HELP = {
     --decisions-only      decisions, one per line.
     --blockers-only       open blockers, one per line.
     --chain               Walk parent_session_id back; show the thread history.
+    --diff <other-id>     Compare this handoff against another (added/removed/changed fields).
     --validate            Check that files_touched + code_anchors still exist locally.
     --raw                 Print just the raw handoff JSON (no envelope metadata).
     --age                 Print handoff_age_minutes (single integer).
@@ -4989,6 +5170,9 @@ const PER_COMMAND_HELP = {
     --status-only         Print just the status string.
     --branch-only         Print just the branch.
     --repo-only           Print just the repo_path.
+    --fields <list>       Print specified fields as "name=value", comma-sep.
+                          Supports any handoff field plus session_id, age_minutes,
+                          quality_score, match_confidence, match_reason, stale.
     --json, -j            Full bootstrap payload as JSON.
   Exit codes: 0 = found, 3 = no handoff / no data, 4 = --validate found missing files.`,
     list: `cf-memory-mcp list [--status S] [--since ISO] [--repo PATH] [--limit N] [--json]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.47.0",
+	"version": "3.49.0",
 	"description": "Cloudflare-hosted MCP server for code indexing, retrieval, and assistant memory with a direct remote MCP endpoint and local stdio bridge.",
 	"main": "bin/cf-memory-mcp.js",
 	"bin": {