@herouucn/opencode-commandcode 0.1.0

package/src/manifest.ts

@@ -0,0 +1,134 @@
+import { writeFileSync } from "fs";
+
+export type CatalogStatus = "healthy" | "degraded" | "broken";
+export type CostCatalogBest = "cli" | "docs" | "thirdParty" | "free" | "fallback" | "missing";
+
+export type CostSources = {
+  cli: number;
+  officialDocs: number;
+  thirdParty: number;
+  free: number;
+  fallback: number;
+  unmatched: number;
+};
+
+export type CatalogReview = {
+  thirdParty: string[];
+  free: string[];
+  unmatched: string[];
+};
+
+export type CatalogManifest = {
+  schemaVersion: 1;
+  generatedAt: string;
+  pluginVersion: string;
+  commandCodeVersion: string;
+  commandCodeTarball: string;
+  modelCount: number;
+  reasoningModelCount: number;
+  extraction: {
+    modelCatalog: "ok" | "failed";
+    costCatalog: CostCatalogBest;
+    costCatalogError: string | null;
+  };
+  costSources: CostSources;
+  review?: CatalogReview;
+  status: CatalogStatus;
+};
+
+export type BuildManifestInput = {
+  pluginVersion: string;
+  commandCodeVersion: string;
+  commandCodeTarball: string;
+  modelCount: number;
+  reasoningModelCount: number;
+  modelCatalogOk: boolean;
+  costSources: CostSources;
+  review?: CatalogReview;
+  generatedAt: string;
+  costCatalogError?: string | null;
+};
+
+export function meetsModelCountFloor(modelCount: number, lastSuccessful: number | null): boolean {
+  const floor = Math.max(20, Math.floor((lastSuccessful ?? 20) * 0.5));
+  // ponytail: when there is no prior catalog, lastSuccessful is null and the floor is 20
+  return modelCount >= (lastSuccessful === null ? 20 : floor);
+}
+
+export function bestCostCatalog(sources: CostSources): CostCatalogBest {
+  if (sources.cli > 0) return "cli";
+  if (sources.officialDocs > 0) return "docs";
+  if (sources.thirdParty > 0) return "thirdParty";
+  if (sources.free > 0) return "free";
+  if (sources.fallback > 0) return "fallback";
+  return "missing";
+}
+
+export function catalogStatus(modelCatalogOk: boolean, sources: CostSources): CatalogStatus {
+  if (!modelCatalogOk) return "broken";
+  if (sources.unmatched > 0) return "degraded";
+  return "healthy";
+}
+
+export function commandCodeTarballUrl(version: string): string {
+  return `https://registry.npmjs.org/command-code/-/command-code-${version}.tgz`;
+}
+
+export function buildManifest(input: BuildManifestInput): CatalogManifest {
+  const status = catalogStatus(input.modelCatalogOk, input.costSources);
+  return {
+    schemaVersion: 1,
+    generatedAt: input.generatedAt,
+    pluginVersion: input.pluginVersion,
+    commandCodeVersion: input.commandCodeVersion,
+    commandCodeTarball: input.commandCodeTarball,
+    modelCount: input.modelCount,
+    reasoningModelCount: input.reasoningModelCount,
+    extraction: {
+      modelCatalog: input.modelCatalogOk ? "ok" : "failed",
+      costCatalog: bestCostCatalog(input.costSources),
+      costCatalogError: input.costCatalogError ?? null,
+    },
+    costSources: { ...input.costSources },
+    ...(input.review ? { review: input.review } : {}),
+    status,
+  };
+}
+
+export function writeManifest(path: string, manifest: CatalogManifest): void {
+  writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+}
+
+export function lastSuccessfulModelCount(manifest: CatalogManifest | null): number | null {
+  if (!manifest) return null;
+  if (manifest.status === "broken") return null;
+  return manifest.modelCount;
+}
+
+export function countCostSources(input: {
+  modelIds: string[];
+  cliIds: Set<string>;
+  officialDocIds: Set<string>;
+  thirdPartyIds: Set<string>;
+  freeIds: Set<string>;
+  fallbackIds?: Set<string>;
+}): CostSources {
+  const fallbackIds = input.fallbackIds ?? new Set<string>();
+  const sources: CostSources = {
+    cli: 0,
+    officialDocs: 0,
+    thirdParty: 0,
+    free: 0,
+    fallback: 0,
+    unmatched: 0,
+  };
+  for (const id of input.modelIds) {
+    if (input.cliIds.has(id)) sources.cli++;
+    else if (input.officialDocIds.has(id)) sources.officialDocs++;
+    else if (input.thirdPartyIds.has(id)) sources.thirdParty++;
+    else if (input.freeIds.has(id)) sources.free++;
+    else if (fallbackIds.has(id)) sources.fallback++;
+    else sources.unmatched++;
+  }
+  return sources;
+}

package/src/model.ts

@@ -0,0 +1,168 @@
+import type {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3StreamResult,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3Content,
+  LanguageModelV3Usage,
+  LanguageModelV3FinishReason,
+} from "@ai-sdk/provider";
+import { buildRequest } from "./convert.js";
+import { parseStreamEvents } from "./stream.js";
+
+const DEFAULT_BASE_URL = "https://api.commandcode.ai";
+// x-command-code-version must match the Command Code CLI version for API compatibility
+const CC_VERSION = "0.26.20";
+
+export interface CommandCodeModelOptions {
+  apiKey: string;
+  baseURL?: string;
+  headers?: Record<string, string>;
+}
+
+export class CommandCodeLanguageModel implements LanguageModelV3 {
+  readonly specificationVersion = "v3" as const;
+  readonly provider = "commandcode";
+  readonly modelId: string;
+  supportedUrls: Record<string, RegExp[]> = {};
+
+  private opts: CommandCodeModelOptions;
+
+  constructor(modelId: string, opts: CommandCodeModelOptions) {
+    this.modelId = modelId;
+    this.opts = opts;
+  }
+
+  private get baseURL(): string {
+    return this.opts.baseURL ?? DEFAULT_BASE_URL;
+  }
+
+  private buildHeaders(): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.opts.apiKey}`,
+      "x-command-code-version": CC_VERSION,
+      "x-cli-environment": "production",
+      "x-project-slug": "opencode",
+      ...this.opts.headers,
+    };
+  }
+
+  async doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
+    const body = buildRequest(this.modelId, options);
+    const requestBody = JSON.stringify(body);
+
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(new Error("Request timed out after 5 minutes")),
+      300_000,
+    );
+    const userSignal = options.abortSignal;
+    if (userSignal) {
+      const onAbort = () => controller.abort(userSignal.reason);
+      userSignal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    try {
+      const response = await fetch(`${this.baseURL}/alpha/generate`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: requestBody,
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        let errorMessage = `Command Code API error: ${response.status} ${response.statusText}`;
+        try {
+          const parsed = JSON.parse(errorBody);
+          if (parsed.error?.message) errorMessage = parsed.error.message;
+          else if (parsed.message) errorMessage = parsed.message;
+        } catch {
+          // intentionally silent: error body is not JSON
+        }
+        throw new Error(`${errorMessage} [model=${this.modelId}]`);
+      }
+
+      if (!response.body) {
+        throw new Error(`Command Code API returned no body [model=${this.modelId}]`);
+      }
+
+      const responseHeaders: Record<string, string> = {};
+      response.headers.forEach((v, k) => {
+        responseHeaders[k] = v;
+      });
+
+      return {
+        stream: parseStreamEvents(response.body as ReadableStream<Uint8Array>),
+        request: { body: requestBody },
+        response: { headers: responseHeaders },
+      };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  async doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
+    const { stream } = await this.doStream(options);
+
+    const textParts: string[] = [];
+    const reasoningParts: string[] = [];
+    const content: LanguageModelV3Content[] = [];
+    let finishReason: LanguageModelV3FinishReason = { unified: "stop", raw: "stop" };
+    let usage: LanguageModelV3Usage = {
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+    };
+
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        switch (value.type) {
+          case "text-delta":
+            textParts.push(value.delta);
+            break;
+          case "reasoning-delta":
+            reasoningParts.push(value.delta);
+            break;
+          case "tool-call":
+            content.push({
+              type: "tool-call",
+              toolCallId: value.toolCallId,
+              toolName: value.toolName,
+              input: value.input,
+            });
+            break;
+          case "finish":
+            finishReason = value.finishReason;
+            usage = value.usage;
+            break;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      stream.cancel();
+    }
+
+    const text = textParts.join("");
+    if (text) content.unshift({ type: "text", text });
+
+    const reasoning = reasoningParts.join("");
+    if (reasoning) content.unshift({ type: "reasoning", text: reasoning });
+
+    return {
+      content,
+      finishReason,
+      usage,
+      warnings: [],
+    };
+  }
+}

package/src/startup.ts

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import type { ModelEntry } from "./catalog.js";
+
+export type { ModelEntry } from "./catalog.js";
+
+export type StartupSummary = {
+  catalogSource: "bundled" | "cache" | "opt-in-local" | "remote";
+  commandCodeVersion: string | null;
+  modelCount: number;
+  reasoningModelCount: number;
+  degraded: boolean;
+  degradedReason: string | null;
+};
+
+export function pluginStateDir(): string {
+  const override = process.env.COMMANDCODE_PROVIDER_STATE_DIR?.trim();
+  if (override) return override;
+  return join(homedir(), ".local/state/opencode/commandcode-provider");
+}
+
+export function readCatalogCache(dir = pluginStateDir()): ModelEntry[] | null {
+  const path = join(dir, "catalog-cache.json");
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+    if (!Array.isArray(parsed) || parsed.length === 0) return null;
+    return parsed as ModelEntry[];
+  } catch {
+    return null;
+  }
+}
+
+export function writeCatalogCache(dir: string, models: ModelEntry[]): void {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "catalog-cache.json"), JSON.stringify(models) + "\n", "utf-8");
+}
+
+export function writeStartupSummary(dir: string, summary: StartupSummary): void {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "startup.json"), JSON.stringify(summary) + "\n", "utf-8");
+}

package/src/stream.ts

@@ -0,0 +1,237 @@
+import type {
+  LanguageModelV3StreamPart,
+  LanguageModelV3Usage,
+  LanguageModelV3FinishReason,
+} from "@ai-sdk/provider";
+
+type RawEvent = Record<string, unknown> & { type: string };
+
+function mapFinishReason(raw: string): LanguageModelV3FinishReason["unified"] {
+  switch (raw) {
+    case "stop":
+    case "end_turn":
+      return "stop";
+    case "tool_calls":
+    case "tool-calls":
+      return "tool-calls";
+    case "length":
+    case "max_tokens":
+    case "max-tokens":
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "other";
+  }
+}
+
+function mapUsage(raw: Record<string, unknown>): LanguageModelV3Usage {
+  const inputDetails = (raw.inputTokenDetails ?? raw.input_token_details ?? {}) as Record<
+    string,
+    unknown
+  >;
+  const outputDetails = (raw.outputTokenDetails ?? raw.output_token_details ?? {}) as Record<
+    string,
+    unknown
+  >;
+  return {
+    inputTokens: {
+      total:
+        typeof raw.inputTokens === "number"
+          ? raw.inputTokens
+          : typeof raw.prompt_tokens === "number"
+            ? raw.prompt_tokens
+            : undefined,
+      noCache:
+        typeof inputDetails.noCacheTokens === "number" ? inputDetails.noCacheTokens : undefined,
+      cacheRead:
+        typeof inputDetails.cacheReadTokens === "number" ? inputDetails.cacheReadTokens : undefined,
+      cacheWrite:
+        typeof inputDetails.cacheWriteTokens === "number"
+          ? inputDetails.cacheWriteTokens
+          : undefined,
+    },
+    outputTokens: {
+      total:
+        typeof raw.outputTokens === "number"
+          ? raw.outputTokens
+          : typeof raw.completion_tokens === "number"
+            ? raw.completion_tokens
+            : undefined,
+      text: typeof outputDetails.textTokens === "number" ? outputDetails.textTokens : undefined,
+      reasoning:
+        typeof outputDetails.reasoningTokens === "number"
+          ? outputDetails.reasoningTokens
+          : undefined,
+    },
+  };
+}
+
+function toStreamPart(event: RawEvent): LanguageModelV3StreamPart | null {
+  switch (event.type) {
+    case "start":
+      return { type: "stream-start", warnings: [] };
+
+    case "text-start":
+      return { type: "text-start", id: event.id as string };
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: event.id as string,
+        delta: (event.text ?? event.delta ?? "") as string,
+      };
+    case "text-end":
+      return { type: "text-end", id: event.id as string };
+
+    case "reasoning-start":
+      return { type: "reasoning-start", id: event.id as string };
+    case "reasoning-delta":
+      return {
+        type: "reasoning-delta",
+        id: event.id as string,
+        delta: (event.text ?? event.delta ?? "") as string,
+      };
+    case "reasoning-end":
+      return { type: "reasoning-end", id: event.id as string };
+
+    case "tool-input-start":
+      return {
+        type: "tool-input-start",
+        id: event.id as string,
+        toolName: event.toolName as string,
+        dynamic: event.dynamic as boolean | undefined,
+      };
+    case "tool-input-delta":
+      return {
+        type: "tool-input-delta",
+        id: event.id as string,
+        delta: (event.delta ?? "") as string,
+      };
+    case "tool-input-end":
+      return { type: "tool-input-end", id: event.id as string };
+
+    case "tool-call": {
+      const input = event.input ?? event.args ?? event.arguments;
+      return {
+        type: "tool-call",
+        toolCallId: (event.toolCallId ?? event.id ?? "") as string,
+        toolName: event.toolName as string,
+        input: typeof input === "string" ? input : JSON.stringify(input ?? {}),
+      };
+    }
+
+    case "finish-step": {
+      const usage = event.usage ?? event.totalUsage ?? {};
+      const rawReason = (event.finishReason ?? event.rawFinishReason ?? "stop") as string;
+      return {
+        type: "finish",
+        finishReason: { unified: mapFinishReason(rawReason), raw: rawReason },
+        usage: mapUsage(
+          typeof usage === "object" && usage !== null ? (usage as Record<string, unknown>) : {},
+        ),
+      };
+    }
+
+    case "finish":
+      return null;
+
+    case "response-metadata":
+      return {
+        type: "response-metadata",
+        id: event.id as string | undefined,
+        modelId: event.modelId as string | undefined,
+      };
+
+    case "error":
+      return { type: "error", error: event.error ?? event.message ?? "Unknown error" };
+
+    default:
+      return null;
+  }
+}
+
+// Assumes line-delimited JSON over SSE: one JSON object per `data:` line.
+// Multi-line `data:` fields are not supported — the buffer splits on `\n`.
+export function parseStreamEvents(
+  body: ReadableStream<Uint8Array>,
+): ReadableStream<LanguageModelV3StreamPart> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  return new ReadableStream<LanguageModelV3StreamPart>({
+    async pull(controller) {
+      try {
+        while (true) {
+          const lines = buffer.split("\n");
+          // Strip trailing \r from Windows-style \r\n line endings
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line !== undefined && line.endsWith("\r")) lines[i] = line.slice(0, -1);
+          }
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":") || trimmed === "[DONE]") continue;
+
+            let jsonStr = trimmed;
+            if (jsonStr.startsWith("data: ")) jsonStr = jsonStr.slice(6);
+            if (jsonStr.startsWith("data:")) jsonStr = jsonStr.slice(5);
+            if (!jsonStr || jsonStr === "[DONE]") continue;
+
+            let parsed: RawEvent;
+            try {
+              parsed = JSON.parse(jsonStr);
+            } catch {
+              // intentionally silent: skip malformed SSE lines
+              continue;
+            }
+
+            if (typeof parsed !== "object" || parsed === null || typeof parsed.type !== "string")
+              continue;
+
+            const part = toStreamPart(parsed);
+            if (part) controller.enqueue(part);
+          }
+
+          const { done, value } = await reader.read();
+          if (done) {
+            if (buffer.trim()) {
+              const trimmed = buffer.trim();
+              if (trimmed && trimmed !== "[DONE]" && !trimmed.startsWith(":")) {
+                let jsonStr = trimmed;
+                if (jsonStr.startsWith("data: ")) jsonStr = jsonStr.slice(6);
+                if (jsonStr.startsWith("data:")) jsonStr = jsonStr.slice(5);
+                try {
+                  const parsed = JSON.parse(jsonStr);
+                  if (
+                    typeof parsed === "object" &&
+                    parsed !== null &&
+                    typeof parsed.type === "string"
+                  ) {
+                    const part = toStreamPart(parsed);
+                    if (part) controller.enqueue(part);
+                  }
+                } catch {
+                  // intentionally silent: skip malformed final buffer
+                }
+              }
+            }
+            controller.close();
+            return;
+          }
+
+          buffer += decoder.decode(value, { stream: true });
+        }
+      } catch (err) {
+        controller.enqueue({ type: "error", error: err });
+        controller.close();
+      }
+    },
+    cancel() {
+      reader.cancel();
+    },
+  });
+}