goatcode-sh 0.0.1 → 0.1.2

package/src/features/skills/skill-merger.ts

@@ -0,0 +1,15 @@
+import type { Skill } from "./skill-loader";
+
+export function mergeSkills(builtinSkills: Skill[], userSkills: Skill[]): Skill[] {
+  const merged = new Map<string, Skill>();
+
+  for (const builtinSkill of builtinSkills) {
+    merged.set(builtinSkill.name, builtinSkill);
+  }
+
+  for (const userSkill of userSkills) {
+    merged.set(userSkill.name, userSkill);
+  }
+
+  return Array.from(merged.values());
+}

package/src/features/skills/skills.test.ts

@@ -0,0 +1,120 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  createMergedSkillLoader,
+  gitMasterSkill,
+  loadProjectSkills,
+  mergeSkills,
+  registerProjectSkillLoader,
+} from "./index";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+  for (const tempDirectory of tempDirectories.splice(0)) {
+    rmSync(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+describe("#given builtin git-master skill", () => {
+  describe("#when reading its metadata", () => {
+    it("#then it has name, description, and non-empty template", () => {
+      expect(gitMasterSkill.name).toBe("git-master");
+      expect(gitMasterSkill.description.length).toBeGreaterThan(0);
+      expect(gitMasterSkill.template.length).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe("#given project skills in .opencode/skills", () => {
+  describe("#when loading markdown files", () => {
+    it("#then frontmatter + body are parsed into skills", () => {
+      const projectDirectory = createTempProjectDirectory();
+      writeProjectSkill(
+        projectDirectory,
+        "release-checklist.md",
+        `---
+name: release-checklist
+description: release readiness checks
+---
+Validate release notes and run smoke tests.
+`,
+      );
+
+      const loaded = loadProjectSkills(projectDirectory);
+
+      expect(loaded).toHaveLength(1);
+      expect(loaded[0]).toEqual({
+        name: "release-checklist",
+        description: "release readiness checks",
+        template: "Validate release notes and run smoke tests.",
+      });
+    });
+  });
+});
+
+describe("#given builtin and user skills with same name", () => {
+  describe("#when merging skills", () => {
+    it("#then user skill overrides builtin by name", () => {
+      const merged = mergeSkills(
+        [{ name: "git-master", description: "builtin", template: "builtin template" }],
+        [{ name: "git-master", description: "user", template: "user template" }],
+      );
+
+      expect(merged).toHaveLength(1);
+      expect(merged[0]).toEqual({
+        name: "git-master",
+        description: "user",
+        template: "user template",
+      });
+    });
+  });
+});
+
+describe("#given a user override file for git-master", () => {
+  describe("#when creating merged skill loader", () => {
+    it("#then load('git-master') returns user template", () => {
+      const projectDirectory = createTempProjectDirectory();
+      writeProjectSkill(
+        projectDirectory,
+        "git-master.md",
+        `---
+name: git-master
+description: custom project git policy
+---
+Use custom git policy for this repository.
+`,
+      );
+
+      const loader = createMergedSkillLoader(projectDirectory);
+
+      expect(loader.load("git-master")).toBe("Use custom git policy for this repository.");
+    });
+  });
+});
+
+describe("#given registerProjectSkillLoader", () => {
+  describe("#when skillHandler.registerSkillLoader is not available", () => {
+    it("#then logs that registration is unavailable without throwing", () => {
+      //#given
+      const projectDirectory = createTempProjectDirectory();
+
+      //#when / #then — should not throw
+      expect(() => registerProjectSkillLoader(projectDirectory)).not.toThrow();
+    });
+  });
+});
+
+function createTempProjectDirectory(): string {
+  const directory = mkdtempSync(join(tmpdir(), "goatcode-skills-"));
+  tempDirectories.push(directory);
+  return directory;
+}
+
+function writeProjectSkill(projectDirectory: string, fileName: string, contents: string): void {
+  const skillDirectory = join(projectDirectory, ".opencode", "skills");
+  mkdirSync(skillDirectory, { recursive: true });
+  writeFileSync(join(skillDirectory, fileName), contents, "utf8");
+}

package/src/features/slash-commands/command-registry.ts

@@ -0,0 +1,36 @@
+import { log } from "../../shared/logger";
+import type { SlashCommand } from "./types";
+import { loopCommand } from "./commands/loop";
+import { cancelLoopCommand } from "./commands/cancel-loop";
+import { startWorkCommand } from "./commands/start-work";
+import { stopContinuationCommand } from "./commands/stop-continuation";
+import { handoffCommand } from "./commands/handoff";
+import { initDeepCommand } from "./commands/init-deep";
+
+const COMMANDS: SlashCommand[] = [
+  loopCommand,
+  cancelLoopCommand,
+  startWorkCommand,
+  stopContinuationCommand,
+  handoffCommand,
+  initDeepCommand,
+];
+
+const COMMAND_MAP: Map<string, SlashCommand> = new Map();
+for (const cmd of COMMANDS) {
+  if (COMMAND_MAP.has(cmd.name)) {
+    throw new Error(`Duplicate slash command name detected: ${cmd.name}`);
+  }
+  COMMAND_MAP.set(cmd.name, cmd);
+}
+
+export function getCommand(name: string): SlashCommand | undefined {
+  const command = COMMAND_MAP.get(name);
+  log("slash-commands: getCommand", { name, found: command !== undefined });
+  return command;
+}
+
+export function getAllCommands(): SlashCommand[] {
+  log("slash-commands: getAllCommands", { count: COMMANDS.length });
+  return [...COMMANDS];
+}

package/src/features/slash-commands/commands/cancel-loop.ts

@@ -0,0 +1,17 @@
+import type { SlashCommand } from "../types";
+
+export const cancelLoopCommand: SlashCommand = {
+  name: "cancel-loop",
+  description: "Cancel active loop and clear persisted loop state",
+  template: `<command-instruction>
+Cancel the currently active unified loop.
+
+This will:
+1. Stop the loop from continuing
+2. Clear in-memory loop state for the session
+3. Remove only this session's loop entry from .sisyphus/loop-state.json (do not delete other sessions)
+4. Allow the session to end normally
+
+Check if a loop is active, cancel it, and inform the user of the result.
+</command-instruction>`,
+};

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

@@ -0,0 +1,59 @@
+import type { SlashCommand } from "../types";
+
+export const handoffCommand: SlashCommand = {
+  name: "handoff",
+  description: "Create a detailed context summary for continuing work in a new session",
+  template: `<command-instruction>
+# Handoff Command
+
+## Purpose
+
+Use /handoff when:
+- The current session context is getting too long and quality is degrading
+- You want to start fresh while preserving essential context from this session
+- The context window is approaching capacity
+
+This creates a detailed context summary that can be used to continue work in a new session.
+
+## PHASE 1: GATHER PROGRAMMATIC CONTEXT
+
+Execute these tools to gather concrete data:
+
+1. session_read({ session_id: "$SESSION_ID" }) - full session history
+2. todoread() - current task progress
+3. Bash({ command: "git diff --stat HEAD~10..HEAD" }) - recent file changes
+4. Bash({ command: "git status --porcelain" }) - uncommitted changes
+
+## PHASE 2: EXTRACT CONTEXT
+
+Write the context summary from first person perspective ("I did...", "I told you...").
+
+Focus on:
+- Capabilities and behavior, not file-by-file implementation details
+- What matters for continuing the work
+- USER REQUESTS (AS-IS) must be verbatim (do not paraphrase)
+- EXPLICIT CONSTRAINTS must be verbatim only (do not invent)
+
+## PHASE 3: FORMAT OUTPUT
+
+Generate a handoff summary using the HANDOFF CONTEXT format with sections:
+USER REQUESTS (AS-IS), GOAL, WORK COMPLETED, CURRENT STATE, PENDING TASKS,
+KEY FILES, IMPORTANT DECISIONS, EXPLICIT CONSTRAINTS, CONTEXT FOR CONTINUATION.
+
+## IMPORTANT CONSTRAINTS
+
+- DO NOT attempt to programmatically create new sessions
+- DO provide a self-contained summary that works without access to this session
+- DO NOT include sensitive information (API keys, credentials, secrets)
+- DO NOT exceed 10 files in the KEY FILES section
+</command-instruction>
+
+<session-context>
+Session ID: $SESSION_ID
+Timestamp: $TIMESTAMP
+</session-context>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+};

package/src/features/slash-commands/commands/init-deep.ts

@@ -0,0 +1,40 @@
+import type { SlashCommand } from "../types";
+
+export const initDeepCommand: SlashCommand = {
+  name: "init-deep",
+  description: "Initialize hierarchical AGENTS.md knowledge base",
+  template: `<command-instruction>
+# /init-deep
+
+Generate hierarchical AGENTS.md files. Root + complexity-scored subdirectories.
+
+## Usage
+
+\`\`\`
+/init-deep                      # Update mode: modify existing + create new where warranted
+/init-deep --create-new         # Read existing -> remove all -> regenerate from scratch
+/init-deep --max-depth=2        # Limit directory depth (default: 3)
+\`\`\`
+
+## Workflow
+
+1. **Discovery + Analysis** (concurrent)
+   - Fire background explore agents immediately
+   - Main session: bash structure + LSP codemap + read existing AGENTS.md
+2. **Score & Decide** - Determine AGENTS.md locations from merged findings
+3. **Generate** - Root first, then subdirs in parallel
+4. **Review** - Deduplicate, trim, validate
+
+## Critical Rules
+
+- TodoWrite ALL phases. Mark in_progress -> completed in real-time.
+- Root AGENTS.md is ALWAYS created
+- Child AGENTS.md never repeats parent content
+- Remove generic advice that applies to ALL projects
+- Telegraphic style: dense, no filler
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+};

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

@@ -0,0 +1,39 @@
+import type { SlashCommand } from "../types";
+
+export const loopCommand: SlashCommand = {
+  name: "loop",
+  description: "Start unified continuation loop until completion",
+  template: `<command-instruction>
+You are starting a unified LOOP that can run in memory or with disk persistence.
+
+## How LOOP Works
+
+1. You will work on the task continuously
+2. When fully complete, output: \`<promise>{{COMPLETION_PROMISE}}</promise>\`
+3. If the promise is not emitted, the loop injects a continuation prompt automatically
+
+## Options
+
+- \`--persist\`: use disk-backed state in \`.sisyphus/loop-state.json\` (resumable)
+- without \`--persist\`: in-memory loop state (default)
+- \`--max-iterations=N\`: set an explicit iteration limit
+
+Default completion promise is "DONE".
+Default max iterations is 100 for in-memory loops and 1000 for persisted loops.
+
+## Exit Conditions
+
+1. **Completion**: You emit the completion promise tag
+2. **Max Iterations**: Loop stops at configured limit
+3. **Cancel**: User runs \`/cancel-loop\`
+
+## Your Task
+
+Parse the arguments below and begin working on the task. The format is:
+\`"task description" [--completion-promise=TEXT] [--max-iterations=N] [--persist] [--strategy=reset|continue]\`
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+};

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