@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/llm-OTJWPMGI.js

@@ -0,0 +1,704 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  costCommand
+} from "./chunk-5PNI276X.js";
+import {
+  streamCommand
+} from "./chunk-ZMGDZMSJ.js";
+import {
+  LOGIN_ARGS,
+  runLoginCommand
+} from "./chunk-UWCZY52R.js";
+import "./chunk-GZFVDR44.js";
+import "./chunk-GRU74UE4.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput,
+  humanLine,
+  isHumanOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/llm.ts
+import { pushWarning } from "@cleocode/core";
+
+// packages/cleo/src/cli/commands/llm-refresh-catalog.ts
+import {
+  buildContextIndex,
+  fetchAndCacheCatalog,
+  findLatestCacheFile,
+  getCatalogDir,
+  readCacheFile
+} from "@cleocode/core/llm/catalog-cache";
+async function runLlmRefreshCatalog(dir) {
+  const cacheDir = dir ?? getCatalogDir();
+  try {
+    const { filePath, catalog } = await fetchAndCacheCatalog(cacheDir);
+    const index = buildContextIndex(catalog);
+    const providerCount = Object.keys(catalog).length;
+    const modelCount = Object.keys(index).length;
+    return {
+      success: true,
+      data: { providers: providerCount, models: modelCount, filePath, source: "live" }
+    };
+  } catch {
+  }
+  const latestPath = findLatestCacheFile(cacheDir);
+  if (latestPath) {
+    const catalog = readCacheFile(latestPath);
+    if (catalog) {
+      const index = buildContextIndex(catalog);
+      return {
+        success: true,
+        data: {
+          providers: Object.keys(catalog).length,
+          models: Object.keys(index).length,
+          filePath: latestPath,
+          source: "stale-cache"
+        }
+      };
+    }
+  }
+  return {
+    success: false,
+    error: {
+      message: "Failed to fetch model catalog and no cached snapshot found.",
+      code: "E_CATALOG_UNAVAILABLE"
+    }
+  };
+}
+
+// packages/cleo/src/cli/commands/llm.ts
+async function getListProviders() {
+  const { listProviders } = await import(
+    /* webpackIgnore: true */
+    "@cleocode/core/llm/provider-registry"
+  );
+  return listProviders;
+}
+async function readApiKeyFromStdin() {
+  if (process.stdin.isTTY) return "";
+  process.stdin.setEncoding("utf-8");
+  let buf = "";
+  for await (const chunk of process.stdin) {
+    buf += chunk;
+  }
+  return buf.replace(/\r?\n$/, "").trim();
+}
+function makeLlmSubcommand(opts) {
+  const mergedArgs = {
+    ...opts.args,
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  };
+  return defineCommand({
+    meta: { name: opts.name, description: opts.description },
+    args: mergedArgs,
+    async run({ args }) {
+      const params = opts.paramBuilder(args);
+      await dispatchFromCli(opts.gateway, "llm", opts.operation, params, opts.output);
+    }
+  });
+}
+var API_KEY_FLAG_DEPRECATION = "[warning] --api-key exposes the secret to 'ps' listings and shell history. Prefer --api-key-stdin or --api-key-env=NAME for production use.";
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    // Help text lists --api-key-stdin first (recommended path) and
+    // --api-key last (deprecated). See S-11 in T9258 for the rationale.
+    description: "Upsert a credential into the multi-credential pool. Reads the secret from stdin (--api-key-stdin, recommended), from an env var (--api-key-env=NAME), or as a literal flag value (--api-key, DEPRECATED \u2014 visible to ps + shell history). Auto-detects authType from token prefix (sk-ant-oat-* \u2192 oauth)."
+  },
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider transport (anthropic | openai | gemini | moonshot)",
+      required: true
+    },
+    // Recommended path — listed first to surface it in --help output.
+    "api-key-stdin": {
+      type: "boolean",
+      description: '(recommended) Read the API key from stdin. Example: `echo "$KEY" | cleo llm add anthropic --api-key-stdin`. Not visible to `ps` listings or shell history.'
+    },
+    // Named-env mode — second-priority. Lets users put the key in a
+    // .envrc / secret manager and reference it by name.
+    "api-key-env": {
+      type: "string",
+      description: "Read the API key from the env var named here. Example: `cleo llm add anthropic --api-key-env=ANTHROPIC_API_KEY`."
+    },
+    // Deprecated literal-value mode — last in the help order. Backward
+    // compat for CI scripts; emits a stderr warning when used.
+    "api-key": {
+      type: "string",
+      description: "(DEPRECATED) API key or OAuth bearer token as a literal flag value. Exposes the secret to `ps` and shell history. Prefer --api-key-stdin or --api-key-env=NAME."
+    },
+    label: {
+      type: "string",
+      description: "Human-readable label, unique within provider (default: 'default')"
+    },
+    "base-url": {
+      type: "string",
+      description: "Optional override for the provider base URL"
+    },
+    "auth-type": {
+      type: "string",
+      description: "Explicit auth type override ('api_key' | 'oauth' | 'aws_sdk')"
+    },
+    priority: {
+      type: "string",
+      description: "Optional priority override (lower wins)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    let apiKey = "";
+    let source = "none";
+    if (a["api-key-stdin"] === true) {
+      apiKey = await readApiKeyFromStdin();
+      source = "stdin";
+      if (!apiKey) {
+        cliError(
+          '--api-key-stdin set but stdin is empty or a TTY. Pipe the secret in, e.g. `echo "$KEY" | cleo llm add ...`.',
+          2,
+          { name: "E_VALIDATION", fix: "Pipe the secret to stdin or use --api-key-env=NAME." },
+          { operation: "llm.add" }
+        );
+        process.exit(2);
+      }
+    } else if (typeof a["api-key-env"] === "string" && a["api-key-env"]) {
+      const envName = a["api-key-env"];
+      const envValue = process.env[envName];
+      if (!envValue) {
+        cliError(
+          `--api-key-env=${envName} is not set in the environment.`,
+          2,
+          {
+            name: "E_VALIDATION",
+            fix: `Export ${envName} before running, or use --api-key-stdin.`
+          },
+          { operation: "llm.add" }
+        );
+        process.exit(2);
+      }
+      apiKey = envValue;
+      source = "env";
+    } else if (typeof a["api-key"] === "string" && a["api-key"]) {
+      pushWarning({
+        code: "W_DEPRECATED_FLAG",
+        message: API_KEY_FLAG_DEPRECATION,
+        deprecated: "--api-key=<value>",
+        replacement: "--api-key-stdin or --api-key-env=NAME"
+      });
+      apiKey = a["api-key"];
+      source = "flag";
+    } else {
+      cliError(
+        "cleo llm add requires one of --api-key-stdin (recommended), --api-key-env=NAME, or --api-key=<value> (deprecated).",
+        2,
+        {
+          name: "E_VALIDATION",
+          fix: "Provide the credential via --api-key-stdin, --api-key-env=NAME, or --api-key=<value>."
+        },
+        { operation: "llm.add" }
+      );
+      process.exit(2);
+    }
+    const params = {
+      provider: a["provider"],
+      apiKey,
+      _source: source
+      // surfaces in audit logs for incident response
+    };
+    if (a["label"] !== void 0) params["label"] = a["label"];
+    if (a["base-url"] !== void 0) params["baseUrl"] = a["base-url"];
+    if (a["auth-type"] !== void 0) params["authType"] = a["auth-type"];
+    if (a["priority"] !== void 0) params["priority"] = Number(a["priority"]);
+    await dispatchFromCli("mutate", "llm", "add", params, {
+      command: "llm-add",
+      operation: "llm.add"
+    });
+  }
+});
+var listCommand = makeLlmSubcommand({
+  name: "list",
+  description: "List redacted credentials from the multi-credential pool (tokens shown as last 4 chars only).",
+  args: {
+    provider: {
+      type: "positional",
+      description: "Optional provider filter",
+      required: false
+    }
+  },
+  gateway: "query",
+  operation: "list",
+  output: { command: "llm-list", operation: "llm.list" },
+  paramBuilder: (args) => ({
+    ...args["provider"] !== void 0 && args["provider"] !== "" ? { provider: args["provider"] } : {}
+  })
+});
+var removeCommand = makeLlmSubcommand({
+  name: "remove",
+  description: "Delete a (provider, label) credential pair from the pool.",
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider transport",
+      required: true
+    },
+    label: {
+      type: "string",
+      description: "Label of the credential to remove",
+      required: true
+    }
+  },
+  gateway: "mutate",
+  operation: "remove",
+  output: { command: "llm-remove", operation: "llm.remove" },
+  paramBuilder: (args) => ({
+    provider: args["provider"],
+    label: args["label"]
+  })
+});
+var useCommand = makeLlmSubcommand({
+  name: "use",
+  description: "Set llm.default.{provider,model} in the global config.",
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider transport to mark as default",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: "Optional default model identifier"
+    }
+  },
+  gateway: "mutate",
+  operation: "use",
+  output: { command: "llm-use", operation: "llm.use" },
+  paramBuilder: (args) => ({
+    provider: args["provider"],
+    ...args["model"] !== void 0 && { model: args["model"] }
+  })
+});
+var profileCommand = makeLlmSubcommand({
+  name: "profile",
+  description: "Pin a logical role (extraction | consolidation | derivation | hygiene | judgement) to a specific provider / model / credential label.",
+  args: {
+    role: {
+      type: "positional",
+      description: "Role name",
+      required: true
+    },
+    provider: {
+      type: "positional",
+      description: "Provider transport for this role",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: "Optional model identifier for this role"
+    },
+    "credential-label": {
+      type: "string",
+      description: "Optional credential label to pin this role to a specific store entry"
+    }
+  },
+  gateway: "mutate",
+  operation: "profile",
+  output: { command: "llm-profile", operation: "llm.profile" },
+  paramBuilder: (args) => ({
+    role: args["role"],
+    provider: args["provider"],
+    ...args["model"] !== void 0 && { model: args["model"] },
+    ...args["credential-label"] !== void 0 && { credentialLabel: args["credential-label"] }
+  })
+});
+var testCommand = makeLlmSubcommand({
+  name: "test",
+  description: "Round-trip ping against the resolved provider (1-token prompt). Returns latency + response id; tokens never surfaced.",
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider transport to probe",
+      required: true
+    },
+    label: {
+      type: "string",
+      description: "Credential label to pin the test to a specific store entry"
+    },
+    model: {
+      type: "string",
+      description: "Model override (defaults to the provider's implicit fallback)"
+    }
+  },
+  gateway: "query",
+  operation: "test",
+  output: { command: "llm-test", operation: "llm.test" },
+  paramBuilder: (args) => ({
+    provider: args["provider"],
+    ...args["label"] !== void 0 && { label: args["label"] },
+    ...args["model"] !== void 0 && { model: args["model"] }
+  })
+});
+var whoamiCommand = makeLlmSubcommand({
+  name: "whoami",
+  description: "For each role, resolve and report which provider / model / credential would be picked today.",
+  args: {
+    role: {
+      type: "string",
+      description: "Optional role filter"
+    }
+  },
+  gateway: "query",
+  operation: "whoami",
+  output: { command: "llm-whoami", operation: "llm.whoami" },
+  paramBuilder: (args) => ({
+    ...args["role"] !== void 0 && args["role"] !== "" ? { role: args["role"] } : {}
+  })
+});
+var listProvidersCommand = defineCommand({
+  meta: {
+    name: "list-providers",
+    description: "List all registered LLM provider profiles (builtins + user plugins from $CLEO_HOME/plugins/model-providers/)."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run() {
+    const listProviders = await getListProviders();
+    const profiles = await listProviders();
+    const providers = profiles.map((p) => ({
+      name: p.name,
+      displayName: p.displayName,
+      authTypes: p.authTypes,
+      defaultModel: p.defaultModel,
+      baseUrl: p.baseUrl
+    }));
+    cliOutput(
+      { providers },
+      {
+        command: "llm-list-providers",
+        operation: "llm.listProviders"
+      }
+    );
+  }
+});
+var contextEnginesListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List all registered ContextEngine names (builtins + user plugins)."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run() {
+    const { listContextEngines } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/executor-factory"
+    );
+    const engines = listContextEngines();
+    cliOutput(
+      { engines: [...engines] },
+      {
+        command: "llm-context-engines-list",
+        operation: "llm.contextEngines.list"
+      }
+    );
+  }
+});
+var contextEnginesCommand = defineCommand({
+  meta: {
+    name: "context-engines",
+    description: "Manage registered ContextEngine plugins."
+  },
+  subCommands: {
+    list: contextEnginesListCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+var loginCommand = defineCommand({
+  meta: {
+    name: "login",
+    description: "Log in to an LLM provider and bind a usable profile (alias of `cleo login`). Picks a provider + auth method (browser OAuth: anthropic, openai/codex; device-code: kimi-code; or API key), selects a model, binds it, and validates the binding. Prompts/URLs go to stderr; the result is a human line on a terminal or a JSON envelope when piped/--json."
+  },
+  args: LOGIN_ARGS,
+  async run({ args }) {
+    await runLoginCommand(args, "llm.login");
+  }
+});
+var refreshCatalogCommand = defineCommand({
+  meta: {
+    name: "refresh-catalog",
+    description: "Fetch the live model catalog from models.dev and persist it to disk. Falls back to the most-recent cached snapshot on network failure."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run() {
+    const result = await runLlmRefreshCatalog();
+    if (result.success && result.data) {
+      const d = result.data;
+      if (isHumanOutput()) {
+        humanLine(
+          `Catalog refreshed: ${d.providers} providers, ${d.models} models written to ${d.filePath}`
+        );
+      } else {
+        cliOutput(result.data, { command: "llm-refresh-catalog", operation: "llm.refreshCatalog" });
+      }
+      return;
+    }
+    if (!result.success) {
+      cliError(
+        result.error?.message ?? "refresh failed",
+        result.error?.code ?? 1,
+        { name: "E_REFRESH_FAILED" },
+        { operation: "llm.refreshCatalog" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var providersCommand = defineCommand({
+  meta: {
+    name: "providers",
+    description: "Show provisioning state, reachability, and resolver scores for all builtin LLM providers (DHQ-081)."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    },
+    role: {
+      type: "string",
+      description: "Role to compute scores against (default: consolidation). One of: consolidation, judgement, hygiene, extraction, derivation."
+    }
+  },
+  async run({ args }) {
+    const { enumerateProvisionedProviders, roleTierFor } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/cross-provider-selector"
+    );
+    const typedArgs = args;
+    const role = typeof typedArgs["role"] === "string" ? typedArgs["role"] : "consolidation";
+    const taskTier = roleTierFor(role);
+    const providers = await enumerateProvisionedProviders(taskTier);
+    const provisioned = providers.filter((p) => p.provisioningState === "provisioned");
+    const winner = provisioned.length > 0 ? provisioned.reduce(
+      (best, p) => (p.resolverScore ?? -Infinity) > (best.resolverScore ?? -Infinity) ? p : best
+    ) : null;
+    const envelope = {
+      providers,
+      implicitFallbackWouldUse: "anthropic",
+      explainCrossProvider: {
+        winner: winner?.id ?? null,
+        scores: Object.fromEntries(providers.map((p) => [p.id, p.resolverScore ?? 0])),
+        reason: winner ? `${winner.id} (tier: ${winner.tier}, score: ${winner.resolverScore}) selected as best provisioned provider for role '${role}'` : `No provisioned provider found; falling back to anthropic implicit fallback`
+      }
+    };
+    if (isHumanOutput() && !typedArgs["json"]) {
+      const lines = ["", "LLM Providers \u2014 Provisioning State", "=".repeat(40)];
+      for (const p of providers) {
+        const star = p.id === winner?.id ? " \u2605" : "";
+        const runnable = p.machineRunnable === null ? "" : ` [local:${p.machineRunnable ? "up" : "down"}]`;
+        lines.push(
+          `  ${p.id.padEnd(12)}  ${p.provisioningState.padEnd(16)}  score:${String(p.resolverScore ?? "-").padStart(4)}  ${p.reachabilityState}${runnable}${star}`
+        );
+      }
+      if (winner) {
+        lines.push(
+          "",
+          `Winner: ${winner.id} \u2014 would pick model: ${winner.wouldPickModel ?? "unknown"}`
+        );
+      }
+      humanLine(lines.join("\n"));
+    } else {
+      cliOutput(envelope, { command: "llm-providers", operation: "llm.providers" });
+    }
+  }
+});
+var healthCommand = defineCommand({
+  meta: {
+    name: "health",
+    description: "Show lightweight provisioning health for all builtin LLM providers (DHQ-081). Alias for cleo llm providers --brief."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const { enumerateProvisionedProviders } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/cross-provider-selector"
+    );
+    const typedArgs = args;
+    const providers = await enumerateProvisionedProviders("frontier");
+    const healthEnvelope = {
+      providers: providers.map((p) => ({
+        id: p.id,
+        displayName: p.displayName,
+        provisioningState: p.provisioningState,
+        reachabilityState: p.reachabilityState,
+        machineRunnable: p.machineRunnable
+      })),
+      implicitFallbackWouldUse: "anthropic"
+    };
+    if (isHumanOutput() && !typedArgs["json"]) {
+      const lines = ["", "LLM Health", "=".repeat(30)];
+      for (const p of healthEnvelope.providers) {
+        const icon = p.provisioningState === "provisioned" ? "\u2713" : "\u2717";
+        const runnable = p.machineRunnable === null ? "" : ` [local:${p.machineRunnable ? "up" : "down"}]`;
+        lines.push(
+          `  ${icon} ${p.id.padEnd(12)}  ${p.provisioningState.padEnd(16)}  ${p.reachabilityState}${runnable}`
+        );
+      }
+      humanLine(lines.join("\n"));
+    } else {
+      cliOutput(healthEnvelope, { command: "llm-health", operation: "llm.health" });
+    }
+  }
+});
+var fitCommand = defineCommand({
+  meta: {
+    name: "fit",
+    description: "Rank 2\u20133 best-fit local open-weight models for this machine (RAM/VRAM check). Wizard building block for local Ollama setup."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope)"
+    },
+    "ollama-url": {
+      type: "string",
+      description: "Override Ollama base URL (default: http://localhost:11434)"
+    }
+  },
+  async run({ args }) {
+    const { rankLocalModelFit } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/local-model-fit"
+    );
+    const typedArgs = args;
+    const ollamaBaseUrl = typeof typedArgs["ollama-url"] === "string" ? typedArgs["ollama-url"] : "http://localhost:11434";
+    const envelope = await rankLocalModelFit({ ollamaBaseUrl });
+    if (isHumanOutput() && !typedArgs["json"]) {
+      const lines = ["", "Local Model Fit \u2014 Hardware Summary", "=".repeat(42)];
+      const hw = envelope.hardware;
+      lines.push(`  RAM total   : ${hw.totalRamGb.toFixed(1)} GB`);
+      lines.push(`  RAM avail   : ${hw.availableRamGb.toFixed(1)} GB`);
+      if (hw.vramTotalGb !== null) {
+        lines.push(`  VRAM total  : ${hw.vramTotalGb.toFixed(1)} GB (${hw.vramMethod})`);
+        lines.push(
+          `  VRAM free   : ${hw.vramFreeGb !== null ? hw.vramFreeGb.toFixed(1) + " GB" : "unknown"}`
+        );
+      } else {
+        lines.push(`  VRAM        : not detected (${hw.vramMethod})`);
+      }
+      lines.push(`  Ollama      : ${envelope.ollamaRunning ? "running" : "not running"}`);
+      if (envelope.pulledModels.length > 0) {
+        lines.push(`  Pulled      : ${envelope.pulledModels.map((m) => m.name).join(", ")}`);
+      }
+      lines.push("");
+      if (envelope.noRecommendationReason) {
+        lines.push("  No local model recommendations:");
+        lines.push(`  ${envelope.noRecommendationReason}`);
+      } else {
+        lines.push("Recommended Models", "-".repeat(42));
+        for (let i = 0; i < envelope.recommendations.length; i++) {
+          const rec = envelope.recommendations[i];
+          const pulled = rec.alreadyPulled ? " [already pulled]" : "";
+          lines.push(`  ${i + 1}. ${rec.candidate.displayName}${pulled}  (fit: ${rec.fitTier})`);
+          for (const reason of rec.reasons) {
+            lines.push(`       \u2022 ${reason}`);
+          }
+          lines.push(`     pull: ${rec.pullCommand}`);
+          lines.push("");
+        }
+      }
+      humanLine(lines.join("\n"));
+    } else {
+      cliOutput(envelope, { command: "llm-fit", operation: "llm.fit" });
+    }
+  }
+});
+var llmCommand = defineCommand({
+  meta: {
+    name: "llm",
+    description: "Manage LLM credentials, role profiles, and resolver diagnostics"
+  },
+  subCommands: {
+    add: addCommand,
+    "context-engines": contextEnginesCommand,
+    cost: costCommand,
+    fit: fitCommand,
+    health: healthCommand,
+    list: listCommand,
+    login: loginCommand,
+    providers: providersCommand,
+    remove: removeCommand,
+    stream: streamCommand,
+    use: useCommand,
+    profile: profileCommand,
+    "refresh-catalog": refreshCatalogCommand,
+    test: testCommand,
+    whoami: whoamiCommand,
+    "list-providers": listProvidersCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  llmCommand
+};
+//# sourceMappingURL=llm-OTJWPMGI.js.map