npm - mcp-memory-bucket - Versions diffs - 0.4.2 → 0.5.0 - Mend

mcp-memory-bucket 0.4.2 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/client/assets/index-DSHtiYCt.js +1329 -0
package/dist/client/index.html +1 -1
package/dist/src/memory/repository.js +15 -0
package/dist/src/server.js +1 -1
package/dist/src/store/sync.js +25 -4
package/dist/src/web/routes.js +130 -2
package/package.json +1 -1
package/dist/client/assets/index-BXCTjiGA.js +0 -894

package/dist/client/index.html CHANGED Viewed

@@ -27,7 +27,7 @@
     :root[data-theme='dark'] { color-scheme: dark; }
     body { font-family: system-ui, sans-serif; margin: 0; background: var(--bg); color: var(--fg); }
   </style>
-  <script type="module" crossorigin src="/assets/index-BXCTjiGA.js"></script>
+  <script type="module" crossorigin src="/assets/index-DSHtiYCt.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

package/dist/src/memory/repository.js CHANGED Viewed

@@ -278,6 +278,21 @@ export class MemoryRepository {
         fs.unlinkSync(existing.source_path);
         removeFile(this.db, 'memory_docs', existing.source_path);
     }
+    /**
+     * Strips the doc's frontmatter entirely, leaving a bare markdown file with just the body — the
+     * inverse of memory_create, for turning a managed memory doc back into a plain dropped-in file.
+     * The file stays at the same path, but loses its `key` (so it drops out of key-based lookup) and
+     * its `id` — the upsertFile call below immediately re-derives a fresh one from the filename via
+     * deriveFrontmatter's fallback, so the caller should treat this doc as gone under its old id
+     * once this returns (look it up by the new filename-derived id/key instead).
+     */
+    stripFrontmatter(id) {
+        const existing = this.get(id);
+        if (!existing)
+            throw new Error(`memory doc with id "${id}" not found`);
+        writeMarkdownFile(existing.source_path, {}, existing.body);
+        upsertFile(this.db, this.syncSpec, existing.source_path);
+    }
     /**
      * Deletes many memory docs by id in one call — e.g. cleaning up a batch of
      * abandoned docs found via search(). Returns per-id results so one bad id

package/dist/src/server.js CHANGED Viewed

@@ -62,7 +62,7 @@ function buildMcpServer() {
 }
 const app = express();
 app.use(express.json());
-app.use(buildWebRouter(db, config, skillRepo, memoryRepo));
+app.use(buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec));
 app.use(express.static(path.join(packageRoot, 'dist', 'client')));
 app.post('/mcp', async (req, res) => {
     const server = buildMcpServer();

package/dist/src/store/sync.js CHANGED Viewed

@@ -4,6 +4,8 @@ import chokidar, {} from 'chokidar';
 import { readMarkdownFile } from './markdown-file.js';
 import { flattenTags } from './db.js';
 import { extractDates, toLocalDate } from './date-extract.js';
+import { slugify } from './slug.js';
+import { normalizeKey } from '../types.js';
 // `paused` is deliberately absent from both lists: it's a local-only cache column (see
 // SkillRepository/MemoryRepository#setPaused) that never round-trips through frontmatter, so a
 // file add/change/rescan must never overwrite it via the INSERT/ON CONFLICT UPDATE below.
@@ -16,7 +18,7 @@ export function skillSyncSpec(sources) {
         matchesFile: (filePath) => path.basename(filePath) === 'SKILL.md',
         columns: skillColumns,
         getId: (fm) => fm.name,
-        toRow: (fm) => ({
+        toRow: (fm, _sourcePath, mtimeMs) => ({
             id: fm.name,
             description: fm.description,
             owner: fm.metadata?.owner ?? null,
@@ -25,7 +27,7 @@ export function skillSyncSpec(sources) {
             trigger_phrases: JSON.stringify(fm.trigger_phrases ?? []),
             extends: fm.metadata?.extends ?? null,
             deprecated: fm.deprecated ? 1 : 0,
-            created_at: fm.created_at ?? null,
+            created_at: fm.created_at ?? new Date(mtimeMs).toISOString(),
         }),
     };
 }
@@ -36,6 +38,22 @@ export function memorySyncSpec(sources) {
         matchesFile: (filePath) => filePath.endsWith('.md'),
         columns: memoryColumns,
         getId: (fm) => fm.id,
+        deriveFrontmatter: (fm, filePath, mtimeMs) => {
+            const basename = path.basename(filePath, '.md');
+            const fallbackId = slugify(basename) || 'untitled';
+            return {
+                ...fm,
+                id: fm.id ?? fallbackId,
+                key: fm.key ?? normalizeKey(fallbackId),
+                key_type: fm.key_type ?? 'freeform',
+                description: fm.description ?? basename,
+                doc_type: fm.doc_type ?? 'other',
+                status: fm.status ?? 'active',
+                tags: fm.tags ?? [],
+                related_to: fm.related_to ?? null,
+                created_at: fm.created_at ?? new Date(mtimeMs).toISOString(),
+            };
+        },
         toRow: (fm) => ({
             id: fm.id,
             key: fm.key,
@@ -76,12 +94,15 @@ export function upsertFile(db, spec, filePath) {
     const parsed = readMarkdownFile(filePath);
     if (existing && existing.mtime_ms === parsed.mtimeMs)
         return; // unchanged, skip reprocessing
-    const id = spec.getId(parsed.frontmatter);
+    const frontmatter = spec.deriveFrontmatter
+        ? spec.deriveFrontmatter(parsed.frontmatter, filePath, parsed.mtimeMs)
+        : parsed.frontmatter;
+    const id = spec.getId(frontmatter);
     if (!id) {
         console.error(`[memory-bucket] skipping ${filePath}: missing required id field in frontmatter`);
         return;
     }
-    const row = spec.toRow(parsed.frontmatter, filePath);
+    const row = spec.toRow(frontmatter, filePath, parsed.mtimeMs);
     const root = rootForFile(spec.sources, filePath);
     const cols = [...spec.columns, 'source_path', 'root', 'body', 'mtime_ms'];
     const values = [...spec.columns.map((c) => row[c]), filePath, root, parsed.body, parsed.mtimeMs];

package/dist/src/web/routes.js CHANGED Viewed

@@ -2,7 +2,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import express from 'express';
+import matter from 'gray-matter';
 import { saveRoot, removeRoot as removeRootFromConfig, sanitizeRootName } from '../config.js';
+import { initialScan } from '../store/sync.js';
 function asArray(v) {
     if (v === undefined)
         return [];
@@ -253,8 +255,21 @@ function buildHealth(db) {
         .map((m) => m.id);
     return { danglingExtends, danglingRelatedTo, emptyTriggerPhrases, staleActiveMemoryDocs };
 }
-export function buildWebRouter(db, config, skillRepo, memoryRepo) {
+export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec) {
     const router = express.Router();
+    router.post('/api/rebuild-cache', (_req, res) => {
+        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;
+            res.json({ skillCount, memoryCount });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     router.get('/api/entries', (req, res) => {
         res.json(queryEntries(db, req));
     });
@@ -271,7 +286,26 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo) {
         }
         const tags = JSON.parse(row.tags);
         const trigger_phrases = row.trigger_phrases ? JSON.parse(row.trigger_phrases) : undefined;
-        res.json({ ...row, tags, trigger_phrases });
+        // A memory doc's cache row always looks fully populated even for a bare file (deriveFrontmatter's
+        // fallback backfills id/key/etc — see sync.ts), so whether it actually has an authored
+        // frontmatter block has to be checked on disk. This drives "Add frontmatter" (memory only —
+        // write real values in for the first time) vs "Edit"/"Delete frontmatter". Skills have no such
+        // fallback, so a skills row reaching this route always has real frontmatter; this stays false
+        // only in the memory_docs case in practice.
+        //
+        // `raw_file` is the true on-disk content (frontmatter block + body) for the Raw view — distinct
+        // from the cache's `body` column, which is always frontmatter-stripped (see readMarkdownFile).
+        let has_frontmatter = true;
+        let raw_file;
+        try {
+            raw_file = fs.readFileSync(row.source_path, 'utf-8');
+            has_frontmatter = Object.keys(matter(raw_file).data).length > 0;
+        }
+        catch {
+            // file unreadable/missing — treat as having frontmatter so the UI doesn't offer to "add"
+            // one for a doc it can't actually reach; the existing edit/delete-doc paths will 404 instead.
+        }
+        res.json({ ...row, tags, trigger_phrases, has_frontmatter, raw_file });
     });
     router.patch('/api/entries/:table/:id/deprecated', (req, res) => {
         const { table, id } = req.params;
@@ -313,6 +347,73 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo) {
         const results = table === 'skills' ? skillRepo.bulkUpdate(ids, { deprecated }) : memoryRepo.bulkUpdate(ids, { deprecated });
         res.json({ results });
     });
+    // General frontmatter edit — covers both "edit an existing doc's fields" and "add frontmatter
+    // to a bare file" (a bare memory doc already has a derived id/key from deriveFrontmatter, so
+    // "add" is just this same call supplying real values). Memory `key` is editable here (update()
+    // normalizes it). Skill `name` is not — SkillRepository.update() rejects it outright since
+    // renaming requires a real folder move (see the rename route below).
+    router.patch('/api/entries/:table/:id', (req, res) => {
+        const { table, id } = req.params;
+        const { frontmatter } = req.body;
+        if (table !== 'skills' && table !== 'memory_docs') {
+            res.status(400).json({ error: 'table must be "skills" or "memory_docs"' });
+            return;
+        }
+        if (!id) {
+            res.status(400).json({ error: 'id is required' });
+            return;
+        }
+        if (!frontmatter || typeof frontmatter !== 'object') {
+            res.status(400).json({ error: 'body must be { frontmatter: object }' });
+            return;
+        }
+        if (table === 'skills' && 'name' in frontmatter) {
+            res.status(400).json({ error: 'name cannot be changed via this route — use rename' });
+            return;
+        }
+        try {
+            const updated = table === 'skills' ? skillRepo.update(id, frontmatter) : memoryRepo.update(id, frontmatter);
+            res.json(updated);
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
+    router.post('/api/entries/skills/:name/rename', (req, res) => {
+        const { name } = req.params;
+        const { new_name } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        if (!new_name) {
+            res.status(400).json({ error: 'body must be { new_name: string }' });
+            return;
+        }
+        try {
+            const renamed = skillRepo.rename(name, new_name);
+            res.json(renamed);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // Memory docs only — skill frontmatter (name/description) is required by the agentskills.io
+    // spec, so stripping it would produce a non-conformant SKILL.md no compliant agent can load.
+    router.delete('/api/entries/memory_docs/:id/frontmatter', (req, res) => {
+        const { id } = req.params;
+        if (!id) {
+            res.status(400).json({ error: 'id is required' });
+            return;
+        }
+        try {
+            memoryRepo.stripFrontmatter(id);
+            res.json({ id, frontmatterRemoved: true });
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
     // `paused` is a local-only cache toggle (see SkillRepository/MemoryRepository#setPaused) — it
     // never touches the source file, so this goes through setPaused, not update()/bulkUpdate().
     router.patch('/api/entries/:table/:id/paused', (req, res) => {
@@ -479,5 +580,32 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo) {
         const parent = path.dirname(dirPath) !== dirPath ? path.dirname(dirPath) : null;
         res.json({ path: dirPath, parent, entries });
     });
+    router.post('/api/fs/mkdir', (req, res) => {
+        const { path: parentPath, name } = req.body;
+        if (!parentPath || !path.isAbsolute(parentPath)) {
+            res.status(400).json({ error: 'path must be an absolute directory path' });
+            return;
+        }
+        if (!name || name.trim() !== name || name.includes('/') || name === '.' || name === '..') {
+            res.status(400).json({ error: 'invalid folder name' });
+            return;
+        }
+        if (!fs.existsSync(parentPath) || !fs.statSync(parentPath).isDirectory()) {
+            res.status(400).json({ error: `not a directory: ${parentPath}` });
+            return;
+        }
+        const newDirPath = path.join(parentPath, name);
+        if (fs.existsSync(newDirPath)) {
+            res.status(409).json({ error: `already exists: ${newDirPath}` });
+            return;
+        }
+        try {
+            fs.mkdirSync(newDirPath);
+            res.json({ path: newDirPath, name });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     return router;
 }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.4.2",
+  "version": "0.5.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": {