goatcode-sh 0.0.1 → 0.1.2

package/src/hooks/task-resume-info/handler.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "bun:test";
+
+import { createTaskResumeInfoHandler } from "./handler";
+
+describe("createTaskResumeInfoHandler", () => {
+  describe("#given a task tool output with Session ID pattern", () => {
+    describe("#when the output contains Session ID: ses_xxx", () => {
+      it("#then appends a continuation hint with the session ID", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "task",
+          output: "Work completed.\nSession ID: ses_test123",
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toContain('task(session_id="ses_test123"');
+        expect(output.output).toContain("to continue:");
+      });
+    });
+  });
+
+  describe("#given a task tool output with session_id lowercase pattern", () => {
+    describe("#when the output uses session_id: ses_xxx", () => {
+      it("#then extracts the session ID and appends continuation", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "task",
+          output: "Done.\nsession_id: ses_lower456",
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toContain("ses_lower456");
+        expect(output.output).toContain("to continue:");
+      });
+    });
+  });
+
+  describe("#given a task tool output with task_metadata XML pattern", () => {
+    describe("#when the output uses <task_metadata> with session_id", () => {
+      it("#then extracts the session ID from the XML-like format", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "task",
+          output: "<task_metadata>\nsession_id: ses_meta789\n</task_metadata>",
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toContain("ses_meta789");
+        expect(output.output).toContain("to continue:");
+      });
+    });
+  });
+
+  describe("#given a task tool output with sessionId camelCase pattern", () => {
+    describe("#when the output uses sessionId: ses_xxx", () => {
+      it("#then extracts the session ID from camelCase format", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "task",
+          output: "Result:\nsessionId: ses_camel321",
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toContain("ses_camel321");
+        expect(output.output).toContain("to continue:");
+      });
+    });
+  });
+
+  describe("#given a task tool output without any session ID", () => {
+    describe("#when the output has no session ID pattern", () => {
+      it("#then does not modify the output", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const original = "Task completed with no session info.";
+        const output = { title: "task", output: original, metadata: {} };
+
+        await handler(input, output);
+
+        expect(output.output).toBe(original);
+      });
+    });
+  });
+
+  describe("#given a task tool output that already has continuation info", () => {
+    describe("#when the output already contains a to continue line", () => {
+      it("#then does not add a duplicate", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "task",
+          output:
+            'Done.\nSession ID: ses_dup\nto continue: task(session_id="ses_dup", prompt="...")',
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        const matches = output.output.match(/to continue:/g);
+        expect(matches?.length).toBe(1);
+      });
+    });
+  });
+
+  describe("#given a task tool output starting with Error:", () => {
+    describe("#when the output is an error even with a session ID", () => {
+      it("#then does not modify the output", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const original = "Error: something failed. Session ID: ses_err1";
+        const output = { title: "task", output: original, metadata: {} };
+
+        await handler(input, output);
+
+        expect(output.output).toBe(original);
+      });
+    });
+  });
+
+  describe("#given a task tool output starting with Failed", () => {
+    describe("#when the output indicates a failure", () => {
+      it("#then does not modify the output", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "task", sessionID: "s1", callID: "c1", args: {} };
+        const original = "Failed to execute. Session ID: ses_fail1";
+        const output = { title: "task", output: original, metadata: {} };
+
+        await handler(input, output);
+
+        expect(output.output).toBe(original);
+      });
+    });
+  });
+
+  describe("#given a non-target tool", () => {
+    describe("#when the tool is Read with a session ID in output", () => {
+      it("#then does not modify the output", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "Read", sessionID: "s1", callID: "c1", args: {} };
+        const original = "Session ID: ses_readtool";
+        const output = { title: "Read", output: original, metadata: {} };
+
+        await handler(input, output);
+
+        expect(output.output).toBe(original);
+      });
+    });
+  });
+
+  describe("#given a call_omo_agent tool with a session ID", () => {
+    describe("#when the tool is in the TARGET_TOOLS list", () => {
+      it("#then appends the continuation hint", async () => {
+        const handler = createTaskResumeInfoHandler();
+        const input = { tool: "call_omo_agent", sessionID: "s1", callID: "c1", args: {} };
+        const output = {
+          title: "call_omo_agent",
+          output: "Agent done.\nSession ID: ses_omo999",
+          metadata: {},
+        };
+
+        await handler(input, output);
+
+        expect(output.output).toContain("ses_omo999");
+        expect(output.output).toContain("to continue:");
+      });
+    });
+  });
+});

package/src/hooks/task-resume-info/handler.ts

@@ -0,0 +1,61 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+
+type PostToolUseHook = NonNullable<PluginHookContributions["tool.execute.after"]>;
+
+const TARGET_TOOLS = ["task", "Task", "task_tool", "call_omo_agent"];
+
+const SESSION_ID_PATTERNS = [
+  /Session ID: (ses_[a-zA-Z0-9_-]+)/,
+  /session_id: (ses_[a-zA-Z0-9_-]+)/,
+  /<task_metadata>\s*session_id: (ses_[a-zA-Z0-9_-]+)/,
+  /sessionId: (ses_[a-zA-Z0-9_-]+)/,
+];
+
+function extractSessionId(output: string): string | null {
+  for (const pattern of SESSION_ID_PATTERNS) {
+    const match = output.match(pattern);
+    if (match) return match[1] ?? null;
+  }
+  return null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function createTaskResumeInfoHandler(): PostToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) {
+      return;
+    }
+
+    const tool = input.tool;
+    if (typeof tool !== "string" || !TARGET_TOOLS.includes(tool)) {
+      return;
+    }
+
+    const toolOutput = output.output;
+    if (typeof toolOutput !== "string") {
+      return;
+    }
+
+    if (toolOutput.startsWith("Error:") || toolOutput.startsWith("Failed")) {
+      return;
+    }
+
+    if (toolOutput.includes("\nto continue:")) {
+      return;
+    }
+
+    const sessionId = extractSessionId(toolOutput);
+    if (!sessionId) {
+      return;
+    }
+
+    output.output =
+      toolOutput.trimEnd() + `\n\nto continue: task(session_id="${sessionId}", prompt="...")`;
+
+    log("[task-resume-info] injected resume continuation info", { sessionId });
+  };
+}

package/src/hooks/task-resume-info/index.ts

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

package/src/hooks/task-resume-info/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createTaskResumeInfoHandler } from "./handler";
+
+const toolExecuteAfterHook = safeCreateHook("task-resume-info", createTaskResumeInfoHandler);
+
+export const taskResumeInfoPlugin = definePlugin({
+  name: "task-resume-info",
+  version: "0.1.0",
+  hooks: toolExecuteAfterHook
+    ? {
+        "tool.execute.after": toolExecuteAfterHook,
+      }
+    : {},
+});

package/src/hooks/think-mode/handler.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { clearSessionMode, setSessionMode } from "../keyword-detector/handler";
+import { createThinkModeHandler } from "./handler";
+
+const SESSION_ID = "ses_test";
+
+function makeInput(providerID: string, modelID: string, sessionID: string = SESSION_ID) {
+  return {
+    sessionID,
+    agent: "sisyphus",
+    model: { providerID, modelID },
+    provider: { id: providerID },
+    message: {},
+  };
+}
+
+function makeOutput() {
+  return {
+    temperature: 0.1,
+    topP: 1,
+    topK: 0,
+    options: {} as Record<string, unknown>,
+  };
+}
+
+describe("createThinkModeHandler", () => {
+  afterEach(() => {
+    clearSessionMode(SESSION_ID);
+  });
+
+  describe("#given think mode is active", () => {
+    describe("#when called with an Anthropic Claude model", () => {
+      it("#then injects thinking with budget_tokens=10000", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 10000,
+        });
+      });
+    });
+
+    describe("#when called with google-vertex-anthropic provider", () => {
+      it("#then injects thinking parameters", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeInput("google-vertex-anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 10000,
+        });
+      });
+    });
+
+    describe("#when called with github-copilot claude model", () => {
+      it("#then injects thinking parameters", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeInput("github-copilot", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 10000,
+        });
+      });
+    });
+
+    describe("#when called with a non-Anthropic model", () => {
+      it("#then does not inject thinking parameters", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeInput("openai", "gpt-5.4");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+
+    describe("#when thinking is already configured", () => {
+      it("#then does not overwrite existing thinking config", async () => {
+        setSessionMode(SESSION_ID, "think");
+        const handler = createThinkModeHandler();
+        const input = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+        output.options.thinking = { type: "enabled", budget_tokens: 5000 };
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 5000,
+        });
+      });
+    });
+  });
+
+  describe("#given ultrawork mode is active (not think)", () => {
+    describe("#when called with an Anthropic model", () => {
+      it("#then does not inject thinking parameters", async () => {
+        setSessionMode(SESSION_ID, "ultrawork");
+        const handler = createThinkModeHandler();
+        const input = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given no session mode is set", () => {
+    describe("#when called with an Anthropic model", () => {
+      it("#then does not inject thinking parameters", async () => {
+        const handler = createThinkModeHandler();
+        const input = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+});

package/src/hooks/think-mode/handler.ts

@@ -0,0 +1,50 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { getSessionMode } from "../keyword-detector/handler";
+import { log } from "../../shared/logger";
+
+const THINK_BUDGET_TOKENS = 10000;
+
+type ChatParamsHook = NonNullable<PluginHookContributions["chat.params"]>;
+
+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;
+}
+
+export function createThinkModeHandler(): ChatParamsHook {
+  return async (input: unknown, output: unknown): Promise<void> => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const sessionID = input.sessionID;
+    if (typeof sessionID !== "string") return;
+
+    const mode = getSessionMode(sessionID);
+    if (mode !== "think") 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;
+
+    const options = output.options;
+    if (!isRecord(options)) return;
+    if (options.thinking !== undefined) return;
+
+    options.thinking = {
+      type: "enabled",
+      budget_tokens: THINK_BUDGET_TOKENS,
+    };
+
+    log("[think-mode] thinking parameters injected", {
+      sessionID,
+      budget_tokens: THINK_BUDGET_TOKENS,
+    });
+  };
+}

package/src/hooks/think-mode/index.ts

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

package/src/hooks/think-mode/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createThinkModeHandler } from "./handler";
+
+const chatParamsHook = safeCreateHook("think-mode", createThinkModeHandler);
+
+export const thinkModePlugin = definePlugin({
+  name: "think-mode",
+  version: "0.1.0",
+  hooks: chatParamsHook
+    ? {
+        "chat.params": chatParamsHook,
+      }
+    : {},
+});

package/src/hooks/thinking-block-validator/handler.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "bun:test";
+import { createThinkingBlockValidatorHandler } from "./handler";
+
+describe("createThinkingBlockValidatorHandler", () => {
+  describe("#given a handler instance", () => {
+    describe("#when messages contain a malformed thinking block", () => {
+      it("#then strips the malformed thinking part", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_1" },
+            parts: [
+              { type: "thinking", thinking: "" },
+              { type: "text", text: "Hello world" },
+            ],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(1);
+        expect(messages[0].parts[0].type).toBe("text");
+        expect(messages[0].parts[0].text).toBe("Hello world");
+      });
+    });
+
+    describe("#when messages contain a valid thinking block", () => {
+      it("#then preserves the thinking part unchanged", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_1" },
+            parts: [
+              { type: "thinking", thinking: "Let me reason through this problem." },
+              { type: "text", text: "The answer is 42." },
+            ],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(2);
+        expect(messages[0].parts[0].type).toBe("thinking");
+        expect(messages[0].parts[0].thinking).toBe("Let me reason through this problem.");
+      });
+    });
+
+    describe("#when messages array is empty", () => {
+      it("#then does nothing and does not throw", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+
+        await expect(handler({}, { messages: [] })).resolves.toBeUndefined();
+      });
+    });
+
+    describe("#when a reasoning part has whitespace-only content", () => {
+      it("#then strips the whitespace-only reasoning part", async () => {
+        const handler = createThinkingBlockValidatorHandler();
+        const messages = [
+          {
+            info: { role: "assistant", id: "msg_2" },
+            parts: [
+              { type: "reasoning", text: "   \n\t  " },
+              { type: "text", text: "Result" },
+            ],
+          },
+        ];
+        const output = { messages };
+
+        await handler({}, output);
+
+        expect(messages[0].parts).toHaveLength(1);
+        expect(messages[0].parts[0].type).toBe("text");
+      });
+    });
+  });
+});

package/src/hooks/thinking-block-validator/handler.ts

@@ -0,0 +1,93 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+
+type MessagesTransformHook = NonNullable<
+  PluginHookContributions["experimental.chat.messages.transform"]
+>;
+
+interface MessagePart {
+  type: string;
+  thinking?: string;
+  text?: string;
+  [key: string]: unknown;
+}
+
+interface MessageEntry {
+  info: {
+    role: string;
+    id: string;
+    [key: string]: unknown;
+  };
+  parts: MessagePart[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isMessageEntry(value: unknown): value is MessageEntry {
+  if (!isRecord(value)) return false;
+  if (!isRecord(value.info)) return false;
+  if (!Array.isArray(value.parts)) return false;
+  return true;
+}
+
+function isThinkingPart(part: MessagePart): boolean {
+  return part.type === "thinking" || part.type === "reasoning";
+}
+
+function isWellFormedThinkingPart(part: MessagePart): boolean {
+  const content = part.thinking ?? part.text;
+  return typeof content === "string" && content.trim().length > 0;
+}
+
+function stripMalformedThinkingParts(parts: MessagePart[]): {
+  filtered: MessagePart[];
+  removedCount: number;
+} {
+  let removedCount = 0;
+  const filtered = parts.filter((part) => {
+    if (!isThinkingPart(part)) return true;
+    if (isWellFormedThinkingPart(part)) return true;
+    removedCount++;
+    return false;
+  });
+  return { filtered, removedCount };
+}
+
+export function createThinkingBlockValidatorHandler(): MessagesTransformHook {
+  return async (_input: unknown, output: unknown) => {
+    if (!isRecord(output)) {
+      return;
+    }
+
+    const messages = output.messages;
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return;
+    }
+
+    let totalRemoved = 0;
+
+    for (const msg of messages) {
+      if (!isMessageEntry(msg)) {
+        continue;
+      }
+
+      if (msg.info.role !== "assistant") {
+        continue;
+      }
+
+      const { filtered, removedCount } = stripMalformedThinkingParts(msg.parts);
+      if (removedCount > 0) {
+        msg.parts = filtered;
+        totalRemoved += removedCount;
+      }
+    }
+
+    if (totalRemoved > 0) {
+      log("[thinking-block-validator] stripped malformed thinking blocks", {
+        count: totalRemoved,
+      });
+    }
+  };
+}

package/src/hooks/thinking-block-validator/index.ts

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

package/src/hooks/thinking-block-validator/plugin.ts

@@ -0,0 +1,18 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createThinkingBlockValidatorHandler } from "./handler";
+
+const messagesTransformHook = safeCreateHook(
+  "thinking-block-validator",
+  createThinkingBlockValidatorHandler,
+);
+
+export const thinkingBlockValidatorPlugin = definePlugin({
+  name: "thinking-block-validator",
+  version: "0.1.0",
+  hooks: messagesTransformHook
+    ? {
+        "experimental.chat.messages.transform": messagesTransformHook,
+      }
+    : {},
+});