@exaudeus/memory-mcp 1.9.5 → 1.9.7

package/dist/config-manager.d.ts

@@ -35,6 +35,12 @@ export declare class ConfigManager {
     constructor(configPath: string, initial: LoadedConfig, initialStores: Map<string, MarkdownMemoryStore>, initialHealth: Map<string, LobeHealth>);
     /** Derive alwaysInclude lobe names from config — pure, no side effects. */
     private static computeAlwaysIncludeLobes;
+    /**
+     * Adopt a newly created config file that didn't exist at startup.
+     * Used by memory_bootstrap when it creates memory-config.json from scratch.
+     * Switches the manager from default/env mode to file-based mode and reloads.
+     */
+    adoptNewConfigFile(filePath: string): Promise<void>;
     /**
      * Ensure config is fresh. Call at the start of every tool handler.
      * Stats config file, reloads if mtime changed. Graceful on all errors.

package/dist/config-manager.js

@@ -36,6 +36,17 @@ export class ConfigManager {
             .filter(([, config]) => config.alwaysInclude === true)
             .map(([name]) => name);
     }
+    /**
+     * Adopt a newly created config file that didn't exist at startup.
+     * Used by memory_bootstrap when it creates memory-config.json from scratch.
+     * Switches the manager from default/env mode to file-based mode and reloads.
+     */
+    async adoptNewConfigFile(filePath) {
+        this.configPath = filePath;
+        this.configOrigin = { source: 'file', path: filePath };
+        this.configMtime = 0; // Force reload on next ensureFresh
+        await this.ensureFresh();
+    }
     /**
      * Ensure config is fresh. Call at the start of every tool handler.
      * Stats config file, reloads if mtime changed. Graceful on all errors.

package/dist/index.js

@@ -201,6 +201,13 @@ async function resolveLobesForRead(isFirstMemoryToolCall = true) {
 /** Build the shared lobe property for tool schemas — called on each ListTools request
  *  so the description and enum stay in sync after a hot-reload adds or removes lobes. */
 function buildLobeProperty(currentLobeNames) {
+    if (currentLobeNames.length === 0) {
+        return {
+            type: 'string',
+            description: 'Memory lobe name. No lobes configured yet — run memory_bootstrap(lobe: "your-project", root: "/absolute/path/to/repo") first.',
+            enum: undefined,
+        };
+    }
     const isSingle = currentLobeNames.length === 1;
     return {
         type: 'string',
@@ -563,6 +570,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     sections.push(crashSection);
                 if (degradedSection)
                     sections.push(degradedSection);
+                // Zero lobes — guide agent to bootstrap before anything else
+                if (configManager.getLobeNames().length === 0) {
+                    sections.push('## No Lobes Configured\n\n' +
+                        'No memory lobes exist yet. Run **memory_bootstrap** to create one for this project:\n\n' +
+                        '```\nmemory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo")\n```\n\n' +
+                        'After bootstrapping, call **brief** again to load project context.');
+                    return { content: [{ type: 'text', text: sections.join('\n\n---\n\n') }] };
+                }
                 // Collect briefing across all lobes (or specified lobe + alwaysInclude)
                 const briefingLobeNames = allBriefingLobes;
                 const allStale = [];
@@ -637,9 +652,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             break;
                         }
                         case 'global-only': {
-                            // No project lobes matched — ask agent to specify
+                            // No project lobes matched — ask agent to specify or bootstrap
+                            const lobeNames = configManager.getLobeNames();
+                            const recallHint = lobeNames.length === 0
+                                ? `No lobes configured. Run memory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo") to create one, then retry.`
+                                : `Cannot determine which lobe to search. Specify the lobe: recall(lobe: "...", context: "${context}")\nAvailable: ${lobeNames.join(', ')}\nIf this is a new project, run memory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo") to create a lobe.`;
                             return {
-                                content: [{ type: 'text', text: `Cannot determine which lobe to search. Specify the lobe: recall(lobe: "...", context: "${context}")\nAvailable: ${configManager.getLobeNames().join(', ')}` }],
+                                content: [{ type: 'text', text: recallHint }],
                                 isError: true,
                             };
                         }
@@ -1492,39 +1511,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     root: z.string().optional(),
                     budgetMB: z.number().positive().optional(),
                 }).parse(args);
-                // Auto-create lobe: if the lobe is unknown AND root is provided AND config is
-                // file-based, write the new lobe entry into memory-config.json and hot-reload.
-                // This lets the agent bootstrap a brand-new repo in a single tool call.
+                // Auto-create lobe: if the lobe is unknown AND root is provided, write the new
+                // lobe entry into memory-config.json and hot-reload. If no config file exists yet,
+                // create one at cwd()/memory-config.json — this is the zero-config bootstrap path.
                 if (rawLobe && root && !configManager.getStore(rawLobe)) {
                     const origin = configManager.getConfigOrigin();
-                    if (origin.source !== 'file') {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `Cannot auto-add lobe "${rawLobe}": config is not file-based (source: ${origin.source}).\n\n` +
-                                        `Create memory-config.json next to the memory MCP server with a "lobes" block, then retry.`,
-                                }],
-                            isError: true,
-                        };
-                    }
+                    // Determine the config file path to write to:
+                    // - If already file-based, use the existing file
+                    // - Otherwise, create memory-config.json in cwd() (the server's working directory)
+                    const targetConfigPath = origin.source === 'file'
+                        ? origin.path
+                        : path.join(process.cwd(), 'memory-config.json');
                     try {
-                        const raw = await readFile(origin.path, 'utf-8');
-                        const config = JSON.parse(raw);
+                        let config = {};
+                        if (origin.source === 'file') {
+                            const raw = await readFile(targetConfigPath, 'utf-8');
+                            config = JSON.parse(raw);
+                        }
                         if (!config.lobes || typeof config.lobes !== 'object')
                             config.lobes = {};
                         config.lobes[rawLobe] = { root, budgetMB: budgetMB ?? 2 };
-                        await writeFile(origin.path, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-                        process.stderr.write(`[memory-mcp] Auto-added lobe "${rawLobe}" (root: ${root}) to memory-config.json\n`);
+                        await writeFile(targetConfigPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+                        process.stderr.write(`[memory-mcp] Auto-added lobe "${rawLobe}" (root: ${root}) to ${targetConfigPath}\n`);
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
                         return {
-                            content: [{ type: 'text', text: `Failed to auto-add lobe "${rawLobe}" to memory-config.json: ${message}` }],
+                            content: [{ type: 'text', text: `Failed to write lobe "${rawLobe}" to ${targetConfigPath}: ${message}` }],
                             isError: true,
                         };
                     }
-                    // Reload config to pick up the new lobe (hot-reload detects the updated mtime)
-                    await configManager.ensureFresh();
+                    // Reload config to pick up the new lobe.
+                    // If the file was just created from scratch, adopt it as the new config source.
+                    if (origin.source !== 'file') {
+                        await configManager.adoptNewConfigFile(targetConfigPath);
+                    }
+                    else {
+                        await configManager.ensureFresh();
+                    }
                 }
                 // Resolve store — after this point, rawLobe is never used again
                 const ctx = resolveToolContext(rawLobe);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/memory-mcp",
-  "version": "1.9.5",
+  "version": "1.9.7",
   "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
   "type": "module",
   "main": "dist/index.js",