goatcode-sh 0.0.1 → 0.1.3

package/src/hooks/context-injection.test.ts

@@ -0,0 +1,124 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  createAgentsInjectorHandler,
+  createReadmeInjectorHandler,
+  createRulesInjectorHandler,
+} from "./context-injector";
+import {
+  createCompactionContextEventHandler,
+  createCompactionContextSystemTransformHandler,
+} from "./compaction-context";
+
+const tempDirectories: string[] = [];
+
+function createWorkspace(): string {
+  const workspace = mkdtempSync(join(tmpdir(), "goatcode-hooks-"));
+  tempDirectories.push(workspace);
+  return workspace;
+}
+
+afterEach(() => {
+  for (const directory of tempDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+describe("context injection hooks", () => {
+  describe("#given a Read tool output in nested directories", () => {
+    describe("#when agents-injector runs", () => {
+      it("#then it appends AGENTS.md context from parent directories", async () => {
+        const workspace = createWorkspace();
+        const nested = join(workspace, "src", "feature");
+        const targetFile = join(nested, "handler.ts");
+        mkdirSync(nested, { recursive: true });
+
+        writeFileSync(join(workspace, "AGENTS.md"), "root-agent-rules");
+        writeFileSync(join(workspace, "src", "AGENTS.md"), "src-agent-rules");
+        writeFileSync(targetFile, "export {}");
+
+        const handler = createAgentsInjectorHandler(workspace);
+        const output = {
+          title: targetFile,
+          output: "file-content",
+        };
+
+        await handler({ tool: "Read" }, output);
+
+        expect(output.output).toContain("root-agent-rules");
+        expect(output.output).toContain("src-agent-rules");
+      });
+    });
+  });
+
+  describe("#given a Read tool output with a sibling README", () => {
+    describe("#when readme-injector runs", () => {
+      it("#then it appends README.md content", async () => {
+        const workspace = createWorkspace();
+        const docsDir = join(workspace, "docs");
+        mkdirSync(docsDir, { recursive: true });
+        writeFileSync(join(docsDir, "README.md"), "docs-readme");
+        writeFileSync(join(docsDir, "guide.md"), "guide");
+
+        const handler = createReadmeInjectorHandler(workspace);
+        const output = {
+          title: join(docsDir, "guide.md"),
+          output: "guide-content",
+        };
+
+        await handler({ tool: "read" }, output);
+
+        expect(output.output).toContain("docs-readme");
+      });
+    });
+  });
+
+  describe("#given workspace rule files", () => {
+    describe("#when rules-injector runs", () => {
+      it("#then it appends .rules and RULES.md to system text", async () => {
+        const workspace = createWorkspace();
+        writeFileSync(join(workspace, ".rules"), "dot-rules");
+        writeFileSync(join(workspace, "RULES.md"), "markdown-rules");
+
+        const handler = createRulesInjectorHandler(workspace);
+        const output = { system: "base-system" };
+
+        await handler({}, output);
+
+        expect(output.system).toContain("dot-rules");
+        expect(output.system).toContain("markdown-rules");
+      });
+    });
+  });
+
+  describe("#given compaction with todo and plan files", () => {
+    describe("#when compaction-context processes event then system transform", () => {
+      it("#then it injects preserved context for the compacted session", async () => {
+        const workspace = createWorkspace();
+        const plansDir = join(workspace, ".sisyphus", "plans");
+        mkdirSync(plansDir, { recursive: true });
+        writeFileSync(join(workspace, ".sisyphus", "todos.md"), "- [ ] do thing");
+        writeFileSync(join(plansDir, "active.md"), "# Active Plan");
+
+        const snapshots = new Map<string, string>();
+        const eventHandler = createCompactionContextEventHandler(workspace, snapshots);
+        const transformHandler = createCompactionContextSystemTransformHandler(snapshots);
+
+        await eventHandler({
+          event: {
+            type: "session.compacted",
+            properties: { sessionID: "session-1" },
+          },
+        });
+
+        const output = { system: "base-system" };
+        await transformHandler({ sessionID: "session-1" }, output);
+
+        expect(output.system).toContain("Current Todos");
+        expect(output.system).toContain("Active Plan");
+      });
+    });
+  });
+});

package/src/hooks/context-injector/handlers/agents.test.ts

@@ -0,0 +1,140 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createAgentsInjectorHandler } from "./agents";
+
+const tempDirectories: string[] = [];
+
+function createWorkspace(): string {
+  const workspace = mkdtempSync(join(tmpdir(), "goatcode-agents-"));
+  tempDirectories.push(workspace);
+  return workspace;
+}
+
+afterEach(() => {
+  for (const directory of tempDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+describe("createAgentsInjectorHandler", () => {
+  describe("#given a read tool with AGENTS.md in parent directories", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then it appends AGENTS.md content to the output", async () => {
+        const workspace = createWorkspace();
+        const subDir = join(workspace, "src");
+        mkdirSync(subDir, { recursive: true });
+        writeFileSync(join(workspace, "AGENTS.md"), "root-agent-rules");
+        writeFileSync(join(subDir, "file.ts"), "export {}");
+
+        const handler = createAgentsInjectorHandler(workspace);
+        const output = { title: join(subDir, "file.ts"), output: "original-content" };
+
+        await handler({ tool: "read" }, output);
+
+        expect(output.output).toContain("root-agent-rules");
+        expect(output.output).toContain("[Directory Context:");
+      });
+    });
+  });
+
+  describe("#given a non-read tool", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then it does not modify the output", async () => {
+        const workspace = createWorkspace();
+        writeFileSync(join(workspace, "AGENTS.md"), "root-agent-rules");
+
+        const handler = createAgentsInjectorHandler(workspace);
+        const output = { title: join(workspace, "file.ts"), output: "original-content" };
+
+        await handler({ tool: "bash" }, output);
+
+        expect(output.output).toBe("original-content");
+      });
+    });
+  });
+
+  describe("#given a read tool with no AGENTS.md files", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then it leaves the output unchanged", async () => {
+        const workspace = createWorkspace();
+        const subDir = join(workspace, "src");
+        mkdirSync(subDir, { recursive: true });
+        writeFileSync(join(subDir, "file.ts"), "export {}");
+
+        const handler = createAgentsInjectorHandler(workspace);
+        const output = { title: join(subDir, "file.ts"), output: "original-content" };
+
+        await handler({ tool: "read" }, output);
+
+        expect(output.output).toBe("original-content");
+      });
+    });
+  });
+
+  describe("#given a read tool with no title", () => {
+    describe("#when the handler processes the output", () => {
+      it("#then it does not modify the output", async () => {
+        const workspace = createWorkspace();
+
+        const handler = createAgentsInjectorHandler(workspace);
+        const output = { output: "original-content" };
+
+        await handler({ tool: "read" }, output);
+
+        expect(output.output).toBe("original-content");
+      });
+    });
+  });
+
+  describe("#given repeated reads from the same AGENTS.md scope", () => {
+    describe("#when the same AGENTS.md would be injected twice in one session", () => {
+      it("#then injects full content once and a back-reference on subsequent reads", async () => {
+        const workspace = createWorkspace();
+        const subDir = join(workspace, "src");
+        mkdirSync(subDir, { recursive: true });
+        writeFileSync(join(workspace, "AGENTS.md"), "root-agent-rules");
+        writeFileSync(join(subDir, "file1.ts"), "export {}");
+        writeFileSync(join(subDir, "file2.ts"), "export {}");
+
+        const handler = createAgentsInjectorHandler(workspace);
+
+        // First read — full content injected
+        const output1 = { title: join(subDir, "file1.ts"), output: "content1" };
+        await handler({ tool: "read", sessionID: "ses1" }, output1);
+        expect(output1.output).toContain("root-agent-rules");
+        expect(output1.output).not.toContain("see full AGENTS.md injected above");
+
+        // Second read in same session — back-reference only
+        const output2 = { title: join(subDir, "file2.ts"), output: "content2" };
+        await handler({ tool: "read", sessionID: "ses1" }, output2);
+        expect(output2.output).toContain("see full AGENTS.md injected above");
+        expect(output2.output).not.toContain("root-agent-rules");
+      });
+    });
+
+    describe("#when a different session reads the same file", () => {
+      it("#then injects full content again for the new session", async () => {
+        const workspace = createWorkspace();
+        const subDir = join(workspace, "src");
+        mkdirSync(subDir, { recursive: true });
+        writeFileSync(join(workspace, "AGENTS.md"), "root-agent-rules");
+        writeFileSync(join(subDir, "file1.ts"), "export {}");
+
+        const handler = createAgentsInjectorHandler(workspace);
+
+        // Session 1 read — full content
+        const output1 = { title: join(subDir, "file1.ts"), output: "content1" };
+        await handler({ tool: "read", sessionID: "ses1" }, output1);
+        expect(output1.output).toContain("root-agent-rules");
+
+        // Session 2 read — full content again (not a back-reference)
+        const output2 = { title: join(subDir, "file1.ts"), output: "content2" };
+        await handler({ tool: "read", sessionID: "ses2" }, output2);
+        expect(output2.output).toContain("root-agent-rules");
+        expect(output2.output).not.toContain("see full AGENTS.md injected above");
+      });
+    });
+  });
+});

package/src/hooks/context-injector/handlers/agents.ts

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { log } from "../../../shared/logger";
+
+type ToolExecuteAfterInput = {
+  tool?: string;
+  sessionID?: string;
+};
+
+type ToolExecuteAfterOutput = {
+  title?: string;
+  output?: string;
+};
+
+function resolveReadPath(workspaceDirectory: string, title?: string): string | null {
+  if (!title) {
+    return null;
+  }
+
+  if (isAbsolute(title)) {
+    return title;
+  }
+
+  return resolve(workspaceDirectory, title);
+}
+
+function collectAgentsPaths(fileDirectory: string, workspaceDirectory: string): string[] {
+  const paths: string[] = [];
+  let current = fileDirectory;
+
+  while (true) {
+    const agentsPath = join(current, "AGENTS.md");
+    if (existsSync(agentsPath)) {
+      paths.push(agentsPath);
+    }
+
+    if (current === workspaceDirectory) {
+      break;
+    }
+
+    const parent = dirname(current);
+    if (parent === current || !parent.startsWith(workspaceDirectory)) {
+      break;
+    }
+
+    current = parent;
+  }
+
+  return paths.reverse();
+}
+
+export function createAgentsInjectorHandler(workspaceDirectory: string) {
+  // Track which AGENTS.md files have been fully injected per session
+  // to avoid repeating hundreds of lines of context on every read call.
+  // Keyed by sessionID so dedup resets correctly across sessions.
+  const injectedBySession = new Map<string, Set<string>>();
+
+  return async (input: unknown, output: unknown): Promise<void> => {
+    const typedInput = input as ToolExecuteAfterInput;
+    const typedOutput = output as ToolExecuteAfterOutput;
+
+    const toolName = typedInput.tool?.toLowerCase();
+    if (toolName !== "read") {
+      return;
+    }
+
+    const filePath = resolveReadPath(workspaceDirectory, typedOutput.title);
+    if (!filePath || typeof typedOutput.output !== "string") {
+      return;
+    }
+
+    const sessionKey = typedInput.sessionID ?? "__default";
+    let injectedPaths = injectedBySession.get(sessionKey);
+    if (!injectedPaths) {
+      injectedPaths = new Set<string>();
+      injectedBySession.set(sessionKey, injectedPaths);
+    }
+
+    const fileDirectory = dirname(filePath);
+    const agentsPaths = collectAgentsPaths(fileDirectory, workspaceDirectory);
+
+    for (const agentsPath of agentsPaths) {
+      if (injectedPaths.has(agentsPath)) {
+        // Already injected full content in this session — append a short back-reference only
+        typedOutput.output += `\n\n[Directory Context: ${agentsPath} — see full AGENTS.md injected above]`;
+        continue;
+      }
+
+      try {
+        const content = readFileSync(agentsPath, "utf8");
+        typedOutput.output += `\n\n[Directory Context: ${agentsPath}]\n${content}`;
+        injectedPaths.add(agentsPath);
+      } catch (error) {
+        log("[agents-injector] Failed to read AGENTS.md", {
+          agentsPath,
+          error: String(error),
+        });
+      }
+    }
+  };
+}

package/src/hooks/context-injector/handlers/readme.ts

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { log } from "../../../shared/logger";
+
+type ToolExecuteAfterInput = {
+  tool?: string;
+};
+
+type ToolExecuteAfterOutput = {
+  title?: string;
+  output?: string;
+};
+
+function resolveReadPath(workspaceDirectory: string, title?: string): string | null {
+  if (!title) {
+    return null;
+  }
+
+  if (isAbsolute(title)) {
+    return title;
+  }
+
+  return resolve(workspaceDirectory, title);
+}
+
+export function createReadmeInjectorHandler(workspaceDirectory: string) {
+  return async (input: unknown, output: unknown): Promise<void> => {
+    const typedInput = input as ToolExecuteAfterInput;
+    const typedOutput = output as ToolExecuteAfterOutput;
+
+    if (typedInput.tool?.toLowerCase() !== "read") {
+      return;
+    }
+
+    const filePath = resolveReadPath(workspaceDirectory, typedOutput.title);
+    if (!filePath || typeof typedOutput.output !== "string") {
+      return;
+    }
+
+    const readmePath = join(dirname(filePath), "README.md");
+    if (!existsSync(readmePath)) {
+      return;
+    }
+
+    try {
+      const content = readFileSync(readmePath, "utf8");
+      typedOutput.output += `\n\n[Project README: ${readmePath}]\n${content}`;
+    } catch (error) {
+      log("[readme-injector] Failed to read README.md", {
+        readmePath,
+        error: String(error),
+      });
+    }
+  };
+}

package/src/hooks/context-injector/handlers/rules.ts

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "../../../shared/logger";
+
+type SystemTransformOutput = {
+  system?: string;
+  prompt?: string;
+  text?: string;
+  content?: string;
+};
+
+function appendToSystemOutput(output: SystemTransformOutput, injection: string): void {
+  if (typeof output.system === "string") {
+    output.system += injection;
+    return;
+  }
+
+  if (typeof output.prompt === "string") {
+    output.prompt += injection;
+    return;
+  }
+
+  if (typeof output.text === "string") {
+    output.text += injection;
+    return;
+  }
+
+  if (typeof output.content === "string") {
+    output.content += injection;
+  }
+}
+
+function collectRuleFiles(workspaceDirectory: string): string[] {
+  const candidates = [join(workspaceDirectory, ".rules"), join(workspaceDirectory, "RULES.md")];
+  return candidates.filter((path) => existsSync(path));
+}
+
+export function createRulesInjectorHandler(workspaceDirectory: string) {
+  return async (_input: unknown, output: unknown): Promise<void> => {
+    const typedOutput = output as SystemTransformOutput;
+    const ruleFiles = collectRuleFiles(workspaceDirectory);
+
+    if (ruleFiles.length === 0) {
+      return;
+    }
+
+    let injection = "\n\n[Injected Rules]\n";
+    for (const ruleFile of ruleFiles) {
+      try {
+        const content = readFileSync(ruleFile, "utf8");
+        injection += `\n[Rule: ${ruleFile}]\n${content}\n`;
+      } catch (error) {
+        log("[rules-injector] Failed to read rules file", {
+          ruleFile,
+          error: String(error),
+        });
+      }
+    }
+
+    appendToSystemOutput(typedOutput, injection);
+  };
+}

package/src/hooks/context-injector/index.ts

@@ -0,0 +1,4 @@
+export { contextInjectorPlugin } from "./plugin";
+export { createAgentsInjectorHandler } from "./handlers/agents";
+export { createReadmeInjectorHandler } from "./handlers/readme";
+export { createRulesInjectorHandler } from "./handlers/rules";

package/src/hooks/context-injector/plugin.ts

@@ -0,0 +1,56 @@
+import type { PluginHookContributions } from "../../types/hook";
+import type { OpenCodeContext } from "../../types/plugin";
+import { definePlugin } from "../../plugin-api";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createAgentsInjectorHandler } from "./handlers/agents";
+import { createReadmeInjectorHandler } from "./handlers/readme";
+import { createRulesInjectorHandler } from "./handlers/rules";
+
+let agentsToolAfterHandler: PluginHookContributions["tool.execute.after"] | null = null;
+let readmeToolAfterHandler: PluginHookContributions["tool.execute.after"] | null = null;
+let rulesTransformHandler: PluginHookContributions["experimental.chat.system.transform"] | null =
+  null;
+
+const combinedToolAfterHandler: PluginHookContributions["tool.execute.after"] = async (
+  input,
+  output,
+) => {
+  if (agentsToolAfterHandler) {
+    await agentsToolAfterHandler(input, output);
+  }
+
+  if (readmeToolAfterHandler) {
+    await readmeToolAfterHandler(input, output);
+  }
+};
+
+const rulesHandler: PluginHookContributions["experimental.chat.system.transform"] = async (
+  input,
+  output,
+) => {
+  if (!rulesTransformHandler) {
+    return;
+  }
+
+  await rulesTransformHandler(input, output);
+};
+
+export const contextInjectorPlugin = definePlugin({
+  name: "context-injector",
+  version: "0.2.0",
+  setup: (ctx: OpenCodeContext) => {
+    agentsToolAfterHandler = safeCreateHook("agents-injector", () =>
+      createAgentsInjectorHandler(ctx.directory),
+    );
+    readmeToolAfterHandler = safeCreateHook("readme-injector", () =>
+      createReadmeInjectorHandler(ctx.directory),
+    );
+    rulesTransformHandler = safeCreateHook("rules-injector", () =>
+      createRulesInjectorHandler(ctx.directory),
+    );
+  },
+  hooks: {
+    "tool.execute.after": combinedToolAfterHandler,
+    "experimental.chat.system.transform": rulesHandler,
+  },
+});

package/src/hooks/context-window-limit/handler.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "bun:test";
+
+import { createContextWindowLimitHandler, CONTEXT_WINDOW_LIMIT_RECOVERY_MESSAGE } from "./handler";
+
+type UnknownHandler = (input: unknown) => Promise<void>;
+
+describe("createContextWindowLimitHandler", () => {
+  describe("#given a handler instance", () => {
+    const handler = createContextWindowLimitHandler() as unknown as UnknownHandler;
+
+    describe("#when event is session.error with token limit error", () => {
+      it("#then sets recoveryActions and recoveryContext", async () => {
+        const properties: Record<string, unknown> = { error: "token limit exceeded" };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryActions).toEqual(["compact", "summarize"]);
+        expect(properties.recoveryContext).toBe(CONTEXT_WINDOW_LIMIT_RECOVERY_MESSAGE);
+      });
+    });
+
+    describe("#when event is session.error with 'context window' error", () => {
+      it("#then sets recoveryActions and recoveryContext", async () => {
+        const properties: Record<string, unknown> = { error: "context window exceeded" };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryActions).toEqual(["compact", "summarize"]);
+        expect(properties.recoveryContext).toContain("[CONTEXT WINDOW LIMIT RECOVERY]");
+      });
+    });
+
+    describe("#when event is session.idle with contextWindowUsage >= 0.9", () => {
+      it("#then sets recoveryActions and recoveryContext", async () => {
+        const properties: Record<string, unknown> = { contextWindowUsage: 0.95 };
+        const input = {
+          event: { type: "session.idle", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryActions).toEqual(["compact", "summarize"]);
+        expect(properties.recoveryContext).toBe(CONTEXT_WINDOW_LIMIT_RECOVERY_MESSAGE);
+      });
+    });
+
+    describe("#when event is session.idle with contextWindowUsage below threshold", () => {
+      it("#then no-op", async () => {
+        const properties: Record<string, unknown> = { contextWindowUsage: 0.5 };
+        const input = {
+          event: { type: "session.idle", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryActions).toBeUndefined();
+        expect(properties.recoveryContext).toBeUndefined();
+      });
+    });
+
+    describe("#when event type is session.created (non-matching)", () => {
+      it("#then no-op", async () => {
+        const properties: Record<string, unknown> = { error: "context window exceeded" };
+        const input = {
+          event: { type: "session.created", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryActions).toBeUndefined();
+        expect(properties.recoveryContext).toBeUndefined();
+      });
+    });
+
+    describe("#when recoveryContext already contains the marker", () => {
+      it("#then does not double-append recoveryContext", async () => {
+        const properties: Record<string, unknown> = {
+          error: "token limit exceeded",
+          recoveryContext: CONTEXT_WINDOW_LIMIT_RECOVERY_MESSAGE,
+        };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toBe(CONTEXT_WINDOW_LIMIT_RECOVERY_MESSAGE);
+      });
+    });
+
+    describe("#when contextWindowUsage is a percentage > 1", () => {
+      it("#then normalizes to ratio and triggers if >= 0.9", async () => {
+        const properties: Record<string, unknown> = { contextWindowUsage: 95 };
+        const input = {
+          event: { type: "session.idle", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryActions).toEqual(["compact", "summarize"]);
+        expect(properties.recoveryContext).toContain("[CONTEXT WINDOW LIMIT RECOVERY]");
+      });
+    });
+
+    describe("#when input is not a record", () => {
+      it("#then no-op", async () => {
+        await handler(null);
+      });
+    });
+  });
+});