mcp-memory-bucket 0.3.0 → 0.4.0

package/dist/client/index.html

@@ -4,10 +4,30 @@
   <meta charset="utf-8" />
   <title>mem-bucket viewer</title>
   <style>
-    :root { color-scheme: light dark; }
-    body { font-family: system-ui, sans-serif; margin: 0; }
+    :root {
+      color-scheme: light dark;
+      --border: light-dark(#0000001f, #ffffff2e);
+      --border-strong: light-dark(#00000038, #ffffff4a);
+      --hover: light-dark(#00000010, #ffffff14);
+      --hover-strong: light-dark(#00000018, #ffffff20);
+      --bg: light-dark(#ffffff, #1a1a1a);
+      --bg-subtle: light-dark(#00000008, #ffffff0d);
+      --fg: light-dark(#111111, #f0f0f0);
+      --accent: light-dark(#2563eb, #3b82f6);
+      --accent-fg: #ffffff;
+      --accent-tint: light-dark(#2563eb11, #3b82f622);
+      --danger: light-dark(#dc2626, #fca5a5);
+      --purple: light-dark(#7c3aed, #a78bfa);
+      --purple-fg: light-dark(#6d28d9, #d8caff);
+      --purple-tint: #a78bfa33;
+      --shadow: light-dark(#00000026, #00000080);
+      --overlay: light-dark(#00000059, #000000b3);
+    }
+    :root[data-theme='light'] { color-scheme: light; }
+    :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-DIO48C0V.js"></script>
+  <script type="module" crossorigin src="/assets/index-vdbzlLML.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

package/dist/src/config.js

@@ -68,6 +68,15 @@ export function saveRoot(config, kind, root) {
     };
     fs.writeFileSync(config.configPath, JSON.stringify(next, null, 2) + '\n');
 }
+/** Lowercase-hyphenate a folder-derived root name, same shape as skill names. */
+export function sanitizeRootName(raw) {
+    return raw
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64);
+}
 /**
  * Removes a named root from the config file by name. Matches both explicit
  * {name, path} entries and bare-string entries (via their derived name).

package/dist/src/server.js

@@ -12,6 +12,7 @@ import { registerSkillTools } from './skills/tools.js';
 import { registerMemoryTools } from './memory/tools.js';
 import { registerRelocateTool } from './shared/relocate-tool.js';
 import { registerSearchTool } from './shared/search-tool.js';
+import { registerBucketRootTools } from './shared/bucket-root-tool.js';
 import { buildWebRouter } from './web/routes.js';
 import { registerUiTool } from './web/ui-tool.js';
 // server.ts is rebuilt from `buildMcpServer()` on every /mcp request (see below),
@@ -48,13 +49,14 @@ if (config.skillRoots.length === 0 && config.memoryRoots.length === 0) {
 // this server — surfaced both in serverInfo.description and instructions so
 // clients that expose either to the model can make that association.
 const SERVER_DESCRIPTION = 'Also known as "memory bucket", "mem bucket", or "skill bucket" — if the user refers to this server by any of those names, they mean this one.';
-const SERVER_INSTRUCTIONS = `${SERVER_DESCRIPTION} Exposes skill_* (reusable coding patterns, stored as agentskills.io-standard SKILL.md folders) and memory_* (point-in-time working context — plans, specs, SQL, session summaries — looked up by key) tools, plus shared relocate/bucket_search tools. Use skill_search/memory_search/bucket_search for full-text search over body content (not just metadata) — bucket_search when you don't know which bucket something landed in. Most operations have a _bulk_ variant (bulk_get/bulk_create/bulk_update/bulk_delete, relocate_bulk) that take a list and return per-item success/failure — prefer these over looping single calls when acting on more than one item. Before calling any *_create/*_update/relocate tool, call skill_get("memory-bucket-authoring") first to learn the exact frontmatter schema — don't guess the shape.`;
+const SERVER_INSTRUCTIONS = `${SERVER_DESCRIPTION} Exposes skill_* (reusable coding patterns, stored as agentskills.io-standard SKILL.md folders) and memory_* (point-in-time working context — plans, specs, SQL, session summaries — looked up by key) tools, plus shared relocate/bucket_search/bucket_*_root tools. Use skill_search/memory_search/bucket_search for full-text search over body content (not just metadata) — bucket_search when you don't know which bucket something landed in. Use bucket_list_roots to see what named source directories (roots) are configured before passing a root argument elsewhere, and bucket_create_root/bucket_delete_root to register or unregister one. Most operations have a _bulk_ variant (bulk_get/bulk_create/bulk_update/bulk_delete/bulk_rename, relocate_bulk) that take a list and return per-item success/failure — prefer these over looping single calls when acting on more than one item. A memory doc's key can be changed in place via memory_update(id, key: ...) — no separate rename tool needed. Before calling any *_create/*_update/relocate tool, call skill_get("memory-bucket-authoring") first to learn the exact frontmatter schema — don't guess the shape.`;
 function buildMcpServer() {
     const server = new McpServer({ name: 'memory-bucket', version: '0.1.0', description: SERVER_DESCRIPTION }, { capabilities: {}, instructions: SERVER_INSTRUCTIONS });
     registerSkillTools(server, skillRepo);
     registerMemoryTools(server, memoryRepo);
     registerRelocateTool(server, skillRepo, memoryRepo);
     registerSearchTool(server, db);
+    registerBucketRootTools(server, config, skillRepo, memoryRepo, db, skillSpec, memorySpec);
     registerUiTool(server, PORT);
     return server;
 }
@@ -87,6 +89,7 @@ app.get('/mcp', methodNotAllowed);
 app.delete('/mcp', methodNotAllowed);
 app.listen(PORT, () => {
     console.error(`[memory-bucket] MCP server listening on http://localhost:${PORT}/mcp`);
+    console.error(`[memory-bucket] UI available at http://localhost:${PORT}`);
     console.error(`[memory-bucket] skill roots: ${config.skillRoots.map((r) => `${r.name}=${r.path}`).join(', ') || '(none)'}`);
     console.error(`[memory-bucket] memory roots: ${config.memoryRoots.map((r) => `${r.name}=${r.path}`).join(', ') || '(none)'}`);
 });

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

@@ -0,0 +1,66 @@
+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 };
+        }
+    });
+}

package/dist/src/shared/search-tool.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { searchCombined, SearchQueryError } from '../store/search.js';
+import { searchCombined, searchByDate, SearchQueryError } from '../store/search.js';
 export function registerSearchTool(mcp, db) {
     mcp.tool('bucket_search', 'Full-text search across BOTH skills and memory docs in one ranked list — use this when you don\'t know (or don\'t care) which bucket something landed in. `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". For filtering by doc_type/status/tag, use skill_search or memory_search instead. Returns ranked hits with a highlighted snippet, not full body — call skill_get/memory_get on a hit for that.', {
         query: z.string().describe('FTS5 match expression, e.g. `deploy AND rollback` or `"blue green"`'),
@@ -15,4 +15,19 @@ export function registerSearchTool(mcp, db) {
             return { content: [{ type: 'text', text: message }], isError: true };
         }
     });
+    mcp.tool('search_by_date', 'Finds skills and memory docs whose body text mentions a date, OR whose created_at falls, within [start, end] (inclusive, ISO YYYY-MM-DD). Matches any date extracted from the document body plus its created_at — ANY-match, no priority between them. created_at is stored converted to the server\'s local calendar date, so "today"/"this week" ranges built from local time line up correctly without any timezone adjustment. Useful for period-based recall, e.g. "what did I work on this week": the caller computes the date range itself, this tool does not parse natural language. Returns ranked hits (earliest matched date first) with a highlighted snippet showing the matched date in context (or a note that it matched via created_at, when the date isn\'t literally in the body), not the full body — call skill_get/memory_get on a hit for that.', {
+        start: z.string().describe('ISO date YYYY-MM-DD, inclusive'),
+        end: z.string().describe('ISO date YYYY-MM-DD, inclusive'),
+        table: z.enum(['skills', 'memory_docs']).optional().describe('restrict to one bucket; omit to search both'),
+        limit: z.number().int().positive().max(100).optional(),
+        offset: z.number().int().nonnegative().optional(),
+    }, async ({ start, end, table, limit, offset }) => {
+        try {
+            const hits = searchByDate(db, start, end, { table, limit, offset });
+            return { content: [{ type: 'text', text: JSON.stringify(hits, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: err.message }], isError: true };
+        }
+    });
 }

package/dist/src/skills/builtin/memory-bucket-authoring/SKILL.md

@@ -557,6 +557,19 @@ given, ask for both before calling it; don't guess a key from context.
   tools when you don't know (or don't care) which bucket something
   landed in. All three return snippets, not full bodies — follow up with
   `skill_get`/`memory_get` (or the bulk variants below) for the rest.
+- **`search_by_date(start, end)`** — finds skills and memory docs whose
+  **body text mentions a date, or whose `created_at` falls,** within an
+  inclusive ISO `YYYY-MM-DD` range, e.g. "what did I work on this week"
+  once you've resolved "this week" into concrete start/end dates
+  yourself (it does not parse natural language). Both a date written
+  inside the content and the doc's `created_at` count as candidate
+  matches — whichever is earliest wins, no priority between them. Like
+  `bucket_search`, it covers both skills and memory docs at once (pass
+  `table` to restrict to one). Returns a highlighted snippet around the
+  matched date (or a note that it matched via `created_at`, when the
+  date isn't literally in the body), not the full body. `created_at` is
+  indexed as the server's local calendar date, so "today"/"this week"
+  ranges built from local time just work — no timezone conversion needed.
 - **`skill_get`/`memory_get`** — exact-key lookup when you already know
   the name/key.
 

package/dist/src/skills/repository.js

@@ -293,6 +293,22 @@ export class SkillRepository {
             }
         });
     }
+    /**
+     * 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
+     * name, name collision) doesn't abort the rest of the batch.
+     */
+    bulkRename(entries) {
+        return entries.map(({ name, new_name }) => {
+            try {
+                this.rename(name, new_name);
+                return { name, new_name, ok: true };
+            }
+            catch (err) {
+                return { name, new_name, ok: false, error: err.message };
+            }
+        });
+    }
     /** Removes the whole skill directory, including any scripts/references/assets alongside SKILL.md. */
     delete(name) {
         const existing = this.get(name);

package/dist/src/skills/tools.js

@@ -143,6 +143,14 @@ export function registerSkillTools(mcp, repo) {
             return { content: [{ type: 'text', text: err.message }], isError: true };
         }
     });
+    mcp.tool('skill_bulk_rename', 'Renames many skills at once — each entry is a {name, new_name} pair, same semantics as skill_rename (moves the folder, updates frontmatter `name`). Returns per-entry success/failure so one bad pair (unknown name, name collision) doesn\'t abort the rest of the batch.', {
+        entries: z
+            .array(z.object({ name: z.string().describe('current skill name'), new_name: z.string().describe(SKILL_NAME_DESCRIPTION) }))
+            .min(1),
+    }, async ({ entries }) => {
+        const results = repo.bulkRename(entries);
+        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/date-extract.js

@@ -0,0 +1,49 @@
+const MONTHS = {
+    jan: '01', feb: '02', mar: '03', apr: '04', may: '05', jun: '06',
+    jul: '07', aug: '08', sep: '09', oct: '10', nov: '11', dec: '12',
+};
+const ISO_DATE_RE = /\b(\d{4})-(\d{2})-(\d{2})\b/g;
+const WRITTEN_MONTH_RE = /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?\s+(\d{1,2}),?\s+(\d{4})\b/gi;
+function isValidDate(year, month, day) {
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return false;
+    const d = new Date(Date.UTC(year, month - 1, day));
+    return d.getUTCFullYear() === year && d.getUTCMonth() === month - 1 && d.getUTCDate() === day;
+}
+function stripCodeBlocks(body) {
+    return body.replace(/```[\s\S]*?```/g, '');
+}
+/** Extracts unique ISO (YYYY-MM-DD) dates mentioned in free text — conservative by design: only unambiguous formats (ISO, written-month-with-year) are matched, code blocks and slash-dates are skipped entirely. */
+export function extractDates(body) {
+    const text = stripCodeBlocks(body);
+    const dates = new Set();
+    for (const match of text.matchAll(ISO_DATE_RE)) {
+        const [, y, m, d] = match;
+        const year = Number(y);
+        const month = Number(m);
+        const day = Number(d);
+        if (isValidDate(year, month, day))
+            dates.add(`${y}-${m}-${d}`);
+    }
+    for (const match of text.matchAll(WRITTEN_MONTH_RE)) {
+        const [, monthName, dayStr, yearStr] = match;
+        const month = MONTHS[monthName.toLowerCase()];
+        const day = Number(dayStr);
+        const year = Number(yearStr);
+        if (month && isValidDate(year, Number(month), day)) {
+            dates.add(`${yearStr}-${month}-${String(day).padStart(2, '0')}`);
+        }
+    }
+    return Array.from(dates).sort();
+}
+/**
+ * Converts a UTC ISO timestamp (e.g. created_at) to the calendar date it
+ * falls on in the given IANA timezone (default: the OS timezone this
+ * process is running in). Distinct from extractDates()'s output, which is
+ * already timezone-naive text — this exists specifically so a UTC instant
+ * lands on the same calendar date a user in that timezone would call "today".
+ */
+export function toLocalDate(isoTimestamp, timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone) {
+    const formatter = new Intl.DateTimeFormat('en-CA', { timeZone, year: 'numeric', month: '2-digit', day: '2-digit' });
+    return formatter.format(new Date(isoTimestamp));
+}

package/dist/src/store/db.js

@@ -46,6 +46,15 @@ export function openCache(dbPath) {
       tags,
       tokenize = 'porter unicode61'
     );
+
+    CREATE TABLE IF NOT EXISTS doc_dates (
+      ref_table TEXT NOT NULL,
+      ref_id TEXT NOT NULL,
+      date TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_doc_dates_date ON doc_dates(date);
+    CREATE INDEX IF NOT EXISTS idx_doc_dates_ref ON doc_dates(ref_table, ref_id);
   `);
     ensureColumns(db, 'skills', [
         ['root', "TEXT NOT NULL DEFAULT ''"],

package/dist/src/store/search.js

@@ -32,6 +32,64 @@ export function searchIndex(db, query, opts = {}) {
         throw new SearchQueryError(query, err);
     }
 }
+const SNIPPET_CONTEXT_WORDS = 20;
+/**
+ * Builds a `<<...>>`-marked excerpt around the first occurrence of `date` in
+ * `body`, mirroring FTS5's snippet() style for visual consistency with the
+ * other search tools. `date` doesn't always appear literally in the body —
+ * it may have matched via created_at instead — in which case there's no
+ * position to excerpt around, so the marker stands alone with no context.
+ */
+function buildDateSnippet(body, date) {
+    const idx = body.indexOf(date);
+    if (idx === -1)
+        return `<<${date}>> (matched via created_at, not mentioned in body)`;
+    const before = body.slice(0, idx).split(/\s+/).filter(Boolean).slice(-SNIPPET_CONTEXT_WORDS).join(' ');
+    const after = body
+        .slice(idx + date.length)
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, SNIPPET_CONTEXT_WORDS)
+        .join(' ');
+    return `${before ? '…' + before + ' ' : ''}<<${date}>>${after ? ' ' + after + '…' : ''}`;
+}
+/**
+ * Finds skills/memory docs whose body mentions a date, OR whose created_at
+ * falls, within [start, end] (inclusive, ISO YYYY-MM-DD) — driven by the
+ * `doc_dates` side table, populated at index time from both extractDates()
+ * on the body and the doc's created_at, not FTS5. ANY-match: a doc with
+ * multiple candidate dates matches if any falls in range; `matched_date` is
+ * the earliest match, with no priority between body-extracted and created_at.
+ */
+export function searchByDate(db, start, end, opts = {}) {
+    if (start > end) {
+        throw new Error(`invalid date range: start "${start}" is after end "${end}"`);
+    }
+    const { table, limit = 20, offset = 0 } = opts;
+    const params = [start, end];
+    if (table)
+        params.push(table);
+    params.push(limit, offset);
+    const rows = db
+        .prepare(`SELECT ref_table, ref_id, MIN(date) AS matched_date
+       FROM doc_dates
+       WHERE date BETWEEN ? AND ? ${table ? 'AND ref_table = ?' : ''}
+       GROUP BY ref_table, ref_id
+       ORDER BY matched_date
+       LIMIT ? OFFSET ?`)
+        .all(...params);
+    return rows.map((row) => {
+        const bodyRow = db
+            .prepare(`SELECT body FROM ${row.ref_table} WHERE id = ?`)
+            .get(row.ref_id);
+        return {
+            ref_table: row.ref_table,
+            ref_id: row.ref_id,
+            matched_date: row.matched_date,
+            snippet: bodyRow ? buildDateSnippet(bodyRow.body, row.matched_date) : '',
+        };
+    });
+}
 /**
  * Full-text search across BOTH skills and memory docs in one ranked list —
  * for the common case of "find where I put X" when the caller doesn't know

package/dist/src/store/sync.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import chokidar, {} from 'chokidar';
 import { readMarkdownFile } from './markdown-file.js';
 import { flattenTags } from './db.js';
+import { extractDates, toLocalDate } from './date-extract.js';
 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) {
@@ -90,12 +91,25 @@ export function upsertFile(db, spec, filePath) {
      ON CONFLICT(id) DO UPDATE SET ${updateClause}`).run(...values);
     db.prepare(`DELETE FROM search_index WHERE ref_table = ? AND ref_id = ?`).run(spec.table, id);
     db.prepare(`INSERT INTO search_index (ref_table, ref_id, description, body, tags) VALUES (?, ?, ?, ?, ?)`).run(spec.table, id, String(row.description ?? ''), parsed.body, flattenTags(String(row.tags ?? '[]')));
+    db.prepare(`DELETE FROM doc_dates WHERE ref_table = ? AND ref_id = ?`).run(spec.table, id);
+    const dates = new Set(extractDates(parsed.body));
+    // created_at is a UTC instant; convert to the OS-local calendar date so it
+    // lines up with what a user in this timezone would call "today", matching
+    // extractDates()'s output, which is already timezone-naive local text.
+    if (row.created_at)
+        dates.add(toLocalDate(String(row.created_at)));
+    if (dates.size > 0) {
+        const insertDate = db.prepare(`INSERT INTO doc_dates (ref_table, ref_id, date) VALUES (?, ?, ?)`);
+        for (const date of dates)
+            insertDate.run(spec.table, id, date);
+    }
 }
 export function removeFile(db, table, filePath) {
     const existing = db.prepare(`SELECT id FROM ${table} WHERE source_path = ?`).get(filePath);
     db.prepare(`DELETE FROM ${table} WHERE source_path = ?`).run(filePath);
     if (existing) {
         db.prepare(`DELETE FROM search_index WHERE ref_table = ? AND ref_id = ?`).run(table, existing.id);
+        db.prepare(`DELETE FROM doc_dates WHERE ref_table = ? AND ref_id = ?`).run(table, existing.id);
     }
 }
 /** Full scan of all configured source dirs — used once at startup before the watcher takes over. */

package/dist/src/web/routes.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import express from 'express';
-import { saveRoot, removeRoot as removeRootFromConfig } from '../config.js';
+import { saveRoot, removeRoot as removeRootFromConfig, sanitizeRootName } from '../config.js';
 function asArray(v) {
     if (v === undefined)
         return [];
@@ -25,18 +25,24 @@ function queryEntries(db, req) {
     const q = req.query.q?.trim();
     const deprecatedParam = req.query.deprecated;
     const deprecated = deprecatedParam === '0' || deprecatedParam === '1' ? deprecatedParam : undefined;
+    const dateFrom = req.query.date_from?.trim() || undefined;
+    const dateTo = req.query.date_to?.trim() || undefined;
     const matchedIds = q
         ? matchSearch(db, q)
         : null;
     if (q && matchedIds && matchedIds.skills.size === 0 && matchedIds.memory_docs.size === 0) {
         return [];
     }
+    const dateIds = dateFrom || dateTo ? matchDateRange(db, dateFrom, dateTo) : null;
+    if (dateIds && dateIds.skills.size === 0 && dateIds.memory_docs.size === 0) {
+        return [];
+    }
     const results = [];
     if (type === 'skill' || type === 'all') {
-        results.push(...queryTable(db, 'skills', { tags, statuses, owners, docTypes: [], keyTypes: [], roots, deprecated }, matchedIds?.skills));
+        results.push(...queryTable(db, 'skills', { tags, statuses, owners, docTypes: [], keyTypes: [], roots, deprecated }, intersectIds(matchedIds?.skills, dateIds?.skills)));
     }
     if (type === 'memory' || type === 'all') {
-        results.push(...queryTable(db, 'memory_docs', { tags, statuses, owners: [], docTypes, keyTypes, roots, deprecated }, matchedIds?.memory_docs));
+        results.push(...queryTable(db, 'memory_docs', { tags, statuses, owners: [], docTypes, keyTypes, roots, deprecated }, intersectIds(matchedIds?.memory_docs, dateIds?.memory_docs)));
     }
     const sort = req.query.sort ?? 'mtime_desc';
     results.sort((a, b) => {
@@ -132,6 +138,36 @@ function queryTable(db, table, filters, restrictToIds) {
         created_at: r.created_at,
     }));
 }
+/** Combines two optional id-restriction sets (e.g. from `q` and a date range) into one, when both are present. */
+function intersectIds(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return new Set([...a].filter((id) => b.has(id)));
+}
+/** Queries the `doc_dates` side table for ids whose body-extracted or created_at date falls in [from, to], bucketed by source table. */
+function matchDateRange(db, from, to) {
+    const skills = new Set();
+    const memory_docs = new Set();
+    const params = [];
+    let where = '1 = 1';
+    if (from) {
+        where += ' AND date >= ?';
+        params.push(from);
+    }
+    if (to) {
+        where += ' AND date <= ?';
+        params.push(to);
+    }
+    const rows = db
+        .prepare(`SELECT DISTINCT ref_table, ref_id FROM doc_dates WHERE ${where}`)
+        .all(...params);
+    for (const row of rows) {
+        (row.ref_table === 'skills' ? skills : memory_docs).add(row.ref_id);
+    }
+    return { skills, memory_docs };
+}
 /** Runs the FTS5 query once and buckets matching ids by source table. */
 function matchSearch(db, q) {
     const skills = new Set();
@@ -209,15 +245,6 @@ function buildHealth(db) {
         .map((m) => m.id);
     return { danglingExtends, danglingRelatedTo, emptyTriggerPhrases, staleActiveMemoryDocs };
 }
-/** Lowercase-hyphenate a folder-derived root name, same shape as skill names. */
-function sanitizeRootName(raw) {
-    return raw
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 64);
-}
 export function buildWebRouter(db, config, skillRepo, memoryRepo) {
     const router = express.Router();
     router.get('/api/entries', (req, res) => {

package/package.json

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