mcp-memory-bucket 0.3.0 → 0.4.2

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

@@ -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
@@ -46,15 +48,26 @@ 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 ''"],
         ['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/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,10 @@ 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';
+// `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) {
@@ -90,12 +94,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,26 @@ 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
         ? 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, paused }, 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, paused }, intersectIds(matchedIds?.memory_docs, dateIds?.memory_docs)));
     }
     const sort = req.query.sort ?? 'mtime_desc';
     results.sort((a, b) => {
@@ -89,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',
@@ -110,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',
@@ -129,9 +142,40 @@ 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,
     }));
 }
+/** 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 +253,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) => {
@@ -278,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

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