mcp-memory-bucket 0.7.1 → 0.7.5

package/dist/src/channels/search.js

@@ -0,0 +1,40 @@
+import { distance } from 'fastest-levenshtein';
+/**
+ * Mirrors mcp-tenant-lib's channel-search.ts — duplicated rather than
+ * imported since this package has no other dependency on mcp-tenant-lib.
+ * See that file for the full design rationale behind the stem/typo split.
+ */
+function words(name) {
+    return name.split(/[_-]+/).filter(Boolean);
+}
+function typoScore(a, b) {
+    const maxLen = Math.max(a.length, b.length);
+    if (maxLen === 0)
+        return 1;
+    return 1 - distance(a, b) / maxLen;
+}
+function stemScore(a, b) {
+    const [shorter, longer] = a.length <= b.length ? [a, b] : [b, a];
+    if (shorter.length < 3 || !longer.startsWith(shorter))
+        return 0;
+    return shorter.length / longer.length;
+}
+function wordScore(query, word) {
+    const stem = stemScore(query, word);
+    if (Math.abs(query.length - word.length) > 2)
+        return stem;
+    return Math.max(stem, typoScore(query, word));
+}
+export function scoreChannelMatch(query, candidate) {
+    const q = query.toLowerCase();
+    const c = candidate.toLowerCase();
+    const whole = Math.max(typoScore(q, c), stemScore(q, c));
+    const perWord = words(c).map((w) => wordScore(q, w));
+    return Math.max(whole, ...perWord, 0);
+}
+export function findChannelMatches(query, candidates, minScore = 0.5) {
+    return candidates
+        .map((name) => ({ name, score: scoreChannelMatch(query, name) }))
+        .filter((m) => m.score >= minScore)
+        .sort((a, b) => b.score - a.score);
+}

package/dist/src/channels/store.js

@@ -0,0 +1,53 @@
+/**
+ * URL-safe slug rule for agent-chosen channel names: letters, digits,
+ * underscore, hyphen only. Mirrors mcp-tenant-lib's isValidChannelName —
+ * duplicated rather than imported since this package has no other
+ * dependency on mcp-tenant-lib and one shared regex isn't worth adding one.
+ */
+export function isValidChannelName(name) {
+    return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+const channels = new Map();
+/** Auto-vivifies on first reference, same as mcp-tenant-lib's getOrCreateTenant. */
+export function getOrCreateChannel(name) {
+    let channel = channels.get(name);
+    if (!channel) {
+        channel = { name, content: '', lastActivityAt: Date.now() };
+        channels.set(name, channel);
+    }
+    return channel;
+}
+export function getChannel(name) {
+    return channels.get(name);
+}
+export function listChannels() {
+    return [...channels.values()];
+}
+function envMs(name, defaultMs) {
+    const raw = process.env[name];
+    if (!raw)
+        return defaultMs;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : defaultMs;
+}
+// Long-lived by design: a cross-agent discussion may span much longer gaps
+// between contributions than a live form-fill session (mcp-tenant-lib's
+// tenants default to a 30-minute idle timeout) — default here is ~24h.
+const MEMORY_CHANNEL_IDLE_TIMEOUT_MS = envMs('MEMORY_CHANNEL_IDLE_TIMEOUT_MS', 24 * 60 * 60 * 1000);
+const MEMORY_CHANNEL_SWEEP_INTERVAL_MS = envMs('MEMORY_CHANNEL_SWEEP_INTERVAL_MS', 30 * 60 * 1000);
+export function startChannelSweep(onSweep) {
+    const sweepInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [name, channel] of channels) {
+            if (now - channel.lastActivityAt > MEMORY_CHANNEL_IDLE_TIMEOUT_MS) {
+                onSweep(name);
+                channels.delete(name);
+            }
+        }
+    }, MEMORY_CHANNEL_SWEEP_INTERVAL_MS);
+    sweepInterval.unref();
+    return sweepInterval;
+}
+// Test-only escape hatch, mirroring how mcp-tenant-lib's tests reach into
+// its module-level `tenants` Map directly (see tenant.ts's `tenants` export).
+export { channels };

package/dist/src/channels/tools.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { getOrCreateChannel, getChannel, listChannels, isValidChannelName } from './store.js';
+import { findChannelMatches } from './search.js';
+export function registerMemoryChannelTools(mcp) {
+    mcp.tool('memory_channel_read', 'Reads a memory channel: ephemeral, in-memory-only text shared live between agent sessions on this server ' +
+        '— distinct from persisted memory_* docs (never on disk, never indexed by search). Empty content if the ' +
+        'channel doesn\'t exist yet — reading never creates one (memory_channel_post does). ' +
+        'IMPORTANT: empty is ambiguous ("nothing posted yet" vs "wrong name" — matching is EXACT, no fuzz). Before ' +
+        'saying a discussion doesn\'t exist, call memory_channel_find or list_memory_channels to check for a ' +
+        'similarly-named channel (e.g. "pets" vs "pet_discussion").', { channel: z.string().describe('Channel name. Letters/digits/underscore/hyphen only.') }, async ({ channel }) => {
+        if (!isValidChannelName(channel)) {
+            return {
+                content: [{ type: 'text', text: `Error: "${channel}" is not a valid channel name — use only letters, digits, underscore, and hyphen.` }],
+                isError: true,
+            };
+        }
+        const existing = getChannel(channel);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ content: existing?.content ?? '', lastActivityAt: existing?.lastActivityAt ?? null }, null, 2) }],
+        };
+    });
+    mcp.tool('memory_channel_post', 'Writes to a memory channel, replacing its content (last-write-wins) — auto-creates it if missing. ' +
+        'Ephemeral, in-memory only: never on disk, never indexed by search, gone on restart or after a long idle ' +
+        'period. This ALWAYS replaces content — "append to a discussion" vs "hand over a fresh summary" is your ' +
+        'choice, not a mode: to preserve history, read first then post the old content plus your addition ' +
+        'concatenated; to hand over cleanly, just post fresh content. Names must match EXACTLY — if continuing an ' +
+        'existing discussion, double-check via memory_channel_find/list_memory_channels first, or a typo silently ' +
+        'starts an unrelated empty channel instead of erroring.', {
+        channel: z.string().describe('Channel name. Letters/digits/underscore/hyphen only.'),
+        content: z.string().describe('The full new content of the channel — replaces whatever was there before.'),
+    }, async ({ channel, content }) => {
+        if (!isValidChannelName(channel)) {
+            return {
+                content: [{ type: 'text', text: `Error: "${channel}" is not a valid channel name — use only letters, digits, underscore, and hyphen.` }],
+                isError: true,
+            };
+        }
+        const ch = getOrCreateChannel(channel);
+        ch.content = content;
+        ch.lastActivityAt = Date.now();
+        return {
+            content: [{ type: 'text', text: `Posted ${content.length} character(s) to channel "${channel}".` }],
+        };
+    });
+    mcp.tool('list_memory_channels', 'Lists every memory channel currently live on this server, with when each was last written or read. Use ' +
+        'this to discover an existing channel by name before calling memory_channel_read/post on it.', {}, async () => {
+        const channels = listChannels().map((c) => ({ name: c.name, lastActivityAt: c.lastActivityAt }));
+        return { content: [{ type: 'text', text: JSON.stringify(channels, null, 2) }] };
+    });
+    mcp.tool('memory_channel_find', 'Fuzzy-searches existing memory channel names for a loose query (e.g. "the pets discussion") instead of ' +
+        'guessing at memory_channel_read/post or eyeballing list_memory_channels yourself. Matches whole-name ' +
+        'similarity (typos) and per-word similarity on underscore/hyphen-split parts (e.g. "pets" matches ' +
+        '"pet_food_memory" via "pet"). Returns ranked {name, score} (0..1, higher better), empty if nothing scores ' +
+        'above threshold. Read-only — does not read or create anything. Call memory_channel_read yourself on the ' +
+        'right result; if scores are close, ask the user to disambiguate rather than guessing.', { query: z.string().describe('Loose/partial channel name or topic to search for, e.g. "pets".') }, async ({ query }) => {
+        const matches = findChannelMatches(query, listChannels().map((c) => c.name));
+        return { content: [{ type: 'text', text: JSON.stringify(matches, null, 2) }] };
+    });
+}

package/dist/src/memory/repository.js

@@ -6,6 +6,7 @@ import { slugify } from '../store/slug.js';
 import { resolveWithinBase } from '../store/safe-path.js';
 import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, memorySyncSpec } from '../store/sync.js';
 import { SearchQueryError, sanitizeFtsQuery } from '../store/search.js';
+import { applyBodyEdits } from '../shared/body-edits.js';
 import { attachmentsDirFor } from '../attachments/storage.js';
 import { normalizeKey } from '../types.js';
 /** Uppercases and strips everything but letters/digits — used to compare keys that differ only in
@@ -235,7 +236,7 @@ export class MemoryRepository {
             }
         });
     }
-    update(id, frontmatter, body) {
+    update(id, frontmatter, body, bodyEdits) {
         const existing = this.get(id);
         if (!existing)
             throw new Error(`memory doc with id "${id}" not found`);
@@ -248,7 +249,7 @@ export class MemoryRepository {
             id: existing.id,
             key: frontmatter?.key ? normalizeKey(frontmatter.key) : existing.key,
         };
-        const newBody = body ?? existing.body;
+        const newBody = bodyEdits ? applyBodyEdits(existing.body, bodyEdits).body : (body ?? existing.body);
         writeMarkdownFile(existing.source_path, stripSourcePath(merged), newBody);
         upsertFile(this.db, this.syncSpec, existing.source_path);
         return { ...merged, body: newBody, paused: existingPaused };

package/dist/src/memory/tools.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { stripKey } from './repository.js';
 import { statusSchema } from '../shared/status.js';
+import { bodyEditsSchema, applyBodyEdits, formatBodyEditsDiff } from '../shared/body-edits.js';
 import { normalizeKey } from '../types.js';
 const MEMORY_DOC_TYPES = ['plan', 'spec', 'sql', 'testing-todo', 'discovery', 'session-summary', 'other'];
 const MEMORY_KEY_TYPES = ['ticket', 'freeform'];
@@ -100,21 +101,39 @@ export function registerMemoryTools(mcp, repo) {
         const results = repo.bulkCreate(entries);
         return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     });
-    mcp.tool('memory_update', `Edits an existing memory doc in place — frontmatter fields and/or body. Only provided fields change. ${AUTHORING_SKILL_HINT}`, {
+    mcp.tool('memory_update', `Edits an existing memory doc in place — frontmatter fields and/or body. Only provided fields change. For a body change smaller than the whole document, prefer body_edits over body: it patches via find/replace instead of requiring you to reproduce the entire body, which saves tokens and avoids accidentally dropping untouched content on a large doc. When body_edits is used, the response includes a \`diff\` field (compact -/+ per-edit summary) — show it to the user so they can see what changed, similar to a code diff view. The response never includes the full body (even on a full-body replacement) to avoid echoing back a potentially large doc — call memory_get(id) if you need the fresh full body. ${AUTHORING_SKILL_HINT}`, {
         id: z.string(),
         key: z.string().optional(),
         key_type: z.enum(MEMORY_KEY_TYPES).optional(),
         doc_type: z.enum(MEMORY_DOC_TYPES).optional(),
         description: z.string().optional(),
-        body: z.string().optional(),
+        body: z.string().optional().describe('full body replacement — omit in favor of body_edits when only part of the doc is changing'),
+        body_edits: bodyEditsSchema.optional(),
         tags: z.array(z.string()).optional(),
         status: statusSchema(MEMORY_STATUS_DEFAULTS).optional(),
         related_to: z.string().optional(),
         deprecated: z.boolean().optional().describe('marks the doc as deprecated (or un-deprecates when false) — independent of status'),
-    }, async ({ id, body, ...frontmatterFields }) => {
+    }, async ({ id, body, body_edits, ...frontmatterFields }) => {
+        if (body !== undefined && body_edits !== undefined) {
+            return { content: [{ type: 'text', text: 'Pass either body or body_edits, not both.' }], isError: true };
+        }
         try {
+            let diff;
+            if (body_edits) {
+                const existing = repo.get(id);
+                if (!existing)
+                    throw new Error(`memory doc with id "${id}" not found`);
+                const { body: patchedBody, applied } = applyBodyEdits(existing.body, body_edits);
+                diff = formatBodyEditsDiff(applied);
+                body = patchedBody;
+            }
             const doc = repo.update(id, frontmatterFields, body);
-            return { content: [{ type: 'text', text: JSON.stringify(doc, null, 2) }] };
+            // Body is omitted from the response: the caller either just sent it (full replacement),
+            // already has it, or has `diff` — echoing a potentially large body back is pure waste.
+            // Fetch memory_get(id) if the fresh full body is actually needed.
+            const { body: _omitted, ...docWithoutBody } = doc;
+            const result = diff ? { ...docWithoutBody, diff } : docWithoutBody;
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         catch (err) {
             return { content: [{ type: 'text', text: err.message }], isError: true };

package/dist/src/server.js

@@ -17,6 +17,8 @@ import { registerAttachmentTools } from './attachments/tools.js';
 import { AttachmentRepository } from './attachments/repository.js';
 import { buildWebRouter } from './web/routes.js';
 import { registerUiTool } from './web/ui-tool.js';
+import { registerMemoryChannelTools } from './channels/tools.js';
+import { startChannelSweep } from './channels/store.js';
 // server.ts is rebuilt from `buildMcpServer()` on every /mcp request (see below),
 // so tool schemas (which conditionally include `folder` based on folder count) always
 // reflect the current folders — no restart needed after an add/remove-folder call.
@@ -52,7 +54,7 @@ if (config.skillFolders.length === 0 && config.memoryFolders.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/bucket_*_folder 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_folders to see what named source directories (folders) are configured before passing a folder argument elsewhere, and bucket_create_folder/bucket_delete_folder 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.`;
+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_*_folder 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_folders to see what named source directories (folders) are configured before passing a folder argument elsewhere, and bucket_create_folder/bucket_delete_folder 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. Also exposes memory_channel_read/memory_channel_post/list_memory_channels — a SEPARATE, ephemeral in-memory layer for live cross-agent coordination (a shared scratchpad/discussion channel by name), never written to disk and never indexed by memory_search/bucket_search; do not confuse these with the persisted memory_* docs above.`;
 function buildMcpServer() {
     const server = new McpServer({ name: 'memory-bucket', version: '0.1.0', description: SERVER_DESCRIPTION }, { capabilities: {}, instructions: SERVER_INSTRUCTIONS });
     registerSkillTools(server, skillRepo);
@@ -62,8 +64,10 @@ function buildMcpServer() {
     registerBucketFolderTools(server, config, skillRepo, memoryRepo, db, skillSpec, memorySpec);
     registerAttachmentTools(server, attachmentRepo);
     registerUiTool(server, PORT);
+    registerMemoryChannelTools(server);
     return server;
 }
+startChannelSweep((name) => console.error(`[memory-bucket] sweeping idle memory channel: ${name}`));
 const app = express();
 app.use(express.json());
 app.use(buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec));

package/dist/src/shared/body-edits.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+/**
+ * Search/replace patch format for editing a doc body without round-tripping the whole
+ * thing through the model — same shape as Claude Code's own Edit tool (old_string/new_string).
+ * Line-anchored diffs (unified diff, @@ hunk headers) are what this deliberately avoids:
+ * weaker models reliably botch line numbers and context-line counts, and a rejected hunk
+ * gives no partial credit. Exact-text search/replace has no offsets for the model to get
+ * wrong, and the host enforces uniqueness so a bad match fails loudly with context instead
+ * of silently patching the wrong spot.
+ */
+export const bodyEditSchema = z.object({
+    find: z.string().min(1).describe('exact existing text to locate in the body — must match exactly once unless replace_all is set'),
+    replace: z.string().describe('text to substitute in place of the match'),
+    replace_all: z.boolean().optional().describe('replace every occurrence instead of requiring exactly one match (default: false)'),
+});
+export const bodyEditsSchema = z
+    .array(bodyEditSchema)
+    .min(1)
+    .describe('Alternative to `body`: apply one or more find/replace patches to the existing body instead of rewriting it wholesale. ' +
+    'Applied in order against the current body. Each `find` must match exactly once unless `replace_all` is set. ' +
+    'Cannot be combined with `body` in the same call.');
+/**
+ * Applies find/replace edits to `body` in order, matching Claude Code's Edit tool semantics:
+ * each `find` must appear exactly once unless `replace_all` is set, and a zero/ambiguous match
+ * throws immediately (with surrounding context) rather than guessing — so the caller can retry
+ * with a more specific `find` in the same turn instead of silently corrupting the doc.
+ *
+ * Also returns the applied edits (with occurrence counts) so a caller can render a diff of what
+ * changed without having to re-fetch and diff the pre-edit body itself.
+ */
+export function applyBodyEdits(body, edits) {
+    let result = body;
+    const applied = [];
+    for (const [i, edit] of edits.entries()) {
+        const { find, replace, replace_all } = edit;
+        const occurrences = countOccurrences(result, find);
+        if (occurrences === 0) {
+            throw new Error(`body_edits[${i}]: find text not found in body: ${JSON.stringify(truncate(find))}`);
+        }
+        if (occurrences > 1 && !replace_all) {
+            throw new Error(`body_edits[${i}]: find text matches ${occurrences} times in body — narrow it to a unique match, or set replace_all: true. Text: ${JSON.stringify(truncate(find))}`);
+        }
+        result = replace_all ? result.split(find).join(replace) : replaceFirst(result, find, replace);
+        applied.push({ find, replace, replace_all: !!replace_all, occurrences });
+    }
+    return { body: result, applied };
+}
+/**
+ * Renders applied edits as a compact per-edit diff (`-`/`+` lines, aider/Claude-Code-Edit-tool
+ * style) so a calling agent can show the user what changed without re-fetching the old body.
+ * Not a true unified diff (no line numbers/hunk headers) — deliberately, since this is for
+ * human-readable display, not for feeding back into another patch tool.
+ */
+export function formatBodyEditsDiff(applied) {
+    return applied
+        .map((edit, i) => {
+        const suffix = edit.occurrences > 1 ? ` (${edit.occurrences} occurrences replaced)` : '';
+        const removed = edit.find
+            .split('\n')
+            .map((line) => `-${line}`)
+            .join('\n');
+        const added = edit.replace
+            .split('\n')
+            .map((line) => `+${line}`)
+            .join('\n');
+        return `--- edit ${i + 1}${suffix} ---\n${removed}\n${added}`;
+    })
+        .join('\n');
+}
+function countOccurrences(haystack, needle) {
+    if (needle.length === 0)
+        return 0;
+    let count = 0;
+    let idx = 0;
+    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
+        count++;
+        idx += needle.length;
+    }
+    return count;
+}
+function replaceFirst(haystack, needle, replacement) {
+    const idx = haystack.indexOf(needle);
+    return idx === -1 ? haystack : haystack.slice(0, idx) + replacement + haystack.slice(idx + needle.length);
+}
+function truncate(s, max = 120) {
+    return s.length > max ? `${s.slice(0, max)}…` : s;
+}

package/dist/src/skills/repository.js

@@ -5,6 +5,7 @@ import { assertValidSkillName } from '../store/skill-name.js';
 import { resolveWithinBase } from '../store/safe-path.js';
 import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, skillSyncSpec } from '../store/sync.js';
 import { SearchQueryError, sanitizeFtsQuery } from '../store/search.js';
+import { applyBodyEdits } from '../shared/body-edits.js';
 function rowToDoc(row) {
     return {
         name: row.id,
@@ -221,7 +222,7 @@ export class SkillRepository {
     isBuiltin(doc) {
         return doc.folder === this.folders[0]?.name;
     }
-    update(name, frontmatter, body) {
+    update(name, frontmatter, body, bodyEdits) {
         const existing = this.get(name);
         if (!existing)
             throw new Error(`skill with name "${name}" not found`);
@@ -243,7 +244,7 @@ export class SkillRepository {
                 extends: frontmatter?.extends !== undefined ? frontmatter.extends : existing.metadata.extends,
             },
         };
-        const newBody = body ?? existing.body;
+        const newBody = bodyEdits ? applyBodyEdits(existing.body, bodyEdits).body : (body ?? existing.body);
         writeMarkdownFile(existing.source_path, stripSourcePath(merged), newBody);
         upsertFile(this.db, this.syncSpec, existing.source_path);
         return { ...merged, body: newBody, paused: existingPaused };

package/dist/src/skills/tools.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { statusSchema } from '../shared/status.js';
+import { bodyEditsSchema, applyBodyEdits, formatBodyEditsDiff } from '../shared/body-edits.js';
 const SKILL_STATUS_DEFAULTS = ['stable', 'beta', 'unreviewed'];
 const SKILL_NAME_DESCRIPTION = 'stable id, must be 1-64 chars, lowercase letters/numbers/hyphens only, no leading/trailing/consecutive hyphens — this becomes the skill\'s folder name (agentskills.io spec requirement)';
 const AUTHORING_SKILL_HINT = "Before your first call in a session, run skill_get(\"memory-bucket-authoring\") to learn the exact frontmatter schema and conventions — don't guess the shape.";
@@ -119,10 +120,11 @@ export function registerSkillTools(mcp, repo) {
         })));
         return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     });
-    mcp.tool('skill_update', `Edits an existing skill in place — frontmatter fields and/or body. Only provided fields change. Use skill_rename to change the name/folder. ${AUTHORING_SKILL_HINT}`, {
+    mcp.tool('skill_update', `Edits an existing skill in place — frontmatter fields and/or body. Only provided fields change. Use skill_rename to change the name/folder. For a body change smaller than the whole document, prefer body_edits over body: it patches via find/replace instead of requiring you to reproduce the entire body, which saves tokens and avoids accidentally dropping untouched content on a large skill. When body_edits is used, the response includes a \`diff\` field (compact -/+ per-edit summary) — show it to the user so they can see what changed, similar to a code diff view. The response never includes the full body (even on a full-body replacement) to avoid echoing back a potentially large doc — call skill_get(name) if you need the fresh full body. ${AUTHORING_SKILL_HINT}`, {
         name: z.string(),
         description: z.string().max(1024).optional(),
-        body: z.string().optional(),
+        body: z.string().optional().describe('full body replacement — omit in favor of body_edits when only part of the doc is changing'),
+        body_edits: bodyEditsSchema.optional(),
         license: z.string().optional(),
         compatibility: z.string().max(500).optional(),
         owner: z.string().optional(),
@@ -131,10 +133,27 @@ export function registerSkillTools(mcp, repo) {
         trigger_phrases: z.array(z.string()).optional(),
         extends: z.string().optional(),
         deprecated: z.boolean().optional().describe('marks the skill as deprecated (or un-deprecates when false) — independent of status'),
-    }, async ({ name, body, ...frontmatterFields }) => {
+    }, async ({ name, body, body_edits, ...frontmatterFields }) => {
+        if (body !== undefined && body_edits !== undefined) {
+            return { content: [{ type: 'text', text: 'Pass either body or body_edits, not both.' }], isError: true };
+        }
         try {
+            let diff;
+            if (body_edits) {
+                const existing = repo.get(name);
+                if (!existing)
+                    throw new Error(`skill with name "${name}" not found`);
+                const { body: patchedBody, applied } = applyBodyEdits(existing.body, body_edits);
+                diff = formatBodyEditsDiff(applied);
+                body = patchedBody;
+            }
             const doc = repo.update(name, frontmatterFields, body);
-            return { content: [{ type: 'text', text: JSON.stringify(doc, null, 2) }] };
+            // Body is omitted from the response: the caller either just sent it (full replacement),
+            // already has it, or has `diff` — echoing a potentially large body back is pure waste.
+            // Fetch skill_get(name) if the fresh full body is actually needed.
+            const { body: _omitted, ...docWithoutBody } = doc;
+            const result = diff ? { ...docWithoutBody, diff } : docWithoutBody;
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         catch (err) {
             return { content: [{ type: 'text', text: err.message }], isError: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.7.1",
+  "version": "0.7.5",
   "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": {
@@ -39,6 +39,7 @@
     "better-sqlite3": "^11.8.0",
     "chokidar": "^4.0.0",
     "express": "^4.21.0",
+    "fastest-levenshtein": "^1.0.16",
     "gray-matter": "^4.0.3",
     "lit": "^3.3.3",
     "marked": "^18.0.10",