mcp-memory-bucket 0.8.2 → 0.8.3

package/dist/src/server.js

@@ -38,13 +38,22 @@ const PORT = process.env.PORT ? Number(process.env.PORT) : 8767;
 const config = loadConfig();
 const db = openCache(config.cacheDbPath);
 const identity = new IdentityTracker(config.folderfooMode);
-const skillSpec = skillSyncSpec([{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders]);
+// Built ONCE and shared by reference with SkillRepository below — registerRemoteFolder/addFolder
+// push into this same array in place, so skillSpec.sources (used by initialScan/watchSources/
+// startRemotePolling/pollOne's upsertFile) sees a folder added live, without a restart. Evaluating
+// this array literal separately for skillSpec and for `new SkillRepository(...)` (as before) creates
+// two distinct arrays that fall out of sync the moment a folder is added live: upsertFile's
+// folderForFile lookup against the stale skillSpec.sources then finds no match and stamps folder=""
+// on every doc from that folder — permanently, since upsertFile's mtime-based skip check means the
+// row is never reprocessed to pick up the correct value once the array is finally in sync.
+const skillFolders = [{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders];
+const skillSpec = skillSyncSpec(skillFolders);
 const memorySpec = memorySyncSpec(config.memoryFolders);
 initialScan(db, skillSpec);
 initialScan(db, memorySpec);
 const skillWatcher = watchSources(db, skillSpec);
 const memoryWatcher = watchSources(db, memorySpec);
-const skillRepo = new SkillRepository(db, [{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders], config.remoteSkillFolders, config.baseDir, identity);
+const skillRepo = new SkillRepository(db, skillFolders, config.remoteSkillFolders, config.baseDir, identity);
 const memoryRepo = new MemoryRepository(db, config.memoryFolders, config.remoteMemoryFolders, config.baseDir, identity);
 skillRepo.setWatcher(skillWatcher);
 memoryRepo.setWatcher(memoryWatcher);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "type": "module",
   "description": "MCP server exposing skill_* (reusable coding patterns) and memory_* (point-in-time working context) tools over a markdown+frontmatter source, cached into SQLite at runtime.",
   "repository": {

package/dist/src/shared/bucket-root-tool.js

@@ -1,66 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-import { saveRoot, removeRoot as removeRootFromConfig, sanitizeRootName } from '../config.js';
-import { initialScan } from '../store/sync.js';
-const KIND = z.enum(['skill', 'memory']);
-export function registerBucketRootTools(mcp, config, skillRepo, memoryRepo, db, skillSpec, memorySpec) {
-    mcp.tool('bucket_list_roots', 'Lists the configured skill and memory roots (the named source directories skills/memory docs live under, e.g. "super-skills", "demo-skills", "builtin") — use this to see what roots exist before passing a `root` argument to a create/list/search tool, or before adding/removing one.', {}, async () => {
-        const skill = skillRepo.listRoots().map((r) => ({ ...r, kind: 'skill' }));
-        const memory = memoryRepo.listRoots().map((r) => ({ ...r, kind: 'memory' }));
-        return { content: [{ type: 'text', text: JSON.stringify({ skill, memory }, null, 2) }] };
-    });
-    mcp.tool('bucket_create_root', 'Registers a new skill or memory root: an existing absolute directory path becomes a new named source that skill_create/memory_create can target via `root`. Scans it once and starts watching it live — never creates the directory itself, it must already exist.', {
-        kind: KIND,
-        path: z.string().describe('absolute path to an existing directory'),
-        name: z.string().optional().describe('name for the root; defaults to a sanitized version of the directory\'s basename'),
-    }, async ({ kind, path: dirPath, name }) => {
-        try {
-            if (!path.isAbsolute(dirPath)) {
-                return { content: [{ type: 'text', text: 'path must be an absolute directory path' }], isError: true };
-            }
-            if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
-                return { content: [{ type: 'text', text: `not a directory: ${dirPath}` }], isError: true };
-            }
-            const rootName = sanitizeRootName(name || path.basename(dirPath));
-            if (!rootName) {
-                return { content: [{ type: 'text', text: 'could not derive a valid root name — provide one explicitly' }], isError: true };
-            }
-            const repo = kind === 'skill' ? skillRepo : memoryRepo;
-            repo.addRoot({ name: rootName, path: dirPath });
-            saveRoot(config, kind, { name: rootName, path: dirPath });
-            return { content: [{ type: 'text', text: JSON.stringify({ name: rootName, path: dirPath, kind }, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: err.message }], isError: true };
-        }
-    });
-    mcp.tool('bucket_delete_root', 'Unregisters a skill or memory root by name: stops watching it and drops its cached entries from the index. Never touches files on disk — the directory and its contents are left in place.', { kind: KIND, name: z.string() }, async ({ kind, name }) => {
-        try {
-            const repo = kind === 'skill' ? skillRepo : memoryRepo;
-            repo.removeRoot(name);
-            removeRootFromConfig(config, kind, name);
-            return { content: [{ type: 'text', text: `Removed ${kind} root "${name}"` }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: err.message }], isError: true };
-        }
-    });
-    mcp.tool('bucket_rebuild_cache', 'EMERGENCY USE ONLY. Wipes the entire SQLite cache (all skills, memory docs, the full-text search index, and the date index) and rebuilds it from scratch by rescanning every configured root from disk. Source markdown files on disk are never touched — this only affects the derived cache, which is always safe to discard and regenerate. Use this only when other tools return results that contradict what you can see in the actual files (e.g. stale search hits, a doc that clearly exists on disk but skill_get/memory_get can\'t find, or search_by_date returning wrong dates) and a normal create/update/relocate call hasn\'t resolved it — this is a last resort, not a routine maintenance step. Takes a moment to complete on a large root; nothing else should be called until it returns.', {}, async () => {
-        try {
-            db.exec(`DELETE FROM skills; DELETE FROM memory_docs; DELETE FROM search_index; DELETE FROM doc_dates;`);
-            initialScan(db, skillSpec);
-            initialScan(db, memorySpec);
-            const skillCount = db.prepare(`SELECT COUNT(*) AS n FROM skills`).get().n;
-            const memoryCount = db.prepare(`SELECT COUNT(*) AS n FROM memory_docs`).get().n;
-            return {
-                content: [
-                    { type: 'text', text: `Cache rebuilt from disk: ${skillCount} skill(s), ${memoryCount} memory doc(s) reindexed.` },
-                ],
-            };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: err.message }], isError: true };
-        }
-    });
-}