goatcode-sh 0.0.1 → 0.1.3

package/src/cli/config-generator.ts

@@ -0,0 +1,119 @@
+import { log } from "../shared/logger";
+import { BUILTIN_AGENT_PLUGINS } from "../agents/builtin-agents";
+import { DEFAULT_CATEGORY_DEFINITIONS } from "../features/categories/category-config";
+
+/** All built-in agent names derived from BUILTIN_AGENT_PLUGINS. */
+const BUILTIN_AGENT_NAMES = BUILTIN_AGENT_PLUGINS.map((p) => p.name);
+
+/** All built-in category names derived from DEFAULT_CATEGORY_DEFINITIONS. */
+const BUILTIN_CATEGORY_NAMES = Object.keys(DEFAULT_CATEGORY_DEFINITIONS);
+
+/** All built-in micro-plugin package names. */
+const BUILTIN_MICRO_PLUGINS = BUILTIN_AGENT_PLUGINS.map((p) => `goatcode-sh/${p.name}`);
+
+/** Options for config generation. */
+export interface GenerateConfigOptions {
+  /**
+   * Whether to include the plugins array in the generated config.
+   * Defaults to true.
+   */
+  includePlugins?: boolean;
+  /**
+   * Whether to include the agent overrides section.
+   * Defaults to true.
+   */
+  includeAgents?: boolean;
+  /**
+   * Whether to include the category overrides section.
+   * Defaults to true.
+   */
+  includeCategories?: boolean;
+}
+
+function buildAgentOverridesSection(): string {
+  const lines: string[] = [];
+  lines.push("  // Agent overrides — uncomment and customize individual agents.");
+  lines.push("  // Each agent can override its model, temperature, prompt, and more.");
+  lines.push("  // agents: {");
+  for (const name of BUILTIN_AGENT_NAMES) {
+    lines.push(`  //   "${name}": {`);
+    lines.push('  //     // model: "provider/model-name",');
+    lines.push("  //     // temperature: 0.7,");
+    lines.push('  //     // prompt_append: "Additional instructions...",');
+    lines.push("  //     // denied_tools: [],");
+    lines.push("  //     // disable: false,");
+    lines.push("  //   },");
+  }
+  lines.push("  // },");
+  return lines.join("\n");
+}
+
+function buildCategoryOverridesSection(): string {
+  const lines: string[] = [];
+  lines.push("  // Category overrides — uncomment to set a default model per task category.");
+  lines.push("  // Categories map to the type of work being performed.");
+  lines.push("  // categories: {");
+  for (const name of BUILTIN_CATEGORY_NAMES) {
+    lines.push(`  //   "${name}": {`);
+    lines.push('  //     // model: "provider/model-name",');
+    lines.push('  //     // variant: "high",');
+    lines.push('  //     // prompt_append: "Additional instructions...",');
+    lines.push("  //   },");
+  }
+  lines.push("  // },");
+  return lines.join("\n");
+}
+
+function buildPluginsSection(): string {
+  const lines: string[] = [];
+  lines.push("  // Micro-plugins to load — all built-in plugins are enabled by default.");
+  lines.push("  // Add external plugin package names here to extend goatcode.");
+  lines.push("  plugins: [");
+  for (const plugin of BUILTIN_MICRO_PLUGINS) {
+    lines.push(`    "${plugin}",`);
+  }
+  lines.push("  ],");
+  return lines.join("\n");
+}
+
+/**
+ * Generate the content of an `goatcode.config.ts` file.
+ *
+ * Returns a TypeScript source string that can be written directly to disk.
+ * All agent and category overrides are commented out by default.
+ * All built-in micro-plugins are listed and enabled.
+ */
+export function generateConfig(options: GenerateConfigOptions = {}): string {
+  const { includePlugins = true, includeAgents = true, includeCategories = true } = options;
+
+  log("config-generator: generating goatcode.config.ts", {
+    includePlugins,
+    includeAgents,
+    includeCategories,
+  });
+
+  const sections: string[] = [];
+
+  if (includeAgents) {
+    sections.push(buildAgentOverridesSection());
+  }
+
+  if (includeCategories) {
+    sections.push(buildCategoryOverridesSection());
+  }
+
+  if (includePlugins) {
+    sections.push(buildPluginsSection());
+  }
+
+  const body = sections.join("\n\n");
+
+  return [
+    `import { defineConfig } from "goatcode-sh"`,
+    ``,
+    `export default defineConfig({`,
+    body,
+    `})`,
+    ``,
+  ].join("\n");
+}

package/src/cli/index.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "bun:test";
+import { createProgram } from "./cli";
+
+describe("#given the goatcode CLI program", () => {
+  describe("#when the program is created", () => {
+    it("#then the program name is goatcode-sh", () => {
+      const program = createProgram();
+      expect(program.name()).toBe("goatcode-sh");
+    });
+
+    it("#then the program has a version from package.json", () => {
+      const program = createProgram();
+      const semverRegex = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+      expect(program.version()).toMatch(semverRegex);
+    });
+
+    it("#then the install subcommand is registered", () => {
+      const program = createProgram();
+      const names = program.commands.map((cmd) => cmd.name());
+      expect(names).toContain("install");
+    });
+
+    it("#then the update subcommand is registered", () => {
+      const program = createProgram();
+      const names = program.commands.map((cmd) => cmd.name());
+      expect(names).toContain("update");
+    });
+
+    it("#then exactly two subcommands are registered", () => {
+      const program = createProgram();
+      expect(program.commands).toHaveLength(2);
+    });
+  });
+});

package/src/cli/index.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { runCli } from "./cli";
+
+runCli();

package/src/config/defaults.ts

@@ -0,0 +1,24 @@
+import type { GoatCodeConfig } from "../types/config";
+
+export const DEFAULT_TEMPERATURE = 0.1;
+
+export const CONFIG_DEFAULTS: Required<
+  Pick<
+    GoatCodeConfig,
+    | "auto_update"
+    | "default_temperature"
+    | "provider_priority"
+    | "disabled_agents"
+    | "disabled_hooks"
+    | "disabled_tools"
+    | "disabled_skills"
+  >
+> = {
+  auto_update: true,
+  default_temperature: DEFAULT_TEMPERATURE,
+  provider_priority: ["anthropic", "openai", "google", "opencode"],
+  disabled_agents: [],
+  disabled_hooks: [],
+  disabled_tools: [],
+  disabled_skills: [],
+};

package/src/config/define-config.ts

@@ -0,0 +1,38 @@
+import type { GoatCodeConfig } from "../types/config";
+
+/**
+ * Define your goatcode configuration.
+ * Provides TypeScript autocomplete and type checking for your config file.
+ *
+ * @example
+ * // goatcode.config.ts
+ * import { defineConfig } from "goatcode-sh"
+ * export default defineConfig({
+ *   agents: {
+ *     orchestrator: { model: "anthropic/claude-opus-4-6" }
+ *   }
+ * })
+ */
+export function defineConfig(config: GoatCodeConfig): GoatCodeConfig {
+  return config;
+}
+
+/**
+ * Async variant of defineConfig supporting environment-based config.
+ *
+ * @example
+ * export default defineConfigAsync(async () => ({
+ *   agents: {
+ *     orchestrator: { model: process.env.ORCHESTRATOR_MODEL ?? "anthropic/claude-opus-4-6" }
+ *   }
+ * }))
+ */
+export function defineConfigAsync(
+  config: () => Promise<GoatCodeConfig> | GoatCodeConfig,
+): () => Promise<GoatCodeConfig> | GoatCodeConfig;
+export function defineConfigAsync(config: GoatCodeConfig): GoatCodeConfig;
+export function defineConfigAsync(
+  config: GoatCodeConfig | (() => Promise<GoatCodeConfig> | GoatCodeConfig),
+): GoatCodeConfig | (() => Promise<GoatCodeConfig> | GoatCodeConfig) {
+  return config;
+}

package/src/config/index.ts

@@ -0,0 +1,6 @@
+export * from "./defaults";
+export * from "./define-config";
+export * from "./loader";
+export * from "./paths";
+export * from "./schema";
+export * from "./validator";

package/src/config/loader.test.ts

@@ -0,0 +1,218 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig } from "./loader";
+
+async function withTempDir(
+  prefix: string,
+  run: (dir: string) => Promise<void> | void,
+): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  try {
+    await run(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function restoreGoatcodeConfigDir(previousDir: string | undefined): void {
+  if (previousDir === undefined) {
+    delete process.env.GOATCODE_CONFIG_DIR;
+  } else {
+    process.env.GOATCODE_CONFIG_DIR = previousDir;
+  }
+}
+
+describe("loadConfig", () => {
+  test("returns null when no user or project config exists", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-user-", async (userDir) => {
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = userDir;
+
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result).toBeNull();
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+
+  test("returns user config when only user config exists", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-user-", async (userDir) => {
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = userDir;
+        writeFileSync(
+          join(userDir, "config.ts"),
+          'export default { auto_update: false, disabled_tools: ["bash"] }\n',
+          "utf8",
+        );
+
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result?.auto_update).toBe(false);
+          expect(result?.disabled_tools).toEqual(["bash"]);
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+
+  test("returns project config when only project config exists", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-user-", async (userDir) => {
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = userDir;
+        writeFileSync(
+          join(projectDir, "goatcode.config.ts"),
+          'export default { auto_update: false, disabled_hooks: ["my-hook"] }\n',
+          "utf8",
+        );
+
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result?.auto_update).toBe(false);
+          expect(result?.disabled_hooks).toEqual(["my-hook"]);
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+
+  test("deep merges user and project config with project taking precedence", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-user-", async (userDir) => {
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = userDir;
+
+        writeFileSync(
+          join(userDir, "config.ts"),
+          `export default {
+  auto_update: true,
+  disabled_tools: ["grep", "glob"],
+  agents: {
+    orchestrator: { model: "openai/gpt-4", temperature: 0.1 },
+    explorer: { model: "anthropic/claude-3-5-sonnet" }
+  }
+}\n`,
+          "utf8",
+        );
+        writeFileSync(
+          join(projectDir, "goatcode.config.ts"),
+          `export default {
+  auto_update: false,
+  disabled_tools: ["bash"],
+  agents: {
+    orchestrator: { temperature: 0.2 }
+  }
+}\n`,
+          "utf8",
+        );
+
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result?.auto_update).toBe(false);
+          expect(result?.disabled_tools).toEqual(["bash"]);
+          expect(result?.agents?.orchestrator?.model).toBe("openai/gpt-4");
+          expect(result?.agents?.orchestrator?.temperature).toBe(0.2);
+          expect(result?.agents?.explorer?.model).toBe("anthropic/claude-3-5-sonnet");
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+
+  test("uses GOATCODE_CONFIG_DIR override for user config path", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-base-", async (baseDir) => {
+        const overrideDir = join(baseDir, "custom-config-dir");
+        mkdirSync(overrideDir);
+        writeFileSync(
+          join(overrideDir, "config.ts"),
+          'export default { disabled_agents: ["advisor"] }\n',
+          "utf8",
+        );
+
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = overrideDir;
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result?.disabled_agents).toEqual(["advisor"]);
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+
+  test("falls through to project config when user config is invalid", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-user-", async (userDir) => {
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = userDir;
+
+        writeFileSync(
+          join(userDir, "config.ts"),
+          'export default { auto_update: "nope" }\n',
+          "utf8",
+        );
+        writeFileSync(
+          join(projectDir, "goatcode.config.ts"),
+          "export default { auto_update: false }\n",
+          "utf8",
+        );
+
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result?.auto_update).toBe(false);
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+
+  test("merges nested agent objects while preserving non-overridden keys", async () => {
+    await withTempDir("goatcode-loader-project-", async (projectDir) => {
+      await withTempDir("goatcode-loader-user-", async (userDir) => {
+        const previousDir = process.env.GOATCODE_CONFIG_DIR;
+        process.env.GOATCODE_CONFIG_DIR = userDir;
+
+        writeFileSync(
+          join(userDir, "config.ts"),
+          `export default {
+  agents: {
+    orchestrator: { model: "anthropic/claude-opus-4-6", temperature: 0 }
+  }
+}\n`,
+          "utf8",
+        );
+        writeFileSync(
+          join(projectDir, "goatcode.config.ts"),
+          `export default {
+  agents: {
+    orchestrator: { prompt_append: "Project specific prompt" }
+  }
+}\n`,
+          "utf8",
+        );
+
+        try {
+          const result = await loadConfig(projectDir);
+          expect(result?.agents?.orchestrator?.model).toBe("anthropic/claude-opus-4-6");
+          expect(result?.agents?.orchestrator?.temperature).toBe(0);
+          expect(result?.agents?.orchestrator?.prompt_append).toBe("Project specific prompt");
+        } finally {
+          restoreGoatcodeConfigDir(previousDir);
+        }
+      });
+    });
+  });
+});

package/src/config/loader.ts

@@ -0,0 +1,89 @@
+import { existsSync } from "node:fs";
+import type { GoatCodeConfig } from "../types/config";
+import { deepMerge } from "../shared/deep-merge";
+import { log } from "../shared/logger";
+import { validateConfig } from "./validator";
+import {
+  resolveLegacyProjectConfigPath,
+  resolveProjectConfigPath,
+  resolveUserConfigPath,
+} from "./paths";
+
+export async function loadConfigFile(configPath: string): Promise<GoatCodeConfig | null> {
+  try {
+    const module = await import(configPath);
+    const raw = module.default ?? module;
+    if (typeof raw === "function") {
+      return await raw();
+    }
+
+    return raw as GoatCodeConfig;
+  } catch (error) {
+    log("[config/loader] Failed to load config file", { configPath, error });
+    return null;
+  }
+}
+
+async function loadValidatedConfigFile(configPath: string): Promise<GoatCodeConfig | null> {
+  const raw = await loadConfigFile(configPath);
+  if (raw === null) return null;
+
+  const validation = validateConfig(raw);
+  if (!validation.success) {
+    log("[config/loader] Loaded config failed validation", {
+      configPath,
+      errors: validation.errors,
+    });
+    return null;
+  }
+
+  return validation.config;
+}
+
+export async function loadConfig(projectDir: string): Promise<GoatCodeConfig | null> {
+  const userConfigPath = resolveUserConfigPath();
+  const userConfig =
+    userConfigPath && existsSync(userConfigPath)
+      ? await loadValidatedConfigFile(userConfigPath)
+      : null;
+
+  const projectConfigPath = resolveProjectConfigPath(projectDir);
+  const hasProjectConfig = existsSync(projectConfigPath);
+  let projectConfig: GoatCodeConfig | null = null;
+  let projectConfigInvalid = false;
+
+  if (hasProjectConfig) {
+    projectConfig = await loadValidatedConfigFile(projectConfigPath);
+    projectConfigInvalid = projectConfig === null;
+  }
+
+  if (!hasProjectConfig) {
+    const legacyConfigPath = resolveLegacyProjectConfigPath(projectDir);
+    if (existsSync(legacyConfigPath)) {
+      log(
+        "[config/loader] Found legacy ochead.config.ts — please rename it to goatcode.config.ts",
+        {
+          legacyPath: legacyConfigPath,
+        },
+      );
+      process.stderr.write(
+        `[goatcode] DEPRECATION: ochead.config.ts is deprecated. Please rename it to goatcode.config.ts\n`,
+      );
+      projectConfig = await loadValidatedConfigFile(legacyConfigPath);
+      projectConfigInvalid = projectConfig === null;
+    }
+  }
+
+  if (projectConfigInvalid) {
+    return null;
+  }
+
+  if (userConfig && projectConfig) {
+    return deepMerge(
+      userConfig as Record<string, unknown>,
+      projectConfig as Record<string, unknown>,
+    ) as GoatCodeConfig;
+  }
+
+  return projectConfig ?? userConfig;
+}

package/src/config/paths.ts

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const USER_CONFIG_FILE_NAME = "config.ts";
+const PROJECT_CONFIG_FILE_NAME = "goatcode.config.ts";
+const LEGACY_PROJECT_CONFIG_FILE_NAME = "ochead.config.ts";
+
+export function resolveUserConfigDir(): string {
+  return process.env.GOATCODE_CONFIG_DIR && process.env.GOATCODE_CONFIG_DIR.trim() !== ""
+    ? process.env.GOATCODE_CONFIG_DIR
+    : join(homedir(), ".config", "goatcode");
+}
+
+export function resolveUserConfigPath(): string | null {
+  const userConfigDir = resolveUserConfigDir();
+  if (!existsSync(userConfigDir)) {
+    return null;
+  }
+
+  return join(userConfigDir, USER_CONFIG_FILE_NAME);
+}
+
+export function resolveProjectConfigPath(projectDir: string): string {
+  return join(projectDir, PROJECT_CONFIG_FILE_NAME);
+}
+
+export function resolveLegacyProjectConfigPath(projectDir: string): string {
+  return join(projectDir, LEGACY_PROJECT_CONFIG_FILE_NAME);
+}

package/src/config/schema.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { defineConfig } from "./define-config";
+import { validateConfig } from "./validator";
+
+describe("validateConfig", () => {
+  describe("with valid config", () => {
+    test("accepts empty config", () => {
+      //#given
+      const raw = {};
+
+      //#when
+      const result = validateConfig(raw);
+
+      //#then
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.config.auto_update).toBe(true);
+        expect(result.config.disabled_agents).toEqual([]);
+        expect(result.config.disabled_hooks).toEqual([]);
+        expect(result.config.disabled_tools).toEqual([]);
+        expect(result.config.disabled_skills).toEqual([]);
+      }
+    });
+
+    test("accepts agent model override", () => {
+      //#given
+      const raw = { agents: { orchestrator: { model: "anthropic/claude-opus-4-6" } } };
+
+      //#when
+      const result = validateConfig(raw);
+
+      //#then
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.config.agents?.orchestrator?.model).toBe("anthropic/claude-opus-4-6");
+      }
+    });
+  });
+
+  describe("with invalid config", () => {
+    test("rejects non-numeric temperature", () => {
+      //#given
+      const raw = { agents: { orchestrator: { temperature: "hot" } } };
+
+      //#when
+      const result = validateConfig(raw);
+
+      //#then
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors[0]).toContain("temperature");
+      }
+    });
+  });
+});
+
+describe("defineConfig", () => {
+  test("returns config unchanged", () => {
+    //#given
+    const config = { agents: { orchestrator: { model: "test" } } };
+
+    //#when
+    const result = defineConfig(config);
+
+    //#then
+    expect(result).toBe(config);
+  });
+});