goatcode-sh 0.0.1 → 0.1.2

package/src/hooks/compaction-todo-preserver/handler.test.ts

@@ -0,0 +1,155 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  clearSessionStore,
+  getSessionState,
+  setSessionState,
+} from "../../features/session-state/session-store";
+import { createCompactionTodoPreserverHandler } from "./handler";
+
+type MutableTodoState = {
+  todos?: Array<{
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+  }>;
+};
+
+type GenericHook = (input: unknown, output?: unknown) => Promise<void>;
+
+function seedTodos(sessionID: string, todos: NonNullable<MutableTodoState["todos"]>): void {
+  setSessionState(sessionID, { status: "active" });
+  const state = getSessionState(sessionID) as unknown as MutableTodoState | undefined;
+  if (!state) return;
+  state.todos = todos;
+}
+
+describe("createCompactionTodoPreserverHandler", () => {
+  beforeEach(() => {
+    clearSessionStore();
+  });
+
+  describe("#given a handler instance", () => {
+    describe("#when session.compacted fires with todos present", () => {
+      it("#then prepends a todo snapshot to output.context", async () => {
+        const sessionID = "ses-compact-todos";
+        seedTodos(sessionID, [
+          { content: "Implement feature X", status: "pending" },
+          { content: "Run lint", status: "in_progress" },
+        ]);
+        const handler = createCompactionTodoPreserverHandler() as unknown as GenericHook;
+        const input = {
+          event: {
+            type: "session.compacted",
+            properties: { sessionID },
+          },
+        };
+        const output = { context: ["existing context"] };
+
+        await handler(input, output);
+
+        expect(output.context.length).toBe(2);
+        expect(output.context[0]).toContain("compaction-todo-preserver");
+        expect(output.context[0]).toContain("Implement feature X");
+        expect(output.context[0]).toContain("Run lint");
+        expect(output.context[1]).toBe("existing context");
+      });
+    });
+
+    describe("#when session.compacting fires with todos", () => {
+      it("#then also triggers since session.compacting is a compaction event", async () => {
+        const sessionID = "ses-compacting";
+        seedTodos(sessionID, [{ content: "Fix tests", status: "pending" }]);
+        const handler = createCompactionTodoPreserverHandler() as unknown as GenericHook;
+        const input = {
+          event: {
+            type: "session.compacting",
+            properties: { sessionID },
+          },
+        };
+        const output = { context: [] as string[] };
+
+        await handler(input, output);
+
+        expect(output.context.length).toBe(1);
+        expect(output.context[0]).toContain("Fix tests");
+      });
+    });
+
+    describe("#when experimental.session.compacting fires", () => {
+      it("#then handles the experimental event type", async () => {
+        const sessionID = "ses-exp-compact";
+        seedTodos(sessionID, [{ content: "Experimental task", status: "in_progress" }]);
+        const handler = createCompactionTodoPreserverHandler() as unknown as GenericHook;
+        const input = {
+          event: {
+            type: "experimental.session.compacting",
+            properties: { sessionID },
+          },
+        };
+        const output = { context: [] as string[] };
+
+        await handler(input, output);
+
+        expect(output.context.length).toBe(1);
+        expect(output.context[0]).toContain("Experimental task");
+      });
+    });
+
+    describe("#when a non-compaction event fires", () => {
+      it("#then does nothing", async () => {
+        const sessionID = "ses-compact-noop";
+        seedTodos(sessionID, [{ content: "Pending work", status: "pending" }]);
+        const handler = createCompactionTodoPreserverHandler() as unknown as GenericHook;
+        const input = {
+          event: {
+            type: "session.idle",
+            properties: { sessionID },
+          },
+        };
+        const output = { context: ["untouched"] };
+
+        await handler(input, output);
+
+        expect(output.context).toEqual(["untouched"]);
+      });
+    });
+
+    describe("#when compaction fires but no todos exist", () => {
+      it("#then does not prepend anything", async () => {
+        const sessionID = "ses-compact-empty";
+        setSessionState(sessionID, { status: "active" });
+        const handler = createCompactionTodoPreserverHandler() as unknown as GenericHook;
+        const input = {
+          event: {
+            type: "session.compacted",
+            properties: { sessionID },
+          },
+        };
+        const output = { context: ["original"] };
+
+        await handler(input, output);
+
+        expect(output.context).toEqual(["original"]);
+      });
+    });
+
+    describe("#when output has no context array", () => {
+      it("#then sets compactionContextPrefix instead", async () => {
+        const sessionID = "ses-compact-no-ctx";
+        seedTodos(sessionID, [{ content: "Fallback task", status: "pending" }]);
+        const handler = createCompactionTodoPreserverHandler() as unknown as GenericHook;
+        const input = {
+          event: {
+            type: "session.compacted",
+            properties: { sessionID },
+          },
+        };
+        const output = {} as Record<string, unknown>;
+
+        await handler(input, output);
+
+        expect(typeof output.compactionContextPrefix).toBe("string");
+        expect(String(output.compactionContextPrefix)).toContain("Fallback task");
+      });
+    });
+  });
+});

package/src/hooks/compaction-todo-preserver/handler.ts

@@ -0,0 +1,129 @@
+import { getSessionState } from "../../runtime";
+import { log } from "../../shared/logger";
+import type { PluginHookContributions } from "../../types/hook";
+
+type EventHook = NonNullable<PluginHookContributions["event"]>;
+
+type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";
+
+interface SessionTodo {
+  content: string;
+  status: TodoStatus;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isTodoStatus(value: unknown): value is TodoStatus {
+  return (
+    value === "pending" || value === "in_progress" || value === "completed" || value === "cancelled"
+  );
+}
+
+function extractTodos(sessionID: string): SessionTodo[] {
+  const state = getSessionState(sessionID);
+  if (!state) {
+    return [];
+  }
+
+  const todos = (state as unknown as { todos?: unknown }).todos;
+  if (!Array.isArray(todos)) {
+    return [];
+  }
+
+  return todos.filter((todo): todo is SessionTodo => {
+    if (!isRecord(todo)) {
+      return false;
+    }
+    return typeof todo.content === "string" && isTodoStatus(todo.status);
+  });
+}
+
+function isCompactionEvent(input: unknown): boolean {
+  if (!isRecord(input)) {
+    return false;
+  }
+
+  if (!isRecord(input.event)) {
+    return false;
+  }
+
+  return (
+    input.event.type === "session.compacting" ||
+    input.event.type === "session.compacted" ||
+    input.event.type === "experimental.session.compacting"
+  );
+}
+
+function resolveSessionID(input: unknown): string | undefined {
+  if (!isRecord(input)) {
+    return undefined;
+  }
+
+  if (typeof input.sessionID === "string") {
+    return input.sessionID;
+  }
+
+  if (!isRecord(input.event)) {
+    return undefined;
+  }
+
+  const properties = isRecord(input.event.properties) ? input.event.properties : undefined;
+  const info = isRecord(properties?.info) ? properties.info : undefined;
+  const eventSessionID = properties?.sessionID;
+  const infoID = info?.id;
+
+  if (typeof eventSessionID === "string") {
+    return eventSessionID;
+  }
+  if (typeof infoID === "string") {
+    return infoID;
+  }
+  return undefined;
+}
+
+function formatTodoSnapshot(todos: SessionTodo[]): string {
+  const lines = todos.map((todo) => `- [${todo.status}] ${todo.content}`);
+  return `[compaction-todo-preserver] Preserve current todos across compaction:\n${lines.join("\n")}`;
+}
+
+function prependSnapshot(output: unknown, snapshot: string): void {
+  if (!isRecord(output)) {
+    return;
+  }
+
+  if (Array.isArray(output.context)) {
+    output.context.unshift(snapshot);
+    return;
+  }
+
+  output.compactionContextPrefix = snapshot;
+}
+
+export function createCompactionTodoPreserverHandler(): EventHook {
+  return async (input: unknown, ...rest: unknown[]) => {
+    if (!isCompactionEvent(input)) {
+      return;
+    }
+
+    const sessionID = resolveSessionID(input);
+    if (!sessionID) {
+      return;
+    }
+
+    const todos = extractTodos(sessionID);
+    if (todos.length === 0) {
+      return;
+    }
+
+    const snapshot = formatTodoSnapshot(todos);
+    const output = rest[0];
+    prependSnapshot(output, snapshot);
+
+    log("[compaction-todo-preserver] Prepended todo snapshot for compaction", {
+      sessionID,
+      todoCount: todos.length,
+    });
+  };
+}

package/src/hooks/compaction-todo-preserver/index.ts

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

package/src/hooks/compaction-todo-preserver/plugin.ts

@@ -0,0 +1,18 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createCompactionTodoPreserverHandler } from "./handler";
+
+const compactionTodoPreserver = safeCreateHook(
+  "compaction-todo-preserver",
+  createCompactionTodoPreserverHandler,
+);
+
+export const compactionTodoPreserverPlugin = definePlugin({
+  name: "compaction-todo-preserver",
+  version: "0.1.0",
+  hooks: compactionTodoPreserver
+    ? {
+        event: compactionTodoPreserver,
+      }
+    : {},
+});

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,90 @@
+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");
+      });
+    });
+  });
+});

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

@@ -0,0 +1,81 @@
+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);
+}
+
+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) {
+  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 fileDirectory = dirname(filePath);
+    const agentsPaths = collectAgentsPaths(fileDirectory, workspaceDirectory);
+
+    for (const agentsPath of agentsPaths) {
+      try {
+        const content = readFileSync(agentsPath, "utf8");
+        typedOutput.output += `\n\n[Directory Context: ${agentsPath}]\n${content}`;
+      } 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),
+      });
+    }
+  };
+}