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

mcp-memory-bucket 0.4.0 → 0.4.2

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 (10) hide show

package/dist/client/assets/{index-vdbzlLML.js → index-BXCTjiGA.js} +144 -134
package/dist/client/index.html +1 -1
package/dist/src/memory/repository.js +50 -9
package/dist/src/memory/tools.js +15 -6
package/dist/src/skills/repository.js +56 -14
package/dist/src/skills/tools.js +22 -7
package/dist/src/store/db.js +4 -0
package/dist/src/store/sync.js +3 -0
package/dist/src/web/routes.js +50 -4
package/package.json +2 -2

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-vdbzlLML.js"></script>
+  <script type="module" crossorigin src="/assets/index-BXCTjiGA.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

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

@@ -18,6 +18,7 @@ function rowToDoc(row) {
         status: row.status,
         related_to: row.related_to,
         deprecated: !!row.deprecated,
+        paused: !!row.paused,
         created_at: row.created_at ?? undefined,
         source_path: row.source_path,
         root: row.root,
@@ -74,12 +75,24 @@ export class MemoryRepository {
         this.watcher?.unwatch(removed.path);
         unregisterRoot(this.db, 'memory_docs', name);
     }
-    /** Exact-match lookup by normalized key, per V0 (no fuzzy matching). */
-    getByKey(key, docType) {
+    /**
+     * Exact-match lookup by normalized key, per V0 (no fuzzy matching).
+     * `includePaused` defaults to false: paused docs are hidden from discovery (see setPaused).
+     */
+    getByKey(key, docType, opts = {}) {
         const normalized = normalizeKey(key);
-        const rows = docType
-            ? this.db.prepare(`SELECT * FROM memory_docs WHERE key = ? AND doc_type = ?`).all(normalized, docType)
-            : this.db.prepare(`SELECT * FROM memory_docs WHERE key = ?`).all(normalized);
+        const conditions = ['key = ?'];
+        const params = [normalized];
+        if (docType) {
+            conditions.push('doc_type = ?');
+            params.push(docType);
+        }
+        if (!opts.includePaused) {
+            conditions.push('paused = 0');
+        }
+        const rows = this.db
+            .prepare(`SELECT * FROM memory_docs WHERE ${conditions.join(' AND ')}`)
+            .all(...params);
         return rows.map(rowToDoc);
     }
     /**
@@ -89,7 +102,7 @@ export class MemoryRepository {
      * so pagination stays correct even when filtering narrows the FTS hit set.
      */
     search(query, opts = {}) {
-        const { docType, status, root, tag, limit = 20, offset = 0 } = opts;
+        const { docType, status, root, tag, limit = 20, offset = 0, includePaused = false } = opts;
         const conditions = [];
         const params = [query];
         if (docType) {
@@ -108,6 +121,9 @@ export class MemoryRepository {
             conditions.push('EXISTS (SELECT 1 FROM json_each(m.tags) WHERE value = ?)');
             params.push(tag);
         }
+        if (!includePaused) {
+            conditions.push('m.paused = 0');
+        }
         params.push(limit, offset);
         try {
             const rows = this.db
@@ -165,7 +181,7 @@ export class MemoryRepository {
         };
         writeMarkdownFile(filePath, stripSourcePath(fm), input.body);
         upsertFile(this.db, this.syncSpec, filePath);
-        return { ...fm, body: input.body };
+        return { ...fm, body: input.body, paused: false };
     }
     /**
      * Creates many memory docs in one call — each entry is the same shape as
@@ -187,8 +203,11 @@ export class MemoryRepository {
         const existing = this.get(id);
         if (!existing)
             throw new Error(`memory doc with id "${id}" not found`);
+        // `paused` is local-cache-only and must never reach writeMarkdownFile — split it off of
+        // `existing` before spreading the rest into the frontmatter that gets written to disk.
+        const { paused: existingPaused, ...existingForFile } = existing;
         const merged = {
-            ...existing,
+            ...existingForFile,
             ...frontmatter,
             id: existing.id,
             key: frontmatter?.key ? normalizeKey(frontmatter.key) : existing.key,
@@ -196,7 +215,7 @@ export class MemoryRepository {
         const newBody = body ?? existing.body;
         writeMarkdownFile(existing.source_path, stripSourcePath(merged), newBody);
         upsertFile(this.db, this.syncSpec, existing.source_path);
-        return { ...merged, body: newBody };
+        return { ...merged, body: newBody, paused: existingPaused };
     }
     /**
      * Applies the same frontmatter change to many memory docs at once — e.g.
@@ -230,6 +249,28 @@ export class MemoryRepository {
             }
         });
     }
+    /**
+     * Pauses/resumes memory docs by id — a local-only toggle stored directly in this cache file's
+     * `paused` column, never written to the doc's markdown file and never synced by the file
+     * watcher (see the comment on memoryColumns in store/sync.ts). Paused docs are hidden from
+     * getByKey()/search() by default but remain fetchable via get()/bulkGet(). Because it's
+     * local-only, the flag does not follow the doc to another machine's cache or survive the cache
+     * file being deleted. Returns per-id results so one bad id doesn't abort the rest of the batch.
+     */
+    setPaused(ids, paused) {
+        return ids.map((id) => {
+            try {
+                const existing = this.get(id);
+                if (!existing)
+                    throw new Error(`memory doc with id "${id}" not found`);
+                this.db.prepare(`UPDATE memory_docs SET paused = ? WHERE id = ?`).run(paused ? 1 : 0, id);
+                return { id, ok: true };
+            }
+            catch (err) {
+                return { id, ok: false, error: err.message };
+            }
+        });
+    }
     delete(id) {
         const existing = this.get(id);
         if (!existing)

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

@@ -7,11 +7,12 @@ export function registerMemoryTools(mcp, repo) {
     const roots = repo.listRoots();
     const multiRoot = roots.length > 1;
     const rootNames = roots.map((r) => r.name).join(', ');
-    mcp.tool('memory_get', 'Exact-match lookup of memory docs (plan/spec/sql/etc.) by normalized key — a ticket ID or a free-form name like "Spot Chart Design". Returns every doc under that key, or only the matching doc_type if provided.', {
+    mcp.tool('memory_get', 'Exact-match lookup of memory docs (plan/spec/sql/etc.) by normalized key — a ticket ID or a free-form name like "Spot Chart Design". Returns every doc under that key, or only the matching doc_type if provided. Paused docs are hidden by default — pass include_paused to see them.', {
         key: z.string(),
         doc_type: z.enum(MEMORY_DOC_TYPES).optional(),
-    }, async ({ key, doc_type }) => {
-        const docs = repo.getByKey(key, doc_type);
+        include_paused: z.boolean().optional().describe('include paused docs, which are hidden by default (see memory_set_paused)'),
+    }, async ({ key, doc_type, include_paused }) => {
+        const docs = repo.getByKey(key, doc_type, { includePaused: include_paused });
         return { content: [{ type: 'text', text: JSON.stringify(docs, null, 2) }] };
     });
     mcp.tool('memory_bulk_get', 'Fetches many memory docs by id in one call, including full markdown bodies — e.g. hydrating a batch of memory_search hits (which return ids, not keys). Missing ids are simply omitted from the result, not errors.', { ids: z.array(z.string()).min(1) }, async ({ ids }) => {
@@ -22,7 +23,7 @@ export function registerMemoryTools(mcp, repo) {
         const keys = repo.listKeys(key_prefix);
         return { content: [{ type: 'text', text: JSON.stringify(keys, null, 2) }] };
     });
-    mcp.tool('memory_search', 'Full-text search over memory doc description/body/tags (grep/find-like, ranked by relevance) — unlike memory_get\'s exact-key lookup, this searches by content across all keys. `query` is raw SQLite FTS5 MATCH syntax: bare words, "exact phrases", prefix* wildcards, AND/OR/NOT boolean operators; hyphenated/punctuated terms must be quoted, e.g. "blue-green". Can be combined with doc_type/status/tag filters. Returns ranked hits with a highlighted snippet, not the full body — call memory_get(key) or fetch by id for that.', {
+    mcp.tool('memory_search', 'Full-text search over memory doc description/body/tags (grep/find-like, ranked by relevance) — unlike memory_get\'s exact-key lookup, this searches by content across all keys. `query` is raw SQLite FTS5 MATCH syntax: bare words, "exact phrases", prefix* wildcards, AND/OR/NOT boolean operators; hyphenated/punctuated terms must be quoted, e.g. "blue-green". Can be combined with doc_type/status/tag filters. Returns ranked hits with a highlighted snippet, not the full body — call memory_get(key) or fetch by id for that. Paused docs are hidden by default — pass include_paused to see them.', {
         query: z.string().describe('FTS5 match expression, e.g. `migration AND rollback` or `"blue green"`'),
         doc_type: z.enum(MEMORY_DOC_TYPES).optional(),
         status: z.enum(MEMORY_STATUS).optional(),
@@ -30,9 +31,10 @@ export function registerMemoryTools(mcp, repo) {
         ...(multiRoot ? { root: z.string().optional().describe(`filter to one root: ${rootNames}`) } : {}),
         limit: z.number().int().positive().max(100).optional(),
         offset: z.number().int().nonnegative().optional(),
-    }, async ({ query, doc_type, status, tag, root, limit, offset }) => {
+        include_paused: z.boolean().optional().describe('include paused docs, which are hidden by default (see memory_set_paused)'),
+    }, async ({ query, doc_type, status, tag, root, limit, offset, include_paused }) => {
         try {
-            const hits = repo.search(query, { docType: doc_type, status, tag, root, limit, offset });
+            const hits = repo.search(query, { docType: doc_type, status, tag, root, limit, offset, includePaused: include_paused });
             return { content: [{ type: 'text', text: JSON.stringify(hits, null, 2) }] };
         }
         catch (err) {
@@ -104,6 +106,13 @@ export function registerMemoryTools(mcp, repo) {
             return { content: [{ type: 'text', text: err.message }], isError: true };
         }
     });
+    mcp.tool('memory_set_paused', 'Pauses or resumes memory docs by id — a local-only toggle stored in this machine\'s SQLite cache, never written to the doc\'s markdown file, so it never touches the file on disk and never follows the doc to another machine\'s cache. Paused docs are hidden from memory_get/memory_search by default but stay fully intact and are still fetchable directly via memory_bulk_get — use this to temporarily stop a doc from surfacing during discovery without deprecating it. Returns per-id success/failure so one bad id doesn\'t abort the batch.', {
+        ids: z.array(z.string()).min(1),
+        paused: z.boolean().describe('true to pause (hide from memory_get/memory_search), false to resume'),
+    }, async ({ ids, paused }) => {
+        const results = repo.setPaused(ids, paused);
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+    });
     mcp.tool('memory_delete', 'Hard-deletes a memory doc by id — removes the markdown file, no tombstone.', { id: z.string() }, async ({ id }) => {
         try {
             repo.delete(id);

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

@@ -13,6 +13,7 @@ function rowToDoc(row) {
         trigger_phrases: JSON.parse(row.trigger_phrases),
         metadata: { owner: row.owner, status: row.status, extends: row.extends },
         deprecated: !!row.deprecated,
+        paused: !!row.paused,
         created_at: row.created_at ?? undefined,
         source_path: row.source_path,
         root: row.root,
@@ -72,14 +73,21 @@ export class SkillRepository {
         this.watcher?.unwatch(removed.path);
         unregisterRoot(this.db, 'skills', name);
     }
-    list(query, root) {
-        const rows = root
-            ? this.db
-                .prepare(`SELECT id, description, owner, status, tags, trigger_phrases, root FROM skills WHERE root = ?`)
-                .all(root)
-            : this.db
-                .prepare(`SELECT id, description, owner, status, tags, trigger_phrases, root FROM skills`)
-                .all();
+    /** `includePaused` defaults to false: paused skills are hidden from discovery (see setPaused). */
+    list(query, root, opts = {}) {
+        const conditions = [];
+        const params = [];
+        if (root) {
+            conditions.push('root = ?');
+            params.push(root);
+        }
+        if (!opts.includePaused) {
+            conditions.push('paused = 0');
+        }
+        const where = conditions.length ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.db
+            .prepare(`SELECT id, description, owner, status, tags, trigger_phrases, root, paused FROM skills${where}`)
+            .all(...params);
         const needle = query?.trim().toLowerCase();
         const items = rows.map((r) => ({
             name: r.id,
@@ -89,6 +97,7 @@ export class SkillRepository {
             tags: JSON.parse(r.tags),
             triggerPhrases: JSON.parse(r.trigger_phrases),
             root: r.root,
+            paused: !!r.paused,
         }));
         const filtered = needle
             ? items.filter((item) => item.description.toLowerCase().includes(needle) ||
@@ -104,7 +113,7 @@ export class SkillRepository {
      * so pagination stays correct even when filtering narrows the FTS hit set.
      */
     search(query, opts = {}) {
-        const { root, status, owner, tag, limit = 20, offset = 0 } = opts;
+        const { root, status, owner, tag, limit = 20, offset = 0, includePaused = false } = opts;
         const conditions = [];
         const params = [query];
         if (root) {
@@ -123,6 +132,9 @@ export class SkillRepository {
             conditions.push('EXISTS (SELECT 1 FROM json_each(s.tags) WHERE value = ?)');
             params.push(tag);
         }
+        if (!includePaused) {
+            conditions.push('s.paused = 0');
+        }
         params.push(limit, offset);
         try {
             const rows = this.db
@@ -186,7 +198,7 @@ export class SkillRepository {
         };
         writeMarkdownFile(filePath, stripSourcePath(fm), body);
         upsertFile(this.db, this.syncSpec, filePath);
-        return { ...fm, body };
+        return { ...fm, body, paused: false };
     }
     /**
      * Creates many skills in one call — each entry is the same shape as create()'s
@@ -212,11 +224,14 @@ export class SkillRepository {
         const existing = this.get(name);
         if (!existing)
             throw new Error(`skill with name "${name}" not found`);
+        // `paused` is local-cache-only and must never reach writeMarkdownFile — split it off of
+        // `existing` before spreading the rest into the frontmatter that gets written to disk.
+        const { paused: existingPaused, ...existingForFile } = existing;
         // Builtin skills (e.g. memory-bucket-authoring) are the server's own always-present
         // documentation, not user content — deprecating them would hide guidance every session needs.
         const deprecated = this.isBuiltin(existing) ? existing.deprecated : frontmatter?.deprecated;
         const merged = {
-            ...existing,
+            ...existingForFile,
             ...frontmatter,
             deprecated,
             name: existing.name, // name is immutable post-creation (it's also the folder name)
@@ -230,7 +245,7 @@ export class SkillRepository {
         const newBody = body ?? existing.body;
         writeMarkdownFile(existing.source_path, stripSourcePath(merged), newBody);
         upsertFile(this.db, this.syncSpec, existing.source_path);
-        return { ...merged, body: newBody };
+        return { ...merged, body: newBody, paused: existingPaused };
     }
     /**
      * Renames a skill: moves <sourceDir>/[folder/]<oldName>/ to .../<newName>/ (keeping any
@@ -253,11 +268,14 @@ export class SkillRepository {
         }
         fs.renameSync(oldDir, newDir);
         const newFilePath = path.join(newDir, 'SKILL.md');
-        const merged = { ...existing, name: newName };
+        // Rename changes the skill's id, so it becomes a fresh cache row — paused (local-only,
+        // keyed by id) does not carry over, same as it wouldn't survive deleting the cache file.
+        const { paused: _existingPaused, ...existingForFile } = existing;
+        const merged = { ...existingForFile, name: newName };
         writeMarkdownFile(newFilePath, stripSourcePath(merged), existing.body);
         removeFile(this.db, 'skills', existing.source_path);
         upsertFile(this.db, this.syncSpec, newFilePath);
-        return { ...merged, body: existing.body };
+        return { ...merged, body: existing.body, paused: false };
     }
     /**
      * Applies the same frontmatter change to many skills at once — e.g. add/remove
@@ -293,6 +311,30 @@ export class SkillRepository {
             }
         });
     }
+    /**
+     * Pauses/resumes skills by name — a local-only toggle stored directly in this cache file's
+     * `paused` column, never written to SKILL.md and never synced by the file watcher (see the
+     * comment on skillColumns in store/sync.ts). Paused skills are hidden from list()/search() by
+     * default but remain fetchable via get()/bulkGet(). Because it's local-only, the flag does not
+     * follow the skill to another machine's cache, survive a rename, or survive the cache file
+     * being deleted. Returns per-name results so one bad name doesn't abort the rest of the batch.
+     */
+    setPaused(names, paused) {
+        return names.map((name) => {
+            try {
+                const existing = this.get(name);
+                if (!existing)
+                    throw new Error(`skill with name "${name}" not found`);
+                if (this.isBuiltin(existing))
+                    throw new Error(`skill "${name}" is builtin and cannot be paused`);
+                this.db.prepare(`UPDATE skills SET paused = ? WHERE id = ?`).run(paused ? 1 : 0, name);
+                return { name, ok: true };
+            }
+            catch (err) {
+                return { name, ok: false, error: err.message };
+            }
+        });
+    }
     /**
      * Renames many skills at once — each entry is a {name, new_name} pair, same
      * semantics as rename(). Returns per-entry results so one bad pair (unknown

package/dist/src/skills/tools.js CHANGED Viewed

@@ -6,23 +6,31 @@ export function registerSkillTools(mcp, repo) {
     const roots = repo.listRoots();
     const multiRoot = roots.length > 1;
     const rootNames = roots.map((r) => r.name).join(', ');
-    mcp.tool('skill_list', 'Lists skills (reusable coding patterns, one SKILL.md per folder per the agentskills.io open standard), optionally filtered by a keyword matched against description/tags/trigger phrases.', multiRoot
-        ? { query: z.string().optional(), root: z.string().optional().describe(`filter to one root: ${rootNames}`) }
-        : { query: z.string().optional() }, async ({ query, root }) => {
-        const items = repo.list(query, root);
+    mcp.tool('skill_list', 'Lists skills (reusable coding patterns, one SKILL.md per folder per the agentskills.io open standard), optionally filtered by a keyword matched against description/tags/trigger phrases. Paused skills are hidden by default — pass include_paused to see them.', multiRoot
+        ? {
+            query: z.string().optional(),
+            root: z.string().optional().describe(`filter to one root: ${rootNames}`),
+            include_paused: z.boolean().optional().describe('include paused skills, which are hidden by default (see skill_set_paused)'),
+        }
+        : {
+            query: z.string().optional(),
+            include_paused: z.boolean().optional().describe('include paused skills, which are hidden by default (see skill_set_paused)'),
+        }, async ({ query, root, include_paused }) => {
+        const items = repo.list(query, root, { includePaused: include_paused });
         return { content: [{ type: 'text', text: JSON.stringify(items, null, 2) }] };
     });
-    mcp.tool('skill_search', 'Full-text search over skill description/body/tags (grep/find-like, ranked by relevance) — unlike skill_list\'s substring metadata filter, this searches the full markdown body. `query` is raw SQLite FTS5 MATCH syntax: bare words, "exact phrases", prefix* wildcards, AND/OR/NOT boolean operators; hyphenated/punctuated terms must be quoted, e.g. "blue-green". Can be combined with status/owner/tag filters. Returns ranked hits with a highlighted snippet, not the full body — call skill_get on a hit\'s name for that.', {
+    mcp.tool('skill_search', 'Full-text search over skill description/body/tags (grep/find-like, ranked by relevance) — unlike skill_list\'s substring metadata filter, this searches the full markdown body. `query` is raw SQLite FTS5 MATCH syntax: bare words, "exact phrases", prefix* wildcards, AND/OR/NOT boolean operators; hyphenated/punctuated terms must be quoted, e.g. "blue-green". Can be combined with status/owner/tag filters. Returns ranked hits with a highlighted snippet, not the full body — call skill_get on a hit\'s name for that. Paused skills are hidden by default — pass include_paused to see them.', {
         query: z.string().describe('FTS5 match expression, e.g. `deploy AND rollback` or `"blue green"`'),
         status: z.enum(SKILL_STATUS).optional(),
         owner: z.string().optional(),
         tag: z.string().optional(),
         limit: z.number().int().positive().max(100).optional(),
         offset: z.number().int().nonnegative().optional(),
+        include_paused: z.boolean().optional().describe('include paused skills, which are hidden by default (see skill_set_paused)'),
         ...(multiRoot ? { root: z.string().optional().describe(`filter to one root: ${rootNames}`) } : {}),
-    }, async ({ query, status, owner, tag, limit, offset, root }) => {
+    }, async ({ query, status, owner, tag, limit, offset, root, include_paused }) => {
         try {
-            const hits = repo.search(query, { root, status, owner, tag, limit, offset });
+            const hits = repo.search(query, { root, status, owner, tag, limit, offset, includePaused: include_paused });
             return { content: [{ type: 'text', text: JSON.stringify(hits, null, 2) }] };
         }
         catch (err) {
@@ -151,6 +159,13 @@ export function registerSkillTools(mcp, repo) {
         const results = repo.bulkRename(entries);
         return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     });
+    mcp.tool('skill_set_paused', 'Pauses or resumes skills by name — a local-only toggle stored in this machine\'s SQLite cache, never written to SKILL.md, so it never touches the file on disk and never follows the skill to another machine\'s cache. Paused skills are hidden from skill_list/skill_search by default but stay fully intact and are still fetchable directly via skill_get/skill_bulk_get — use this to temporarily stop a skill from being surfaced during discovery without deprecating (retiring) it. Returns per-name success/failure so one bad name doesn\'t abort the batch.', {
+        names: z.array(z.string()).min(1),
+        paused: z.boolean().describe('true to pause (hide from skill_list/skill_search), false to resume'),
+    }, async ({ names, paused }) => {
+        const results = repo.setPaused(names, paused);
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+    });
     mcp.tool('skill_delete', 'Hard-deletes a skill by name — removes the whole skill folder (SKILL.md plus any scripts/references/assets), no tombstone.', { name: z.string() }, async ({ name }) => {
         try {
             repo.delete(name);

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

@@ -14,6 +14,7 @@ export function openCache(dbPath) {
       source_path TEXT NOT NULL UNIQUE, -- path to SKILL.md
       root TEXT NOT NULL DEFAULT '',  -- name of the configured root this file lives under
       deprecated INTEGER NOT NULL DEFAULT 0,
+      paused INTEGER NOT NULL DEFAULT 0, -- local-only: never synced from/to SKILL.md, cache-file scoped
       created_at TEXT,
       body TEXT NOT NULL,
       mtime_ms INTEGER NOT NULL
@@ -31,6 +32,7 @@ export function openCache(dbPath) {
       source_path TEXT NOT NULL UNIQUE,
       root TEXT NOT NULL DEFAULT '',  -- name of the configured root this file lives under
       deprecated INTEGER NOT NULL DEFAULT 0,
+      paused INTEGER NOT NULL DEFAULT 0, -- local-only: never synced from/to the doc's markdown file, cache-file scoped
       created_at TEXT,
       body TEXT NOT NULL,
       mtime_ms INTEGER NOT NULL
@@ -59,11 +61,13 @@ export function openCache(dbPath) {
     ensureColumns(db, 'skills', [
         ['root', "TEXT NOT NULL DEFAULT ''"],
         ['deprecated', 'INTEGER NOT NULL DEFAULT 0'],
+        ['paused', 'INTEGER NOT NULL DEFAULT 0'],
         ['created_at', 'TEXT'],
     ]);
     ensureColumns(db, 'memory_docs', [
         ['root', "TEXT NOT NULL DEFAULT ''"],
         ['deprecated', 'INTEGER NOT NULL DEFAULT 0'],
+        ['paused', 'INTEGER NOT NULL DEFAULT 0'],
         ['created_at', 'TEXT'],
     ]);
     backfillSearchIndex(db);

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

@@ -4,6 +4,9 @@ import chokidar, {} from 'chokidar';
 import { readMarkdownFile } from './markdown-file.js';
 import { flattenTags } from './db.js';
 import { extractDates, toLocalDate } from './date-extract.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.
 const skillColumns = ['id', 'description', 'owner', 'status', 'tags', 'trigger_phrases', 'extends', 'deprecated', 'created_at'];
 const memoryColumns = ['id', 'key', 'key_type', 'description', 'doc_type', 'tags', 'status', 'related_to', 'deprecated', 'created_at'];
 export function skillSyncSpec(sources) {

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

@@ -25,6 +25,8 @@ function queryEntries(db, req) {
     const q = req.query.q?.trim();
     const deprecatedParam = req.query.deprecated;
     const deprecated = deprecatedParam === '0' || deprecatedParam === '1' ? deprecatedParam : undefined;
+    const pausedParam = req.query.paused;
+    const paused = pausedParam === '0' || pausedParam === '1' ? pausedParam : undefined;
     const dateFrom = req.query.date_from?.trim() || undefined;
     const dateTo = req.query.date_to?.trim() || undefined;
     const matchedIds = q
@@ -39,10 +41,10 @@ function queryEntries(db, req) {
     }
     const results = [];
     if (type === 'skill' || type === 'all') {
-        results.push(...queryTable(db, 'skills', { tags, statuses, owners, docTypes: [], keyTypes: [], roots, deprecated }, intersectIds(matchedIds?.skills, dateIds?.skills)));
+        results.push(...queryTable(db, 'skills', { tags, statuses, owners, docTypes: [], keyTypes: [], roots, deprecated, paused }, intersectIds(matchedIds?.skills, dateIds?.skills)));
     }
     if (type === 'memory' || type === 'all') {
-        results.push(...queryTable(db, 'memory_docs', { tags, statuses, owners: [], docTypes, keyTypes, roots, deprecated }, intersectIds(matchedIds?.memory_docs, dateIds?.memory_docs)));
+        results.push(...queryTable(db, 'memory_docs', { tags, statuses, owners: [], docTypes, keyTypes, roots, deprecated, paused }, intersectIds(matchedIds?.memory_docs, dateIds?.memory_docs)));
     }
     const sort = req.query.sort ?? 'mtime_desc';
     results.sort((a, b) => {
@@ -95,13 +97,17 @@ function queryTable(db, table, filters, restrictToIds) {
         where += ` AND deprecated = ?`;
         params.push(filters.deprecated === '1' ? 1 : 0);
     }
+    if (filters.paused !== undefined) {
+        where += ` AND paused = ?`;
+        params.push(filters.paused === '1' ? 1 : 0);
+    }
     if (restrictToIds) {
         where += ` AND id IN (${[...restrictToIds].map(() => '?').join(', ')})`;
         params.push(...restrictToIds);
     }
     if (table === 'skills') {
         const rows = db
-            .prepare(`SELECT id, description, owner, status, tags, root, mtime_ms, deprecated, created_at FROM skills WHERE ${where}`)
+            .prepare(`SELECT id, description, owner, status, tags, root, mtime_ms, deprecated, paused, created_at FROM skills WHERE ${where}`)
             .all(...params);
         return rows.map((r) => ({
             _table: 'skills',
@@ -116,11 +122,12 @@ function queryTable(db, table, filters, restrictToIds) {
             root: r.root,
             mtime_ms: r.mtime_ms,
             deprecated: !!r.deprecated,
+            paused: !!r.paused,
             created_at: r.created_at,
         }));
     }
     const rows = db
-        .prepare(`SELECT id, key, description, doc_type, key_type, status, tags, root, mtime_ms, deprecated, created_at FROM memory_docs WHERE ${where}`)
+        .prepare(`SELECT id, key, description, doc_type, key_type, status, tags, root, mtime_ms, deprecated, paused, created_at FROM memory_docs WHERE ${where}`)
         .all(...params);
     return rows.map((r) => ({
         _table: 'memory_docs',
@@ -135,6 +142,7 @@ function queryTable(db, table, filters, restrictToIds) {
         root: r.root,
         mtime_ms: r.mtime_ms,
         deprecated: !!r.deprecated,
+        paused: !!r.paused,
         created_at: r.created_at,
     }));
 }
@@ -305,6 +313,44 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo) {
         const results = table === 'skills' ? skillRepo.bulkUpdate(ids, { deprecated }) : memoryRepo.bulkUpdate(ids, { deprecated });
         res.json({ results });
     });
+    // `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) => {
+        const { table, id } = req.params;
+        const { paused } = 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 (typeof paused !== 'boolean') {
+            res.status(400).json({ error: 'body must be { paused: boolean }' });
+            return;
+        }
+        const [result] = table === 'skills' ? skillRepo.setPaused([id], paused) : memoryRepo.setPaused([id], paused);
+        if (!result?.ok) {
+            res.status(404).json({ error: result?.error ?? 'not found' });
+            return;
+        }
+        res.json({ id, paused });
+    });
+    router.post('/api/entries/:table/bulk/paused', (req, res) => {
+        const { table } = req.params;
+        const { ids, paused } = req.body;
+        if (table !== 'skills' && table !== 'memory_docs') {
+            res.status(400).json({ error: 'table must be "skills" or "memory_docs"' });
+            return;
+        }
+        if (!Array.isArray(ids) || ids.length === 0 || typeof paused !== 'boolean') {
+            res.status(400).json({ error: 'body must be { ids: string[], paused: boolean }' });
+            return;
+        }
+        const results = table === 'skills' ? skillRepo.setPaused(ids, paused) : memoryRepo.setPaused(ids, paused);
+        res.json({ results });
+    });
     router.delete('/api/entries/:table/:id', (req, res) => {
         const { table, id } = req.params;
         if (table !== 'skills' && table !== 'memory_docs') {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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": {
@@ -29,7 +29,7 @@
     "copy:builtin-skills": "mkdir -p dist/src/skills/builtin && cp -r src/skills/builtin/. dist/src/skills/builtin/",
     "prepublishOnly": "npm run build",
     "start": "tsx src/server.ts",
-    "start_in_folder": "tsx src/server.ts --memory-dir",
+    "start_in_folder": "vite build && tsx src/server.ts --memory-dir",
     "typecheck": "tsc --noEmit -p tsconfig.server.json && tsc --noEmit -p tsconfig.client.json",
     "test": "node --import tsx --test test/**/*.test.ts"
   },