@maxiaochao/pi-toolkit 0.9.4 → 0.9.6

package/packages/codex-edit/tests/legacy-parser-v0.1.7.mjs

@@ -0,0 +1,128 @@
+// Frozen semantic baseline from @maxiaochao/pi-codex-edit v0.1.7.
+// Source blob: codex-edit-v0.1.7:packages/codex-edit/src/parser.ts
+// Git blob ID: e2896b59d40b5f6f01b3a4a7918476f4acc28cd8
+// Keep this file unchanged; add cases to comparison-cases.mjs instead.
+
+export function parseLegacyPatch(patch) {
+  const lines = patch.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim().split("\n");
+  if (lines[0]?.trim() !== "*** Begin Patch") throw new Error("The first line of the patch must be '*** Begin Patch'");
+  if (lines.at(-1)?.trim() !== "*** End Patch") throw new Error("The last line of the patch must be '*** End Patch'");
+  const operations = [];
+  let index = 1;
+  while (index < lines.length - 1) {
+    const line = lines[index];
+    if (line.startsWith("*** Add File: ")) {
+      const path = line.slice("*** Add File: ".length);
+      index += 1;
+      const content = [];
+      while (index < lines.length - 1 && !lines[index].startsWith("*** ")) {
+        if (!lines[index].startsWith("+")) throw new Error(`Invalid add line ${index + 1}`);
+        content.push(lines[index].slice(1));
+        index += 1;
+      }
+      if (content.length === 0) throw new Error(`Add file hunk for path '${path}' is empty`);
+      operations.push({ action: "add", path, content: `${content.join("\n")}\n` });
+      continue;
+    }
+    if (line.startsWith("*** Delete File: ")) {
+      const path = line.slice("*** Delete File: ".length);
+      if (!path) throw new Error(`Delete file hunk on line ${index + 1} has an empty path`);
+      operations.push({ action: "delete", path });
+      index += 1;
+      continue;
+    }
+    if (line.startsWith("*** Update File: ")) {
+      const path = line.slice("*** Update File: ".length);
+      index += 1;
+      let moveTo;
+      if (lines[index]?.startsWith("*** Move to: ")) {
+        moveTo = lines[index].slice("*** Move to: ".length);
+        index += 1;
+      }
+      const chunks = [];
+      while (index < lines.length - 1 && !lines[index].startsWith("*** ")) {
+        let context;
+        if (lines[index] === "@@" || lines[index].startsWith("@@ ")) {
+          context = lines[index].slice(2).trim() || undefined;
+          index += 1;
+        }
+        const oldLines = [];
+        const newLines = [];
+        const contextLineIndices = [];
+        while (index < lines.length - 1 && !lines[index].startsWith("*** ") && !lines[index].startsWith("@@")) {
+          const change = lines[index];
+          const marker = change[0];
+          if (!["+", "-", " "].includes(marker)) throw new Error(`Invalid update line ${index + 1}`);
+          const text = change.slice(1);
+          if (marker === "+") newLines.push(text);
+          else if (marker === "-") oldLines.push(text);
+          else {
+            contextLineIndices.push([oldLines.length, newLines.length]);
+            oldLines.push(text);
+            newLines.push(text);
+          }
+          index += 1;
+        }
+        const endOfFile = lines[index] === "*** End of File";
+        if (endOfFile) index += 1;
+        if (oldLines.length === 0 && newLines.length === 0) throw new Error(`Empty update chunk on line ${index + 1}`);
+        chunks.push({ context, oldLines, newLines, contextLineIndices, endOfFile });
+      }
+      if (chunks.length === 0) throw new Error(`Update file hunk for path '${path}' is empty`);
+      operations.push({ action: "update", path, moveTo, chunks });
+      continue;
+    }
+    throw new Error(`Invalid hunk header on line ${index + 1}: ${line}`);
+  }
+  if (operations.length === 0) throw new Error("Patch contains no file operations");
+  const targets = operations.flatMap((operation) => [operation.path, operation.moveTo].filter(Boolean));
+  if (new Set(targets).size !== targets.length) throw new Error("Multiple operations target the same path");
+  return operations;
+}
+
+function findCandidates(lines, pattern, start, eof, compare) {
+  const candidates = [];
+  for (let index = start; index + pattern.length <= lines.length; index += 1) {
+    if (pattern.every((line, offset) => compare(lines[index + offset], line))) candidates.push(index);
+  }
+  candidates.sort((left, right) => eof ? right - left : left - right);
+  return candidates;
+}
+
+function locate(lines, pattern, start, eof, label) {
+  if (pattern.length === 0) return Math.min(start, lines.length);
+  const comparisons = [
+    (left, right) => left === right,
+    (left, right) => left.trimEnd() === right.trimEnd(),
+    (left, right) => left.trim() === right.trim(),
+  ];
+  for (const compare of comparisons) {
+    const candidates = findCandidates(lines, pattern, start, eof, compare);
+    if (candidates.length > 0) return candidates[0];
+  }
+  throw new Error(`Failed to find expected lines${label ? ` in ${label}` : ""}: ${pattern.join("\\n")}`);
+}
+
+export function applyLegacyUpdate(content, chunks, path) {
+  const bom = content.startsWith("\ufeff") ? "\ufeff" : "";
+  const withoutBom = bom ? content.slice(1) : content;
+  const ending = withoutBom.includes("\r\n") ? "\r\n" : "\n";
+  const normalized = withoutBom.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const hadFinalNewline = normalized.endsWith("\n");
+  const lines = normalized === "" ? [] : normalized.split("\n");
+  if (hadFinalNewline) lines.pop();
+  const replacements = [];
+  let cursor = 0;
+  for (const chunk of chunks) {
+    if (chunk.context !== undefined) cursor = locate(lines, [chunk.context], cursor, false, path) + 1;
+    const start = locate(lines, chunk.oldLines, cursor, chunk.endOfFile, path);
+    replacements.push({ start, length: chunk.oldLines.length, next: chunk.newLines });
+    cursor = start + chunk.oldLines.length;
+  }
+  const output = [...lines];
+  for (const replacement of [...replacements].reverse()) output.splice(replacement.start, replacement.length, ...replacement.next);
+  let next = output.join("\n");
+  if (hadFinalNewline || next.length > 0) next += "\n";
+  if (ending === "\r\n") next = next.replace(/\n/g, "\r\n");
+  return bom + next;
+}

package/packages/codex-edit/tests/native-vs-codex.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { createEditToolDefinition } from "@earendil-works/pi-coding-agent";
+import registerCodexEdit from "../extensions/codex-edit.ts";
+import { comparisonCases } from "./comparison-cases.mjs";
+
+async function writeSnapshot(root, snapshot) {
+  for (const [path, content] of Object.entries(snapshot)) {
+    const absolute = join(root, path);
+    await mkdir(dirname(absolute), { recursive: true });
+    await writeFile(absolute, content, "utf8");
+  }
+}
+
+async function readSnapshot(root, relative = "") {
+  const snapshot = {};
+  for (const entry of await readdir(join(root, relative), { withFileTypes: true })) {
+    const path = relative ? `${relative}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) Object.assign(snapshot, await readSnapshot(root, path));
+    else snapshot[path] = await readFile(join(root, path), "utf8");
+  }
+  return snapshot;
+}
+
+async function runNativeCase(testCase) {
+  if (testCase.outcomes.native === "unsupported") {
+    assert.equal(testCase.nativeCalls, null, `${testCase.id}: unsupported native case must not invent edit calls`);
+    return "unsupported";
+  }
+  const workspace = await mkdtemp(join(tmpdir(), "codex-edit-native-"));
+  try {
+    await writeSnapshot(workspace, testCase.input);
+    const edit = createEditToolDefinition(workspace);
+    try {
+      for (const [index, call] of testCase.nativeCalls.entries()) {
+        await edit.execute(`native-${index}`, call, undefined, undefined, { cwd: workspace });
+      }
+      if (testCase.outcomes.native !== "pass") {
+        assert.fail(`${testCase.id}: native edit unexpectedly succeeded`);
+      }
+      assert.deepEqual(await readSnapshot(workspace), testCase.expected);
+      return "pass";
+    } catch (error) {
+      if (testCase.outcomes.native === "pass") throw error;
+      return "fail";
+    }
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+  }
+}
+
+async function getCodexTool() {
+  let tool;
+  await registerCodexEdit({
+    registerTool(definition) { tool = definition; },
+    on() {},
+    getActiveTools() { return []; },
+  });
+  assert.ok(tool, "Codex Edit extension did not register apply_patch");
+  return tool;
+}
+
+async function runCodexCase(tool, testCase) {
+  const workspace = await mkdtemp(join(tmpdir(), "codex-edit-local-"));
+  try {
+    await writeSnapshot(workspace, testCase.input);
+    try {
+      await tool.execute("codex-local", { patch: testCase.patch }, undefined, undefined, {
+        cwd: workspace,
+        hasUI: false,
+      });
+      if (testCase.outcomes.local !== "pass") {
+        assert.fail(`${testCase.id}: local Codex Edit unexpectedly succeeded`);
+      }
+      assert.deepEqual(await readSnapshot(workspace), testCase.expected);
+      return "pass";
+    } catch (error) {
+      if (testCase.outcomes.local === "pass") throw error;
+      assert.deepEqual(
+        await readSnapshot(workspace),
+        testCase.input,
+        `${testCase.id}: failed Codex patch must not partially mutate the workspace`,
+      );
+      return "fail";
+    }
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+  }
+}
+
+export default async function () {
+  const codexTool = await getCodexTool();
+  const results = [];
+  for (const testCase of comparisonCases) {
+    const native = await runNativeCase(testCase);
+    const codex = await runCodexCase(codexTool, testCase);
+    results.push({ id: testCase.id, native, codex });
+  }
+  assert.equal(results.length, comparisonCases.length);
+  assert.equal(results.filter(({ native }) => native === "pass").length, 5);
+  assert.equal(results.filter(({ native }) => native === "fail").length, 2);
+  assert.equal(results.filter(({ native }) => native === "unsupported").length, 5);
+  assert.equal(results.filter(({ codex }) => codex === "pass").length, 7);
+  assert.equal(results.filter(({ codex }) => codex === "fail").length, 5);
+  for (const result of results) console.log(`${result.id}: native=${result.native}, codex=${result.codex}`);
+  console.log(`Native edit vs local Codex Edit: ${results.length} comparison cases passed`);
+}

package/packages/codex-edit/tests/package.test.mjs

@@ -12,6 +12,8 @@ test("package points Pi at the extension and config is reachable from it", async
   const source = await readFile(join(packageDir, "extensions/codex-edit.ts"), "utf8");
   assert.match(source, /new URL\("\.\.\/config\.json", import\.meta\.url\)/);
   assert.match(source, /model-routing\.ts/);
+  assert.match(source, /parameters: Type\.Object\(\{\s*patch: Type\.String/);
+  assert.match(source, /applyUpdateGroups\(before, operation\.chunkGroups, operation\.path\)/);
   const config = JSON.parse(await readFile(join(packageDir, "config.json"), "utf8"));
   assert.equal(config.enabled, true);
   assert.deepEqual(config.models, ["gpt-5.6-*"]);
@@ -41,3 +43,9 @@ test("matches allowed model IDs with globs independently of provider and grammar
   assert.equal(modelIsAllowed({ ...baseModel, id: "GPT-5.6-terra" }, settings), false);
   assert.equal(modelIsAllowed(baseModel, { enabled: false, models: ["gpt-5.6-*"] }), false);
 });
+
+test("execution keeps a resolved-path conflict guard after parser coalescing", async () => {
+  const source = await readFile(join(packageDir, "extensions/codex-edit.ts"), "utf8");
+  assert.match(source, /new Set\(targets\)\.size !== targets\.length/);
+  assert.match(source, /Multiple patch operations target the same resolved path/);
+});

package/packages/codex-edit/tests/parser.test.mjs

@@ -3,7 +3,7 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
-import { applyUpdate, parsePatch, resolveWorkspacePath } from "../src/parser.ts";
+import { applyUpdate, applyUpdateGroups, parsePatch, resolveWorkspacePath } from "../src/parser.ts";
 
 test("parses add, delete, update, and move operations", () => {
   const operations = parsePatch(`*** Begin Patch
@@ -162,6 +162,128 @@ test("parses multiple file operations used by structural refactors", () => {
   );
 });
 
+test("coalesces repeated updates to one path and preserves operation order", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+-const value = 1;
++const value = 2;
+*** Update File: src/tool.ts
+@@
+-const value = 2;
++const value = 3;
+*** End Patch`);
+  assert.equal(operations.length, 1);
+  assert.equal(operations[0].path, "src/tool.ts");
+  assert.equal(operations[0].chunkGroups.length, 2);
+  const after = applyUpdateGroups("const value = 1;\n", operations[0].chunkGroups, "src/tool.ts");
+  assert.equal(after, "const value = 3;\n");
+});
+
+test("still rejects conflicting repeated targets", () => {
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+-old
++new
+*** Delete File: src/tool.ts
+*** End Patch`), /same path/);
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Update File: src/old.ts
+*** Move to: src/new.ts
+@@
+-old
++new
+*** Add File: src/new.ts
++replacement
+*** End Patch`), /same path/);
+});
+
+test("rejects empty chunks and stale expected lines instead of guessing", () => {
+  assert.throws(() => parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+*** End Patch`), /Empty update chunk/);
+  const [operation] = parsePatch(`*** Begin Patch
+*** Update File: src/tool.ts
+@@
+-missing line
++replacement
+*** End Patch`);
+  assert.throws(
+    () => applyUpdate("actual line\n", operation.chunks, operation.path),
+    /Failed to find expected lines in src\/tool\.ts/,
+  );
+});
+
+test("handles the reported project-scale repeated-file and Markdown shapes", () => {
+  const operations = parsePatch(`*** Begin Patch
+*** Update File: skills/pi-worktree/SKILL.md
+@@
+-description: old
++description: updated
+@@
+ ---
++Release notes follow.
+*** Update File: packages/tiny-subagent/src/tool.ts
+@@
+-const state = "old";
++const state = "middle";
+*** Update File: packages/tiny-subagent/src/tool.ts
+@@
+-const state = "middle";
++const state = "new";
+*** Update File: scripts/release-package.sh
+@@
+-ROOT_LEVEL=patch
++ROOT_LEVEL=minor
+*** Update File: scripts/release-package.sh
+@@
+-ROOT_LEVEL=minor
++ROOT_LEVEL=patch
+*** End Patch`);
+  assert.deepEqual(operations.map((operation) => operation.path), [
+    "skills/pi-worktree/SKILL.md",
+    "packages/tiny-subagent/src/tool.ts",
+    "scripts/release-package.sh",
+  ]);
+  assert.equal(operations[1].chunkGroups.length, 2);
+  assert.equal(operations[2].chunkGroups.length, 2);
+
+  const skill = `---
+name: pi-worktree
+description: old
+---
+
+# pi-worktree
+
+---
+Footer
+`;
+  assert.equal(
+    applyUpdateGroups(skill, operations[0].chunkGroups, operations[0].path),
+    `---
+name: pi-worktree
+description: updated
+---
+Release notes follow.
+
+# pi-worktree
+
+---
+Footer
+`,
+  );
+  assert.equal(
+    applyUpdateGroups('const state = "old";\n', operations[1].chunkGroups, operations[1].path),
+    'const state = "new";\n',
+  );
+  assert.equal(
+    applyUpdateGroups("ROOT_LEVEL=patch\n", operations[2].chunkGroups, operations[2].path),
+    "ROOT_LEVEL=patch\n",
+  );
+});
+
 test("rejects workspace escapes", () => {
   assert.equal(resolveWorkspacePath("/tmp/project", "/tmp/project/src/a.js"), "/tmp/project/src/a.js");
   assert.throws(() => resolveWorkspacePath("/tmp/project", "/tmp/other/a.js"), /escapes/);

package/packages/codex-edit/tests/released-vs-local.test.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { applyUpdate, parsePatch } from "../src/parser.ts";
+import { comparisonCases } from "./comparison-cases.mjs";
+import { runPatchCase } from "./comparison-harness.mjs";
+import { applyLegacyUpdate, parseLegacyPatch } from "./legacy-parser-v0.1.7.mjs";
+
+test("released v0.1.7 versus local parser over the growing comparison corpus", () => {
+  const results = [];
+  for (const testCase of comparisonCases) {
+    const released = runPatchCase(
+      testCase,
+      parseLegacyPatch,
+      applyLegacyUpdate,
+      testCase.outcomes.released,
+    );
+    const local = runPatchCase(testCase, parsePatch, applyUpdate, testCase.outcomes.local);
+    results.push({ id: testCase.id, released, local });
+  }
+
+  assert.equal(results.length, comparisonCases.length);
+  assert.deepEqual(
+    results.find(({ id }) => id === "repeated-update-same-path"),
+    { id: "repeated-update-same-path", released: "fail", local: "pass" },
+  );
+  assert.equal(results.filter(({ released }) => released === "pass").length, 6);
+  assert.equal(results.filter(({ released }) => released === "fail").length, 6);
+  assert.equal(results.filter(({ local }) => local === "pass").length, 7);
+  assert.equal(results.filter(({ local }) => local === "fail").length, 5);
+  for (const result of results) console.log(`${result.id}: released=${result.released}, local=${result.local}`);
+});