plugsuits 1.0.0

package/src/tools/modify/edit-file-stress.test.ts

@@ -0,0 +1,200 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { executeReadFile } from "../explore/read-file";
+import { executeEditFile } from "./edit-file";
+
+const LINE_REF_REGEX_TEMPLATE = (lineNumber: number): RegExp =>
+  new RegExp(`\\b${lineNumber}#([ZPMQVRWSNKTXJBYH]{2})\\|`);
+
+function extractLineRef(readOutput: string, lineNumber: number): string {
+  const matched = readOutput.match(LINE_REF_REGEX_TEMPLATE(lineNumber));
+  if (!matched?.[1]) {
+    throw new Error(`Failed to extract line reference for line ${lineNumber}`);
+  }
+  return `${lineNumber}#${matched[1]}`;
+}
+
+describe("edit_file stress patterns", () => {
+  let tempDir: string;
+  beforeAll(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "edit-file-stress-test-"));
+  });
+  afterAll(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true });
+    }
+  });
+  async function lineRefs(
+    path: string,
+    ...numbers: number[]
+  ): Promise<string[]> {
+    const readOutput = await executeReadFile({ path });
+    return numbers.map((lineNumber) => extractLineRef(readOutput, lineNumber));
+  }
+
+  it("replaces line containing hashline-like syntax", async () => {
+    const testFile = join(tempDir, "stress-hashline-like.txt");
+    writeFileSync(testFile, "alpha\n5#AB|fake hashline\nomega\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["literal replaced"] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "alpha\nliteral replaced\nomega\n"
+    );
+  });
+
+  it("handles multiple edits on adjacent lines", async () => {
+    const testFile = join(tempDir, "stress-adjacent-edits.txt");
+    writeFileSync(testFile, "l1\nl2\nl3\nl4\nl5\n");
+    const [line2, line3, line4] = await lineRefs(testFile, 2, 3, 4);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        { op: "replace", pos: line2, lines: ["L2"] },
+        { op: "replace", pos: line3, lines: ["L3"] },
+        { op: "replace", pos: line4, lines: ["L4"] },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe("l1\nL2\nL3\nL4\nl5\n");
+  });
+
+  it("range replace spanning 5 lines down to 2", async () => {
+    const testFile = join(tempDir, "stress-range-5-to-2.txt");
+    writeFileSync(testFile, "one\ntwo\nthree\nfour\nfive\n");
+    const [line1, line5] = await lineRefs(testFile, 1, 5);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        { op: "replace", pos: line1, end: line5, lines: ["new-a", "new-b"] },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe("new-a\nnew-b\n");
+  });
+
+  it("simultaneous first and last line edits", async () => {
+    const testFile = join(tempDir, "stress-first-last.txt");
+    writeFileSync(testFile, "first\nsecond\nthird\nfourth\n");
+    const [line1, line4] = await lineRefs(testFile, 1, 4);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        { op: "replace", pos: line1, lines: ["FIRST"] },
+        { op: "replace", pos: line4, lines: ["FOURTH"] },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "FIRST\nsecond\nthird\nFOURTH\n"
+    );
+  });
+
+  it("append EOF + replace first line in same call", async () => {
+    const testFile = join(tempDir, "stress-eof-append-plus-first.txt");
+    writeFileSync(testFile, "top\nmiddle\nbottom\n");
+    const [line1, line3] = await lineRefs(testFile, 1, 3);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        { op: "replace", pos: line1, lines: ["TOP"] },
+        { op: "append", pos: line3, lines: ["tail"] },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe("TOP\nmiddle\nbottom\ntail\n");
+  });
+
+  it("replace with content containing regex special chars", async () => {
+    const testFile = join(tempDir, "stress-regex-specials.txt");
+    writeFileSync(testFile, "offer\nplaceholder\nend\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        {
+          op: "replace",
+          pos: line2,
+          lines: ["price = $99.99 (50% off) [limited*]"],
+        },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "offer\nprice = $99.99 (50% off) [limited*]\nend\n"
+    );
+  });
+
+  it("expand single line into multiple lines", async () => {
+    const testFile = join(tempDir, "stress-expand-line.txt");
+    writeFileSync(testFile, "header\nsingle\nfooter\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        {
+          op: "replace",
+          pos: line2,
+          lines: ["part-1", "part-2", "part-3", "part-4"],
+        },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "header\npart-1\npart-2\npart-3\npart-4\nfooter\n"
+    );
+  });
+
+  it("triple operation: prepend + replace + append on different anchors", async () => {
+    const testFile = join(tempDir, "stress-triple-operation.txt");
+    writeFileSync(testFile, "one\ntwo\nthree\nfour\nfive\n");
+    const [line1, line3, line5] = await lineRefs(testFile, 1, 3, 5);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        { op: "prepend", pos: line1, lines: ["zero"] },
+        { op: "replace", pos: line3, lines: ["THREE"] },
+        { op: "append", pos: line5, lines: ["six"] },
+      ],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "zero\none\ntwo\nTHREE\nfour\nfive\nsix\n"
+    );
+  });
+
+  it("edit content containing unicode and emoji", async () => {
+    const testFile = join(tempDir, "stress-unicode-emoji.txt");
+    writeFileSync(testFile, "alpha\n🎉 celebration\nomega\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["✅ done — 완료"] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "alpha\n✅ done — 완료\nomega\n"
+    );
+  });
+
+  it("range replace preserving surrounding context", async () => {
+    const testFile = join(tempDir, "stress-range-context.txt");
+    writeFileSync(
+      testFile,
+      `${Array.from({ length: 10 }, (_, index) => `line-${index + 1}`).join("\n")}\n`
+    );
+    const [line4, line7] = await lineRefs(testFile, 4, 7);
+    await executeEditFile({
+      path: testFile,
+      edits: [
+        { op: "replace", pos: line4, end: line7, lines: ["new-4", "new-5"] },
+      ],
+    }, { rootDir: tempDir });
+    const actualLines = readFileSync(testFile, "utf-8").trimEnd().split("\n");
+    expect(actualLines.slice(0, 3)).toEqual(["line-1", "line-2", "line-3"]);
+    expect(actualLines.slice(3, 5)).toEqual(["new-4", "new-5"]);
+    expect(actualLines.slice(5)).toEqual(["line-8", "line-9", "line-10"]);
+  });
+});

package/src/tools/modify/edit-file-validation.ts

@@ -0,0 +1,134 @@
+import {
+  computeFileHash,
+  type HashlineEdit,
+  tryParseLineTag,
+} from "../utils/hashline";
+import {
+  diagnoseAnchorFailure,
+  diagnoseMissingLines,
+  ESCALATION_THRESHOLD,
+  getEscalatedHint,
+  trackMissingLinesFailure,
+} from "./edit-file-diagnostics";
+import {
+  assertSingleLineAnchor,
+  type HashlineToolEdit,
+  repairMalformedEdit,
+} from "./edit-file-repair";
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: complex validation pipeline
+export function validateAndRepairEdits(
+  edits: HashlineToolEdit[],
+  fileLines: string[],
+  filePath: string
+): { edits: HashlineToolEdit[]; repairWarnings: string[] } {
+  const repairWarnings: string[] = [];
+  const validated: HashlineToolEdit[] = [];
+
+  for (const edit of edits) {
+    let { edit: repairedEdit, warnings } = repairMalformedEdit(edit);
+    repairWarnings.push(...warnings);
+
+    assertSingleLineAnchor(repairedEdit.pos, "pos");
+    assertSingleLineAnchor(repairedEdit.end, "end");
+
+    if (repairedEdit.op === "replace" && repairedEdit.lines === undefined) {
+      const failureCount = trackMissingLinesFailure(repairedEdit.pos, filePath);
+      const baseMessage = diagnoseMissingLines(repairedEdit.pos);
+      if (failureCount >= ESCALATION_THRESHOLD && fileLines.length > 0) {
+        const hint = getEscalatedHint(
+          repairedEdit.pos,
+          fileLines,
+          failureCount
+        );
+        if (hint) {
+          throw new Error(`${baseMessage} ${hint}`);
+        }
+      }
+      throw new Error(baseMessage);
+    }
+
+    const parsedPos = tryParseLineTag(repairedEdit.pos);
+    const parsedEnd = tryParseLineTag(repairedEdit.end);
+
+    if (repairedEdit.op === "replace") {
+      if (!(parsedPos || parsedEnd)) {
+        if (repairedEdit.pos) {
+          throw new Error(
+            diagnoseAnchorFailure(repairedEdit.pos, "pos", fileLines)
+          );
+        }
+        if (repairedEdit.end) {
+          throw new Error(
+            diagnoseAnchorFailure(repairedEdit.end, "end", fileLines)
+          );
+        }
+        throw new Error("replace requires pos or end anchor.");
+      }
+      // Fallback: clear invalid anchors so normalize uses the valid one
+      if (!parsedPos && parsedEnd) {
+        repairedEdit = { ...repairedEdit, pos: undefined };
+        repairWarnings.push(
+          edit.pos === undefined
+            ? "pos was not provided; falling back to end anchor."
+            : `Ignored invalid pos "${edit.pos}"; falling back to end anchor.`
+        );
+      } else if (parsedPos && !parsedEnd && repairedEdit.end) {
+        repairedEdit = { ...repairedEdit, end: undefined };
+        repairWarnings.push(
+          `Ignored invalid end "${edit.end}"; falling back to pos anchor.`
+        );
+      }
+    } else if (
+      (repairedEdit.pos || repairedEdit.end) &&
+      !parsedPos &&
+      !parsedEnd
+    ) {
+      const failedField = repairedEdit.pos ? "pos" : "end";
+      const failedValue = repairedEdit.pos ?? repairedEdit.end;
+      if (failedValue) {
+        throw new Error(
+          diagnoseAnchorFailure(failedValue, failedField, fileLines)
+        );
+      }
+    } else if (!parsedPos && parsedEnd) {
+      // For append/prepend: fall back to end when pos is invalid
+      repairedEdit = { ...repairedEdit, pos: repairedEdit.end, end: undefined };
+      repairWarnings.push(
+        `Ignored invalid pos "${edit.pos}"; falling back to end anchor.`
+      );
+    } else if (parsedPos && !parsedEnd && repairedEdit.end) {
+      repairedEdit = { ...repairedEdit, end: undefined };
+      repairWarnings.push(
+        `Ignored invalid end "${edit.end}"; falling back to pos anchor.`
+      );
+    }
+
+    validated.push(repairedEdit);
+  }
+
+  return { edits: validated, repairWarnings };
+}
+
+export function canCreateFromMissingFile(edits: HashlineEdit[]): boolean {
+  if (edits.length === 0) {
+    return false;
+  }
+  return edits.every((edit) => edit.op === "append" || edit.op === "prepend");
+}
+
+export function assertExpectedFileHash(
+  expectedHash: string | undefined,
+  currentContent: string
+): void {
+  if (!expectedHash) {
+    return;
+  }
+  const normalizedExpected = expectedHash.toLowerCase();
+  const currentHash = computeFileHash(currentContent).toLowerCase();
+  if (normalizedExpected !== currentHash) {
+    throw new Error(
+      `File changed since read_file output. expected=${normalizedExpected}, current=${currentHash}`
+    );
+  }
+}

package/src/tools/modify/edit-file-whitespace.test.ts

@@ -0,0 +1,117 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { executeReadFile } from "../explore/read-file";
+import { executeEditFile } from "./edit-file";
+
+const LINE_REF_REGEX_TEMPLATE = (lineNumber: number): RegExp =>
+  new RegExp(`\\b${lineNumber}#([ZPMQVRWSNKTXJBYH]{2})\\|`);
+
+function extractLineRef(readOutput: string, lineNumber: number): string {
+  const matched = readOutput.match(LINE_REF_REGEX_TEMPLATE(lineNumber));
+  if (!matched?.[1]) {
+    throw new Error(`Failed to extract line reference for line ${lineNumber}`);
+  }
+  return `${lineNumber}#${matched[1]}`;
+}
+
+describe("edit_file whitespace stress patterns", () => {
+  let tempDir: string;
+
+  beforeAll(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "edit-file-whitespace-test-"));
+  });
+
+  afterAll(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  async function lineRefs(
+    path: string,
+    ...numbers: number[]
+  ): Promise<string[]> {
+    const readOutput = await executeReadFile({ path });
+    return numbers.map((lineNumber) => extractLineRef(readOutput, lineNumber));
+  }
+
+  it("preserves leading indentation on replace", async () => {
+    const testFile = join(tempDir, "stress-indent-leading.txt");
+    writeFileSync(testFile, "start\n    indented line\nend\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["updated indented line"] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "start\n    updated indented line\nend\n"
+    );
+  });
+
+  it("edits line containing only spaces", async () => {
+    const testFile = join(tempDir, "stress-only-spaces-line.txt");
+    writeFileSync(testFile, "before\n    \nafter\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["filled"] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe("before\n    filled\nafter\n");
+  });
+
+  it("preserves tab indentation", async () => {
+    const testFile = join(tempDir, "stress-tab-indent.txt");
+    writeFileSync(testFile, "start\n\tfunction foo() {\nend\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["return 42;"] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe("start\n\treturn 42;\nend\n");
+  });
+
+  it("inserts blank lines via append", async () => {
+    const testFile = join(tempDir, "stress-append-blank-lines.txt");
+    writeFileSync(testFile, "anchor\ntail\n");
+    const [line1] = await lineRefs(testFile, 1);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "append", pos: line1, lines: ["", "new content", ""] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "anchor\n\nnew content\n\ntail\n"
+    );
+  });
+
+  it("handles trailing spaces in replacement content", async () => {
+    const testFile = join(tempDir, "stress-trailing-spaces.txt");
+    writeFileSync(testFile, "x\ny\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["hello   "] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe("x\nhello   \n");
+  });
+
+  it("edits file with mixed indentation (tabs + spaces)", async () => {
+    const testFile = join(tempDir, "stress-mixed-indentation.txt");
+    writeFileSync(testFile, "\tif (ok) {\n    run();\n\t    mixed();\n}\n");
+    const [line2] = await lineRefs(testFile, 2);
+    await executeEditFile({
+      path: testFile,
+      edits: [{ op: "replace", pos: line2, lines: ["updated();"] }],
+    }, { rootDir: tempDir });
+    expect(readFileSync(testFile, "utf-8")).toBe(
+      "\tif (ok) {\n    updated();\n\t    mixed();\n}\n"
+    );
+  });
+});