opencode-repos 0.2.0 → 0.3.0

package/oh-my-opencode/src/mcp/index.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test"
+import { createBuiltinMcps } from "./index"
+
+describe("createBuiltinMcps", () => {
+  test("should return all MCPs when disabled_mcps is empty", () => {
+    //#given
+    const disabledMcps: string[] = []
+
+    //#when
+    const result = createBuiltinMcps(disabledMcps)
+
+    //#then
+    expect(result).toHaveProperty("websearch")
+    expect(result).toHaveProperty("context7")
+    expect(result).toHaveProperty("grep_app")
+    expect(Object.keys(result)).toHaveLength(3)
+  })
+
+  test("should filter out disabled built-in MCPs", () => {
+    //#given
+    const disabledMcps = ["context7"]
+
+    //#when
+    const result = createBuiltinMcps(disabledMcps)
+
+    //#then
+    expect(result).toHaveProperty("websearch")
+    expect(result).not.toHaveProperty("context7")
+    expect(result).toHaveProperty("grep_app")
+    expect(Object.keys(result)).toHaveLength(2)
+  })
+
+  test("should filter out all built-in MCPs when all disabled", () => {
+    //#given
+    const disabledMcps = ["websearch", "context7", "grep_app"]
+
+    //#when
+    const result = createBuiltinMcps(disabledMcps)
+
+    //#then
+    expect(result).not.toHaveProperty("websearch")
+    expect(result).not.toHaveProperty("context7")
+    expect(result).not.toHaveProperty("grep_app")
+    expect(Object.keys(result)).toHaveLength(0)
+  })
+
+  test("should ignore custom MCP names in disabled_mcps", () => {
+    //#given
+    const disabledMcps = ["context7", "playwright", "custom"]
+
+    //#when
+    const result = createBuiltinMcps(disabledMcps)
+
+    //#then
+    expect(result).toHaveProperty("websearch")
+    expect(result).not.toHaveProperty("context7")
+    expect(result).toHaveProperty("grep_app")
+    expect(Object.keys(result)).toHaveLength(2)
+  })
+
+  test("should handle empty disabled_mcps by default", () => {
+    //#given
+    //#when
+    const result = createBuiltinMcps()
+
+    //#then
+    expect(result).toHaveProperty("websearch")
+    expect(result).toHaveProperty("context7")
+    expect(result).toHaveProperty("grep_app")
+    expect(Object.keys(result)).toHaveLength(3)
+  })
+
+  test("should only filter built-in MCPs, ignoring unknown names", () => {
+    //#given
+    const disabledMcps = ["playwright", "sqlite", "unknown-mcp"]
+
+    //#when
+    const result = createBuiltinMcps(disabledMcps)
+
+    //#then
+    expect(result).toHaveProperty("websearch")
+    expect(result).toHaveProperty("context7")
+    expect(result).toHaveProperty("grep_app")
+    expect(Object.keys(result)).toHaveLength(3)
+  })
+})

package/oh-my-opencode/src/mcp/index.ts

@@ -0,0 +1,32 @@
+import { websearch } from "./websearch"
+import { context7 } from "./context7"
+import { grep_app } from "./grep-app"
+import type { McpName } from "./types"
+
+export { McpNameSchema, type McpName } from "./types"
+
+type RemoteMcpConfig = {
+  type: "remote"
+  url: string
+  enabled: boolean
+  headers?: Record<string, string>
+  oauth?: false
+}
+
+const allBuiltinMcps: Record<McpName, RemoteMcpConfig> = {
+  websearch,
+  context7,
+  grep_app,
+}
+
+export function createBuiltinMcps(disabledMcps: string[] = []) {
+  const mcps: Record<string, RemoteMcpConfig> = {}
+
+  for (const [name, config] of Object.entries(allBuiltinMcps)) {
+    if (!disabledMcps.includes(name)) {
+      mcps[name] = config
+    }
+  }
+
+  return mcps
+}

package/oh-my-opencode/src/mcp/types.ts

@@ -0,0 +1,9 @@
+import { z } from "zod"
+
+export const McpNameSchema = z.enum(["websearch", "context7", "grep_app"])
+
+export type McpName = z.infer<typeof McpNameSchema>
+
+export const AnyMcpNameSchema = z.string().min(1)
+
+export type AnyMcpName = z.infer<typeof AnyMcpNameSchema>

package/oh-my-opencode/src/mcp/websearch.ts

@@ -0,0 +1,10 @@
+export const websearch = {
+  type: "remote" as const,
+  url: "https://mcp.exa.ai/mcp?tools=web_search_exa",
+  enabled: true,
+  headers: process.env.EXA_API_KEY
+    ? { "x-api-key": process.env.EXA_API_KEY }
+    : undefined,
+  // Disable OAuth auto-detection - Exa uses API key header, not OAuth
+  oauth: false as const,
+}

package/oh-my-opencode/src/plugin-config.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "bun:test";
+import { mergeConfigs } from "./plugin-config";
+import type { OhMyOpenCodeConfig } from "./config";
+
+describe("mergeConfigs", () => {
+  describe("categories merging", () => {
+    // #given base config has categories, override has different categories
+    // #when merging configs
+    // #then should deep merge categories, not override completely
+
+    it("should deep merge categories from base and override", () => {
+      const base = {
+        categories: {
+          general: {
+            model: "openai/gpt-5.2",
+            temperature: 0.5,
+          },
+          quick: {
+            model: "anthropic/claude-haiku-4-5",
+          },
+        },
+      } as OhMyOpenCodeConfig;
+
+      const override = {
+        categories: {
+          general: {
+            temperature: 0.3,
+          },
+          visual: {
+            model: "google/gemini-3-pro-preview",
+          },
+        },
+      } as unknown as OhMyOpenCodeConfig;
+
+      const result = mergeConfigs(base, override);
+
+      // #then general.model should be preserved from base
+      expect(result.categories?.general?.model).toBe("openai/gpt-5.2");
+      // #then general.temperature should be overridden
+      expect(result.categories?.general?.temperature).toBe(0.3);
+      // #then quick should be preserved from base
+      expect(result.categories?.quick?.model).toBe("anthropic/claude-haiku-4-5");
+      // #then visual should be added from override
+      expect(result.categories?.visual?.model).toBe("google/gemini-3-pro-preview");
+    });
+
+    it("should preserve base categories when override has no categories", () => {
+      const base: OhMyOpenCodeConfig = {
+        categories: {
+          general: {
+            model: "openai/gpt-5.2",
+          },
+        },
+      };
+
+      const override: OhMyOpenCodeConfig = {};
+
+      const result = mergeConfigs(base, override);
+
+      expect(result.categories?.general?.model).toBe("openai/gpt-5.2");
+    });
+
+    it("should use override categories when base has no categories", () => {
+      const base: OhMyOpenCodeConfig = {};
+
+      const override: OhMyOpenCodeConfig = {
+        categories: {
+          general: {
+            model: "openai/gpt-5.2",
+          },
+        },
+      };
+
+      const result = mergeConfigs(base, override);
+
+      expect(result.categories?.general?.model).toBe("openai/gpt-5.2");
+    });
+  });
+
+  describe("existing behavior preservation", () => {
+    it("should deep merge agents", () => {
+      const base: OhMyOpenCodeConfig = {
+        agents: {
+          oracle: { model: "openai/gpt-5.2" },
+        },
+      };
+
+      const override: OhMyOpenCodeConfig = {
+        agents: {
+          oracle: { temperature: 0.5 },
+          explore: { model: "anthropic/claude-haiku-4-5" },
+        },
+      };
+
+      const result = mergeConfigs(base, override);
+
+      expect(result.agents?.oracle?.model).toBe("openai/gpt-5.2");
+      expect(result.agents?.oracle?.temperature).toBe(0.5);
+      expect(result.agents?.explore?.model).toBe("anthropic/claude-haiku-4-5");
+    });
+
+    it("should merge disabled arrays without duplicates", () => {
+      const base: OhMyOpenCodeConfig = {
+        disabled_hooks: ["comment-checker", "think-mode"],
+      };
+
+      const override: OhMyOpenCodeConfig = {
+        disabled_hooks: ["think-mode", "session-recovery"],
+      };
+
+      const result = mergeConfigs(base, override);
+
+      expect(result.disabled_hooks).toContain("comment-checker");
+      expect(result.disabled_hooks).toContain("think-mode");
+      expect(result.disabled_hooks).toContain("session-recovery");
+      expect(result.disabled_hooks?.length).toBe(3);
+    });
+  });
+});

package/oh-my-opencode/src/plugin-config.ts

@@ -0,0 +1,135 @@
+import * as fs from "fs";
+import * as path from "path";
+import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig } from "./config";
+import {
+  log,
+  deepMerge,
+  getUserConfigDir,
+  addConfigLoadError,
+  parseJsonc,
+  detectConfigFile,
+  migrateConfigFile,
+} from "./shared";
+
+export function loadConfigFromPath(
+  configPath: string,
+  ctx: unknown
+): OhMyOpenCodeConfig | null {
+  try {
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const rawConfig = parseJsonc<Record<string, unknown>>(content);
+
+      migrateConfigFile(configPath, rawConfig);
+
+      const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+
+      if (!result.success) {
+        const errorMsg = result.error.issues
+          .map((i) => `${i.path.join(".")}: ${i.message}`)
+          .join(", ");
+        log(`Config validation error in ${configPath}:`, result.error.issues);
+        addConfigLoadError({
+          path: configPath,
+          error: `Validation error: ${errorMsg}`,
+        });
+        return null;
+      }
+
+      log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+      return result.data;
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    log(`Error loading config from ${configPath}:`, err);
+    addConfigLoadError({ path: configPath, error: errorMsg });
+  }
+  return null;
+}
+
+export function mergeConfigs(
+  base: OhMyOpenCodeConfig,
+  override: OhMyOpenCodeConfig
+): OhMyOpenCodeConfig {
+  return {
+    ...base,
+    ...override,
+    agents: deepMerge(base.agents, override.agents),
+    categories: deepMerge(base.categories, override.categories),
+    disabled_agents: [
+      ...new Set([
+        ...(base.disabled_agents ?? []),
+        ...(override.disabled_agents ?? []),
+      ]),
+    ],
+    disabled_mcps: [
+      ...new Set([
+        ...(base.disabled_mcps ?? []),
+        ...(override.disabled_mcps ?? []),
+      ]),
+    ],
+    disabled_hooks: [
+      ...new Set([
+        ...(base.disabled_hooks ?? []),
+        ...(override.disabled_hooks ?? []),
+      ]),
+    ],
+    disabled_commands: [
+      ...new Set([
+        ...(base.disabled_commands ?? []),
+        ...(override.disabled_commands ?? []),
+      ]),
+    ],
+    disabled_skills: [
+      ...new Set([
+        ...(base.disabled_skills ?? []),
+        ...(override.disabled_skills ?? []),
+      ]),
+    ],
+    claude_code: deepMerge(base.claude_code, override.claude_code),
+  };
+}
+
+export function loadPluginConfig(
+  directory: string,
+  ctx: unknown
+): OhMyOpenCodeConfig {
+  // User-level config path (OS-specific) - prefer .jsonc over .json
+  const userBasePath = path.join(
+    getUserConfigDir(),
+    "opencode",
+    "oh-my-opencode"
+  );
+  const userDetected = detectConfigFile(userBasePath);
+  const userConfigPath =
+    userDetected.format !== "none"
+      ? userDetected.path
+      : userBasePath + ".json";
+
+  // Project-level config path - prefer .jsonc over .json
+  const projectBasePath = path.join(directory, ".opencode", "oh-my-opencode");
+  const projectDetected = detectConfigFile(projectBasePath);
+  const projectConfigPath =
+    projectDetected.format !== "none"
+      ? projectDetected.path
+      : projectBasePath + ".json";
+
+  // Load user config first (base)
+  let config: OhMyOpenCodeConfig =
+    loadConfigFromPath(userConfigPath, ctx) ?? {};
+
+  // Override with project config
+  const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
+  if (projectConfig) {
+    config = mergeConfigs(config, projectConfig);
+  }
+
+  log("Final merged config", {
+    agents: config.agents,
+    disabled_agents: config.disabled_agents,
+    disabled_mcps: config.disabled_mcps,
+    disabled_hooks: config.disabled_hooks,
+    claude_code: config.claude_code,
+  });
+  return config;
+}

package/oh-my-opencode/src/plugin-handlers/config-handler.test.ts

@@ -0,0 +1,103 @@
+import { describe, test, expect } from "bun:test"
+import { resolveCategoryConfig } from "./config-handler"
+import type { CategoryConfig } from "../config/schema"
+
+describe("Prometheus category config resolution", () => {
+  test("resolves ultrabrain category config", () => {
+    // #given
+    const categoryName = "ultrabrain"
+
+    // #when
+    const config = resolveCategoryConfig(categoryName)
+
+    // #then
+    expect(config).toBeDefined()
+    expect(config?.model).toBe("openai/gpt-5.2-codex")
+    expect(config?.variant).toBe("xhigh")
+  })
+
+  test("resolves visual-engineering category config", () => {
+    // #given
+    const categoryName = "visual-engineering"
+
+    // #when
+    const config = resolveCategoryConfig(categoryName)
+
+    // #then
+    expect(config).toBeDefined()
+    expect(config?.model).toBe("google/gemini-3-pro-preview")
+  })
+
+  test("user categories override default categories", () => {
+    // #given
+    const categoryName = "ultrabrain"
+    const userCategories: Record<string, CategoryConfig> = {
+      ultrabrain: {
+        model: "google/antigravity-claude-opus-4-5-thinking",
+        temperature: 0.1,
+      },
+    }
+
+    // #when
+    const config = resolveCategoryConfig(categoryName, userCategories)
+
+    // #then
+    expect(config).toBeDefined()
+    expect(config?.model).toBe("google/antigravity-claude-opus-4-5-thinking")
+    expect(config?.temperature).toBe(0.1)
+  })
+
+  test("returns undefined for unknown category", () => {
+    // #given
+    const categoryName = "nonexistent-category"
+
+    // #when
+    const config = resolveCategoryConfig(categoryName)
+
+    // #then
+    expect(config).toBeUndefined()
+  })
+
+  test("falls back to default when user category has no entry", () => {
+    // #given
+    const categoryName = "ultrabrain"
+    const userCategories: Record<string, CategoryConfig> = {
+      "visual-engineering": {
+        model: "custom/visual-model",
+      },
+    }
+
+    // #when
+    const config = resolveCategoryConfig(categoryName, userCategories)
+
+    // #then - falls back to DEFAULT_CATEGORIES
+    expect(config).toBeDefined()
+    expect(config?.model).toBe("openai/gpt-5.2-codex")
+    expect(config?.variant).toBe("xhigh")
+  })
+
+  test("preserves all category properties (temperature, top_p, tools, etc.)", () => {
+    // #given
+    const categoryName = "custom-category"
+    const userCategories: Record<string, CategoryConfig> = {
+      "custom-category": {
+        model: "test/model",
+        temperature: 0.5,
+        top_p: 0.9,
+        maxTokens: 32000,
+        tools: { tool1: true, tool2: false },
+      },
+    }
+
+    // #when
+    const config = resolveCategoryConfig(categoryName, userCategories)
+
+    // #then
+    expect(config).toBeDefined()
+    expect(config?.model).toBe("test/model")
+    expect(config?.temperature).toBe(0.5)
+    expect(config?.top_p).toBe(0.9)
+    expect(config?.maxTokens).toBe(32000)
+    expect(config?.tools).toEqual({ tool1: true, tool2: false })
+  })
+})