mono-pilot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 qianwan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# MonoPilot
+
+> Cursor-compatible coding agent profile powered by pi-mono.
+
+**⚠️ Disclaimer:** This project is an independent compatibility implementation and is **not affiliated with Cursor** or Anysphere Inc.
+
+## MVP Scope (Current)
+
+This repository is intentionally in a **minimal MVP** stage:
+
+- ✅ Core toolset is wired through `mono-pilot` extensions (`read`, `rg`, `glob`, `shell`, `delete`, `apply_patch`).
+- ✅ Built-in `edit` / `write` are removed from default exposed tools.
+- ✅ File mutation is funneled through `apply_patch` (which internally delegates to robust pi-mono primitives).
+- ✅ Additional tools can be migrated incrementally without changing the launcher architecture.
+
+## What ships now
+
+- `src/cli.ts` – `mono-pilot` launcher that wraps `pi`
+- `src/extensions/mono-pilot.ts` – extension entrypoint (wires the current toolset)
+- `tools/*.ts` – tool implementations (`read`, `rg`, `glob`, `shell`, `delete`, `apply_patch`)
+- `tools/*.md` – tool prompt specs injected at runtime
+
+## Local development setup
+
+```bash
+git clone https://github.com/qianwan/mono-pilot.git
+cd mono-pilot
+npm install
+npm run build
+```
+
+## Use in any repository
+
+```bash
+# Run directly without global install
+cd /path/to/your/project
+npx mono-pilot
+
+# Or install globally
+npm install -g mono-pilot
+mono-pilot
+```
+
+## Usage
+
+```bash
+# Interactive
+mono-pilot
+
+# One-shot prompt
+mono-pilot -p "Refactor this module"
+
+# Continue previous session
+mono-pilot --continue
+```
+
+By default, `mono-pilot` launches pi with:
+
+- `--no-extensions`
+- `--extension <mono-pilot extension>`
+- `--tools read,bash,grep,find,ls`
+
+So the exposed write path is `apply_patch`, not built-in `edit` / `write`.
+If you pass `--tools` manually and include `edit`/`write`, MonoPilot strips them automatically.
+
+## Publishing
+
+```bash
+# 1) Validate and build
+npm run check
+npm run build
+
+# 2) Verify package contents
+npm pack --dry-run
+
+# 3) Publish
+npm publish
+```
+
+## Roadmap
+
+- Gradually migrate other Cursor-style tools from `tools/`
+- Keep compatibility behavior focused and testable, one tool at a time
+
+---
+
+*Not affiliated with Cursor or Anysphere Inc. Cursor is a trademark of Anysphere Inc.*

package/dist/src/cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+const DEFAULT_TOOLS = "ls";
+const TOOL_BLACKLIST = new Set(["edit", "write", "grep", "read", "glob", "bash"]);
+function hasFlag(args, names) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (names.includes(arg))
+            return true;
+        for (const name of names) {
+            if (arg.startsWith(`${name}=`))
+                return true;
+        }
+    }
+    return false;
+}
+function sanitizeToolList(rawValue) {
+    const tools = rawValue
+        .split(",")
+        .map((tool) => tool.trim())
+        .filter(Boolean)
+        .filter((tool) => !TOOL_BLACKLIST.has(tool));
+    if (tools.length === 0) {
+        return DEFAULT_TOOLS;
+    }
+    return Array.from(new Set(tools)).join(",");
+}
+function sanitizeToolsArgs(args) {
+    const sanitized = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--tools") {
+            const raw = args[i + 1] ?? "";
+            sanitized.push("--tools", sanitizeToolList(raw));
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--tools=")) {
+            const raw = arg.slice("--tools=".length);
+            sanitized.push(`--tools=${sanitizeToolList(raw)}`);
+            continue;
+        }
+        sanitized.push(arg);
+    }
+    return sanitized;
+}
+function buildPiArgs(userArgs) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const extensionPath = resolve(here, "extensions", "mono-pilot.js");
+    const sanitizedUserArgs = sanitizeToolsArgs(userArgs);
+    const args = ["--no-extensions", "--extension", extensionPath];
+    if (!hasFlag(sanitizedUserArgs, ["--tools", "--no-tools"])) {
+        args.push("--tools", DEFAULT_TOOLS);
+    }
+    return [...args, ...sanitizedUserArgs];
+}
+function resolvePiCliPath() {
+    const codingAgentEntryUrl = import.meta.resolve("@mariozechner/pi-coding-agent");
+    const codingAgentEntryPath = fileURLToPath(codingAgentEntryUrl);
+    return resolve(dirname(codingAgentEntryPath), "cli.js");
+}
+function main() {
+    const userArgs = process.argv.slice(2);
+    const piArgs = buildPiArgs(userArgs);
+    const piCliPath = resolvePiCliPath();
+    const child = spawn(process.execPath, [piCliPath, ...piArgs], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    child.on("exit", (code, signal) => {
+        if (signal) {
+            process.kill(process.pid, signal);
+            return;
+        }
+        process.exit(code ?? 1);
+    });
+    child.on("error", (error) => {
+        console.error(`[mono-pilot] Failed to launch pi: ${error.message}`);
+        process.exit(1);
+    });
+}
+main();

package/dist/src/extensions/mono-pilot.js

@@ -0,0 +1,19 @@
+import shellExtension from "../../tools/shell.js";
+import globExtension from "../../tools/glob.js";
+import rgExtension from "../../tools/rg.js";
+import readFileExtension from "../../tools/read-file.js";
+import deleteExtension from "../../tools/delete.js";
+import applyPatchExtension from "../../tools/apply-patch.js";
+const toolExtensions = [
+    shellExtension,
+    globExtension,
+    rgExtension,
+    readFileExtension,
+    deleteExtension,
+    applyPatchExtension,
+];
+export default function monoPilotExtension(pi) {
+    for (const register of toolExtensions) {
+        register(pi);
+    }
+}

package/dist/tools/README.md

@@ -0,0 +1,31 @@
+# Tools
+
+This directory stores the tool layer for `mono-pilot`.
+
+## Structure
+
+Each tool is split into two files:
+
+- `*.ts`: tool implementation (registration, validation, execution)
+- `*.md`: tool spec text injected into the runtime prompt
+
+## Current tools
+
+- `apply-patch.ts` / `apply-patch.md` (`apply_patch`)
+  - Apply single-file patches in `*** Begin Patch` format.
+- `read-file.ts` / `read-file.md` (`read`)
+  - Read file content with truncation and pagination behavior.
+- `rg.ts` / `rg.md` (`rg`)
+  - Search file content with ripgrep.
+- `glob.ts` / `glob.md` (`Glob`)
+  - Find paths by glob pattern.
+- `shell.ts` / `shell.md` (`shell`)
+  - Execute shell commands in the workspace.
+- `delete.ts` / `delete.md` (`Delete`)
+  - Delete files or directories.
+
+## Maintenance rules
+
+- Keep each `*.ts` and `*.md` pair aligned.
+- When adding/removing tools, update this file in the same commit.
+- Keep wording concrete and implementation-focused.

package/dist/tools/apply-patch.js

@@ -0,0 +1,337 @@
+/**
+ * Apply Patch Tool Example
+ *
+ * Adds an `apply_patch` custom tool that applies a single-file patch document
+ * in the familiar "*** Begin Patch" format.
+ *
+ * This is intentionally low-intrusion:
+ * - it does NOT modify built-in tools
+ * - it delegates actual file mutations to built-in `write` and `edit` tools
+ */
+import { mkdir, readFile, rename } from "node:fs/promises";
+import { dirname, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createEditTool, createWriteTool } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+const BEGIN_PATCH = "*** Begin Patch";
+const END_PATCH = "*** End Patch";
+const ADD_FILE = "*** Add File: ";
+const UPDATE_FILE = "*** Update File: ";
+const MOVE_TO = "*** Move to: ";
+const END_OF_FILE = "*** End of File";
+const APPLY_PATCH_PROMPT_MARKER = "## ApplyPatch";
+const APPLY_PATCH_DOC_PATH = fileURLToPath(new URL("./apply-patch.md", import.meta.url));
+const MAX_RENDER_CALL_LINES = 24;
+const MAX_RENDER_CALL_LINE_CHARS = 180;
+const applyPatchSchema = Type.Object({
+    patch: Type.String({
+        description: "Single-file patch document in ApplyPatch format. Must start with *** Begin Patch and end with *** End Patch.",
+    }),
+});
+function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function buildPatchPreview(patch) {
+    const normalized = normalizeLineEndings(patch).trimEnd();
+    if (!normalized)
+        return "(empty patch)";
+    const lines = normalized.split("\n");
+    const previewLines = lines.slice(0, MAX_RENDER_CALL_LINES).map((line) => {
+        if (line.length <= MAX_RENDER_CALL_LINE_CHARS)
+            return line;
+        return `${line.slice(0, MAX_RENDER_CALL_LINE_CHARS - 1)}…`;
+    });
+    if (lines.length > MAX_RENDER_CALL_LINES) {
+        previewLines.push(`... (${lines.length - MAX_RENDER_CALL_LINES} more line(s))`);
+    }
+    return previewLines.join("\n");
+}
+function normalizeAddFileLines(lines) {
+    const nonEmpty = lines.filter((line) => line.length > 0);
+    if (nonEmpty.length === 0)
+        return lines;
+    // Some models emit "+ " as a visual separator in Add File lines.
+    // If all non-empty lines share this one-space prefix, strip it once.
+    const allNonEmptyStartWithSpace = nonEmpty.every((line) => line.startsWith(" "));
+    if (!allNonEmptyStartWithSpace)
+        return lines;
+    return lines.map((line) => (line.startsWith(" ") ? line.slice(1) : line));
+}
+function normalizePatchPath(rawPath) {
+    const trimmed = rawPath.trim();
+    const withoutAt = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+    if (!withoutAt) {
+        throw new Error("Patch file path cannot be empty");
+    }
+    if (!isAbsolute(withoutAt)) {
+        throw new Error(`Patch path must be absolute: ${rawPath}`);
+    }
+    return withoutAt;
+}
+function isFileHeader(line) {
+    return line.startsWith(ADD_FILE) || line.startsWith(UPDATE_FILE);
+}
+function parseAddFile(lines, startIndex) {
+    const header = lines[startIndex];
+    const rawPath = header.slice(ADD_FILE.length);
+    const path = normalizePatchPath(rawPath);
+    const addLines = [];
+    let i = startIndex + 1;
+    while (i < lines.length && lines[i] !== END_PATCH) {
+        const line = lines[i];
+        if (!line.startsWith("+")) {
+            throw new Error(`Add File only allows '+' lines, got: ${line}`);
+        }
+        addLines.push(line.slice(1));
+        i++;
+    }
+    if (addLines.length === 0) {
+        throw new Error("Add File operation requires at least one '+' content line");
+    }
+    const normalizedLines = normalizeAddFileLines(addLines);
+    return {
+        operation: { kind: "add", path, lines: normalizedLines },
+        nextIndex: i,
+    };
+}
+function parseUpdateFile(lines, startIndex) {
+    const header = lines[startIndex];
+    const rawPath = header.slice(UPDATE_FILE.length);
+    const path = normalizePatchPath(rawPath);
+    let moveTo;
+    let i = startIndex + 1;
+    if (i < lines.length && lines[i].startsWith(MOVE_TO)) {
+        moveTo = normalizePatchPath(lines[i].slice(MOVE_TO.length));
+        i++;
+    }
+    const hunks = [];
+    let currentHeaders;
+    let currentLines = [];
+    const flushCurrentHunk = () => {
+        if (!currentHeaders)
+            return;
+        hunks.push({
+            headers: currentHeaders,
+            lines: currentLines,
+        });
+        currentHeaders = undefined;
+        currentLines = [];
+    };
+    while (i < lines.length && lines[i] !== END_PATCH) {
+        const line = lines[i];
+        if (line === END_OF_FILE) {
+            i++;
+            break;
+        }
+        if (line.startsWith("@@")) {
+            if (!currentHeaders) {
+                currentHeaders = [line];
+            }
+            else if (currentLines.length === 0) {
+                // Support multiple consecutive @@ headers to narrow context.
+                currentHeaders.push(line);
+            }
+            else {
+                flushCurrentHunk();
+                currentHeaders = [line];
+            }
+            i++;
+            continue;
+        }
+        const marker = line[0];
+        if (marker === " " || marker === "+" || marker === "-") {
+            if (!currentHeaders) {
+                throw new Error(`Update File change line encountered before hunk header @@: ${line}`);
+            }
+            currentLines.push(line);
+            i++;
+            continue;
+        }
+        if (isFileHeader(line)) {
+            throw new Error("Patch must contain exactly one file operation");
+        }
+        throw new Error(`Invalid update patch line: ${line}`);
+    }
+    flushCurrentHunk();
+    return {
+        operation: { kind: "update", path, moveTo, hunks },
+        nextIndex: i,
+    };
+}
+function parsePatchDocument(patchText) {
+    const normalized = normalizeLineEndings(patchText);
+    const lines = normalized.split("\n");
+    if (lines.length === 0 || lines[0] !== BEGIN_PATCH) {
+        throw new Error(`Patch must start with "${BEGIN_PATCH}"`);
+    }
+    let index = 1;
+    if (index >= lines.length) {
+        throw new Error("Patch is incomplete");
+    }
+    const opHeader = lines[index] ?? "";
+    if (!isFileHeader(opHeader)) {
+        throw new Error(`Expected "${ADD_FILE}" or "${UPDATE_FILE}", got: ${opHeader}`);
+    }
+    const parsed = opHeader.startsWith(ADD_FILE) ? parseAddFile(lines, index) : parseUpdateFile(lines, index);
+    index = parsed.nextIndex;
+    if (index >= lines.length || lines[index] !== END_PATCH) {
+        throw new Error(`Patch must end with "${END_PATCH}"`);
+    }
+    for (let i = index + 1; i < lines.length; i++) {
+        if (lines[i] !== "") {
+            throw new Error(`Unexpected trailing content after "${END_PATCH}"`);
+        }
+    }
+    return { operation: parsed.operation };
+}
+function buildReplacementTexts(hunk) {
+    const oldLines = [];
+    const newLines = [];
+    for (const line of hunk.lines) {
+        const marker = line[0];
+        const text = line.slice(1);
+        if (marker === " " || marker === "-")
+            oldLines.push(text);
+        if (marker === " " || marker === "+")
+            newLines.push(text);
+    }
+    return {
+        oldText: oldLines.join("\n"),
+        newText: newLines.join("\n"),
+    };
+}
+function hunkHasChanges(hunk) {
+    return hunk.lines.some((line) => {
+        const marker = line[0];
+        return marker === "+" || marker === "-";
+    });
+}
+function parseFirstChangedLine(details) {
+    if (typeof details !== "object" || details === null)
+        return undefined;
+    const record = details;
+    const value = record.firstChangedLine;
+    return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+}
+export default function (pi) {
+    let applyPatchSpecCache;
+    const getApplyPatchSpec = async () => {
+        if (applyPatchSpecCache !== undefined) {
+            return applyPatchSpecCache ?? undefined;
+        }
+        try {
+            const doc = await readFile(APPLY_PATCH_DOC_PATH, "utf-8");
+            applyPatchSpecCache = doc.trim();
+            return applyPatchSpecCache;
+        }
+        catch {
+            // Best effort. The tool still works without prompt injection.
+            applyPatchSpecCache = null;
+            return undefined;
+        }
+    };
+    pi.on("before_agent_start", async (event) => {
+        if (event.systemPrompt.includes(APPLY_PATCH_PROMPT_MARKER)) {
+            return;
+        }
+        const spec = await getApplyPatchSpec();
+        if (!spec)
+            return;
+        return {
+            systemPrompt: `${event.systemPrompt}\n\n${APPLY_PATCH_PROMPT_MARKER}\n\n${spec}`,
+        };
+    });
+    pi.registerTool({
+        name: "apply_patch",
+        label: "Apply Patch",
+        description: "Apply a single-file patch in *** Begin Patch format. Supports *** Add File and *** Update File operations.",
+        parameters: applyPatchSchema,
+        renderCall(args, theme) {
+            const patch = typeof args.patch === "string" ? args.patch : "";
+            const preview = buildPatchPreview(patch);
+            let text = theme.fg("toolTitle", theme.bold("apply_patch"));
+            text += ` ${theme.fg("muted", "(patch input)")}`;
+            text += `\n${theme.fg("toolOutput", preview)}`;
+            return new Text(text, 0, 0);
+        },
+        async execute(toolCallId, params, signal, _onUpdate, ctx) {
+            const parsed = parsePatchDocument(params.patch);
+            const writeTool = createWriteTool(ctx.cwd);
+            const editTool = createEditTool(ctx.cwd);
+            if (parsed.operation.kind === "add") {
+                const content = parsed.operation.lines.join("\n");
+                await writeTool.execute(`${toolCallId}:add`, {
+                    path: parsed.operation.path,
+                    content,
+                }, signal);
+                const details = {
+                    operation: "add",
+                    path: parsed.operation.path,
+                    bytesWritten: Buffer.byteLength(content, "utf-8"),
+                };
+                return {
+                    content: [{ type: "text", text: `Applied patch: added ${parsed.operation.path}` }],
+                    details,
+                };
+            }
+            const firstChangedLines = [];
+            let appliedHunks = 0;
+            let noopHunks = 0;
+            for (let i = 0; i < parsed.operation.hunks.length; i++) {
+                const hunk = parsed.operation.hunks[i];
+                if (!hunkHasChanges(hunk)) {
+                    noopHunks++;
+                    continue;
+                }
+                const replacement = buildReplacementTexts(hunk);
+                if (replacement.oldText === replacement.newText) {
+                    noopHunks++;
+                    continue;
+                }
+                const result = await editTool.execute(`${toolCallId}:hunk:${i + 1}`, {
+                    path: parsed.operation.path,
+                    oldText: replacement.oldText,
+                    newText: replacement.newText,
+                }, signal);
+                appliedHunks++;
+                const firstChangedLine = parseFirstChangedLine(result.details);
+                if (firstChangedLine !== undefined) {
+                    firstChangedLines.push(firstChangedLine);
+                }
+            }
+            let movedTo;
+            if (parsed.operation.moveTo && parsed.operation.moveTo !== parsed.operation.path) {
+                await mkdir(dirname(parsed.operation.moveTo), { recursive: true });
+                await rename(parsed.operation.path, parsed.operation.moveTo);
+                movedTo = parsed.operation.moveTo;
+            }
+            const details = {
+                operation: "update",
+                path: parsed.operation.path,
+                moveTo: movedTo,
+                hunkCount: parsed.operation.hunks.length,
+                appliedHunks,
+                noopHunks,
+                firstChangedLines,
+            };
+            const suffix = [];
+            if (noopHunks > 0) {
+                suffix.push(`skipped ${noopHunks} no-op hunk(s)`);
+            }
+            if (movedTo) {
+                suffix.push(`moved to ${movedTo}`);
+            }
+            const suffixText = suffix.length > 0 ? ` (${suffix.join(", ")})` : "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Applied patch: updated ${parsed.operation.path} with ${appliedHunks} hunk(s)${suffixText}.`,
+                    },
+                ],
+                details,
+            };
+        },
+    });
+}

package/dist/tools/apply-patch.md

@@ -0,0 +1,93 @@
+// Use this tool to edit files.
+// Your patch language is a stripped-down, file-oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high-level envelope:
+//
+// *** Begin Patch
+// [ one file section ]
+// *** End Patch
+//
+// Within that envelope, you get one file operation.
+// You MUST include a header to specify the action you are taking.
+// Each operation starts with one of two headers:
+//
+// *** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+// *** Update File: <path> - patch an existing file in place (optionally with a rename).
+//
+// Then one or more "hunks", each introduced by @@ (optionally followed by a hunk header).
+// Within a hunk each line starts with:
+//
+// For instructions on [context_before] and [context_after]:
+// - By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change's [context_after] lines in the second change's [context_before] lines.
+// - If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:
+// @@ class BaseClass
+// [3 lines of pre-context]
+// - [old_code]
+// + [new_code]
+// [3 lines of post-context]
+//
+// - If a code block is repeated so many times in a class or function such that even a single `@@` statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple `@@` statements to jump to the right context. For instance:
+//
+// @@ class BaseClass
+// @@ 	def method():
+// [3 lines of pre-context]
+// - [old_code]
+// + [new_code]
+// [3 lines of post-context]
+//
+// The full grammar definition is below:
+// Patch := Begin { FileOp } End
+// Begin := "*** Begin Patch" NEWLINE
+// End := "*** End Patch" NEWLINE
+// FileOp := AddFile | UpdateFile
+// AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }
+// UpdateFile := "*** Update File: " path NEWLINE { Hunk }
+// Hunk := "@@" [ header ] NEWLINE { HunkLine } [ "*** End of File" NEWLINE ]
+// HunkLine := (" " | "-" | "+") text NEWLINE
+//
+// Example for Update File:
+// *** Begin Patch
+// *** Update File: pygorithm/searching/binary_search.py
+// @@ class BaseClass
+// @@     def search():
+// -          pass
+// +          raise NotImplementedError()
+//
+// @@ class Subclass
+// @@     def search():
+// -          pass
+// +          raise NotImplementedError()
+// *** End Patch
+//
+// Example for Add File:
+// *** Begin Patch
+// *** Add File: [path/to/file]
+// + [new_code]
+// *** End Patch
+//
+// It is important to remember:
+// - You must only include one file per call
+// - You must include a header with your intended action (Add/Update)
+// - You must prefix new lines with ` +` even when creating a new file
+//
+// All file paths must be absolute paths. Make sure to read the file before applying a patch to get the latest file content, unless you are creating a new file.
+//
+// IMPORTANT: This tool only accepts string inputs that obey the lark grammar start: begin_patch hunk end_patch
+// begin_patch: "*** Begin Patch" LF
+// end_patch: "*** End Patch" LF?
+//
+// hunk: add_hunk | update_hunk
+// add_hunk: "*** Add File: " filename LF add_line+
+// update_hunk: "*** Update File: " filename LF change?
+//
+// filename: /(.+)/
+// add_line: "+" /(.*)/ LF -> line
+//
+// change: (change_context | change_line)+ eof_line?
+//
+// change_context: ("@@" | "@@ " /(.+)/) LF
+// change_line: ("+" | "-" | " ") /(.*)/ LF
+// eof_line: "*** End of File" LF
+//
+// %import common.LF
+// . You must reason carefully about the input and make sure it obeys the grammar.
+// IMPORTANT: Do NOT call this tool in parallel with other tools.
+type ApplyPatch = (FREEFORM) => any;