goatcode-sh 0.0.1 → 0.1.2

package/src/agents/tool-restrictions.ts

@@ -0,0 +1,87 @@
+export type ToolRestriction = {
+  denied?: string[];
+  allowed?: string[];
+};
+
+const ALL_KNOWN_TOOLS = [
+  // Core file operations (OpenCode built-ins)
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "glob",
+  "grep",
+  "task",
+  "todowrite",
+  // LSP tools
+  "lsp_goto_definition",
+  "lsp_find_references",
+  "lsp_symbols",
+  "lsp_diagnostics",
+  "lsp_prepare_rename",
+  "lsp_rename",
+  // AST tools
+  "ast_grep_search",
+  "ast_grep_replace",
+  // Web tools
+  "webfetch",
+  "websearch",
+  "codesearch",
+  // GoatCode custom tools
+  "hashline_edit",
+  "interactive_bash",
+  "look_at",
+  "delegate_task",
+  "background_output",
+  "background_cancel",
+  "session_list",
+  "session_read",
+  "session_search",
+  "session_info",
+  "skill",
+  "skill_mcp",
+  "task_create",
+  "task_list",
+  "task_get",
+  "task_update",
+];
+
+export const AGENT_TOOL_RESTRICTIONS: Record<string, ToolRestriction> = {
+  advisor: {
+    denied: [
+      "write",
+      "edit",
+      "bash",
+      "interactive_bash",
+      "delegate_task",
+      "task_create",
+      "task_update",
+    ],
+  },
+};
+
+export function getToolRestrictions(agentName: string): ToolRestriction {
+  return AGENT_TOOL_RESTRICTIONS[agentName] ?? { denied: [] };
+}
+
+export function buildToolsMap(agentName: string): Record<string, boolean> | undefined {
+  const restriction = AGENT_TOOL_RESTRICTIONS[agentName];
+  if (!restriction) return undefined;
+
+  const tools: Record<string, boolean> = {};
+
+  if (restriction.allowed) {
+    for (const tool of ALL_KNOWN_TOOLS) {
+      tools[tool] = false;
+    }
+    for (const tool of restriction.allowed) {
+      tools[tool] = true;
+    }
+  } else if (restriction.denied) {
+    for (const tool of restriction.denied) {
+      tools[tool] = false;
+    }
+  }
+
+  return Object.keys(tools).length > 0 ? tools : undefined;
+}

package/src/agents/worker/config.ts

@@ -0,0 +1,6 @@
+import type { AgentMode } from "../../types/agent";
+import { DEFAULT_TEMPERATURE } from "../../config/defaults";
+
+export const WORKER_TEMPERATURE = DEFAULT_TEMPERATURE;
+export const WORKER_MODE: AgentMode = "subagent";
+export const WORKER_FALLBACK_MODELS = ["gpt-5.3-codex"];

package/src/agents/worker/index.ts

@@ -0,0 +1,2 @@
+export { workerPlugin } from "./plugin";
+export * from "./config";

package/src/agents/worker/plugin.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "bun:test";
+import { workerPlugin } from "./plugin";
+
+describe("workerPlugin", () => {
+  describe("#given the worker plugin", () => {
+    describe("#when inspecting plugin metadata", () => {
+      it("#then has the correct plugin name", () => {
+        expect(workerPlugin.name).toBe("worker");
+      });
+    });
+
+    describe("#when inspecting the agent config", () => {
+      it("#then mode is 'subagent'", () => {
+        const agent = workerPlugin.agents!.worker;
+        expect(agent.mode).toBe("subagent");
+      });
+
+      it("#then has a temperature and non-empty prompt", () => {
+        const agent = workerPlugin.agents!.worker;
+        expect(typeof agent.temperature).toBe("number");
+        expect(typeof agent.prompt).toBe("string");
+        expect(agent.prompt!.length).toBeGreaterThan(0);
+      });
+
+      it("#then does not define tool restrictions", () => {
+        const agent = workerPlugin.agents!.worker;
+        expect(agent.tools).toBeUndefined();
+      });
+    });
+  });
+});

package/src/agents/worker/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api";
+import { WORKER_TEMPERATURE, WORKER_MODE } from "./config";
+import { WORKER_PROMPT } from "./prompt";
+
+export const workerPlugin = definePlugin({
+  name: "worker",
+  version: "0.1.0",
+  agents: {
+    worker: {
+      temperature: WORKER_TEMPERATURE,
+      mode: WORKER_MODE,
+      prompt: WORKER_PROMPT,
+    },
+  },
+});

package/src/agents/worker/prompt-meta.ts

@@ -0,0 +1,14 @@
+import type { PromptMeta } from "../prompt-meta";
+
+export const WORKER_PROMPT_META: PromptMeta = {
+  version: "1.0.0",
+  date: "2025-03-28",
+  summary: "Executes assigned atomic tasks with concrete completion evidence.",
+  changelog: [
+    {
+      version: "1.0.0",
+      date: "2025-03-28",
+      description: "Production-grade prompt with structured sections and quality gates",
+    },
+  ],
+};

package/src/agents/worker/prompt.ts

@@ -0,0 +1,83 @@
+export const WORKER_PROMPT = `# Role
+You are GoatCode's focused execution worker.
+You are assigned one bounded task. Complete it fully, verify it, and report evidence.
+
+You do not broaden scope.
+
+# Execution Contract
+- Deliver exactly the assigned outcome.
+- Follow the assigned category/domain conventions.
+- Keep changes minimal and targeted.
+- Verify before claiming completion.
+
+# Working Method
+
+## 1) Parse Assignment
+- Extract explicit requirements.
+- Extract implicit constraints from context.
+- Identify acceptance checks before editing.
+
+## 2) Execute Precisely
+- Edit only relevant files.
+- Match existing style and architecture.
+- Avoid incidental refactors.
+
+## 3) Verify Rigorously
+- Run diagnostics for changed files.
+- Run build/test commands required by task.
+- Confirm outputs, not assumptions.
+
+## 4) Report
+- What was changed.
+- Why it satisfies requirements.
+- Verification evidence.
+- Any unresolved blockers.
+
+# Category Alignment
+Respect category intent (e.g., quick fix, deep logic, visual work).
+If category guidance and assignment conflict, prioritize explicit assignment and note the conflict.
+
+# Scope Discipline
+- Do not pick up adjacent tasks.
+- Do not add "nice to have" enhancements.
+- Do not redesign architecture unless explicitly required.
+
+# Evidence Standard
+No completion claim without command evidence.
+
+Evidence examples:
+- LSP diagnostics output (clean).
+- Build command exit code 0.
+- Test command pass output.
+
+If verification fails:
+- Report failure honestly.
+- Include failure details.
+- Provide next corrective action.
+
+# Anti-Patterns to Avoid
+- Assuming correctness without running checks.
+- Touching unrelated files "while here".
+- Hiding uncertainty.
+- Excessive rewrites for small tasks.
+- Type safety bypasses as shortcut fixes.
+
+# Tool Usage Guidance
+- Use search/read tools to localize changes fast.
+- Use edit tools surgically.
+- Use bash for reproducible verification commands.
+- Use diagnostics before final response.
+
+# Hard Constraints
+- No delegation: execute task yourself.
+- No as any, @ts-ignore, @ts-expect-error.
+- No commits/pushes unless user explicitly requests.
+- No task expansion beyond assigned objective.
+
+# Completion Checklist
+- Assigned objective fully met.
+- Only relevant files changed.
+- Diagnostics clean on changed files.
+- Build/test checks passed as required.
+- Final response includes concrete evidence.
+`;

package/src/bootstrap.integration.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, describe, expect, it, mock } from "bun:test";
+
+const BOOTSTRAP_TEST_DIRECTORY = "/tmp/bootstrap-integration-test-project";
+
+let loadConfigImpl: (projectDir: string) => Promise<unknown> = async () => undefined;
+let realLoadConfig: ((projectDir: string) => Promise<unknown>) | null = null;
+const originalStructuredClone = globalThis.structuredClone;
+
+const passthroughStructuredClone = ((value: unknown) => value) as typeof structuredClone;
+
+mock.module("./config/loader", () => ({
+  loadConfig: (projectDir: string) => {
+    if (projectDir === BOOTSTRAP_TEST_DIRECTORY) {
+      return loadConfigImpl(projectDir);
+    }
+    if (!realLoadConfig) {
+      throw new Error("real loadConfig is not initialized");
+    }
+    return realLoadConfig(projectDir);
+  },
+}));
+
+import { bootstrap } from "./bootstrap";
+import { createMockPluginContext } from "./test-utils/mock-plugin-context";
+
+const unmockedLoaderModule = (await import(`./config/loader.ts?unmocked=${Date.now()}`)) as {
+  loadConfig: (projectDir: string) => Promise<unknown>;
+};
+realLoadConfig = unmockedLoaderModule.loadConfig;
+
+function createBootstrapContext() {
+  return createMockPluginContext({ directory: BOOTSTRAP_TEST_DIRECTORY });
+}
+
+const EXPECTED_TOOL_NAMES = [
+  "grep",
+  "glob",
+  "hashline_edit",
+  "look_at",
+  "skill",
+  "task",
+  "lsp_goto_definition",
+  "lsp_find_references",
+  "lsp_symbols",
+  "lsp_diagnostics",
+  "lsp_prepare_rename",
+  "lsp_rename",
+  "ast_grep_search",
+  "ast_grep_replace",
+  "background_output",
+  "background_cancel",
+  "session_list",
+  "session_read",
+  "session_search",
+  "session_info",
+  "task_create",
+  "task_list",
+  "task_get",
+  "task_update",
+] as const;
+
+const EXPECTED_AGENT_NAMES = [
+  "orchestrator",
+  "deep-worker",
+  "planner",
+  "advisor",
+  "researcher",
+  "explorer",
+  "worker",
+] as const;
+
+describe("bootstrap", () => {
+  afterEach(() => {
+    loadConfigImpl = async () => undefined;
+    globalThis.structuredClone = originalStructuredClone;
+  });
+
+  describe("#given default config", () => {
+    describe("#when bootstrap is executed", () => {
+      it("#then registers all built-in GoatCode tools in hooks.tool", async () => {
+        globalThis.structuredClone = passthroughStructuredClone;
+        const hooks = await bootstrap(createBootstrapContext());
+
+        expect(hooks.tool).toBeDefined();
+        for (const name of EXPECTED_TOOL_NAMES) {
+          expect(hooks.tool?.[name]).toBeDefined();
+        }
+      });
+
+      it("#then registers all built-in GoatCode agents through the config hook", async () => {
+        globalThis.structuredClone = passthroughStructuredClone;
+        const hooks = await bootstrap(createBootstrapContext());
+        expect(hooks.config).toBeDefined();
+
+        if (!hooks.config) {
+          throw new Error("Expected hooks.config to be defined");
+        }
+
+        type ConfigInput = Parameters<NonNullable<typeof hooks.config>>[0];
+        const input = { agent: {} } as ConfigInput;
+
+        await hooks.config(input);
+
+        const configuredAgents = input.agent ?? {};
+        for (const name of EXPECTED_AGENT_NAMES) {
+          expect(configuredAgents[name]).toBeDefined();
+        }
+        const configuredAgentNames = Object.keys(configuredAgents);
+        const allowedExtraAgents = new Set(["build", "plan"]);
+        const unexpectedAgents = configuredAgentNames.filter(
+          (name) =>
+            !EXPECTED_AGENT_NAMES.includes(name as (typeof EXPECTED_AGENT_NAMES)[number]) &&
+            !allowedExtraAgents.has(name),
+        );
+        expect(unexpectedAgents).toEqual([]);
+        expect(configuredAgentNames.length).toBeGreaterThanOrEqual(EXPECTED_AGENT_NAMES.length);
+      });
+
+      it("#then exposes key hook event slots as callable functions", async () => {
+        globalThis.structuredClone = passthroughStructuredClone;
+        const hooks = await bootstrap(createBootstrapContext());
+
+        expect(typeof hooks["tool.execute.before"]).toBe("function");
+        expect(typeof hooks["tool.execute.after"]).toBe("function");
+        expect(typeof hooks["chat.params"]).toBe("function");
+        expect(typeof hooks["tool.definition"]).toBe("function");
+      });
+    });
+  });
+
+  describe("#given invalid raw config from loader", () => {
+    describe("#when bootstrap is executed", () => {
+      it("#then falls back to defaults, returns hooks, and warns to stderr", async () => {
+        loadConfigImpl = async () => ({ agents: "invalid" });
+        globalThis.structuredClone = passthroughStructuredClone;
+
+        const originalStderrWrite = process.stderr.write;
+        const stderrWriteSpy = mock((..._args: unknown[]) => true);
+        process.stderr.write = stderrWriteSpy as typeof process.stderr.write;
+
+        try {
+          const hooks = await bootstrap(createBootstrapContext());
+
+          expect(hooks.tool).toBeDefined();
+          expect(hooks.tool?.grep).toBeDefined();
+          expect(stderrWriteSpy).toHaveBeenCalled();
+          expect(stderrWriteSpy.mock.calls[0]?.[0]).toContain("validation errors");
+        } finally {
+          process.stderr.write = originalStderrWrite;
+        }
+      });
+    });
+  });
+
+  describe("#given disabled_tools config", () => {
+    describe("#when bootstrap is executed", () => {
+      it("#then excludes disabled tools from hooks.tool", async () => {
+        loadConfigImpl = async () => ({ disabled_tools: ["grep"] });
+        globalThis.structuredClone = passthroughStructuredClone;
+
+        const hooks = await bootstrap(createBootstrapContext());
+
+        expect(hooks.tool?.grep).toBeUndefined();
+        expect(hooks.tool?.glob).toBeDefined();
+      });
+    });
+  });
+});

package/src/bootstrap.ts

@@ -0,0 +1,171 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import { loadConfig } from "./config/loader";
+import { validateConfig } from "./config/validator";
+import { PluginRegistry } from "./registry/plugin-registry";
+import { compose } from "./plugin/compositor";
+import { log } from "./shared/logger";
+import type { OpenCodeContext } from "./types/plugin";
+import type { GoatCodeConfig } from "./types/config";
+import type { PluginDefinition } from "./types/plugin";
+import { BUILTIN_AGENT_PLUGINS } from "./agents/builtin-agents";
+import { BUILTIN_HOOK_PLUGINS } from "./hooks/builtin-hooks";
+import { BUILTIN_TOOL_PLUGINS } from "./tools/builtin-tools";
+import { BUILTIN_FEATURE_PLUGINS } from "./features/builtin-features";
+import { registerProjectSkillLoader } from "./features/skills";
+import {
+  buildDiscoveryIndex,
+  initializeDiscovery,
+  resetDiscovery,
+  type ProviderListResponse,
+} from "./shared/provider-discovery";
+import {
+  resetProviderRegistry,
+  setDefaultPreferredProvider,
+  setProviderPriority,
+} from "./shared/provider-registry";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isValidPluginDefinition(value: unknown): value is PluginDefinition {
+  if (!isRecord(value)) return false;
+  const obj = value;
+
+  // Required: non-empty name string
+  if (typeof obj["name"] !== "string" || obj["name"] === "") return false;
+
+  // Optional: dependencies must be array of strings if present
+  if (obj["dependencies"] !== undefined) {
+    if (!isStringArray(obj["dependencies"])) return false;
+  }
+
+  // Optional: hooks/tools/agents must be plain objects if present
+  for (const key of ["hooks", "tools", "agents"] as const) {
+    if (obj[key] !== undefined) {
+      if (typeof obj[key] !== "object" || obj[key] === null || Array.isArray(obj[key]))
+        return false;
+    }
+  }
+
+  if (obj["hooks"] !== undefined) {
+    for (const handler of Object.values(obj["hooks"] as Record<string, unknown>)) {
+      if (handler !== undefined && typeof handler !== "function") return false;
+    }
+  }
+
+  // Optional: setup/teardown must be functions if present
+  if (obj["setup"] !== undefined && typeof obj["setup"] !== "function") return false;
+  if (obj["teardown"] !== undefined && typeof obj["teardown"] !== "function") return false;
+
+  return true;
+}
+
+export async function bootstrap(ctx: OpenCodeContext): Promise<Hooks> {
+  const rawConfig = await loadConfig(ctx.directory);
+
+  const validation = validateConfig(rawConfig ?? {});
+  let config: GoatCodeConfig;
+  if (validation.success) {
+    config = validation.config;
+  } else {
+    log("[bootstrap] Config validation failed, using defaults", {
+      errors: validation.errors,
+    });
+    process.stderr.write(
+      `[goatcode] WARNING: goatcode.config.ts has validation errors — using defaults.\n` +
+        validation.errors.map((e) => `  - ${e}`).join("\n") +
+        "\n",
+    );
+    const fallback = validateConfig({});
+    if (!fallback.success) {
+      throw new Error("[bootstrap] Default config validation failed");
+    }
+    config = fallback.config;
+  }
+
+  resetProviderRegistry();
+  resetDiscovery();
+  setProviderPriority(config.provider_priority ?? []);
+  setDefaultPreferredProvider(config.default_provider);
+  try {
+    const DISCOVERY_TIMEOUT_MS = 5_000;
+    const providerResponse = (await Promise.race([
+      ctx.client.provider.list(),
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () => reject(new Error(`provider.list timeout after ${DISCOVERY_TIMEOUT_MS}ms`)),
+          DISCOVERY_TIMEOUT_MS,
+        ),
+      ),
+    ])) as Awaited<ReturnType<typeof ctx.client.provider.list>>;
+    const providerData = providerResponse?.data as ProviderListResponse | undefined;
+    if (providerData?.all && providerData?.connected) {
+      const discovery = buildDiscoveryIndex(providerData);
+      initializeDiscovery(discovery);
+    } else {
+      log("[bootstrap] Provider discovery response missing required fields");
+    }
+  } catch (error) {
+    log("[bootstrap] Provider discovery failed; using pass-through model resolution", { error });
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(
+      `[goatcode] WARNING: Provider discovery failed (${msg}) — model provider resolution will use pass-through fallback.\n`,
+    );
+  }
+
+  const registry = new PluginRegistry();
+
+  for (const plugin of BUILTIN_AGENT_PLUGINS) {
+    registry.register(plugin);
+  }
+
+  for (const plugin of BUILTIN_HOOK_PLUGINS) {
+    registry.register(plugin);
+  }
+
+  for (const plugin of BUILTIN_TOOL_PLUGINS) {
+    registry.register(plugin);
+  }
+
+  for (const plugin of BUILTIN_FEATURE_PLUGINS) {
+    registry.register(plugin);
+  }
+
+  for (const packageName of config.plugins ?? []) {
+    try {
+      const mod = await import(packageName);
+      const pluginDef = mod.default ?? mod;
+      if (!isValidPluginDefinition(pluginDef)) {
+        log(
+          `[bootstrap] External plugin "${packageName}" does not export a valid PluginDefinition, skipping`,
+        );
+        process.stderr.write(
+          `[goatcode] WARNING: Plugin "${packageName}" is not a valid PluginDefinition and was skipped.\n`,
+        );
+        continue;
+      }
+      registry.register(pluginDef);
+    } catch (error) {
+      log(`[bootstrap] Failed to load external plugin: ${packageName}`, { error });
+      const msg = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[goatcode] WARNING: Failed to load plugin "${packageName}": ${msg}\n`);
+    }
+  }
+
+  registerProjectSkillLoader(ctx.directory);
+
+  const resolved = registry.resolve();
+  const initializedPlugins = await registry.setup(resolved, ctx);
+
+  const aggregated = registry.aggregate(initializedPlugins, {
+    disabledAgents: config.disabled_agents,
+    disabledHooks: config.disabled_hooks,
+    disabledTools: config.disabled_tools,
+  });
+  return compose(aggregated);
+}

package/src/cli/cli.ts

@@ -0,0 +1,42 @@
+import { Command } from "commander";
+import { log } from "../shared/logger";
+import { handleUpdateCommand } from "./commands/update";
+import packageJson from "../../package.json" with { type: "json" };
+
+const VERSION = packageJson.version;
+
+export function createProgram(): Command {
+  const program = new Command();
+
+  program
+    .name("goatcode-sh")
+    .description(
+      "Enterprise-grade OpenCode plugin with micro-plugin architecture and multi-agent orchestration",
+    )
+    .version(VERSION, "-v, --version", "Show version number");
+
+  program
+    .command("install")
+    .description("Install and configure goatcode")
+    .option("--non-interactive", "Skip interactive prompts and use defaults")
+    .option("--force", "Overwrite existing config file")
+    .action(async (options) => {
+      log("cli: install command invoked");
+      const { installCommand } = await import("./commands/install");
+      await installCommand({ nonInteractive: options.nonInteractive, force: options.force });
+    });
+
+  program
+    .command("update")
+    .description("Update goatcode to the latest version")
+    .action(async () => {
+      await handleUpdateCommand();
+    });
+
+  return program;
+}
+
+export function runCli(): void {
+  const program = createProgram();
+  program.parse();
+}

package/src/cli/commands/install.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { BUILTIN_AGENT_PLUGINS } from "../../agents/builtin-agents";
+import { installCommand } from "./install";
+
+describe("#given the install command", () => {
+  describe("#when run with --non-interactive", () => {
+    it("#then it generates goatcode.config.ts with defineConfig", async () => {
+      const tempDir = mkdtempSync(join(tmpdir(), "goatcode-install-test-"));
+
+      try {
+        const configPath = await installCommand({ nonInteractive: true, cwd: tempDir });
+        const content = readFileSync(configPath, "utf8");
+
+        expect(configPath).toBe(join(tempDir, "goatcode.config.ts"));
+        expect(content).toContain('import { defineConfig } from "goatcode-sh"');
+        expect(content).toContain("export default defineConfig({");
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    it("#then generated config lists all built-in plugins", async () => {
+      const tempDir = mkdtempSync(join(tmpdir(), "goatcode-install-test-"));
+
+      try {
+        const configPath = await installCommand({ nonInteractive: true, cwd: tempDir });
+        const content = readFileSync(configPath, "utf8");
+
+        for (const plugin of BUILTIN_AGENT_PLUGINS) {
+          expect(content).toContain(`"${plugin.name}"`);
+        }
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
+});