goatcode-sh 0.0.1 → 0.1.3

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

package/src/cli/commands/install.ts

@@ -0,0 +1,125 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { BUILTIN_AGENT_PLUGINS } from "../../agents/builtin-agents";
+import { log } from "../../shared/logger";
+
+interface InstallDefaults {
+  autoUpdate: boolean;
+  plugins: string[];
+}
+
+export interface InstallCommandOptions {
+  nonInteractive?: boolean;
+  force?: boolean;
+  cwd?: string;
+}
+
+const CONFIG_FILE_NAME = "goatcode.config.ts";
+
+function getDefaultInstallConfig(): InstallDefaults {
+  return {
+    autoUpdate: true,
+    plugins: BUILTIN_AGENT_PLUGINS.map((plugin) => plugin.name),
+  };
+}
+
+function parseBooleanInput(inputValue: string, fallback: boolean): boolean {
+  const normalized = inputValue.trim().toLowerCase();
+  if (normalized === "") return fallback;
+  if (normalized === "y" || normalized === "yes" || normalized === "true") return true;
+  if (normalized === "n" || normalized === "no" || normalized === "false") return false;
+  return fallback;
+}
+
+function parsePluginInput(inputValue: string, fallback: string[]): string[] {
+  const normalized = inputValue.trim();
+  if (normalized === "") return fallback;
+  return normalized
+    .split(",")
+    .map((part) => part.trim())
+    .filter((value, index, array) => value !== "" && array.indexOf(value) === index);
+}
+
+function getConfigTemplate(config: InstallDefaults): string {
+  const pluginLines = config.plugins.map((plugin) => `    ${JSON.stringify(plugin)},`).join("\n");
+  return `import { defineConfig } from "goatcode-sh"
+
+export default defineConfig({
+  // Agent-level model and behavior overrides.
+  agents: {},
+
+  // Category-level defaults for delegated tasks.
+  categories: {},
+
+  // Disable built-in runtime components by name.
+  disabled_agents: [],
+  disabled_hooks: [],
+  disabled_tools: [],
+  disabled_skills: [],
+
+  // Keep goatcode updated automatically.
+  auto_update: ${String(config.autoUpdate)},
+
+  // External and internal micro-plugins to load.
+  plugins: [
+${pluginLines}
+  ],
+})
+`;
+}
+
+async function promptInstallConfig(defaults: InstallDefaults): Promise<InstallDefaults> {
+  const rl = createInterface({ input, output });
+  try {
+    output.write("goatcode install: interactive setup\n");
+    const autoUpdateAnswer = await rl.question(
+      `Enable auto-update checks? (Y/n) [${defaults.autoUpdate ? "Y" : "N"}]: `,
+    );
+    const pluginsAnswer = await rl.question(
+      `Plugins (comma-separated) [${defaults.plugins.join(", ")}]: `,
+    );
+
+    return {
+      autoUpdate: parseBooleanInput(autoUpdateAnswer, defaults.autoUpdate),
+      plugins: parsePluginInput(pluginsAnswer, defaults.plugins),
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+export async function installCommand(options: InstallCommandOptions = {}): Promise<string> {
+  const defaults = getDefaultInstallConfig();
+  const config = options.nonInteractive ? defaults : await promptInstallConfig(defaults);
+  const configContent = getConfigTemplate(config);
+  const targetDirectory = options.cwd ?? process.cwd();
+  const configPath = resolve(targetDirectory, CONFIG_FILE_NAME);
+
+  if (!options.force) {
+    try {
+      await writeFile(configPath, configContent, { encoding: "utf8", flag: "wx" });
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "EEXIST") {
+        output.write(
+          `${CONFIG_FILE_NAME} already exists at ${configPath}. Use --force to overwrite.\n`,
+        );
+        return configPath;
+      }
+      throw err;
+    }
+  } else {
+    await writeFile(configPath, configContent, "utf8");
+  }
+
+  log("cli: install config generated", {
+    nonInteractive: options.nonInteractive ?? false,
+    configPath,
+  });
+  output.write(`Created ${CONFIG_FILE_NAME} at ${configPath}\n`);
+
+  return configPath;
+}
+
+export { getConfigTemplate };

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

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { handleUpdateCommand } from "./update";
+
+describe("#given update command", () => {
+  let stdoutWrites: string[] = [];
+  let originalWrite: any;
+  let originalFetch: any;
+  let originalSpawn: any;
+
+  beforeEach(() => {
+    stdoutWrites = [];
+    originalWrite = process.stdout.write;
+    originalFetch = globalThis.fetch;
+    originalSpawn = Bun.spawn;
+
+    process.stdout.write = ((text: string) => {
+      stdoutWrites.push(text);
+      return true;
+    }) as any;
+  });
+
+  afterEach(() => {
+    process.stdout.write = originalWrite;
+    globalThis.fetch = originalFetch;
+    Bun.spawn = originalSpawn;
+  });
+
+  describe("#when update is available", () => {
+    it("#then runs bun update goatcode-sh", async () => {
+      globalThis.fetch = (() => {
+        return Promise.resolve(new Response(JSON.stringify({ version: "0.2.0" })));
+      }) as any;
+
+      Bun.spawn = (() => {
+        return {
+          exited: Promise.resolve(0),
+        };
+      }) as any;
+
+      await handleUpdateCommand();
+      expect(stdoutWrites.some((w) => w.includes("Update available"))).toBe(true);
+      expect(stdoutWrites.some((w) => w.includes("bun update goatcode-sh"))).toBe(true);
+    });
+  });
+
+  describe("#when already up to date", () => {
+    it("#then prints already up to date message", async () => {
+      globalThis.fetch = (() => {
+        return Promise.resolve(new Response(JSON.stringify({ version: "0.1.0" })));
+      }) as any;
+
+      await handleUpdateCommand();
+      expect(stdoutWrites.some((w) => w.includes("Already up to date"))).toBe(true);
+    });
+  });
+
+  describe("#when npm check fails", () => {
+    it("#then reports failure gracefully", async () => {
+      globalThis.fetch = (() => {
+        return Promise.reject(new Error("Network error"));
+      }) as any;
+
+      await handleUpdateCommand();
+      expect(stdoutWrites.some((w) => w.includes("Failed to check for updates"))).toBe(true);
+    });
+  });
+
+  describe("#when bun update fails", () => {
+    it("#then reports exit code", async () => {
+      globalThis.fetch = (() => {
+        return Promise.resolve(new Response(JSON.stringify({ version: "0.2.0" })));
+      }) as any;
+
+      Bun.spawn = (() => {
+        return {
+          exited: Promise.resolve(1),
+        };
+      }) as any;
+
+      await handleUpdateCommand();
+      expect(stdoutWrites.some((w) => w.includes("exit code 1"))).toBe(true);
+    });
+  });
+});

package/src/cli/commands/update.ts

@@ -0,0 +1,45 @@
+import { log } from "../../shared/logger";
+import { checkForUpdate } from "../../features/auto-update/update-checker";
+import packageJson from "../../../package.json" with { type: "json" };
+
+const VERSION = packageJson.version;
+const PACKAGE_NAME = packageJson.name;
+
+export async function handleUpdateCommand(): Promise<void> {
+  try {
+    log("cli: update command invoked");
+
+    const result = await checkForUpdate(VERSION);
+
+    if (result.error) {
+      process.stdout.write("Failed to check for updates. Please try again later.\n");
+      return;
+    }
+
+    if (!result.updateAvailable) {
+      process.stdout.write(`Already up to date (v${result.current})\n`);
+      return;
+    }
+
+    process.stdout.write(`Update available: v${result.current} -> v${result.latest}\n`);
+    process.stdout.write(`Running: bun update ${PACKAGE_NAME}\n`);
+
+    const proc = Bun.spawn(["bun", "update", PACKAGE_NAME], {
+      stdio: ["inherit", "inherit", "inherit"],
+    });
+
+    const exitCode = await proc.exited;
+
+    if (exitCode === 0) {
+      process.stdout.write("Update completed successfully!\n");
+      log("cli: update command completed successfully");
+    } else {
+      process.stdout.write(`Update failed with exit code ${exitCode}\n`);
+      log("cli: update command failed", { exitCode });
+    }
+  } catch (error) {
+    log("cli: update command error", error);
+    process.stdout.write("Error during update: " + String(error) + "\n");
+    process.exit(1);
+  }
+}

package/src/cli/config-generator.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { generateConfig } from "./config-generator";
+
+describe("#given generateConfig with default options", () => {
+  describe("#when called with no arguments", () => {
+    it("#then the output contains the defineConfig import", () => {
+      const result = generateConfig();
+      expect(result).toContain('import { defineConfig } from "goatcode-sh"');
+    });
+
+    it("#then the output contains the defineConfig call", () => {
+      const result = generateConfig();
+      expect(result).toContain("export default defineConfig({");
+    });
+
+    it("#then the output contains agent override comments", () => {
+      const result = generateConfig();
+      expect(result).toContain("// agents: {");
+    });
+
+    it("#then the output contains all active agent names in comments", () => {
+      const result = generateConfig();
+      expect(result).toContain('"orchestrator"');
+      expect(result).toContain('"deep-worker"');
+      expect(result).toContain('"planner"');
+      expect(result).toContain('"advisor"');
+      expect(result).toContain('"researcher"');
+      expect(result).toContain('"explorer"');
+      expect(result).toContain('"worker"');
+    });
+
+    it("#then the output does not contain disabled agent names", () => {
+      const result = generateConfig();
+      expect(result).not.toContain('"executor"');
+      expect(result).not.toContain('"analyst"');
+      expect(result).not.toContain('"reviewer"');
+      expect(result).not.toContain('"inspector"');
+    });
+
+    it("#then the output contains category override comments", () => {
+      const result = generateConfig();
+      expect(result).toContain("// categories: {");
+    });
+
+    it("#then the output contains all built-in category names in comments", () => {
+      const result = generateConfig();
+      expect(result).toContain('//   "visual-engineering":');
+      expect(result).toContain('//   "ultrabrain":');
+      expect(result).toContain('//   "deep":');
+      expect(result).toContain('//   "artistry":');
+      expect(result).toContain('//   "quick":');
+      expect(result).toContain('//   "unspecified-low":');
+      expect(result).toContain('//   "unspecified-high":');
+      expect(result).toContain('//   "writing":');
+    });
+
+    it("#then the output contains the plugins array", () => {
+      const result = generateConfig();
+      expect(result).toContain("plugins: [");
+    });
+
+    it("#then the output lists all active micro-plugins", () => {
+      const result = generateConfig();
+      expect(result).toContain('"goatcode-sh/orchestrator"');
+      expect(result).toContain('"goatcode-sh/deep-worker"');
+      expect(result).toContain('"goatcode-sh/planner"');
+      expect(result).toContain('"goatcode-sh/advisor"');
+      expect(result).toContain('"goatcode-sh/researcher"');
+      expect(result).toContain('"goatcode-sh/explorer"');
+      expect(result).toContain('"goatcode-sh/worker"');
+    });
+
+    it("#then the output does not list disabled micro-plugins", () => {
+      const result = generateConfig();
+      expect(result).not.toContain('"goatcode-sh/executor"');
+      expect(result).not.toContain('"goatcode-sh/analyst"');
+      expect(result).not.toContain('"goatcode-sh/reviewer"');
+      expect(result).not.toContain('"goatcode-sh/inspector"');
+    });
+
+    it("#then the output ends with a newline", () => {
+      const result = generateConfig();
+      expect(result.endsWith("\n")).toBe(true);
+    });
+  });
+});
+
+describe("#given generateConfig with includePlugins: false", () => {
+  describe("#when called with includePlugins disabled", () => {
+    it("#then the output does not contain the plugins array", () => {
+      const result = generateConfig({ includePlugins: false });
+      expect(result).not.toContain("plugins: [");
+    });
+
+    it("#then the output still contains the defineConfig import", () => {
+      const result = generateConfig({ includePlugins: false });
+      expect(result).toContain('import { defineConfig } from "goatcode-sh"');
+    });
+  });
+});
+
+describe("#given generateConfig with includeAgents: false", () => {
+  describe("#when called with includeAgents disabled", () => {
+    it("#then the output does not contain agent override comments", () => {
+      const result = generateConfig({ includeAgents: false });
+      expect(result).not.toContain("// agents: {");
+    });
+
+    it("#then the output still contains category override comments", () => {
+      const result = generateConfig({ includeAgents: false });
+      expect(result).toContain("// categories: {");
+    });
+  });
+});
+
+describe("#given generateConfig with includeCategories: false", () => {
+  describe("#when called with includeCategories disabled", () => {
+    it("#then the output does not contain category override comments", () => {
+      const result = generateConfig({ includeCategories: false });
+      expect(result).not.toContain("// categories: {");
+    });
+
+    it("#then the output still contains agent override comments", () => {
+      const result = generateConfig({ includeCategories: false });
+      expect(result).toContain("// agents: {");
+    });
+  });
+});
+
+describe("#given the generated config written to a temp file", () => {
+  let tempDir: string;
+  let tempFile: string;
+
+  beforeAll(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "goatcode-config-test-"));
+    tempFile = join(tempDir, "goatcode.config.ts");
+    const content = generateConfig();
+    writeFileSync(tempFile, content, "utf8");
+
+    writeFileSync(
+      join(tempDir, "goatcode-sh.d.ts"),
+      "export function defineConfig(config: any): any\n",
+      "utf8",
+    );
+  });
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("#when typechecked with tsc", () => {
+    it("#then the generated config is valid TypeScript", () => {
+      const result = spawnSync(
+        "bunx",
+        [
+          "tsc",
+          "--noEmit",
+          "--skipLibCheck",
+          "--isolatedModules",
+          "--module",
+          "esnext",
+          "--target",
+          "esnext",
+          tempFile,
+        ],
+        { encoding: "utf8", timeout: 30000 },
+      );
+      if (result.error) {
+        throw new Error(`tsc failed to launch: ${result.error.message}`);
+      }
+      expect(result.status).toBe(0);
+    });
+  });
+});