@herouucn/opencode-commandcode 0.1.0

package/src/convert.ts

@@ -0,0 +1,242 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import type {
+  LanguageModelV3FunctionTool,
+  LanguageModelV3Message,
+  LanguageModelV3TextPart,
+  LanguageModelV3ReasoningPart,
+  LanguageModelV3ToolCallPart,
+  LanguageModelV3ToolResultPart,
+  LanguageModelV3ToolResultOutput,
+} from "@ai-sdk/provider";
+
+type CCMessage =
+  | { role: "user"; content: string | unknown[] }
+  | { role: "assistant"; content: CCAssistantContent[] }
+  | { role: "tool"; content: CCToolResultContent[] };
+
+type CCAssistantContent =
+  | { type: "text"; text: string }
+  | { type: "reasoning"; text: string }
+  | { type: "tool-call"; toolCallId: string; toolName: string; input: unknown };
+
+type CCToolResultContent = {
+  type: "tool-result";
+  toolCallId: string;
+  toolName: string;
+  output: { type: "text"; value: string } | { type: "error-text"; value: string };
+};
+
+type CCTool = {
+  type: "function";
+  name: string;
+  description?: string;
+  input_schema: unknown;
+};
+
+interface CCRequestEnvelope {
+  config: {
+    workingDir: string;
+    date: string;
+    environment: string;
+    structure: unknown[];
+    isGitRepo: boolean;
+    currentBranch: string;
+    mainBranch: string;
+    gitStatus: string;
+    recentCommits: unknown[];
+  };
+  memory: string;
+  taste: string;
+  skills: null;
+  permissionMode: string;
+  params: {
+    model: string;
+    messages: CCMessage[];
+    tools: CCTool[];
+    system: string;
+    max_tokens: number;
+    stream: true;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+  };
+}
+
+function hasType(p: unknown, type: string): boolean {
+  return typeof p === "object" && p !== null && (p as { type?: string }).type === type;
+}
+
+function isTextPart(p: unknown): p is LanguageModelV3TextPart {
+  return hasType(p, "text");
+}
+
+function isReasoningPart(p: unknown): p is LanguageModelV3ReasoningPart {
+  return hasType(p, "reasoning");
+}
+
+function isToolCallPart(p: unknown): p is LanguageModelV3ToolCallPart {
+  return hasType(p, "tool-call");
+}
+
+function isToolResultPart(p: unknown): p is LanguageModelV3ToolResultPart {
+  return hasType(p, "tool-result");
+}
+
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const textParts = content.filter(isTextPart) as LanguageModelV3TextPart[];
+    const nonTextParts = content.filter((p) => !isTextPart(p));
+    if (nonTextParts.length > 0 && textParts.length === 0) {
+      console.warn(
+        `Command Code provider: dropped ${nonTextParts.length} non-text part(s) in user message`,
+      );
+    }
+    return textParts.map((p) => p.text).join("\n");
+  }
+  return "";
+}
+
+function convertToolResultOutput(
+  output: LanguageModelV3ToolResultOutput,
+): CCToolResultContent["output"] {
+  switch (output.type) {
+    case "text":
+      return { type: "text", value: output.value };
+    case "error-text":
+      return { type: "error-text", value: output.value };
+    case "json":
+      return { type: "text", value: JSON.stringify(output.value) };
+    case "execution-denied":
+      return { type: "error-text", value: output.reason ?? "Execution denied" };
+    case "error-json":
+      return { type: "error-text", value: JSON.stringify(output.value) };
+    case "content":
+      return {
+        type: "text",
+        value: output.value
+          .map((v: Record<string, unknown>) => ("text" in v ? v.text : JSON.stringify(v)))
+          .join("\n"),
+      };
+    default:
+      return { type: "text", value: JSON.stringify(output) };
+  }
+}
+
+function convertMessage(msg: LanguageModelV3Message): CCMessage | null {
+  switch (msg.role) {
+    case "user": {
+      const text = extractText(msg.content);
+      return { role: "user", content: text };
+    }
+    case "assistant": {
+      const parts: CCAssistantContent[] = [];
+      for (const part of msg.content) {
+        if (isTextPart(part)) {
+          parts.push({ type: "text", text: part.text });
+        } else if (isReasoningPart(part)) {
+          parts.push({ type: "reasoning", text: part.text });
+        } else if (isToolCallPart(part)) {
+          parts.push({
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: part.input,
+          });
+        }
+      }
+      return { role: "assistant", content: parts };
+    }
+    case "tool": {
+      const parts: CCToolResultContent[] = [];
+      for (const part of msg.content) {
+        if (isToolResultPart(part)) {
+          parts.push({
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            output: convertToolResultOutput(part.output),
+          });
+        }
+      }
+      return { role: "tool", content: parts };
+    }
+    default:
+      return null;
+  }
+}
+
+function convertTools(
+  tools:
+    | Array<
+        | LanguageModelV3FunctionTool
+        | {
+            type: "provider";
+            id: `${string}.${string}`;
+            name: string;
+            args: Record<string, unknown>;
+          }
+      >
+    | undefined,
+): CCTool[] {
+  if (!tools) return [];
+  return tools
+    .filter((t): t is LanguageModelV3FunctionTool => t.type === "function")
+    .map((t) => ({
+      type: "function" as const,
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema,
+    }));
+}
+
+export function buildRequest(
+  modelId: string,
+  options: LanguageModelV3CallOptions,
+): CCRequestEnvelope {
+  let systemPrompt = "";
+  const messages: CCMessage[] = [];
+
+  for (const msg of options.prompt) {
+    if (msg.role === "system") {
+      systemPrompt += (systemPrompt ? "\n\n" : "") + msg.content;
+      continue;
+    }
+    const converted = convertMessage(msg);
+    if (converted) messages.push(converted);
+  }
+
+  const params: CCRequestEnvelope["params"] = {
+    model: modelId,
+    messages,
+    tools: convertTools(options.tools),
+    system: systemPrompt,
+    max_tokens: options.maxOutputTokens ?? 16384,
+    stream: true,
+  };
+
+  if (options.temperature !== undefined) params.temperature = options.temperature;
+  if (options.topP !== undefined) params.top_p = options.topP;
+  if (options.topK !== undefined) params.top_k = options.topK;
+
+  return {
+    config: {
+      workingDir: process.cwd() ?? "/",
+      date: new Date().toISOString().split("T")[0] ?? "",
+      environment: `${process.platform}-${process.arch}`,
+      // Stub: opencode does not expose project structure context
+      structure: [],
+      isGitRepo: false,
+      currentBranch: "",
+      mainBranch: "",
+      gitStatus: "",
+      recentCommits: [],
+    },
+    memory: "",
+    // Stub: taste/memory/permissionMode are Command Code CLI features not exposed via provider API
+    taste: "",
+    skills: null,
+    permissionMode: "standard",
+    params,
+  };
+}

package/src/costs-docs.ts

@@ -0,0 +1,179 @@
+import type { ModelEntry } from "./catalog.js";
+
+export type DocCostRow = {
+  name: string;
+  id?: string;
+  input: number;
+  output: number;
+  cache_read?: number;
+  cache_write?: number;
+};
+
+export function parseMoneyCell(cell: string): number | undefined {
+  const trimmed = cell.trim();
+  if (!trimmed || trimmed === "—" || trimmed === "-") return undefined;
+  if (/^free$/i.test(trimmed)) return 0;
+  const amounts = [...trimmed.matchAll(/\$([0-9]+(?:\.[0-9]+)?)/g)].map((m) => Number(m[1]));
+  if (amounts.length === 0) return undefined;
+  return amounts[amounts.length - 1];
+}
+
+type CellRow = { cells: string[]; id?: string };
+
+function decodeEntities(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, " ");
+}
+
+function stripTags(html: string): string {
+  return decodeEntities(html.replace(/<[^>]+>/g, " "))
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function visibleCellText(innerHtml: string): string {
+  const trunc = innerHtml.match(/<span class="truncate[^"]*"[^>]*>([^<]*)<\/span>/i);
+  if (trunc?.[1]) return decodeEntities(trunc[1]).trim();
+  return stripTags(innerHtml);
+}
+
+function headerName(cell: string): string {
+  return cell.replace(/↕/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+function colIndex(headers: string[], name: string): number {
+  return headers.findIndex((h) => h === name || h.startsWith(`${name} `) || h.startsWith(name));
+}
+
+function pipeRows(markdown: string): CellRow[] {
+  const rows: CellRow[] = [];
+  for (const line of markdown.split("\n")) {
+    if (!line.includes("|")) continue;
+    const cells = line
+      .split("|")
+      .map((c) => c.trim())
+      .filter((c, i, arr) => !(i === 0 && c === "") && !(i === arr.length - 1 && c === ""));
+    if (cells.length) rows.push({ cells });
+  }
+  return rows;
+}
+
+function htmlTableRows(html: string): CellRow[] {
+  const rows: CellRow[] = [];
+  const tables = html.match(/<table[\s\S]*?<\/table>/gi) ?? [];
+  for (const table of tables) {
+    const trs = table.match(/<tr[\s\S]*?<\/tr>/gi) ?? [];
+    for (const tr of trs) {
+      const rawCells = [...tr.matchAll(/<t[dh]\b[\s\S]*?<\/t[dh]>/gi)].map((m) => m[0]);
+      if (rawCells.length === 0) continue;
+      const cells = rawCells.map((raw) => {
+        const inner = raw.replace(/^<t[dh]\b[^>]*>/i, "").replace(/<\/t[dh]>$/i, "");
+        return visibleCellText(inner);
+      });
+      const href = tr.match(/href="\/models\/([^"?#]+)"/i)?.[1];
+      rows.push({ cells, ...(href ? { id: href } : {}) });
+    }
+  }
+  return rows;
+}
+
+function rowsFromGroup(group: CellRow[]): DocCostRow[] {
+  if (group.length === 0) return [];
+
+  let modelI = 0;
+  let inputI = 2;
+  let outputI = 3;
+  let cacheReadI = 4;
+  let cacheWriteI = 5;
+  let start = 0;
+
+  const headerIdx = group.findIndex((r) => /^model\b/i.test(headerName(r.cells[0] ?? "")));
+  if (headerIdx >= 0) {
+    const headers = group[headerIdx]!.cells.map(headerName);
+    const foundInput = colIndex(headers, "input");
+    const foundOutput = colIndex(headers, "output");
+    if (foundInput >= 0 && foundOutput >= 0) {
+      const foundModel = colIndex(headers, "model");
+      if (foundModel >= 0) modelI = foundModel;
+      inputI = foundInput;
+      outputI = foundOutput;
+      cacheReadI = colIndex(headers, "cache read");
+      cacheWriteI = colIndex(headers, "cache write");
+      start = headerIdx + 1;
+    }
+  }
+
+  const rows: DocCostRow[] = [];
+  for (let i = start; i < group.length; i++) {
+    const { cells, id } = group[i]!;
+    if (cells.length < 2) continue;
+    const first = headerName(cells[0] ?? "");
+    if (first === "model" || (cells[0] ?? "").startsWith("---")) continue;
+    const input = parseMoneyCell(cells[inputI] ?? "");
+    const output = parseMoneyCell(cells[outputI] ?? "");
+    if (input === undefined || output === undefined) continue;
+    const name = (cells[modelI] ?? "").trim();
+    if (!name) continue;
+    const row: DocCostRow = { name, input, output };
+    if (id) row.id = id;
+    if (cacheReadI >= 0) {
+      const cacheRead = parseMoneyCell(cells[cacheReadI] ?? "");
+      if (cacheRead !== undefined) row.cache_read = cacheRead;
+    }
+    if (cacheWriteI >= 0) {
+      const cacheWrite = parseMoneyCell(cells[cacheWriteI] ?? "");
+      if (cacheWrite !== undefined) row.cache_write = cacheWrite;
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+
+export function parseModelsTable(markdown: string): DocCostRow[] {
+  return [...rowsFromGroup(pipeRows(markdown)), ...rowsFromGroup(htmlTableRows(markdown))];
+}
+
+export function applyDocCosts(
+  models: ModelEntry[],
+  rows: DocCostRow[],
+  cliIds: Set<string> = new Set(),
+  filledIds?: Set<string>,
+): number {
+  const byName = new Map(rows.map((r) => [r.name.toLowerCase(), r]));
+  const byId = new Map(rows.filter((r) => r.id).map((r) => [r.id!.toLowerCase(), r]));
+  let filled = 0;
+  for (const model of models) {
+    if (cliIds.has(model.id)) continue;
+    const row = byId.get(model.id.toLowerCase()) ?? byName.get(model.name.toLowerCase());
+    if (!row) continue;
+    model.cost = { input: row.input, output: row.output };
+    if (row.cache_read !== undefined) model.cost.cache_read = row.cache_read;
+    if (row.cache_write !== undefined) model.cost.cache_write = row.cache_write;
+    filledIds?.add(model.id);
+    filled++;
+  }
+  return filled;
+}
+
+export async function fetchOfficialModelsMarkdown(): Promise<string> {
+  const urls = [
+    "https://commandcode.ai/models",
+    "https://commandcode.ai/docs/resources/pricing-limits",
+  ];
+  for (const url of urls) {
+    try {
+      const resp = await fetch(url);
+      if (!resp.ok) continue;
+      const text = await resp.text();
+      if (parseModelsTable(text).length > 0) return text;
+    } catch {
+      // try next
+    }
+  }
+  return "";
+}

package/src/costs-models-dev.ts

@@ -0,0 +1,173 @@
+import type { ModelEntry } from "./catalog.js";
+
+export const MODELS_DEV_URL = "https://models.dev/api.json";
+export const FREE_COST = { input: 0, output: 0 } as const;
+export const TEXT_ONLY_MODALITIES = { input: ["text"], output: ["text"] } as const;
+
+export type ModelsDevRow = {
+  id: string;
+  name: string;
+  cost: { input: number; output: number; cache_read?: number; cache_write?: number };
+  attachment?: boolean;
+  modalities?: { input: string[]; output: string[] };
+};
+
+type ModelsDevModel = {
+  id?: string;
+  name?: string;
+  cost?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+  attachment?: boolean;
+  modalities?: { input?: string[]; output?: string[] };
+};
+
+type ModelsDevProvider = { models?: Record<string, ModelsDevModel> };
+
+function lastSegment(id: string): string {
+  const i = id.lastIndexOf("/");
+  return i >= 0 ? id.slice(i + 1) : id;
+}
+
+export function isFreeSku(model: { id: string; name: string }): boolean {
+  if (/-free$/i.test(model.id)) return true;
+  return /\bfree\b/i.test(`${model.id} ${model.name}`);
+}
+
+export function parseModelsDev(json: string): ModelsDevRow[] {
+  const data = JSON.parse(json) as Record<string, ModelsDevProvider>;
+  const rows: ModelsDevRow[] = [];
+  const seen = new Set<string>();
+  for (const provider of Object.keys(data).sort()) {
+    const models = data[provider]?.models ?? {};
+    for (const model of Object.values(models)) {
+      if (!model?.id || model.cost?.input === undefined || model.cost?.output === undefined)
+        continue;
+      const key = model.id.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const cost: ModelsDevRow["cost"] = { input: model.cost.input, output: model.cost.output };
+      if (model.cost.cache_read !== undefined) cost.cache_read = model.cost.cache_read;
+      if (model.cost.cache_write !== undefined) cost.cache_write = model.cost.cache_write;
+      const row: ModelsDevRow = { id: model.id, name: model.name ?? model.id, cost };
+      if (typeof model.attachment === "boolean") row.attachment = model.attachment;
+      const input = model.modalities?.input?.filter((x) => typeof x === "string");
+      const output = model.modalities?.output?.filter((x) => typeof x === "string");
+      if (input?.length || output?.length) {
+        row.modalities = {
+          input: input?.length ? input : [...TEXT_ONLY_MODALITIES.input],
+          output: output?.length ? output : [...TEXT_ONLY_MODALITIES.output],
+        };
+      }
+      rows.push(row);
+    }
+  }
+  return rows;
+}
+
+function indexRows(rows: ModelsDevRow[]) {
+  const byId = new Map<string, ModelsDevRow>();
+  const bySegment = new Map<string, ModelsDevRow>();
+  const byName = new Map<string, ModelsDevRow>();
+  for (const row of rows) {
+    const idKey = row.id.toLowerCase();
+    if (!byId.has(idKey)) byId.set(idKey, row);
+    const segment = lastSegment(row.id).toLowerCase();
+    if (!bySegment.has(segment)) bySegment.set(segment, row);
+    const nameKey = row.name.toLowerCase();
+    if (!byName.has(nameKey)) byName.set(nameKey, row);
+  }
+  return { byId, bySegment, byName };
+}
+
+function findRow(model: ModelEntry, index: ReturnType<typeof indexRows>): ModelsDevRow | undefined {
+  return (
+    index.byId.get(model.id.toLowerCase()) ??
+    index.bySegment.get(lastSegment(model.id).toLowerCase()) ??
+    index.byName.get(model.name.toLowerCase())
+  );
+}
+
+export function applyFreeCosts(
+  models: ModelEntry[],
+  skipIds: Set<string>,
+  filledIds?: Set<string>,
+): number {
+  let filled = 0;
+  for (const model of models) {
+    if (skipIds.has(model.id) || !isFreeSku(model)) continue;
+    model.cost = { ...FREE_COST };
+    filledIds?.add(model.id);
+    filled++;
+  }
+  return filled;
+}
+
+function textOnly(): { input: string[]; output: string[] } {
+  return { input: [...TEXT_ONLY_MODALITIES.input], output: [...TEXT_ONLY_MODALITIES.output] };
+}
+
+export function applyModelsDevModalities(models: ModelEntry[], rows: ModelsDevRow[]): number {
+  const index = indexRows(rows);
+  let filled = 0;
+  for (const model of models) {
+    const row = findRow(model, index);
+    const current = model.modalities;
+    if (current && model.attachment !== undefined) {
+      const extra = row?.modalities?.input?.filter((x) => !current.input.includes(x)) ?? [];
+      if (extra.length > 0) {
+        model.modalities = {
+          input: [...current.input, ...extra],
+          output: [...current.output],
+        };
+        if (model.modalities.input.includes("image")) model.attachment = true;
+        filled++;
+      }
+      continue;
+    }
+    if (row && (row.modalities || row.attachment !== undefined)) {
+      const modalities = row.modalities
+        ? { input: [...row.modalities.input], output: [...row.modalities.output] }
+        : textOnly();
+      model.modalities = modalities;
+      model.attachment = row.attachment ?? modalities.input.includes("image");
+      filled++;
+    } else {
+      model.attachment = false;
+      model.modalities = textOnly();
+    }
+  }
+  return filled;
+}
+
+export function applyModelsDevCosts(
+  models: ModelEntry[],
+  rows: ModelsDevRow[],
+  skipIds: Set<string>,
+  filledIds?: Set<string>,
+): number {
+  const index = indexRows(rows);
+  let filled = 0;
+  for (const model of models) {
+    if (skipIds.has(model.id) || isFreeSku(model)) continue;
+    const row = findRow(model, index);
+    if (!row) continue;
+    model.cost = { input: row.cost.input, output: row.cost.output };
+    if (row.cost.cache_read !== undefined) model.cost.cache_read = row.cost.cache_read;
+    if (row.cost.cache_write !== undefined) model.cost.cache_write = row.cost.cache_write;
+    filledIds?.add(model.id);
+    filled++;
+  }
+  return filled;
+}
+
+export async function fetchModelsDevJson(): Promise<string> {
+  const resp = await fetch(MODELS_DEV_URL, {
+    headers: {
+      // ponytail: models.dev returns 403 without a browser-like UA; upgrade if they add a real API token
+      "User-Agent":
+        "Mozilla/5.0 (compatible; opencode-commandcode/0.5; +https://github.com/BrainerVirus/opencode-commandcode)",
+      Accept: "application/json",
+    },
+  });
+  if (!resp.ok) throw new Error(`models.dev returned ${resp.status}`);
+  return resp.text();
+}