goatcode-sh 0.0.1 → 0.1.2

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

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createPreemptiveCompactionHandler } from "./handler";
+
+const preemptiveCompactionMessageHook = safeCreateHook("preemptive-compaction", () =>
+  createPreemptiveCompactionHandler(),
+);
+
+export const preemptiveCompactionPlugin = definePlugin({
+  name: "preemptive-compaction",
+  version: "0.1.0",
+  hooks: preemptiveCompactionMessageHook
+    ? { "chat.message": preemptiveCompactionMessageHook }
+    : undefined,
+});

package/src/hooks/productivity.test.ts

@@ -0,0 +1,332 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  clearSessionMode,
+  createKeywordDetectorHandler,
+  getSessionMode,
+  setSessionMode,
+} from "./keyword-detector/handler";
+import { createThinkModeHandler } from "./think-mode/handler";
+import { createAnthropicEffortHandler } from "./anthropic-effort/handler";
+
+const SESSION_ID = "test-session";
+
+function makeChatMessageInput(sessionID: string = SESSION_ID) {
+  return { sessionID };
+}
+
+function makeChatMessageOutput(text: string) {
+  return {
+    message: {},
+    parts: [{ type: "text", text }],
+  };
+}
+
+function makeChatParamsInput(providerID: string, modelID: string, sessionID: string = SESSION_ID) {
+  return {
+    sessionID,
+    agent: "sisyphus",
+    model: { providerID, modelID },
+    provider: { id: providerID },
+    message: {},
+  };
+}
+
+function makeChatParamsOutput() {
+  return {
+    temperature: 0.1,
+    topP: 1,
+    topK: 0,
+    options: {} as Record<string, unknown>,
+  };
+}
+
+describe("keyword-detector", () => {
+  beforeEach(() => {
+    clearSessionMode(SESSION_ID);
+  });
+
+  describe("#given a message containing 'ultrawork'", () => {
+    describe("#when the handler processes the message", () => {
+      it("#then sets the session mode to 'ultrawork'", async () => {
+        const handler = createKeywordDetectorHandler();
+        const input = makeChatMessageInput();
+        const output = makeChatMessageOutput("Please ultrawork on this task now");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("ultrawork");
+      });
+    });
+  });
+
+  describe("#given a message containing 'ulw' shorthand", () => {
+    describe("#when the handler processes the message", () => {
+      it("#then sets the session mode to 'ultrawork'", async () => {
+        const handler = createKeywordDetectorHandler();
+        const input = makeChatMessageInput();
+        const output = makeChatMessageOutput("ulw this task");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("ultrawork");
+      });
+    });
+  });
+
+  describe("#given a message containing 'deep-think'", () => {
+    describe("#when the handler processes the message", () => {
+      it("#then sets the session mode to 'think'", async () => {
+        const handler = createKeywordDetectorHandler();
+        const input = makeChatMessageInput();
+        const output = makeChatMessageOutput("Please deep-think about this problem");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("think");
+      });
+    });
+  });
+
+  describe("#given a message containing 'fast'", () => {
+    describe("#when the handler processes the message", () => {
+      it("#then sets the session mode to 'fast'", async () => {
+        const handler = createKeywordDetectorHandler();
+        const input = makeChatMessageInput();
+        const output = makeChatMessageOutput("fast response please");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("fast");
+      });
+    });
+  });
+
+  describe("#given a message with no recognized keywords", () => {
+    describe("#when the handler processes the message", () => {
+      it("#then does not set a session mode", async () => {
+        const handler = createKeywordDetectorHandler();
+        const input = makeChatMessageInput();
+        const output = makeChatMessageOutput("just a normal request");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given a keyword inside a code block", () => {
+    describe("#when the handler processes the message", () => {
+      it("#then does not set a session mode", async () => {
+        const handler = createKeywordDetectorHandler();
+        const input = makeChatMessageInput();
+        const output = makeChatMessageOutput("check this code: ```ultrawork()```");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBeUndefined();
+      });
+    });
+  });
+});
+
+describe("think-mode", () => {
+  beforeEach(() => {
+    clearSessionMode(SESSION_ID);
+  });
+
+  describe("#given think mode is active for the session", () => {
+    describe("#when chat.params hook is called with an Anthropic Claude model", () => {
+      it("#then injects thinking parameters with budget_tokens", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 10000,
+        });
+      });
+    });
+  });
+
+  describe("#given think mode is active and model is github-copilot claude", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking parameters", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeChatParamsInput("github-copilot", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 10000,
+        });
+      });
+    });
+  });
+
+  describe("#given think mode is not active", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then does not inject thinking parameters", async () => {
+        const handler = createThinkModeHandler();
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given think mode is active but model is not Anthropic Claude", () => {
+    describe("#when chat.params hook is called with an OpenAI model", () => {
+      it("#then does not inject thinking parameters", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeChatParamsInput("openai", "gpt-5.4");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given think mode is active but thinking is already set", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then does not overwrite existing thinking config", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+        output.options.thinking = { type: "enabled", budget_tokens: 5000 };
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({ type: "enabled", budget_tokens: 5000 });
+      });
+    });
+  });
+});
+
+describe("anthropic-effort", () => {
+  describe("#given effort level 'medium' and an Anthropic Claude model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking with budget_tokens=5000", async () => {
+        const handler = createAnthropicEffortHandler("medium");
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 5000,
+        });
+      });
+    });
+  });
+
+  describe("#given effort level 'high' and an Anthropic Claude model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking with budget_tokens=10000", async () => {
+        const handler = createAnthropicEffortHandler("high");
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 10000,
+        });
+      });
+    });
+  });
+
+  describe("#given effort level 'max' and an Anthropic Claude model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking with budget_tokens=32000", async () => {
+        const handler = createAnthropicEffortHandler("max");
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 32000,
+        });
+      });
+    });
+  });
+
+  describe("#given effort level 'max' and Opus model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then also injects effort='max' for opus", async () => {
+        const handler = createAnthropicEffortHandler("max");
+        const input = makeChatParamsInput("anthropic", "claude-opus-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 32000,
+        });
+        expect(output.options.effort).toBe("max");
+      });
+    });
+  });
+
+  describe("#given effort level 'low'", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then does not inject any parameters", async () => {
+        const handler = createAnthropicEffortHandler("low");
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given an OpenAI model", () => {
+    describe("#when chat.params hook is called with effort 'high'", () => {
+      it("#then does not inject Anthropic-specific parameters", async () => {
+        const handler = createAnthropicEffortHandler("high");
+        const input = makeChatParamsInput("openai", "gpt-5.4");
+        const output = makeChatParamsOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given thinking is already configured in options", () => {
+    describe("#when chat.params hook is called with effort 'high'", () => {
+      it("#then does not overwrite existing thinking config", async () => {
+        const handler = createAnthropicEffortHandler("high");
+        const input = makeChatParamsInput("anthropic", "claude-sonnet-4-6");
+        const output = makeChatParamsOutput();
+        output.options.thinking = { type: "enabled", budget_tokens: 999 };
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({ type: "enabled", budget_tokens: 999 });
+      });
+    });
+  });
+});

package/src/hooks/quality.test.ts

@@ -0,0 +1,330 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { createCommentCheckerHandler, EMPTY_CATCH_WARNING } from "./comment-checker/handler";
+import { createWriteFileGuardHandler, BLOCK_MESSAGE } from "./write-file-guard/handler";
+import { createThinkingBlockValidatorHandler } from "./thinking-block-validator/handler";
+
+describe("createCommentCheckerHandler", () => {
+  describe("#given a write tool call with an empty catch block", () => {
+    describe("#when the handler runs", () => {
+      it("#then injects a warning into output.output", async () => {
+        const handler = createCommentCheckerHandler();
+        const input = { tool: "write", sessionID: "ses_1", callID: "call_1" };
+        const output: Record<string, unknown> = {
+          content: `
+function foo() {
+  try {
+    doSomething()
+  } catch (e) {}
+}
+`,
+        };
+
+        await handler(input, output);
+
+        expect(typeof output.output).toBe("string");
+        expect(output.output as string).toContain(EMPTY_CATCH_WARNING);
+      });
+    });
+  });
+
+  describe("#given a write tool call with a commented catch block", () => {
+    describe("#when the handler runs", () => {
+      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: `
+function foo() {
+  try {
+    doSomething()
+  } catch (e) {
+    // ignore: expected on first run
+  }
+}
+`,
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given a non-write/edit tool call", () => {
+    describe("#when the handler runs", () => {
+      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 {} catch (e) {}",
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given an edit tool call with empty catch in newString", () => {
+    describe("#when the handler runs", () => {
+      it("#then injects a warning", async () => {
+        const handler = createCommentCheckerHandler();
+        const input = { tool: "edit", sessionID: "ses_1", callID: "call_1" };
+        const output: Record<string, unknown> = {
+          newString: "try { doThing() } catch (err) {}",
+        };
+
+        await handler(input, output);
+
+        expect(output.output as string).toContain(EMPTY_CATCH_WARNING);
+      });
+    });
+  });
+});
+
+describe("createWriteFileGuardHandler", () => {
+  let tempDir: string;
+
+  const createFile = (relativePath: string, content = "existing"): string => {
+    const abs = join(tempDir, relativePath);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, content);
+    return abs;
+  };
+
+  const invokePreToolUse = async (
+    handler: ReturnType<typeof createWriteFileGuardHandler>,
+    opts: {
+      tool: string;
+      sessionID?: string;
+      filePath: string;
+    },
+  ): Promise<void> => {
+    const input = {
+      tool: opts.tool,
+      sessionID: opts.sessionID ?? "ses_default",
+      callID: "call_1",
+    };
+    const output = { args: { filePath: opts.filePath } };
+    await handler.preToolUse(input, output);
+  };
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "write-file-guard-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("#given an existing file with no prior read", () => {
+    describe("#when write is attempted", () => {
+      it("#then throws block error", async () => {
+        const handler = createWriteFileGuardHandler(tempDir);
+        const existingFile = createFile("existing.txt");
+
+        await expect(
+          invokePreToolUse(handler, { tool: "write", filePath: existingFile }),
+        ).rejects.toThrow(BLOCK_MESSAGE);
+      });
+    });
+  });
+
+  describe("#given an existing file that was read first in the same session", () => {
+    describe("#when write is attempted", () => {
+      it("#then allows the write", async () => {
+        const handler = createWriteFileGuardHandler(tempDir);
+        const existingFile = createFile("readable.txt");
+        const sessionID = "ses_read_first";
+
+        await invokePreToolUse(handler, { tool: "read", sessionID, filePath: existingFile });
+
+        await expect(
+          invokePreToolUse(handler, { tool: "write", sessionID, filePath: existingFile }),
+        ).resolves.toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given a non-existing file", () => {
+    describe("#when write is attempted", () => {
+      it("#then allows the write", async () => {
+        const handler = createWriteFileGuardHandler(tempDir);
+        const newFile = join(tempDir, "new-file.txt");
+
+        await expect(
+          invokePreToolUse(handler, { tool: "write", filePath: newFile }),
+        ).resolves.toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given a read in a different session", () => {
+    describe("#when write is attempted from another session", () => {
+      it("#then blocks the write", async () => {
+        const handler = createWriteFileGuardHandler(tempDir);
+        const existingFile = createFile("cross-session.txt");
+
+        await invokePreToolUse(handler, {
+          tool: "read",
+          sessionID: "ses_reader",
+          filePath: existingFile,
+        });
+
+        await expect(
+          invokePreToolUse(handler, {
+            tool: "write",
+            sessionID: "ses_writer",
+            filePath: existingFile,
+          }),
+        ).rejects.toThrow(BLOCK_MESSAGE);
+      });
+    });
+  });
+
+  describe("#given a session that was deleted after reading", () => {
+    describe("#when write is attempted after session deletion", () => {
+      it("#then blocks the write", async () => {
+        const handler = createWriteFileGuardHandler(tempDir);
+        const existingFile = createFile("cleanup.txt");
+        const sessionID = "ses_cleanup";
+
+        await invokePreToolUse(handler, { tool: "read", sessionID, filePath: existingFile });
+
+        await handler.event({
+          event: { type: "session.deleted", properties: { info: { id: sessionID } } },
+        });
+
+        await expect(
+          invokePreToolUse(handler, { tool: "write", sessionID, filePath: existingFile }),
+        ).rejects.toThrow(BLOCK_MESSAGE);
+      });
+    });
+  });
+});
+
+describe("createThinkingBlockValidatorHandler", () => {
+  describe("#given messages with a malformed thinking block (empty thinking)", () => {
+    describe("#when the handler runs", () => {
+      it("#then strips the malformed thinking block", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_1" },
+            parts: [
+              { type: "thinking", thinking: "" },
+              { type: "text", text: "Hello" },
+            ],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(1);
+        expect(messages[0].parts[0].type).toBe("text");
+      });
+    });
+  });
+
+  describe("#given messages with a well-formed thinking block", () => {
+    describe("#when the handler runs", () => {
+      it("#then keeps the thinking block intact", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_1" },
+            parts: [
+              { type: "thinking", thinking: "I need to think about this carefully." },
+              { type: "text", text: "Here is my answer." },
+            ],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(2);
+        expect(messages[0].parts[0].type).toBe("thinking");
+      });
+    });
+  });
+
+  describe("#given messages with a whitespace-only thinking block", () => {
+    describe("#when the handler runs", () => {
+      it("#then strips the whitespace-only thinking block", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_1" },
+            parts: [
+              { type: "thinking", thinking: "   \n  " },
+              { type: "text", text: "Response" },
+            ],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(1);
+        expect(messages[0].parts[0].type).toBe("text");
+      });
+    });
+  });
+
+  describe("#given messages with no thinking blocks", () => {
+    describe("#when the handler runs", () => {
+      it("#then leaves messages unchanged", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_1" },
+            parts: [{ type: "text", text: "Just text." }],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(1);
+      });
+    });
+  });
+
+  describe("#given user messages with malformed thinking blocks", () => {
+    describe("#when the handler runs", () => {
+      it("#then does not strip from user messages", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "user", id: "msg_1" },
+            parts: [{ type: "thinking", thinking: "" }],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(1);
+      });
+    });
+  });
+
+  describe("#given empty output", () => {
+    describe("#when the handler runs", () => {
+      it("#then does not throw", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+
+        await expect(handler({}, {})).resolves.toBeUndefined();
+        await expect(handler({}, { messages: [] })).resolves.toBeUndefined();
+      });
+    });
+  });
+});