poe-code 3.0.186 → 3.0.188

package/packages/cmdkit/dist/cli.js

@@ -1,2331 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/sisteransi/src/index.js
-var require_src = __commonJS({
-  "node_modules/sisteransi/src/index.js"(exports, module) {
-    "use strict";
-    var ESC = "\x1B";
-    var CSI = `${ESC}[`;
-    var beep = "\x07";
-    var cursor = {
-      to(x, y) {
-        if (!y) return `${CSI}${x + 1}G`;
-        return `${CSI}${y + 1};${x + 1}H`;
-      },
-      move(x, y) {
-        let ret = "";
-        if (x < 0) ret += `${CSI}${-x}D`;
-        else if (x > 0) ret += `${CSI}${x}C`;
-        if (y < 0) ret += `${CSI}${-y}A`;
-        else if (y > 0) ret += `${CSI}${y}B`;
-        return ret;
-      },
-      up: (count = 1) => `${CSI}${count}A`,
-      down: (count = 1) => `${CSI}${count}B`,
-      forward: (count = 1) => `${CSI}${count}C`,
-      backward: (count = 1) => `${CSI}${count}D`,
-      nextLine: (count = 1) => `${CSI}E`.repeat(count),
-      prevLine: (count = 1) => `${CSI}F`.repeat(count),
-      left: `${CSI}G`,
-      hide: `${CSI}?25l`,
-      show: `${CSI}?25h`,
-      save: `${ESC}7`,
-      restore: `${ESC}8`
-    };
-    var scroll = {
-      up: (count = 1) => `${CSI}S`.repeat(count),
-      down: (count = 1) => `${CSI}T`.repeat(count)
-    };
-    var erase = {
-      screen: `${CSI}2J`,
-      up: (count = 1) => `${CSI}1J`.repeat(count),
-      down: (count = 1) => `${CSI}J`.repeat(count),
-      line: `${CSI}2K`,
-      lineEnd: `${CSI}K`,
-      lineStart: `${CSI}1K`,
-      lines(count) {
-        let clear = "";
-        for (let i = 0; i < count; i++)
-          clear += this.line + (i < count - 1 ? cursor.up() : "");
-        if (count)
-          clear += cursor.left;
-        return clear;
-      }
-    };
-    module.exports = { cursor, scroll, erase, beep };
-  }
-});
-
-// packages/cmdkit/src/cli.ts
-import { access, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { Command as CommanderCommand, CommanderError, InvalidArgumentError, Option } from "commander";
-
-// packages/design-system/src/tokens/colors.ts
-import chalk from "chalk";
-var dark = {
-  header: (text4) => chalk.magentaBright.bold(text4),
-  divider: (text4) => chalk.dim(text4),
-  prompt: (text4) => chalk.cyan(text4),
-  number: (text4) => chalk.cyanBright(text4),
-  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
-  resolvedSymbol: chalk.magenta("\u25C7"),
-  errorSymbol: chalk.red("\u25A0"),
-  accent: (text4) => chalk.cyan(text4),
-  muted: (text4) => chalk.dim(text4),
-  success: (text4) => chalk.green(text4),
-  warning: (text4) => chalk.yellow(text4),
-  error: (text4) => chalk.red(text4),
-  info: (text4) => chalk.magenta(text4),
-  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
-};
-var light = {
-  header: (text4) => chalk.hex("#a200ff").bold(text4),
-  divider: (text4) => chalk.hex("#666666")(text4),
-  prompt: (text4) => chalk.hex("#006699").bold(text4),
-  number: (text4) => chalk.hex("#0077cc").bold(text4),
-  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
-  resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
-  errorSymbol: chalk.hex("#cc0000")("\u25A0"),
-  accent: (text4) => chalk.hex("#006699").bold(text4),
-  muted: (text4) => chalk.hex("#666666")(text4),
-  success: (text4) => chalk.hex("#008800")(text4),
-  warning: (text4) => chalk.hex("#cc6600")(text4),
-  error: (text4) => chalk.hex("#cc0000")(text4),
-  info: (text4) => chalk.hex("#a200ff")(text4),
-  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
-};
-
-// packages/design-system/src/tokens/typography.ts
-import chalk2 from "chalk";
-var typography = {
-  bold: (text4) => chalk2.bold(text4),
-  dim: (text4) => chalk2.dim(text4),
-  italic: (text4) => chalk2.italic(text4),
-  underline: (text4) => chalk2.underline(text4),
-  strikethrough: (text4) => chalk2.strikethrough(text4)
-};
-
-// packages/design-system/src/tokens/widths.ts
-var widths = {
-  header: 60,
-  helpColumn: 24,
-  maxLine: 80
-};
-
-// packages/design-system/src/components/text.ts
-import chalk3 from "chalk";
-
-// packages/design-system/src/internal/output-format.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
-var formatStorage = new AsyncLocalStorage();
-var cached;
-function resolveOutputFormat(env = process.env) {
-  const scoped = formatStorage.getStore();
-  if (scoped) {
-    return scoped;
-  }
-  if (cached) {
-    return cached;
-  }
-  const raw = env.OUTPUT_FORMAT?.toLowerCase();
-  cached = VALID_FORMATS.has(raw) ? raw : "terminal";
-  return cached;
-}
-function resetOutputFormatCache() {
-  cached = void 0;
-}
-
-// packages/design-system/src/internal/theme-detect.ts
-function detectThemeFromEnv(env) {
-  const apple = env.APPLE_INTERFACE_STYLE;
-  if (typeof apple === "string") {
-    return apple.toLowerCase() === "dark" ? "dark" : "light";
-  }
-  const vscodeKind = env.VSCODE_COLOR_THEME_KIND;
-  if (typeof vscodeKind === "string") {
-    const normalized = vscodeKind.toLowerCase();
-    if (normalized.includes("light")) {
-      return "light";
-    }
-    if (normalized.includes("dark")) {
-      return "dark";
-    }
-  }
-  const colorFGBG = env.COLORFGBG;
-  if (typeof colorFGBG === "string") {
-    const parts = colorFGBG.split(";").map((part) => Number.parseInt(part, 10));
-    const background = parts.at(-1);
-    if (Number.isFinite(background)) {
-      return background >= 8 ? "light" : "dark";
-    }
-  }
-  return void 0;
-}
-function resolveThemeName(env = process.env) {
-  const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
-  if (raw === "light" || raw === "dark") {
-    return raw;
-  }
-  const detected = detectThemeFromEnv(env);
-  if (detected) {
-    return detected;
-  }
-  return "dark";
-}
-var cachedTheme;
-function getTheme(env) {
-  if (cachedTheme) {
-    return cachedTheme;
-  }
-  const themeName = resolveThemeName(env);
-  cachedTheme = themeName === "light" ? light : dark;
-  return cachedTheme;
-}
-
-// packages/design-system/src/components/text.ts
-var text = {
-  intro(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `**${content}**`;
-    return getTheme().intro(content);
-  },
-  heading(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `## ${content}`;
-    return getTheme().header(content);
-  },
-  section(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `**${content}**`;
-    return typography.bold(content);
-  },
-  command(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `\`${content}\``;
-    return getTheme().accent(content);
-  },
-  argument(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `<${content}>`;
-    return getTheme().muted(content);
-  },
-  option(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `\`${content}\``;
-    return chalk3.yellow(content);
-  },
-  example(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `\`${content}\``;
-    return getTheme().muted(content);
-  },
-  usageCommand(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `\`${content}\``;
-    return chalk3.green(content);
-  },
-  link(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `[${content}](${content})`;
-    return getTheme().accent(content);
-  },
-  muted(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `*${content}*`;
-    return getTheme().muted(content);
-  },
-  badge(content) {
-    const format = resolveOutputFormat();
-    if (format === "json") return content;
-    if (format === "markdown") return `[${content}]`;
-    return getTheme().badge(content);
-  },
-  selectLabel(label, detail) {
-    if (!detail) {
-      return label;
-    }
-    const format = resolveOutputFormat();
-    if (format !== "terminal") {
-      return `${label} \u2014 ${detail}`;
-    }
-    return `${label} ${typography.dim("\u2014")} ${typography.dim(detail)}`;
-  }
-};
-
-// packages/design-system/src/components/symbols.ts
-import chalk4 from "chalk";
-var symbols = {
-  get info() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "info";
-    if (format === "markdown") return "(i)";
-    return chalk4.magenta("\u25CF");
-  },
-  get success() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "success";
-    if (format === "markdown") return "[ok]";
-    return chalk4.magenta("\u25C6");
-  },
-  get resolved() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "resolved";
-    if (format === "markdown") return ">";
-    return getTheme().resolvedSymbol;
-  },
-  get errorResolved() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "error";
-    if (format === "markdown") return "[!]";
-    return getTheme().errorSymbol;
-  },
-  get bar() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "";
-    if (format === "markdown") return "|";
-    return "\u2502";
-  },
-  cornerTopRight: "\u256E",
-  cornerBottomRight: "\u256F",
-  get warning() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "warning";
-    if (format === "markdown") return "[!]";
-    return "\u25B2";
-  },
-  get active() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "active";
-    if (format === "markdown") return "[x]";
-    return "\u25C6";
-  },
-  get inactive() {
-    const format = resolveOutputFormat();
-    if (format === "json") return "inactive";
-    if (format === "markdown") return "[ ]";
-    return "\u25CB";
-  }
-};
-
-// packages/design-system/src/components/logger.ts
-import chalk6 from "chalk";
-
-// packages/design-system/src/prompts/primitives/log.ts
-import chalk5 from "chalk";
-
-// packages/design-system/src/internal/strip-ansi.ts
-function stripAnsi(value) {
-  return value.replace(/\u001b\[[0-9;]*m/g, "");
-}
-
-// packages/design-system/src/prompts/primitives/log.ts
-function writeTerminalMessage(msg, {
-  symbol = chalk5.gray("\u2502"),
-  secondarySymbol = chalk5.gray("\u2502"),
-  spacing: spacing2 = 1,
-  withGuide = true
-} = {}) {
-  const lines = [];
-  const showGuide = withGuide !== false;
-  const contentLines = msg.split("\n");
-  const prefix = showGuide ? `${symbol}  ` : "";
-  const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
-  const emptyGuide = showGuide ? secondarySymbol : "";
-  for (let index = 0; index < spacing2; index += 1) {
-    lines.push(emptyGuide);
-  }
-  if (contentLines.length === 0) {
-    process.stdout.write("\n");
-    return;
-  }
-  const [firstLine = "", ...continuationLines] = contentLines;
-  if (firstLine.length > 0) {
-    lines.push(`${prefix}${firstLine}`);
-  } else {
-    lines.push(showGuide ? symbol : "");
-  }
-  for (const line of continuationLines) {
-    if (line.length > 0) {
-      lines.push(`${continuationPrefix}${line}`);
-      continue;
-    }
-    lines.push(emptyGuide);
-  }
-  process.stdout.write(`${lines.join("\n")}
-`);
-}
-function message(msg, options) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "message", message: stripAnsi(msg) })}
-`
-    );
-    return;
-  }
-  writeTerminalMessage(msg, options);
-}
-function info(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **info:** ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "info", message: stripAnsi(msg) })}
-`
-    );
-    return;
-  }
-  message(msg, { symbol: symbols.info });
-}
-function success(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **success:** ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "success", message: stripAnsi(msg) })}
-`
-    );
-    return;
-  }
-  message(msg, { symbol: symbols.success });
-}
-function warn(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **warning:** ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}
-`
-    );
-    return;
-  }
-  message(msg, { symbol: chalk5.yellow("\u25B2") });
-}
-function error(msg) {
-  const format = resolveOutputFormat();
-  if (format === "markdown") {
-    process.stdout.write(`- **error:** ${stripAnsi(msg)}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({ level: "error", message: stripAnsi(msg) })}
-`
-    );
-    return;
-  }
-  message(msg, { symbol: chalk5.red("\u25A0") });
-}
-var log = {
-  info,
-  success,
-  message,
-  warn,
-  error
-};
-
-// packages/design-system/src/components/logger.ts
-function createLogger(emitter) {
-  const emit = (level, message2) => {
-    if (emitter) {
-      emitter(message2);
-      return;
-    }
-    if (level === "success") {
-      log.success(message2);
-      return;
-    }
-    if (level === "warn") {
-      log.warn(message2);
-      return;
-    }
-    if (level === "error") {
-      log.error(message2);
-      return;
-    }
-    log.info(message2);
-  };
-  return {
-    info(message2) {
-      emit("info", message2);
-    },
-    success(message2) {
-      emit("success", message2);
-    },
-    warn(message2) {
-      emit("warn", message2);
-    },
-    error(message2) {
-      emit("error", message2);
-    },
-    resolved(label, value) {
-      if (emitter) {
-        emitter(`${label}: ${value}`);
-        return;
-      }
-      log.message(`${label}
-   ${value}`, { symbol: symbols.resolved });
-    },
-    errorResolved(label, value) {
-      if (emitter) {
-        emitter(`${label}: ${value}`);
-        return;
-      }
-      log.message(`${label}
-   ${value}`, { symbol: symbols.errorResolved });
-    },
-    message(message2, symbol) {
-      if (emitter) {
-        emitter(message2);
-        return;
-      }
-      log.message(message2, { symbol: symbol ?? chalk6.gray("\u2502") });
-    }
-  };
-}
-var logger = createLogger();
-
-// packages/design-system/src/components/help-formatter.ts
-function formatCommand(name, description) {
-  const paddedName = name.padEnd(widths.helpColumn);
-  return `  ${text.command(paddedName)}  ${description}`;
-}
-function formatOption(flags, description) {
-  const paddedFlags = flags.padEnd(widths.helpColumn);
-  return `  ${text.option(paddedFlags)}  ${description}`;
-}
-function formatCommandList(commands) {
-  return commands.map((cmd) => formatCommand(cmd.name, cmd.description)).join("\n");
-}
-function formatOptionList(options) {
-  return options.map((opt) => formatOption(opt.flags, opt.description)).join("\n");
-}
-
-// packages/design-system/src/components/table.ts
-import { Table } from "console-table-printer";
-function renderTableTerminal(options) {
-  const { theme, columns, rows } = options;
-  const table = new Table({
-    style: {
-      headerTop: {
-        left: theme.muted("\u250C"),
-        mid: theme.muted("\u252C"),
-        right: theme.muted("\u2510"),
-        other: theme.muted("\u2500")
-      },
-      headerBottom: {
-        left: theme.muted("\u251C"),
-        mid: theme.muted("\u253C"),
-        right: theme.muted("\u2524"),
-        other: theme.muted("\u2500")
-      },
-      tableBottom: {
-        left: theme.muted("\u2514"),
-        mid: theme.muted("\u2534"),
-        right: theme.muted("\u2518"),
-        other: theme.muted("\u2500")
-      },
-      vertical: theme.muted("\u2502"),
-      rowSeparator: {
-        left: theme.muted("\u251C"),
-        mid: theme.muted("\u253C"),
-        right: theme.muted("\u2524"),
-        other: theme.muted("\u2500")
-      }
-    },
-    columns: columns.map((col) => ({
-      name: col.name,
-      title: theme.header(col.title),
-      alignment: col.alignment,
-      maxLen: col.maxLen
-    }))
-  });
-  for (const row of rows) {
-    table.addRow(row);
-  }
-  return table.render();
-}
-function renderTableMarkdown(options) {
-  const { columns, rows } = options;
-  const header = `| ${columns.map((c) => c.title).join(" | ")} |`;
-  const separator = `| ${columns.map((c) => c.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
-  const dataRows = rows.map(
-    (row) => `| ${columns.map((c) => stripAnsi(row[c.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
-  );
-  return [header, separator, ...dataRows].join("\n");
-}
-function renderTableJson(options) {
-  const { columns, rows } = options;
-  const cleaned = rows.map((row) => {
-    const obj = {};
-    for (const col of columns) {
-      obj[col.name] = stripAnsi(row[col.name] ?? "");
-    }
-    return obj;
-  });
-  return JSON.stringify(cleaned, null, 2);
-}
-function renderTable(options) {
-  const format = resolveOutputFormat();
-  switch (format) {
-    case "markdown":
-      return renderTableMarkdown(options);
-    case "json":
-      return renderTableJson(options);
-    default:
-      return renderTableTerminal(options);
-  }
-}
-
-// packages/design-system/src/acp/components.ts
-import chalk7 from "chalk";
-
-// packages/design-system/src/acp/writer.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var storage = new AsyncLocalStorage2();
-
-// packages/design-system/src/acp/components.ts
-var AGENT_PREFIX = `${chalk7.green.bold("\u2713")} agent: `;
-
-// packages/design-system/src/dashboard/buffer.ts
-import chalk8 from "chalk";
-
-// packages/design-system/src/dashboard/terminal.ts
-import readline from "node:readline";
-import { PassThrough } from "node:stream";
-
-// packages/design-system/src/prompts/index.ts
-import chalk15 from "chalk";
-import * as clack from "@clack/prompts";
-
-// packages/design-system/src/prompts/primitives/cancel.ts
-import chalk9 from "chalk";
-
-// node_modules/@clack/core/dist/index.mjs
-var import_sisteransi = __toESM(require_src(), 1);
-import { stdout as R, stdin as q } from "node:process";
-import * as k from "node:readline";
-import ot from "node:readline";
-import { ReadStream as J } from "node:tty";
-var P = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
-var ct = new RegExp("\\p{M}+", "gu");
-var pt = { limit: 1 / 0, ellipsis: "" };
-var ft = { limit: 1 / 0, ellipsis: "", ellipsisWidth: 0 };
-var j = "\x07";
-var Q = "[";
-var dt = "]";
-var U = `${dt}8;;`;
-var et = new RegExp(`(?:\\${Q}(?<code>\\d+)m|\\${U}(?<uri>.*)${j})`, "y");
-var At = ["up", "down", "left", "right", "space", "enter", "cancel"];
-var _ = { actions: new Set(At), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true };
-var bt = globalThis.process.platform.startsWith("win");
-var z = /* @__PURE__ */ Symbol("clack:cancel");
-function Ct(t) {
-  return t === z;
-}
-
-// packages/design-system/src/prompts/primitives/cancel.ts
-function cancel(msg = "") {
-  if (resolveOutputFormat() !== "terminal") {
-    return;
-  }
-  process.stdout.write(`${chalk9.gray("\u2514")}  ${chalk9.red(msg)}
-
-`);
-}
-
-// packages/design-system/src/prompts/primitives/intro.ts
-import chalk10 from "chalk";
-
-// packages/design-system/src/prompts/primitives/note.ts
-import chalk11 from "chalk";
-function getVisibleWidth(value) {
-  return stripAnsi(value).length;
-}
-function renderTerminalNote(message2, title) {
-  const contentLines = ["", ...message2.split("\n"), ""];
-  const visibleTitle = stripAnsi(title ?? "");
-  const contentWidth = Math.max(
-    visibleTitle.length,
-    ...contentLines.map((line) => getVisibleWidth(line))
-  ) + 2;
-  const titleLine = `${chalk11.green("\u25C7")}  ${chalk11.reset(title ?? "")} ${chalk11.gray(
-    `${"\u2500".repeat(Math.max(contentWidth - visibleTitle.length - 1, 1))}\u256E`
-  )}`;
-  const content = contentLines.map((line) => {
-    const padding = " ".repeat(contentWidth - getVisibleWidth(line));
-    return `${chalk11.gray("\u2502")}  ${line}${padding}${chalk11.gray("\u2502")}`;
-  });
-  const bottom = chalk11.gray(`\u251C${"\u2500".repeat(contentWidth + 2)}\u256F`);
-  return [chalk11.gray("\u2502"), titleLine, ...content, bottom].join("\n");
-}
-function note(message2, title) {
-  const format = resolveOutputFormat();
-  const strippedMessage = stripAnsi(message2);
-  const strippedTitle = stripAnsi(title ?? "");
-  if (format === "markdown") {
-    const lines = strippedMessage.split("\n");
-    const heading = strippedTitle ? `> **${strippedTitle}**
-` : "";
-    const body = lines.map((line) => `> ${line}`).join("\n");
-    process.stdout.write(`${heading}${body}
-`);
-    return;
-  }
-  if (format === "json") {
-    process.stdout.write(
-      `${JSON.stringify({
-        type: "note",
-        title: strippedTitle,
-        message: strippedMessage
-      })}
-`
-    );
-    return;
-  }
-  process.stdout.write(`${renderTerminalNote(message2, title)}
-`);
-}
-
-// packages/design-system/src/prompts/primitives/outro.ts
-import chalk12 from "chalk";
-
-// packages/design-system/src/prompts/primitives/spinner.ts
-import chalk14 from "chalk";
-
-// packages/design-system/src/static/spinner.ts
-import chalk13 from "chalk";
-
-// packages/design-system/src/prompts/index.ts
-async function select2(opts) {
-  return clack.select(opts);
-}
-async function text3(opts) {
-  return clack.text(opts);
-}
-async function confirm2(opts) {
-  return clack.confirm(opts);
-}
-
-// packages/design-system/src/static/menu.ts
-import chalk16 from "chalk";
-
-// packages/cmdkit/src/index.ts
-import { fileURLToPath } from "node:url";
-var commandSourcePathSymbol = /* @__PURE__ */ Symbol("cmdkit.command.sourcePath");
-var UserError = class extends Error {
-  constructor(message2) {
-    super(message2);
-    this.name = "UserError";
-  }
-};
-function parseSimpleSemver(value) {
-  const parts = value.split(".");
-  if (parts.length !== 3) {
-    return void 0;
-  }
-  const parsed = parts.map((part) => {
-    if (part.length === 0) {
-      return Number.NaN;
-    }
-    for (const char of part) {
-      if (char < "0" || char > "9") {
-        return Number.NaN;
-      }
-    }
-    return Number(part);
-  });
-  if (parsed.some((part) => !Number.isInteger(part) || part < 0)) {
-    return void 0;
-  }
-  return parsed;
-}
-function parseMinimumApiVersion(requirement) {
-  if (!requirement.startsWith(">=")) {
-    return void 0;
-  }
-  return parseSimpleSemver(requirement.slice(2).trim());
-}
-function compareSemver(left, right) {
-  for (let index = 0; index < left.length; index += 1) {
-    if (left[index] === right[index]) {
-      continue;
-    }
-    return left[index] > right[index] ? 1 : -1;
-  }
-  return 0;
-}
-function resolveCommandSecrets(command, env = process.env) {
-  const secrets = {};
-  for (const [name, secret] of Object.entries(command.secrets)) {
-    const value = env[secret.env];
-    if (value === void 0 && secret.optional !== true) {
-      const details = secret.description ? `
-  ${secret.description}` : "";
-      throw new UserError(`Error: Missing required secret ${secret.env}${details}`);
-    }
-    secrets[name] = value;
-  }
-  return secrets;
-}
-async function assertCommandRequirements(command, context, options = {}) {
-  const requires = command.requires;
-  if (requires === void 0) {
-    return;
-  }
-  const env = options.env ?? process.env;
-  const authEnvVar = options.authEnvVar ?? "POE_API_KEY";
-  if (requires.auth === true && env[authEnvVar] === void 0) {
-    throw new UserError(
-      `Error: Command "${command.name}" requires authentication.
-  Run 'poe-code login' first.`
-    );
-  }
-  if (requires.apiVersion !== void 0) {
-    const minimumVersion = parseMinimumApiVersion(requires.apiVersion);
-    if (minimumVersion === void 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" has invalid apiVersion requirement "${requires.apiVersion}". Expected format ">=X.Y.Z".`
-      );
-    }
-    if (options.apiVersion === void 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" requires API version ${requires.apiVersion}, but no runner API version was provided.`
-      );
-    }
-    const runnerVersion = parseSimpleSemver(options.apiVersion);
-    if (runnerVersion === void 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version "${options.apiVersion}" is not valid semver.`
-      );
-    }
-    if (compareSemver(runnerVersion, minimumVersion) < 0) {
-      throw new UserError(
-        `Error: Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version is ${options.apiVersion}.`
-      );
-    }
-  }
-  const checkResult = await requires.check?.(context);
-  if (checkResult && !checkResult.ok) {
-    throw new UserError(checkResult.message ?? "Command precondition failed.");
-  }
-}
-function getCommandSourcePath(command) {
-  return command[commandSourcePathSymbol];
-}
-
-// packages/cmdkit/src/number-schema.ts
-function isValidNumberSchemaValue(value, schema) {
-  return typeof value === "number" && Number.isFinite(value) && (schema.jsonType !== "integer" || Number.isInteger(value));
-}
-function getExpectedNumberDescription(schema) {
-  return schema.jsonType === "integer" ? "an integer" : "a number";
-}
-
-// packages/cmdkit/src/renderer.ts
-function isObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isArrayOfObjects(value) {
-  return Array.isArray(value) && value.every((entry) => isObject(entry));
-}
-function stringifyValue(value) {
-  if (value === void 0) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  return stringifyJson(value);
-}
-function stringifyJson(value, spaces) {
-  try {
-    return JSON.stringify(
-      value,
-      (_key, currentValue) => typeof currentValue === "bigint" ? currentValue.toString() : currentValue,
-      spaces
-    ) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function renderObjectTable(result, primitives) {
-  const rows = Object.entries(result).map(([key, value]) => ({
-    key,
-    value: stringifyValue(value)
-  }));
-  return primitives.renderTable({
-    theme: primitives.getTheme(),
-    columns: [
-      {
-        name: "key",
-        title: "Key",
-        alignment: "left",
-        maxLen: Math.max("Key".length, ...rows.map((row) => row.key.length))
-      },
-      {
-        name: "value",
-        title: "Value",
-        alignment: "left",
-        maxLen: Math.max("Value".length, ...rows.map((row) => row.value.length))
-      }
-    ],
-    rows
-  });
-}
-function renderObjectMarkdown(result) {
-  return Object.entries(result).map(([key, value]) => `- ${key}: ${stringifyValue(value)}`).join("\n");
-}
-function getColumnNames(rows) {
-  const names = /* @__PURE__ */ new Set();
-  for (const row of rows) {
-    for (const name of Object.keys(row)) {
-      names.add(name);
-    }
-  }
-  return [...names];
-}
-function renderArrayTable(result, primitives) {
-  if (result.length === 0) {
-    return "[]";
-  }
-  const columnNames = getColumnNames(result);
-  return primitives.renderTable({
-    theme: primitives.getTheme(),
-    columns: columnNames.map((name) => ({
-      name,
-      title: name,
-      alignment: "left",
-      maxLen: Math.max(
-        name.length,
-        ...result.map((row) => name in row ? stringifyValue(row[name]).length : 0)
-      )
-    })),
-    rows: result.map(
-      (row) => Object.fromEntries(
-        columnNames.map((name) => [name, name in row ? stringifyValue(row[name]) : ""])
-      )
-    )
-  });
-}
-function renderArrayMarkdown(result) {
-  if (result.length === 0) {
-    return "[]";
-  }
-  const columnNames = getColumnNames(result);
-  const header = `| ${columnNames.join(" | ")} |`;
-  const separator = `| ${columnNames.map(() => ":---").join(" | ")} |`;
-  const rows = result.map(
-    (row) => `| ${columnNames.map((name) => name in row ? stringifyValue(row[name]).replaceAll("|", "\\|") : "").join(" | ")} |`
-  );
-  return [header, separator, ...rows].join("\n");
-}
-function autoRender(result, output, primitives) {
-  if (result === null || result === void 0) {
-    if (output === "json") {
-      return stringifyJson({ ok: true }, 2);
-    }
-    return "Done.";
-  }
-  if (typeof result === "string") {
-    if (output === "json") {
-      return stringifyJson({ result }, 2);
-    }
-    return result;
-  }
-  if (isObject(result)) {
-    if (output === "rich") {
-      return renderObjectTable(result, primitives);
-    }
-    if (output === "md") {
-      return renderObjectMarkdown(result);
-    }
-    return stringifyJson(result, 2);
-  }
-  if (isArrayOfObjects(result)) {
-    if (output === "md") {
-      return renderArrayMarkdown(result);
-    }
-    if (output === "json") {
-      return stringifyJson(result, 2);
-    }
-    return renderArrayTable(result, primitives);
-  }
-  return stringifyJson(result, 2);
-}
-function renderResult(command, result, output, primitives, write = (chunk) => {
-  process.stdout.write(chunk);
-}) {
-  if (output === "json" && command.render?.json) {
-    const payload2 = command.render.json(result, primitives);
-    if (payload2 !== void 0) {
-      write(`${stringifyJson(payload2, 2)}
-`);
-    }
-    return;
-  }
-  if (output === "md" && command.render?.markdown) {
-    const payload2 = command.render.markdown(result, primitives);
-    if (typeof payload2 === "string" && payload2.length > 0) {
-      write(`${payload2}
-`);
-    }
-    return;
-  }
-  if (output === "rich" && command.render?.rich) {
-    command.render.rich(result, primitives);
-    return;
-  }
-  const payload = autoRender(result, output, primitives);
-  if (payload.length > 0) {
-    write(`${payload}
-`);
-  }
-}
-
-// packages/cmdkit/src/cli.ts
-var RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
-function inferProgramName(argv) {
-  const entrypoint = argv[1];
-  if (typeof entrypoint !== "string" || entrypoint.length === 0) {
-    return "cmdkit";
-  }
-  const parsed = path.parse(entrypoint);
-  return parsed.name.length > 0 ? parsed.name : "cmdkit";
-}
-function normalizeRoots(roots, argv) {
-  if (!Array.isArray(roots)) {
-    return roots;
-  }
-  return {
-    kind: "group",
-    name: inferProgramName(argv),
-    aliases: [],
-    secrets: {},
-    children: roots
-  };
-}
-var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
-function unwrapOptional(schema) {
-  if (schema.kind === "optional") {
-    return unwrapOptional(schema.inner);
-  }
-  return schema;
-}
-function splitWords(value) {
-  const words = [];
-  let current = "";
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index] ?? "";
-    const lower = char.toLowerCase();
-    const upper = char.toUpperCase();
-    const isSeparator = char === "-" || char === "_" || char === " " || char === ".";
-    if (isSeparator) {
-      if (current.length > 0) {
-        words.push(current.toLowerCase());
-        current = "";
-      }
-      continue;
-    }
-    const isUppercase = char !== lower && char === upper;
-    const previous = value[index - 1];
-    const next = value[index + 1];
-    const previousIsLowercase = previous !== void 0 && previous === previous.toLowerCase() && previous !== previous.toUpperCase();
-    const nextIsLowercase = next !== void 0 && next === next.toLowerCase() && next !== next.toUpperCase();
-    if (isUppercase && current.length > 0 && (previousIsLowercase || nextIsLowercase)) {
-      words.push(current.toLowerCase());
-      current = char;
-      continue;
-    }
-    current += char;
-  }
-  if (current.length > 0) {
-    words.push(current.toLowerCase());
-  }
-  return words;
-}
-function formatSegment(segment, casing) {
-  const separator = casing === "snake" ? "_" : "-";
-  return splitWords(segment).join(separator);
-}
-function toOptionFlag(path2, casing) {
-  return `--${path2.map((segment) => formatSegment(segment, casing)).join(".")}`;
-}
-function toOptionAttribute(path2, casing) {
-  return path2.map((segment) => {
-    const formatted = formatSegment(segment, casing);
-    if (casing === "snake") {
-      return formatted;
-    }
-    const words = formatted.split("-");
-    return words.map(
-      (word, index) => index === 0 ? word : `${word[0]?.toUpperCase() ?? ""}${word.slice(1)}`
-    ).join("");
-  }).join(".");
-}
-function toDisplayPath(path2) {
-  return path2.join(".");
-}
-function collectFields(schema, casing, path2 = [], inheritedOptional = false) {
-  const fields = [];
-  for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path2, key];
-    const optional = inheritedOptional || rawChildSchema.kind === "optional";
-    const childSchema = unwrapOptional(rawChildSchema);
-    if (childSchema.kind === "object") {
-      fields.push(...collectFields(childSchema, casing, nextPath, optional));
-      continue;
-    }
-    fields.push({
-      path: nextPath,
-      displayPath: toDisplayPath(nextPath),
-      optionAttribute: toOptionAttribute(nextPath, casing),
-      commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing),
-      optionFlag: toOptionFlag(nextPath, casing),
-      shortFlag: childSchema.short,
-      schema: childSchema,
-      description: childSchema.description,
-      optional,
-      hasDefault: childSchema.default !== void 0,
-      defaultValue: childSchema.default
-    });
-  }
-  return fields;
-}
-function toCommanderOptionAttribute(path2, casing) {
-  const optionAttribute = toOptionAttribute(path2, casing);
-  const optionFlag = toOptionFlag(path2, casing);
-  if (!GLOBAL_LONG_OPTION_FLAGS.has(optionFlag)) {
-    return optionAttribute;
-  }
-  return `param_${optionAttribute}`;
-}
-function assignPositionals(fields, positional) {
-  if (positional.length === 0) {
-    return fields;
-  }
-  const byPath = new Map(fields.map((field) => [field.displayPath, field]));
-  let variadicPositionSeen = false;
-  positional.forEach((name, index) => {
-    const field = byPath.get(name);
-    if (field === void 0) {
-      throw new UserError(`Positional parameter "${name}" does not exist in params.`);
-    }
-    if (field.schema.kind === "array") {
-      if (index !== positional.length - 1) {
-        throw new UserError(`Positional array parameter "${name}" must be the last positional.`);
-      }
-      variadicPositionSeen = true;
-    }
-    if (variadicPositionSeen && field.schema.kind !== "array") {
-      throw new UserError(`Positional parameter "${name}" cannot appear after a positional array.`);
-    }
-    field.positionalIndex = index;
-    field.variadicPosition = field.schema.kind === "array";
-  });
-  return fields;
-}
-function formatOptionFlags(field) {
-  const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
-  if (collidesWithGlobalFlag) {
-    if (field.shortFlag === void 0) {
-      throw new UserError(
-        `Parameter "${field.displayPath}" uses reserved CLI flag "${field.optionFlag}". Add a short flag or rename the parameter.`
-      );
-    }
-    return `-${field.shortFlag}`;
-  }
-  if (field.shortFlag === void 0) {
-    return field.optionFlag;
-  }
-  return `-${field.shortFlag}, ${field.optionFlag}`;
-}
-function formatPositionalToken(field) {
-  const optionalPositional = field.optional || field.hasDefault;
-  if (field.variadicPosition === true) {
-    return optionalPositional ? `[${field.displayPath}...]` : `<${field.displayPath}...>`;
-  }
-  return optionalPositional ? `[${field.displayPath}]` : `<${field.displayPath}>`;
-}
-function parseBooleanText(value, label) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "true") {
-    return true;
-  }
-  if (normalized === "false") {
-    return false;
-  }
-  throw new InvalidArgumentError(`Invalid value for "${label}". Expected true or false.`);
-}
-function parseEnumValue(value, values, label) {
-  const match = values.find((candidate) => String(candidate) === value);
-  if (match === void 0) {
-    throw new InvalidArgumentError(
-      `Invalid value for "${label}". Expected one of: ${values.map((candidate) => String(candidate)).join(", ")}.`
-    );
-  }
-  return match;
-}
-function parseScalarValue(value, schema, label) {
-  switch (schema.kind) {
-    case "string":
-      return value;
-    case "number": {
-      const parsed = Number(value);
-      if (!isValidNumberSchemaValue(parsed, schema)) {
-        throw new InvalidArgumentError(
-          `Invalid value for "${label}". Expected ${getExpectedNumberDescription(schema)}.`
-        );
-      }
-      return parsed;
-    }
-    case "boolean":
-      return parseBooleanText(value, label);
-    case "enum":
-      return parseEnumValue(value, schema.values, label);
-    default:
-      throw new UserError(`Unsupported CLI schema kind "${schema.kind}".`);
-  }
-}
-function splitArrayInput(value) {
-  const items = [];
-  let current = "";
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index] ?? "";
-    if (char === ",") {
-      const trimmed2 = current.trim();
-      if (trimmed2.length > 0) {
-        items.push(trimmed2);
-      }
-      current = "";
-      continue;
-    }
-    current += char;
-  }
-  const trimmed = current.trim();
-  if (trimmed.length > 0) {
-    items.push(trimmed);
-  }
-  return items;
-}
-function parseArrayValue(value, schema, label) {
-  const itemSchema = unwrapOptional(schema.item);
-  if (itemSchema.kind === "array" || itemSchema.kind === "object") {
-    throw new UserError(`Array parameter "${label}" must use scalar items.`);
-  }
-  return splitArrayInput(value).map((item) => parseScalarValue(item, itemSchema, label));
-}
-function createOption(field) {
-  const flags = formatOptionFlags(field);
-  const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
-  if (field.schema.kind === "boolean") {
-    if (collidesWithGlobalFlag) {
-      return [createCommanderOption(flags, field.description, field)];
-    }
-    const mainOption = createCommanderOption(`${flags} [value]`, field.description, field);
-    mainOption.preset(true);
-    mainOption.argParser(
-      (value) => typeof value === "boolean" ? value : parseBooleanText(value, field.displayPath)
-    );
-    return [
-      mainOption,
-      createCommanderOption(`--no-${field.optionFlag.slice(2)}`, field.description, field)
-    ];
-  }
-  if (field.schema.kind === "array") {
-    return [
-      createCommanderOption(`${flags} <value...>`, field.description, field).argParser(
-        (value, previous = []) => [
-          ...previous,
-          ...parseArrayValue(value, field.schema, field.displayPath)
-        ]
-      )
-    ];
-  }
-  const option = createCommanderOption(`${flags} <value>`, field.description, field);
-  if (field.schema.kind === "enum" && field.schema.values.every((value) => typeof value === "string")) {
-    option.choices([...field.schema.values]);
-  }
-  option.argParser((value) => parseScalarValue(value, field.schema, field.displayPath));
-  return [option];
-}
-var GLOBAL_LONG_OPTION_FLAGS = /* @__PURE__ */ new Set(["--preset", "--yes", "--output", "--verbose"]);
-function createCommanderOption(flags, description, field) {
-  const option = new Option(flags, description);
-  if (field.commanderOptionAttribute !== field.optionAttribute) {
-    option.attributeName = () => field.commanderOptionAttribute;
-  }
-  return option;
-}
-function hasHelpFlag(argv) {
-  return argv.some((token) => HELP_FLAGS.has(token));
-}
-function resolveHelpOutput(argv) {
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index] ?? "";
-    if (token === "--output") {
-      const value = argv[index + 1];
-      if (value === "rich" || value === "md" || value === "json") {
-        return value;
-      }
-      if (value === "markdown") {
-        return "md";
-      }
-      continue;
-    }
-    if (token.startsWith("--output=")) {
-      const value = token.slice("--output=".length);
-      if (value === "rich" || value === "md" || value === "json") {
-        return value;
-      }
-      if (value === "markdown") {
-        return "md";
-      }
-    }
-  }
-  return "rich";
-}
-function isNodeVisibleInScope(node, scope) {
-  if (node.kind === "command") {
-    return node.scope.includes(scope);
-  }
-  return getVisibleChildren(node, scope).length > 0 || Boolean(node.default && node.default.scope.includes(scope)) || node.scope === void 0 || node.scope.includes(scope);
-}
-function getVisibleChildren(group, scope) {
-  return group.children.filter((child) => isNodeVisibleInScope(child, scope));
-}
-function findVisibleChild(group, token, scope) {
-  return getVisibleChildren(group, scope).find(
-    (child) => child.name === token || child.aliases.includes(token)
-  );
-}
-function resolveHelpTarget(root, argv, scope, rootDisplayName) {
-  const breadcrumb = [rootDisplayName ?? root.name];
-  let current = root;
-  for (const token of argv.slice(2)) {
-    if (token.startsWith("-") || token === "help") {
-      break;
-    }
-    if (current.kind !== "group") {
-      break;
-    }
-    const child = findVisibleChild(
-      current,
-      token,
-      scope
-    );
-    if (child === void 0) {
-      break;
-    }
-    breadcrumb.push(child.name);
-    current = child;
-  }
-  return {
-    breadcrumb,
-    node: current
-  };
-}
-function describeSchemaType(schema) {
-  switch (schema.kind) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "enum":
-      return "value";
-    case "array":
-      return `${describeSchemaType(unwrapOptional(schema.item))}...`;
-    default:
-      throw new UserError("Unsupported CLI schema kind.");
-  }
-}
-function formatHelpFieldFlags(field) {
-  if (field.positionalIndex !== void 0) {
-    return formatPositionalToken(field);
-  }
-  if (field.schema.kind === "boolean") {
-    return `${formatOptionFlags(field)} [value]`;
-  }
-  return `${formatOptionFlags(field)} <${describeSchemaType(field.schema)}>`;
-}
-function appendHelpMetadata(description, metadata) {
-  if (metadata.length === 0) {
-    return description;
-  }
-  if (description.length === 0) {
-    return `(${metadata.join(", ")})`;
-  }
-  return `${description} (${metadata.join(", ")})`;
-}
-function formatHelpFieldDescription(field) {
-  const description = field.description ?? field.displayPath;
-  const metadata = [];
-  if (!field.optional && !field.hasDefault) {
-    metadata.push("required");
-  }
-  if (field.hasDefault) {
-    metadata.push(`default: ${formatResolvedValue(field.defaultValue)}`);
-  }
-  return appendHelpMetadata(description, metadata);
-}
-function formatSecretRows(secrets) {
-  return Object.values(secrets).map((secret) => ({
-    flags: secret.env,
-    description: formatSecretDescription(secret)
-  }));
-}
-function formatSecretDescription(secret) {
-  if (secret.description !== void 0 && secret.description.length > 0) {
-    return secret.description;
-  }
-  return secret.optional === true ? "Optional secret" : "Required secret";
-}
-function formatCommandRows(group, scope) {
-  return getVisibleChildren(group, scope).map((child) => ({
-    name: child.aliases.length === 0 ? child.name : `${child.name} (${child.aliases.join(", ")})`,
-    description: child.description ?? ""
-  }));
-}
-function formatGlobalOptionRows(showVersion) {
-  const rows = [
-    {
-      flags: "--preset <path>",
-      description: "Load parameter defaults from a JSON file"
-    },
-    {
-      flags: "--yes",
-      description: "Accept defaults, skip prompts"
-    },
-    {
-      flags: "--output <format>",
-      description: "Output format (rich, md, json)"
-    },
-    {
-      flags: "-h, --help",
-      description: "Show help"
-    }
-  ];
-  if (showVersion) {
-    rows.push({
-      flags: "--version",
-      description: "Show version"
-    });
-  }
-  return rows;
-}
-function renderHelpSections(sections) {
-  return sections.filter((section) => section.length > 0).join("\n\n");
-}
-function buildUsageLine(breadcrumb, rootUsageName, suffix) {
-  if (rootUsageName === void 0) {
-    return void 0;
-  }
-  const subPath = breadcrumb.slice(1).join(" ");
-  return subPath ? `${rootUsageName} ${subPath} ${suffix}` : `${rootUsageName} ${suffix}`;
-}
-function renderGroupHelp(group, breadcrumb, scope, showVersion, rootUsageName) {
-  const sections = [];
-  const commandRows = formatCommandRows(group, scope);
-  if (commandRows.length > 0) {
-    sections.push(`${text.section("Commands:")}
-${formatCommandList(commandRows)}`);
-  }
-  sections.push(`${text.section("Global options:")}
-${formatOptionList(formatGlobalOptionRows(showVersion))}`);
-  return renderHelpDocument({
-    breadcrumb,
-    usageLine: buildUsageLine(breadcrumb, rootUsageName, "[options] [command]"),
-    description: group.description,
-    requiresAuth: group.requires?.auth === true,
-    sections
-  });
-}
-function renderLeafHelp(command, breadcrumb, casing, rootUsageName) {
-  const sections = [];
-  const fields = assignPositionals(collectFields(command.params, casing), command.positional);
-  const optionRows = fields.map((field) => ({
-    flags: formatHelpFieldFlags(field),
-    description: formatHelpFieldDescription(field)
-  }));
-  if (optionRows.length > 0) {
-    sections.push(`${text.section("Options:")}
-${formatOptionList(optionRows)}`);
-  }
-  sections.push(`${text.section("Global options:")}
-${formatOptionList(formatGlobalOptionRows(false))}`);
-  const secretRows = formatSecretRows(command.secrets);
-  if (secretRows.length > 0) {
-    sections.push(`${text.section("Secrets (via environment):")}
-${formatOptionList(secretRows)}`);
-  }
-  const positionalFields = fields.filter((f) => f.positionalIndex !== void 0);
-  const usageSuffix = positionalFields.length > 0 ? `[options] ${positionalFields.map(formatPositionalToken).join(" ")}` : "[options]";
-  return renderHelpDocument({
-    breadcrumb,
-    usageLine: buildUsageLine(breadcrumb, rootUsageName, usageSuffix),
-    description: command.description,
-    requiresAuth: command.requires?.auth === true,
-    sections
-  });
-}
-function renderHelpDocument(input) {
-  const lines = [text.heading(input.breadcrumb.join(" ")), ""];
-  if (input.usageLine !== void 0) {
-    lines.push(`${text.section("Usage:")} ${text.usageCommand(input.usageLine)}`, "");
-  }
-  if (input.description !== void 0) {
-    lines.push(input.description);
-  }
-  if (input.requiresAuth) {
-    lines.push("Requires: authentication");
-  }
-  if (input.description !== void 0 || input.requiresAuth) {
-    lines.push("");
-  }
-  lines.push(renderHelpSections(input.sections));
-  return `${lines.join("\n").trimEnd()}
-`;
-}
-async function renderGeneratedHelp(root, argv, options) {
-  const target = resolveHelpTarget(root, argv, "cli", options.rootDisplayName);
-  const output = resolveHelpOutput(argv);
-  const casing = options.casing ?? "kebab";
-  await withOutputFormat2(output, async () => {
-    const rendered = target.node.kind === "group" ? renderGroupHelp(target.node, target.breadcrumb, "cli", options.version !== void 0, options.rootUsageName) : renderLeafHelp(target.node, target.breadcrumb, casing, options.rootUsageName);
-    process.stdout.write(rendered);
-  });
-}
-function createNodeCommand(node, casing, execute) {
-  if (node.kind === "command") {
-    if (!node.scope.includes("cli")) {
-      return null;
-    }
-    const command = new CommanderCommand(node.name);
-    const fields = assignPositionals(collectFields(node.params, casing), node.positional);
-    if (node.description !== void 0) {
-      command.description(node.description);
-    }
-    node.aliases.forEach((alias) => command.alias(alias));
-    command.addHelpCommand(false);
-    addGlobalOptions(command);
-    for (const field of fields) {
-      if (field.positionalIndex !== void 0) {
-        command.argument(formatPositionalToken(field));
-        continue;
-      }
-      for (const option of createOption(field)) {
-        command.addOption(option);
-      }
-    }
-    command.action(async (...args) => {
-      const actionCommand = args[args.length - 1];
-      const positionalValues = args.slice(0, -2);
-      await execute({
-        command: node,
-        fields,
-        positionalValues,
-        actionCommand
-      });
-    });
-    return command;
-  }
-  if (!isNodeVisibleInScope(node, "cli")) {
-    return null;
-  }
-  const visibleChildren = node.children.map((child) => createNodeCommand(child, casing, execute)).filter((child) => child !== null);
-  const group = new CommanderCommand(node.name);
-  if (node.description !== void 0) {
-    group.description(node.description);
-  }
-  node.aliases.forEach((alias) => group.alias(alias));
-  group.addHelpCommand(false);
-  addGlobalOptions(group);
-  for (const child of visibleChildren) {
-    const isDefaultChild = node.default !== void 0 && node.default.scope.includes("cli") && (child.name() === node.default.name || child.aliases().includes(node.default.name));
-    group.addCommand(child, isDefaultChild ? { isDefault: true } : void 0);
-  }
-  return group;
-}
-function addGlobalOptions(command) {
-  command.option("--preset <path>", "Load parameter defaults from a JSON file.").option("--yes", "Accept defaults and skip prompts.").option("--output <format>", "Output format.", (value) => {
-    if (value === "rich" || value === "md" || value === "json") {
-      return value;
-    }
-    if (value === "markdown") {
-      return "md";
-    }
-    throw new InvalidArgumentError('Invalid value for "--output". Expected one of: rich, md, markdown, json.');
-  }).option("--verbose", "Print stack traces for unexpected errors.");
-}
-function setNestedValue(target, path2, value) {
-  let cursor = target;
-  for (let index = 0; index < path2.length - 1; index += 1) {
-    const segment = path2[index] ?? "";
-    const existing = cursor[segment];
-    if (typeof existing === "object" && existing !== null) {
-      cursor = existing;
-      continue;
-    }
-    const next = {};
-    cursor[segment] = next;
-    cursor = next;
-  }
-  const leaf = path2[path2.length - 1];
-  if (leaf !== void 0) {
-    cursor[leaf] = value;
-  }
-}
-function formatResolvedValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => String(item)).join(", ");
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  return JSON.stringify(value);
-}
-async function promptForField(field) {
-  const schema = field.schema;
-  if (schema.kind === "enum") {
-    const options = schema.loadOptions ? await schema.loadOptions() : schema.values.map((value) => ({
-      label: schema.labels?.[String(value)] ?? String(value),
-      value
-    }));
-    const selected = await select2({
-      message: field.description ?? field.displayPath,
-      options,
-      initialValue: field.hasDefault ? field.defaultValue : void 0
-    });
-    if (Ct(selected)) {
-      cancel("Operation cancelled.");
-      throw new UserError("Operation cancelled.");
-    }
-    return selected;
-  }
-  if (field.schema.kind === "boolean") {
-    const selected = await confirm2({
-      message: field.displayPath,
-      initialValue: field.hasDefault ? Boolean(field.defaultValue) : void 0
-    });
-    if (Ct(selected)) {
-      cancel("Operation cancelled.");
-      throw new UserError("Operation cancelled.");
-    }
-    return selected;
-  }
-  const entered = await text3({
-    message: field.displayPath,
-    initialValue: field.hasDefault && field.defaultValue !== void 0 ? formatResolvedValue(field.defaultValue) : void 0
-  });
-  if (Ct(entered)) {
-    cancel("Operation cancelled.");
-    throw new UserError("Operation cancelled.");
-  }
-  if (typeof entered !== "string") {
-    throw new UserError(`Missing required parameter "${field.displayPath}".`);
-  }
-  if (entered.trim().length === 0 && field.hasDefault) {
-    return field.defaultValue;
-  }
-  if (field.schema.kind === "array") {
-    return parseArrayValue(entered, field.schema, field.displayPath);
-  }
-  return parseScalarValue(entered, field.schema, field.displayPath);
-}
-function resolveOutput(resolvedFlags) {
-  if (resolvedFlags.json === true) {
-    return "json";
-  }
-  if (resolvedFlags.output !== void 0) {
-    return resolvedFlags.output;
-  }
-  return "rich";
-}
-var DESIGN_SYSTEM_OUTPUT_BY_MODE = {
-  rich: "terminal",
-  md: "markdown",
-  json: "json"
-};
-function toDesignSystemOutput(output) {
-  return DESIGN_SYSTEM_OUTPUT_BY_MODE[output];
-}
-async function withOutputFormat2(output, fn) {
-  const previous = process.env.OUTPUT_FORMAT;
-  process.env.OUTPUT_FORMAT = toDesignSystemOutput(output);
-  resetOutputFormatCache();
-  try {
-    return await fn();
-  } finally {
-    if (previous === void 0) {
-      delete process.env.OUTPUT_FORMAT;
-    } else {
-      process.env.OUTPUT_FORMAT = previous;
-    }
-    resetOutputFormatCache();
-  }
-}
-function createFs() {
-  return {
-    readFile: async (path2, encoding = "utf8") => readFile(path2, { encoding }),
-    writeFile: async (path2, contents) => {
-      await writeFile(path2, contents);
-    },
-    exists: async (path2) => {
-      try {
-        await access(path2);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  };
-}
-function createEnv(values = process.env) {
-  return {
-    get(key) {
-      return values[key];
-    }
-  };
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasFieldValue(value) {
-  return value !== void 0;
-}
-function hasNestedField(fields, path2) {
-  return fields.some(
-    (field) => path2.length < field.path.length && path2.every((segment, index) => field.path[index] === segment)
-  );
-}
-function describeExpectedPresetValue(schema) {
-  if (schema.kind === "array") {
-    return "an array";
-  }
-  if (schema.kind === "enum") {
-    return `one of: ${schema.values.map((value) => JSON.stringify(value)).join(", ")}`;
-  }
-  return `a ${schema.kind}`;
-}
-function validatePresetScalarValue(value, schema, fieldPath, presetPath) {
-  if (value === null && schema.nullable === true) {
-    return null;
-  }
-  switch (schema.kind) {
-    case "string":
-      if (typeof value !== "string") {
-        break;
-      }
-      return value;
-    case "number":
-      if (!isValidNumberSchemaValue(value, schema)) {
-        break;
-      }
-      return value;
-    case "boolean":
-      if (typeof value !== "boolean") {
-        break;
-      }
-      return value;
-    case "enum": {
-      const match = schema.values.find((candidate) => Object.is(candidate, value));
-      if (match !== void 0) {
-        return match;
-      }
-      break;
-    }
-    default:
-      throw new UserError(`Unsupported CLI schema kind "${schema.kind}".`);
-  }
-  throw new UserError(
-    `Preset file "${presetPath}" has an invalid value for "${fieldPath}". Expected ${describeExpectedPresetValue(schema)}.`
-  );
-}
-function validatePresetFieldValue(value, field, presetPath) {
-  if (field.schema.kind !== "array") {
-    return validatePresetScalarValue(value, field.schema, field.displayPath, presetPath);
-  }
-  const itemSchema = unwrapOptional(field.schema.item);
-  if (itemSchema.kind === "array" || itemSchema.kind === "object") {
-    throw new UserError(`Array parameter "${field.displayPath}" must use scalar items.`);
-  }
-  if (!Array.isArray(value)) {
-    throw new UserError(
-      `Preset file "${presetPath}" has an invalid value for "${field.displayPath}". Expected an array.`
-    );
-  }
-  return value.map(
-    (item) => validatePresetScalarValue(item, itemSchema, field.displayPath, presetPath)
-  );
-}
-async function loadPresetValues(fields, presetPath) {
-  let rawPreset;
-  try {
-    rawPreset = await readFile(presetPath, {
-      encoding: "utf8"
-    });
-  } catch (error2) {
-    if (typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT") {
-      throw new UserError(`Preset file "${presetPath}" was not found.`);
-    }
-    const message2 = error2 instanceof Error && error2.message.length > 0 ? error2.message : "Unknown read error.";
-    throw new UserError(`Preset file "${presetPath}" could not be read: ${message2}`);
-  }
-  let parsedPreset;
-  try {
-    parsedPreset = JSON.parse(rawPreset);
-  } catch {
-    throw new UserError(`Preset file "${presetPath}" is not valid JSON.`);
-  }
-  if (!isPlainObject(parsedPreset)) {
-    throw new UserError(`Preset file "${presetPath}" must contain a JSON object.`);
-  }
-  const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
-  const presetValues = {};
-  function visitObject(current, path2) {
-    for (const [key, value] of Object.entries(current)) {
-      const nextPath = [...path2, key];
-      const displayPath = toDisplayPath(nextPath);
-      const field = fieldByPath.get(displayPath);
-      if (field !== void 0) {
-        presetValues[field.optionAttribute] = validatePresetFieldValue(value, field, presetPath);
-        continue;
-      }
-      if (!hasNestedField(fields, nextPath)) {
-        throw new UserError(
-          `Preset file "${presetPath}" contains unknown parameter "${displayPath}".`
-        );
-      }
-      if (!isPlainObject(value)) {
-        throw new UserError(
-          `Preset file "${presetPath}" has an invalid value for "${displayPath}". Expected an object.`
-        );
-      }
-      visitObject(value, nextPath);
-    }
-  }
-  visitObject(parsedPreset, []);
-  return presetValues;
-}
-function isNumericFixtureSelector(value) {
-  if (value.length === 0) {
-    return false;
-  }
-  for (const char of value) {
-    if (char < "0" || char > "9") {
-      return false;
-    }
-  }
-  return true;
-}
-function normalizeHttpMethod(value) {
-  return (value ?? "GET").toUpperCase();
-}
-function isReadLikeMethod(name) {
-  const normalized = name.toLowerCase();
-  return normalized === "get" || normalized === "head" || normalized === "options" || normalized.startsWith("read") || normalized.startsWith("get") || normalized.startsWith("find") || normalized.startsWith("list") || normalized.startsWith("load") || normalized.startsWith("fetch") || normalized.startsWith("query") || normalized.startsWith("exists") || normalized.startsWith("has");
-}
-function isWriteLikeMethod(name) {
-  const normalized = name.toLowerCase();
-  return normalized === "post" || normalized === "put" || normalized === "patch" || normalized === "delete" || normalized.startsWith("write") || normalized.startsWith("set") || normalized.startsWith("save") || normalized.startsWith("create") || normalized.startsWith("update") || normalized.startsWith("delete") || normalized.startsWith("remove") || normalized.startsWith("insert");
-}
-function matchesFixtureValue(expected, actual) {
-  if (typeof expected === "string" && typeof actual === "string" && expected.endsWith("%")) {
-    return actual.startsWith(expected.slice(0, -1));
-  }
-  if (Array.isArray(expected)) {
-    if (!Array.isArray(actual) || expected.length !== actual.length) {
-      return false;
-    }
-    return expected.every((item, index) => matchesFixtureValue(item, actual[index]));
-  }
-  if (isPlainObject(expected)) {
-    if (!isPlainObject(actual)) {
-      return false;
-    }
-    return Object.entries(expected).every(([key, value]) => matchesFixtureValue(value, actual[key]));
-  }
-  return Object.is(expected, actual);
-}
-function getFetchUrl(input) {
-  if (typeof input === "string") {
-    return input;
-  }
-  if (input instanceof URL) {
-    return input.toString();
-  }
-  return input.url;
-}
-function createFixtureResponse(response) {
-  const status = response.status ?? 200;
-  const headers = new Headers(response.headers);
-  if (response.body === void 0) {
-    return new Response(null, {
-      status,
-      headers
-    });
-  }
-  if (typeof response.body === "string") {
-    return new Response(response.body, {
-      status,
-      headers
-    });
-  }
-  if (!headers.has("content-type")) {
-    headers.set("content-type", "application/json");
-  }
-  return new Response(JSON.stringify(response.body), {
-    status,
-    headers
-  });
-}
-function createFixtureFetch(entries) {
-  return async (input, init) => {
-    const method = normalizeHttpMethod(init?.method ?? (input instanceof Request ? input.method : void 0));
-    const url = getFetchUrl(input);
-    const match = entries?.find((entry) => {
-      const requestMethod = normalizeHttpMethod(entry.request.method);
-      return requestMethod === method && entry.request.url === url;
-    });
-    if (match !== void 0) {
-      return createFixtureResponse(match.response);
-    }
-    if (isReadLikeMethod(method)) {
-      return null;
-    }
-    return new Response(null, {
-      status: 204
-    });
-  };
-}
-function createFixtureFs(definition) {
-  const fsDefinition = isPlainObject(definition) ? definition : {};
-  const readFileEntries = isPlainObject(fsDefinition.readFile) ? fsDefinition.readFile : {};
-  const existsEntries = isPlainObject(fsDefinition.exists) ? fsDefinition.exists : {};
-  return {
-    readFile: async (filePath) => {
-      if (Object.prototype.hasOwnProperty.call(readFileEntries, filePath)) {
-        return String(readFileEntries[filePath]);
-      }
-      return null;
-    },
-    writeFile: async () => void 0,
-    exists: async (filePath) => {
-      if (Object.prototype.hasOwnProperty.call(existsEntries, filePath)) {
-        return Boolean(existsEntries[filePath]);
-      }
-      return Object.prototype.hasOwnProperty.call(readFileEntries, filePath);
-    }
-  };
-}
-function resolveFixtureMethodResult(methodName, definition, args) {
-  if (Array.isArray(definition)) {
-    for (const entry of definition) {
-      if (!isPlainObject(entry)) {
-        continue;
-      }
-      const explicitMatcher = isPlainObject(entry.request) ? entry.request : void 0;
-      const matcher = explicitMatcher ?? Object.fromEntries(
-        Object.entries(entry).filter(([key]) => key !== "result" && key !== "response" && key !== "error")
-      );
-      const firstArg = args[0];
-      let matched = false;
-      if (Array.isArray(matcher.args)) {
-        matched = matchesFixtureValue(matcher.args, args);
-      } else if (Object.keys(matcher).length === 0) {
-        matched = true;
-      } else if (isPlainObject(firstArg)) {
-        matched = matchesFixtureValue(matcher, firstArg);
-      } else if (args.length === 1 && Object.keys(matcher).length === 1) {
-        const [[, expectedValue]] = Object.entries(matcher);
-        matched = matchesFixtureValue(expectedValue, firstArg);
-      }
-      if (!matched) {
-        continue;
-      }
-      if (entry.error !== void 0) {
-        throw new Error(String(entry.error));
-      }
-      if (Object.prototype.hasOwnProperty.call(entry, "result")) {
-        return Promise.resolve(entry.result);
-      }
-      if (Object.prototype.hasOwnProperty.call(entry, "response")) {
-        return Promise.resolve(entry.response);
-      }
-      return Promise.resolve(null);
-    }
-  }
-  if (isPlainObject(definition)) {
-    const firstArg = args[0];
-    if (typeof firstArg === "string" && Object.prototype.hasOwnProperty.call(definition, firstArg)) {
-      return Promise.resolve(definition[firstArg]);
-    }
-  }
-  if (isWriteLikeMethod(methodName)) {
-    return Promise.resolve(void 0);
-  }
-  return Promise.resolve(null);
-}
-function createFixtureService(definition) {
-  const methods = isPlainObject(definition) ? definition : {};
-  return new Proxy(
-    {},
-    {
-      get(_target, property) {
-        if (property === "then") {
-          return void 0;
-        }
-        const methodName = String(property);
-        return async (...args) => resolveFixtureMethodResult(methodName, methods[methodName], args);
-      }
-    }
-  );
-}
-function resolveFixturePath(commandPath) {
-  const parsed = path.parse(commandPath);
-  return path.join(parsed.dir, `${parsed.name}.fixture.json`);
-}
-function selectFixtureScenario(scenarios, selector) {
-  if (isNumericFixtureSelector(selector)) {
-    const index = Number(selector) - 1;
-    const scenario2 = scenarios[index];
-    if (scenario2 === void 0) {
-      throw new UserError(
-        `Fixture scenario index ${selector} is out of range. Available scenarios: ${scenarios.length}.`
-      );
-    }
-    return scenario2;
-  }
-  const scenario = scenarios.find((entry) => entry.name === selector);
-  if (scenario === void 0) {
-    throw new UserError(`Fixture scenario "${selector}" was not found.`);
-  }
-  return scenario;
-}
-async function loadFixtureScenario(command, selector) {
-  const commandPath = getCommandSourcePath(command);
-  if (commandPath === void 0) {
-    throw new UserError(`Fixture mode could not determine the source file for command "${command.name}".`);
-  }
-  const fixturePath = resolveFixturePath(commandPath);
-  let rawFixture;
-  try {
-    rawFixture = await readFile(fixturePath, {
-      encoding: "utf8"
-    });
-  } catch {
-    throw new UserError(
-      `Fixture file not found for command "${command.name}". Expected ${fixturePath}.`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(rawFixture);
-  } catch {
-    throw new UserError(`Fixture file ${fixturePath} is not valid JSON.`);
-  }
-  if (!Array.isArray(parsed)) {
-    throw new UserError(`Fixture file ${fixturePath} must contain a JSON array of scenarios.`);
-  }
-  return selectFixtureScenario(parsed, selector);
-}
-function resolveFixtureSecrets(command) {
-  return Object.fromEntries(Object.keys(command.secrets).map((name) => [name, "fixture-secret"]));
-}
-function createFixtureEnvValues(command) {
-  const values = {
-    ...process.env,
-    POE_API_KEY: process.env.POE_API_KEY ?? "fixture-secret"
-  };
-  for (const secret of Object.values(command.secrets)) {
-    values[secret.env] = values[secret.env] ?? "fixture-secret";
-  }
-  return values;
-}
-async function resolveFixtureRuntime(command, services, requirementOptions) {
-  const selector = process.env.CMDKIT_FIXTURE;
-  if (selector === void 0 || selector.length === 0) {
-    return {
-      env: createEnv(),
-      fetch: globalThis.fetch,
-      fs: createFs(),
-      isFixture: false,
-      requirementOptions,
-      secrets: resolveCommandSecrets(command),
-      services
-    };
-  }
-  const scenario = await loadFixtureScenario(command, selector);
-  const scenarioServices = isPlainObject(scenario.services) ? scenario.services : {};
-  const customServiceNames = /* @__PURE__ */ new Set([
-    ...Object.keys(services),
-    ...Object.keys(scenarioServices).filter((name) => !RESERVED_SERVICE_NAMES.has(name))
-  ]);
-  const fixtureServices = Object.fromEntries(
-    [...customServiceNames].map((name) => [name, createFixtureService(scenarioServices[name])])
-  );
-  const fixtureEnvValues = createFixtureEnvValues(command);
-  return {
-    env: createEnv(fixtureEnvValues),
-    fetch: createFixtureFetch(scenarioServices.fetch),
-    fs: createFixtureFs(scenarioServices.fs),
-    isFixture: true,
-    requirementOptions: {
-      ...requirementOptions,
-      env: fixtureEnvValues
-    },
-    secrets: resolveFixtureSecrets(command),
-    services: fixtureServices
-  };
-}
-function writeRichHeader(title) {
-  const padding = Math.max(12, 34 - title.length);
-  process.stdout.write(`\u2500\u2500 ${title} ${"\u2500".repeat(padding)}
-`);
-}
-function validateServices(services) {
-  for (const name of Object.keys(services)) {
-    if (RESERVED_SERVICE_NAMES.has(name)) {
-      throw new Error(`Service name "${name}" is reserved. Choose a different name.`);
-    }
-  }
-}
-async function resolveParams(fields, positionalValues, optionValues, presetPath, shouldPrompt) {
-  const params = {};
-  const presetValues = typeof presetPath === "string" && presetPath.length > 0 ? await loadPresetValues(fields, presetPath) : {};
-  for (const field of fields) {
-    let value;
-    if (field.positionalIndex !== void 0) {
-      const positionalValue = positionalValues[field.positionalIndex];
-      if (field.schema.kind === "array") {
-        if (Array.isArray(positionalValue) && positionalValue.length > 0) {
-          const itemSchema = unwrapOptional(field.schema.item);
-          if (itemSchema.kind === "array" || itemSchema.kind === "object") {
-            throw new UserError(`Array parameter "${field.displayPath}" must use scalar items.`);
-          }
-          value = positionalValue.map(
-            (item) => parseScalarValue(String(item), itemSchema, field.displayPath)
-          );
-        }
-      } else if (typeof positionalValue === "string" && positionalValue.length > 0) {
-        value = parseScalarValue(positionalValue, field.schema, field.displayPath);
-      }
-    }
-    if (value === void 0 && Object.prototype.hasOwnProperty.call(optionValues, field.commanderOptionAttribute) && hasFieldValue(optionValues[field.commanderOptionAttribute])) {
-      value = optionValues[field.commanderOptionAttribute];
-    }
-    if (value === void 0 && field.commanderOptionAttribute === field.optionAttribute && Object.prototype.hasOwnProperty.call(optionValues, field.optionAttribute) && hasFieldValue(optionValues[field.optionAttribute])) {
-      value = optionValues[field.optionAttribute];
-    }
-    if (value === void 0 && Object.prototype.hasOwnProperty.call(presetValues, field.optionAttribute)) {
-      value = presetValues[field.optionAttribute];
-    }
-    if (value === void 0 && shouldPrompt && !field.optional) {
-      value = await promptForField(field);
-    }
-    if (value === void 0 && field.hasDefault) {
-      value = field.defaultValue;
-    }
-    if (value === void 0) {
-      if (field.optional) {
-        continue;
-      }
-      throw new UserError(`Missing required parameter "${field.displayPath}".`);
-    }
-    setNestedValue(params, field.path, value);
-  }
-  return params;
-}
-function getResolvedFlags(command) {
-  const flags = command.optsWithGlobals();
-  return flags;
-}
-async function executeCommand(state, services, requirementOptions) {
-  const logger2 = createLogger();
-  const primitives = {
-    logger: logger2,
-    renderTable,
-    getTheme,
-    note
-  };
-  const optionValues = state.actionCommand.optsWithGlobals();
-  const resolvedFlags = optionValues;
-  const output = resolveOutput(resolvedFlags);
-  const shouldPrompt = !resolvedFlags.yes && Boolean(process.stdin.isTTY);
-  const runtime = await resolveFixtureRuntime(state.command, services, requirementOptions);
-  const preflightContext = {
-    ...runtime.services,
-    secrets: runtime.secrets,
-    fetch: runtime.fetch,
-    fs: runtime.fs,
-    env: runtime.env,
-    progress(message2) {
-      logger2.info(message2);
-    }
-  };
-  await withOutputFormat2(output, async () => {
-    await assertCommandRequirements(state.command, preflightContext, runtime.requirementOptions);
-    const params = await resolveParams(
-      state.fields,
-      state.positionalValues,
-      optionValues,
-      resolvedFlags.preset,
-      shouldPrompt
-    );
-    const context = {
-      ...preflightContext,
-      params
-    };
-    if (state.command.confirm && !resolvedFlags.yes && process.stdin.isTTY) {
-      for (const field of state.fields) {
-        const value = field.path.reduce(
-          (current, segment) => current && typeof current === "object" ? current[segment] : void 0,
-          params
-        );
-        if (value !== void 0) {
-          logger2.resolved(field.displayPath, formatResolvedValue(value));
-        }
-      }
-      const proceed = await confirm2({
-        message: "Proceed?",
-        initialValue: true
-      });
-      if (Ct(proceed)) {
-        cancel("Operation cancelled.");
-        throw new UserError("Operation cancelled.");
-      }
-      if (proceed !== true) {
-        throw new UserError("Operation cancelled.");
-      }
-    }
-    const result = await state.command.handler(context);
-    if (output === "rich" && runtime.isFixture) {
-      writeRichHeader(`${state.command.name} (fixture)`);
-    }
-    renderResult(state.command, result, output, primitives);
-  });
-}
-function handleRunError(error2, verbose) {
-  const logger2 = createLogger();
-  if (error2 instanceof UserError) {
-    logger2.error(error2.message);
-    process.exitCode = 1;
-    return;
-  }
-  if (error2 instanceof CommanderError) {
-    process.exitCode = error2.exitCode;
-    if (error2.code === "commander.helpDisplayed" || error2.code === "commander.version") {
-      return;
-    }
-    return;
-  }
-  const message2 = error2 instanceof Error ? error2.message : String(error2);
-  logger2.error(verbose ? message2 : `${message2} Use --verbose for a stack trace.`);
-  if (verbose && error2 instanceof Error && error2.stack) {
-    process.stderr.write(`${error2.stack}
-`);
-  }
-  process.exitCode = 1;
-}
-async function runCLI(roots, options = {}) {
-  const root = normalizeRoots(roots, process.argv);
-  const casing = options.casing ?? "kebab";
-  const services = options.services ?? {};
-  const requirementOptions = {
-    apiVersion: options.apiVersion
-  };
-  validateServices(services);
-  if (hasHelpFlag(process.argv)) {
-    await renderGeneratedHelp(root, process.argv, options);
-    return;
-  }
-  const program = new CommanderCommand();
-  program.name(root.name);
-  program.exitOverride();
-  program.showHelpAfterError();
-  program.addHelpCommand(false);
-  addGlobalOptions(program);
-  if (options.version !== void 0) {
-    program.version(options.version, "--version");
-  }
-  const execute = async (state) => {
-    try {
-      await executeCommand(state, services, requirementOptions);
-    } catch (error2) {
-      handleRunError(error2, Boolean(getResolvedFlags(state.actionCommand).verbose));
-    }
-  };
-  for (const child of root.children) {
-    const command = createNodeCommand(child, casing, execute);
-    if (command === null) {
-      continue;
-    }
-    const isDefaultChild = root.default !== void 0 && root.default.scope.includes("cli") && (command.name() === root.default.name || command.aliases().includes(root.default.name));
-    program.addCommand(command, isDefaultChild ? { isDefault: true } : void 0);
-  }
-  try {
-    await program.parseAsync(process.argv);
-  } catch (error2) {
-    handleRunError(error2, process.argv.includes("--verbose"));
-  }
-}
-export {
-  runCLI
-};
-//# sourceMappingURL=cli.js.map