goatcode-sh 0.0.1 → 0.1.2

package/src/shared/provider-discovery.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  buildDiscoveryIndex,
+  getDiscovery,
+  initializeDiscovery,
+  resetDiscovery,
+  type ProviderListResponse,
+} from "./provider-discovery";
+
+function createProviderListResponse(): ProviderListResponse {
+  return {
+    all: [
+      {
+        id: "anthropic",
+        name: "Anthropic",
+        env: ["ANTHROPIC_API_KEY"],
+        models: {
+          "claude-opus-4-6": { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
+          "claude-sonnet-4-6": { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
+        },
+      },
+      {
+        id: "opencode",
+        name: "OpenCode",
+        env: [],
+        models: {
+          "claude-opus-4-6": { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
+          "gpt-5.4": { id: "gpt-5.4", name: "GPT 5.4" },
+        },
+      },
+      {
+        id: "openai",
+        name: "OpenAI",
+        env: ["OPENAI_API_KEY"],
+        models: {
+          "gpt-5.4": { id: "gpt-5.4", name: "GPT 5.4" },
+        },
+      },
+    ],
+    default: {},
+    connected: ["anthropic", "opencode"],
+  };
+}
+
+describe("buildDiscoveryIndex", () => {
+  beforeEach(() => {
+    resetDiscovery();
+  });
+
+  it("builds model and provider indexes from provider list", () => {
+    const result = buildDiscoveryIndex(createProviderListResponse());
+
+    expect(result.modelIndex.get("claude-opus-4-6")).toEqual([
+      { providerId: "anthropic", modelId: "claude-opus-4-6" },
+      { providerId: "opencode", modelId: "claude-opus-4-6" },
+    ]);
+    expect(result.providerModels.get("anthropic")?.has("claude-sonnet-4-6")).toBe(true);
+    expect(result.providerModels.get("openai")?.has("gpt-5.4")).toBe(true);
+  });
+
+  it("normalizes model and provider identifiers", () => {
+    const base = createProviderListResponse();
+    const response: ProviderListResponse = {
+      ...base,
+      all: [
+        {
+          ...base.all[0],
+          id: "Anthropic",
+          models: {
+            "CLAUDE-OPUS-4-6": { id: "CLAUDE-OPUS-4-6", name: "Claude Opus 4.6" },
+          },
+        },
+        base.all[1],
+        base.all[2],
+      ],
+      connected: [" Anthropic "],
+    };
+
+    const result = buildDiscoveryIndex(response);
+    expect(result.connectedProviders.has("anthropic")).toBe(true);
+    expect(result.modelIndex.get("claude-opus-4-6")).toEqual([
+      { providerId: "anthropic", modelId: "claude-opus-4-6" },
+      { providerId: "opencode", modelId: "claude-opus-4-6" },
+    ]);
+  });
+
+  it("initializes and resets cached discovery state", () => {
+    const result = buildDiscoveryIndex(createProviderListResponse());
+    initializeDiscovery(result);
+
+    expect(getDiscovery()).toBeDefined();
+    expect(getDiscovery()?.connectedProviders.has("anthropic")).toBe(true);
+
+    resetDiscovery();
+    expect(getDiscovery()).toBeUndefined();
+  });
+});

package/src/shared/provider-discovery.ts

@@ -0,0 +1,73 @@
+export type ProviderListResponse = {
+  readonly all: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly env: readonly string[];
+    readonly npm?: string;
+    readonly api?: string;
+    readonly models: Record<string, { readonly id: string; readonly name: string }>;
+  }[];
+  readonly default: Record<string, string>;
+  readonly connected: readonly string[];
+};
+
+export type ProviderModelEntry = {
+  readonly providerId: string;
+  readonly modelId: string;
+};
+
+export type DiscoveryResult = {
+  readonly connectedProviders: ReadonlySet<string>;
+  readonly modelIndex: ReadonlyMap<string, ProviderModelEntry[]>;
+  readonly providerModels: ReadonlyMap<string, ReadonlySet<string>>;
+};
+
+function normalizeIdentifier(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+export function buildDiscoveryIndex(response: ProviderListResponse): DiscoveryResult {
+  const connectedProviders = new Set(
+    response.connected.map((providerId) => normalizeIdentifier(providerId)),
+  );
+  const modelIndex = new Map<string, ProviderModelEntry[]>();
+  const providerModels = new Map<string, ReadonlySet<string>>();
+
+  for (const provider of response.all) {
+    const providerId = normalizeIdentifier(provider.id);
+    const modelsForProvider = new Set<string>();
+
+    for (const modelId of Object.keys(provider.models ?? {})) {
+      const normalizedModelId = normalizeIdentifier(modelId);
+      if (!normalizedModelId) continue;
+
+      modelsForProvider.add(normalizedModelId);
+
+      const entries = modelIndex.get(normalizedModelId) ?? [];
+      entries.push({ providerId, modelId: normalizedModelId });
+      modelIndex.set(normalizedModelId, entries);
+    }
+
+    providerModels.set(providerId, modelsForProvider);
+  }
+
+  return {
+    connectedProviders,
+    modelIndex,
+    providerModels,
+  };
+}
+
+let cachedDiscovery: DiscoveryResult | undefined;
+
+export function initializeDiscovery(result: DiscoveryResult): void {
+  cachedDiscovery = result;
+}
+
+export function getDiscovery(): DiscoveryResult | undefined {
+  return cachedDiscovery;
+}
+
+export function resetDiscovery(): void {
+  cachedDiscovery = undefined;
+}

package/src/shared/provider-registry.test.ts

@@ -0,0 +1,212 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  buildDiscoveryIndex,
+  initializeDiscovery,
+  resetDiscovery,
+  type ProviderListResponse,
+} from "./provider-discovery";
+import {
+  findProvidersForModel,
+  getProviderPriority,
+  isQualifiedModel,
+  qualifyModel,
+  registerProviderModelMap,
+  resetProviderRegistry,
+  resolveProvider,
+  setDefaultPreferredProvider,
+  setProviderPriority,
+} from "./provider-registry";
+
+function createProviderListResponse(connected: string[]): ProviderListResponse {
+  return {
+    all: [
+      {
+        id: "anthropic",
+        name: "Anthropic",
+        env: ["ANTHROPIC_API_KEY"],
+        models: {
+          "claude-opus-4-6": { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
+        },
+      },
+      {
+        id: "opencode",
+        name: "OpenCode",
+        env: [],
+        models: {
+          "claude-opus-4-6": { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
+          "gpt-5.4": { id: "gpt-5.4", name: "GPT 5.4" },
+          "gemini-3.1-flash-lite": {
+            id: "gemini-3.1-flash-lite",
+            name: "Gemini 3.1 Flash Lite",
+          },
+        },
+      },
+      {
+        id: "openai",
+        name: "OpenAI",
+        env: ["OPENAI_API_KEY"],
+        models: {
+          "gpt-5.4": { id: "gpt-5.4", name: "GPT 5.4" },
+        },
+      },
+      {
+        id: "google",
+        name: "Google",
+        env: ["GOOGLE_API_KEY"],
+        models: {
+          "gemini-3.1-flash-lite": {
+            id: "gemini-3.1-flash-lite",
+            name: "Gemini 3.1 Flash Lite",
+          },
+        },
+      },
+    ],
+    default: {},
+    connected,
+  };
+}
+
+describe("provider-registry (discovery-based)", () => {
+  beforeEach(() => {
+    resetProviderRegistry();
+    resetDiscovery();
+  });
+
+  describe("isQualifiedModel", () => {
+    it("detects qualified models", () => {
+      expect(isQualifiedModel("anthropic/claude-opus-4-6")).toBe(true);
+      expect(isQualifiedModel("claude-opus-4-6")).toBe(false);
+    });
+
+    it("rejects malformed qualified models", () => {
+      expect(isQualifiedModel("/gpt-5.4")).toBe(false);
+      expect(isQualifiedModel("openai/")).toBe(false);
+      expect(isQualifiedModel("/")).toBe(false);
+    });
+  });
+
+  describe("resolveProvider", () => {
+    it("resolves connected providers by priority", () => {
+      initializeDiscovery(
+        buildDiscoveryIndex(createProviderListResponse(["anthropic", "opencode"])),
+      );
+
+      const result = resolveProvider("claude-opus-4-6");
+      expect(result).toEqual({
+        qualifiedModel: "anthropic/claude-opus-4-6",
+        providerId: "anthropic",
+      });
+    });
+
+    it("uses preferred provider override when available", () => {
+      initializeDiscovery(
+        buildDiscoveryIndex(createProviderListResponse(["anthropic", "opencode"])),
+      );
+
+      const result = resolveProvider("claude-opus-4-6", "opencode");
+      expect(result).toEqual({
+        qualifiedModel: "opencode/claude-opus-4-6",
+        providerId: "opencode",
+      });
+    });
+
+    it("ignores disconnected higher-priority providers", () => {
+      initializeDiscovery(buildDiscoveryIndex(createProviderListResponse(["opencode"])));
+
+      const result = resolveProvider("claude-opus-4-6");
+      expect(result).toEqual({
+        qualifiedModel: "opencode/claude-opus-4-6",
+        providerId: "opencode",
+      });
+    });
+
+    it("passes through already-qualified models", () => {
+      const result = resolveProvider("OpenAI/GPT-5.4");
+      expect(result).toEqual({
+        qualifiedModel: "openai/gpt-5.4",
+        providerId: "openai",
+      });
+    });
+
+    it("returns undefined for bare models when discovery is unavailable and no preferred provider", () => {
+      expect(resolveProvider("claude-opus-4-6")).toBeUndefined();
+    });
+
+    it("synthesizes qualification using default preferred provider when discovery is unavailable", () => {
+      setDefaultPreferredProvider("opencode");
+      const result = resolveProvider("claude-opus-4-6");
+      expect(result).toEqual({
+        qualifiedModel: "opencode/claude-opus-4-6",
+        providerId: "opencode",
+      });
+    });
+
+    it("synthesizes qualification using explicit preferred provider when discovery is unavailable", () => {
+      const result = resolveProvider("claude-opus-4-6", "anthropic");
+      expect(result).toEqual({
+        qualifiedModel: "anthropic/claude-opus-4-6",
+        providerId: "anthropic",
+      });
+    });
+
+    it("rejects malformed qualified models like /gpt-5.4", () => {
+      const result = resolveProvider("/gpt-5.4");
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("qualifyModel", () => {
+    it("qualifies when discovery is available", () => {
+      initializeDiscovery(buildDiscoveryIndex(createProviderListResponse(["openai", "opencode"])));
+
+      expect(qualifyModel("gpt-5.4")).toBe("openai/gpt-5.4");
+    });
+
+    it("falls back to pass-through when discovery is unavailable", () => {
+      expect(qualifyModel("gpt-5.4")).toBe("gpt-5.4");
+    });
+  });
+
+  describe("provider priority", () => {
+    it("supports setProviderPriority and getProviderPriority", () => {
+      setProviderPriority(["opencode", "openai", "anthropic", "google"]);
+
+      expect(getProviderPriority()).toEqual(["opencode", "openai", "anthropic", "google"]);
+    });
+
+    it("applies priority ordering when multiple connected providers exist", () => {
+      initializeDiscovery(buildDiscoveryIndex(createProviderListResponse(["openai", "opencode"])));
+      setProviderPriority(["opencode", "openai", "anthropic", "google"]);
+
+      const result = resolveProvider("gpt-5.4");
+      expect(result?.providerId).toBe("opencode");
+    });
+  });
+
+  describe("gateway model maps", () => {
+    it("translates canonical model IDs for selected provider", () => {
+      initializeDiscovery(buildDiscoveryIndex(createProviderListResponse(["opencode"])));
+      registerProviderModelMap("opencode", {
+        "gemini-3.1-flash-lite": "google/gemini-3.1-flash-lite",
+      });
+
+      const result = resolveProvider("gemini-3.1-flash-lite");
+      expect(result).toEqual({
+        qualifiedModel: "opencode/google/gemini-3.1-flash-lite",
+        providerId: "opencode",
+      });
+    });
+  });
+
+  describe("findProvidersForModel", () => {
+    it("returns only connected providers that offer the model", () => {
+      initializeDiscovery(buildDiscoveryIndex(createProviderListResponse(["openai", "opencode"])));
+      const providers = findProvidersForModel("gpt-5.4");
+
+      expect(providers).toEqual([
+        { providerId: "openai", modelId: "gpt-5.4" },
+        { providerId: "opencode", modelId: "gpt-5.4" },
+      ]);
+    });
+  });
+});

package/src/shared/provider-registry.ts

@@ -0,0 +1,157 @@
+import { getDiscovery, type ProviderModelEntry } from "./provider-discovery";
+
+export interface ProviderResolutionResult {
+  readonly qualifiedModel: string;
+  readonly providerId: string;
+}
+
+const DEFAULT_PROVIDER_PRIORITY = ["anthropic", "openai", "google", "opencode"] as const;
+
+let providerPriority: string[] = [...DEFAULT_PROVIDER_PRIORITY];
+let defaultPreferredProvider: string | undefined;
+const customModelMaps = new Map<string, Map<string, string>>();
+
+function normalizeIdentifier(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function normalizePriorityList(priority: readonly string[]): string[] {
+  const deduped = new Set<string>();
+  for (const providerId of priority) {
+    const normalized = normalizeIdentifier(providerId);
+    if (normalized) deduped.add(normalized);
+  }
+  return deduped.size > 0 ? [...deduped] : [...DEFAULT_PROVIDER_PRIORITY];
+}
+
+function providerRank(providerId: string): number {
+  const idx = providerPriority.indexOf(providerId);
+  return idx === -1 ? Number.MAX_SAFE_INTEGER : idx;
+}
+
+function sortByPriority(entries: ProviderModelEntry[]): ProviderModelEntry[] {
+  return [...entries].sort((a, b) => {
+    const byRank = providerRank(a.providerId) - providerRank(b.providerId);
+    if (byRank !== 0) return byRank;
+    return a.providerId.localeCompare(b.providerId);
+  });
+}
+
+function getProviderSpecificModelId(providerId: string, modelId: string): string {
+  const modelMap = customModelMaps.get(providerId);
+  if (!modelMap) return modelId;
+  return modelMap.get(modelId) ?? modelId;
+}
+
+export function setProviderPriority(priority: string[]): void {
+  providerPriority = normalizePriorityList(priority);
+}
+
+export function getProviderPriority(): readonly string[] {
+  return [...providerPriority];
+}
+
+export function setDefaultPreferredProvider(provider: string | undefined): void {
+  defaultPreferredProvider = provider ? normalizeIdentifier(provider) : undefined;
+}
+
+export function getDefaultPreferredProvider(): string | undefined {
+  return defaultPreferredProvider;
+}
+
+export function registerProviderModelMap(
+  providerId: string,
+  modelMap: Record<string, string>,
+): void {
+  const providerKey = normalizeIdentifier(providerId);
+  if (!providerKey) return;
+
+  const normalizedMap = new Map<string, string>();
+  for (const [canonicalModelId, providerModelId] of Object.entries(modelMap)) {
+    const canonical = normalizeIdentifier(canonicalModelId);
+    const providerSpecific = normalizeIdentifier(providerModelId);
+    if (canonical && providerSpecific) {
+      normalizedMap.set(canonical, providerSpecific);
+    }
+  }
+
+  customModelMaps.set(providerKey, normalizedMap);
+}
+
+export function unregisterProviderModelMap(providerId: string): boolean {
+  return customModelMaps.delete(normalizeIdentifier(providerId));
+}
+
+export function isQualifiedModel(model: string): boolean {
+  const slashIdx = model.indexOf("/");
+  return slashIdx > 0 && slashIdx < model.length - 1;
+}
+
+export function resetProviderRegistry(): void {
+  providerPriority = [...DEFAULT_PROVIDER_PRIORITY];
+  defaultPreferredProvider = undefined;
+  customModelMaps.clear();
+}
+
+export function findProvidersForModel(bareModel: string): ProviderModelEntry[] {
+  const normalizedModel = normalizeIdentifier(bareModel);
+  if (!normalizedModel) return [];
+
+  const discovery = getDiscovery();
+  if (!discovery) return [];
+
+  const entries = discovery.modelIndex.get(normalizedModel) ?? [];
+  const connectedEntries = entries.filter((entry) =>
+    discovery.connectedProviders.has(entry.providerId),
+  );
+
+  return sortByPriority(connectedEntries);
+}
+
+export function resolveProvider(
+  model: string,
+  preferredProvider?: string,
+): ProviderResolutionResult | undefined {
+  const trimmed = normalizeIdentifier(model);
+  if (!trimmed) return undefined;
+
+  if (isQualifiedModel(trimmed)) {
+    const slashIdx = trimmed.indexOf("/");
+    return {
+      qualifiedModel: trimmed,
+      providerId: trimmed.slice(0, slashIdx),
+    };
+  }
+
+  const candidates = findProvidersForModel(trimmed);
+  const preferred = normalizeIdentifier(preferredProvider ?? defaultPreferredProvider ?? "");
+
+  if (candidates.length === 0) {
+    // No discovery data or model not found — synthesize using preferred provider
+    if (preferred) {
+      const providerModelId = getProviderSpecificModelId(preferred, trimmed);
+      return {
+        qualifiedModel: `${preferred}/${providerModelId}`,
+        providerId: preferred,
+      };
+    }
+    return undefined;
+  }
+
+  const selected = preferred
+    ? (candidates.find((candidate) => candidate.providerId === preferred) ?? candidates[0])
+    : candidates[0];
+
+  if (!selected) return undefined;
+
+  const providerModelId = getProviderSpecificModelId(selected.providerId, selected.modelId);
+  return {
+    qualifiedModel: `${selected.providerId}/${providerModelId}`,
+    providerId: selected.providerId,
+  };
+}
+
+export function qualifyModel(model: string, preferredProvider?: string): string {
+  const result = resolveProvider(model, preferredProvider);
+  return result?.qualifiedModel ?? model;
+}

package/src/shared/safe-create-hook.ts

@@ -0,0 +1,15 @@
+import { log } from "./logger";
+
+export function safeCreateHook<T>(
+  name: string,
+  factory: () => T,
+  options?: { enabled?: boolean },
+): T | null {
+  if (options?.enabled === false) return null;
+  try {
+    return factory() ?? null;
+  } catch (error) {
+    log(`[safe-create-hook] Hook creation failed: ${name}`, { error });
+    return null;
+  }
+}

package/src/shared/snake-case.ts

@@ -0,0 +1,7 @@
+export function toSnakeCase(str: string): string {
+  return str
+    .replace(/([A-Z])/g, "_$1")
+    .toLowerCase()
+    .replace(/^_/, "")
+    .replace(/-/g, "_");
+}

package/src/shared/truncate-description.ts

@@ -0,0 +1,6 @@
+const DEFAULT_MAX_LENGTH = 100;
+
+export function truncateDescription(text: string, maxLength = DEFAULT_MAX_LENGTH): string {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}

package/src/test-utils/index.ts

@@ -0,0 +1,6 @@
+export { createMockPluginContext } from "./mock-plugin-context";
+export { createMockAgentConfig } from "./mock-agent-config";
+export * from "./mock-hook-inputs";
+export * from "./mock-hook-outputs";
+export { createMockToolContext } from "./mock-tool-context";
+export { createMockSdkClient } from "./mock-sdk-client";

package/src/test-utils/mock-agent-config.ts

@@ -0,0 +1,13 @@
+import type { AgentConfig } from "../types/agent";
+
+/**
+ * Create a minimal mock AgentConfig for unit testing.
+ */
+export function createMockAgentConfig(overrides: Partial<AgentConfig> = {}): AgentConfig {
+  return {
+    instructions: "You are a test agent.",
+    model: "anthropic/claude-sonnet-4-6",
+    temperature: 0.1,
+    ...overrides,
+  } as AgentConfig;
+}