@brainervirus/opencode-commandcode 0.6.0

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@brainervirus/opencode-commandcode",
+  "version": "0.6.0",
+  "description": "Command Code API provider for opencode — use Claude, GPT, Gemini, DeepSeek, Qwen, Kimi, GLM, MiniMax, and Step models via Command Code",
+  "keywords": [
+    "ai",
+    "claude",
+    "commandcode",
+    "deepseek",
+    "gemini",
+    "glm",
+    "gpt",
+    "kimi",
+    "llm",
+    "minimax",
+    "opencode",
+    "opencode-plugin",
+    "opencode-provider",
+    "qwen"
+  ],
+  "homepage": "https://github.com/BrainerVirus/opencode-commandcode#readme",
+  "bugs": {
+    "url": "https://github.com/BrainerVirus/opencode-commandcode/issues"
+  },
+  "license": "MIT",
+  "author": "Brent Weatherall",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BrainerVirus/opencode-commandcode.git"
+  },
+  "files": [
+    "index.ts",
+    "plugin.ts",
+    "models.json",
+    "manifest.json",
+    "_version.txt",
+    "README.md",
+    "CHANGELOG.md",
+    "src/"
+  ],
+  "type": "module",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts"
+    },
+    "./server": {
+      "import": "./plugin.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "oxlint --deny-warnings src scripts plugin.ts index.ts tests",
+    "lint:fix": "oxlint --fix src scripts plugin.ts index.ts tests",
+    "format": "oxfmt src scripts plugin.ts index.ts tests package.json tsconfig.json release.config.cjs",
+    "format:check": "oxfmt --check src scripts plugin.ts index.ts tests package.json tsconfig.json release.config.cjs",
+    "check": "bun run lint && bun run format:check && bun test tests/unit/ && bun run typecheck",
+    "test": "bun test tests/unit/",
+    "test:integration": "bun test tests/integration/",
+    "test:all": "bun test",
+    "typecheck": "tsc --noEmit",
+    "verify:release-candidate": "bun run scripts/verify-release-candidate.ts",
+    "generate-readme": "bun run scripts/generate-readme.ts",
+    "sync": "bun run scripts/sync-models.ts",
+    "sync:global": "bun run scripts/sync-models.ts --update-global",
+    "catalog:ci": "bun run scripts/catalog-sync-ci.ts"
+  },
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/github": "12.0.9",
+    "@semantic-release/npm": "13.1.5",
+    "@semantic-release/release-notes-generator": "14.1.1",
+    "@types/node": "^25.9.1",
+    "ai": "6.0.191",
+    "oxfmt": "0.63.0",
+    "oxlint": "1.78.0",
+    "semantic-release": "25.0.9",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "ai": ">=6.0.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/plugin.ts

@@ -0,0 +1,197 @@
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  generateOpencodeModels,
+  loadCatalogFromLocalCommandCode,
+  type ModelEntry,
+} from "./src/catalog.js";
+import {
+  readCatalogCache,
+  writeCatalogCache,
+  writeStartupSummary,
+  pluginStateDir,
+} from "./src/startup.js";
+import type { CatalogManifest } from "./src/manifest.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MODELS_PATH = join(__dirname, "models.json");
+const VERSION_PATH = join(__dirname, "_version.txt");
+const MANIFEST_PATH = join(__dirname, "manifest.json");
+
+interface PluginFileConfig {
+  disableModelSync?: boolean;
+  commandCodePackagePath?: string;
+  debugStartupLogs?: boolean;
+}
+
+function loadPluginConfig(): PluginFileConfig {
+  const dir = join(homedir(), ".config", "opencode");
+  const configPath = [
+    join(dir, "opencode-commandcode.json"),
+    join(dir, "commandcode-go-opencode-provider.json"),
+  ].find((p) => existsSync(p));
+  if (!configPath) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export type { ModelEntry };
+
+function loadBundledModels(): ModelEntry[] | null {
+  try {
+    return JSON.parse(readFileSync(MODELS_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function readBundledManifest(): CatalogManifest | null {
+  if (!existsSync(MANIFEST_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(MANIFEST_PATH, "utf-8")) as CatalogManifest;
+  } catch {
+    return null;
+  }
+}
+
+function readBundledVersion(): string | null {
+  const manifest = readBundledManifest();
+  if (manifest?.commandCodeVersion) return manifest.commandCodeVersion;
+  if (!existsSync(VERSION_PATH)) return null;
+  try {
+    const parts = readFileSync(VERSION_PATH, "utf-8").split("\n");
+    const first = parts[0]?.trim();
+    return first || null;
+  } catch {
+    return null;
+  }
+}
+
+export default async function commandcodePlugin() {
+  return {
+    config: async (config: Record<string, unknown>) => {
+      if (!(config as Record<string, unknown>).provider) {
+        (config as Record<string, unknown>).provider = { commandcode: {} };
+      }
+      const cc = (
+        (config as Record<string, unknown>).provider as Record<string, Record<string, unknown>>
+      )?.commandcode as Record<string, unknown> | undefined;
+      if (!cc) return;
+
+      const pluginCfg = loadPluginConfig();
+      const debug = pluginCfg.debugStartupLogs === true;
+      const override =
+        pluginCfg.commandCodePackagePath?.trim() ||
+        process.env.COMMANDCODE_PACKAGE_PATH?.trim() ||
+        "";
+
+      if (!cc.npm) cc.npm = "commandcode-go-opencode-provider";
+      if (!cc.name) cc.name = "Command Code";
+      if (!cc.env) cc.env = ["COMMANDCODE_API_KEY"];
+
+      if (cc.models) return;
+
+      let models: ModelEntry[] = [];
+      let catalogSource: "bundled" | "cache" | "opt-in-local" = "bundled";
+      let commandCodeVersion: string | null = null;
+      let degraded = false;
+      let degradedReason: string | null = null;
+
+      if (override) {
+        const localCatalog = loadCatalogFromLocalCommandCode({ packagePath: override });
+        if (localCatalog && localCatalog.models.length > 0) {
+          models = localCatalog.models;
+          catalogSource = "opt-in-local";
+          commandCodeVersion = localCatalog.version;
+        }
+      }
+
+      if (models.length === 0) {
+        const bundled = loadBundledModels();
+        if (bundled) {
+          models = bundled;
+          catalogSource = "bundled";
+          commandCodeVersion = readBundledVersion();
+          const manifest = readBundledManifest();
+          if (manifest?.status === "degraded" || manifest?.status === "broken") {
+            degraded = true;
+            degradedReason =
+              manifest.status === "broken"
+                ? "bundled catalog marked broken"
+                : "bundled catalog has models with no listed price";
+          }
+        } else {
+          const cached = readCatalogCache();
+          if (cached) {
+            models = cached;
+            catalogSource = "cache";
+            degraded = true;
+            degradedReason = "bundled models.json unreadable; using last-good cache";
+          } else {
+            degraded = true;
+            degradedReason = "no bundled catalog and no cache";
+          }
+        }
+      }
+
+      if (models.length > 0) {
+        try {
+          writeCatalogCache(pluginStateDir(), models);
+        } catch {
+          // ignore cache write
+        }
+      }
+
+      cc.models = generateOpencodeModels(models);
+
+      const summary = {
+        catalogSource,
+        commandCodeVersion,
+        modelCount: models.length,
+        reasoningModelCount: models.filter((m) => m.reasoning).length,
+        degraded,
+        degradedReason,
+      };
+      try {
+        writeStartupSummary(pluginStateDir(), summary);
+      } catch {
+        // ignore
+      }
+      if (debug) {
+        console.warn("[commandcode]", JSON.stringify(summary));
+      }
+    },
+
+    auth: {
+      provider: "commandcode",
+      methods: [
+        {
+          type: "api",
+          label: "API Key",
+          authorize: async (inputs: Record<string, unknown> | undefined) => {
+            const rawKey = inputs?.key;
+            if (typeof rawKey !== "string") return { type: "failed" as const };
+            const key = rawKey.trim();
+            if (!key) return { type: "failed" as const };
+            return { type: "success" as const, key };
+          },
+        },
+      ],
+      loader: async (getAuth: () => Promise<{ type: string; key?: string } | null>) => {
+        try {
+          const auth = await getAuth();
+          if (!auth) return {};
+          if (auth.type === "api" && auth.key) return { apiKey: auth.key };
+          return {};
+        } catch {
+          return {};
+        }
+      },
+    },
+  };
+}

package/src/auth.ts

@@ -0,0 +1,43 @@
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export function resolveApiKey(options: {
+  apiKey?: string;
+  env?: Record<string, string | undefined>;
+  authPaths?: string[];
+}): string | undefined {
+  if (options.apiKey) return options.apiKey;
+
+  const envKey = options.env?.COMMANDCODE_API_KEY ?? process.env.COMMANDCODE_API_KEY;
+  if (envKey) return envKey;
+
+  const authPaths = options.authPaths ?? [
+    join(homedir(), ".commandcode", "auth.json"),
+    join(homedir(), ".pi", "agent", "auth.json"),
+  ];
+
+  for (const p of authPaths) {
+    if (!existsSync(p)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(p, "utf-8"));
+      if (typeof parsed === "object" && parsed !== null) {
+        if (typeof parsed.apiKey === "string") return parsed.apiKey;
+        if (typeof parsed.commandcode === "string") return parsed.commandcode;
+        if (
+          typeof parsed.commandcode === "object" &&
+          parsed.commandcode !== null &&
+          parsed.commandcode.type === "oauth" &&
+          typeof parsed.commandcode.access === "string"
+        ) {
+          return parsed.commandcode.access;
+        }
+      }
+    } catch {
+      // intentionally silent: skip unreadable or malformed auth files
+      continue;
+    }
+  }
+
+  return undefined;
+}

package/src/catalog-break.ts

@@ -0,0 +1,40 @@
+export function catalogBreakTitle(commandCodeVersion: string): string {
+  return `[catalog-break] command-code@${commandCodeVersion} — model extraction failed`;
+}
+
+export function renderCatalogBreakBody(input: {
+  commandCodeVersion: string;
+  error: string;
+  workflowUrl: string;
+  bundledCommandCodeVersion: string | null;
+}): string {
+  const bundled = input.bundledCommandCodeVersion ?? "(none)";
+  return `Model catalog extraction failed for \`command-code@${input.commandCodeVersion}\`.
+
+## Error
+
+\`\`\`
+${input.error}
+\`\`\`
+
+## Workflow
+
+${input.workflowUrl}
+
+## Still serving
+
+Bundled catalog is still \`command-code@${bundled}\`. No npm release was published.
+
+## Manual fix
+
+- [ ] Check extraction anchors in \`src/catalog.ts\`
+- [ ] Add/adjust unit fixtures under \`tests/fixtures/command-code/\`
+- [ ] Re-run **Catalog sync** with \`force=true\`
+`;
+}
+
+export function catalogBreakResolvedComment(input: { commit: string; tag: string }): string {
+  return `Catalog sync recovered. Fix commit: \`${input.commit}\`. Release: \`${input.tag}\`.`;
+}
+
+export const CATALOG_BREAK_LABEL = "catalog-break";

package/src/catalog-release-notes.ts

@@ -0,0 +1,171 @@
+import type { CatalogManifest, CatalogReview, CatalogStatus, CostSources } from "./manifest.js";
+
+export type PricedModel = {
+  id: string;
+  name: string;
+  cost: { input: number; output: number };
+};
+
+export type CatalogReleaseInput = {
+  pluginVersion: string;
+  commandCodeVersion: string;
+  modelCount: number;
+  reasoningModelCount: number;
+  status: CatalogStatus;
+  costSources: CostSources;
+  models: PricedModel[];
+  review?: CatalogReview;
+};
+
+const DEFAULT_COST = { input: 0.5, output: 2 };
+
+export function partitionPrices(
+  models: PricedModel[],
+  review: CatalogReview | undefined,
+): { thirdParty: PricedModel[]; free: PricedModel[]; unmatched: PricedModel[] } {
+  const byId = new Map(models.map((m) => [m.id, m]));
+  if (review) {
+    return {
+      thirdParty: review.thirdParty.flatMap((id) => (byId.get(id) ? [byId.get(id)!] : [])),
+      free: review.free.flatMap((id) => (byId.get(id) ? [byId.get(id)!] : [])),
+      unmatched: review.unmatched.flatMap((id) => (byId.get(id) ? [byId.get(id)!] : [])),
+    };
+  }
+  const thirdParty: PricedModel[] = [];
+  const free: PricedModel[] = [];
+  const unmatched: PricedModel[] = [];
+  for (const model of models) {
+    if (model.cost.input === 0 && model.cost.output === 0) free.push(model);
+    else if (model.cost.input === DEFAULT_COST.input && model.cost.output === DEFAULT_COST.output) {
+      unmatched.push(model);
+    }
+  }
+  return { thirdParty, free, unmatched };
+}
+
+function n(count: number, one: string, many: string): string {
+  return `${count} ${count === 1 ? one : many}`;
+}
+
+function headline(status: CatalogStatus): string {
+  if (status === "healthy") {
+    return "**Catalog is complete.** Prices come from Command Code, official docs, models.dev, or free SKUs.";
+  }
+  if (status === "broken") {
+    return "**Do not use this catalog.** Model extraction failed; OpenCode would not get a current model list.";
+  }
+  return "**Safe to use.** Every model is listed. Some prices have no listed source — expand the sections below to review them.";
+}
+
+function priceSummary(sources: CostSources): string {
+  const parts: string[] = [];
+  if (sources.cli > 0) parts.push(`${sources.cli} CLI`);
+  if (sources.officialDocs > 0) parts.push(`${sources.officialDocs} official docs`);
+  if (sources.thirdParty > 0) parts.push(`${sources.thirdParty} models.dev`);
+  if (sources.free > 0) parts.push(`${sources.free} free`);
+  if (sources.fallback > 0)
+    parts.push(`${sources.fallback} hardcoded fallback${sources.fallback === 1 ? "" : "s"}`);
+  if (sources.unmatched > 0) parts.push(`${sources.unmatched} no listed price`);
+  return parts.join(" · ") || "none";
+}
+
+function money(n: number): string {
+  return `$${n}`;
+}
+
+function modelTable(models: PricedModel[]): string {
+  const rows = models
+    .map((m) => `| ${m.name} | \`${m.id}\` | ${money(m.cost.input)} / ${money(m.cost.output)} |`)
+    .join("\n");
+  return `| Model | Id | In / out per 1M |\n| --- | --- | --- |\n${rows}`;
+}
+
+function details(summary: string, body: string): string {
+  return `<details>\n<summary>${summary}</summary>\n\n${body}\n\n</details>`;
+}
+
+export function renderCatalogReleaseNotes(input: CatalogReleaseInput): string {
+  const { thirdParty, free, unmatched } = partitionPrices(input.models, input.review);
+  const sections = [
+    headline(input.status),
+    "",
+    "| | |",
+    "| --- | --- |",
+    `| Plugin | ${input.pluginVersion} |`,
+    `| Command Code | ${input.commandCodeVersion} |`,
+    `| Models | ${input.modelCount} (${input.reasoningModelCount} with reasoning) |`,
+    `| Prices | ${priceSummary(input.costSources)} |`,
+  ];
+
+  if (thirdParty.length > 0) {
+    sections.push(
+      "",
+      details(
+        n(
+          thirdParty.length,
+          "model with a models.dev reference price",
+          "models with models.dev reference prices",
+        ),
+        modelTable(thirdParty),
+      ),
+    );
+  }
+  if (free.length > 0) {
+    sections.push(
+      "",
+      details(n(free.length, "free model ($0)", "free models ($0)"), modelTable(free)),
+    );
+  }
+  if (unmatched.length > 0) {
+    sections.push(
+      "",
+      details(
+        n(
+          unmatched.length,
+          "model with no listed price ($0.50 / $2)",
+          "models with no listed price ($0.50 / $2)",
+        ),
+        modelTable(unmatched),
+      ),
+    );
+  }
+
+  sections.push(
+    "",
+    details(
+      "Machine-readable catalog",
+      "```json\n" +
+        JSON.stringify(
+          {
+            status: input.status,
+            pluginVersion: input.pluginVersion,
+            commandCodeVersion: input.commandCodeVersion,
+            modelCount: input.modelCount,
+            reasoningModelCount: input.reasoningModelCount,
+            costSources: input.costSources,
+          },
+          null,
+          2,
+        ) +
+        "\n```",
+    ),
+  );
+
+  return sections.join("\n") + "\n";
+}
+
+export function catalogReleaseNotesFromFiles(input: {
+  manifest: CatalogManifest;
+  models: PricedModel[];
+}): string {
+  return renderCatalogReleaseNotes({
+    pluginVersion: input.manifest.pluginVersion,
+    commandCodeVersion: input.manifest.commandCodeVersion,
+    modelCount: input.manifest.modelCount,
+    reasoningModelCount: input.manifest.reasoningModelCount,
+    status: input.manifest.status,
+    costSources: input.manifest.costSources,
+    models: input.models,
+    review: input.manifest.review,
+  });
+}