mcp-memory-bucket 0.8.7 → 0.9.0

package/dist/client/index.html

@@ -33,7 +33,7 @@
       z-index: 2147483000;
     }
   </style>
-  <script type="module" crossorigin src="/assets/index-y6XKwUMi.js"></script>
+  <script type="module" crossorigin src="/assets/index-D-Xr5fx5.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

package/dist/src/config.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 const FOLDERFOO_DEV_HOST = 'http://localhost:3000';
 const FOLDERFOO_CLOUD_HOST = 'https://files.cuul.cc';
@@ -75,12 +76,23 @@ function resolveFolders(entries, baseDir) {
     const deduped = folders.filter((f) => (seen.has(f.path) ? false : (seen.add(f.path), true)));
     return { folders: deduped, remoteFolders };
 }
+/**
+ * Default home for the cache DB, config file, credentials, and remote mirrors
+ * when nothing else is specified — centralized under the user's home directory
+ * so the same store is used regardless of which directory the tool is launched
+ * from. Overridable via --memory-dir/MEMORY_BUCKET_DIR for tests or anyone who
+ * still wants a per-project store.
+ */
+export function defaultBaseDir() {
+    return path.join(os.homedir(), '.mem-mcp');
+}
 export function loadConfig(cwd = process.cwd(), argv = process.argv) {
     const explicitDir = memoryDirFlag(argv) ?? process.env.MEMORY_BUCKET_DIR;
-    const baseDir = explicitDir ? path.resolve(cwd, explicitDir) : cwd;
-    // The config file lives alongside the cache DB in baseDir (which is cwd
-    // itself unless --memory-dir/MEMORY_BUCKET_DIR points elsewhere) — this
-    // must match where saveFolder/removeFolder write back to.
+    const baseDir = explicitDir ? path.resolve(cwd, explicitDir) : defaultBaseDir();
+    fs.mkdirSync(baseDir, { recursive: true });
+    // The config file lives alongside the cache DB in baseDir (~/.mem-mcp unless
+    // --memory-dir/MEMORY_BUCKET_DIR points elsewhere) — this must match where
+    // saveFolder/removeFolder write back to.
     const configPath = path.join(baseDir, 'memory-bucket.config.json');
     const overrides = readConfigFile(configPath);
     // Without an explicit config, only default to ./skills or ./docs when that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.8.7",
+  "version": "0.9.0",
   "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 };
-        }
-    });
-}