cf-memory-mcp 3.63.0 → 3.65.0

package/bin/cf-memory-mcp.js

@@ -4145,6 +4145,10 @@ function parseCliArgs(rest) {
             flags.repo_path = rest[++i];
         } else if (a.startsWith('--repo=')) {
             flags.repo_path = a.slice('--repo='.length);
+        } else if (a === '--repo-prefix') {
+            flags.repo_path_prefix = rest[++i];
+        } else if (a.startsWith('--repo-prefix=')) {
+            flags.repo_path_prefix = a.slice('--repo-prefix='.length);
         } else if (a === '--project-id') {
             flags.project_id = rest[++i];
         } else if (a.startsWith('--project-id=')) {
@@ -4706,6 +4710,62 @@ async function runResumeCli() {
             } else {
                 process.stdout.write(JSON.stringify(payload.resume_handoff, null, 2) + '\n');
             }
+            // Branch state: if the handoff's repo matches cwd and there
+            // are uncommitted changes (especially in files_touched),
+            // surface them so the agent knows work was interrupted mid-
+            // edit. Quiet when the tree is clean to avoid noise. Skip
+            // entirely when env var disables it.
+            if (process.env.CF_MEMORY_BRANCH_STATE !== 'off') {
+                try {
+                    const meta = server.getRepoMetadata();
+                    const handoffRepo = payload.resume_handoff?.handoff?.repo_path
+                        || payload.resume_handoff?.repo_path;
+                    if (meta.repo_path && handoffRepo && meta.repo_path === handoffRepo) {
+                        const { execSync } = require('child_process');
+                        const dirty = execSync('git status --porcelain', { cwd: meta.repo_path, encoding: 'utf8', timeout: 2000 })
+                            .split('\n').filter(Boolean);
+                        if (dirty.length > 0) {
+                            const filesTouched = Array.isArray(payload.resume_handoff?.handoff?.files_touched)
+                                ? payload.resume_handoff.handoff.files_touched
+                                    .map(ft => typeof ft === 'string' ? ft : ft?.path)
+                                    .filter(Boolean)
+                                : [];
+                            const inHandoff = new Set(filesTouched);
+                            const matched = dirty.filter(line => {
+                                const p = line.slice(3);
+                                return inHandoff.has(p);
+                            });
+                            const otherCount = dirty.length - matched.length;
+                            process.stdout.write('\n### Branch state (since handoff was written)\n');
+                            if (matched.length > 0) {
+                                process.stdout.write(`Mid-edit on ${matched.length} of your files_touched:\n`);
+                                for (const line of matched.slice(0, 8)) {
+                                    process.stdout.write(`  ${line}\n`);
+                                }
+                                if (matched.length > 8) {
+                                    process.stdout.write(`  ... and ${matched.length - 8} more\n`);
+                                }
+                            }
+                            if (otherCount > 0) {
+                                process.stdout.write(`Plus ${otherCount} other uncommitted file${otherCount === 1 ? '' : 's'} in the tree (run \`git status\` for full list).\n`);
+                            }
+                            // Also check if HEAD has advanced past the handoff time.
+                            try {
+                                const handoffTime = payload.resume_handoff?.ended_at
+                                    || payload.resume_handoff?.started_at;
+                                if (handoffTime) {
+                                    const since = `--since="${handoffTime}"`;
+                                    const newCommits = execSync(`git log ${since} --oneline 2>/dev/null | wc -l`, { cwd: meta.repo_path, encoding: 'utf8', timeout: 2000, shell: '/bin/sh' }).trim();
+                                    const n = parseInt(newCommits, 10);
+                                    if (Number.isFinite(n) && n > 0) {
+                                        process.stdout.write(`${n} commit${n === 1 ? '' : 's'} on this branch since handoff (\`git log --since="${handoffTime}"\` to see them).\n`);
+                                    }
+                                }
+                            } catch (_) { /* commit-count is best-effort */ }
+                        }
+                    }
+                } catch (_) { /* git unavailable or non-repo — silent */ }
+            }
             // --include-chain N: walk parent_session_id back N times and
             // append each parent's resume_prompt inline so the agent sees
             // the full thread arc in one output.
@@ -4733,12 +4793,32 @@ async function runResumeCli() {
                 }
             }
             if (Array.isArray(payload.recent_handoffs) && payload.recent_handoffs.length > 1) {
-                process.stdout.write('\n---\nOther recent handoffs:\n');
-                for (const h of payload.recent_handoffs.slice(0, 4)) {
-                    const shortId = (h.session_id || '').slice(0, 8);
-                    process.stdout.write(`  ${shortId} [${h.status || '?'}] ${h.goal || ''}\n`);
+                // Dedupe: skip the primary handoff (already shown) and
+                // collapse near-duplicate auto-checkpoints — entries that
+                // share normalized (goal, branch, status). Keep the most
+                // recent occurrence of each unique key. This removes
+                // visible noise from 30+ in_progress sessions all named
+                // "Re-verify enrichment+freshness" on the same branch.
+                const primaryId = payload.resume_handoff?.session_id;
+                const norm = (s) => (s || '').toLowerCase().replace(/\s+/g, ' ').trim();
+                const seen = new Set();
+                const unique = [];
+                for (const h of payload.recent_handoffs) {
+                    if (h.session_id === primaryId) continue;
+                    const key = `${norm(h.goal)}|${norm(h.branch)}|${h.status || ''}`;
+                    if (seen.has(key)) continue;
+                    seen.add(key);
+                    unique.push(h);
+                    if (unique.length >= 4) break;
+                }
+                if (unique.length > 0) {
+                    process.stdout.write('\n---\nOther recent handoffs:\n');
+                    for (const h of unique) {
+                        const shortId = (h.session_id || '').slice(0, 8);
+                        process.stdout.write(`  ${shortId} [${h.status || '?'}] ${h.goal || ''}\n`);
+                    }
+                    process.stdout.write(`(Pass any short id as: npx cf-memory-mcp resume <id>)\n`);
                 }
-                process.stdout.write(`(Pass any short id as: npx cf-memory-mcp resume <id>)\n`);
             }
             process.exit(0);
         } else {
@@ -5280,14 +5360,15 @@ async function runDeleteCli() {
     }
     const { positional, flags } = parseCliArgs(process.argv.slice(3));
     const idArg = positional[0];
-    const bulkMode = !idArg && (flags.older_than_days !== undefined || flags.status || flags.repo_path);
+    const bulkMode = !idArg && (flags.older_than_days !== undefined || flags.status || flags.repo_path || flags.repo_path_prefix);
     if (!idArg && !bulkMode) {
         console.error('Usage:');
         console.error('  cf-memory-mcp delete <session-id-or-prefix>          # single delete');
         console.error('  cf-memory-mcp delete --older-than 30d                # bulk delete by age');
         console.error('  cf-memory-mcp delete --status abandoned              # bulk by status');
-        console.error('  cf-memory-mcp delete --repo /path/to/repo            # bulk by repo');
-        console.error('  Combine filters; use --yes to confirm >5 deletions.');
+        console.error('  cf-memory-mcp delete --repo /path/to/repo            # bulk by exact repo');
+        console.error('  cf-memory-mcp delete --repo-prefix /tmp/cfm-         # bulk by repo prefix');
+        console.error('  Combine filters; without --yes you get a dry-run preview.');
         process.exit(1);
     }
     const server = new CFMemoryMCP();
@@ -5298,6 +5379,7 @@ async function runDeleteCli() {
             if (flags.status) args.status = flags.status;
             if (flags.older_than_days !== undefined) args.older_than_days = flags.older_than_days;
             if (flags.repo_path) args.repo_path = flags.repo_path;
+            if (flags.repo_path_prefix) args.repo_path_prefix = flags.repo_path_prefix;
 
             // Dry-run preview when --yes is missing. The server returns
             // {deleted:false, deleted_count, deleted_session_ids[]} so the
@@ -5308,6 +5390,16 @@ async function runDeleteCli() {
                     method: 'tools/call',
                     params: { name: 'delete_session', arguments: { ...args, dry_run: true } },
                 });
+                // Surface JSON-RPC errors (e.g. "repo_path_prefix too short")
+                // instead of swallowing them into a "no matches" message.
+                if (previewRes?.error) {
+                    if (flags.json) {
+                        process.stdout.write(JSON.stringify({ error: previewRes.error }, null, 2) + '\n');
+                    } else {
+                        process.stderr.write(`Error: ${previewRes.error.message || JSON.stringify(previewRes.error)}\n`);
+                    }
+                    process.exit(1);
+                }
                 const previewText = previewRes?.result?.content?.[0]?.text;
                 const preview = JSON.parse(previewText || '{}');
                 if (flags.json) {
@@ -5364,6 +5456,14 @@ async function runDeleteCli() {
                 method: 'tools/call',
                 params: { name: 'delete_session', arguments: args },
             });
+            if (deleteRes?.error) {
+                if (flags.json) {
+                    process.stdout.write(JSON.stringify({ error: deleteRes.error }, null, 2) + '\n');
+                } else {
+                    process.stderr.write(`Error: ${deleteRes.error.message || JSON.stringify(deleteRes.error)}\n`);
+                }
+                process.exit(1);
+            }
             const deleteText = deleteRes?.result?.content?.[0]?.text;
             const payload = JSON.parse(deleteText || '{}');
             // Implicit-cache invalidation: if any deleted id matches the
@@ -5409,6 +5509,14 @@ async function runDeleteCli() {
             method: 'tools/call',
             params: { name: 'delete_session', arguments: { session_id: fullId } },
         });
+        if (deleteRes?.error) {
+            if (flags.json) {
+                process.stdout.write(JSON.stringify({ error: deleteRes.error, session_id: fullId }, null, 2) + '\n');
+            } else {
+                process.stderr.write(`Error: ${deleteRes.error.message || JSON.stringify(deleteRes.error)}\n`);
+            }
+            process.exit(1);
+        }
         const deleteText = deleteRes?.result?.content?.[0]?.text;
         const payload = JSON.parse(deleteText || '{}');
         // Drop the implicit-session disk cache if the deleted id matches
@@ -5448,6 +5556,7 @@ function runEnvCli() {
         ['CF_MEMORY_SHUTDOWN_HANDOFF', 'default: on; "off" disables the SIGINT/SIGTERM handoff flush'],
         ['CF_MEMORY_PREWARM_RESUME', 'default: on; "off" disables the background resume prewarm at bridge startup'],
         ['CF_MEMORY_RESUME_DIFF', 'default: on; "off" disables git-diff injection into resume responses'],
+        ['CF_MEMORY_BRANCH_STATE', 'default: on; "off" disables the "Branch state (since handoff was written)" block in `cfm resume`'],
         ['CF_MEMORY_DISK_CACHE', 'default: on; "off" disables ~/.cf-memory/handoff-*.json disk caching'],
         ['CF_MEMORY_NO_RETRY', 'default: off; "1" disables the single retry-on-transient-failure'],
         ['CF_MEMORY_LOG', 'default: off; "1" writes DEBUG/ERROR lines to ~/.cf-memory/bridge.log'],
@@ -5766,12 +5875,15 @@ const PER_COMMAND_HELP = {
     --uninstall          Remove a previously-installed script.
     --all-shells         With --install: install for every shell at once.`,
     delete: `cf-memory-mcp delete <session-id-or-prefix> [--json]
-  cf-memory-mcp delete [--status STATUS] [--older-than 30d] [--repo PATH] --yes [--json]
+  cf-memory-mcp delete [--status STATUS] [--older-than 30d] [--repo PATH] [--repo-prefix PFX] --yes [--json]
   Delete session row(s) and any session_summary memories tied to them.
     <session-id>          Single delete: full UUID or short prefix (>=8 chars).
     --status STATUS       Bulk filter by status (abandoned, completed, ...).
     --older-than 30d      Bulk filter by age (suffixes: d, h, m).
-    --repo PATH           Bulk filter by repo_path.
+    --repo PATH           Bulk filter by repo_path (exact match).
+    --repo-prefix PFX     Bulk filter by repo_path PREFIX (min 4 chars).
+                          E.g. --repo-prefix /tmp/cfm-lifecycle- nukes
+                          accumulated benchmark artifacts in one call.
     --yes, -y             Required for bulk delete to confirm intent.
     --json, -j            Emit JSON.
   Exit codes: 0 = deleted, 2 = bulk missing --yes, 3 = nothing matched.`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.63.0",
+	"version": "3.65.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": {