@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-QI72X67S.js

@@ -1,481 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  runVectorTool
-} from "./chunk-YQYINEJI.js";
-import {
-  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
-  capturePerfEnvironment,
-  evaluatePerfBudget,
-  loadProjectVerifierCatalog,
-  packageDeclaredCheck,
-  parsePerfBaseline,
-  renderPerfBaseline,
-  resolveProjectVerifierExecutionCwd
-} from "./chunk-H72DCH3E.js";
-import {
-  compareNumeric,
-  parseNumericPayload,
-  renderNumericReport
-} from "./chunk-2KUBKL63.js";
-import {
-  declaredVerificationScripts
-} from "./chunk-M4KFUXS7.js";
-import {
-  resolveSafeCwd,
-  runCommandVector
-} from "./chunk-XTQ7MEJG.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/tools/verify/scripts.ts
-init_esm_shims();
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-var JUDGED_CHECK_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
-var SCIENTIFIC_VALIDITY_NOT_ESTABLISHED = "not established by this check";
-function sha256(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-function executionOutcome(result) {
-  if (result.aborted) return "aborted";
-  if (result.timedOut) return "timed-out";
-  if (result.outputCapped) return "output-capped";
-  return result.exitCode === 0 ? "succeeded" : "failed";
-}
-function judgement(execution, validation) {
-  return { execution, validation, scientificValidity: SCIENTIFIC_VALIDITY_NOT_ESTABLISHED };
-}
-function repositoryRelativeCwd(workspaceRoot, resolved) {
-  const relative = path.relative(workspaceRoot, resolved);
-  return relative.length === 0 ? "." : relative.split(path.sep).join("/");
-}
-function packageTag(id) {
-  const separator = id.search(/[:.-]/u);
-  return [separator === -1 ? id : id.slice(0, separator)];
-}
-function packageCheckSource(packageRoot, workspaceRoot) {
-  const packagePath = path.join(packageRoot, "package.json");
-  if (!existsSync(packagePath)) return null;
-  const pkg = parsePackageJson(packagePath);
-  if (!pkg.ok) return null;
-  const cwd = repositoryRelativeCwd(workspaceRoot, packageRoot);
-  const checks = declaredVerificationScripts(pkg.scripts).map(
-    (id) => packageDeclaredCheck(id, packagePath, cwd, packageTag(id))
-  );
-  return { kind: "package.json", path: packagePath, checks };
-}
-function discoverDeclaredProjectEntriesAtRoot(workspaceRoot) {
-  const entries = [];
-  const packagePath = path.join(workspaceRoot, "package.json");
-  if (existsSync(packagePath)) {
-    const pkg = parsePackageJson(packagePath);
-    if (pkg.ok) {
-      for (const name of Object.keys(pkg.scripts).sort()) {
-        if (typeof pkg.scripts[name] !== "string") continue;
-        entries.push({
-          id: name,
-          command: ["npm", "run", name],
-          path: "package.json",
-          detail: `package.json script '${name}'`,
-          kind: "package-script"
-        });
-      }
-    }
-  }
-  for (const relative of ["justfile", "Justfile"]) {
-    const filePath = path.join(workspaceRoot, relative);
-    if (!existsSync(filePath)) continue;
-    const text = readFileSync(filePath, "utf8");
-    for (const match of text.matchAll(/^([A-Za-z0-9][A-Za-z0-9_-]*)\s*(?:[^:=\n]*)?:\s*(?:#.*)?$/gmu)) {
-      const name = match[1];
-      if (name === void 0 || name.startsWith("_")) continue;
-      entries.push({
-        id: name,
-        command: ["just", name],
-        path: relative,
-        detail: `just recipe '${name}'`,
-        kind: "just-recipe"
-      });
-    }
-    break;
-  }
-  const makePath = path.join(workspaceRoot, "Makefile");
-  if (existsSync(makePath)) {
-    const text = readFileSync(makePath, "utf8");
-    for (const match of text.matchAll(/^([A-Za-z0-9][A-Za-z0-9_.-]*)\s*:(?![=])[^\n]*$/gmu)) {
-      const name = match[1];
-      if (name === void 0 || name.startsWith(".")) continue;
-      entries.push({
-        id: name,
-        command: ["make", name],
-        path: "Makefile",
-        detail: `Makefile target '${name}'`,
-        kind: "make-target"
-      });
-    }
-  }
-  return entries;
-}
-function providerCollision(sources) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const source of sources) {
-    for (const check of source.checks) {
-      const prior = seen.get(check.id);
-      if (prior !== void 0) {
-        return `duplicate declared check id '${check.id}' from ${prior.source.kind} (${prior.source.path}) and ${check.source.kind} (${check.source.path})`;
-      }
-      seen.set(check.id, check);
-    }
-  }
-  return null;
-}
-function discoverDeclaredChecksAtRoot(workspaceRoot, cwdArg) {
-  let packageRoot;
-  try {
-    packageRoot = resolveSafeCwd(cwdArg, workspaceRoot);
-  } catch (error) {
-    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
-  }
-  const sources = [];
-  const packageSource = packageCheckSource(packageRoot, workspaceRoot);
-  if (packageSource !== null) sources.push(packageSource);
-  const projectCatalog = loadProjectVerifierCatalog(workspaceRoot);
-  if (!projectCatalog.ok) return projectCatalog;
-  if (projectCatalog.source !== null) sources.push(projectCatalog.source);
-  const collision = providerCollision(sources);
-  if (collision !== null) return { ok: false, reason: collision };
-  return { ok: true, sources };
-}
-function discoverDeclaredChecks(cwdArg) {
-  return discoverDeclaredChecksAtRoot(process.cwd(), cwdArg);
-}
-function clonedSources(sources) {
-  return sources.map((source) => ({
-    kind: source.kind,
-    path: source.path,
-    checks: source.checks.map((check) => ({
-      ...check,
-      command: [...check.command],
-      tags: [...check.tags],
-      source: { ...check.source }
-    }))
-  }));
-}
-function listChecks(cwdArg) {
-  const discovery = discoverDeclaredChecks(cwdArg);
-  if (!discovery.ok) return { kind: "error", message: `verify: ${discovery.reason}` };
-  const lines = [];
-  if (discovery.sources.length === 0 || discovery.sources.every((source) => source.checks.length === 0)) {
-    lines.push(
-      `No declared verification checks found (no package.json verification scripts or ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} entries).`,
-      "Run `clio-coder verifiers author` to inspect declared project tooling, preview exact argv checks, and create the catalog after confirmation."
-    );
-  } else {
-    lines.push("Declared verification checks:");
-    for (const source of discovery.sources) {
-      lines.push(source.kind === "package.json" ? "package.json:" : `${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}:`);
-      for (const check of source.checks) {
-        const tags = check.tags.length > 0 ? ` [${check.tags.join(", ")}]` : "";
-        lines.push(`- ${check.id}${tags}: ${check.description}`);
-      }
-    }
-  }
-  lines.push(
-    "",
-    'Run one with verify(check="<id>"). verify(check="frontend", path=<file>) validates an HTML/CSS/JS artifact.'
-  );
-  return {
-    kind: "ok",
-    output: lines.join("\n"),
-    details: { sources: clonedSources(discovery.sources) }
-  };
-}
-function withCommandJudgement(result) {
-  const details = result.details ?? {};
-  if (details.judgement !== void 0) return result;
-  if (!Object.hasOwn(details, "exitCode")) return result;
-  const execution = executionOutcome({
-    aborted: details.aborted === true,
-    timedOut: details.timedOut === true,
-    outputCapped: details.outputCapped === true,
-    exitCode: typeof details.exitCode === "number" ? details.exitCode : null
-  });
-  const validation = execution === "succeeded" || execution === "failed" ? "exit-code" : "not-run";
-  return { ...result, details: { ...details, judgement: judgement(execution, validation) } };
-}
-function withDeclaredEvidence(result, check) {
-  const judged = check.kind === "command" ? withCommandJudgement(result) : result;
-  return {
-    ...judged,
-    details: {
-      ...judged.details,
-      action: "verify",
-      check: check.id,
-      kind: check.kind,
-      source: { ...check.source },
-      description: check.description,
-      declaredCommand: [...check.command],
-      declaredCwd: check.cwd,
-      declaredTimeoutMs: check.timeoutMs,
-      tags: [...check.tags]
-    }
-  };
-}
-function extractNumericPayloadText(output) {
-  const trimmed = output.trim();
-  try {
-    JSON.parse(trimmed);
-    return trimmed;
-  } catch {
-    const start = trimmed.indexOf("{");
-    const end = trimmed.lastIndexOf("}");
-    return start >= 0 && end > start ? trimmed.slice(start, end + 1) : trimmed;
-  }
-}
-function readCheckFile(workspaceRoot, relative, label) {
-  let resolved;
-  try {
-    resolved = resolveSafeCwd(relative, workspaceRoot);
-  } catch (error) {
-    return new Error(`${label} ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!existsSync(resolved)) return new Error(`${label} '${relative}' does not exist`);
-  try {
-    const { size } = statSync(resolved);
-    if (size > JUDGED_CHECK_MAX_OUTPUT_BYTES) {
-      return new Error(`${label} '${relative}' exceeds the ${JUDGED_CHECK_MAX_OUTPUT_BYTES}-byte cap (${size} bytes)`);
-    }
-    return readFileSync(resolved, "utf8");
-  } catch (error) {
-    return new Error(`${label} '${relative}' cannot be read (${error instanceof Error ? error.message : String(error)})`);
-  }
-}
-function judgeNumericTexts(stdout, referenceText, tolerance, referenceLabel, referencePath) {
-  const reference = parseNumericPayload(referenceText, referenceLabel);
-  if (reference instanceof Error) return reference;
-  const payloadText = extractNumericPayloadText(stdout);
-  const actual = parseNumericPayload(payloadText, "command output");
-  if (actual instanceof Error) return actual;
-  return {
-    ...compareNumeric(actual, reference, tolerance),
-    reference: {
-      source: referenceLabel,
-      ...referencePath !== void 0 ? { path: referencePath } : {},
-      sha256: sha256(referenceText),
-      bytes: Buffer.byteLength(referenceText, "utf8")
-    },
-    actual: { sha256: sha256(payloadText), bytes: Buffer.byteLength(payloadText, "utf8") }
-  };
-}
-function judgeNumericCompare(stdout, numeric, workspaceRoot) {
-  const referenceText = readCheckFile(workspaceRoot, numeric.reference, "reference");
-  if (referenceText instanceof Error) return referenceText;
-  return judgeNumericTexts(
-    stdout,
-    referenceText,
-    numeric.tolerance,
-    `reference '${numeric.reference}'`,
-    numeric.reference
-  );
-}
-function judgePerfTexts(measuredMs, perf, baselineText, baselineLabel, options = {}) {
-  let baseline;
-  let provenance;
-  if (perf.baseline !== void 0) {
-    if (baselineText === void 0) {
-      return new Error(`${baselineLabel} is missing; record it with \`clio-coder verifiers baseline <id>\``);
-    }
-    const parsed = parsePerfBaseline(baselineText, baselineLabel);
-    if (parsed instanceof Error) return parsed;
-    baseline = parsed;
-    provenance = {
-      path: perf.baseline,
-      sha256: sha256(baselineText),
-      bytes: Buffer.byteLength(baselineText, "utf8"),
-      ...parsed.recordedAt !== void 0 ? { recordedAt: parsed.recordedAt } : {},
-      ...parsed.check !== void 0 ? { check: parsed.check } : {}
-    };
-  }
-  const report = evaluatePerfBudget(measuredMs, {
-    ...perf.budget !== void 0 ? { budget: perf.budget } : {},
-    ...baseline !== void 0 ? { baseline, environment: options.environment ?? capturePerfEnvironment() } : {},
-    ...perf.tolerance?.relative !== void 0 ? { relative: perf.tolerance.relative } : {}
-  });
-  if (report instanceof Error || provenance === void 0) return report;
-  return { ...report, baseline: provenance };
-}
-function judgePerfBudget(measuredMs, perf, workspaceRoot) {
-  let baselineText;
-  if (perf.baseline !== void 0) {
-    const text = readCheckFile(workspaceRoot, perf.baseline, "baseline");
-    if (text instanceof Error) {
-      return new Error(`${text.message}; record it with \`clio-coder verifiers baseline <id>\``);
-    }
-    baselineText = text;
-  }
-  return judgePerfTexts(measuredMs, perf, baselineText, `baseline '${perf.baseline ?? ""}'`);
-}
-function commandFacts(result) {
-  return {
-    command: [result.file, ...result.args].join(" "),
-    argv: [result.file, ...result.args],
-    cwd: result.cwd,
-    exitCode: result.exitCode,
-    durationMs: result.durationMs,
-    aborted: result.aborted,
-    timedOut: result.timedOut,
-    outputCapped: result.outputCapped
-  };
-}
-async function runJudgedCheck(check, file, vector, cwd, options) {
-  let result;
-  try {
-    result = await runCommandVector(file, vector, {
-      cwd,
-      timeoutMs: check.timeoutMs,
-      maxOutputBytes: JUDGED_CHECK_MAX_OUTPUT_BYTES,
-      ...options?.signal !== void 0 ? { signal: options.signal } : {}
-    });
-  } catch (error) {
-    return { kind: "error", message: `verify: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  const execution = executionOutcome(result);
-  const facts = { ...commandFacts(result), judgement: judgement(execution, "not-run") };
-  if (result.aborted) return { kind: "error", message: "verify: aborted", details: facts };
-  if (result.timedOut) return { kind: "error", message: `verify: timed out after ${check.timeoutMs}ms`, details: facts };
-  if (result.outputCapped) {
-    return {
-      kind: "error",
-      message: `verify: ${check.kind} command output exceeded ${JUDGED_CHECK_MAX_OUTPUT_BYTES} bytes before judgement`,
-      details: facts
-    };
-  }
-  if (result.exitCode !== 0) {
-    const tail = `${result.stdout}${result.stderr}`.trim().slice(-2e3);
-    return {
-      kind: "error",
-      message: `verify: ${check.kind} command exited with code ${result.exitCode ?? "?"} before judgement: ${tail}`,
-      details: facts
-    };
-  }
-  const report = check.kind === "numeric-compare" && check.numeric !== void 0 ? judgeNumericCompare(result.stdout, check.numeric, process.cwd()) : check.kind === "perf-budget" && check.perf !== void 0 ? judgePerfBudget(result.durationMs, check.perf, process.cwd()) : new Error(`declared check '${check.id}' has kind ${check.kind} without its parameters`);
-  if (report instanceof Error) return { kind: "error", message: `verify: ${report.message}`, details: facts };
-  const rendered = report.kind === "numeric-compare" ? renderNumericReport(report) : report.summary;
-  const details = { ...facts, report, judgement: judgement(execution, report.passed ? "passed" : "failed") };
-  if (!report.passed) return { kind: "error", message: `verify: ${rendered}`, details };
-  return { kind: "ok", output: `${rendered}
-`, details };
-}
-async function runProjectCheck(check, options) {
-  const [file, ...vector] = check.command;
-  if (file === void 0) return { kind: "error", message: `verify: declared check '${check.id}' has empty argv` };
-  const cwd = resolveProjectVerifierExecutionCwd(check.cwd, process.cwd());
-  if (cwd instanceof Error) return { kind: "error", message: `verify: ${cwd.message}` };
-  if (check.kind !== "command") {
-    return withDeclaredEvidence(await runJudgedCheck(check, file, vector, cwd, options), check);
-  }
-  const result = await runVectorTool("verify", file, vector, { cwd, timeout_ms: check.timeoutMs }, options);
-  return withDeclaredEvidence(result, check);
-}
-async function recordPerfBaseline(check, options) {
-  if (check.kind !== "perf-budget" || check.perf?.baseline === void 0) {
-    return { ok: false, message: `check '${check.id}' is not a perf-budget check with a baseline path` };
-  }
-  const [file, ...vector] = check.command;
-  if (file === void 0) return { ok: false, message: `declared check '${check.id}' has empty argv` };
-  const cwd = resolveProjectVerifierExecutionCwd(check.cwd, process.cwd());
-  if (cwd instanceof Error) return { ok: false, message: cwd.message };
-  let result;
-  try {
-    result = await runCommandVector(file, vector, {
-      cwd,
-      timeoutMs: check.timeoutMs,
-      maxOutputBytes: JUDGED_CHECK_MAX_OUTPUT_BYTES,
-      ...options?.signal !== void 0 ? { signal: options.signal } : {}
-    });
-  } catch (error) {
-    return { ok: false, message: error instanceof Error ? error.message : String(error) };
-  }
-  const execution = executionOutcome(result);
-  if (execution !== "succeeded") {
-    const ended = execution === "aborted" ? "was aborted" : execution === "timed-out" ? "timed out" : execution === "output-capped" ? `output exceeded ${JUDGED_CHECK_MAX_OUTPUT_BYTES} bytes` : `exited with code ${result.exitCode ?? "?"}`;
-    return { ok: false, message: `command ${ended}; no baseline recorded` };
-  }
-  let target;
-  try {
-    target = resolveSafeCwd(check.perf.baseline, process.cwd());
-  } catch (error) {
-    return { ok: false, message: `baseline ${error instanceof Error ? error.message : String(error)}` };
-  }
-  const recordedAt = (options?.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
-  const environment = options?.environment ?? capturePerfEnvironment();
-  try {
-    mkdirSync(path.dirname(target), { recursive: true });
-    writeFileSync(
-      target,
-      renderPerfBaseline({ wallTimeMs: result.durationMs, check: check.id, recordedAt, environment }),
-      "utf8"
-    );
-  } catch (error) {
-    return {
-      ok: false,
-      message: `cannot write baseline '${check.perf.baseline}' (${error instanceof Error ? error.message : String(error)})`
-    };
-  }
-  return { ok: true, path: check.perf.baseline, wallTimeMs: result.durationMs };
-}
-async function runScriptCheck(check, args, options) {
-  let cwd;
-  try {
-    cwd = resolveSafeCwd(typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : void 0, process.cwd());
-  } catch (error) {
-    return { kind: "error", message: `verify: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  const packagePath = path.join(cwd, "package.json");
-  if (!existsSync(packagePath)) return { kind: "error", message: `verify: package.json not found in ${cwd}` };
-  const pkg = parsePackageJson(packagePath);
-  if (!pkg.ok) return { kind: "error", message: `verify: ${pkg.reason}` };
-  if (!Object.hasOwn(pkg.scripts, check)) {
-    const declared = declaredVerificationScripts(pkg.scripts);
-    const list = declared.length > 0 ? declared.join(", ") : "(none)";
-    return {
-      kind: "error",
-      message: `verify: package.json has no '${check}' script. Declared verification checks: ${list}.`
-    };
-  }
-  const extraArgs = Array.isArray(args.args) ? args.args.filter((entry) => typeof entry === "string") : [];
-  const vector = ["run", check];
-  if (extraArgs.length > 0) vector.push("--", ...extraArgs);
-  return withCommandJudgement(await runVectorTool("verify", "npm", vector, { ...args, cwd }, options));
-}
-function parsePackageJson(packagePath) {
-  try {
-    const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { ok: false, reason: "package.json root must be an object" };
-    }
-    const scripts = parsed.scripts;
-    if (!scripts || typeof scripts !== "object" || Array.isArray(scripts)) {
-      return { ok: false, reason: "package.json has no scripts object" };
-    }
-    return { ok: true, scripts };
-  } catch (error) {
-    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
-  }
-}
-
-export {
-  JUDGED_CHECK_MAX_OUTPUT_BYTES,
-  discoverDeclaredProjectEntriesAtRoot,
-  discoverDeclaredChecksAtRoot,
-  discoverDeclaredChecks,
-  listChecks,
-  judgeNumericTexts,
-  judgePerfTexts,
-  runProjectCheck,
-  recordPerfBaseline,
-  runScriptCheck
-};
-//# sourceMappingURL=chunk-QI72X67S.js.map

package/dist/chunk-QJMRYTCX.js

@@ -1,56 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/providers/probe/fingerprint.ts
-init_esm_shims();
-async function fetchWithTimeout(url, timeoutMs, headers) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { signal: controller.signal, headers });
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function fingerprintNativeRuntime(baseUrl, headers = {}) {
-  const normalized = baseUrl.replace(/^ws:/u, "http:").replace(/^wss:/u, "https:");
-  const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-  const greeting = await fetchWithTimeout(`${trimmed}/lmstudio-greeting`, 750, headers);
-  if (greeting?.ok) {
-    try {
-      const data = await greeting.json();
-      if (data.lmstudio === true) return { runtimeId: "lmstudio", displayName: "LM Studio" };
-    } catch {
-    }
-  }
-  const lmStudioV0 = await fetchWithTimeout(`${trimmed}/api/v0/models`, 750, headers);
-  if (lmStudioV0?.ok) {
-    try {
-      const data = await lmStudioV0.json();
-      if (Array.isArray(data.data) && data.data.some((entry) => typeof entry === "object" && entry !== null && "compatibility_type" in entry)) {
-        return { runtimeId: "lmstudio", displayName: "LM Studio" };
-      }
-    } catch {
-    }
-  }
-  const ollama = await fetchWithTimeout(`${trimmed}/api/version`, 750, headers);
-  if (ollama?.ok) {
-    try {
-      const data = await ollama.json();
-      if (typeof data.version === "string") {
-        return { runtimeId: "ollama-native", displayName: "Ollama" };
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-
-export {
-  fingerprintNativeRuntime
-};
-//# sourceMappingURL=chunk-QJMRYTCX.js.map

package/dist/chunk-QKHZZFKH.js

@@ -1,98 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  printError
-} from "./chunk-KIVFXGBM.js";
-import {
-  MCP_TRUST_ACTION_CLASSES,
-  resolveMcpServers,
-  trustMcpServer,
-  untrustMcpServer
-} from "./chunk-PP23PZEV.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/cli/mcp.ts
-init_esm_shims();
-var HELP = `clio-coder mcp <command>
-
-Commands:
-  clio-coder mcp list [--json]
-  clio-coder mcp trust <id> [--action-class <class>] [--json]
-  clio-coder mcp untrust <id> [--json]
-
-Action classes: ${MCP_TRUST_ACTION_CLASSES.join(", ")}
-
-JSON responses (--json):
-  list: {servers: [...], diagnostics: [...], trustDiagnostics: [...]}
-    Each server includes its declaration and trust {status, actionClass, reason?}.
-  trust: {ok: true, record: {projectRoot, id, digest, actionClass, trustedAt}}
-  untrust: {ok: true, removed: boolean}
-  errors: {ok: false, message: string}
-Exit codes: 0 success; 1 operational failure; 2 invalid usage.
-List retains its response shape on failure and exits 1 when config or trust
- diagnostics are present. Mutation errors return the error shape with a
- one-line reason. --help prints this text even when --json is supplied.
-`;
-function mcpCommandOutput(argv, options = { cwd: process.cwd() }) {
-  const fail = (code, message) => {
-    const text = message.replace(/[\r\n]+/gu, " ");
-    return { code, text, data: { ok: false, message: text } };
-  };
-  try {
-    const [command, id, ...rest] = argv;
-    if (command === "list" && id === void 0) {
-      const result2 = resolveMcpServers(options);
-      const lines = result2.servers.map(
-        (server2) => `${server2.id} scope=${server2.scope} command=${JSON.stringify([server2.command, ...server2.args])} cwd=${JSON.stringify(server2.cwd)} trust=${server2.trust.status}${"reason" in server2.trust ? ` (${server2.trust.reason})` : ""} actionClass=${server2.trust.actionClass}`
-      );
-      lines.push(...result2.diagnostics.map((entry) => `${entry.path}: ${entry.message}`), ...result2.trustDiagnostics);
-      return {
-        code: result2.diagnostics.length || result2.trustDiagnostics.length ? 1 : 0,
-        text: lines.join("\n") || "mcp: none",
-        data: result2
-      };
-    }
-    if (command !== "trust" && command !== "untrust" || !id)
-      return fail(2, "usage: clio-coder mcp list | trust <id> [--action-class <class>] | untrust <id>");
-    let actionClass;
-    if (rest.length) {
-      if (command !== "trust" || rest.length !== 2 || rest[0] !== "--action-class" || !MCP_TRUST_ACTION_CLASSES.includes(rest[1]))
-        return fail(2, `--action-class must be one of ${MCP_TRUST_ACTION_CLASSES.join(", ")} and applies only to trust`);
-      actionClass = rest[1];
-    }
-    if (command === "trust") {
-      const result2 = trustMcpServer({ ...options, id, ...actionClass ? { actionClass } : {} });
-      return result2.ok ? { code: 0, text: `mcp: trusted ${id} ${JSON.stringify(result2.record)}`, data: result2 } : fail(1, result2.message);
-    }
-    const resolved = resolveMcpServers(options);
-    const server = resolved.servers.find((entry) => entry.id === id);
-    if (!server) return fail(1, `no declared MCP server with id '${id}'`);
-    if (server.scope === "user")
-      return fail(1, `server '${id}' is a user-scope declaration; it is trusted by authorship`);
-    const result = untrustMcpServer({ ...options, id });
-    return result.ok ? { code: 0, text: `mcp: untrusted ${id} (record ${result.removed ? "removed" : "already absent"})`, data: result } : fail(1, result.message);
-  } catch (error) {
-    return fail(1, error instanceof Error ? error.message : String(error));
-  }
-}
-function runMcpCommand(argv) {
-  if (argv.includes("--help") || argv.includes("-h")) {
-    process.stdout.write(HELP);
-    return 0;
-  }
-  const json = argv.includes("--json");
-  const result = mcpCommandOutput(argv.filter((arg) => arg !== "--json"));
-  if (json) process.stdout.write(`${JSON.stringify(result.data, null, 2)}
-`);
-  else if (result.code && argv[0] !== "list") printError(result.text);
-  else process.stdout.write(`${result.text}
-`);
-  return result.code;
-}
-
-export {
-  mcpCommandOutput,
-  runMcpCommand
-};
-//# sourceMappingURL=chunk-QKHZZFKH.js.map