goatcode-sh 0.0.1 → 0.1.3

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,
+      }
+    : {},
+});

package/src/hooks/hook-composer.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "bun:test";
+
+import type { PluginHookHandler } from "../types/plugin";
+import { composeHooks } from "./hook-composer";
+
+describe("composeHooks", () => {
+  describe("#given 3 handlers", () => {
+    describe("#when composed and called", () => {
+      it("#then all 3 fire in order", async () => {
+        const calls: number[] = [];
+        const handler1: PluginHookHandler = async () => {
+          calls.push(1);
+        };
+        const handler2: PluginHookHandler = async () => {
+          calls.push(2);
+        };
+        const handler3: PluginHookHandler = async () => {
+          calls.push(3);
+        };
+
+        const composed = composeHooks("event", [handler1, handler2, handler3]);
+
+        await composed({}, {});
+
+        expect(calls).toEqual([1, 2, 3]);
+      });
+    });
+  });
+
+  describe("#given one handler throws", () => {
+    describe("#when composed with safe=true and called", () => {
+      it("#then other handlers still fire", async () => {
+        const calls: string[] = [];
+        const first: PluginHookHandler = async () => {
+          calls.push("first");
+        };
+        const failing: PluginHookHandler = async () => {
+          throw new Error("boom");
+        };
+        const last: PluginHookHandler = async () => {
+          calls.push("last");
+        };
+
+        const composed = composeHooks("event", [first, failing, last], { safe: true });
+
+        await composed({}, {});
+
+        expect(calls).toEqual(["first", "last"]);
+      });
+    });
+  });
+});

package/src/hooks/hook-composer.ts

@@ -0,0 +1,17 @@
+import type { PluginHookHandler } from "../types/plugin";
+import { wrapSafely } from "./safe-hook-wrapper";
+
+export function composeHooks(
+  eventName: string,
+  handlers: PluginHookHandler[],
+  options?: { safe?: boolean },
+): PluginHookHandler {
+  const wrapped =
+    options?.safe !== false ? handlers.map((h) => wrapSafely(eventName, h)) : handlers;
+
+  return async (input: unknown, output: unknown) => {
+    for (const handler of wrapped) {
+      await handler(input, output);
+    }
+  };
+}

package/src/hooks/hook-composition.integration.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from "bun:test";
+
+import { EDIT_ERROR_RECOVERY_MESSAGE } from "./edit-error/handler";
+import { composeHooks } from "./hook-composer";
+import { withPriority } from "./hook-ordering";
+import { HOOK_TIERS, type HookTier } from "./hook-types";
+import { clearSessionMode, createKeywordDetectorHandler } from "./keyword-detector/handler";
+import { createThinkModeHandler } from "./think-mode/handler";
+import { aggregateHooks } from "../registry/hook-aggregator";
+import type { PluginDefinition, PluginHookHandler } from "../types/plugin";
+
+const TIER_PRIORITIES: Record<HookTier, number> = {
+  config: 0,
+  message: 10,
+  transform: 20,
+  event: 30,
+  tool: 40,
+};
+
+function getTierPriority(eventName: string): number {
+  const tier = HOOK_TIERS[eventName as keyof typeof HOOK_TIERS];
+  return tier ? TIER_PRIORITIES[tier] : 100;
+}
+
+async function runAggregatedHooksByTier(
+  hookMap: Map<string, PluginHookHandler[]>,
+  ioByEvent: Record<string, { input: unknown; output: unknown }>,
+): Promise<void> {
+  const orderedEvents = [...hookMap.entries()].sort(
+    ([eventA], [eventB]) => getTierPriority(eventA) - getTierPriority(eventB),
+  );
+
+  for (const [eventName, handlers] of orderedEvents) {
+    const composed = composeHooks(eventName, handlers);
+    const io = ioByEvent[eventName] ?? { input: {}, output: {} };
+    await composed(io.input, io.output);
+  }
+}
+
+describe("hook composition integration", () => {
+  describe("#given hooks across config/message/tool tiers", () => {
+    describe("#when hooks are aggregated and executed by tier priority", () => {
+      it("#then config fires before message, and message before tool", async () => {
+        const calls: string[] = [];
+
+        const plugins: PluginDefinition[] = [
+          {
+            name: "config-plugin",
+            hooks: {
+              config: async () => {
+                calls.push("config");
+              },
+            },
+          },
+          {
+            name: "message-plugin",
+            hooks: {
+              "chat.message": async () => {
+                calls.push("message");
+              },
+            },
+          },
+          {
+            name: "tool-plugin",
+            hooks: {
+              "tool.execute.before": async () => {
+                calls.push("tool");
+              },
+            },
+          },
+        ];
+
+        const aggregated = aggregateHooks(plugins);
+        await runAggregatedHooksByTier(aggregated, {
+          config: { input: {}, output: {} },
+          "chat.message": { input: {}, output: {} },
+          "tool.execute.before": { input: {}, output: {} },
+        });
+
+        expect(calls).toEqual(["config", "message", "tool"]);
+      });
+    });
+  });
+
+  describe("#given two handlers in the same tier and event", () => {
+    describe("#when one handler has lower explicit priority", () => {
+      it("#then the lower-priority-number handler fires first", async () => {
+        const calls: string[] = [];
+
+        const earlyHandler = withPriority(async () => {
+          calls.push("early");
+        }, -1);
+
+        const aggregated = aggregateHooks([
+          {
+            name: "normal-message-plugin",
+            hooks: {
+              "chat.message": async () => {
+                calls.push("normal");
+              },
+            },
+          },
+          {
+            name: "early-message-plugin",
+            hooks: { "chat.message": earlyHandler },
+          },
+        ]);
+
+        const handlers = aggregated.get("chat.message") ?? [];
+        const composed = composeHooks("chat.message", handlers);
+
+        await composed({}, {});
+
+        expect(calls).toEqual(["early", "normal"]);
+      });
+    });
+  });
+
+  describe("#given multiple hooks mutating the same output field", () => {
+    describe("#when both handlers append to output.output", () => {
+      it("#then both mutations are accumulated in sequence", async () => {
+        const plugins: PluginDefinition[] = [
+          {
+            name: "append-a",
+            hooks: {
+              "tool.execute.after": async (_input, output) => {
+                if (typeof output === "object" && output !== null && "output" in output) {
+                  const current = output.output;
+                  if (typeof current === "string") {
+                    output.output = `${current}\n[A]`;
+                  }
+                }
+              },
+            },
+          },
+          {
+            name: "append-b",
+            hooks: {
+              "tool.execute.after": async (_input, output) => {
+                if (typeof output === "object" && output !== null && "output" in output) {
+                  const current = output.output;
+                  if (typeof current === "string") {
+                    output.output = `${current}\n[B]`;
+                  }
+                }
+              },
+            },
+          },
+        ];
+
+        const aggregated = aggregateHooks(plugins);
+        const handlers = aggregated.get("tool.execute.after") ?? [];
+        const composed = composeHooks("tool.execute.after", handlers);
+
+        const input = {
+          tool: "bash",
+          sessionID: "ses_accumulate",
+          callID: "call_accumulate",
+          args: {},
+        };
+        const output = { output: "base", title: "tool execution", metadata: {} };
+        await composed(input, output);
+
+        expect(output.output).toBe("base\n[A]\n[B]");
+      });
+    });
+  });
+
+  describe("#given keyword-detector and think-mode handlers", () => {
+    describe("#when a message enables think mode for a session", () => {
+      it("#then chat.params composition reads shared session state and injects thinking", async () => {
+        const sessionID = "ses_hook_chain";
+        clearSessionMode(sessionID);
+
+        const keywordHandler = createKeywordDetectorHandler();
+        const thinkModeHandler = createThinkModeHandler();
+
+        const messageInput = { sessionID };
+        const messageOutput = {
+          message: {},
+          parts: [{ type: "text", text: "Please deep-think this architecture change." }],
+        };
+
+        await keywordHandler(messageInput, messageOutput);
+
+        const paramsInput = {
+          sessionID,
+          agent: "sisyphus",
+          model: {
+            providerID: "anthropic",
+            modelID: "claude-3-7-sonnet",
+          },
+          provider: { id: "anthropic" },
+          message: {},
+        };
+        const paramsOutput = {
+          temperature: 0.1,
+          topP: 1,
+          topK: 0,
+          options: {},
+        };
+
+        await thinkModeHandler(paramsInput, paramsOutput);
+
+        expect(paramsOutput.options).toEqual({
+          thinking: {
+            type: "enabled",
+            budget_tokens: 10000,
+          },
+        });
+
+        clearSessionMode(sessionID);
+      });
+    });
+  });
+
+  describe("#given two hooks that both append guidance to tool output", () => {
+    describe("#when composed handlers run on an edit failure payload", () => {
+      it("#then truncation notice and edit recovery guidance are both preserved", async () => {
+        const plugins: PluginDefinition[] = [
+          {
+            name: "tool-output-truncator-like",
+            hooks: {
+              "tool.execute.after": async (_input, output) => {
+                if (typeof output === "object" && output !== null && "output" in output) {
+                  const current = output.output;
+                  if (typeof current === "string") {
+                    output.output = `${current}\n[Output truncated: synthetic notice for integration test.]`;
+                  }
+                }
+              },
+            },
+          },
+          {
+            name: "edit-error-like",
+            hooks: {
+              "tool.execute.after": async (_input, output) => {
+                if (typeof output === "object" && output !== null && "output" in output) {
+                  const current = output.output;
+                  if (typeof current === "string" && /oldstring not found/i.test(current)) {
+                    output.output = `${current}\n${EDIT_ERROR_RECOVERY_MESSAGE}`;
+                  }
+                }
+              },
+            },
+          },
+        ];
+
+        const handlers = aggregateHooks(plugins).get("tool.execute.after") ?? [];
+        const composed = composeHooks("tool.execute.after", handlers);
+
+        const input = {
+          tool: "edit",
+          sessionID: "ses_dual_mutation",
+          callID: "call_dual_mutation",
+          args: {},
+        };
+        const output = {
+          output: "oldString not found while applying patch",
+          title: "tool execution",
+          metadata: {},
+        };
+
+        await composed(input, output);
+
+        expect(typeof output.output).toBe("string");
+        expect(output.output).toContain(
+          "[Output truncated: synthetic notice for integration test.]",
+        );
+        expect(output.output).toContain(EDIT_ERROR_RECOVERY_MESSAGE);
+      });
+    });
+  });
+});

package/src/hooks/hook-ordering.ts

@@ -0,0 +1,41 @@
+import type { PluginHookHandler } from "../types/plugin";
+
+const HOOK_PRIORITY_SYMBOL = Symbol.for("goatcode.hookPriority");
+
+export type PrioritizedHandler = {
+  handler: PluginHookHandler;
+  priority: number;
+  order: number;
+};
+
+export function sortByPriority(handlers: PrioritizedHandler[]): PluginHookHandler[] {
+  return [...handlers]
+    .sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return a.priority - b.priority;
+      }
+      return a.order - b.order;
+    })
+    .map((h) => h.handler);
+}
+
+export function getHookPriority(handler: PluginHookHandler): number {
+  const value = (handler as PluginHookHandler & { [HOOK_PRIORITY_SYMBOL]?: unknown })[
+    HOOK_PRIORITY_SYMBOL
+  ];
+  return typeof value === "number" ? value : 0;
+}
+
+export function withPriority<T extends PluginHookHandler>(handler: T, priority: number): T {
+  const wrapped = function (this: unknown, ...args: unknown[]) {
+    return (handler as (...args: unknown[]) => unknown).apply(this, args);
+  } as T;
+
+  Object.defineProperty(wrapped, HOOK_PRIORITY_SYMBOL, {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: priority,
+  });
+  return wrapped;
+}