goatcode-sh 0.0.1 → 0.1.3

package/src/features/slash-commands/commands/start-work.ts

@@ -0,0 +1,39 @@
+import type { SlashCommand } from "../types";
+
+export const startWorkCommand: SlashCommand = {
+  name: "start-work",
+  description: "Start Sisyphus work session from Prometheus plan",
+  template: `<command-instruction>
+You are starting a Sisyphus work session.
+
+## ARGUMENTS
+
+- \`/start-work [plan-name] [--worktree <path>]\`
+  - \`plan-name\` (optional): name or partial match of the plan to start
+  - \`--worktree <path>\` (optional): absolute path to an existing git worktree to work in
+
+## WHAT TO DO
+
+1. **Find available plans**: Search for Prometheus-generated plan files at \`.sisyphus/plans/\`
+2. **Decision logic**:
+   - If \`plan-name\` is provided: resolve by exact/partial match and use that plan (or report no match)
+   - Else if a plan is already in progress: continue the existing plan
+   - Else: list available plan files and select one
+3. **Read the plan file** and start executing tasks
+
+## CRITICAL
+
+- Read the FULL plan file before delegating any tasks
+- Follow atlas delegation protocols (7-section format)
+- Decompose every plan task into granular, implementation-level sub-steps
+</command-instruction>
+
+<session-context>
+Session ID: $SESSION_ID
+Timestamp: $TIMESTAMP
+</session-context>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+};

package/src/features/slash-commands/commands/stop-continuation.ts

@@ -0,0 +1,21 @@
+import type { SlashCommand } from "../types";
+
+export const stopContinuationCommand: SlashCommand = {
+  name: "stop-continuation",
+  description: "Stop all continuation mechanisms (loop, todo continuation) for this session",
+  template: `<command-instruction>
+Stop all continuation mechanisms for the current session.
+
+This command will:
+1. Stop the todo-continuation-enforcer from automatically continuing incomplete tasks
+2. Cancel any active unified Loop
+3. Remove persisted loop state when applicable (.sisyphus/loop-state.json)
+
+After running this command:
+- The session will not auto-continue when idle
+- You can manually continue work when ready
+- Persisted loop sessions will remain stopped across sessions until explicitly restarted
+
+Use this when you need to pause automated continuation and take manual control.
+</command-instruction>`,
+};

package/src/features/slash-commands/index.ts

@@ -0,0 +1,2 @@
+export type { SlashCommand } from "./types";
+export { getCommand, getAllCommands } from "./command-registry";

package/src/features/slash-commands/slash-commands.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "bun:test";
+import { getAllCommands, getCommand } from "./command-registry";
+
+const EXPECTED_COMMAND_NAMES = [
+  "loop",
+  "cancel-loop",
+  "start-work",
+  "stop-continuation",
+  "handoff",
+  "init-deep",
+] as const;
+
+describe("getAllCommands", () => {
+  describe("#given the command registry is initialized", () => {
+    describe("#when getAllCommands is called", () => {
+      it("#then returns all 6 commands", () => {
+        const commands = getAllCommands();
+        expect(commands).toHaveLength(EXPECTED_COMMAND_NAMES.length);
+      });
+
+      it("#then every command has name, description, and template", () => {
+        const commands = getAllCommands();
+        for (const command of commands) {
+          expect(typeof command.name).toBe("string");
+          expect(command.name.length).toBeGreaterThan(0);
+          expect(typeof command.description).toBe("string");
+          expect(command.description.length).toBeGreaterThan(0);
+          expect(typeof command.template).toBe("string");
+          expect(command.template.length).toBeGreaterThan(0);
+        }
+      });
+
+      it("#then all expected command names are present", () => {
+        const commands = getAllCommands();
+        const names = commands.map((c) => c.name);
+        for (const expected of EXPECTED_COMMAND_NAMES) {
+          expect(names).toContain(expected);
+        }
+      });
+    });
+  });
+});
+
+describe("getCommand", () => {
+  describe("#given a valid command name", () => {
+    for (const name of EXPECTED_COMMAND_NAMES) {
+      it(`#then returns '${name}'`, () => {
+        const command = getCommand(name);
+        expect(command).toBeDefined();
+        expect(command?.name).toBe(name);
+      });
+    }
+
+    it("#then returns the start-work command with $ARGUMENTS in template", () => {
+      const command = getCommand("start-work");
+      expect(command?.template).toContain("$ARGUMENTS");
+    });
+  });
+
+  describe("#given an unknown command name", () => {
+    describe("#when getCommand is called with an unregistered name", () => {
+      it("#then returns undefined", () => {
+        const command = getCommand("nonexistent-command");
+        expect(command).toBeUndefined();
+      });
+    });
+  });
+});

package/src/features/slash-commands/types.ts

@@ -0,0 +1,5 @@
+export interface SlashCommand {
+  name: string;
+  description: string;
+  template: string;
+}

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

@@ -0,0 +1,156 @@
+import { describe, expect, it } from "bun:test";
+import { createAnthropicEffortHandler } from "./handler";
+
+function makeInput(providerID: string, modelID: string) {
+  return {
+    sessionID: "ses_test",
+    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("createAnthropicEffortHandler", () => {
+  describe("#given effort level 'medium' and Anthropic model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking with budget_tokens=5000", async () => {
+        const handler = createAnthropicEffortHandler("medium");
+        const input = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 5000,
+        });
+      });
+    });
+  });
+
+  describe("#given effort level 'high' and Anthropic model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking with budget_tokens=10000", async () => {
+        const handler = createAnthropicEffortHandler("high");
+        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("#given effort level 'max' and Anthropic sonnet model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking with budget_tokens=32000 but no effort flag", async () => {
+        const handler = createAnthropicEffortHandler("max");
+        const input = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toEqual({
+          type: "enabled",
+          budget_tokens: 32000,
+        });
+        expect(output.options.effort).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given effort level 'max' and Anthropic opus model", () => {
+    describe("#when chat.params hook is called", () => {
+      it("#then injects thinking and sets effort='max'", async () => {
+        const handler = createAnthropicEffortHandler("max");
+        const input = makeInput("anthropic", "claude-opus-4-6");
+        const output = makeOutput();
+
+        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 = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given default effort level (no argument)", () => {
+    describe("#when chat.params hook is called with Anthropic model", () => {
+      it("#then defaults to 'high' with budget_tokens=10000", async () => {
+        const handler = createAnthropicEffortHandler();
+        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("#given a non-Anthropic model", () => {
+    describe("#when chat.params hook is called with effort 'high'", () => {
+      it("#then does not inject any parameters", async () => {
+        const handler = createAnthropicEffortHandler("high");
+        const input = makeInput("openai", "gpt-5.4");
+        const output = makeOutput();
+
+        await handler(input, output);
+
+        expect(output.options.thinking).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given thinking is already configured", () => {
+    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 = makeInput("anthropic", "claude-sonnet-4-6");
+        const output = makeOutput();
+        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/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,
+      }
+    : {},
+});