goatcode-sh 0.0.1 → 0.1.2

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

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";