cf-memory-mcp 3.61.0 → 3.63.0

package/bin/cf-memory-mcp.js

@@ -2672,6 +2672,42 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Drop the implicit-session disk cache iff the cached session id is
+     * in `deletedSessionIds`. Called from the delete CLI so a subsequent
+     * end_session against the implicit cache won't write to a session
+     * that no longer exists on the server. Also clears the in-memory map
+     * for the matching cwd. Returns true when something was dropped.
+     */
+    invalidateImplicitSessionIfMatches(deletedSessionIds) {
+        if (!deletedSessionIds || !deletedSessionIds.length) return false;
+        const matchSet = new Set(deletedSessionIds);
+        let dropped = false;
+        try {
+            const implicitPath = this.getImplicitSessionDiskPath();
+            if (implicitPath && fs.existsSync(implicitPath)) {
+                const entry = JSON.parse(fs.readFileSync(implicitPath, 'utf8'));
+                if (matchSet.has(entry.session_id)) {
+                    fs.unlinkSync(implicitPath);
+                    dropped = true;
+                }
+            }
+        } catch (_) { /* non-fatal */ }
+        // Also evict in-memory entries so a long-lived bridge stops
+        // auto-filling the deleted id.
+        try {
+            if (this._implicitSessionByCwd && this._implicitSessionByCwd.size) {
+                for (const [cwd, sid] of this._implicitSessionByCwd.entries()) {
+                    if (matchSet.has(sid)) {
+                        this._implicitSessionByCwd.delete(cwd);
+                        dropped = true;
+                    }
+                }
+            }
+        } catch (_) { /* non-fatal */ }
+        return dropped;
+    }
+
     /**
      * Return the implicit session_id for the current cwd, creating one via
      * start_session when no session is active. Lets agents skip explicit
@@ -3919,7 +3955,7 @@ if (process.argv.includes('--version') || process.argv.includes('-v')) {
 
 // Global --help only when no subcommand is present. With a subcommand, fall
 // through to the per-command help dispatch below.
-const SUBCOMMANDS = new Set(['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion', 'delete', 'env', 'history', 'link', 'explain', 'gha']);
+const SUBCOMMANDS = new Set(['resume', 'list', 'search', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion', 'delete', 'env', 'history', 'link', 'explain', 'gha']);
 const hasSubcommand = process.argv[2] && SUBCOMMANDS.has(process.argv[2]);
 
 if (!hasSubcommand && (process.argv.includes('--help') || process.argv.includes('-h'))) {
@@ -3932,6 +3968,7 @@ Usage:
   npx cf-memory-mcp                 Start the MCP server
   npx cf-memory-mcp resume [id]     Print the prior resume handoff (markdown)
   npx cf-memory-mcp list            List recent handoffs for cwd (status-ranked)
+  npx cf-memory-mcp search <query>  Find handoffs by goal/notes/decisions text (cross-repo default)
   npx cf-memory-mcp history         List all handoffs for cwd, chronological
   npx cf-memory-mcp checkpoint ["<goal>"]  Snapshot current state (keep_open)
   npx cf-memory-mcp link <child> --parent <id>  Retroactively link a child session to a parent
@@ -4122,6 +4159,10 @@ function parseCliArgs(rest) {
             flags.since = a.slice('--since='.length);
         } else if (a === '--yes' || a === '-y') {
             flags.yes = true;
+        } else if (a === '--ids-only') {
+            flags.ids_only = true;
+        } else if (a === '--here') {
+            flags.here = true;
         } else positional.push(a);
     }
     return { positional, flags };
@@ -4959,6 +5000,116 @@ async function runListCli() {
     }
 }
 
+async function runSearchCli() {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { positional, flags } = parseCliArgs(process.argv.slice(3));
+    const query = positional[0];
+    if (!query) {
+        console.error('Usage: cf-memory-mcp search <query> [--repo <path>] [--project-id <id>] [--status <s>] [--since <iso>] [--limit N] [--json] [--ids-only]');
+        console.error('Searches across goal/next_steps/notes/decisions/blockers (case-insensitive substring).');
+        console.error('Defaults to ALL your handoffs (cross-repo). Use --repo or --project-id to scope.');
+        process.exit(1);
+    }
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    server.logError = (...a) => process.stderr.write(a.join(' ') + '\n');
+    try {
+        // Server-side substring filter via goal_contains (which actually
+        // matches the whole serialized handoff JSON — goal, next_steps,
+        // notes, decisions, blockers, code_anchors, files_touched).
+        const args = { resume: true, goal_contains: query };
+        // Default: NO repo/project scoping — search is meant to be global.
+        // Opt-in via --repo or --project-id (or --here for cwd's repo).
+        if (flags.repo_path) args.repo_path = flags.repo_path;
+        if (flags.project_id) args.project_id = flags.project_id;
+        if (flags.here) {
+            const meta = server.getRepoMetadata();
+            if (meta.repo_path) args.repo_path = meta.repo_path;
+            if (meta.branch) args.branch = meta.branch;
+        }
+        if (flags.status) args.status_filter = flags.status;
+        if (flags.since) args.since = flags.since;
+
+        const response = await server.makeRequest({
+            jsonrpc: '2.0',
+            id: `cli-search-${Date.now()}`,
+            method: 'tools/call',
+            params: { name: 'get_context_bootstrap', arguments: args },
+        });
+        const text = response?.result?.content?.[0]?.text;
+        const payload = JSON.parse(text || '{}');
+        const allList = Array.isArray(payload.recent_handoffs) ? payload.recent_handoffs : [];
+        const list = flags.limit ? allList.slice(0, flags.limit) : allList;
+
+        if (flags.ids_only) {
+            for (const h of list) process.stdout.write(`${h.session_id || ''}\n`);
+            process.exit(list.length === 0 ? 3 : 0);
+        }
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({
+                query,
+                scope: args.repo_path ? 'repo' : args.project_id ? 'project' : 'global',
+                repo_path: args.repo_path,
+                project_id: args.project_id,
+                status_filter: flags.status,
+                since: flags.since,
+                count: list.length,
+                handoffs: list,
+            }, null, 2) + '\n');
+            process.exit(list.length === 0 ? 3 : 0);
+        }
+        if (list.length === 0) {
+            process.stderr.write(`No handoffs match "${query}".\n`);
+            process.exit(3);
+        }
+        // Render with terminal highlight (ANSI bold) when stdout is a TTY.
+        const tty = process.stdout.isTTY;
+        const lcQuery = query.toLowerCase();
+        const highlight = (str) => {
+            if (!str) return str;
+            if (!tty) return str;
+            const idx = str.toLowerCase().indexOf(lcQuery);
+            if (idx < 0) return str;
+            const before = str.slice(0, idx);
+            const match = str.slice(idx, idx + query.length);
+            const after = str.slice(idx + query.length);
+            return `${before}\x1b[1;33m${match}\x1b[0m${after}`;
+        };
+        const fmtAge = (iso) => {
+            if (!iso) return '?';
+            const min = Math.round((Date.now() - new Date(iso).getTime()) / 60000);
+            if (min < 60) return `${min}m`;
+            if (min < 1440) return `${Math.round(min/60)}h`;
+            return `${Math.round(min/1440)}d`;
+        };
+        const scopeLabel = args.repo_path ? `in repo ${args.repo_path}` : args.project_id ? `in project ${args.project_id}` : 'across all your handoffs';
+        process.stdout.write(`Found ${list.length} handoff${list.length === 1 ? '' : 's'} matching "${query}" ${scopeLabel}:\n\n`);
+        for (const h of list) {
+            const shortId = (h.session_id || '').slice(0, 8);
+            const age = fmtAge(h.ended_at || h.started_at);
+            const status = (h.status || 'unknown').padEnd(11);
+            const branch = h.branch ? `[${h.branch}] ` : '';
+            const goal = highlight((h.goal || '(no goal)').slice(0, 100));
+            const q = typeof h.quality_score === 'number' ? ` q=${h.quality_score.toFixed(2)}` : '';
+            process.stdout.write(`  ${shortId}  ${status}  ${age.padStart(4)} ago${q}  ${branch}${goal}\n`);
+            if (h.next_step) process.stdout.write(`              next: ${highlight(h.next_step.slice(0, 100))}\n`);
+            // If the repo differs from the user's cwd, surface it so they
+            // know which project the handoff belongs to.
+            if (h.repo_path && !args.repo_path) {
+                process.stdout.write(`              repo: ${h.repo_path}\n`);
+            }
+        }
+        process.stdout.write(`\n(Run "npx cf-memory-mcp resume <id>" to load one, or pipe to "xargs -I{} npx cf-memory-mcp resume {}" with --ids-only)\n`);
+        process.exit(0);
+    } catch (err) {
+        console.error('search command failed:', err.message);
+        process.exit(1);
+    }
+}
+
 async function runLinkCli() {
     if (!API_KEY) {
         console.error('Error: CF_MEMORY_API_KEY environment variable is required');
@@ -5215,6 +5366,12 @@ async function runDeleteCli() {
             });
             const deleteText = deleteRes?.result?.content?.[0]?.text;
             const payload = JSON.parse(deleteText || '{}');
+            // Implicit-cache invalidation: if any deleted id matches the
+            // current cwd's implicit session, drop the cache so the next
+            // end_session creates a fresh one.
+            if (payload.deleted) {
+                server.invalidateImplicitSessionIfMatches(payload.deleted_session_ids || []);
+            }
             if (flags.json) {
                 process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
                 process.exit(payload.deleted ? 0 : 3);
@@ -5254,6 +5411,12 @@ async function runDeleteCli() {
         });
         const deleteText = deleteRes?.result?.content?.[0]?.text;
         const payload = JSON.parse(deleteText || '{}');
+        // Drop the implicit-session disk cache if the deleted id matches
+        // it. Otherwise a subsequent end_session would try to write to a
+        // session that no longer exists.
+        if (payload.deleted) {
+            server.invalidateImplicitSessionIfMatches([fullId]);
+        }
         if (flags.json) {
             process.stdout.write(JSON.stringify({ ...payload, session_id: fullId }, null, 2) + '\n');
             process.exit(payload.deleted ? 0 : 3);
@@ -5341,7 +5504,7 @@ function runCompletionCli() {
         process.stderr.write(`\nDone. Installed completion for ${installed} shell${installed === 1 ? '' : 's'}.\n`);
         process.exit(installed > 0 ? 0 : 1);
     }
-    const commands = ['resume', 'list', 'history', 'checkpoint', 'link', 'explain', 'gha', 'status', 'clean', 'export', 'import', 'delete', 'doctor', 'env', 'completion'];
+    const commands = ['resume', 'list', 'search', 'history', 'checkpoint', 'link', 'explain', 'gha', 'status', 'clean', 'export', 'import', 'delete', 'doctor', 'env', 'completion'];
     const flags = ['--json', '-j', '--limit', '-n', '--md', '--all', '--force', '-f', '--version', '-v', '--help', '-h', '--diagnose'];
 
     // Determine the install target for each shell. Use user-local paths
@@ -5545,6 +5708,23 @@ const PER_COMMAND_HELP = {
     --repo PATH           Override the cwd's repo (peek at another repo).
     --limit N, -n N       Max number of entries (default 5, max 50).
     --json, -j            Emit a JSON array for scripts.`,
+    search: `cf-memory-mcp search <query> [--here | --repo PATH | --project-id ID] [--status S] [--since ISO] [--limit N] [--json|--ids-only]
+  Find handoffs matching <query> across goal, next_steps, notes,
+  decisions, blockers, code_anchors, and files_touched (case-insensitive
+  substring). Default scope is ALL your handoffs (cross-repo). Highlights
+  the matched substring in terminal output.
+    <query>               Required substring to search for.
+    --here                Scope to cwd's repo (otherwise: global).
+    --repo PATH           Scope to a specific repo path.
+    --project-id ID       Scope to a specific project.
+    --status S            Filter by status (in_progress, completed, ...).
+    --since ISO           Lower bound on handoff timestamp (ISO 8601).
+    --limit N             Max entries to render (server may cap at 50).
+    --ids-only            Print only session_ids (xargs-friendly).
+    --json, -j            Emit JSON for scripts.
+  Exit codes: 0 = matches, 3 = no matches.
+  Example: cf-memory-mcp search "OAuth" --status in_progress
+           cf-memory-mcp search "migration" --ids-only | xargs -I{} cfm resume {}`,
     checkpoint: `cf-memory-mcp checkpoint ["<goal>"] [--force] [--json]
   Snapshot current state to a fresh handoff with keep_open:true. The
   session stays active for future checkpoints. The final end_session (or
@@ -6097,11 +6277,15 @@ async function runCleanCli() {
     const removed = [];
     try {
         if (all) {
-            // Clear ALL disk caches in ~/.cf-memory/.
+            // Clear ALL disk caches in ~/.cf-memory/: handoff-*.json
+            // (offline resume cache) AND implicit-*.json (persistent
+            // implicit session id per cwd).
             const dir = path.join(os.homedir(), '.cf-memory');
             if (fs.existsSync(dir)) {
                 for (const entry of fs.readdirSync(dir)) {
-                    if (entry.startsWith('handoff-') && entry.endsWith('.json')) {
+                    const isHandoff = entry.startsWith('handoff-') && entry.endsWith('.json');
+                    const isImplicit = entry.startsWith('implicit-') && entry.endsWith('.json');
+                    if (isHandoff || isImplicit) {
                         const full = path.join(dir, entry);
                         fs.unlinkSync(full);
                         removed.push(full);
@@ -6109,10 +6293,17 @@ async function runCleanCli() {
                 }
             }
         } else {
-            const p = server.getDiskCachePath();
-            if (p && fs.existsSync(p)) {
-                fs.unlinkSync(p);
-                removed.push(p);
+            // cwd-only mode: drop both the handoff cache AND the
+            // implicit session cache for this cwd.
+            const handoffPath = server.getDiskCachePath();
+            if (handoffPath && fs.existsSync(handoffPath)) {
+                fs.unlinkSync(handoffPath);
+                removed.push(handoffPath);
+            }
+            const implicitPath = server.getImplicitSessionDiskPath();
+            if (implicitPath && fs.existsSync(implicitPath)) {
+                fs.unlinkSync(implicitPath);
+                removed.push(implicitPath);
             }
         }
         if (flags.json) {
@@ -6369,6 +6560,11 @@ if (process.argv[2] === 'list') {
     return;
 }
 
+if (process.argv[2] === 'search') {
+    runSearchCli();
+    return;
+}
+
 if (process.argv[2] === 'checkpoint') {
     runCheckpointCli();
     return;

package/package.json

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