@aria-cli/tools 1.0.0

package/tests/definitions/apply-patch.test.ts

@@ -0,0 +1,586 @@
+/**
+ * @aria/tools - apply_patch unit tests
+ *
+ * Tests for the patch parser, fuzzy matching, and sandbox path validation.
+ * These are the core subsystems of the extended apply_patch tool.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  parsePatchText,
+  normalizeUnicodeSpaces,
+  checkPatchBoundariesLenient,
+  parseOneHunk,
+  BEGIN_PATCH_MARKER,
+  END_PATCH_MARKER,
+} from "../../src/definitions/patch/patch-parser.js";
+import { applyUpdateHunk } from "../../src/definitions/patch/fuzzy-match.js";
+import {
+  resolveSandboxPath,
+  assertSandboxPath,
+} from "../../src/definitions/patch/sandbox-paths.js";
+
+// ── Patch Parser ──────────────────────────────────────────────────────
+
+describe("apply_patch", () => {
+  describe("patch-parser", () => {
+    it("parses Add File hunk", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Add File: src/hello.ts",
+        '+export const hello = "world";',
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      expect(hunks[0]!.kind).toBe("add");
+      if (hunks[0]!.kind === "add") {
+        expect(hunks[0]!.path).toBe("src/hello.ts");
+        expect(hunks[0]!.contents).toBe('export const hello = "world";\n');
+      }
+    });
+
+    it("parses Add File with multiple lines", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Add File: README.md",
+        "+# Title",
+        "+",
+        "+Some content",
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      if (hunks[0]!.kind === "add") {
+        expect(hunks[0]!.contents).toBe("# Title\n\nSome content\n");
+      }
+    });
+
+    it("parses Delete File hunk", () => {
+      const input = ["*** Begin Patch", "*** Delete File: old/deprecated.ts", "*** End Patch"].join(
+        "\n",
+      );
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      expect(hunks[0]!.kind).toBe("delete");
+      if (hunks[0]!.kind === "delete") {
+        expect(hunks[0]!.path).toBe("old/deprecated.ts");
+      }
+    });
+
+    it("parses Update File hunk with @@ chunks", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Update File: src/main.ts",
+        "@@ export function main() {",
+        '-  console.log("old");',
+        '+  console.log("new");',
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      expect(hunks[0]!.kind).toBe("update");
+      if (hunks[0]!.kind === "update") {
+        expect(hunks[0]!.path).toBe("src/main.ts");
+        expect(hunks[0]!.chunks).toHaveLength(1);
+        expect(hunks[0]!.chunks[0]!.changeContext).toBe("export function main() {");
+        expect(hunks[0]!.chunks[0]!.oldLines).toEqual(['  console.log("old");']);
+        expect(hunks[0]!.chunks[0]!.newLines).toEqual(['  console.log("new");']);
+      }
+    });
+
+    it("parses Update File with context lines (space prefix)", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Update File: src/config.ts",
+        "@@ const config = {",
+        "   debug: false,",
+        "-  port: 3000,",
+        "+  port: 8080,",
+        '   host: "localhost",',
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      if (hunks[0]!.kind === "update") {
+        const chunk = hunks[0]!.chunks[0]!;
+        // Context lines appear in both old and new
+        expect(chunk.oldLines).toEqual([
+          "  debug: false,",
+          "  port: 3000,",
+          '  host: "localhost",',
+        ]);
+        expect(chunk.newLines).toEqual([
+          "  debug: false,",
+          "  port: 8080,",
+          '  host: "localhost",',
+        ]);
+      }
+    });
+
+    it("handles *** Move to: rename", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Update File: old-name.ts",
+        "*** Move to: new-name.ts",
+        "@@ ",
+        "-const OLD = true;",
+        "+const NEW = true;",
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      if (hunks[0]!.kind === "update") {
+        expect(hunks[0]!.path).toBe("old-name.ts");
+        expect(hunks[0]!.movePath).toBe("new-name.ts");
+      }
+    });
+
+    it("validates *** Begin Patch / *** End Patch boundaries", () => {
+      // Missing Begin Patch
+      expect(() => parsePatchText(["*** Delete File: foo.ts", "*** End Patch"].join("\n"))).toThrow(
+        "*** Begin Patch",
+      );
+
+      // Missing End Patch
+      expect(() =>
+        parsePatchText(["*** Begin Patch", "*** Delete File: foo.ts"].join("\n")),
+      ).toThrow("*** End Patch");
+
+      // Valid boundaries should not throw
+      expect(() =>
+        parsePatchText(["*** Begin Patch", "*** Delete File: foo.ts", "*** End Patch"].join("\n")),
+      ).not.toThrow();
+    });
+
+    it("rejects empty input", () => {
+      expect(() => parsePatchText("")).toThrow("input is empty");
+      expect(() => parsePatchText("   ")).toThrow("input is empty");
+    });
+
+    it("handles <<EOF heredoc wrapper", () => {
+      const input = [
+        "<<EOF",
+        "*** Begin Patch",
+        "*** Delete File: tmp.ts",
+        "*** End Patch",
+        "EOF",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      expect(hunks[0]!.kind).toBe("delete");
+    });
+
+    it("handles <<'EOF' (single-quoted) heredoc wrapper", () => {
+      const input = [
+        "<<'EOF'",
+        "*** Begin Patch",
+        "*** Delete File: tmp.ts",
+        "*** End Patch",
+        "EOF",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+    });
+
+    it('handles <<"EOF" (double-quoted) heredoc wrapper', () => {
+      const input = [
+        '<<"EOF"',
+        "*** Begin Patch",
+        "*** Delete File: tmp.ts",
+        "*** End Patch",
+        "EOF",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+    });
+
+    it("normalizes Unicode spaces in paths", () => {
+      // \u00A0 = non-breaking space
+      const result = normalizeUnicodeSpaces("src/my\u00A0file.ts");
+      expect(result).toBe("src/my file.ts");
+
+      // \u2003 = em space
+      const result2 = normalizeUnicodeSpaces("src/my\u2003file.ts");
+      expect(result2).toBe("src/my file.ts");
+    });
+
+    it("parses multiple hunks in one patch", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Add File: a.ts",
+        "+a",
+        "*** Delete File: b.ts",
+        "*** Add File: c.ts",
+        "+c",
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(3);
+      expect(hunks[0]!.kind).toBe("add");
+      expect(hunks[1]!.kind).toBe("delete");
+      expect(hunks[2]!.kind).toBe("add");
+    });
+
+    it("handles empty @@ context marker", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Update File: src/main.ts",
+        "@@",
+        "-old",
+        "+new",
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      expect(hunks).toHaveLength(1);
+      if (hunks[0]!.kind === "update") {
+        expect(hunks[0]!.chunks[0]!.changeContext).toBeUndefined();
+      }
+    });
+
+    it("handles *** End of File marker", () => {
+      const input = [
+        "*** Begin Patch",
+        "*** Update File: src/main.ts",
+        "@@",
+        "-old line",
+        "+new line",
+        "*** End of File",
+        "*** End Patch",
+      ].join("\n");
+
+      const { hunks } = parsePatchText(input);
+      if (hunks[0]!.kind === "update") {
+        expect(hunks[0]!.chunks[0]!.isEndOfFile).toBe(true);
+      }
+    });
+
+    it("throws on invalid hunk header", () => {
+      const input = ["*** Begin Patch", "not a valid header", "*** End Patch"].join("\n");
+
+      expect(() => parsePatchText(input)).toThrow("not a valid hunk header");
+    });
+
+    it("throws on empty Update File hunk", () => {
+      const input = ["*** Begin Patch", "*** Update File: src/main.ts", "*** End Patch"].join("\n");
+
+      expect(() => parsePatchText(input)).toThrow("empty");
+    });
+  });
+
+  // ── Fuzzy Match ───────────────────────────────────────────────────────
+
+  describe("fuzzy-match", () => {
+    const mockReadFile = (content: string) => async (_path: string) => content;
+
+    it("matches exact lines (pass 1)", async () => {
+      const original = "line one\nline two\nline three\n";
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            oldLines: ["line two"],
+            newLines: ["line TWO replaced"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("line TWO replaced");
+      expect(result).not.toContain("line two");
+      expect(result).toContain("line one");
+      expect(result).toContain("line three");
+    });
+
+    it("matches trimmed trailing whitespace (pass 2)", async () => {
+      // Original has trailing spaces on "line two   "
+      const original = "line one\nline two   \nline three\n";
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            // Pattern has no trailing spaces
+            oldLines: ["line two"],
+            newLines: ["replaced"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("replaced");
+      expect(result).not.toContain("line two");
+    });
+
+    it("matches fully trimmed lines (pass 3)", async () => {
+      // Original has leading whitespace
+      const original = "  line one\n  line two\n  line three\n";
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            // Pattern without leading whitespace
+            oldLines: ["line two"],
+            newLines: ["replaced"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("replaced");
+    });
+
+    it("matches after Unicode punctuation normalization (pass 4)", async () => {
+      // \u201C and \u201D are "smart quotes"
+      const original = "const msg = \u201Chello world\u201D;\n";
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            oldLines: ['const msg = "hello world";'],
+            newLines: ['const msg = "goodbye world";'],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("goodbye world");
+    });
+
+    it("matches with Unicode dash normalization (pass 4)", async () => {
+      // \u2014 is em dash
+      const original = "value \u2014 default\n";
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            oldLines: ["value - default"],
+            newLines: ["value - override"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("override");
+    });
+
+    it("returns null when no match found", async () => {
+      const original = "line one\nline two\nline three\n";
+
+      await expect(
+        applyUpdateHunk(
+          "test.txt",
+          [
+            {
+              oldLines: ["completely nonexistent line"],
+              newLines: ["replaced"],
+              isEndOfFile: false,
+            },
+          ],
+          { readFile: mockReadFile(original) },
+        ),
+      ).rejects.toThrow("Failed to find expected lines");
+    });
+
+    it("applies hunks in reverse order to preserve line numbers", async () => {
+      const original = "line 1\nline 2\nline 3\nline 4\nline 5\n";
+
+      // Two replacements: one near start, one near end
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            oldLines: ["line 2"],
+            newLines: ["LINE TWO"],
+            isEndOfFile: false,
+          },
+          {
+            oldLines: ["line 4"],
+            newLines: ["LINE FOUR"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      const lines = result.split("\n");
+      expect(lines).toContain("LINE TWO");
+      expect(lines).toContain("LINE FOUR");
+      expect(lines).not.toContain("line 2");
+      expect(lines).not.toContain("line 4");
+    });
+
+    it("handles insertion with empty oldLines (append)", async () => {
+      const original = "existing content\n";
+
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            oldLines: [],
+            newLines: ["appended line"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("appended line");
+      expect(result).toContain("existing content");
+    });
+
+    it("handles changeContext to seek correct location", async () => {
+      const original = [
+        "function a() {",
+        "  return 1;",
+        "}",
+        "function b() {",
+        "  return 2;",
+        "}",
+        "",
+      ].join("\n");
+
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            changeContext: "function b() {",
+            oldLines: ["  return 2;"],
+            newLines: ["  return 42;"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result).toContain("return 42");
+      expect(result).toContain("return 1"); // function a untouched
+    });
+
+    it("ensures output ends with newline", async () => {
+      const original = "line one\nline two\n";
+
+      const result = await applyUpdateHunk(
+        "test.txt",
+        [
+          {
+            oldLines: ["line two"],
+            newLines: ["replaced"],
+            isEndOfFile: false,
+          },
+        ],
+        { readFile: mockReadFile(original) },
+      );
+
+      expect(result.endsWith("\n")).toBe(true);
+    });
+  });
+
+  // ── Sandbox Paths ─────────────────────────────────────────────────────
+
+  describe("sandbox-paths", () => {
+    it("rejects path traversal with ..", () => {
+      expect(() =>
+        resolveSandboxPath({
+          filePath: "../../../etc/passwd",
+          cwd: "/home/user/project",
+          root: "/home/user/project",
+        }),
+      ).toThrow("escapes sandbox root");
+    });
+
+    it("rejects absolute paths outside root", () => {
+      expect(() =>
+        resolveSandboxPath({
+          filePath: "/etc/passwd",
+          cwd: "/home/user/project",
+          root: "/home/user/project",
+        }),
+      ).toThrow("escapes sandbox root");
+    });
+
+    it("allows paths within cwd", () => {
+      const result = resolveSandboxPath({
+        filePath: "src/main.ts",
+        cwd: "/home/user/project",
+        root: "/home/user/project",
+      });
+
+      expect(result.resolved).toBe("/home/user/project/src/main.ts");
+      expect(result.relative).toBe("src/main.ts");
+    });
+
+    it("allows the root path itself", () => {
+      const result = resolveSandboxPath({
+        filePath: ".",
+        cwd: "/home/user/project",
+        root: "/home/user/project",
+      });
+
+      expect(result.resolved).toBe("/home/user/project");
+      expect(result.relative).toBe("");
+    });
+
+    it("expands ~ to homedir", () => {
+      const os = require("node:os");
+      const home = os.homedir();
+      const root = home;
+
+      const result = resolveSandboxPath({
+        filePath: "~/somefile.ts",
+        cwd: home,
+        root,
+      });
+
+      expect(result.resolved).toBe(`${home}/somefile.ts`);
+    });
+
+    it("normalizes Unicode spaces in paths", () => {
+      // resolveSandboxPath goes through expandPath which normalizes Unicode spaces
+      const result = resolveSandboxPath({
+        filePath: "src/my\u00A0file.ts",
+        cwd: "/home/user/project",
+        root: "/home/user/project",
+      });
+
+      expect(result.resolved).toBe("/home/user/project/src/my file.ts");
+    });
+
+    it("assertSandboxPath checks symlink escapes", async () => {
+      // For a path that doesn't exist yet, assertNoSymlinkEscape returns
+      // early with ENOENT — so it should succeed (no symlink to check)
+      const result = await assertSandboxPath({
+        filePath: "nonexistent/path.ts",
+        cwd: "/tmp",
+        root: "/tmp",
+      });
+
+      expect(result.resolved).toBe("/tmp/nonexistent/path.ts");
+    });
+
+    it("rejects relative path that escapes via multiple segments", () => {
+      expect(() =>
+        resolveSandboxPath({
+          filePath: "a/b/../../../../../../etc/passwd",
+          cwd: "/home/user/project",
+          root: "/home/user/project",
+        }),
+      ).toThrow("escapes sandbox root");
+    });
+  });
+});