goatcode-sh 0.0.1 → 0.1.2

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

package/src/config/schema.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { CONFIG_DEFAULTS } from "./defaults";
+
+export const AgentOverrideConfigSchema = z.object({
+  model: z.string().optional(),
+  variant: z.string().optional(),
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  prompt_append: z.string().optional(),
+  denied_tools: z.array(z.string()).optional(),
+  disable: z.boolean().optional(),
+  fallback_models: z.union([z.string(), z.array(z.string())]).optional(),
+});
+
+export const CategoryConfigSchema = z.object({
+  model: z.string().optional(),
+  variant: z.string().optional(),
+  description: z.string().optional(),
+  prompt_append: z.string().optional(),
+});
+
+export const AgentOverridesSchema = z.object({
+  orchestrator: AgentOverrideConfigSchema.optional(),
+  "deep-worker": AgentOverrideConfigSchema.optional(),
+  planner: AgentOverrideConfigSchema.optional(),
+  advisor: AgentOverrideConfigSchema.optional(),
+  researcher: AgentOverrideConfigSchema.optional(),
+  explorer: AgentOverrideConfigSchema.optional(),
+  worker: AgentOverrideConfigSchema.optional(),
+});
+
+export const CategoryOverridesSchema = z.object({
+  "visual-engineering": CategoryConfigSchema.optional(),
+  ultrabrain: CategoryConfigSchema.optional(),
+  deep: CategoryConfigSchema.optional(),
+  artistry: CategoryConfigSchema.optional(),
+  quick: CategoryConfigSchema.optional(),
+  "unspecified-low": CategoryConfigSchema.optional(),
+  "unspecified-high": CategoryConfigSchema.optional(),
+  writing: CategoryConfigSchema.optional(),
+});
+
+export const GoatCodeConfigSchema = z.object({
+  agents: AgentOverridesSchema.optional(),
+  categories: CategoryOverridesSchema.optional(),
+  default_temperature: z.number().min(0).max(2).default(CONFIG_DEFAULTS.default_temperature),
+  default_provider: z.string().optional(),
+  provider_priority: z.array(z.string()).default(CONFIG_DEFAULTS.provider_priority),
+  disabled_agents: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_agents),
+  disabled_hooks: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_hooks),
+  disabled_tools: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_tools),
+  disabled_skills: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_skills),
+  auto_update: z.boolean().default(CONFIG_DEFAULTS.auto_update),
+  plugins: z.array(z.string()).optional(),
+});
+
+export type GoatCodeConfigInput = z.input<typeof GoatCodeConfigSchema>;

package/src/config/validator.ts

@@ -0,0 +1,24 @@
+import type { GoatCodeConfig } from "../types/config";
+import { log } from "../shared/logger";
+import { GoatCodeConfigSchema } from "./schema";
+
+export type ValidationResult =
+  | {
+      success: true;
+      config: GoatCodeConfig;
+    }
+  | {
+      success: false;
+      errors: string[];
+    };
+
+export function validateConfig(raw: unknown): ValidationResult {
+  const result = GoatCodeConfigSchema.safeParse(raw);
+  if (result.success) {
+    return { success: true, config: result.data };
+  }
+
+  const errors = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+  log("[config/validator] Validation failed", { errors });
+  return { success: false, errors };
+}

package/src/features/auto-update/auto-update.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect } from "bun:test";
+import { checkForUpdate } from "./update-checker";
+
+describe("#auto-update-checker", () => {
+  describe("#when checking for updates", () => {
+    it("#then returns updateAvailable=true when latest version is newer", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "0.2.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(true);
+      expect(result.latest).toBe("0.2.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then returns updateAvailable=false when versions are the same", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "0.1.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then returns updateAvailable=false when current version is newer", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "0.1.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.2.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.2.0");
+    });
+
+    it("#then handles fetch errors gracefully", async () => {
+      const mockFetch = async () => {
+        throw new Error("Network error");
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then handles failed HTTP responses", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: false,
+          status: 404,
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then compares semantic versions correctly", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "1.0.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.9.9", mockFetch);
+
+      expect(result.updateAvailable).toBe(true);
+    });
+
+    it("#then handles missing version in response", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({}),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+    });
+  });
+});

package/src/features/auto-update/index.ts

@@ -0,0 +1,4 @@
+export { checkForUpdate } from "./update-checker";
+export type { UpdateCheckResult } from "./update-checker";
+
+export { createAutoUpdatePlugin } from "./plugin";

package/src/features/auto-update/plugin.ts

@@ -0,0 +1,45 @@
+import type { PluginDefinition } from "../../types/plugin";
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { log } from "../../shared/logger";
+import { checkForUpdate } from "./update-checker";
+import packageJson from "../../../package.json";
+
+function isSessionCreatedEvent(value: unknown): value is { type: string; properties?: unknown } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "type" in value &&
+    typeof (value as { type: unknown }).type === "string"
+  );
+}
+
+export function createAutoUpdatePlugin(): PluginDefinition {
+  let hasChecked = false;
+
+  return definePlugin({
+    name: "auto-update",
+    version: "1.0.0",
+    hooks: {
+      event: async (input: unknown) => {
+        if (!isSessionCreatedEvent(input) || input.type !== "session.created") return;
+        if (hasChecked) return;
+
+        hasChecked = true;
+
+        try {
+          const currentVersion = packageJson.version;
+          const result = await checkForUpdate(currentVersion);
+
+          if (result.updateAvailable) {
+            log("[auto-update] Update available", {
+              current: result.current,
+              latest: result.latest,
+            });
+          }
+        } catch (error) {
+          log("[auto-update] Hook execution failed", { error });
+        }
+      },
+    },
+  });
+}