goatcode-sh 0.0.1 → 0.1.2

package/src/hooks/anthropic-effort/handler.ts

@@ -0,0 +1,64 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+
+export type EffortLevel = "low" | "medium" | "high" | "max";
+
+type ChatParamsHook = NonNullable<PluginHookContributions["chat.params"]>;
+
+const EFFORT_BUDGET_TOKENS: Record<Exclude<EffortLevel, "low">, number> = {
+  medium: 5000,
+  high: 10000,
+  max: 32000,
+};
+
+const OPUS_PATTERN = /claude-opus/i;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isAnthropicClaude(providerID: string, modelID: string): boolean {
+  const claudeProviders = ["anthropic", "google-vertex-anthropic", "opencode"];
+  if (claudeProviders.includes(providerID)) return true;
+  if (providerID === "github-copilot" && modelID.toLowerCase().includes("claude")) return true;
+  return false;
+}
+
+function normalizeModelID(modelID: string): string {
+  return modelID.replace(/\./g, "-");
+}
+
+export function createAnthropicEffortHandler(effortLevel: EffortLevel = "high"): ChatParamsHook {
+  return async (input: unknown, output: unknown): Promise<void> => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const model = input.model;
+    if (!isRecord(model)) return;
+    if (typeof model.providerID !== "string" || typeof model.modelID !== "string") return;
+
+    if (!isAnthropicClaude(model.providerID, model.modelID)) return;
+
+    if (effortLevel === "low") return;
+
+    const options = output.options;
+    if (!isRecord(options)) return;
+    if (options.thinking !== undefined) return;
+
+    const budgetTokens = EFFORT_BUDGET_TOKENS[effortLevel];
+    options.thinking = {
+      type: "enabled",
+      budget_tokens: budgetTokens,
+    };
+
+    const normalized = normalizeModelID(model.modelID);
+    if (effortLevel === "max" && OPUS_PATTERN.test(normalized) && options.effort === undefined) {
+      options.effort = "max";
+    }
+
+    log("[anthropic-effort] thinking parameters injected", {
+      sessionID: input.sessionID,
+      effortLevel,
+      budget_tokens: budgetTokens,
+    });
+  };
+}

package/src/hooks/anthropic-effort/index.ts

@@ -0,0 +1,3 @@
+export { createAnthropicEffortHandler } from "./handler";
+export type { EffortLevel } from "./handler";
+export { anthropicEffortPlugin } from "./plugin";

package/src/hooks/anthropic-effort/plugin.ts

@@ -0,0 +1,17 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createAnthropicEffortHandler } from "./handler";
+
+const chatParamsHook = safeCreateHook("anthropic-effort", () =>
+  createAnthropicEffortHandler("high"),
+);
+
+export const anthropicEffortPlugin = definePlugin({
+  name: "anthropic-effort",
+  version: "0.1.0",
+  hooks: chatParamsHook
+    ? {
+        "chat.params": chatParamsHook,
+      }
+    : {},
+});

package/src/hooks/builtin-hooks.ts

@@ -0,0 +1,64 @@
+import type { PluginDefinition } from "../types/plugin";
+import { thinkingBlockValidatorPlugin } from "./thinking-block-validator/plugin";
+import { contextInjectorPlugin } from "./context-injector/plugin";
+import { hashlineReadEnhancerPlugin } from "./hashline-read-enhancer/plugin";
+import { toolOutputTruncatorPlugin } from "./tool-output-truncator/plugin";
+import { todoEnforcerPlugin } from "./todo-enforcer/plugin";
+import { delegateRetryPlugin } from "./delegate-retry/plugin";
+import { editErrorPlugin } from "./edit-error/plugin";
+import { keywordDetectorPlugin } from "./keyword-detector/plugin";
+import { preemptiveCompactionPlugin } from "./preemptive-compaction/plugin";
+import { anthropicEffortPlugin } from "./anthropic-effort/plugin";
+import { modelFallbackPlugin } from "./model-fallback/plugin";
+import { taskResumeInfoPlugin } from "./task-resume-info/plugin";
+import { commentCheckerPlugin } from "./comment-checker/plugin";
+import { thinkModePlugin } from "./think-mode/plugin";
+import { contextWindowLimitPlugin } from "./context-window-limit/plugin";
+import { runtimeFallbackPlugin } from "./runtime-fallback/plugin";
+import { stopGuardPlugin } from "./stop-guard/plugin";
+import { hashlineDiffEnhancerPlugin } from "./hashline-diff-enhancer/plugin";
+import { compactionContextPlugin } from "./compaction-context/plugin";
+import { sessionRecoveryPlugin } from "./session-recovery/plugin";
+import { emptyResponseDetectorPlugin } from "./empty-response-detector/plugin";
+import { jsonErrorPlugin } from "./json-error/plugin";
+import { todowriteDisablerPlugin } from "./todowrite-disabler/plugin";
+import { compactionTodoPreserverPlugin } from "./compaction-todo-preserver/plugin";
+import { writeFileGuardPlugin } from "./write-file-guard/plugin";
+import { foregroundFallbackPlugin } from "./foreground-fallback";
+import { phaseReminderPlugin } from "./phase-reminder";
+import { postReadNudgePlugin } from "./post-read-nudge";
+import { errorDiagnosticsPlugin } from "./error-diagnostics/plugin";
+import { skillDiscoveryPlugin } from "./skill-discovery/plugin";
+
+export const BUILTIN_HOOK_PLUGINS: PluginDefinition[] = [
+  thinkingBlockValidatorPlugin,
+  contextInjectorPlugin,
+  hashlineReadEnhancerPlugin,
+  toolOutputTruncatorPlugin,
+  todoEnforcerPlugin,
+  delegateRetryPlugin,
+  editErrorPlugin,
+  keywordDetectorPlugin,
+  preemptiveCompactionPlugin,
+  anthropicEffortPlugin,
+  modelFallbackPlugin,
+  taskResumeInfoPlugin,
+  commentCheckerPlugin,
+  thinkModePlugin,
+  contextWindowLimitPlugin,
+  runtimeFallbackPlugin,
+  stopGuardPlugin,
+  hashlineDiffEnhancerPlugin,
+  compactionContextPlugin,
+  sessionRecoveryPlugin,
+  emptyResponseDetectorPlugin,
+  jsonErrorPlugin,
+  todowriteDisablerPlugin,
+  compactionTodoPreserverPlugin,
+  writeFileGuardPlugin,
+  foregroundFallbackPlugin,
+  phaseReminderPlugin,
+  postReadNudgePlugin,
+  errorDiagnosticsPlugin,
+  skillDiscoveryPlugin,
+];

package/src/hooks/comment-checker/handler.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "bun:test";
+import { createCommentCheckerHandler, EMPTY_CATCH_WARNING } from "./handler";
+
+describe("createCommentCheckerHandler", () => {
+  describe("#given a handler instance", () => {
+    describe("#when output content contains an empty catch block", () => {
+      it("#then appends a warning to output.output", async () => {
+        const handler = createCommentCheckerHandler();
+        const input = { tool: "write", sessionID: "ses_1", callID: "call_1" };
+        const output: Record<string, unknown> = {
+          content: `function run() {
+  try { doWork(); } catch (e) {}
+}`,
+        };
+
+        await handler(input, output);
+
+        expect(typeof output.output).toBe("string");
+        expect(output.output as string).toContain(EMPTY_CATCH_WARNING);
+      });
+    });
+
+    describe("#when output content is plain text without code", () => {
+      it("#then does not inject a warning", async () => {
+        const handler = createCommentCheckerHandler();
+        const input = { tool: "write", sessionID: "ses_1", callID: "call_1" };
+        const output: Record<string, unknown> = {
+          content: "This is a plain text readme with no code blocks at all.",
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toBeUndefined();
+      });
+    });
+
+    describe("#when the tool is not write, edit, or multiedit", () => {
+      it("#then does nothing", async () => {
+        const handler = createCommentCheckerHandler();
+        const input = { tool: "bash", sessionID: "ses_1", callID: "call_1" };
+        const output: Record<string, unknown> = {
+          content: "try { x(); } catch (err) {}",
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toBeUndefined();
+      });
+    });
+
+    describe("#when output has newString with empty catch block", () => {
+      it("#then appends a warning via newString extraction", async () => {
+        const handler = createCommentCheckerHandler();
+        const input = { tool: "edit", sessionID: "ses_1", callID: "call_1" };
+        const output: Record<string, unknown> = {
+          newString: "try { parse(); } catch (ex) {}",
+        };
+
+        await handler(input, output);
+
+        expect(output.output as string).toContain(EMPTY_CATCH_WARNING);
+      });
+    });
+  });
+});

package/src/hooks/comment-checker/handler.ts

@@ -0,0 +1,60 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+
+type PreToolUseHook = NonNullable<PluginHookContributions["tool.execute.before"]>;
+
+const EMPTY_CATCH_PATTERN = /catch\s*\([^)]*\)\s*\{\s*\}/g;
+
+const WARNING_MARKER = "[COMMENT-CHECKER WARNING]";
+
+export const EMPTY_CATCH_WARNING =
+  `${WARNING_MARKER}\nEmpty catch block detected with no comment explaining why the error is ignored. ` +
+  `Add a comment inside the catch block explaining the intent, e.g. // ignore: expected when X.`;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function extractContent(output: Record<string, unknown>): string | undefined {
+  const content = output.content ?? output.newString ?? output.new_string;
+  return typeof content === "string" ? content : undefined;
+}
+
+function hasEmptyCatchBlock(code: string): boolean {
+  const matches = [...code.matchAll(EMPTY_CATCH_PATTERN)];
+  return matches.length > 0;
+}
+
+export function createCommentCheckerHandler(): PreToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) {
+      return;
+    }
+
+    const tool = input.tool;
+    if (typeof tool !== "string") {
+      return;
+    }
+
+    const toolLower = tool.toLowerCase();
+    if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
+      return;
+    }
+
+    const content = extractContent(output);
+    if (!content) {
+      return;
+    }
+
+    if (!hasEmptyCatchBlock(content)) {
+      return;
+    }
+
+    log("[comment-checker] empty catch block detected", { tool: toolLower });
+
+    const existingOutput = typeof output.output === "string" ? output.output : "";
+    output.output = existingOutput
+      ? `${existingOutput}\n${EMPTY_CATCH_WARNING}`
+      : EMPTY_CATCH_WARNING;
+  };
+}

package/src/hooks/comment-checker/index.ts

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

package/src/hooks/comment-checker/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createCommentCheckerHandler } from "./handler";
+
+const preToolUseHook = safeCreateHook("comment-checker", createCommentCheckerHandler);
+
+export const commentCheckerPlugin = definePlugin({
+  name: "comment-checker",
+  version: "0.1.0",
+  hooks: preToolUseHook
+    ? {
+        "tool.execute.before": preToolUseHook,
+      }
+    : {},
+});

package/src/hooks/compaction-context/handler.test.ts

@@ -0,0 +1,160 @@
+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 {
+  createCompactionContextEventHandler,
+  createCompactionContextSystemTransformHandler,
+} from "./handler";
+
+const tempDirectories: string[] = [];
+
+function createWorkspace(): string {
+  const workspace = mkdtempSync(join(tmpdir(), "goatcode-compaction-"));
+  tempDirectories.push(workspace);
+  return workspace;
+}
+
+afterEach(() => {
+  for (const directory of tempDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+describe("createCompactionContextEventHandler", () => {
+  describe("#given a session.compacted event with todo files", () => {
+    describe("#when the handler processes the event", () => {
+      it("#then it stores a snapshot in the session map", async () => {
+        const workspace = createWorkspace();
+        mkdirSync(join(workspace, ".sisyphus"), { recursive: true });
+        writeFileSync(join(workspace, ".sisyphus", "todos.md"), "- [ ] do thing");
+
+        const snapshots = new Map<string, string>();
+        const handler = createCompactionContextEventHandler(workspace, snapshots);
+
+        await handler({
+          event: {
+            type: "session.compacted",
+            properties: { sessionID: "ses-1" },
+          },
+        });
+
+        expect(snapshots.has("ses-1")).toBe(true);
+        expect(snapshots.get("ses-1")).toContain("Current Todos");
+        expect(snapshots.get("ses-1")).toContain("do thing");
+      });
+    });
+  });
+
+  describe("#given a session.deleted event", () => {
+    describe("#when the handler processes the event", () => {
+      it("#then it removes the snapshot from the map", async () => {
+        const workspace = createWorkspace();
+        const snapshots = new Map<string, string>();
+        snapshots.set("ses-1", "old-snapshot");
+
+        const handler = createCompactionContextEventHandler(workspace, snapshots);
+
+        await handler({
+          event: {
+            type: "session.deleted",
+            properties: { sessionID: "ses-1" },
+          },
+        });
+
+        expect(snapshots.has("ses-1")).toBe(false);
+      });
+    });
+  });
+
+  describe("#given a non-compaction event type", () => {
+    describe("#when the handler processes the event", () => {
+      it("#then it does not modify the snapshot map", async () => {
+        const workspace = createWorkspace();
+        const snapshots = new Map<string, string>();
+
+        const handler = createCompactionContextEventHandler(workspace, snapshots);
+
+        await handler({
+          event: {
+            type: "session.idle",
+            properties: { sessionID: "ses-1" },
+          },
+        });
+
+        expect(snapshots.size).toBe(0);
+      });
+    });
+  });
+
+  describe("#given a session.compacted event with no todo or plan files", () => {
+    describe("#when the handler processes the event", () => {
+      it("#then it does not store a snapshot", async () => {
+        const workspace = createWorkspace();
+        const snapshots = new Map<string, string>();
+
+        const handler = createCompactionContextEventHandler(workspace, snapshots);
+
+        await handler({
+          event: {
+            type: "session.compacted",
+            properties: { sessionID: "ses-1" },
+          },
+        });
+
+        expect(snapshots.has("ses-1")).toBe(false);
+      });
+    });
+  });
+});
+
+describe("createCompactionContextSystemTransformHandler", () => {
+  describe("#given a session with a stored snapshot", () => {
+    describe("#when the system transform runs", () => {
+      it("#then it appends the snapshot to system output and removes it from the map", async () => {
+        const snapshots = new Map<string, string>();
+        snapshots.set("ses-1", "[Compaction Recovery Context]\n## Current Todos\n- do thing");
+
+        const handler = createCompactionContextSystemTransformHandler(snapshots);
+        const output = { system: "base-system" };
+
+        await handler({ sessionID: "ses-1" }, output);
+
+        expect(output.system).toContain("Compaction Recovery Context");
+        expect(output.system).toContain("Current Todos");
+        expect(snapshots.has("ses-1")).toBe(false);
+      });
+    });
+  });
+
+  describe("#given a session without a stored snapshot", () => {
+    describe("#when the system transform runs", () => {
+      it("#then it does not modify the output", async () => {
+        const snapshots = new Map<string, string>();
+        const handler = createCompactionContextSystemTransformHandler(snapshots);
+        const output = { system: "base-system" };
+
+        await handler({ sessionID: "ses-no-snapshot" }, output);
+
+        expect(output.system).toBe("base-system");
+      });
+    });
+  });
+
+  describe("#given a session ID provided via session.id", () => {
+    describe("#when the system transform runs", () => {
+      it("#then it resolves the session ID from the nested path", async () => {
+        const snapshots = new Map<string, string>();
+        snapshots.set("ses-nested", "snapshot-content");
+
+        const handler = createCompactionContextSystemTransformHandler(snapshots);
+        const output = { system: "base-system" };
+
+        await handler({ session: { id: "ses-nested" } }, output);
+
+        expect(output.system).toContain("snapshot-content");
+        expect(snapshots.has("ses-nested")).toBe(false);
+      });
+    });
+  });
+});

package/src/hooks/compaction-context/handler.ts

@@ -0,0 +1,179 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "../../shared/logger";
+
+type EventInput = {
+  event?: {
+    type?: string;
+    properties?: unknown;
+  };
+};
+
+type SessionLikeInput = {
+  sessionID?: string;
+  session?: {
+    id?: string;
+  };
+};
+
+type SystemTransformOutput = {
+  system?: string;
+  prompt?: string;
+  text?: string;
+  content?: string;
+};
+
+function readTextIfExists(path: string, maxChars = 4000): string | null {
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  try {
+    const text = readFileSync(path, "utf8");
+    return text.length > maxChars ? `${text.slice(0, maxChars)}\n\n[truncated]` : text;
+  } catch (error) {
+    log("[compaction-context] Failed to read context file", { path, error: String(error) });
+    return null;
+  }
+}
+
+function resolveLatestPlanPath(workspaceDirectory: string): string | null {
+  const plansDirectory = join(workspaceDirectory, ".sisyphus", "plans");
+  if (!existsSync(plansDirectory)) {
+    return null;
+  }
+
+  const planFiles = readdirSync(plansDirectory)
+    .filter((name) => name.endsWith(".md"))
+    .map((name) => ({
+      path: join(plansDirectory, name),
+      mtimeMs: statSync(join(plansDirectory, name)).mtimeMs,
+    }))
+    .sort((left, right) => right.mtimeMs - left.mtimeMs);
+
+  return planFiles[0]?.path ?? null;
+}
+
+function buildCompactionSnapshot(workspaceDirectory: string): string | null {
+  const todoPaths = [
+    join(workspaceDirectory, ".sisyphus", "todos.md"),
+    join(workspaceDirectory, ".sisyphus", "todo.md"),
+  ];
+
+  const todoContent = todoPaths
+    .map((path) => ({ path, content: readTextIfExists(path) }))
+    .find((entry) => entry.content !== null);
+
+  const planPath = resolveLatestPlanPath(workspaceDirectory);
+  const planContent = planPath ? readTextIfExists(planPath) : null;
+
+  if (!todoContent?.content && !planContent) {
+    return null;
+  }
+
+  let snapshot = "[Compaction Recovery Context]\n";
+  if (todoContent?.content) {
+    snapshot += `\n## Current Todos\n[Source: ${todoContent.path}]\n${todoContent.content}\n`;
+  }
+  if (planContent && planPath) {
+    snapshot += `\n## Active Plan\n[Source: ${planPath}]\n${planContent}\n`;
+  }
+
+  return snapshot;
+}
+
+function resolveSessionID(properties: unknown): string | null {
+  if (!properties || typeof properties !== "object") {
+    return null;
+  }
+
+  const record = properties as Record<string, unknown>;
+  const direct = record.sessionID;
+  if (typeof direct === "string") {
+    return direct;
+  }
+
+  const info = record.info;
+  if (info && typeof info === "object") {
+    const id = (info as Record<string, unknown>).id;
+    if (typeof id === "string") {
+      return id;
+    }
+  }
+
+  return null;
+}
+
+export function createCompactionContextEventHandler(
+  workspaceDirectory: string,
+  sessionSnapshots: Map<string, string>,
+) {
+  return async (input: unknown): Promise<void> => {
+    const typedInput = input as EventInput;
+    const eventType = typedInput.event?.type;
+    const properties = typedInput.event?.properties;
+    const sessionID = resolveSessionID(properties);
+
+    if (!sessionID) {
+      return;
+    }
+
+    if (eventType === "session.deleted") {
+      sessionSnapshots.delete(sessionID);
+      return;
+    }
+
+    if (eventType !== "session.compacted") {
+      return;
+    }
+
+    const snapshot = buildCompactionSnapshot(workspaceDirectory);
+    if (!snapshot) {
+      return;
+    }
+
+    sessionSnapshots.set(sessionID, snapshot);
+  };
+}
+
+export function createCompactionContextSystemTransformHandler(
+  sessionSnapshots: Map<string, string>,
+) {
+  return async (input: unknown, output: unknown): Promise<void> => {
+    const typedInput = input as SessionLikeInput;
+    const typedOutput = output as SystemTransformOutput;
+    const sessionID = typedInput.sessionID ?? typedInput.session?.id;
+
+    if (!sessionID) {
+      return;
+    }
+
+    const snapshot = sessionSnapshots.get(sessionID);
+    if (!snapshot) {
+      return;
+    }
+
+    if (typeof typedOutput.system === "string") {
+      typedOutput.system += `\n\n${snapshot}`;
+      sessionSnapshots.delete(sessionID);
+      return;
+    }
+
+    if (typeof typedOutput.prompt === "string") {
+      typedOutput.prompt += `\n\n${snapshot}`;
+      sessionSnapshots.delete(sessionID);
+      return;
+    }
+
+    if (typeof typedOutput.text === "string") {
+      typedOutput.text += `\n\n${snapshot}`;
+      sessionSnapshots.delete(sessionID);
+      return;
+    }
+
+    if (typeof typedOutput.content === "string") {
+      typedOutput.content += `\n\n${snapshot}`;
+      sessionSnapshots.delete(sessionID);
+    }
+  };
+}

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

@@ -0,0 +1,5 @@
+export { compactionContextPlugin } from "./plugin";
+export {
+  createCompactionContextEventHandler,
+  createCompactionContextSystemTransformHandler,
+} from "./handler";

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

@@ -0,0 +1,40 @@
+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 {
+  createCompactionContextEventHandler,
+  createCompactionContextSystemTransformHandler,
+} from "./handler";
+
+const sessionSnapshots = new Map<string, string>();
+let eventHandler: PluginHookContributions["event"] | null = null;
+let systemTransformHandler: PluginHookContributions["experimental.chat.system.transform"] | null =
+  null;
+
+export const compactionContextPlugin = definePlugin({
+  name: "compaction-context",
+  version: "0.1.0",
+  setup: (ctx: OpenCodeContext) => {
+    eventHandler = safeCreateHook("compaction-context:event", () =>
+      createCompactionContextEventHandler(ctx.directory, sessionSnapshots),
+    );
+    systemTransformHandler = safeCreateHook("compaction-context:system-transform", () =>
+      createCompactionContextSystemTransformHandler(sessionSnapshots),
+    );
+  },
+  hooks: {
+    event: async (input) => {
+      if (!eventHandler) {
+        return;
+      }
+      await eventHandler(input);
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      if (!systemTransformHandler) {
+        return;
+      }
+      await systemTransformHandler(input, output);
+    },
+  },
+});