@wrongstack/cli 1.0.19 → 1.0.26

package/dist/modeldiag-36VODVIH.js

@@ -0,0 +1,828 @@
+import {
+  applyProviderOAuthRefresh
+} from "./chunk-LDCGZJTC.js";
+import {
+  discoverAndMergeProviders
+} from "./chunk-D5GB5MHA.js";
+import {
+  checkMark,
+  costLabel,
+  createProviderForId,
+  findProfile,
+  fmtMs,
+  fmtPrice,
+  fmtTokens,
+  rankModels,
+  roleCat,
+  runModeldiagEval,
+  scoreBar,
+  speedLabel
+} from "./chunk-BBHWW6LR.js";
+import {
+  resolveRawProviderConnection
+} from "./chunk-S4FFHDJG.js";
+import {
+  mutateConfigProviders
+} from "./chunk-LUMETJFO.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
+
+// src/subcommands/handlers/modeldiag.ts
+import * as fs from "node:fs/promises";
+import { color as color3 } from "@wrongstack/core/utils";
+
+// src/subcommands/handlers/modeldiag-bench.ts
+import { color, toErrorMessage } from "@wrongstack/core/utils";
+async function runModeldiagBench(args, deps, providers, config, hasKey) {
+  const writeLine = (line = "") => {
+    deps.renderer.write(`${line}
+`);
+  };
+  const benchArgs = args.slice(1);
+  if (benchArgs.length < 2) {
+    writeLine(
+      `${color.amber("Usage:")} wstack modeldiag bench <role> "<test prompt>" [--providers=p1,p2]`
+    );
+    writeLine();
+    writeLine(
+      color.dim(
+        'Example: wstack modeldiag bench verify "Write a function that checks if a string is a palindrome"'
+      )
+    );
+    writeLine(
+      color.dim(
+        "Tests the top 5 candidate models for the role with your prompt and reports results."
+      )
+    );
+    writeLine(color.dim("Add --providers=anthropic,google to test across multiple providers."));
+    return 0;
+  }
+  const providersEqIdx = benchArgs.findIndex((a) => a.startsWith("--providers="));
+  let providerFilter;
+  if (providersEqIdx >= 0) {
+    const rawFilter = benchArgs[providersEqIdx]?.replace("--providers=", "").split(",");
+    if (rawFilter) {
+      providerFilter = rawFilter.map((s) => s.trim()).filter(Boolean);
+      benchArgs.splice(providersEqIdx, 1);
+    }
+  } else {
+    const rawFilter = deps.flags?.["providers"] ?? deps.flags?.["provider"];
+    if (typeof rawFilter === "string") {
+      providerFilter = rawFilter.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  const benchRole = benchArgs[0];
+  if (!benchRole) {
+    writeLine(
+      `${color.amber("No benchmark role specified")}. Usage: wstack diag bench <role> [prompt]`
+    );
+    return 1;
+  }
+  const benchPrompt = benchArgs.slice(1).join(" ");
+  const cat = roleCat(benchRole);
+  const candidates = rankModels(providers, hasKey, cat, 5);
+  if (candidates.length === 0) {
+    writeLine(
+      `${color.amber("No candidate models found")} for role "${benchRole}" (category: ${cat}).`
+    );
+    return 0;
+  }
+  let targetCandidates;
+  if (providerFilter && providerFilter.length > 0) {
+    targetCandidates = candidates.filter((c) => providerFilter.includes(c.provider));
+    if (targetCandidates.length === 0) {
+      writeLine(
+        `${color.amber("No candidates match the specified providers")}: ${providerFilter.join(", ")}`
+      );
+      writeLine(
+        `Candidate providers: ${[...new Set(candidates.map((c) => c.provider))].join(", ")}`
+      );
+      return 0;
+    }
+  } else {
+    targetCandidates = candidates;
+  }
+  writeLine(
+    `${color.bold("Model Benchmark")} \u2014 ${color.amber(benchRole)} ${color.dim(`(category: ${cat})`)}`
+  );
+  writeLine(
+    `${color.dim("Prompt:")} "${benchPrompt.slice(0, 120)}${benchPrompt.length > 120 ? "\u2026" : ""}"`
+  );
+  writeLine();
+  writeLine(
+    `  ${color.dim("#  model".padEnd(52))} ${color.dim("score".padEnd(12))} ${color.dim("latency".padEnd(10))} ${color.dim("tokens".padEnd(14))} ${color.dim("first line")}`
+  );
+  writeLine(`  ${color.dim("\u2500".repeat(108))}`);
+  const providerInstances = /* @__PURE__ */ new Map();
+  for (const pid of [...new Set(targetCandidates.map((c) => c.provider))]) {
+    const prov = createProviderForId(pid, config);
+    if (prov) providerInstances.set(pid, prov);
+  }
+  let idx = 0;
+  for (const c of targetCandidates.slice(0, 20)) {
+    idx++;
+    const label = `${idx}`.padStart(2);
+    const modelKey = `${c.provider}/${c.model}`;
+    const prov = providerInstances.get(c.provider);
+    if (!prov) {
+      writeLine(
+        `  ${label} ${color.red(modelKey.padEnd(50))} ${scoreBar(c.score, 110).slice(0, 11)}  ${color.red("NO PROVIDER")}`
+      );
+      continue;
+    }
+    try {
+      const start = Date.now();
+      const resp = await prov.complete(
+        {
+          model: c.model,
+          messages: [{ role: "user", content: [{ type: "text", text: benchPrompt }] }],
+          maxTokens: 256
+        },
+        { signal: AbortSignal.timeout(3e4) }
+      );
+      const latency = Date.now() - start;
+      const firstText = resp.content[0] && "text" in resp.content[0] ? resp.content[0].text : "";
+      const firstLineClean = firstText.replace(/\n/g, " ").slice(0, 80) || color.dim("(empty)");
+      const provColor = c.provider === config.provider ? color.green : color.cyan;
+      const usage = resp.usage;
+      writeLine(
+        `  ${label} ${provColor(modelKey.padEnd(50))} ${scoreBar(c.score, 110).slice(0, 11)}  ${color.amber(fmtMs(latency).padEnd(8))} ${color.dim(`in${usage?.input ?? "?"}/out${usage?.output ?? "?"}`.padEnd(12))} ${firstLineClean}`
+      );
+    } catch (err) {
+      const errMsg = toErrorMessage(err);
+      writeLine(
+        `  ${label} ${color.red(modelKey.padEnd(50))} ${scoreBar(c.score, 110).slice(0, 11)}  ${color.red("FAILED")}    ${color.dim(errMsg.slice(0, 40))}`
+      );
+    }
+  }
+  const testedProviders = [...new Set(targetCandidates.map((c) => c.provider))];
+  writeLine();
+  writeLine(
+    color.dim(
+      `Tested ${idx} model(s) across ${testedProviders.length} provider(s): ${testedProviders.join(", ")}.`
+    )
+  );
+  writeLine(color.dim("Pin the best: wstack setmodel set <role> <provider>/<model>"));
+  return 0;
+}
+
+// src/subcommands/handlers/modeldiag-test.ts
+import { color as color2, toErrorMessage as toErrorMessage3 } from "@wrongstack/core/utils";
+import {
+  buildProviderFactoriesFromRegistry,
+  makeProviderFromConfig,
+  setOAuthTokenPersister
+} from "@wrongstack/providers";
+
+// src/subcommands/handlers/model-smoke-test.ts
+import { ProviderError } from "@wrongstack/core/types";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+var DEFAULT_TIMEOUT_MS = 45e3;
+var DEFAULT_MAX_TOKENS = 32;
+function csv(value) {
+  if (typeof value !== "string") return void 0;
+  const values = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return values.length > 0 ? values : void 0;
+}
+function positiveInteger(value, fallback, label) {
+  if (value === void 0) return fallback;
+  const parsed = typeof value === "string" ? Number(value) : Number.NaN;
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+  return parsed;
+}
+function parseModelSmokeOptions(args, flags = {}) {
+  const local = /* @__PURE__ */ new Map();
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg?.startsWith("--")) continue;
+    const eq = arg.indexOf("=");
+    if (eq >= 0) {
+      local.set(arg.slice(2, eq), arg.slice(eq + 1));
+      continue;
+    }
+    const name = arg.slice(2);
+    const next = args[i + 1];
+    if (next && !next.startsWith("--")) {
+      local.set(name, next);
+      i++;
+    } else {
+      local.set(name, true);
+    }
+  }
+  const get = (name) => local.get(name) ?? flags[name];
+  const providerFilter = csv(get("providers") ?? get("provider"));
+  const modelFilter = csv(get("models") ?? get("model"));
+  return {
+    allModels: get("all-models") === true || get("all-models") === "true",
+    planOnly: get("plan") === true || get("plan") === "true",
+    json: get("json") === true || get("json") === "true",
+    timeoutMs: positiveInteger(get("timeout"), DEFAULT_TIMEOUT_MS, "--timeout"),
+    maxTokens: positiveInteger(get("max-tokens"), DEFAULT_MAX_TOKENS, "--max-tokens"),
+    ...providerFilter ? { providerFilter } : {},
+    ...modelFilter ? { modelFilter } : {}
+  };
+}
+function pushUnique(target, values) {
+  const seen = new Set(target);
+  for (const value of values) {
+    const normalized = value?.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    target.push(normalized);
+  }
+}
+async function catalogModelsFor(providerId, providerConfig, registry) {
+  const direct = await registry.getProvider(providerId).catch(() => void 0);
+  const inherited = direct ?? (providerConfig?.type && providerConfig.type !== providerId ? await registry.getProvider(providerConfig.type).catch(() => void 0) : void 0);
+  return inherited?.models ?? [];
+}
+function supportsTextCompletion(model) {
+  const outputs = model?.modalities?.output;
+  return !outputs?.length || outputs.includes("text");
+}
+async function buildModelSmokeTargets(config, registry, options) {
+  const providerIds = Object.keys(config.providers ?? {});
+  if (config.provider && !providerIds.includes(config.provider)) providerIds.push(config.provider);
+  const providerFilter = options.providerFilter ? new Set(options.providerFilter.map((id) => id.toLowerCase())) : void 0;
+  const modelFilter = options.modelFilter ? new Set(options.modelFilter) : void 0;
+  const targets = [];
+  for (const providerId of providerIds) {
+    if (providerFilter && !providerFilter.has(providerId.toLowerCase())) continue;
+    const saved = config.providers?.[providerId];
+    const catalogModels = await catalogModelsFor(providerId, saved, registry);
+    const catalogById = new Map(catalogModels.map((model) => [model.id, model]));
+    const textCatalogModels = catalogModels.filter(supportsTextCompletion);
+    const candidates = [];
+    if (options.allModels) {
+      pushUnique(candidates, saved?.models ?? []);
+      pushUnique(candidates, Object.keys(saved?.customModels ?? {}));
+      pushUnique(
+        candidates,
+        textCatalogModels.map((model) => model.id)
+      );
+      if (providerId === config.provider) pushUnique(candidates, [config.model]);
+      pushUnique(candidates, [saved?.model]);
+    } else {
+      const representative = (providerId === config.provider ? config.model : void 0) ?? saved?.model ?? saved?.models?.find(Boolean) ?? Object.keys(saved?.customModels ?? {})[0] ?? await registry.suggestModel(providerId).catch(() => void 0) ?? textCatalogModels[0]?.id;
+      pushUnique(candidates, [representative]);
+    }
+    for (const modelId of candidates) {
+      if (modelFilter && !modelFilter.has(modelId)) continue;
+      if (!supportsTextCompletion(catalogById.get(modelId))) continue;
+      targets.push({ providerId, modelId });
+    }
+  }
+  return targets;
+}
+function classifyFailure(err) {
+  if (err instanceof ProviderError || ProviderError.isProviderError(err)) {
+    const providerError = err;
+    return {
+      error: providerError.describe(),
+      errorKind: providerError.kind,
+      httpStatus: providerError.status
+    };
+  }
+  const isTimeout = err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError") || /timed?\s*out/i.test(toErrorMessage2(err));
+  return {
+    error: toErrorMessage2(err),
+    errorKind: isTimeout ? "timeout" : "unknown"
+  };
+}
+async function runModelSmokeTests(params) {
+  const results = [];
+  let providerId;
+  let provider;
+  let providerError;
+  for (let index = 0; index < params.targets.length; index++) {
+    const target = params.targets[index];
+    params.onTargetStart?.(target, index, params.targets.length);
+    const started = Date.now();
+    if (target.providerId !== providerId) {
+      providerId = target.providerId;
+      provider = void 0;
+      providerError = void 0;
+      try {
+        provider = await params.createProvider(target.providerId);
+      } catch (err) {
+        providerError = err;
+      }
+    }
+    if (!provider) {
+      const failure = classifyFailure(providerError ?? new Error("Provider could not be created."));
+      const result = {
+        providerId: target.providerId,
+        modelId: target.modelId,
+        status: "failed",
+        latencyMs: Date.now() - started,
+        ...failure
+      };
+      results.push(result);
+      params.onTargetComplete?.(result, index, params.targets.length);
+      continue;
+    }
+    try {
+      const response = await provider.complete(
+        {
+          model: target.modelId,
+          messages: [
+            {
+              role: "user",
+              content: [{ type: "text", text: "Reply with exactly: OK" }]
+            }
+          ],
+          maxTokens: params.options.maxTokens
+        },
+        { signal: AbortSignal.timeout(params.options.timeoutMs) }
+      );
+      const result = {
+        providerId: target.providerId,
+        modelId: target.modelId,
+        status: "passed",
+        latencyMs: Date.now() - started,
+        stopReason: response.stopReason,
+        usage: response.usage
+      };
+      results.push(result);
+      params.onTargetComplete?.(result, index, params.targets.length);
+    } catch (err) {
+      const result = {
+        providerId: target.providerId,
+        modelId: target.modelId,
+        status: "failed",
+        latencyMs: Date.now() - started,
+        ...classifyFailure(err)
+      };
+      results.push(result);
+      params.onTargetComplete?.(result, index, params.targets.length);
+    }
+  }
+  return results;
+}
+
+// src/subcommands/handlers/modeldiag-test.ts
+async function createModelDiagSmokeProvider(params) {
+  const { providerId, config, modelsRegistry, providerFactories } = params;
+  const saved = config.providers?.[providerId];
+  const connection = resolveRawProviderConnection(config, providerId);
+  const factoryType = saved?.type ?? providerId;
+  const resolved = await modelsRegistry.getProvider(providerId).catch(() => void 0) ?? (factoryType !== providerId ? await modelsRegistry.getProvider(factoryType).catch(() => void 0) : void 0);
+  const providerConfig = {
+    ...saved,
+    ...connection.apiKey ? { apiKey: connection.apiKey } : {},
+    // Keep the user-visible alias on the factory input. The selected factory
+    // already captures the canonical models.dev provider and its per-model
+    // wire metadata.
+    type: providerId,
+    ...saved?.family ?? resolved?.family ? { family: saved?.family ?? resolved?.family } : {},
+    ...connection.baseUrl ?? resolved?.apiBase ? { baseUrl: connection.baseUrl ?? resolved?.apiBase } : {},
+    ...saved?.envVars ?? resolved?.envVars ? { envVars: saved?.envVars ?? resolved?.envVars } : {}
+  };
+  const factory = providerFactories.get(factoryType);
+  return factory ? factory.create(providerConfig) : makeProviderFromConfig(providerId, { ...providerConfig, type: factoryType });
+}
+async function runModeldiagTest(args, deps, config) {
+  const writeLine = (line = "") => {
+    deps.renderer.write(`${line}
+`);
+  };
+  if (args.slice(1).includes("--help") || deps.flags?.["help"] === true) {
+    writeLine(`${color2.bold("Usage:")} wstack modeldiag test [options]`);
+    writeLine();
+    writeLine("  (no flags)              Probe one representative model per configured provider");
+    writeLine("  --all-models             Probe every catalog-visible model sequentially");
+    writeLine("  --plan                   Show targets without making model calls");
+    writeLine("  --provider=<id,...>      Restrict provider ids");
+    writeLine("  --model=<id,...>         Restrict model ids");
+    writeLine("  --timeout=<ms>           Per-model timeout (default 45000)");
+    writeLine("  --max-tokens=<n>         Output cap for the tiny probe (default 32)");
+    writeLine("  --json                   Emit machine-readable output");
+    writeLine("  --yes                    Confirm a run larger than 50 requests");
+    return 0;
+  }
+  let smokeOptions;
+  try {
+    smokeOptions = parseModelSmokeOptions(args.slice(1), deps.flags);
+  } catch (err) {
+    writeLine(`${color2.red("Invalid smoke-test options:")} ${toErrorMessage3(err)}`);
+    return 2;
+  }
+  if ("mergeOverlay" in deps.modelsRegistry) {
+    await discoverAndMergeProviders({
+      config,
+      registry: deps.modelsRegistry,
+      cacheDir: deps.paths.cacheDir
+    });
+  }
+  const targets = await buildModelSmokeTargets(
+    config,
+    deps.modelsRegistry,
+    smokeOptions
+  );
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    byProvider.set(target.providerId, (byProvider.get(target.providerId) ?? 0) + 1);
+  }
+  if (smokeOptions.planOnly) {
+    const plan = {
+      mode: smokeOptions.allModels ? "all-models" : "representative",
+      targetCount: targets.length,
+      providers: Object.fromEntries(byProvider),
+      targets
+    };
+    if (smokeOptions.json) {
+      writeLine(JSON.stringify(plan, null, 2));
+    } else {
+      writeLine(`${color2.bold("Provider/Model Smoke Test Plan")}`);
+      writeLine();
+      for (const [providerId, count] of byProvider) {
+        writeLine(`  ${color2.cyan(providerId.padEnd(24))} ${count} model(s)`);
+      }
+      writeLine();
+      writeLine(
+        color2.dim(`${targets.length} request(s) would run sequentially. Remove --plan to execute.`)
+      );
+    }
+    return targets.length > 0 ? 0 : 2;
+  }
+  if (targets.length === 0) {
+    const message = "No provider/model targets matched. Check the active profile or remove filters.";
+    if (smokeOptions.json) {
+      writeLine(JSON.stringify({ results: [], summary: { passed: 0, failed: 0 }, error: message }));
+    } else {
+      writeLine(color2.amber(message));
+    }
+    return 2;
+  }
+  const confirmed = deps.flags?.["yes"] === true || deps.flags?.["yes"] === "true" || args.slice(1).includes("--yes");
+  if (targets.length > 50 && !confirmed) {
+    const message = `${targets.length} live requests are planned. Review with --plan, then add --yes to run them.`;
+    if (smokeOptions.json) {
+      writeLine(JSON.stringify({ error: message, targetCount: targets.length }));
+    } else {
+      writeLine(color2.amber(message));
+    }
+    return 2;
+  }
+  if (!smokeOptions.json) {
+    writeLine(`${color2.bold("Live Provider/Model Smoke Test")}`);
+    writeLine(
+      color2.dim(
+        `${targets.length} request(s), sequential, ${smokeOptions.timeoutMs}ms timeout, max ${smokeOptions.maxTokens} output tokens.`
+      )
+    );
+    writeLine();
+  }
+  const resultLines = (result, index, total) => {
+    if (smokeOptions.json) return;
+    const label = `[${String(index + 1).padStart(String(total).length)}/${total}]`;
+    const target = `${result.providerId}/${result.modelId}`;
+    if (result.status === "passed") {
+      writeLine(
+        `  ${color2.green("\u2713")} ${color2.dim(label)} ${color2.cyan(target)} ${color2.dim(
+          `${fmtMs(result.latencyMs)} \xB7 in${result.usage.input}/out${result.usage.output} \xB7 ${result.stopReason}`
+        )}`
+      );
+    } else {
+      const status = result.httpStatus ? `HTTP ${result.httpStatus} \xB7 ` : "";
+      writeLine(
+        `  ${color2.red("\u2717")} ${color2.dim(label)} ${color2.red(target)} ${color2.dim(
+          `${fmtMs(result.latencyMs)} \xB7 ${status}${result.errorKind}`
+        )}`
+      );
+      writeLine(`      ${color2.red(result.error.slice(0, 240))}`);
+    }
+  };
+  let oauthWriteChain = Promise.resolve();
+  let oauthWriteScheduled = false;
+  const profilePath = activeProfileConfigPath(deps.paths, config);
+  setOAuthTokenPersister((providerId, credentials, source) => {
+    oauthWriteScheduled = true;
+    oauthWriteChain = oauthWriteChain.then(
+      () => mutateConfigProviders(profilePath, deps.vault, (all) => {
+        const providerConfig = all[providerId];
+        if (!providerConfig) return;
+        applyProviderOAuthRefresh(providerConfig, credentials, source);
+      })
+    );
+  });
+  let results;
+  try {
+    const providerFactories = new Map(
+      (await buildProviderFactoriesFromRegistry({ registry: deps.modelsRegistry })).map(
+        (factory) => [factory.type, factory]
+      )
+    );
+    results = await runModelSmokeTests({
+      targets,
+      options: smokeOptions,
+      createProvider: (providerId) => createModelDiagSmokeProvider({
+        providerId,
+        config,
+        modelsRegistry: deps.modelsRegistry,
+        providerFactories
+      }),
+      onTargetComplete: resultLines
+    });
+  } finally {
+    setOAuthTokenPersister(void 0);
+  }
+  let oauthPersistenceError;
+  if (oauthWriteScheduled) {
+    try {
+      await oauthWriteChain;
+    } catch (err) {
+      oauthPersistenceError = toErrorMessage3(err);
+    }
+  }
+  const passed = results.filter((result) => result.status === "passed").length;
+  const failed = results.length - passed;
+  const summary = { passed, failed, total: results.length };
+  if (smokeOptions.json) {
+    writeLine(
+      JSON.stringify(
+        {
+          results,
+          summary,
+          ...oauthPersistenceError ? {
+            warning: `OAuth token refresh worked in-memory but could not be saved: ${oauthPersistenceError}`
+          } : {}
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    writeLine();
+    writeLine(
+      `${color2.bold("Summary:")} ${color2.green(`${passed} passed`)} \xB7 ${failed > 0 ? color2.red(`${failed} failed`) : color2.dim("0 failed")}`
+    );
+    if (!smokeOptions.allModels) {
+      writeLine(color2.dim("Use --all-models to test every catalog-visible model sequentially."));
+    }
+    if (oauthPersistenceError) {
+      writeLine(
+        color2.amber(
+          `OAuth token refresh worked in-memory but could not be saved: ${oauthPersistenceError}`
+        )
+      );
+    }
+  }
+  return failed === 0 ? 0 : 1;
+}
+
+// src/subcommands/handlers/modeldiag.ts
+async function readProviders(cachePath) {
+  if (!cachePath) {
+    return { ok: false, message: `${color3.red("Models cache not available")}.`, hard: true };
+  }
+  try {
+    const raw = await fs.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const payload = parsed.payload ?? parsed;
+    return {
+      ok: true,
+      providers: Object.entries(payload).map(([id, p]) => ({
+        id: p.id ?? id,
+        name: p.name ?? id,
+        family: p.npm ?? id,
+        models: Object.values(p.models ?? {}).map(
+          (m) => ({
+            id: m.id,
+            name: m.name,
+            capabilities: {
+              contextWindow: m.limit?.context,
+              maxOutputTokens: m.limit?.output
+            },
+            pricing: m.cost
+          })
+        )
+      }))
+    };
+  } catch {
+    return {
+      ok: false,
+      message: `${color3.amber("Models cache not available")}. Run wstack sync-models.`,
+      hard: false
+    };
+  }
+}
+function checkHasKey(pid, config) {
+  if (pid === config.provider && config.provider) return true;
+  const pc = config.providers?.[pid];
+  if (!pc) return false;
+  if (typeof pc.apiKey === "string" && pc.apiKey.length > 0) return true;
+  if (Array.isArray(pc.apiKeys) && pc.apiKeys.some((k) => k?.apiKey)) return true;
+  return false;
+}
+var modeldiagCmd = async (args, deps) => {
+  const sub = args[0]?.toLowerCase() || "full";
+  const cacheResult = await readProviders(deps.paths.modelsCache);
+  if (!cacheResult.ok) {
+    deps.renderer.write(`${cacheResult.message}
+`);
+    return cacheResult.hard ? 1 : 0;
+  }
+  const providers = cacheResult.providers;
+  const config = deps.config;
+  const modelMatrix = config.modelMatrix ?? {};
+  function hasKey(pid) {
+    return checkHasKey(pid, config);
+  }
+  function writeLine(line = "") {
+    deps.renderer.write(`${line}
+`);
+  }
+  if (sub === "keys") {
+    writeLine(`${color3.bold("API Key Status")}`);
+    writeLine();
+    for (const prov of providers) {
+      const k = hasKey(prov.id);
+      writeLine(`  ${checkMark(k)} ${color3.bold(prov.id.padEnd(18))} ${color3.dim(prov.name)}`);
+    }
+    writeLine();
+    writeLine(`${color3.dim(`Leader: ${config.provider}/${config.model}`)}`);
+    return 0;
+  }
+  if (sub === "caps") {
+    writeLine(`${color3.bold("Model Capabilities")} ${color3.dim("\u2014 matched to known profiles")}`);
+    writeLine();
+    for (const prov of providers) {
+      if (!hasKey(prov.id)) continue;
+      writeLine(`  ${color3.bold(prov.id)} ${color3.dim(`(${prov.name})`)}`);
+      const tiers = {
+        premium: [],
+        standard: [],
+        budget: [],
+        unknown: []
+      };
+      for (const m of prov.models ?? []) {
+        const profile = findProfile(prov.id, m.id);
+        tiers[profile?.costTier ?? "unknown"]?.push(m);
+      }
+      for (const tier of ["premium", "standard", "budget", "unknown"]) {
+        const tierModels = tiers[tier];
+        if (tierModels.length === 0) continue;
+        const label = tier === "unknown" ? color3.dim("unmatched") : `${costLabel(tier)} ${tier}`;
+        writeLine(`    ${label}`);
+        for (const m of tierModels) {
+          const cap = m.capabilities;
+          const ctx = cap?.contextWindow ?? 0;
+          const maxOut = cap?.maxOutputTokens ?? 0;
+          const profile = findProfile(prov.id, m.id);
+          const family = profile ? `${speedLabel(profile.speedTier)} ${color3.green(profile.family)}` : color3.dim("no profile match");
+          const pricing = m.pricing ? `${color3.dim("in")}${fmtPrice(m.pricing.input)} ${color3.dim("out")}${fmtPrice(m.pricing.output)}` : color3.dim("pricing ?");
+          writeLine(
+            `      ${color3.cyan(m.id.padEnd(34))}${ctx > 0 ? `ctx ${fmtTokens(ctx).padEnd(6)}` : color3.dim("ctx ?  ")}${maxOut > 0 ? `out ${fmtTokens(maxOut).padEnd(6)}` : "        "}${family}   ${pricing}`
+          );
+        }
+      }
+      writeLine();
+    }
+    writeLine(
+      color3.dim(
+        "Prices in USD per 1M tokens (input/output). ctx = context window, out = max output."
+      )
+    );
+    return 0;
+  }
+  async function renderSuggest() {
+    writeLine();
+    writeLine(
+      `${color3.bold("Agent \u2192 Model Suggestions")} ${color3.amber("(heuristic \u2014 untested)")}`
+    );
+    writeLine(
+      color3.dim(
+        'These are profile-based best guesses. Test them with wstack modeldiag bench <role> "<prompt>".'
+      )
+    );
+    writeLine();
+    const keyedProviders = providers.filter((p) => hasKey(p.id));
+    if (keyedProviders.length === 0) {
+      writeLine(
+        `  ${color3.amber("No providers have API keys configured. Add keys with wstack auth.")}`
+      );
+    } else {
+      const roles = [
+        "security-scanner",
+        "bug-hunter",
+        "planner",
+        "architect",
+        "refactor-planner",
+        "verifier",
+        "test",
+        "document",
+        "reviewer",
+        "code-reviewer",
+        "executor",
+        "debugger"
+      ];
+      for (const role of roles) {
+        if (modelMatrix[role]) {
+          const entry = modelMatrix[role];
+          const p = entry.provider ?? config.provider;
+          writeLine(
+            `  ${color3.dim(role.padEnd(20))} \u2192 ${color3.cyan(`${p}/${entry.model}`)}  ${color3.dim("(user-configured)")}`
+          );
+          continue;
+        }
+        const cat = roleCat(role);
+        const ranked = rankModels(providers, hasKey, cat, 3);
+        if (ranked.length === 0) {
+          writeLine(`  ${color3.dim(role.padEnd(20))} \u2192 ${color3.dim("no candidates")}`);
+          continue;
+        }
+        const best = ranked[0];
+        const family = best.profile ? ` ${color3.dim(`(${best.profile.family})`)}` : "";
+        const bar = scoreBar(best.score, 110);
+        writeLine(
+          `  ${color3.amber(role.padEnd(20))} \u2192 ${color3.cyan(`${best.provider}/${best.model}`)}${family}`
+        );
+        writeLine(`  ${" ".repeat(22)}  ${bar}  ${color3.dim(cat)}`);
+        if (ranked.length > 1 && (ranked[1]?.score ?? Number.NEGATIVE_INFINITY) >= best.score - 15) {
+          for (const alt of ranked.slice(1)) {
+            const af = alt.profile ? ` (${alt.profile.family})` : "";
+            writeLine(
+              `  ${" ".repeat(22)}  ${color3.dim(`${alt.provider}/${alt.model}${af}  score ${alt.score}`)}`
+            );
+          }
+        }
+      }
+      writeLine();
+      writeLine(
+        `  ${color3.bold("leader".padEnd(20))} \u2192 ${color3.cyan(`${config.provider}/${config.model}`)}`
+      );
+    }
+  }
+  if (sub === "suggest") {
+    await renderSuggest();
+    writeLine();
+    writeLine(color3.dim("Pin a suggestion:  wstack setmodel set <role> <provider>/<model>"));
+    writeLine(color3.dim('Test candidates:   wstack modeldiag bench <role> "<test prompt>"'));
+    return 0;
+  }
+  if (sub === "test") {
+    return runModeldiagTest(args, deps, config);
+  }
+  if (sub === "bench") {
+    return runModeldiagBench(args, deps, providers, config, hasKey);
+  }
+  if (sub === "eval" || sub === "evall") {
+    return runModeldiagEval(args, deps, providers, config, hasKey);
+  }
+  writeLine(`${color3.bold("API Key Status")}`);
+  writeLine();
+  for (const prov of providers) {
+    const k = hasKey(prov.id);
+    writeLine(`  ${checkMark(k)} ${color3.bold(prov.id.padEnd(18))} ${color3.dim(prov.name)}`);
+  }
+  writeLine();
+  writeLine(`${color3.dim(`Leader: ${config.provider}/${config.model}`)}`);
+  writeLine();
+  writeLine(`${color3.bold("Model Capabilities")} ${color3.dim("\u2014 matched to known profiles")}`);
+  writeLine();
+  for (const prov of providers) {
+    if (!hasKey(prov.id)) continue;
+    writeLine(`  ${color3.bold(prov.id)} ${color3.dim(`(${prov.name})`)}`);
+    const tiers = {
+      premium: [],
+      standard: [],
+      budget: [],
+      unknown: []
+    };
+    for (const m of prov.models ?? []) {
+      const profile = findProfile(prov.id, m.id);
+      tiers[profile?.costTier ?? "unknown"]?.push(m);
+    }
+    for (const tier of ["premium", "standard", "budget", "unknown"]) {
+      const tierModels = tiers[tier];
+      if (tierModels.length === 0) continue;
+      const label = tier === "unknown" ? color3.dim("unmatched") : `${costLabel(tier)} ${tier}`;
+      writeLine(`    ${label}`);
+      for (const m of tierModels) {
+        const cap = m.capabilities;
+        const ctx = cap?.contextWindow ?? 0;
+        const maxOut = cap?.maxOutputTokens ?? 0;
+        const profile = findProfile(prov.id, m.id);
+        const family = profile ? `${speedLabel(profile.speedTier)} ${color3.green(profile.family)}` : color3.dim("no profile match");
+        const pricing = m.pricing ? `${color3.dim("in")}${fmtPrice(m.pricing.input)} ${color3.dim("out")}${fmtPrice(m.pricing.output)}` : color3.dim("pricing ?");
+        writeLine(
+          `      ${color3.cyan(m.id.padEnd(34))}${ctx > 0 ? `ctx ${fmtTokens(ctx).padEnd(6)}` : color3.dim("ctx ?  ")}${maxOut > 0 ? `out ${fmtTokens(maxOut).padEnd(6)}` : "        "}${family}   ${pricing}`
+        );
+      }
+    }
+    writeLine();
+  }
+  await renderSuggest();
+  writeLine();
+  writeLine(color3.dim("Pin a suggestion:  wstack setmodel set <role> <provider>/<model>"));
+  writeLine(color3.dim('Test candidates:   wstack modeldiag bench <role> "<test prompt>"'));
+  return 0;
+};
+export {
+  modeldiagCmd
+};
+//# sourceMappingURL=modeldiag-36VODVIH.js.map