@mrfentmen/patch-mcp 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# Unified Patch
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Create, check and apply unified diffs offline - a real patch tool with no shell and no repo, keyless.
+
+Keyless — no signup, no API key, no environment variables.
+
+## Install
+
+```bash
+npx -y @mrfentmen/patch-mcp
+```
+
+Or add it to your MCP client:
+
+```json
+{
+  "mcpServers": {
+    "patch-mcp": { "command": "npx", "args": ["-y", "@mrfentmen/patch-mcp"] }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `make_patch` | Produce a unified diff between two texts with configurable context lines. |
+| `apply_patch` | Apply a unified diff to text; fails with a precise message when a hunk does not match. |
+| `check_patch` | Dry-run a unified diff against text and report whether it applies cleanly. |
+
+## Data source
+
+Runs fully offline — all work happens inside the server with no API calls and no keys.

package/dist/api.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unified Patch — keyless public API client.
+ */
+export declare class SourceError extends Error {
+}
+export declare function makePatch(a: {
+    before: string;
+    after: string;
+    context?: number;
+    oldPath?: string;
+    newPath?: string;
+}): Promise<string>;
+export declare function applyPatch(a: {
+    text: string;
+    patch: string;
+    reverse?: boolean;
+}): Promise<string>;
+export declare function checkPatch(a: {
+    text: string;
+    patch: string;
+}): Promise<string>;

package/dist/api.js

@@ -0,0 +1,263 @@
+/**
+ * Unified Patch — keyless public API client.
+ */
+export class SourceError extends Error {
+}
+const MAX_LINES = 3000;
+function linesOf(text) {
+    if (text === "")
+        return [];
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    // A trailing newline marks the end of the last line; it is not an extra
+    // empty line for diff-count purposes.
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+function endsWithNewline(text) {
+    return /\n$/.test(text);
+}
+function parseHunkHeader(line) {
+    const m = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (!m)
+        throw new SourceError(`not a valid hunk header: "${line.slice(0, 60)}"`);
+    return {
+        oldStart: Number(m[1]),
+        oldCount: m[2] === undefined ? 1 : Number(m[2]),
+        newStart: Number(m[3]),
+        newCount: m[4] === undefined ? 1 : Number(m[4]),
+    };
+}
+function parsePatch(patch) {
+    const lines = linesOf(patch);
+    const files = [];
+    let current = null;
+    let hunk = null;
+    let ignoredMarker = false;
+    const finishHunk = () => {
+        if (hunk && current)
+            current.hunks.push(hunk);
+        hunk = null;
+    };
+    for (const line of lines) {
+        if (line.startsWith("--- ")) {
+            finishHunk();
+            current = { oldPath: line.slice(4).trim() || "a", newPath: "", hunks: [] };
+            files.push(current);
+            continue;
+        }
+        if (line.startsWith("+++ ")) {
+            if (!current)
+                throw new SourceError("patch has a +++ line before any --- line");
+            current.newPath = line.slice(4).trim() || "b";
+            continue;
+        }
+        if (line.startsWith("@@")) {
+            if (!current)
+                throw new SourceError("patch has a hunk before any file header");
+            finishHunk();
+            const header = parseHunkHeader(line);
+            const tail = line.replace(/^@@ -[^@]*@@/, "");
+            hunk = { ...header, body: [] };
+            if (tail.trim())
+                throw new SourceError("hunk header has unexpected text after the ranges");
+            continue;
+        }
+        if (line.startsWith("\\")) {
+            ignoredMarker = true;
+            continue;
+        }
+        if (hunk) {
+            const prefix = line.charAt(0);
+            if (prefix !== " " && prefix !== "-" && prefix !== "+") {
+                throw new SourceError(`hunk line must start with a space, - or +: "${line.slice(0, 60)}"`);
+            }
+            hunk.body.push(line);
+            continue;
+        }
+        if (line.trim() !== "")
+            throw new SourceError("patch has text outside any hunk");
+    }
+    finishHunk();
+    if (!files.length)
+        throw new SourceError("no file header (--- / +++) found in the patch");
+    for (const file of files) {
+        if (!file.hunks.length)
+            throw new SourceError(`file "${file.oldPath}" has no hunks`);
+    }
+    for (const file of files) {
+        for (const h of file.hunks) {
+            const oldCount = h.body.filter((l) => l[0] === " " || l[0] === "-").length;
+            const newCount = h.body.filter((l) => l[0] === " " || l[0] === "+").length;
+            if (oldCount !== h.oldCount || newCount !== h.newCount) {
+                throw new SourceError(`hunk at old line ${h.oldStart} declares -${h.oldCount}/+${h.newCount} but contains -${oldCount}/+${newCount}`);
+            }
+        }
+    }
+    return { files, ignoredMarker };
+}
+function reverseHunks(hunks) {
+    return hunks.map((h) => ({
+        oldStart: h.newStart,
+        oldCount: h.newCount,
+        newStart: h.oldStart,
+        newCount: h.oldCount,
+        body: h.body.map((l) => (l[0] === "+" ? "-" + l.slice(1) : l[0] === "-" ? "+" + l.slice(1) : l)),
+    }));
+}
+function applyFile(text, patch) {
+    const old = linesOf(text);
+    const out = [];
+    let cursor = 0;
+    let added = 0;
+    let removed = 0;
+    for (const hunk of patch.hunks) {
+        const target = hunk.oldStart - 1;
+        if (target < cursor)
+            throw new SourceError(`hunks overlap or run backwards at old line ${hunk.oldStart}`);
+        while (cursor < target)
+            out.push(old[cursor++]);
+        for (const body of hunk.body) {
+            const prefix = body[0];
+            const content = body.slice(1);
+            if (prefix === "+") {
+                out.push(content);
+                added++;
+                continue;
+            }
+            const actual = old[cursor];
+            if (actual === undefined) {
+                throw new SourceError(`hunk expects line ${cursor + 1} but the text ends early`);
+            }
+            if (actual !== content) {
+                throw new SourceError(`hunk does not match at line ${cursor + 1}: expected "${content.slice(0, 60)}" but found "${actual.slice(0, 60)}"`);
+            }
+            if (prefix === " ")
+                out.push(actual);
+            else
+                removed++;
+            cursor++;
+        }
+    }
+    while (cursor < old.length)
+        out.push(old[cursor++]);
+    return { text: out.join("\n") + (endsWithNewline(text) && out.length ? "\n" : ""), added, removed };
+}
+function diffPairs(a, b) {
+    const n = a.length;
+    const m = b.length;
+    if (n > MAX_LINES || m > MAX_LINES) {
+        throw new SourceError(`inputs are limited to ${MAX_LINES} lines each (got ${n} and ${m})`);
+    }
+    const width = m + 1;
+    const dp = new Uint32Array((n + 1) * width);
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i * width + j] =
+                a[i] === b[j]
+                    ? dp[(i + 1) * width + j + 1] + 1
+                    : Math.max(dp[(i + 1) * width + j], dp[i * width + j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            out.push(" " + a[i++]);
+            j++;
+        }
+        else if (dp[(i + 1) * width + j] >= dp[i * width + j + 1]) {
+            out.push("-" + a[i++]);
+        }
+        else {
+            out.push("+" + b[j++]);
+        }
+    }
+    while (i < n)
+        out.push("-" + a[i++]);
+    while (j < m)
+        out.push("+" + b[j++]);
+    return out;
+}
+export async function makePatch(a) {
+    const context = Math.floor(a.context ?? 3);
+    if (!Number.isInteger(context) || context < 0 || context > 20)
+        throw new SourceError("context must be between 0 and 20");
+    const before = linesOf(a.before);
+    const after = linesOf(a.after);
+    const pairs = diffPairs(before, after);
+    const changed = pairs.map((line, idx) => (line[0] === " " ? -1 : idx)).filter((idx) => idx >= 0);
+    if (!changed.length)
+        return "No differences between before and after.";
+    const ranges = [];
+    for (const idx of changed) {
+        const start = Math.max(0, idx - context);
+        const end = Math.min(pairs.length - 1, idx + context);
+        const last = ranges[ranges.length - 1];
+        if (last && start <= last.end + 1)
+            last.end = Math.max(last.end, end);
+        else
+            ranges.push({ start, end });
+    }
+    const oldPath = a.oldPath ?? "a";
+    const newPath = a.newPath ?? "b";
+    const header = [`--- ${oldPath}`, `+++ ${newPath}`];
+    for (const range of ranges) {
+        const body = pairs.slice(range.start, range.end + 1);
+        let oldStart = 1;
+        let newStart = 1;
+        for (let k = 0; k < range.start; k++) {
+            if (pairs[k][0] !== "+")
+                oldStart++;
+            if (pairs[k][0] !== "-")
+                newStart++;
+        }
+        const oldCount = body.filter((l) => l[0] !== "+").length;
+        const newCount = body.filter((l) => l[0] !== "-").length;
+        header.push(`@@ -${oldCount ? oldStart : oldStart - 1},${oldCount} +${newCount ? newStart : newStart - 1},${newCount} @@`);
+        header.push(...body);
+    }
+    return [
+        `Unified diff — ${changed.length} changed line(s), ${ranges.length} hunk(s):`,
+        "",
+        ...header,
+    ].join("\n");
+}
+export async function applyPatch(a) {
+    const parsed = parsePatch(a.patch);
+    if (parsed.ignoredMarker) {
+        // "" markers are dropped during parsing.
+    }
+    const files = parsed.files;
+    const target = files[0];
+    if (a.reverse)
+        target.hunks = reverseHunks(target.hunks);
+    const result = applyFile(a.text, target);
+    const beforeLines = linesOf(a.text).length;
+    const afterLines = linesOf(result.text).length;
+    return [
+        `Patch applied${a.reverse ? " in reverse" : ""}: +${result.added} line(s), -${result.removed} line(s).`,
+        `Lines: ${beforeLines} -> ${afterLines}`,
+        a.reverse ? `(reverse of ${files[0].hunks.length} hunk(s))` : `(${target.hunks.length} hunk(s))`,
+        "",
+        result.text,
+    ].join("\n");
+}
+export async function checkPatch(a) {
+    const parsed = parsePatch(a.patch);
+    const target = parsed.files[0];
+    const added = target.hunks.reduce((sum, h) => sum + h.body.filter((l) => l[0] === "+").length, 0);
+    const removed = target.hunks.reduce((sum, h) => sum + h.body.filter((l) => l[0] === "-").length, 0);
+    try {
+        applyFile(a.text, target);
+    }
+    catch (e) {
+        return `Patch does NOT apply: ${e.message}`;
+    }
+    return [
+        `Patch applies cleanly.`,
+        `File: ${target.oldPath} -> ${target.newPath}`,
+        `Hunks: ${target.hunks.length}, +${added} line(s), -${removed} line(s)`,
+    ].join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,12 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("patch-mcp running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,43 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { applyPatch, checkPatch, makePatch, SourceError } from "./api.js";
+const text = (t) => ({ content: [{ type: "text", text: t }] });
+function errorMessage(e) {
+    if (e instanceof SourceError || e instanceof Error)
+        return `Error: ${e.message}`;
+    return `Error: ${String(e)}`;
+}
+export function createServer() {
+    const server = new McpServer({ name: "patch-mcp", version: "1.0.0" });
+    server.tool("make_patch", "Produce a unified diff between two texts with configurable context lines.", {
+        before: z.string().describe('Original text'), after: z.string().describe('Changed text'), context: z.number().int().min(0).max(20).optional().describe('Context lines per hunk, default 3'), oldPath: z.string().optional().describe('Label for the old file, default a'), newPath: z.string().optional().describe('Label for the new file, default b')
+    }, async (a) => {
+        try {
+            return text(await makePatch(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    server.tool("apply_patch", "Apply a unified diff to text; fails with a precise message when a hunk does not match.", {
+        text: z.string().describe('Text to patch'), patch: z.string().describe('Unified diff'), reverse: z.boolean().optional().describe('Apply the patch in reverse, undoing it')
+    }, async (a) => {
+        try {
+            return text(await applyPatch(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    server.tool("check_patch", "Dry-run a unified diff against text and report whether it applies cleanly.", {
+        text: z.string().describe('Text to test against'), patch: z.string().describe('Unified diff')
+    }, async (a) => {
+        try {
+            return text(await checkPatch(a));
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errorMessage(e) }], isError: true };
+        }
+    });
+    return server;
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@mrfentmen/patch-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Create, check and apply unified diffs offline - a real patch tool with no shell and no repo, keyless.",
+  "type": "module",
+  "mcpName": "io.github.mrfentmen/patch-mcp",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrfentmen/awesome-servers.git"
+  },
+  "bin": {
+    "patch-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "diff",
+    "patch",
+    "unified-diff",
+    "developer-tools",
+    "offline",
+    "keyless"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}