mono-pilot 0.2.10 → 0.2.13

package/dist/{tools → src/tools}/apply-patch.js

@@ -13,7 +13,7 @@ const MOVE_TO = "*** Move to: ";
 const END_OF_FILE = "*** End of File";
 const MAX_RENDER_SUMMARY_PATH_CHARS = 96;
 const MAX_RENDER_FIRST_CHANGED_LINES = 12;
-const DESCRIPTION = readFileSync(fileURLToPath(new URL("./shell-description.md", import.meta.url)), "utf-8").trim();
+const DESCRIPTION = readFileSync(fileURLToPath(new URL("./apply-patch-description.md", import.meta.url)), "utf-8").trim();
 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.",
@@ -98,6 +98,13 @@ function buildRenderDetailLines(details) {
         lines.push("patch:");
         lines.push(details.patchText.length > 0 ? details.patchText : "(empty patch)");
     }
+    if (details.sftp) {
+        const targets = details.sftp.targets.length > 0 ? details.sftp.targets.join(", ") : "(none)";
+        lines.push(`sftp uploaded: ${details.sftp.uploaded} to ${targets}`);
+        if (details.sftp.errors && details.sftp.errors.length > 0) {
+            lines.push(`sftp errors: ${details.sftp.errors.join("; ")}`);
+        }
+    }
     return lines;
 }
 function normalizeAddFileLines(lines) {
@@ -161,15 +168,18 @@ function parseUpdateFile(lines, startIndex) {
     const hunks = [];
     let currentHeaders;
     let currentLines = [];
+    let currentLineHint;
     const flushCurrentHunk = () => {
         if (!currentHeaders)
             return;
         hunks.push({
             headers: currentHeaders,
             lines: currentLines,
+            lineHint: currentLineHint,
         });
         currentHeaders = undefined;
         currentLines = [];
+        currentLineHint = undefined;
     };
     while (i < lines.length && lines[i] !== END_PATCH) {
         const line = lines[i];
@@ -178,16 +188,19 @@ function parseUpdateFile(lines, startIndex) {
             break;
         }
         if (line.startsWith("@@")) {
+            const { headerText, lineHint } = parseHunkHeaderLine(line);
             if (!currentHeaders) {
-                currentHeaders = [line];
-            }
-            else if (currentLines.length === 0) {
-                // Support multiple consecutive @@ headers to narrow context.
-                currentHeaders.push(line);
+                currentHeaders = [];
             }
-            else {
+            else if (currentLines.length > 0) {
                 flushCurrentHunk();
-                currentHeaders = [line];
+                currentHeaders = [];
+            }
+            if (headerText) {
+                currentHeaders.push(headerText);
+            }
+            if (lineHint && !currentLineHint) {
+                currentLineHint = lineHint;
             }
             i++;
             continue;
@@ -274,6 +287,52 @@ function parseFirstChangedLine(details) {
     const value = record.firstChangedLine;
     return typeof value === "number" && Number.isInteger(value) ? value : undefined;
 }
+function toZeroBasedLine(line) {
+    return Math.max(0, line - 1);
+}
+function parseDiffHeader(header) {
+    const match = header.match(/^-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@(?:\s+(.*))?$/);
+    if (!match)
+        return null;
+    const oldStart = Number(match[1]);
+    const oldCount = match[2] ? Number(match[2]) : undefined;
+    const contextText = match[5]?.trim();
+    if (!Number.isInteger(oldStart) || oldStart <= 0) {
+        return {
+            headerText: contextText || undefined,
+        };
+    }
+    const startLine = toZeroBasedLine(oldStart);
+    const endLine = oldCount && oldCount > 0 ? startLine + oldCount - 1 : undefined;
+    return {
+        lineHint: { startLine, endLine },
+        headerText: contextText || undefined,
+    };
+}
+function parseLineDirective(header) {
+    const match = header.match(/^line\s*(?::|=)?\s*(\d+)(?:\s*(?:-|\.\.)\s*(\d+))?$/i);
+    if (!match)
+        return null;
+    const start = Number(match[1]);
+    if (!Number.isInteger(start) || start <= 0)
+        return null;
+    const end = match[2] ? Number(match[2]) : undefined;
+    const startLine = toZeroBasedLine(start);
+    const endLine = end && end >= start ? toZeroBasedLine(end) : undefined;
+    return { lineHint: { startLine, endLine } };
+}
+function parseHunkHeaderLine(line) {
+    const header = line.replace(/^@@/, "").trim();
+    if (!header)
+        return {};
+    const diffParsed = parseDiffHeader(header);
+    if (diffParsed)
+        return diffParsed;
+    const lineParsed = parseLineDirective(header);
+    if (lineParsed)
+        return lineParsed;
+    return { headerText: header };
+}
 function normalizeHeaderText(header) {
     const trimmed = header.replace(/^@@/, "").trim();
     return trimmed.length > 0 ? trimmed : undefined;
@@ -360,6 +419,106 @@ export function alignReplacement(fileContent, oldText, newText, options) {
     }
     return null;
 }
+export async function applyPatchToFilesystem(options) {
+    const toolCallId = options.toolCallId ?? "apply-patch";
+    const parsed = parsePatchDocument(options.patchText);
+    const patchLineCount = getNormalizedPatchLines(options.patchText).length;
+    const normalizedPatchText = normalizeLineEndings(options.patchText);
+    const writeTool = createWriteTool(options.cwd);
+    const editTool = createEditTool(options.cwd);
+    if (parsed.operation.kind === "add") {
+        const content = parsed.operation.lines.join("\n");
+        await writeTool.execute(`${toolCallId}:add`, {
+            path: parsed.operation.path,
+            content,
+        }, options.signal);
+        const details = {
+            operation: "add",
+            path: parsed.operation.path,
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            patchLineCount,
+            patchText: normalizedPatchText,
+        };
+        return {
+            summary: `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;
+        }
+        let { oldText, newText } = buildReplacementTexts(hunk);
+        if (oldText === newText) {
+            noopHunks++;
+            continue;
+        }
+        const absolutePath = isAbsolute(parsed.operation.path)
+            ? parsed.operation.path
+            : resolve(options.cwd, parsed.operation.path);
+        if (existsSync(absolutePath)) {
+            try {
+                const fileContent = readFileSync(absolutePath, "utf-8");
+                const headerStart = findHeaderSearchStart(fileContent, hunk.headers);
+                const startLine = hunk.lineHint?.startLine ?? headerStart;
+                const endLine = hunk.lineHint?.endLine;
+                const alignOptions = startLine !== undefined || endLine !== undefined ? { startLine, endLine } : undefined;
+                const aligned = alignReplacement(fileContent, oldText, newText, alignOptions);
+                if (aligned) {
+                    oldText = aligned.oldText;
+                    newText = aligned.newText;
+                }
+            }
+            catch {
+                // Ignore read errors, let editTool handle it
+            }
+        }
+        const result = await editTool.execute(`${toolCallId}:hunk:${i + 1}`, {
+            path: parsed.operation.path,
+            oldText,
+            newText,
+        }, options.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,
+        patchLineCount,
+        patchText: normalizedPatchText,
+    };
+    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 {
+        summary: `Applied patch: updated ${parsed.operation.path} with ${appliedHunks} hunk(s)${suffixText}.`,
+        details,
+    };
+}
 export default function (pi) {
     // System prompt injection is handled centrally by system-prompt extension.
     pi.registerTool({
@@ -391,103 +550,14 @@ export default function (pi) {
             return new Text(text, 0, 0);
         },
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
-            const parsed = parsePatchDocument(params.patch);
-            const patchLineCount = getNormalizedPatchLines(params.patch).length;
-            const patchText = normalizeLineEndings(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"),
-                    patchLineCount,
-                    patchText,
-                };
-                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;
-                }
-                let { oldText, newText } = buildReplacementTexts(hunk);
-                if (oldText === newText) {
-                    noopHunks++;
-                    continue;
-                }
-                const absolutePath = isAbsolute(parsed.operation.path)
-                    ? parsed.operation.path
-                    : resolve(ctx.cwd, parsed.operation.path);
-                if (existsSync(absolutePath)) {
-                    try {
-                        const fileContent = readFileSync(absolutePath, "utf-8");
-                        const headerStart = findHeaderSearchStart(fileContent, hunk.headers);
-                        const aligned = alignReplacement(fileContent, oldText, newText, headerStart !== undefined ? { startLine: headerStart } : undefined);
-                        if (aligned) {
-                            oldText = aligned.oldText;
-                            newText = aligned.newText;
-                        }
-                    }
-                    catch {
-                        // Ignore read errors, let editTool handle it
-                    }
-                }
-                const result = await editTool.execute(`${toolCallId}:hunk:${i + 1}`, {
-                    path: parsed.operation.path,
-                    oldText,
-                    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,
-                patchLineCount,
-                patchText,
-            };
-            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(", ")})` : "";
+            const { summary, details } = await applyPatchToFilesystem({
+                patchText: params.patch,
+                cwd: ctx.cwd,
+                toolCallId,
+                signal,
+            });
             return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Applied patch: updated ${parsed.operation.path} with ${appliedHunks} hunk(s)${suffixText}.`,
-                    },
-                ],
+                content: [{ type: "text", text: summary }],
                 details,
             };
         },

package/dist/{tools → src/tools}/apply-patch.test.js

@@ -1,5 +1,14 @@
 import { describe, it, expect } from "vitest";
-import { alignReplacement } from "./apply-patch.js";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { alignReplacement, applyPatchToFilesystem } from "./apply-patch.js";
+const fixtureRoot = fileURLToPath(new URL("./apply-patch-fixtures", import.meta.url));
+const fixtureOriginal = resolve(fixtureRoot, "original.md");
+const fixturePatches = resolve(fixtureRoot, "patches");
+const fixtureExpected = resolve(fixtureRoot, "expected");
+const PATCH_TARGET = "{{FILE}}";
 describe("ApplyPatch Robustness - alignReplacement", () => {
     it("should align 2-space indentation to tabs", () => {
         const fileContent = "function test() {\n\t\tfoo();\n\t\tbar();\n}";
@@ -87,3 +96,45 @@ describe("ApplyPatch Robustness - alignReplacement", () => {
         expect(result?.newText).toBe("  bar();");
     });
 });
+describe("ApplyPatch fixtures", () => {
+    const cases = [
+        {
+            name: "context-only",
+            patch: "00-context-only.patch",
+            expected: "00-context-only.md",
+        },
+        {
+            name: "line-hint",
+            patch: "01-line-hint.patch",
+            expected: "01-line-hint.md",
+        },
+        {
+            name: "line-range",
+            patch: "02-line-range.patch",
+            expected: "02-line-range.md",
+        },
+        {
+            name: "diff-header",
+            patch: "03-diff-header.patch",
+            expected: "03-diff-header.md",
+        },
+    ];
+    for (const entry of cases) {
+        it(`applies fixture patch: ${entry.name}`, async () => {
+            const tempDir = await mkdtemp(`${tmpdir()}/apply-patch-fixture-`);
+            const targetPath = resolve(tempDir, "target.md");
+            const original = await readFile(fixtureOriginal, "utf-8");
+            await writeFile(targetPath, original, "utf-8");
+            const patchTemplate = await readFile(resolve(fixturePatches, entry.patch), "utf-8");
+            const patchText = patchTemplate.replaceAll(PATCH_TARGET, targetPath);
+            await applyPatchToFilesystem({
+                patchText,
+                cwd: tempDir,
+                toolCallId: "fixture",
+            });
+            const expected = await readFile(resolve(fixtureExpected, entry.expected), "utf-8");
+            const actual = await readFile(targetPath, "utf-8");
+            expect(actual).toBe(expected);
+        });
+    }
+});

package/dist/{tools/ask-question.js → src/tools/ask-user-question.js}

@@ -212,11 +212,11 @@ function buildSuccessText(answers, questions) {
     }
     return lines.join("\n");
 }
-export default function askQuestionExtension(pi) {
+export default function askUserQuestionExtension(pi) {
     // System prompt injection is handled centrally by system-prompt extension.
     pi.registerTool({
-        name: "AskQuestion",
-        label: "AskQuestion",
+        name: "AskUserQuestion",
+        label: "AskUserQuestion",
         description: DESCRIPTION,
         parameters: askQuestionSchema,
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {