goatcode-sh 0.0.1 → 0.1.2

package/src/hooks/hashline-diff-enhancer/handler.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  createHashlineDiffEnhancerBeforeHandler,
+  createHashlineDiffEnhancerAfterHandler,
+  createHashlineDiffEnhancerHandlers,
+} from "./handler";
+
+const HASHLINE_PATTERN = /^[0-9]+#[ZPMQVRWSNKTXJBYH]{2}\|/;
+
+describe("createHashlineDiffEnhancerHandlers", () => {
+  describe("#given a Write tool that modifies an existing file", () => {
+    describe("#when before and after handlers both run", () => {
+      it("#then metadata contains diff, hashlined content, and filediff", async () => {
+        const beforeHandler = createHashlineDiffEnhancerBeforeHandler();
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-diff-"));
+        const filePath = path.join(tempDir, "test.ts");
+        fs.writeFileSync(filePath, "const a = 1\nconst b = 2\n");
+
+        const sessionID = "s1";
+        const callID = "c1";
+        const beforeInput = { tool: "write", sessionID, callID };
+        const beforeOutput = { args: { filePath } };
+
+        await beforeHandler(beforeInput, beforeOutput);
+
+        fs.writeFileSync(filePath, "const a = 1\nconst b = 2\nconst c = 3\n");
+
+        const afterInput = { tool: "write", sessionID, callID, args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeDefined();
+        expect(typeof afterOutput.metadata.diff).toBe("string");
+        expect(afterOutput.metadata.hashlined).toBeDefined();
+        const hashlined = afterOutput.metadata.hashlined as string;
+        expect(hashlined).toMatch(HASHLINE_PATTERN);
+        expect(afterOutput.metadata.filediff).toBeDefined();
+        expect(afterOutput.title).toBe(filePath);
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+
+  describe("#given a non-Write tool", () => {
+    describe("#when the before handler processes the input", () => {
+      it("#then does not capture any state and after handler is a no-op", async () => {
+        const beforeHandler = createHashlineDiffEnhancerBeforeHandler();
+        const input = { tool: "read", sessionID: "s1", callID: "c2" };
+        const output = { args: { filePath: "/some/file.ts" } };
+
+        await beforeHandler(input, output);
+
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+        const afterInput = { tool: "read", sessionID: "s1", callID: "c2", args: {} };
+        const afterOutput = {
+          title: "read",
+          output: "file content",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeUndefined();
+        expect(afterOutput.metadata.hashlined).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given after handler called without prior before capture", () => {
+    describe("#when a different callID is used", () => {
+      it("#then after handler produces no diff metadata", async () => {
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+        const afterInput = { tool: "write", sessionID: "s1", callID: "c-no-before", args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeUndefined();
+        expect(afterOutput.metadata.hashlined).toBeUndefined();
+        expect(afterOutput.title).toBe("write");
+      });
+    });
+  });
+
+  describe("#given a Write tool targeting a new file", () => {
+    describe("#when before captures empty content and after reads the written file", () => {
+      it("#then diff reflects all lines as additions", async () => {
+        const { before, after } = createHashlineDiffEnhancerHandlers();
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-diff-new-"));
+        const filePath = path.join(tempDir, "new-file.ts");
+
+        const sessionID = "s2";
+        const callID = "c3";
+        const beforeInput = { tool: "write", sessionID, callID };
+        const beforeOutput = { args: { filePath } };
+
+        await before(beforeInput, beforeOutput);
+
+        fs.writeFileSync(filePath, "line one\nline two\nline three\n");
+
+        const afterInput = { tool: "write", sessionID, callID, args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await after(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeDefined();
+        const diff = afterOutput.metadata.diff as string;
+        expect(diff).toContain("+3 additions");
+        expect(diff).toContain("-0 deletions");
+        expect(afterOutput.metadata.hashlined).toBeDefined();
+        expect(afterOutput.title).toBe(filePath);
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+
+  describe("#given missing sessionID or callID", () => {
+    describe("#when the before handler receives incomplete input", () => {
+      it("#then does not capture state", async () => {
+        const beforeHandler = createHashlineDiffEnhancerBeforeHandler();
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-diff-noid-"));
+        const filePath = path.join(tempDir, "test.ts");
+        fs.writeFileSync(filePath, "content\n");
+
+        const beforeInput = { tool: "write", sessionID: "", callID: "" };
+        const beforeOutput = { args: { filePath } };
+        await beforeHandler(beforeInput, beforeOutput);
+
+        const afterInput = { tool: "write", sessionID: "", callID: "", args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeUndefined();
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+});

package/src/hooks/hashline-diff-enhancer/handler.ts

@@ -0,0 +1,186 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+import { computeLineHash } from "../../tools/hashline-edit/hash-computation";
+
+const STALE_TIMEOUT_MS = 5 * 60 * 1000;
+
+type BeforeInput = { tool: string; sessionID: string; callID: string };
+type BeforeOutput = { args: Record<string, unknown> };
+type AfterInput = { tool: string; sessionID: string; callID: string };
+type AfterOutput = { title: string; output: string; metadata: Record<string, unknown> };
+
+type PreToolUseHook = NonNullable<PluginHookContributions["tool.execute.before"]>;
+type PostToolUseHook = NonNullable<PluginHookContributions["tool.execute.after"]>;
+
+interface PendingCapture {
+  content: string;
+  filePath: string;
+  storedAt: number;
+}
+
+const pendingCaptures = new Map<string, PendingCapture>();
+
+function makeKey(sessionID: string, callID: string): string {
+  return `${sessionID}:${callID}`;
+}
+
+function cleanupStaleEntries(): void {
+  const now = Date.now();
+  for (const [key, entry] of pendingCaptures) {
+    if (now - entry.storedAt > STALE_TIMEOUT_MS) {
+      pendingCaptures.delete(key);
+    }
+  }
+}
+
+function isWriteTool(toolName: string): boolean {
+  return toolName.toLowerCase() === "write";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function extractFilePath(args: Record<string, unknown>): string | undefined {
+  const path = args.path ?? args.filePath ?? args.file_path;
+  return typeof path === "string" ? path : undefined;
+}
+
+async function captureOldContent(filePath: string): Promise<string> {
+  try {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return await file.text();
+    }
+  } catch {
+    log("[hashline-diff-enhancer] failed to read old content", { filePath });
+  }
+  return "";
+}
+
+function toHashlineContent(content: string): string {
+  if (!content) return content;
+  const lines = content.split("\n");
+  const lastLine = lines[lines.length - 1];
+  const hasTrailingNewline = lastLine === "";
+  const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const hashlined = contentLines.map((line, i) => {
+    const lineNum = i + 1;
+    const hash = computeLineHash(lineNum, line);
+    return `${lineNum}#${hash}|${line}`;
+  });
+  return hasTrailingNewline ? hashlined.join("\n") + "\n" : hashlined.join("\n");
+}
+
+function buildSimpleDiff(oldContent: string, newContent: string, filePath: string): string {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+
+  const oldSet = new Map<string, number>();
+  for (const line of oldLines) {
+    oldSet.set(line, (oldSet.get(line) ?? 0) + 1);
+  }
+
+  const newSet = new Map<string, number>();
+  for (const line of newLines) {
+    newSet.set(line, (newSet.get(line) ?? 0) + 1);
+  }
+
+  let deletions = 0;
+  for (const [line, count] of oldSet) {
+    const newCount = newSet.get(line) ?? 0;
+    if (count > newCount) deletions += count - newCount;
+  }
+
+  let additions = 0;
+  for (const [line, count] of newSet) {
+    const oldCount = oldSet.get(line) ?? 0;
+    if (count > oldCount) additions += count - oldCount;
+  }
+
+  return `--- ${filePath}\n+++ ${filePath}\n@@ -${oldLines.length} lines +${newLines.length} lines @@\n+${additions} additions, -${deletions} deletions`;
+}
+
+export function createHashlineDiffEnhancerBeforeHandler(): PreToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const tool = input.tool;
+    if (typeof tool !== "string" || !isWriteTool(tool)) return;
+
+    const args = output.args;
+    if (!isRecord(args)) return;
+
+    const filePath = extractFilePath(args);
+    if (!filePath) return;
+
+    const sessionID = typeof input.sessionID === "string" ? input.sessionID : "";
+    const callID = typeof input.callID === "string" ? input.callID : "";
+    if (!sessionID || !callID) return;
+
+    cleanupStaleEntries();
+    const oldContent = await captureOldContent(filePath);
+    pendingCaptures.set(makeKey(sessionID, callID), {
+      content: oldContent,
+      filePath,
+      storedAt: Date.now(),
+    });
+  };
+}
+
+export function createHashlineDiffEnhancerAfterHandler(): PostToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const tool = input.tool;
+    if (typeof tool !== "string" || !isWriteTool(tool)) return;
+
+    const sessionID = typeof input.sessionID === "string" ? input.sessionID : "";
+    const callID = typeof input.callID === "string" ? input.callID : "";
+    if (!sessionID || !callID) return;
+
+    const key = makeKey(sessionID, callID);
+    const captured = pendingCaptures.get(key);
+    if (!captured) return;
+    pendingCaptures.delete(key);
+
+    const { content: oldContent, filePath } = captured;
+
+    let newContent: string;
+    try {
+      newContent = await Bun.file(filePath).text();
+    } catch {
+      log("[hashline-diff-enhancer] failed to read new content", { filePath });
+      return;
+    }
+
+    const metadata = output.metadata;
+    if (!isRecord(metadata)) return;
+
+    const diff = buildSimpleDiff(oldContent, newContent, filePath);
+    const hashlinedNew = toHashlineContent(newContent);
+
+    metadata.filediff = {
+      file: filePath,
+      path: filePath,
+      before: oldContent,
+      after: newContent,
+    };
+    metadata.diff = diff;
+    metadata.hashlined = hashlinedNew;
+
+    output.title = filePath as string;
+  };
+}
+
+export function createHashlineDiffEnhancerHandlers(): {
+  before: PreToolUseHook;
+  after: PostToolUseHook;
+} {
+  return {
+    before: createHashlineDiffEnhancerBeforeHandler(),
+    after: createHashlineDiffEnhancerAfterHandler(),
+  };
+}
+
+export type { BeforeInput, BeforeOutput, AfterInput, AfterOutput };

package/src/hooks/hashline-diff-enhancer/index.ts

@@ -0,0 +1,6 @@
+export { hashlineDiffEnhancerPlugin } from "./plugin";
+export {
+  createHashlineDiffEnhancerBeforeHandler,
+  createHashlineDiffEnhancerAfterHandler,
+  createHashlineDiffEnhancerHandlers,
+} from "./handler";

package/src/hooks/hashline-diff-enhancer/plugin.ts

@@ -0,0 +1,24 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import {
+  createHashlineDiffEnhancerBeforeHandler,
+  createHashlineDiffEnhancerAfterHandler,
+} from "./handler";
+
+const toolExecuteBeforeHook = safeCreateHook(
+  "hashline-diff-enhancer-before",
+  createHashlineDiffEnhancerBeforeHandler,
+);
+const toolExecuteAfterHook = safeCreateHook(
+  "hashline-diff-enhancer-after",
+  createHashlineDiffEnhancerAfterHandler,
+);
+
+export const hashlineDiffEnhancerPlugin = definePlugin({
+  name: "hashline-diff-enhancer",
+  version: "0.1.0",
+  hooks: {
+    ...(toolExecuteBeforeHook ? { "tool.execute.before": toolExecuteBeforeHook } : {}),
+    ...(toolExecuteAfterHook ? { "tool.execute.after": toolExecuteAfterHook } : {}),
+  },
+});

package/src/hooks/hashline-read-enhancer/handler.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createHashlineReadEnhancerHandler } from "./handler";
+
+const HASHLINE_PATTERN = /^[0-9]+#[ZPMQVRWSNKTXJBYH]{2}\|/;
+
+describe("createHashlineReadEnhancerHandler", () => {
+  describe("#given a Read tool output with content tags", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then prepends LINE#HASH| to each file line inside content tags", async () => {
+        const handler = createHashlineReadEnhancerHandler();
+        const input = { tool: "read", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "demo.ts",
+          output: [
+            "<path>/tmp/demo.ts</path>",
+            "<type>file</type>",
+            "<content>",
+            "1: const x = 1",
+            "2: const y = 2",
+            "</content>",
+          ].join("\n"),
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        const lines = output.output.split("\n");
+        expect(lines[3]).toMatch(HASHLINE_PATTERN);
+        expect(lines[3]).toContain("const x = 1");
+        expect(lines[4]).toMatch(HASHLINE_PATTERN);
+        expect(lines[4]).toContain("const y = 2");
+      });
+    });
+  });
+
+  describe("#given a Read tool output without content tags", () => {
+    describe("#when the handler processes plain numbered lines", () => {
+      it("#then hashifies each numbered line directly", async () => {
+        const handler = createHashlineReadEnhancerHandler();
+        const input = { tool: "read", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "README.md",
+          output: ["1: # Title", "2: Some content", "3: More content"].join("\n"),
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        const lines = output.output.split("\n");
+        expect(lines[0]).toMatch(HASHLINE_PATTERN);
+        expect(lines[0]).toContain("# Title");
+        expect(lines[1]).toMatch(HASHLINE_PATTERN);
+        expect(lines[2]).toMatch(HASHLINE_PATTERN);
+      });
+    });
+  });
+
+  describe("#given a non-Read tool", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then leaves the output unchanged", async () => {
+        const handler = createHashlineReadEnhancerHandler();
+        const input = { tool: "bash", sessionID: "s1", callID: "c1", args: {} };
+        const original = "1: some output";
+        const output = {
+          title: "bash",
+          output: original,
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toBe(original);
+      });
+    });
+  });
+
+  describe("#given a Read tool with empty output", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then returns the empty output unchanged", async () => {
+        const handler = createHashlineReadEnhancerHandler();
+        const input = { tool: "read", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "empty.ts",
+          output: "",
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toBe("");
+      });
+    });
+  });
+
+  describe("#given a Write tool with a valid file path", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then replaces output with a line count summary", async () => {
+        const handler = createHashlineReadEnhancerHandler();
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-read-write-"));
+        const filePath = path.join(tempDir, "demo.ts");
+        fs.writeFileSync(filePath, "const x = 1\nconst y = 2");
+        const input = { tool: "write", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "write",
+          output: "Wrote file successfully.",
+          metadata: { filepath: filePath },
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toContain("File written successfully.");
+        expect(output.output).toContain("2 lines written.");
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+});

package/src/hooks/hashline-read-enhancer/handler.ts

@@ -0,0 +1,165 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { computeLineHash } from "../../tools/hashline-edit/hash-computation";
+
+const WRITE_SUCCESS_MARKER = "File written successfully.";
+const COLON_READ_LINE_PATTERN = /^\s*(\d+): ?(.*)$/;
+const PIPE_READ_LINE_PATTERN = /^\s*(\d+)\| ?(.*)$/;
+const CONTENT_OPEN_TAG = "<content>";
+const CONTENT_CLOSE_TAG = "</content>";
+const FILE_OPEN_TAG = "<file>";
+const FILE_CLOSE_TAG = "</file>";
+const OPENCODE_LINE_TRUNCATION_SUFFIX = "... (line truncated to 2000 chars)";
+
+type PostToolUseHook = NonNullable<PluginHookContributions["tool.execute.after"]>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isReadTool(toolName: string): boolean {
+  return toolName.toLowerCase() === "read";
+}
+
+function isWriteTool(toolName: string): boolean {
+  return toolName.toLowerCase() === "write";
+}
+
+function isTextFile(output: string): boolean {
+  const firstLine = output.split("\n")[0] ?? "";
+  return COLON_READ_LINE_PATTERN.test(firstLine) || PIPE_READ_LINE_PATTERN.test(firstLine);
+}
+
+function parseReadLine(line: string): { lineNumber: number; content: string } | null {
+  const colonMatch = COLON_READ_LINE_PATTERN.exec(line);
+  if (colonMatch) {
+    return {
+      lineNumber: Number.parseInt(colonMatch[1], 10),
+      content: colonMatch[2] ?? "",
+    };
+  }
+
+  const pipeMatch = PIPE_READ_LINE_PATTERN.exec(line);
+  if (pipeMatch) {
+    return {
+      lineNumber: Number.parseInt(pipeMatch[1], 10),
+      content: pipeMatch[2] ?? "",
+    };
+  }
+
+  return null;
+}
+
+function transformLine(line: string): string {
+  const parsed = parseReadLine(line);
+  if (!parsed) return line;
+  if (parsed.content.endsWith(OPENCODE_LINE_TRUNCATION_SUFFIX)) return line;
+  const hash = computeLineHash(parsed.lineNumber, parsed.content);
+  return `${parsed.lineNumber}#${hash}|${parsed.content}`;
+}
+
+function transformOutput(output: string): string {
+  if (!output) return output;
+
+  const lines = output.split("\n");
+  const contentStart = lines.findIndex(
+    (line) => line === CONTENT_OPEN_TAG || line.startsWith(CONTENT_OPEN_TAG),
+  );
+  const contentEnd = lines.indexOf(CONTENT_CLOSE_TAG);
+  const fileStart = lines.findIndex(
+    (line) => line === FILE_OPEN_TAG || line.startsWith(FILE_OPEN_TAG),
+  );
+  const fileEnd = lines.indexOf(FILE_CLOSE_TAG);
+
+  const blockStart = contentStart !== -1 ? contentStart : fileStart;
+  const blockEnd = contentStart !== -1 ? contentEnd : fileEnd;
+  const openTag = contentStart !== -1 ? CONTENT_OPEN_TAG : FILE_OPEN_TAG;
+
+  if (blockStart !== -1 && blockEnd !== -1 && blockEnd > blockStart) {
+    const openLine = lines[blockStart] ?? "";
+    const inlineFirst =
+      openLine.startsWith(openTag) && openLine !== openTag ? openLine.slice(openTag.length) : null;
+    const fileLines =
+      inlineFirst !== null
+        ? [inlineFirst, ...lines.slice(blockStart + 1, blockEnd)]
+        : lines.slice(blockStart + 1, blockEnd);
+    if (!isTextFile(fileLines[0] ?? "")) return output;
+
+    const result: string[] = [];
+    for (const line of fileLines) {
+      if (!parseReadLine(line)) {
+        result.push(...fileLines.slice(result.length));
+        break;
+      }
+      result.push(transformLine(line));
+    }
+
+    const prefixLines =
+      inlineFirst !== null
+        ? [...lines.slice(0, blockStart), openTag]
+        : lines.slice(0, blockStart + 1);
+
+    return [...prefixLines, ...result, ...lines.slice(blockEnd)].join("\n");
+  }
+
+  if (!isTextFile(lines[0] ?? "")) return output;
+
+  const result: string[] = [];
+  for (const line of lines) {
+    if (!parseReadLine(line)) {
+      result.push(...lines.slice(result.length));
+      break;
+    }
+    result.push(transformLine(line));
+  }
+
+  return result.join("\n");
+}
+
+function extractFilePath(metadata: unknown): string | undefined {
+  if (!isRecord(metadata)) return undefined;
+  const candidates = [metadata.filepath, metadata.filePath, metadata.path, metadata.file];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return undefined;
+}
+
+async function appendWriteHashlineOutput(output: Record<string, unknown>): Promise<void> {
+  const outputStr = output.output;
+  if (typeof outputStr !== "string") return;
+  if (outputStr.startsWith(WRITE_SUCCESS_MARKER)) return;
+
+  const outputLower = outputStr.toLowerCase();
+  if (outputLower.startsWith("error") || outputLower.includes("failed")) return;
+
+  const filePath = extractFilePath(output.metadata);
+  if (!filePath) return;
+
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) return;
+
+  const content = await file.text();
+  const lines = content.split("\n");
+  const lineCount =
+    content === "" ? 0 : lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+  output.output = `${WRITE_SUCCESS_MARKER} ${lineCount} lines written.`;
+}
+
+export function createHashlineReadEnhancerHandler(): PostToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const tool = input.tool;
+    if (typeof tool !== "string") return;
+
+    if (isWriteTool(tool) && typeof output.output === "string") {
+      await appendWriteHashlineOutput(output);
+      return;
+    }
+
+    if (!isReadTool(tool)) return;
+    if (typeof output.output !== "string") return;
+
+    output.output = transformOutput(output.output);
+  };
+}

package/src/hooks/hashline-read-enhancer/index.ts

@@ -0,0 +1,2 @@
+export { hashlineReadEnhancerPlugin } from "./plugin";
+export { createHashlineReadEnhancerHandler } from "./handler";

package/src/hooks/hashline-read-enhancer/plugin.ts

@@ -0,0 +1,18 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createHashlineReadEnhancerHandler } from "./handler";
+
+const toolExecuteAfterHook = safeCreateHook(
+  "hashline-read-enhancer",
+  createHashlineReadEnhancerHandler,
+);
+
+export const hashlineReadEnhancerPlugin = definePlugin({
+  name: "hashline-read-enhancer",
+  version: "0.1.0",
+  hooks: toolExecuteAfterHook
+    ? {
+        "tool.execute.after": toolExecuteAfterHook,
+      }
+    : {},
+});