goatcode-sh 0.0.1 → 0.1.3

package/src/shared/index.ts

@@ -0,0 +1,59 @@
+export { log, getLogFilePath } from "./logger";
+export { deepMerge, isPlainObject } from "./deep-merge";
+export { toSnakeCase } from "./snake-case";
+export { truncateDescription } from "./truncate-description";
+export { getDataDir, getCacheDir, getOpenCodeStorageDir, getGoatCodeCacheDir } from "./data-path";
+export { safeCreateHook } from "./safe-create-hook";
+export { normalizeModel, parseModelId, normalizeAndQualifyModel } from "./model-normalization";
+export { isModelAvailable } from "./model-availability";
+export { buildFallbackChain } from "./fallback-chain";
+export { resolveModel } from "./model-resolution-pipeline";
+export type {
+  ModelResolutionInput,
+  ModelResolutionSource,
+  ModelResolutionResult,
+} from "./model-resolution-pipeline";
+export {
+  toPlatformModel,
+  toCanonicalModel,
+  registerPlatformMappings,
+  getKnownPlatforms,
+} from "./model-prefix-map";
+export type { PlatformId, BuiltinPlatformId } from "./model-prefix-map";
+export {
+  resolveProvider,
+  qualifyModel,
+  isQualifiedModel,
+  findProvidersForModel,
+  setProviderPriority,
+  getProviderPriority,
+  setDefaultPreferredProvider,
+  getDefaultPreferredProvider,
+  registerProviderModelMap,
+  unregisterProviderModelMap,
+  resetProviderRegistry,
+} from "./provider-registry";
+export type { ProviderResolutionResult } from "./provider-registry";
+export {
+  buildDiscoveryIndex,
+  initializeDiscovery,
+  getDiscovery,
+  resetDiscovery,
+} from "./provider-discovery";
+export type {
+  ProviderListResponse,
+  ProviderModelEntry,
+  DiscoveryResult,
+} from "./provider-discovery";
+export {
+  buildModelsDevIndex,
+  fetchModelsDevData,
+  resolveWithModelsDevData,
+  createModelsDevCache,
+} from "./models-dev";
+export type {
+  ModelsDevModel,
+  ModelsDevProvider,
+  ModelsDevIndex,
+  ModelsDevCache,
+} from "./models-dev";

package/src/shared/logger.ts

@@ -0,0 +1,54 @@
+import { appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const LOG_FILE = join(tmpdir(), "goatcode.log");
+const BUFFER_SIZE_LIMIT = 50;
+const FLUSH_INTERVAL_MS = 500;
+
+let buffer: string[] = [];
+let flushTimer: ReturnType<typeof setTimeout> | null = null;
+
+function flush(): void {
+  if (buffer.length === 0) return;
+  const data = buffer.join("");
+  buffer = [];
+  try {
+    appendFileSync(LOG_FILE, data);
+  } catch {
+    // Ignore log write failures - never crash the plugin for logging
+  }
+}
+
+// Flush buffer on process exit to avoid losing buffered log entries
+process.on("exit", flush);
+process.on("beforeExit", flush);
+
+function scheduleFlush(): void {
+  if (flushTimer) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
+
+/** Write a structured log entry to the goatcode log file. */
+export function log(message: string, data?: unknown): void {
+  try {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data !== undefined ? JSON.stringify(data) : ""}\n`;
+    buffer.push(logEntry);
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  } catch {
+    // Never throw from logger
+  }
+}
+
+/** Returns the absolute path to the log file. */
+export function getLogFilePath(): string {
+  return LOG_FILE;
+}

package/src/shared/model-availability.ts

@@ -0,0 +1,18 @@
+export function isModelAvailable(model: string, availableModels: Set<string>): boolean {
+  if (availableModels.size === 0) return true;
+  const normalized = model.toLowerCase().trim();
+  if (availableModels.has(normalized)) return true;
+
+  for (const available of availableModels) {
+    const longer = available.length > normalized.length ? available : normalized;
+    const shorter = available.length <= normalized.length ? available : normalized;
+    if (
+      longer.startsWith(shorter) &&
+      (longer.length === shorter.length || /[/\-.]/.test(longer[shorter.length]!))
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/shared/model-normalization.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "bun:test";
+import { normalizeModel, parseModelId } from "./model-normalization";
+
+describe("normalizeModel", () => {
+  describe("given undefined input", () => {
+    it("returns undefined", () => {
+      expect(normalizeModel(undefined)).toBeUndefined();
+    });
+  });
+
+  describe("given empty string", () => {
+    it("returns undefined", () => {
+      expect(normalizeModel("")).toBeUndefined();
+    });
+  });
+
+  describe("given whitespace-only string", () => {
+    it("returns undefined", () => {
+      expect(normalizeModel("   ")).toBeUndefined();
+    });
+  });
+
+  describe("given model with leading/trailing whitespace", () => {
+    it("trims whitespace", () => {
+      expect(normalizeModel("  openai/gpt-4  ")).toBe("openai/gpt-4");
+    });
+  });
+
+  describe("given model with uppercase letters", () => {
+    it("lowercases the result", () => {
+      expect(normalizeModel("OpenAI/GPT-4")).toBe("openai/gpt-4");
+    });
+  });
+
+  describe("given already normalized model", () => {
+    it("returns unchanged", () => {
+      expect(normalizeModel("anthropic/claude-3")).toBe("anthropic/claude-3");
+    });
+  });
+});
+
+describe("parseModelId", () => {
+  describe("given model without slash", () => {
+    it("returns undefined", () => {
+      expect(parseModelId("gpt-4")).toBeUndefined();
+    });
+  });
+
+  describe("given empty string", () => {
+    it("returns undefined", () => {
+      expect(parseModelId("")).toBeUndefined();
+    });
+  });
+
+  describe("given valid provider/model format", () => {
+    it("splits on first slash", () => {
+      expect(parseModelId("openai/gpt-4")).toEqual({ provider: "openai", modelId: "gpt-4" });
+    });
+  });
+
+  describe("given model with multiple slashes", () => {
+    it("splits on first slash only", () => {
+      expect(parseModelId("openai/gpt-4/turbo")).toEqual({
+        provider: "openai",
+        modelId: "gpt-4/turbo",
+      });
+    });
+  });
+
+  describe("given model with uppercase", () => {
+    it("normalizes before parsing", () => {
+      expect(parseModelId("OpenAI/GPT-4")).toEqual({ provider: "openai", modelId: "gpt-4" });
+    });
+  });
+});

package/src/shared/model-normalization.ts

@@ -0,0 +1,28 @@
+import { qualifyModel } from "./provider-registry";
+
+export function normalizeModel(model: string | undefined): string | undefined {
+  if (!model) return undefined;
+  const trimmed = model.trim();
+  if (!trimmed) return undefined;
+  return trimmed.toLowerCase();
+}
+
+export function parseModelId(model: string): { provider: string; modelId: string } | undefined {
+  const normalized = normalizeModel(model);
+  if (!normalized) return undefined;
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex === -1) return undefined;
+  return {
+    provider: normalized.slice(0, slashIndex),
+    modelId: normalized.slice(slashIndex + 1),
+  };
+}
+
+export function normalizeAndQualifyModel(
+  model: string | undefined,
+  preferredProvider?: string,
+): string | undefined {
+  const normalized = normalizeModel(model);
+  if (!normalized) return undefined;
+  return qualifyModel(normalized, preferredProvider);
+}

package/src/shared/model-prefix-map.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "bun:test";
+import { toPlatformModel, toCanonicalModel } from "./model-prefix-map";
+
+describe("model prefix map", () => {
+  describe("#given direct platform", () => {
+    describe("#when converting to platform model", () => {
+      it("#then returns the model unchanged", () => {
+        expect(toPlatformModel("anthropic/claude-opus-4-6", "direct")).toBe(
+          "anthropic/claude-opus-4-6",
+        );
+      });
+    });
+
+    describe("#when converting to canonical model", () => {
+      it("#then returns the model unchanged", () => {
+        expect(toCanonicalModel("anthropic/claude-opus-4-6", "direct")).toBe(
+          "anthropic/claude-opus-4-6",
+        );
+      });
+    });
+  });
+
+  describe("#given zen platform", () => {
+    describe("#when converting anthropic model to platform", () => {
+      it("#then adds zen- prefix", () => {
+        expect(toPlatformModel("anthropic/claude-opus-4-6", "zen")).toBe(
+          "zen-anthropic/claude-opus-4-6",
+        );
+      });
+    });
+
+    describe("#when converting openai model to platform", () => {
+      it("#then adds zen- prefix", () => {
+        expect(toPlatformModel("openai/gpt-5.4", "zen")).toBe("zen-openai/gpt-5.4");
+      });
+    });
+
+    describe("#when converting google model to platform", () => {
+      it("#then adds zen- prefix", () => {
+        expect(toPlatformModel("google/gemini-2.5-flash", "zen")).toBe(
+          "zen-google/gemini-2.5-flash",
+        );
+      });
+    });
+
+    describe("#when converting zen-prefixed model back to canonical", () => {
+      it("#then strips zen- prefix", () => {
+        expect(toCanonicalModel("zen-anthropic/claude-opus-4-6", "zen")).toBe(
+          "anthropic/claude-opus-4-6",
+        );
+        expect(toCanonicalModel("zen-openai/gpt-5.4", "zen")).toBe("openai/gpt-5.4");
+        expect(toCanonicalModel("zen-google/gemini-2.5-flash", "zen")).toBe(
+          "google/gemini-2.5-flash",
+        );
+      });
+    });
+
+    describe("#when converting an unknown provider", () => {
+      it("#then returns the model unchanged", () => {
+        expect(toPlatformModel("mistral/mistral-large", "zen")).toBe("mistral/mistral-large");
+      });
+    });
+  });
+
+  describe("#given roundtrip conversion", () => {
+    describe("#when converting to platform then back to canonical", () => {
+      it("#then returns the original model", () => {
+        const original = "anthropic/claude-sonnet-4-6";
+        const platform = toPlatformModel(original, "zen");
+        const canonical = toCanonicalModel(platform, "zen");
+        expect(canonical).toBe(original);
+      });
+    });
+  });
+});

package/src/shared/model-prefix-map.ts

@@ -0,0 +1,58 @@
+export type BuiltinPlatformId = "direct" | "zen";
+export type PlatformId = BuiltinPlatformId | (string & {});
+
+type PrefixMapping = {
+  canonical: string;
+  platform: string;
+};
+
+const ZEN_PREFIX_MAPPINGS: PrefixMapping[] = [
+  { canonical: "anthropic/", platform: "zen-anthropic/" },
+  { canonical: "openai/", platform: "zen-openai/" },
+  { canonical: "google/", platform: "zen-google/" },
+];
+
+const PLATFORM_MAPPINGS: Record<string, PrefixMapping[]> = {
+  direct: [],
+  zen: ZEN_PREFIX_MAPPINGS,
+};
+
+// "anthropic/claude-opus-4-6" + "zen" -> "zen-anthropic/claude-opus-4-6"
+export function toPlatformModel(canonicalModel: string, platform: PlatformId): string {
+  if (platform === "direct") return canonicalModel;
+
+  const mappings = PLATFORM_MAPPINGS[platform];
+  if (!mappings) return canonicalModel;
+
+  for (const { canonical, platform: platformPrefix } of mappings) {
+    if (canonicalModel.startsWith(canonical)) {
+      return platformPrefix + canonicalModel.slice(canonical.length);
+    }
+  }
+
+  return canonicalModel;
+}
+
+// "zen-anthropic/claude-opus-4-6" + "zen" -> "anthropic/claude-opus-4-6"
+export function toCanonicalModel(platformModel: string, platform: PlatformId): string {
+  if (platform === "direct") return platformModel;
+
+  const mappings = PLATFORM_MAPPINGS[platform];
+  if (!mappings) return platformModel;
+
+  for (const { canonical, platform: platformPrefix } of mappings) {
+    if (platformModel.startsWith(platformPrefix)) {
+      return canonical + platformModel.slice(platformPrefix.length);
+    }
+  }
+
+  return platformModel;
+}
+
+export function registerPlatformMappings(platform: string, mappings: PrefixMapping[]): void {
+  PLATFORM_MAPPINGS[platform] = mappings;
+}
+
+export function getKnownPlatforms(): string[] {
+  return Object.keys(PLATFORM_MAPPINGS);
+}

package/src/shared/model-resolution-pipeline.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "bun:test";
+import { resolveModel } from "./model-resolution-pipeline";
+
+describe("resolveModel", () => {
+  describe("given an override", () => {
+    it("returns override regardless of other inputs", () => {
+      const result = resolveModel({
+        override: "openai/gpt-4",
+        categoryDefault: "anthropic/claude-3",
+        fallbackChain: ["google/gemini-pro"],
+        systemDefault: "openai/gpt-3.5-turbo",
+      });
+      expect(result).toEqual({ model: "openai/gpt-4", source: "override" });
+    });
+
+    it("normalizes the override model", () => {
+      const result = resolveModel({ override: "  OpenAI/GPT-4  " });
+      expect(result).toEqual({ model: "openai/gpt-4", source: "override" });
+    });
+  });
+
+  describe("given no override but a category default", () => {
+    it("returns category default when available", () => {
+      const result = resolveModel({
+        categoryDefault: "anthropic/claude-3",
+        availableModels: new Set(["anthropic/claude-3"]),
+      });
+      expect(result).toEqual({ model: "anthropic/claude-3", source: "category-default" });
+    });
+
+    it("skips category default when not available", () => {
+      const result = resolveModel({
+        categoryDefault: "anthropic/claude-3",
+        fallbackChain: ["openai/gpt-4"],
+        availableModels: new Set(["openai/gpt-4"]),
+      });
+      expect(result).toEqual({ model: "openai/gpt-4", source: "fallback" });
+    });
+
+    it("returns category default when no availability constraint", () => {
+      const result = resolveModel({
+        categoryDefault: "anthropic/claude-3",
+        availableModels: new Set(),
+      });
+      expect(result).toEqual({ model: "anthropic/claude-3", source: "category-default" });
+    });
+  });
+
+  describe("given no override and no category default, but a fallback chain", () => {
+    it("returns first available fallback", () => {
+      const result = resolveModel({
+        fallbackChain: ["unavailable/model", "openai/gpt-4", "google/gemini-pro"],
+        availableModels: new Set(["openai/gpt-4", "google/gemini-pro"]),
+      });
+      expect(result).toEqual({ model: "openai/gpt-4", source: "fallback" });
+    });
+
+    it("skips unavailable fallbacks", () => {
+      const result = resolveModel({
+        fallbackChain: ["unavailable/model-a", "unavailable/model-b", "openai/gpt-4"],
+        availableModels: new Set(["openai/gpt-4"]),
+      });
+      expect(result).toEqual({ model: "openai/gpt-4", source: "fallback" });
+    });
+  });
+
+  describe("given only a system default", () => {
+    it("returns system default as last resort", () => {
+      const result = resolveModel({
+        systemDefault: "openai/gpt-3.5-turbo",
+      });
+      expect(result).toEqual({ model: "openai/gpt-3.5-turbo", source: "system-default" });
+    });
+
+    it("returns system default when it is in available models", () => {
+      const result = resolveModel({
+        categoryDefault: "anthropic/claude-3",
+        fallbackChain: ["google/gemini-pro"],
+        systemDefault: "openai/gpt-3.5-turbo",
+        availableModels: new Set(["openai/gpt-3.5-turbo"]),
+      });
+      expect(result).toEqual({ model: "openai/gpt-3.5-turbo", source: "system-default" });
+    });
+
+    it("returns undefined when system default is not available", () => {
+      const result = resolveModel({
+        categoryDefault: "anthropic/claude-3",
+        fallbackChain: ["google/gemini-pro"],
+        systemDefault: "openai/gpt-3.5-turbo",
+        availableModels: new Set(["openai/gpt-4"]),
+      });
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("given no inputs", () => {
+    it("returns undefined", () => {
+      expect(resolveModel({})).toBeUndefined();
+    });
+  });
+
+  describe("given empty override string", () => {
+    it("falls through to next step", () => {
+      const result = resolveModel({
+        override: "   ",
+        systemDefault: "openai/gpt-3.5-turbo",
+      });
+      expect(result).toEqual({ model: "openai/gpt-3.5-turbo", source: "system-default" });
+    });
+  });
+});

package/src/shared/model-resolution-pipeline.ts

@@ -0,0 +1,55 @@
+import { normalizeModel } from "./model-normalization";
+import { isModelAvailable } from "./model-availability";
+import { qualifyModel } from "./provider-registry";
+
+export type ModelResolutionInput = {
+  override?: string;
+  categoryDefault?: string;
+  fallbackChain?: string[];
+  systemDefault?: string;
+  availableModels?: Set<string>;
+  preferredProvider?: string;
+};
+
+export type ModelResolutionSource = "override" | "category-default" | "fallback" | "system-default";
+
+export type ModelResolutionResult = {
+  model: string;
+  source: ModelResolutionSource;
+};
+
+function normalizeAndQualify(
+  model: string | undefined,
+  preferredProvider?: string,
+): string | undefined {
+  const normalized = normalizeModel(model);
+  if (!normalized) return undefined;
+  return qualifyModel(normalized, preferredProvider);
+}
+
+export function resolveModel(input: ModelResolutionInput): ModelResolutionResult | undefined {
+  const available = input.availableModels ?? new Set<string>();
+  const pref = input.preferredProvider;
+
+  const override = normalizeAndQualify(input.override, pref);
+  if (override) return { model: override, source: "override" };
+
+  const categoryDefault = normalizeAndQualify(input.categoryDefault, pref);
+  if (categoryDefault && isModelAvailable(categoryDefault, available)) {
+    return { model: categoryDefault, source: "category-default" };
+  }
+
+  for (const fallback of input.fallbackChain ?? []) {
+    const normalized = normalizeAndQualify(fallback, pref);
+    if (normalized && isModelAvailable(normalized, available)) {
+      return { model: normalized, source: "fallback" };
+    }
+  }
+
+  const systemDefault = normalizeAndQualify(input.systemDefault, pref);
+  if (systemDefault && isModelAvailable(systemDefault, available)) {
+    return { model: systemDefault, source: "system-default" };
+  }
+
+  return undefined;
+}