@iowarp/clio-coder 0.3.0

package/dist/fleet-preflight-CLIAX7YR.js

@@ -0,0 +1,21 @@
+import {
+  fleetPreflightVerdict,
+  readFleetPreflightRecords,
+  recordFleetPreflight,
+  routeFactVerdict,
+  runFleetNodePreflight
+} from "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+export {
+  fleetPreflightVerdict,
+  readFleetPreflightRecords,
+  recordFleetPreflight,
+  routeFactVerdict,
+  runFleetNodePreflight
+};
+//# sourceMappingURL=fleet-preflight-CLIAX7YR.js.map

package/dist/init-2OZDJE2D.js

@@ -0,0 +1,227 @@
+import {
+  CONTEXT_INIT_FLAG_TABLE,
+  bootstrapInputFromInitOptions,
+  modelBootstrapGenerate,
+  validateInitOptions
+} from "./chunk-O4EJEDHO.js";
+import "./chunk-4UQA7NCT.js";
+import "./chunk-3DANZDGR.js";
+import "./chunk-JPOWPFCU.js";
+import "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import {
+  runBootstrap
+} from "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import "./chunk-VOO7NYPP.js";
+import "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import {
+  VALID_THINKING_LEVELS
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/init.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+var HELP = `Usage:
+  clio-coder context init [--preview] [--heuristic] [--yes] [--json] [--adopt] [--global] [--propose|--apply|--rewrite]
+                    [--target <id> [--model <id>] [--thinking <level>]]
+
+Explore the repository and bootstrap the project context in one pass: CLIO-CODER.md,
+the codewiki index, and the .clio-coder state. The configured Clio
+target drafts CLIO-CODER.md grounded in the existing handbook, codewiki structure, and
+sibling agent context. Existing CLIO-CODER.md files are preserved by default; use
+--propose for an ignored draft, --apply to update the handbook using it as source,
+or --rewrite to replace it with a fresh draft that ignores the current CLIO-CODER.md.
+
+Options:
+  --preview        show the plan without writing any files
+  --heuristic      skip model exploration; use the deterministic generator (offline)
+  --adopt          refresh only the managed Imported agent context section
+  --global         include global sibling agent context from user home directory
+  --propose        write an ignored .clio-coder/proposals/CLIO-CODER-*.md draft when CLIO-CODER.md exists
+  --apply          replace an existing CLIO-CODER.md with a draft grounded in the existing handbook
+  --rewrite        replace an existing CLIO-CODER.md with a fresh draft that ignores it as source
+  --json           emit one machine-readable result object on stdout
+  --yes, -y        update .gitignore without prompting
+  --target <id>    override the configured Scout target for this noninteractive run
+  --model <id>     override the Scout wire model (requires --target)
+  --thinking <n>   override Scout thinking: ${VALID_THINKING_LEVELS.join("|")} (requires --target)
+`;
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+function parseContextInitArgs(args) {
+  const options = {};
+  let json = false;
+  let target;
+  let model;
+  let thinkingLevel;
+  const thinkingLevels = new Set(VALID_THINKING_LEVELS);
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h" || arg === "--yes" || arg === "-y") continue;
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--target" || arg === "--model" || arg === "--thinking") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("-")) return { options, json, error: `${arg} requires a value` };
+      index += 1;
+      if (arg === "--target") target = value;
+      else if (arg === "--model") model = value;
+      else {
+        if (!thinkingLevels.has(value)) {
+          return { options, json, error: `--thinking must be one of: ${[...thinkingLevels].join("|")}` };
+        }
+        thinkingLevel = value;
+      }
+      continue;
+    }
+    const row = CONTEXT_INIT_FLAG_TABLE.find((candidate) => candidate.flag === arg || candidate.aliases?.includes(arg));
+    if (!row) {
+      return { options, json, error: arg.startsWith("-") ? `unknown flag ${arg}` : `unexpected argument ${arg}` };
+    }
+    options[row.field] = true;
+  }
+  if (!target && (model || thinkingLevel)) {
+    return { options, json, error: "--model and --thinking require --target" };
+  }
+  return {
+    options,
+    json,
+    ...target ? { target } : {},
+    ...model ? { model } : {},
+    ...thinkingLevel ? { thinkingLevel } : {},
+    error: null
+  };
+}
+async function confirmGitignore(assumeYes) {
+  if (assumeYes) return true;
+  if (!input.isTTY) return false;
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question("Update .gitignore for Clio context artifacts? [y/N] ");
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function runInitCommand(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const assumeYes = hasFlag(args, "--yes") || hasFlag(args, "-y");
+  const parsed = parseContextInitArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`clio-coder context init: ${parsed.error}
+`);
+    process.stdout.write(HELP);
+    return 2;
+  }
+  const validationError = validateInitOptions(parsed.options);
+  if (validationError) {
+    process.stderr.write(`${validationError}
+`);
+    process.stdout.write(HELP);
+    return 2;
+  }
+  const bootstrapOptions = bootstrapInputFromInitOptions(parsed.options);
+  const useModel = parsed.options.heuristic !== true && parsed.options.preview !== true;
+  const startedAt = performance.now();
+  const phaseTimings = /* @__PURE__ */ new Map();
+  try {
+    const result = await runBootstrap({
+      cwd: process.cwd(),
+      io: {
+        stdout: (s) => {
+          if (!parsed.json) process.stdout.write(s);
+        },
+        stderr: (s) => process.stderr.write(s)
+      },
+      onProgress: (event) => {
+        const now = performance.now();
+        const timing = phaseTimings.get(event.phase);
+        if (event.status === "started") phaseTimings.set(event.phase, { startedAt: now });
+        else if (event.status === "completed" && timing) timing.completedMs = Math.max(0, now - timing.startedAt);
+      },
+      confirmGitignore: () => confirmGitignore(assumeYes),
+      ...bootstrapOptions,
+      ...useModel ? {
+        generate: modelBootstrapGenerate({
+          ...parsed.target ? {
+            route: {
+              target: parsed.target,
+              ...parsed.model ? { model: parsed.model } : {},
+              ...parsed.thinkingLevel ? { thinkingLevel: parsed.thinkingLevel } : {}
+            }
+          } : {},
+          onFallback: (err, mode) => process.stderr.write(
+            `clio-coder context init: model exploration unavailable, using ${mode === "existing" ? "existing CLIO-CODER.md" : "heuristic"} (${err.message})
+`
+          )
+        }),
+        modelId: "configured-clio-target"
+      } : {}
+    });
+    if (parsed.json) {
+      process.stdout.write(
+        `${JSON.stringify({
+          version: 1,
+          action: result.summary.action,
+          projectType: result.projectType,
+          codewikiEntries: result.summary.codewikiEntries,
+          clioMdPath: result.clioMdPath,
+          statePath: result.statePath,
+          preload: result.preload,
+          adoption: result.summary.adoption,
+          generation: result.telemetry.generation,
+          timings: {
+            wallMs: Math.max(0, performance.now() - startedAt),
+            ...phaseTimings.get("codewiki")?.completedMs !== void 0 ? { codewikiMs: phaseTimings.get("codewiki")?.completedMs } : {},
+            ...phaseTimings.get("generate")?.completedMs !== void 0 ? { generationMs: phaseTimings.get("generate")?.completedMs } : {}
+          }
+        })}
+`
+      );
+    }
+    if (parsed.options.rewriteClioMd === true && result.telemetry.generation.mode === "existing") {
+      process.stderr.write(
+        "clio-coder context init: --rewrite did not rewrite CLIO-CODER.md; the model draft failed and the fallback rebuilt the handbook from the existing file.\n  rerun `clio-coder context init --rewrite` once the bootstrap target answers, or `clio-coder context init --rewrite --heuristic` to replace it with the deterministic draft.\n"
+      );
+      return 1;
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(`clio-coder context init failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+export {
+  runInitCommand
+};
+//# sourceMappingURL=init-2OZDJE2D.js.map

package/dist/memory-3PIQQAKX.js

@@ -0,0 +1,207 @@
+import {
+  approveMemoryRecord,
+  loadMemoryRecords,
+  memoryStatus,
+  proposeMemoryFromEvidence,
+  pruneStaleMemory,
+  rejectMemoryRecord
+} from "./chunk-VOO7NYPP.js";
+import "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioDataDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/memory.ts
+var HELP = `clio-coder memory list
+clio-coder memory propose --from-evidence <evidenceId>
+clio-coder memory approve <memoryId>
+clio-coder memory reject <memoryId>
+clio-coder memory prune --stale
+
+Manage scoped, approved, evidence-linked local memory records.
+`;
+function parseMemoryArgs(args) {
+  const parsed = { stale: false, help: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (parsed.command === void 0) {
+      if (arg === "list" || arg === "propose" || arg === "approve" || arg === "reject" || arg === "prune") {
+        parsed.command = arg;
+        continue;
+      }
+      throw new Error(`unknown memory command: ${arg}`);
+    }
+    if (parsed.command === "propose") {
+      if (arg === "--from-evidence") {
+        const value = args[index + 1];
+        if (value === void 0 || value.startsWith("-")) throw new Error("--from-evidence requires an evidence id");
+        parsed.evidenceId = value;
+        index += 1;
+        continue;
+      }
+      throw new Error(`unknown memory propose argument: ${arg}`);
+    }
+    if (parsed.command === "approve" || parsed.command === "reject") {
+      if (parsed.memoryId === void 0 && !arg.startsWith("-")) {
+        parsed.memoryId = arg;
+        continue;
+      }
+      throw new Error(`unexpected memory ${parsed.command} argument: ${arg}`);
+    }
+    if (parsed.command === "prune") {
+      if (arg === "--stale") {
+        parsed.stale = true;
+        continue;
+      }
+      throw new Error(`unknown memory prune argument: ${arg}`);
+    }
+    throw new Error(`unexpected memory argument: ${arg}`);
+  }
+  if (parsed.help) return parsed;
+  if (parsed.command === void 0) throw new Error("memory requires list, propose, approve, reject, or prune");
+  if (parsed.command === "propose" && parsed.evidenceId === void 0) {
+    throw new Error("propose requires --from-evidence <evidenceId>");
+  }
+  if ((parsed.command === "approve" || parsed.command === "reject") && parsed.memoryId === void 0) {
+    throw new Error(`${parsed.command} requires a memory id`);
+  }
+  if (parsed.command === "prune" && !parsed.stale) throw new Error("prune requires --stale");
+  if (parsed.command === "list" && (parsed.evidenceId !== void 0 || parsed.memoryId !== void 0 || parsed.stale)) {
+    throw new Error("list does not accept extra arguments");
+  }
+  return parsed;
+}
+async function runMemoryCommand(args) {
+  let parsed;
+  try {
+    parsed = parseMemoryArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const dataDir = clioDataDir();
+  try {
+    if (parsed.command === "list") {
+      renderMemoryList(await loadMemoryRecords(dataDir));
+      return 0;
+    }
+    if (parsed.command === "propose") {
+      const evidenceId = parsed.evidenceId;
+      if (evidenceId === void 0) {
+        printError("propose requires --from-evidence <evidenceId>");
+        return 2;
+      }
+      const result = await proposeMemoryFromEvidence(dataDir, evidenceId);
+      renderProposal(result.record, result.created);
+      return 0;
+    }
+    if (parsed.command === "approve") {
+      const memoryId = parsed.memoryId;
+      if (memoryId === void 0) {
+        printError("approve requires a memory id");
+        return 2;
+      }
+      const record = await approveMemoryRecord(dataDir, memoryId);
+      printOk(`approved ${record.id}`);
+      return 0;
+    }
+    if (parsed.command === "reject") {
+      const memoryId = parsed.memoryId;
+      if (memoryId === void 0) {
+        printError("reject requires a memory id");
+        return 2;
+      }
+      const record = await rejectMemoryRecord(dataDir, memoryId);
+      printOk(`rejected ${record.id}`);
+      return 0;
+    }
+    if (parsed.command === "prune") {
+      const pruned = await pruneStaleMemory(dataDir);
+      printOk(`pruned ${pruned.length} stale memory record${pruned.length === 1 ? "" : "s"}`);
+      return 0;
+    }
+    printError("memory requires list, propose, approve, reject, or prune");
+    return 2;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+function renderProposal(record, created) {
+  process.stdout.write(`memory: ${record.id}
+`);
+  process.stdout.write(`status: ${created ? "proposed" : memoryStatus(record)}
+`);
+  process.stdout.write(`scope: ${record.scope}
+`);
+  process.stdout.write(`key: ${record.key}
+`);
+  process.stdout.write(`evidence: ${record.evidenceRefs.join(", ")}
+`);
+  process.stdout.write(`confidence: ${record.confidence.toFixed(2)}
+`);
+  process.stdout.write(`lesson: ${record.lesson}
+`);
+}
+function renderMemoryList(records) {
+  process.stdout.write(`${records.length} memory record${records.length === 1 ? "" : "s"}
+`);
+  if (records.length === 0) return;
+  process.stdout.write("\n");
+  for (const record of records) {
+    process.stdout.write(
+      [
+        record.id.padEnd(21),
+        memoryStatus(record).padEnd(10),
+        record.scope.padEnd(13),
+        `confidence=${record.confidence.toFixed(2)}`.padEnd(16),
+        `evidence=${record.evidenceRefs.join(",")}`
+      ].join("")
+    );
+    process.stdout.write("\n");
+    process.stdout.write(`  key: ${record.key}
+`);
+    process.stdout.write(`  lesson: ${record.lesson}
+`);
+  }
+}
+export {
+  runMemoryCommand
+};
+//# sourceMappingURL=memory-3PIQQAKX.js.map

package/dist/models-DY35XI7Y.js

@@ -0,0 +1,237 @@
+import "./chunk-NI4DEJMC.js";
+import {
+  ensureClioState
+} from "./chunk-7RBKDI66.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import "./chunk-HMYNFFY4.js";
+import "./chunk-262G75JS.js";
+import "./chunk-TFSSEXL6.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError
+} from "./chunk-67MTHP2E.js";
+import {
+  ProvidersDomainModule,
+  modelCandidatesForStatus,
+  resolveModelCapabilities
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/models.ts
+import chalk from "chalk";
+var HELP = `clio-coder models [search] [--target <id>] [--json] [--offline]
+
+List live-discovered models for configured targets.
+
+Options:
+  --offline   use cached/configured/catalog model hints without probing targets
+`;
+function parseModelArgs(args) {
+  const parsed = { json: false, offline: false, help: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      parsed.json = true;
+      continue;
+    }
+    if (arg === "--offline") {
+      parsed.offline = true;
+      continue;
+    }
+    if (arg === "--target") {
+      const value = args[i + 1];
+      if (!value) throw new Error("--target requires a value");
+      parsed.target = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    if (parsed.search) throw new Error("models accepts at most one search term");
+    parsed.search = arg;
+  }
+  return parsed;
+}
+async function runModelsCommand(args) {
+  let parsed;
+  try {
+    parsed = parseModelArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  ensureClioState();
+  const loaded = await loadDomains([ConfigDomainModule, ProvidersDomainModule]);
+  const providers = loaded.getContract("providers");
+  if (!providers) {
+    process.stderr.write("models: provider domain not loaded\n");
+    await loaded.stop();
+    return 1;
+  }
+  if (!parsed.offline) {
+    try {
+      await providers.probeAllLive();
+    } catch (err) {
+      process.stderr.write(`models: live probe failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
+  const entries = providers.list();
+  if (parsed.target !== void 0 && !entries.some((e) => e.target.id === parsed.target)) {
+    printError(`no target with id ${parsed.target}. ${targetCount(entries.length)} configured.`);
+    await loaded.stop();
+    return 2;
+  }
+  const filtered = parsed.target ? entries.filter((e) => e.target.id === parsed.target) : entries;
+  const rows = collectRows(filtered, providers).filter((row) => matchesSearch(row, parsed.search));
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(rows, null, 2)}
+`);
+  } else if (rows.length === 0) {
+    process.stdout.write(`${emptyModelsMessage(parsed, entries.length, filtered.length)}
+`);
+  } else {
+    renderRows(rows);
+  }
+  await loaded.stop();
+  return 0;
+}
+function collectRows(entries, providers) {
+  const rows = [];
+  for (const status of entries) {
+    const runtimeId = status.runtime?.id ?? status.target.runtime;
+    const candidates = modelCandidatesForStatus(status);
+    if (candidates.length === 0) {
+      const caps = resolveRowCapabilities(status, status.target.defaultModel ?? null, providers);
+      rows.push({
+        targetId: status.target.id,
+        runtimeId,
+        modelId: "(no models)",
+        state: "-",
+        ...formatCapabilities(caps)
+      });
+      continue;
+    }
+    for (const candidate of candidates) {
+      const modelId = candidate.id;
+      const caps = resolveRowCapabilities(status, modelId, providers);
+      rows.push({
+        targetId: status.target.id,
+        runtimeId,
+        modelId,
+        state: candidate.loadState ?? "-",
+        ...formatCapabilities(caps)
+      });
+    }
+  }
+  return rows;
+}
+function resolveRowCapabilities(status, modelId, providers) {
+  return resolveModelCapabilities(status, modelId, providers.knowledgeBase, {
+    detectedReasoning: modelId ? providers.getDetectedReasoning(status.target.id, modelId) : null
+  });
+}
+function formatCapabilities(c) {
+  return {
+    caps: capabilityBadges(c),
+    contextWindow: c.contextWindow,
+    maxTokens: c.maxTokens,
+    reasoning: c.reasoning
+  };
+}
+function capabilityBadges(c) {
+  const badge = (on, letter) => on ? letter : "-";
+  return [
+    badge(c.chat, "C"),
+    badge(c.tools, "T"),
+    badge(c.reasoning, "R"),
+    badge(c.vision, "V"),
+    badge(c.embeddings, "E"),
+    badge(c.rerank, "K"),
+    badge(c.fim, "F")
+  ].join("");
+}
+function compactTokenCount(value) {
+  if (!Number.isFinite(value) || value <= 0) return "-";
+  if (value >= 1e6) {
+    const rounded = value / 1e6;
+    return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)}m`;
+  }
+  if (value >= 1e3) return `${Math.round(value / 1e3)}k`;
+  return String(value);
+}
+function emptyModelsMessage(args, configuredTargets, matchedTargets) {
+  if (configuredTargets === 0) {
+    return "no targets configured. run `clio-coder configure` or `clio-coder targets add` to register one.";
+  }
+  if (args.target !== void 0 && matchedTargets === 0) {
+    return `no target with id ${args.target}. ${targetCount(configuredTargets)} configured.`;
+  }
+  if (args.search !== void 0) {
+    return `no models matched "${args.search}" across ${targetCount(matchedTargets)}.`;
+  }
+  return `no models found across ${targetCount(matchedTargets)}.`;
+}
+function targetCount(n) {
+  return `${n} target${n === 1 ? "" : "s"}`;
+}
+var MODEL_ID_WIDTH_CAP = 56;
+var COLUMN_GAP = "  ";
+function truncateModelId(id) {
+  if (id.length <= MODEL_ID_WIDTH_CAP) return id;
+  return `${id.slice(0, MODEL_ID_WIDTH_CAP - 3)}...`;
+}
+function modelTableLines(rows) {
+  const includeState = rows.some((row) => row.state && row.state !== "-");
+  const headers = includeState ? ["target", "runtime", "model", "state", "caps", "ctx", "max"] : ["target", "runtime", "model", "caps", "ctx", "max"];
+  const cells = rows.map((row) => {
+    const base = [row.targetId, row.runtimeId, truncateModelId(row.modelId)];
+    if (includeState) base.push(row.state || "-");
+    base.push(row.caps, compactTokenCount(row.contextWindow), compactTokenCount(row.maxTokens));
+    return base;
+  });
+  const widths = headers.map((h, col) => Math.max(h.length, ...cells.map((cell) => cell[col]?.length ?? 0)));
+  const formatLine = (values) => values.map((value, col) => value.padEnd(widths[col] ?? 0)).join(COLUMN_GAP).trimEnd();
+  return [formatLine(headers), ...cells.map(formatLine)];
+}
+function renderRows(rows) {
+  const [header, ...body] = modelTableLines(rows);
+  process.stdout.write(`${chalk.bold(header ?? "")}
+`);
+  for (const line of body) {
+    process.stdout.write(`${line}
+`);
+  }
+}
+function matchesSearch(row, search) {
+  if (!search) return true;
+  const needle = search.toLowerCase();
+  return row.targetId.toLowerCase().includes(needle) || row.runtimeId.toLowerCase().includes(needle) || row.modelId.toLowerCase().includes(needle) || row.state.toLowerCase().includes(needle);
+}
+export {
+  emptyModelsMessage,
+  modelTableLines,
+  runModelsCommand
+};
+//# sourceMappingURL=models-DY35XI7Y.js.map