@aaroncql/pim-agent 0.0.1 → 0.2.0

package/src/shared/DiffRenderer.test.ts

@@ -1,206 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DiffLines, type ToolDiffHunk } from "./DiffLines";
-import { DiffRenderer, type DiffHighlighter } from "./DiffRenderer";
-
-const tagHighlighter: DiffHighlighter = (block) =>
-  block.split("\n").map((line) => `<H>${line}</H>`);
-
-const recordingHighlighter = (calls: string[][]): DiffHighlighter => {
-  return (block) => {
-    const lines = block.split("\n");
-    calls.push(lines);
-    return lines.map((line) => `<H>${line}</H>`);
-  };
-};
-
-const firstHunk = (
-  oldText: readonly string[],
-  newText: readonly string[]
-): ToolDiffHunk => {
-  const diff = DiffLines.buildToolDiff(
-    "foo.ts",
-    { lines: oldText, hasTrailingNewline: true },
-    { lines: newText, hasTrailingNewline: true },
-    1
-  );
-
-  if (diff === undefined || diff.hunks[0] === undefined) {
-    throw new Error("expected at least one hunk");
-  }
-
-  return diff.hunks[0];
-};
-
-describe("DiffRenderer.highlightHunkLines", () => {
-  test("highlights added lines using the new-side block", () => {
-    const hunk = firstHunk(["a", "b", "c"], ["a", "b", "c", "d"]);
-    const result = DiffRenderer.highlightHunkLines(hunk, tagHighlighter);
-
-    expect(result).toEqual(hunk.lines.map((line) => `<H>${line.text}</H>`));
-  });
-
-  test("highlights removed lines using the old-side block", () => {
-    const hunk = firstHunk(["a", "b", "c"], ["a", "c"]);
-    const result = DiffRenderer.highlightHunkLines(hunk, tagHighlighter);
-
-    expect(result).toEqual(hunk.lines.map((line) => `<H>${line.text}</H>`));
-  });
-
-  test("passes old and new versions as multi-line blocks (not per line)", () => {
-    const hunk = firstHunk(
-      ["line1", "old-mid", "line3"],
-      ["line1", "new-mid", "line3"]
-    );
-    const calls: string[][] = [];
-    DiffRenderer.highlightHunkLines(hunk, recordingHighlighter(calls));
-
-    expect(calls).toHaveLength(2);
-    expect(calls).toContainEqual(["line1", "old-mid", "line3"]);
-    expect(calls).toContainEqual(["line1", "new-mid", "line3"]);
-  });
-
-  test("maps each diff line to the correct highlighted entry", () => {
-    const hunk = firstHunk(
-      ["keep", "drop1", "drop2", "tail"],
-      ["keep", "add1", "add2", "tail"]
-    );
-    const result = DiffRenderer.highlightHunkLines(hunk, tagHighlighter);
-
-    for (let i = 0; i < hunk.lines.length; i += 1) {
-      expect(result[i]).toBe(`<H>${hunk.lines[i]?.text}</H>`);
-    }
-  });
-
-  test("falls back to raw text when highlighter returns shorter array", () => {
-    const hunk = firstHunk(["a"], ["a", "b"]);
-    const truncating: DiffHighlighter = () => [];
-    const result = DiffRenderer.highlightHunkLines(hunk, truncating);
-
-    expect(result).toEqual(hunk.lines.map((line) => line.text));
-  });
-
-  test("skips highlighter calls when one side is empty", () => {
-    const hunk = firstHunk(["a", "b"], ["a", "b", "c", "d"]);
-    const calls: string[][] = [];
-    DiffRenderer.highlightHunkLines(hunk, recordingHighlighter(calls));
-
-    for (const call of calls) {
-      expect(call.length).toBeGreaterThan(0);
-    }
-  });
-});
-
-describe("DiffRenderer.render", () => {
-  const stubTheme = {
-    name: "pim-dark",
-    fg: (_color: string, text: string) => text,
-  } as unknown as Parameters<typeof DiffRenderer.render>[0]["theme"];
-
-  test("returns empty string for empty diff", () => {
-    const out = DiffRenderer.render({
-      toolDiff: { path: "foo.ts", hunks: [] },
-      theme: stubTheme,
-    });
-    expect(out).toBe("");
-  });
-
-  test("includes content for each diff line", () => {
-    const diff = DiffLines.buildToolDiff(
-      "foo.ts",
-      { lines: ["alpha", "beta", "gamma"], hasTrailingNewline: true },
-      { lines: ["alpha", "BETA", "gamma"], hasTrailingNewline: true },
-      1
-    );
-
-    if (diff === undefined) {
-      throw new Error("expected diff");
-    }
-
-    const out = DiffRenderer.render({ toolDiff: diff, theme: stubTheme });
-
-    expect(out).toContain("alpha");
-    expect(out).toContain("beta");
-    expect(out).toContain("BETA");
-    expect(out).toContain("gamma");
-  });
-
-  test("emits emphasis bg for paired changed lines", () => {
-    const diff = DiffLines.buildToolDiff(
-      "foo.ts",
-      { lines: ["const x = 1;"], hasTrailingNewline: true },
-      { lines: ["const y = 2;"], hasTrailingNewline: true },
-      1
-    );
-
-    if (diff === undefined) {
-      throw new Error("expected diff");
-    }
-
-    const out = DiffRenderer.render({ toolDiff: diff, theme: stubTheme });
-
-    expect(out).toContain("\x1b[48;2;26;81;47m");
-    expect(out).toContain("\x1b[48;2;100;35;35m");
-  });
-
-  test("does not render any EOF newline marker (EOF state is surfaced by callers, not the renderer)", () => {
-    const diff = DiffLines.buildToolDiff(
-      "foo.ts",
-      { lines: ["alpha"], hasTrailingNewline: false },
-      { lines: ["beta"], hasTrailingNewline: true },
-      1
-    );
-
-    if (diff === undefined) {
-      throw new Error("expected diff");
-    }
-
-    const out = DiffRenderer.render({ toolDiff: diff, theme: stubTheme });
-    expect(out).not.toContain("No newline at end of file");
-    expect(out).not.toContain("Newline added");
-  });
-});
-
-describe("DiffRenderer.applyEmphasis", () => {
-  const lineBg = "\x1b[48;2;0;0;0m";
-  const emphBg = "\x1b[48;2;255;255;255m";
-
-  test("returns text unchanged when no ranges", () => {
-    expect(DiffRenderer.applyEmphasis("hello", [], lineBg, emphBg)).toBe(
-      "hello"
-    );
-  });
-
-  test("wraps an emphasized range with emph then line bg", () => {
-    const out = DiffRenderer.applyEmphasis(
-      "hello world",
-      [{ start: 6, end: 11 }],
-      lineBg,
-      emphBg
-    );
-    expect(out).toBe(`hello ${emphBg}world${lineBg}`);
-  });
-
-  test("counts visible chars only, ignoring ANSI escape sequences", () => {
-    const colored = `\x1b[31mhello\x1b[39m world`;
-    const out = DiffRenderer.applyEmphasis(
-      colored,
-      [{ start: 6, end: 11 }],
-      lineBg,
-      emphBg
-    );
-    expect(out).toBe(`\x1b[31mhello\x1b[39m ${emphBg}world${lineBg}`);
-  });
-
-  test("supports multiple non-overlapping ranges", () => {
-    const out = DiffRenderer.applyEmphasis(
-      "abcdef",
-      [
-        { start: 0, end: 2 },
-        { start: 4, end: 6 },
-      ],
-      lineBg,
-      emphBg
-    );
-    expect(out).toBe(`${emphBg}ab${lineBg}cd${emphBg}ef${lineBg}`);
-  });
-});

package/src/shared/EditMatcher.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { EditMatcher } from "./EditMatcher";
-
-const replace = (
-  content: string,
-  oldString: string,
-  newString: string,
-  replaceAll = false
-): string => {
-  const resolved = EditMatcher.resolve(content, oldString, replaceAll);
-  const ranges = "ranges" in resolved ? resolved.ranges : [resolved.range];
-  return EditMatcher.applyAll(
-    content,
-    ranges.map((range) => ({ range, newString }))
-  );
-};
-
-describe("EditMatcher", () => {
-  test("resolves exact matches", () => {
-    expect(replace("alpha\nbeta\ngamma", "beta", "delta")).toBe(
-      "alpha\ndelta\ngamma"
-    );
-  });
-
-  test("uses lineTrimmed fallback", () => {
-    expect(replace("alpha\n  beta\ngamma", "beta ", "delta")).toBe(
-      "alpha\ndelta\ngamma"
-    );
-  });
-
-  test("uses whitespaceNormalized fallback", () => {
-    expect(replace("alpha\nfoo     bar\ngamma", "foo bar", "baz")).toBe(
-      "alpha\nbaz\ngamma"
-    );
-  });
-
-  test("uses indentationFlexible fallback", () => {
-    const content = "root\n    if (ok) {\n      run()\n    }\nend";
-    const oldString = "if (ok) {\n  run()\n}";
-    expect(replace(content, oldString, "done()")).toBe("root\ndone()\nend");
-  });
-
-  test("uses escapeNormalized fallback", () => {
-    expect(replace("alpha\nbeta\ngamma", "beta\\ngamma", "delta")).toBe(
-      "alpha\ndelta"
-    );
-  });
-
-  test("uses trimmedBoundary fallback", () => {
-    expect(replace("alpha\nbeta\ngamma", "\n beta \n", "delta")).toBe(
-      "alpha\ndelta\ngamma"
-    );
-  });
-
-  test("uses unicodeNormalized fallback", () => {
-    expect(replace("say “hello” now", 'say "hello" now', "done")).toBe("done");
-  });
-
-  test("uses blockAnchor fallback with same-line-count constraint", () => {
-    const content = [
-      "start",
-      "actual middle",
-      "end",
-      "start",
-      "one",
-      "two",
-      "three",
-      "end",
-    ].join("\n");
-
-    expect(replace(content, "start\nexpected middle\nend", "done")).toBe(
-      ["done", "start", "one", "two", "three", "end"].join("\n")
-    );
-  });
-
-  test("blockAnchor matches 3-line region with drifted middle", () => {
-    const content = ["start", "drifted middle", "end"].join("\n");
-    expect(replace(content, "start\nexpected middle\nend", "done")).toBe(
-      "done"
-    );
-  });
-
-  test("uses contextAware fallback", () => {
-    const content = "start\nsame\nactual\nend";
-    expect(replace(content, "start\nsame\nexpected\nend", "done")).toBe("done");
-  });
-
-  test("replaceAll returns every occurrence", () => {
-    expect(replace("foo\nbar\nfoo", "foo", "baz", true)).toBe("baz\nbar\nbaz");
-  });
-
-  test("throws multiple matches without replaceAll", () => {
-    expect(() => EditMatcher.resolve("foo\nbar\nfoo", "foo")).toThrow(
-      /matched multiple regions/
-    );
-  });
-
-  test("not found includes closest regions above threshold", () => {
-    const closest = EditMatcher.findClosestRegions(
-      "alpha\nbeta\ngamma",
-      "betx"
-    );
-    expect(closest[0]?.startLine).toBe(2);
-    expect(closest[0]?.similarity).toBeGreaterThan(0.5);
-  });
-
-  test("not found returns no regions below threshold", () => {
-    const closest = EditMatcher.findClosestRegions("aaaa\nbbbb", "zzzz");
-    expect(closest).toEqual([]);
-  });
-
-  test("escape-drift guard rejects new escape sequences after fuzzy match", () => {
-    const resolved = EditMatcher.resolve("  beta", "beta ");
-    const range = "range" in resolved ? resolved.range : resolved.ranges[0]!;
-    expect(() =>
-      EditMatcher.assertNoEscapeDrift(
-        resolved.strategy,
-        "new\\nvalue",
-        "  beta".slice(range[0], range[1])
-      )
-    ).toThrow(/newString contains literal escape text/);
-  });
-});

package/src/shared/FileScanner.test.ts

@@ -1,158 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
-import { FileScanner } from "./FileScanner";
-
-const tempRoots: string[] = [];
-
-const createTempDir = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-file-scanner-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-const defaultOptions = {
-  includeDotfiles: false,
-  includeIgnored: false,
-} as const;
-
-describe("FileScanner.scan", () => {
-  test("scans a directory and returns absolute file paths", async () => {
-    const root = await createTempDir();
-    await writeFile(join(root, "a.ts"), "", "utf8");
-    await writeFile(join(root, "b.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", defaultOptions);
-
-    expect(files.toSorted()).toEqual(
-      [join(root, "a.ts"), join(root, "b.ts")].sort()
-    );
-  });
-
-  test("respects gitignore patterns", async () => {
-    const root = await createTempDir();
-    await writeFile(join(root, ".gitignore"), "ignored.ts\n", "utf8");
-    await writeFile(join(root, "kept.ts"), "", "utf8");
-    await writeFile(join(root, "ignored.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", defaultOptions);
-
-    expect(files).toEqual([join(root, "kept.ts")]);
-  });
-
-  test("respects always-ignored defaults like node_modules", async () => {
-    const root = await createTempDir();
-    await mkdir(join(root, "node_modules", "pkg"), { recursive: true });
-    await writeFile(join(root, "node_modules", "pkg", "x.ts"), "", "utf8");
-    await writeFile(join(root, "kept.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", defaultOptions);
-
-    expect(files).toEqual([join(root, "kept.ts")]);
-  });
-
-  test("skips dotfiles by default", async () => {
-    const root = await createTempDir();
-    await mkdir(join(root, ".hidden"), { recursive: true });
-    await writeFile(join(root, ".hidden", "secret.ts"), "", "utf8");
-    await writeFile(join(root, "visible.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", defaultOptions);
-
-    expect(files).toEqual([join(root, "visible.ts")]);
-  });
-
-  test("includes dotfiles when requested", async () => {
-    const root = await createTempDir();
-    await mkdir(join(root, ".hidden"), { recursive: true });
-    await writeFile(join(root, ".hidden", "secret.ts"), "", "utf8");
-    await writeFile(join(root, "visible.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", {
-      ...defaultOptions,
-      includeDotfiles: true,
-    });
-
-    expect(files.toSorted()).toEqual(
-      [join(root, ".hidden", "secret.ts"), join(root, "visible.ts")].sort()
-    );
-  });
-
-  test("includes ignored files when requested", async () => {
-    const root = await createTempDir();
-    await writeFile(join(root, ".gitignore"), "ignored.ts\n", "utf8");
-    await writeFile(join(root, "kept.ts"), "", "utf8");
-    await writeFile(join(root, "ignored.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", {
-      ...defaultOptions,
-      includeIgnored: true,
-    });
-
-    expect(files.toSorted()).toEqual(
-      [join(root, "ignored.ts"), join(root, "kept.ts")].sort()
-    );
-  });
-
-  test("excludes patterns via the exclude option", async () => {
-    const root = await createTempDir();
-    await mkdir(join(root, "src"), { recursive: true });
-    await writeFile(join(root, "src", "app.ts"), "", "utf8");
-    await writeFile(join(root, "src", "app.test.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", {
-      ...defaultOptions,
-      exclude: ["**/*.test.ts"],
-    });
-
-    expect(files).toEqual([join(root, "src", "app.ts")]);
-  });
-
-  test("excludes multiple patterns", async () => {
-    const root = await createTempDir();
-    await mkdir(join(root, "src", "generated"), { recursive: true });
-    await writeFile(join(root, "src", "app.ts"), "", "utf8");
-    await writeFile(join(root, "src", "app.test.ts"), "", "utf8");
-    await writeFile(join(root, "src", "generated", "types.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", {
-      ...defaultOptions,
-      exclude: ["**/*.test.ts", "src/generated/**"],
-    });
-
-    expect(files).toEqual([join(root, "src", "app.ts")]);
-  });
-
-  test("returns an empty array for an empty directory", async () => {
-    const root = await createTempDir();
-
-    const files = await FileScanner.scan(root, "**/*", defaultOptions);
-
-    expect(files).toEqual([]);
-  });
-
-  test("scans nested directories", async () => {
-    const root = await createTempDir();
-    await mkdir(join(root, "a", "b", "c"), { recursive: true });
-    await writeFile(join(root, "a", "top.ts"), "", "utf8");
-    await writeFile(join(root, "a", "b", "mid.ts"), "", "utf8");
-    await writeFile(join(root, "a", "b", "c", "deep.ts"), "", "utf8");
-
-    const files = await FileScanner.scan(root, "**/*.ts", defaultOptions);
-
-    expect(files.toSorted()).toEqual(
-      [
-        join(root, "a", "top.ts"),
-        join(root, "a", "b", "mid.ts"),
-        join(root, "a", "b", "c", "deep.ts"),
-      ].sort()
-    );
-  });
-});

package/src/shared/FuzzyMatcher.test.ts

@@ -1,114 +0,0 @@
-import { expect, test } from "bun:test";
-import { FuzzyMatcher, type FuzzyCandidate } from "./FuzzyMatcher";
-
-type Command = {
-  readonly name: string;
-  readonly description: string;
-};
-
-const commandCandidates = (
-  commands: readonly Command[]
-): readonly FuzzyCandidate<Command>[] =>
-  commands.map((command) => ({
-    item: command,
-    haystacks: [command.name, command.description],
-  }));
-
-test("empty query returns candidates sorted alphabetically by first haystack", () => {
-  const candidates = commandCandidates([
-    { name: "rename", description: "rename" },
-    { name: "clear", description: "clear" },
-    { name: "help", description: "help" },
-  ]);
-
-  const hits = FuzzyMatcher.rank("", candidates);
-
-  expect(hits.map((hit) => hit.item.name)).toEqual(["clear", "help", "rename"]);
-  expect(hits[0]?.score).toBe(0);
-  expect(hits[0]?.positions.size).toBe(0);
-});
-
-test("whitespace-only query is treated as empty", () => {
-  const candidates = commandCandidates([
-    { name: "b", description: "b" },
-    { name: "a", description: "a" },
-  ]);
-
-  const hits = FuzzyMatcher.rank("   ", candidates);
-
-  expect(hits.map((hit) => hit.item.name)).toEqual(["a", "b"]);
-});
-
-test("non-empty query orders results by fzf score", () => {
-  const candidates = commandCandidates([
-    { name: "clear", description: "Clear the session." },
-    { name: "rename", description: "Rename the session." },
-    { name: "resume", description: "Resume a session." },
-    { name: "help", description: "Show help." },
-  ]);
-
-  const hits = FuzzyMatcher.rank("cl", candidates);
-
-  expect(hits.length).toBeGreaterThan(0);
-  expect(hits[0]?.item.name).toBe("clear");
-});
-
-test("limit truncates ranked results", () => {
-  const candidates = commandCandidates([
-    { name: "alpha", description: "" },
-    { name: "alphabet", description: "" },
-    { name: "alphanumeric", description: "" },
-  ]);
-
-  const hits = FuzzyMatcher.rank("a", candidates, { limit: 2 });
-
-  expect(hits.length).toBe(2);
-});
-
-test("limit also applies to the empty-query alphabetical case", () => {
-  const candidates = commandCandidates([
-    { name: "c", description: "" },
-    { name: "a", description: "" },
-    { name: "b", description: "" },
-  ]);
-
-  const hits = FuzzyMatcher.rank("", candidates, { limit: 2 });
-
-  expect(hits.map((hit) => hit.item.name)).toEqual(["a", "b"]);
-});
-
-test("ties on score break toward the earlier match start", () => {
-  const candidates = commandCandidates([
-    { name: "new", description: "Start a new session." },
-    { name: "status", description: "Show the current session status." },
-  ]);
-
-  const hits = FuzzyMatcher.rank("sta", candidates);
-
-  expect(hits[0]?.item.name).toBe("status");
-});
-
-test("ties on score and start break toward the shorter haystack", () => {
-  const candidates: readonly FuzzyCandidate<string>[] = [
-    {
-      item: "src/shared/DiffLines.test.ts",
-      haystacks: ["src/shared/DiffLines.test.ts"],
-    },
-    { item: "src/shared/DiffLines.ts", haystacks: ["src/shared/DiffLines.ts"] },
-  ];
-
-  const hits = FuzzyMatcher.rank("difflines", candidates);
-
-  expect(hits[0]?.item).toBe("src/shared/DiffLines.ts");
-});
-
-test("matches against the second haystack when the first does not contain the query", () => {
-  const candidates = commandCandidates([
-    { name: "noop", description: "fully unrelated" },
-    { name: "x", description: "rename the session" },
-  ]);
-
-  const hits = FuzzyMatcher.rank("rename", candidates);
-
-  expect(hits[0]?.item.name).toBe("x");
-});

package/src/shared/GitignoreFilter.test.ts

@@ -1,64 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, expect, test } from "bun:test";
-import { GitignoreFilter } from "./GitignoreFilter";
-
-const tempRoots: string[] = [];
-
-const createTempDir = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-gitignore-filter-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-test("applies hardcoded defaults", async () => {
-  const root = await createTempDir();
-  const filter = await GitignoreFilter.for(root);
-
-  expect(filter.ignores(join(root, "node_modules", "pkg", "index.js"))).toBe(
-    true
-  );
-  expect(filter.ignores(join(root, ".git", "config"))).toBe(true);
-  expect(filter.ignores(join(root, "src", "index.ts"))).toBe(false);
-});
-
-test("loads gitignore patterns from root up to the git boundary", async () => {
-  const root = await createTempDir();
-  const project = join(root, "project");
-  const nested = join(project, "packages", "app");
-
-  await mkdir(join(project, ".git"), { recursive: true });
-  await mkdir(nested, { recursive: true });
-  await writeFile(
-    join(project, ".gitignore"),
-    ["*.tmp", "*.log", "!important.log", "logs/", "/anchored.txt"].join("\n"),
-    "utf8"
-  );
-  await writeFile(join(nested, ".gitignore"), "local.txt\n", "utf8");
-
-  const filter = await GitignoreFilter.for(nested);
-
-  expect(filter.ignores(join(nested, "scratch.tmp"))).toBe(true);
-  expect(filter.ignores(join(nested, "logs", "app.log"))).toBe(true);
-  expect(filter.ignores(join(project, "anchored.txt"))).toBe(true);
-  expect(filter.ignores(join(nested, "anchored.txt"))).toBe(false);
-  expect(filter.ignores(join(nested, "drop.log"))).toBe(true);
-  expect(filter.ignores(join(nested, "important.log"))).toBe(false);
-  expect(filter.ignores(join(nested, "local.txt"))).toBe(true);
-});
-
-test("rejects relative paths", async () => {
-  const root = await createTempDir();
-  const filter = await GitignoreFilter.for(root);
-
-  expect(() => filter.ignores("src/index.ts")).toThrow(
-    "Expected absolute path"
-  );
-});

package/src/shared/Lines.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Lines } from "./Lines";
-
-describe("Lines.continuationLine", () => {
-  test("resumes on the partial last line when the cut is mid-line", () => {
-    expect(Lines.continuationLine("a\nb\nc")).toBe(3);
-  });
-
-  test("resumes on the next line when the cut lands on a newline", () => {
-    expect(Lines.continuationLine("a\nb\n")).toBe(3);
-  });
-
-  test("treats a single unterminated line as line 1", () => {
-    expect(Lines.continuationLine("a")).toBe(1);
-  });
-
-  test("never returns below 1 for empty input", () => {
-    expect(Lines.continuationLine("")).toBe(1);
-  });
-
-  test("counts normalized newlines (CRLF and CR)", () => {
-    expect(Lines.continuationLine("a\r\nb\r\nc")).toBe(3);
-    expect(Lines.continuationLine("a\rb")).toBe(2);
-  });
-});