goatcode-sh 0.0.1 → 0.1.2

package/src/tools/glob/handler.ts

@@ -0,0 +1,74 @@
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { buildTool } from "../tool-builder";
+import { log } from "../../shared/logger";
+import type { GlobArgs, GlobOutput } from "./types";
+import { globArgsSchema } from "./types";
+
+const MAX_FILES = 100;
+
+type FileMatch = {
+  path: string;
+  mtimeMs: number;
+};
+
+export type GlobScanner = (pattern: string, cwd: string) => Promise<string[]>;
+
+async function scanFiles(pattern: string, cwd: string): Promise<string[]> {
+  const glob = new Bun.Glob(pattern);
+  const matches: string[] = [];
+  for await (const match of glob.scan({ cwd })) {
+    matches.push(match);
+  }
+  return matches;
+}
+
+async function collectWithMtime(cwd: string, paths: string[]): Promise<FileMatch[]> {
+  const files = await Promise.all(
+    paths.map(async (relativePath) => {
+      const absolutePath = resolve(cwd, relativePath);
+      const fileStats = await stat(absolutePath);
+      return { path: absolutePath, mtimeMs: fileStats.mtimeMs };
+    }),
+  );
+
+  return files.sort((left, right) => right.mtimeMs - left.mtimeMs);
+}
+
+export async function executeGlob(
+  args: GlobArgs,
+  context: { directory: string },
+  scanner: GlobScanner = scanFiles,
+): Promise<GlobOutput> {
+  const searchDirectory = args.path ? resolve(context.directory, args.path) : context.directory;
+  log("glob executing", { pattern: args.pattern, searchDirectory });
+
+  try {
+    const paths = await scanner(args.pattern, searchDirectory);
+    if (paths.length === 0) {
+      return "No files found";
+    }
+
+    const files = await collectWithMtime(searchDirectory, paths);
+    const limited = files.slice(0, MAX_FILES);
+    return limited.map((file) => file.path).join("\n");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log("glob failed", { message });
+    return `Error: ${message}`;
+  }
+}
+
+export function createGlobTool(scanner?: GlobScanner): ToolDefinition {
+  return buildTool({
+    description:
+      "Fast file pattern matching tool with safety limits (60s timeout, 100 file limit). " +
+      'Supports glob patterns like "**/*.js" or "src/**/*.ts". ' +
+      "Returns matching file paths sorted by modification time. " +
+      "Use this tool when you need to find files by name patterns.",
+    args: globArgsSchema as unknown as ToolDefinition["args"],
+    execute: async (toolArgs, toolContext) =>
+      executeGlob(toolArgs as GlobArgs, toolContext, scanner),
+  });
+}

package/src/tools/glob/index.ts

@@ -0,0 +1,2 @@
+export { globPlugin } from "./plugin";
+export { createGlobTool, executeGlob } from "./handler";

package/src/tools/glob/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../plugin-api";
+import { createGlobTool } from "./handler";
+
+export const globPlugin = definePlugin({
+  name: "glob",
+  version: "0.1.0",
+  tools: {
+    glob: createGlobTool(),
+  },
+});

package/src/tools/glob/types.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const globArgsSchema = {
+  pattern: z.string().describe("The glob pattern to match files against"),
+  path: z
+    .string()
+    .optional()
+    .describe(
+      'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
+    ),
+};
+
+export type GlobArgs = z.infer<z.ZodObject<typeof globArgsSchema>>;
+export type GlobOutput = string;

package/src/tools/grep/handler.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, mock } from "bun:test";
+import { createGrepTool } from "./handler";
+import { createMockToolContext } from "../../test-utils";
+
+describe("grepTool", () => {
+  describe("#given a content output mode search", () => {
+    describe("#when pattern matches files", () => {
+      it("#then returns matching lines with line numbers", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async (command: string[], _cwd: string) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "src/a.ts:1:const log = console.log\nsrc/b.ts:5:log(error)",
+            stderr: "",
+          };
+        });
+        const tool = createGrepTool(runner);
+        const ctx = createMockToolContext({ directory: "/repo" });
+
+        const result = await tool.execute(
+          { pattern: "log.*error", output_mode: "content", include: "*.ts" },
+          ctx,
+        );
+
+        expect(capturedCommand).toContain("--line-number");
+        expect(capturedCommand).toContain("--include=*.ts");
+        expect(capturedCommand).not.toContain("-l");
+        expect(capturedCommand).not.toContain("-c");
+        expect(result).toContain("src/a.ts:1:");
+        expect(result).toContain("src/b.ts:5:");
+      });
+    });
+  });
+
+  describe("#given a search with no matches", () => {
+    describe("#when grep exits with code 1", () => {
+      it("#then returns no matches found message", async () => {
+        const runner = mock(async (_command: string[], _cwd: string) => ({
+          exitCode: 1,
+          stdout: "",
+          stderr: "",
+        }));
+        const tool = createGrepTool(runner);
+        const ctx = createMockToolContext({ directory: "/repo" });
+
+        const result = await tool.execute({ pattern: "nonExistentPattern123" }, ctx);
+
+        expect(result).toBe("No matches found");
+      });
+    });
+  });
+
+  describe("#given a count output mode search", () => {
+    describe("#when pattern matches files", () => {
+      it("#then includes -c flag and returns count output", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async (command: string[], _cwd: string) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "src/a.ts:5\nsrc/b.ts:3",
+            stderr: "",
+          };
+        });
+        const tool = createGrepTool(runner);
+        const ctx = createMockToolContext({ directory: "/repo" });
+
+        const result = await tool.execute({ pattern: "import", output_mode: "count" }, ctx);
+
+        expect(capturedCommand).toContain("-c");
+        expect(capturedCommand).not.toContain("--line-number");
+        expect(capturedCommand).not.toContain("-l");
+        expect(result).toContain("src/a.ts:5");
+        expect(result).toContain("src/b.ts:3");
+      });
+    });
+  });
+});

package/src/tools/grep/handler.ts

@@ -0,0 +1,104 @@
+import { resolve } from "node:path";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { buildTool } from "../tool-builder";
+import { log } from "../../shared/logger";
+import type { GrepArgs, GrepOutput } from "./types";
+import { grepArgsSchema } from "./types";
+
+type CommandResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+
+export type GrepCommandRunner = (command: string[], cwd: string) => Promise<CommandResult>;
+
+async function runGrepCommand(command: string[], cwd: string): Promise<CommandResult> {
+  const process = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(process.stdout).text(),
+    new Response(process.stderr).text(),
+    process.exited,
+  ]);
+  return { exitCode, stdout, stderr };
+}
+
+function buildGrepCommand(args: GrepArgs, baseDirectory: string): string[] {
+  const outputMode = args.output_mode ?? "files_with_matches";
+  const targetDirectory = args.path ? resolve(baseDirectory, args.path) : baseDirectory;
+
+  const command = ["grep", "-R", "-E", "--binary-files=without-match"];
+  if (outputMode === "content") {
+    command.push("--line-number");
+  }
+  if (outputMode === "files_with_matches") {
+    command.push("-l");
+  }
+  if (outputMode === "count") {
+    command.push("-c");
+  }
+  if (args.include) {
+    command.push(`--include=${args.include}`);
+  }
+
+  command.push(args.pattern, targetDirectory);
+  return command;
+}
+
+function applyHeadLimit(output: string, headLimit: number): string {
+  if (headLimit <= 0) {
+    return output;
+  }
+  const lines = output.split("\n").filter((line) => line.length > 0);
+  return lines.slice(0, headLimit).join("\n");
+}
+
+export async function executeGrep(
+  args: GrepArgs,
+  context: { directory: string },
+  runner: GrepCommandRunner = runGrepCommand,
+): Promise<GrepOutput> {
+  const command = buildGrepCommand(args, context.directory);
+  log("grep executing", { command, directory: context.directory });
+
+  try {
+    const result = await runner(command, context.directory);
+    if (result.exitCode === 1) {
+      return "No matches found";
+    }
+
+    if (result.exitCode !== 0) {
+      const errorOutput = result.stderr.trim() || result.stdout.trim();
+      return `Error: ${errorOutput || "grep command failed"}`;
+    }
+
+    const normalized = result.stdout.trim();
+    if (normalized.length === 0) {
+      return "No matches found";
+    }
+
+    const output = applyHeadLimit(normalized, args.head_limit ?? 0);
+    return output.length > 0 ? output : "No matches found";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log("grep failed", { message });
+    return `Error: ${message}`;
+  }
+}
+
+export function createGrepTool(runner?: GrepCommandRunner): ToolDefinition {
+  return buildTool({
+    description:
+      "Fast content search tool with safety limits (60s timeout, 256KB output). " +
+      'Searches file contents using regular expressions. Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' +
+      'Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}"). ' +
+      'Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts per file.',
+    args: grepArgsSchema as unknown as ToolDefinition["args"],
+    execute: async (toolArgs, toolContext) =>
+      executeGrep(toolArgs as GrepArgs, toolContext, runner),
+  });
+}

package/src/tools/grep/index.ts

@@ -0,0 +1,2 @@
+export { grepPlugin } from "./plugin";
+export { createGrepTool, executeGrep } from "./handler";

package/src/tools/grep/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../plugin-api";
+import { createGrepTool } from "./handler";
+
+export const grepPlugin = definePlugin({
+  name: "grep",
+  version: "0.1.0",
+  tools: {
+    grep: createGrepTool(),
+  },
+});

package/src/tools/grep/types.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+export const grepOutputModes = ["content", "files_with_matches", "count"] as const;
+
+export const grepArgsSchema = {
+  pattern: z.string().describe("The regex pattern to search for in file contents"),
+  include: z
+    .string()
+    .optional()
+    .describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
+  path: z
+    .string()
+    .optional()
+    .describe("The directory to search in. Defaults to the current working directory."),
+  output_mode: z
+    .enum(grepOutputModes)
+    .optional()
+    .describe(
+      'Output mode: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts per file.',
+    ),
+  head_limit: z
+    .number()
+    .optional()
+    .describe("Limit output to first N entries. 0 or omitted means no limit."),
+};
+
+export type GrepArgs = z.infer<z.ZodObject<typeof grepArgsSchema>>;
+export type GrepOutput = string;

package/src/tools/hashline-edit/constants.ts

@@ -0,0 +1,10 @@
+export const NIBBLE_STR = "ZPMQVRWSNKTXJBYH";
+
+export const HASHLINE_DICT = Array.from({ length: 256 }, (_, i) => {
+  const high = i >>> 4;
+  const low = i & 0x0f;
+  return `${NIBBLE_STR[high]}${NIBBLE_STR[low]}`;
+});
+
+export const HASHLINE_REF_PATTERN = /^([0-9]+)#([ZPMQVRWSNKTXJBYH]{2})$/;
+export const HASHLINE_OUTPUT_PATTERN = /^([0-9]+)#([ZPMQVRWSNKTXJBYH]{2})\|(.*)$/;

package/src/tools/hashline-edit/edit-operations.ts

@@ -0,0 +1,115 @@
+import { computeLineHash } from "./hash-computation";
+import type { EditOperation, HashlineEdit, ParsedHashline } from "./types";
+
+const HASHLINE_OLD_STRING_PATTERN = /^([0-9]+)#([ZPMQVRWSNKTXJBYH]{2})\|(.*)$/;
+
+function splitLines(content: string): { lines: string[]; trailingNewline: boolean } {
+  if (content.length === 0) return { lines: [], trailingNewline: false };
+  const normalized = content.replace(/\r/g, "");
+  const trailingNewline = normalized.endsWith("\n");
+  const lines = normalized.split("\n");
+  if (trailingNewline) lines.pop();
+  return { lines, trailingNewline };
+}
+
+function joinLines(lines: string[], trailingNewline: boolean): string {
+  if (lines.length === 0) return "";
+  const joined = lines.join("\n");
+  return trailingNewline ? `${joined}\n` : joined;
+}
+
+function parseOldString(oldString: string): ParsedHashline {
+  const match = oldString.match(HASHLINE_OLD_STRING_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid oldString format: "${oldString}". Expected "LINE#ID|content"`);
+  }
+
+  return {
+    lineNumber: Number.parseInt(match[1], 10),
+    hash: match[2],
+    content: match[3],
+  };
+}
+
+function lineDistance(a: number, b: number): number {
+  return Math.abs(a - b);
+}
+
+function pickBestCandidate(candidates: number[], preferredLine: number): number {
+  if (candidates.length === 1) return candidates[0];
+  return [...candidates].sort(
+    (a, b) => lineDistance(a, preferredLine) - lineDistance(b, preferredLine),
+  )[0];
+}
+
+function resolveLineIndex(lines: string[], parsed: ParsedHashline, expectedHash: string): number {
+  const candidates: number[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] !== parsed.content) continue;
+    const actualHash = computeLineHash(i + 1, lines[i]);
+    if (actualHash === expectedHash) {
+      candidates.push(i);
+    }
+  }
+
+  if (candidates.length === 0) {
+    throw new Error(
+      `stale content: could not locate line matching hash ${expectedHash} and text "${parsed.content}"`,
+    );
+  }
+
+  return pickBestCandidate(candidates, parsed.lineNumber - 1);
+}
+
+export function planEditOperations(content: string, edits: HashlineEdit[]): EditOperation[] {
+  const { lines } = splitLines(content);
+  const operations: EditOperation[] = [];
+  const targetedLineIndexes = new Set<number>();
+
+  for (let i = 0; i < edits.length; i++) {
+    const edit = edits[i];
+    const parsed = parseOldString(edit.oldString);
+
+    if (parsed.hash !== edit.hash) {
+      throw new Error(
+        `stale content: hash mismatch for edit ${i} (oldString hash does not match hash field)`,
+      );
+    }
+
+    const lineIndex = resolveLineIndex(lines, parsed, edit.hash);
+    if (targetedLineIndexes.has(lineIndex)) {
+      throw new Error(`stale content: conflicting edits target the same line (${lineIndex + 1})`);
+    }
+
+    const actualHash = computeLineHash(lineIndex + 1, lines[lineIndex]);
+    if (actualHash !== edit.hash) {
+      throw new Error(`stale content: expected hash ${edit.hash} but found ${actualHash}`);
+    }
+
+    targetedLineIndexes.add(lineIndex);
+    operations.push({
+      editIndex: i,
+      lineIndex,
+      newLines: edit.newString.split("\n"),
+    });
+  }
+
+  return operations;
+}
+
+export function applyEditOperations(content: string, operations: EditOperation[]): string {
+  const { lines, trailingNewline } = splitLines(content);
+  const sorted = [...operations].sort((a, b) => b.lineIndex - a.lineIndex);
+
+  for (const operation of sorted) {
+    lines.splice(operation.lineIndex, 1, ...operation.newLines);
+  }
+
+  return joinLines(lines, trailingNewline);
+}
+
+export function applyHashlineEdits(content: string, edits: HashlineEdit[]): string {
+  const operations = planEditOperations(content, edits);
+  return applyEditOperations(content, operations);
+}

package/src/tools/hashline-edit/handler.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { computeLineHash, formatHashLine } from "./hash-computation";
+import { createMockToolContext } from "../../test-utils";
+import { executeHashlineEdit } from "./handler";
+import type { HashlineEditToolArgs } from "./types";
+
+describe("executeHashlineEdit", () => {
+  let tempDir: string;
+  let ctx: ReturnType<typeof createMockToolContext>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "hashline-handler-test-"));
+    ctx = createMockToolContext();
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("#given a file with valid hashline content", () => {
+    describe("#when a valid edit is applied", () => {
+      it("#then writes updated content and returns success message", async () => {
+        const filePath = join(tempDir, "test.txt");
+        const content = "alpha\nbeta\ngamma";
+        await writeFile(filePath, content, "utf8");
+
+        const hash = computeLineHash(2, "beta");
+        const args: HashlineEditToolArgs = {
+          filePath,
+          edits: [{ oldString: formatHashLine(2, "beta"), newString: "BETA", hash }],
+        };
+
+        const result = await executeHashlineEdit(args, ctx);
+
+        expect(result).toContain("Applied 1 hashline edit(s)");
+        expect(result).toContain(filePath);
+        const updated = await readFile(filePath, "utf8");
+        expect(updated).toBe("alpha\nBETA\ngamma");
+      });
+    });
+  });
+
+  describe("#given an edit that produces identical content", () => {
+    describe("#when executeHashlineEdit is called", () => {
+      it("#then returns 'No changes applied' and leaves content unchanged", async () => {
+        const filePath = join(tempDir, "test.txt");
+        const content = "alpha\nbeta\ngamma";
+        await writeFile(filePath, content, "utf8");
+
+        const hash = computeLineHash(2, "beta");
+        const args: HashlineEditToolArgs = {
+          filePath,
+          edits: [{ oldString: formatHashLine(2, "beta"), newString: "beta", hash }],
+        };
+
+        const result = await executeHashlineEdit(args, ctx);
+
+        expect(result).toBe("No changes applied");
+        const after = await readFile(filePath, "utf8");
+        expect(after).toBe(content);
+      });
+    });
+  });
+
+  describe("#given a nonexistent file path", () => {
+    describe("#when executeHashlineEdit is called", () => {
+      it("#then returns an error message", async () => {
+        const args: HashlineEditToolArgs = {
+          filePath: join(tempDir, "does-not-exist.txt"),
+          edits: [{ oldString: "1#ZZ|foo", newString: "bar", hash: "ZZ" }],
+        };
+
+        const result = await executeHashlineEdit(args, ctx);
+
+        expect(result).toStartWith("Error:");
+      });
+    });
+  });
+
+  describe("#given a stale hash that does not match file content", () => {
+    describe("#when executeHashlineEdit is called", () => {
+      it("#then returns a stale content error", async () => {
+        const filePath = join(tempDir, "test.txt");
+        const content = "alpha\nbeta\ngamma";
+        await writeFile(filePath, content, "utf8");
+
+        const realHash = computeLineHash(2, "beta");
+        const wrongHash = realHash === "ZZ" ? "PP" : "ZZ";
+
+        const args: HashlineEditToolArgs = {
+          filePath,
+          edits: [{ oldString: formatHashLine(2, "beta"), newString: "BETA", hash: wrongHash }],
+        };
+
+        const result = await executeHashlineEdit(args, ctx);
+
+        expect(result).toContain("Error:");
+        expect(result).toContain("stale content");
+      });
+    });
+  });
+});

package/src/tools/hashline-edit/handler.ts

@@ -0,0 +1,33 @@
+import { readFile, writeFile } from "node:fs/promises";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { log } from "../../shared/logger";
+import { applyHashlineEdits } from "./edit-operations";
+import type { HashlineEditToolArgs } from "./types";
+
+type ToolContext = Parameters<ToolDefinition["execute"]>[1];
+
+export async function executeHashlineEdit(
+  args: HashlineEditToolArgs,
+  _context: ToolContext,
+): Promise<string> {
+  log("hashline_edit.start", { filePath: args.filePath, editCount: args.edits.length });
+
+  try {
+    const existing = await readFile(args.filePath, "utf8");
+    const updated = applyHashlineEdits(existing, args.edits);
+
+    if (updated === existing) {
+      log("hashline_edit.noop", { filePath: args.filePath });
+      return "No changes applied";
+    }
+
+    await writeFile(args.filePath, updated, "utf8");
+    log("hashline_edit.success", { filePath: args.filePath, editCount: args.edits.length });
+
+    return `Applied ${args.edits.length} hashline edit(s) to ${args.filePath}`;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log("hashline_edit.error", { filePath: args.filePath, error: message });
+    return `Error: ${message}`;
+  }
+}

package/src/tools/hashline-edit/hash-computation.ts

@@ -0,0 +1,20 @@
+import { HASHLINE_DICT } from "./constants";
+
+const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+
+function computeNormalizedLineHash(lineNumber: number, normalizedContent: string): string {
+  const stripped = normalizedContent;
+  const seed = RE_SIGNIFICANT.test(stripped) ? 0 : lineNumber;
+  const hash = Bun.hash.xxHash32(stripped, seed);
+  const index = hash % 256;
+  return HASHLINE_DICT[index];
+}
+
+export function computeLineHash(lineNumber: number, content: string): string {
+  return computeNormalizedLineHash(lineNumber, content.replace(/\r/g, "").trimEnd());
+}
+
+export function formatHashLine(lineNumber: number, content: string): string {
+  const hash = computeLineHash(lineNumber, content);
+  return `${lineNumber}#${hash}|${content}`;
+}

package/src/tools/hashline-edit/hashline-edit.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "bun:test";
+import { applyHashlineEdits } from "./edit-operations";
+import { computeLineHash, formatHashLine } from "./hash-computation";
+import type { HashlineEdit } from "./types";
+
+describe("hashline_edit", () => {
+  describe("#given a matching hash for the targeted line", () => {
+    describe("#when applying one edit", () => {
+      it("#then it replaces the line successfully", () => {
+        const content = ["alpha", "beta", "gamma"].join("\n");
+        const edit: HashlineEdit = {
+          oldString: formatHashLine(2, "beta"),
+          newString: "BETA",
+          hash: computeLineHash(2, "beta"),
+        };
+
+        const result = applyHashlineEdits(content, [edit]);
+
+        expect(result).toBe(["alpha", "BETA", "gamma"].join("\n"));
+      });
+    });
+  });
+
+  describe("#given an incorrect hash", () => {
+    describe("#when applying an edit", () => {
+      it("#then it rejects with a stale content error", () => {
+        const content = ["alpha", "beta", "gamma"].join("\n");
+        const edit: HashlineEdit = {
+          oldString: formatHashLine(2, "beta"),
+          newString: "BETA",
+          hash: "ZZ",
+        };
+
+        expect(() => applyHashlineEdits(content, [edit])).toThrow("stale content");
+      });
+    });
+  });
+
+  describe("#given multiple valid edits", () => {
+    describe("#when applying them in one call", () => {
+      it("#then all edits are applied", () => {
+        const content = ["first", "second", "third", "fourth"].join("\n");
+        const edits: HashlineEdit[] = [
+          {
+            oldString: formatHashLine(2, "second"),
+            newString: "SECOND",
+            hash: computeLineHash(2, "second"),
+          },
+          {
+            oldString: formatHashLine(4, "fourth"),
+            newString: "FOURTH",
+            hash: computeLineHash(4, "fourth"),
+          },
+        ];
+
+        const result = applyHashlineEdits(content, edits);
+
+        expect(result).toBe(["first", "SECOND", "third", "FOURTH"].join("\n"));
+      });
+    });
+  });
+});