@bunli/test 0.1.0

package/dist/index.js

@@ -0,0 +1,1169 @@
+// @bun
+// ../core/dist/index.js
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var exports_dist = {};
+__export(exports_dist, {
+  validateFields: () => validateFields,
+  validate: () => validate,
+  utils: () => utils,
+  spinner: () => createSpinner,
+  select: () => select,
+  prompt: () => prompt2,
+  password: () => password,
+  getDotPath: () => getDotPath2,
+  confirm: () => confirm,
+  colors: () => colors,
+  SchemaError: () => SchemaError2
+});
+function createColorFunction(code) {
+  return (text) => {
+    if (!process.stdout.isTTY || process.env.NO_COLOR) {
+      return text;
+    }
+    return `\x1B[${code}m${text}\x1B[0m`;
+  };
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+async function readline(prompt) {
+  process.stdout.write(prompt);
+  for await (const line of console) {
+    return line;
+  }
+  return "";
+}
+async function prompt(message, options = {}) {
+  const defaultHint = options.default ? ` (${options.default})` : "";
+  const promptText = `${message}${defaultHint} `;
+  while (true) {
+    const input = await readline(promptText);
+    const value = input.trim() || options.default || "";
+    if (options.schema) {
+      const result = await options.schema["~standard"].validate(value);
+      if (result.issues) {
+        console.error(colors.red("Invalid input:"));
+        for (const issue of result.issues) {
+          console.error(colors.dim(`  \u2022 ${issue.message}`));
+        }
+        console.error();
+        continue;
+      }
+      return result.value;
+    }
+    if (options.validate) {
+      const result = options.validate(value);
+      if (result === true) {
+        return value;
+      } else if (typeof result === "string") {
+        console.error(`\u2717 ${result}`);
+        continue;
+      } else {
+        console.error("\u2717 Invalid input");
+        continue;
+      }
+    }
+    return value;
+  }
+}
+async function confirm(message, options = {}) {
+  const defaultHint = options.default === true ? "Y/n" : options.default === false ? "y/N" : "y/n";
+  const promptText = `${message} (${defaultHint}) `;
+  while (true) {
+    const input = await readline(promptText);
+    const value = input.trim().toLowerCase();
+    if (!value && options.default !== undefined) {
+      return options.default;
+    }
+    if (value === "y" || value === "yes") {
+      return true;
+    }
+    if (value === "n" || value === "no") {
+      return false;
+    }
+    console.error("\u2717 Please answer with y/yes or n/no");
+  }
+}
+async function select(message, options) {
+  const { options: choices, default: defaultValue } = options;
+  let selectedIndex = defaultValue ? choices.findIndex((opt) => opt.value === defaultValue) : 0;
+  if (selectedIndex === -1)
+    selectedIndex = 0;
+  console.log(message);
+  process.stdout.write(CURSOR_HIDE);
+  drawOptions(choices, selectedIndex);
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write(CURSOR_SHOW);
+    };
+    process.stdin.on("data", (data) => {
+      const key = data.toString();
+      if (key === "\x1B[A") {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        drawOptions(choices, selectedIndex);
+      } else if (key === "\x1B[B") {
+        selectedIndex = Math.min(choices.length - 1, selectedIndex + 1);
+        drawOptions(choices, selectedIndex);
+      } else if (key === "\r" || key === `
+`) {
+        cleanup();
+        for (let i = 0;i < choices.length; i++) {
+          process.stdout.write(`${CSI}1A${CLEAR_LINE}`);
+        }
+        const selected = choices[selectedIndex];
+        if (selected) {
+          console.log(`\u2713 ${selected.label}`);
+          resolve(selected.value);
+        }
+      } else if (key === "\x03" || key === "\x1B") {
+        cleanup();
+        process.exit(0);
+      }
+    });
+  });
+}
+function drawOptions(options, selectedIndex) {
+  for (let i = 0;i < options.length; i++) {
+    process.stdout.write(`${CSI}1A`);
+  }
+  options.forEach((option, index) => {
+    process.stdout.write(CLEAR_LINE + CURSOR_START);
+    const prefix = index === selectedIndex ? "\u276F " : "  ";
+    const hint = option.hint ? ` (${option.hint})` : "";
+    console.log(`${prefix}${option.label}${hint}`);
+  });
+}
+async function password(message, options = {}) {
+  process.stdout.write(message + " ");
+  return new Promise((resolve) => {
+    let input = "";
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      console.log();
+    };
+    process.stdin.on("data", async (data) => {
+      const key = data.toString();
+      if (key === "\r" || key === `
+`) {
+        cleanup();
+        if (options.schema) {
+          const result = await options.schema["~standard"].validate(input);
+          if (result.issues) {
+            console.error(colors.red("Invalid input:"));
+            for (const issue of result.issues) {
+              console.error(colors.dim(`  \u2022 ${issue.message}`));
+            }
+            console.error();
+            password(message, options).then(resolve);
+            return;
+          }
+          resolve(result.value);
+        } else if (options.validate) {
+          const result = options.validate(input);
+          if (result === true) {
+            resolve(input);
+          } else {
+            const errorMsg = typeof result === "string" ? result : "Invalid input";
+            console.error(`\u2717 ${errorMsg}`);
+            password(message, options).then(resolve);
+          }
+        } else {
+          resolve(input);
+        }
+      } else if (key === "\x03") {
+        cleanup();
+        process.exit(0);
+      } else if (key === "\x7F" || key === "\b") {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else if (key.length === 1 && key >= " ") {
+        input += key;
+        process.stdout.write("*");
+      }
+    });
+  });
+}
+function createSpinner(options) {
+  const config = typeof options === "string" ? { text: options } : options || {};
+  let isSpinning = false;
+  let frameIndex = 0;
+  let intervalId = null;
+  let currentText = config.text || "";
+  const render = (symbol, text) => {
+    process.stdout.write(`${CLEAR_LINE2}${CURSOR_START2}${symbol} ${text}`);
+  };
+  const spinner = {
+    start(text) {
+      if (isSpinning)
+        return;
+      isSpinning = true;
+      if (text !== undefined) {
+        currentText = text;
+      }
+      process.stdout.write("\x1B[?25l");
+      intervalId = setInterval(() => {
+        const frame = SPINNER_FRAMES[frameIndex];
+        render(frame, currentText);
+        frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+      }, 80);
+    },
+    stop(text) {
+      if (!isSpinning)
+        return;
+      isSpinning = false;
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(CLEAR_LINE2 + CURSOR_START2);
+      process.stdout.write("\x1B[?25h");
+      if (text) {
+        console.log(text);
+      }
+    },
+    succeed(text) {
+      this.stop();
+      console.log(`\u2705 ${text || currentText}`);
+    },
+    fail(text) {
+      this.stop();
+      console.log(`\u274C ${text || currentText}`);
+    },
+    warn(text) {
+      this.stop();
+      console.log(`\u26A0\uFE0F  ${text || currentText}`);
+    },
+    info(text) {
+      this.stop();
+      console.log(`\u2139\uFE0F  ${text || currentText}`);
+    },
+    update(text) {
+      currentText = text;
+      if (isSpinning) {
+        render(SPINNER_FRAMES[frameIndex], currentText);
+      }
+    }
+  };
+  process.on("exit", () => spinner.stop());
+  process.on("SIGINT", () => {
+    spinner.stop();
+    process.exit(0);
+  });
+  return spinner;
+}
+function getDotPath2(issue) {
+  if (issue.path?.length) {
+    let dotPath = "";
+    for (const item of issue.path) {
+      const key = typeof item === "object" ? item.key : item;
+      if (typeof key === "string" || typeof key === "number") {
+        if (dotPath) {
+          dotPath += `.${key}`;
+        } else {
+          dotPath += key;
+        }
+      } else {
+        return null;
+      }
+    }
+    return dotPath;
+  }
+  return null;
+}
+async function validate(schema, value) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues) {
+    throw new SchemaError2(result.issues);
+  }
+  return result.value;
+}
+async function validateFields(schemas, values) {
+  const results = {};
+  const errors = {};
+  for (const [field, schema] of Object.entries(schemas)) {
+    const result = await schema["~standard"].validate(values[field]);
+    if (result.issues) {
+      errors[field] = result.issues.map((issue) => issue.message);
+    } else {
+      results[field] = result.value;
+    }
+  }
+  if (Object.keys(errors).length > 0) {
+    return { errors };
+  }
+  return results;
+}
+var colorCodes;
+var colors;
+var ESC = "\x1B";
+var CSI;
+var CLEAR_LINE;
+var CURSOR_START;
+var CURSOR_HIDE;
+var CURSOR_SHOW;
+var SPINNER_FRAMES;
+var CLEAR_LINE2 = "\x1B[2K";
+var CURSOR_START2 = "\x1B[G";
+var SchemaError2;
+var utils;
+var prompt2;
+var init_dist = __esm(() => {
+  colorCodes = {
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
+    gray: 90,
+    brightRed: 91,
+    brightGreen: 92,
+    brightYellow: 93,
+    brightBlue: 94,
+    brightMagenta: 95,
+    brightCyan: 96,
+    brightWhite: 97,
+    bgRed: 41,
+    bgGreen: 42,
+    bgYellow: 43,
+    bgBlue: 44,
+    bgMagenta: 45,
+    bgCyan: 46,
+    bgWhite: 47,
+    bold: 1,
+    dim: 2,
+    italic: 3,
+    underline: 4,
+    strikethrough: 9,
+    reset: 0
+  };
+  colors = {
+    black: createColorFunction(colorCodes.black),
+    red: createColorFunction(colorCodes.red),
+    green: createColorFunction(colorCodes.green),
+    yellow: createColorFunction(colorCodes.yellow),
+    blue: createColorFunction(colorCodes.blue),
+    magenta: createColorFunction(colorCodes.magenta),
+    cyan: createColorFunction(colorCodes.cyan),
+    white: createColorFunction(colorCodes.white),
+    gray: createColorFunction(colorCodes.gray),
+    brightRed: createColorFunction(colorCodes.brightRed),
+    brightGreen: createColorFunction(colorCodes.brightGreen),
+    brightYellow: createColorFunction(colorCodes.brightYellow),
+    brightBlue: createColorFunction(colorCodes.brightBlue),
+    brightMagenta: createColorFunction(colorCodes.brightMagenta),
+    brightCyan: createColorFunction(colorCodes.brightCyan),
+    brightWhite: createColorFunction(colorCodes.brightWhite),
+    bgRed: createColorFunction(colorCodes.bgRed),
+    bgGreen: createColorFunction(colorCodes.bgGreen),
+    bgYellow: createColorFunction(colorCodes.bgYellow),
+    bgBlue: createColorFunction(colorCodes.bgBlue),
+    bgMagenta: createColorFunction(colorCodes.bgMagenta),
+    bgCyan: createColorFunction(colorCodes.bgCyan),
+    bgWhite: createColorFunction(colorCodes.bgWhite),
+    bold: createColorFunction(colorCodes.bold),
+    dim: createColorFunction(colorCodes.dim),
+    italic: createColorFunction(colorCodes.italic),
+    underline: createColorFunction(colorCodes.underline),
+    strikethrough: createColorFunction(colorCodes.strikethrough),
+    reset: createColorFunction(colorCodes.reset),
+    strip: stripAnsi
+  };
+  CSI = `${ESC}[`;
+  CLEAR_LINE = `${CSI}2K`;
+  CURSOR_START = `${CSI}G`;
+  CURSOR_HIDE = `${CSI}?25l`;
+  CURSOR_SHOW = `${CSI}?25h`;
+  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  SchemaError2 = class extends Error {
+    issues;
+    constructor(issues) {
+      super(issues[0].message);
+      this.name = "SchemaError";
+      this.issues = issues;
+    }
+  };
+  utils = {
+    prompt: Object.assign(prompt, {
+      confirm,
+      select,
+      password
+    }),
+    spinner: createSpinner,
+    colors
+  };
+  prompt2 = Object.assign(prompt, {
+    confirm,
+    select,
+    password
+  });
+});
+function getDotPath(issue) {
+  if (issue.path?.length) {
+    let dotPath = "";
+    for (const item of issue.path) {
+      const key = typeof item === "object" ? item.key : item;
+      if (typeof key === "string" || typeof key === "number") {
+        if (dotPath) {
+          dotPath += `.${key}`;
+        } else {
+          dotPath += key;
+        }
+      } else {
+        return null;
+      }
+    }
+    return dotPath;
+  }
+  return null;
+}
+var SchemaError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "SchemaError";
+    this.issues = issues;
+  }
+};
+async function parseArgs(args, options) {
+  const flags = {};
+  const positional = [];
+  const shortToName = new Map;
+  for (const [name, opt] of Object.entries(options)) {
+    if (opt.short) {
+      shortToName.set(opt.short, name);
+    }
+  }
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg.startsWith("--")) {
+      const eqIndex = arg.indexOf("=");
+      const name = eqIndex > 0 ? arg.slice(2, eqIndex) : arg.slice(2);
+      const inlineValue = eqIndex > 0 ? arg.slice(eqIndex + 1) : undefined;
+      if (!name || !options[name])
+        continue;
+      let value = inlineValue;
+      if (value === undefined && i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+        value = args[++i];
+      }
+      flags[name] = await validateOption(name, value ?? "true", options[name].schema);
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const short = arg.slice(1);
+      const name = shortToName.get(short);
+      if (name && options[name]) {
+        let value;
+        if (i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+          value = args[++i];
+        }
+        flags[name] = await validateOption(name, value ?? "true", options[name].schema);
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  for (const [name, opt] of Object.entries(options)) {
+    if (!(name in flags)) {
+      flags[name] = await validateOption(name, undefined, opt.schema);
+    }
+  }
+  return { flags, positional };
+}
+async function validateOption(name, value, schema) {
+  let processedValue = value;
+  if (typeof value === "string" && (value === "true" || value === "false")) {
+    const testResult = await schema["~standard"].validate(true);
+    if (!testResult.issues) {
+      processedValue = value === "true";
+    }
+  }
+  const result = await schema["~standard"].validate(processedValue);
+  if (result.issues) {
+    const issuesWithPath = result.issues.map((issue) => ({
+      ...issue,
+      path: [name, ...issue.path || []]
+    }));
+    throw new SchemaError(issuesWithPath);
+  }
+  return result.value;
+}
+function createCLI(config) {
+  const fullConfig = "commands" in config ? config : { ...config, commands: undefined };
+  const commands = new Map;
+  function registerCommand(cmd, path = []) {
+    const fullName = [...path, cmd.name].join(" ");
+    commands.set(fullName, cmd);
+    if (cmd.alias) {
+      const aliases = Array.isArray(cmd.alias) ? cmd.alias : [cmd.alias];
+      aliases.forEach((alias) => {
+        const aliasPath = [...path, alias].join(" ");
+        commands.set(aliasPath, cmd);
+      });
+    }
+    if (cmd.commands) {
+      cmd.commands.forEach((subCmd) => {
+        registerCommand(subCmd, [...path, cmd.name]);
+      });
+    }
+  }
+  function findCommand(args) {
+    for (let i = args.length;i > 0; i--) {
+      const cmdPath = args.slice(0, i).join(" ");
+      const command = commands.get(cmdPath);
+      if (command) {
+        return { command, remainingArgs: args.slice(i) };
+      }
+    }
+    return { command: undefined, remainingArgs: args };
+  }
+  function showHelp(cmd, path = []) {
+    if (!cmd) {
+      console.log(`${fullConfig.name} v${fullConfig.version}`);
+      if (fullConfig.description) {
+        console.log(fullConfig.description);
+      }
+      console.log(`
+Commands:`);
+      const topLevel = new Set;
+      for (const [name, command] of commands) {
+        if (!name.includes(" ") && !command.alias?.includes(name)) {
+          topLevel.add(command);
+        }
+      }
+      for (const command of topLevel) {
+        console.log(`  ${command.name.padEnd(20)} ${command.description}`);
+      }
+    } else {
+      const fullPath = [...path, cmd.name].join(" ");
+      console.log(`Usage: ${fullConfig.name} ${fullPath} [options]`);
+      console.log(`
+${cmd.description}`);
+      if (cmd.options && Object.keys(cmd.options).length > 0) {
+        console.log(`
+Options:`);
+        for (const [name, opt] of Object.entries(cmd.options)) {
+          const flag = `--${name}${opt.short ? `, -${opt.short}` : ""}`;
+          const description = opt.description || "";
+          console.log(`  ${flag.padEnd(20)} ${description}`);
+        }
+      }
+      if (cmd.commands && cmd.commands.length > 0) {
+        console.log(`
+Subcommands:`);
+        for (const subCmd of cmd.commands) {
+          console.log(`  ${subCmd.name.padEnd(20)} ${subCmd.description}`);
+        }
+      }
+    }
+  }
+  async function loadFromConfig() {
+    if (fullConfig.commands?.manifest) {
+      try {
+        const manifestPath = fullConfig.commands.manifest.startsWith(".") ? `${process.cwd()}/${fullConfig.commands.manifest}` : fullConfig.commands.manifest;
+        const manifestModule = await import(manifestPath);
+        const manifest = manifestModule.default || manifestModule;
+        await loadCommandsFromManifest(manifest);
+      } catch (error) {
+        console.error(`Failed to load command manifest from ${fullConfig.commands.manifest}:`, error);
+      }
+    }
+  }
+  async function loadCommandsFromManifest(manifest) {
+    async function loadFromManifest(obj, path = []) {
+      const commands2 = [];
+      if (typeof obj === "function") {
+        const { default: command } = await obj();
+        return [command];
+      }
+      for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === "function") {
+          const { default: command } = await value();
+          commands2.push(command);
+        } else {
+          const subCommands = await loadFromManifest(value, [...path, key]);
+          if (subCommands.length > 0) {
+            const parentCommand = {
+              name: key,
+              description: `${key} commands`,
+              commands: subCommands
+            };
+            commands2.push(parentCommand);
+          }
+        }
+      }
+      return commands2;
+    }
+    const loadedCommands = await loadFromManifest(manifest);
+    loadedCommands.forEach((cmd) => registerCommand(cmd));
+  }
+  return {
+    command(cmd) {
+      registerCommand(cmd);
+    },
+    async load(manifest) {
+      await loadCommandsFromManifest(manifest);
+    },
+    async init() {
+      await loadFromConfig();
+    },
+    async run(argv = process.argv.slice(2)) {
+      if (argv.length === 0) {
+        showHelp();
+        return;
+      }
+      if (argv.includes("--help") || argv.includes("-h")) {
+        const helpIndex = Math.max(argv.indexOf("--help"), argv.indexOf("-h"));
+        const cmdArgs = argv.slice(0, helpIndex);
+        if (cmdArgs.length === 0) {
+          showHelp();
+        } else {
+          const { command: command2 } = findCommand(cmdArgs);
+          if (command2) {
+            showHelp(command2, cmdArgs.slice(0, -1));
+          } else {
+            console.error(`Unknown command: ${cmdArgs.join(" ")}`);
+            process.exit(1);
+          }
+        }
+        return;
+      }
+      const { command, remainingArgs } = findCommand(argv);
+      if (!command) {
+        console.error(`Unknown command: ${argv[0]}`);
+        process.exit(1);
+      }
+      if (!command.handler && command.commands) {
+        showHelp(command, argv.slice(0, argv.length - remainingArgs.length - 1));
+        return;
+      }
+      if (command.handler) {
+        try {
+          const parsed = await parseArgs(remainingArgs, command.options || {});
+          const { prompt: prompt3, spinner, colors: colors2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+          await command.handler({
+            flags: parsed.flags,
+            positional: parsed.positional,
+            shell: Bun.$,
+            env: process.env,
+            cwd: process.cwd(),
+            prompt: prompt3,
+            spinner,
+            colors: colors2
+          });
+        } catch (error) {
+          const { colors: colors2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+          if (error instanceof SchemaError) {
+            console.error(colors2.red("Validation errors:"));
+            const fieldErrors = {};
+            const generalErrors = [];
+            for (const issue of error.issues) {
+              const dotPath = getDotPath(issue);
+              if (dotPath) {
+                fieldErrors[dotPath] ??= [];
+                fieldErrors[dotPath].push(issue.message);
+              } else {
+                generalErrors.push(issue.message);
+              }
+            }
+            for (const [field, messages] of Object.entries(fieldErrors)) {
+              console.error(colors2.yellow(`  --${field}:`));
+              for (const message of messages) {
+                console.error(colors2.dim(`    \u2022 ${message}`));
+              }
+            }
+            for (const message of generalErrors) {
+              console.error(colors2.dim(`  \u2022 ${message}`));
+            }
+            process.exit(1);
+          } else if (error instanceof Error) {
+            console.error(colors2.red(`Error: ${error.message}`));
+            process.exit(1);
+          }
+          throw error;
+        }
+      }
+    }
+  };
+}
+
+// src/test-command.ts
+async function testCommand(command, options = {}) {
+  const startTime = performance.now();
+  const stdout = [];
+  const stderr = [];
+  let exitCode = 0;
+  let error;
+  const stdinLines = Array.isArray(options.stdin) ? [...options.stdin] : options.stdin ? [options.stdin] : [];
+  const mockPromptsMap = options.mockPrompts || {};
+  const promptResponsesUsed = new Map;
+  const mockPrompt = Object.assign(async (message, options2) => {
+    stdout.push(message);
+    let response;
+    if (mockPromptsMap[message]) {
+      const responses = mockPromptsMap[message];
+      const usedCount = promptResponsesUsed.get(message) || 0;
+      if (Array.isArray(responses)) {
+        response = responses[usedCount] ?? responses[responses.length - 1] ?? "";
+        promptResponsesUsed.set(message, usedCount + 1);
+      } else {
+        response = responses ?? "";
+      }
+    } else {
+      response = stdinLines.shift() || "";
+    }
+    stdout.push(response);
+    if (options2?.schema) {
+      const result = await options2.schema["~standard"].validate(response);
+      if (result.issues) {
+        stderr.push("[red]Invalid input:[/red]");
+        for (const issue of result.issues) {
+          stderr.push(`[dim]  \u2022 ${issue.message}[/dim]`);
+        }
+        const hasMoreMockResponses = mockPromptsMap[message] && Array.isArray(mockPromptsMap[message]) && (promptResponsesUsed.get(message) || 0) < mockPromptsMap[message].length;
+        const hasMoreStdin = stdinLines.length > 0;
+        if (hasMoreMockResponses || hasMoreStdin) {
+          return mockPrompt(message, options2);
+        }
+        return;
+      }
+      return result.value;
+    }
+    if (options2?.validate) {
+      const validationResult = options2.validate(response);
+      if (validationResult !== true) {
+        const errorMsg = typeof validationResult === "string" ? validationResult : "Invalid input";
+        stderr.push(`\u2717 ${errorMsg}`);
+        if (stdinLines.length > 0) {
+          return mockPrompt(message, options2);
+        }
+      }
+    }
+    return response;
+  }, {
+    confirm: async (message, opts) => {
+      stdout.push(message);
+      let response;
+      if (mockPromptsMap[message]) {
+        const responses = mockPromptsMap[message];
+        const usedCount = promptResponsesUsed.get(message) || 0;
+        if (Array.isArray(responses)) {
+          response = responses[usedCount] ?? responses[responses.length - 1] ?? "";
+          promptResponsesUsed.set(message, usedCount + 1);
+        } else {
+          response = responses ?? "";
+        }
+      } else {
+        response = stdinLines.shift() || "";
+      }
+      stdout.push(response);
+      const normalized = response.toLowerCase().trim();
+      return normalized === "y" || normalized === "yes" || opts?.default && normalized === "";
+    },
+    select: async (message, selectOptions) => {
+      stdout.push(message);
+      selectOptions.options.forEach((choice2, i) => {
+        const label = typeof choice2 === "object" ? choice2.label : choice2;
+        stdout.push(`  ${i + 1}. ${label}`);
+      });
+      let response;
+      if (mockPromptsMap[message]) {
+        const responses = mockPromptsMap[message];
+        const usedCount = promptResponsesUsed.get(message) || 0;
+        if (Array.isArray(responses)) {
+          response = responses[usedCount] ?? responses[responses.length - 1] ?? "";
+          promptResponsesUsed.set(message, usedCount + 1);
+        } else {
+          response = responses ?? "";
+        }
+      } else {
+        response = stdinLines.shift() || "1";
+      }
+      stdout.push(`> ${response}`);
+      const index = parseInt(response) - 1;
+      const choice = selectOptions.options[index] || selectOptions.options[0];
+      return typeof choice === "object" ? choice.value : choice;
+    },
+    password: async (message, options2) => {
+      stdout.push(message);
+      let response;
+      if (mockPromptsMap[message]) {
+        const responses = mockPromptsMap[message];
+        const usedCount = promptResponsesUsed.get(message) || 0;
+        if (Array.isArray(responses)) {
+          response = responses[usedCount] ?? responses[responses.length - 1] ?? "";
+          promptResponsesUsed.set(message, usedCount + 1);
+        } else {
+          response = responses ?? "";
+        }
+      } else {
+        response = stdinLines.shift() || "";
+      }
+      stdout.push("*".repeat(response.length));
+      if (options2?.schema) {
+        const result = await options2.schema["~standard"].validate(response);
+        if (result.issues) {
+          stderr.push("[red]Invalid input:[/red]");
+          for (const issue of result.issues) {
+            stderr.push(`[dim]  \u2022 ${issue.message}[/dim]`);
+          }
+          const hasMoreMockResponses = mockPromptsMap[message] && Array.isArray(mockPromptsMap[message]) && (promptResponsesUsed.get(message) || 0) < mockPromptsMap[message].length;
+          const hasMoreStdin = stdinLines.length > 0;
+          if (hasMoreMockResponses || hasMoreStdin) {
+            return mockPrompt.password(message, options2);
+          }
+          return;
+        }
+        return result.value;
+      }
+      return response;
+    },
+    multiselect: async (message, selectOptions) => {
+      stdout.push(message);
+      selectOptions.options.forEach((choice, i) => {
+        const label = typeof choice === "object" ? choice.label : choice;
+        stdout.push(`  [ ] ${i + 1}. ${label}`);
+      });
+      let response;
+      if (mockPromptsMap[message]) {
+        const responses = mockPromptsMap[message];
+        const usedCount = promptResponsesUsed.get(message) || 0;
+        if (Array.isArray(responses)) {
+          response = responses[usedCount] ?? responses[responses.length - 1] ?? "";
+          promptResponsesUsed.set(message, usedCount + 1);
+        } else {
+          response = responses ?? "";
+        }
+      } else {
+        response = stdinLines.shift() || "";
+      }
+      stdout.push(`> ${response}`);
+      const indices = response.split(",").map((s) => parseInt(s.trim()) - 1);
+      return indices.filter((i) => i >= 0 && i < selectOptions.options.length).map((i) => {
+        const choice = selectOptions.options[i];
+        return typeof choice === "object" ? choice.value : choice;
+      });
+    }
+  });
+  const mockSpinner = (text) => {
+    if (text)
+      stdout.push(`\u280B ${text}`);
+    return {
+      start: (text2) => {
+        if (text2)
+          stdout.push(`\u280B ${text2}`);
+      },
+      stop: (text2) => {
+        if (text2)
+          stdout.push(text2);
+      },
+      succeed: (text2) => {
+        stdout.push(`\u2705 ${text2 || "Done"}`);
+      },
+      fail: (text2) => {
+        stdout.push(`\u274C ${text2 || "Failed"}`);
+      },
+      warn: (text2) => {
+        stdout.push(`\u26A0\uFE0F  ${text2 || "Warning"}`);
+      },
+      info: (text2) => {
+        stdout.push(`\u2139\uFE0F  ${text2 || "Info"}`);
+      },
+      update: (text2) => {
+        stdout.push(`\u280B ${text2}`);
+      }
+    };
+  };
+  const mockShellCommands = options.mockShellCommands || {};
+  const mockShell = (strings, ...values) => {
+    const command2 = strings.reduce((acc, str, i) => {
+      return acc + str + (values[i] || "");
+    }, "").trim();
+    stdout.push(`$ ${command2}`);
+    const promise = Promise.resolve();
+    promise.text = async () => {
+      if (mockShellCommands[command2]) {
+        return mockShellCommands[command2];
+      }
+      if (command2.includes("git branch --show-current")) {
+        return `main
+`;
+      }
+      if (command2.includes("git status")) {
+        return `nothing to commit, working tree clean
+`;
+      }
+      return "";
+    };
+    promise.json = async () => {
+      if (mockShellCommands[command2]) {
+        try {
+          return JSON.parse(mockShellCommands[command2]);
+        } catch {
+          return {};
+        }
+      }
+      return {};
+    };
+    promise.quiet = () => promise;
+    return promise;
+  };
+  const mockColors = {
+    red: (text) => `[red]${text}[/red]`,
+    green: (text) => `[green]${text}[/green]`,
+    blue: (text) => `[blue]${text}[/blue]`,
+    yellow: (text) => `[yellow]${text}[/yellow]`,
+    cyan: (text) => `[cyan]${text}[/cyan]`,
+    magenta: (text) => `[magenta]${text}[/magenta]`,
+    gray: (text) => `[gray]${text}[/gray]`,
+    dim: (text) => `[dim]${text}[/dim]`,
+    bold: (text) => `[bold]${text}[/bold]`,
+    italic: (text) => `[italic]${text}[/italic]`,
+    underline: (text) => `[underline]${text}[/underline]`,
+    strikethrough: (text) => `[strikethrough]${text}[/strikethrough]`,
+    bgRed: (text) => `[bgRed]${text}[/bgRed]`,
+    bgGreen: (text) => `[bgGreen]${text}[/bgGreen]`,
+    bgBlue: (text) => `[bgBlue]${text}[/bgBlue]`,
+    bgYellow: (text) => `[bgYellow]${text}[/bgYellow]`,
+    bgCyan: (text) => `[bgCyan]${text}[/bgCyan]`,
+    bgMagenta: (text) => `[bgMagenta]${text}[/bgMagenta]`,
+    bgGray: (text) => `[bgGray]${text}[/bgGray]`,
+    black: (text) => `[black]${text}[/black]`,
+    white: (text) => `[white]${text}[/white]`,
+    bgBlack: (text) => `[bgBlack]${text}[/bgBlack]`,
+    bgWhite: (text) => `[bgWhite]${text}[/bgWhite]`,
+    brightRed: (text) => `[brightRed]${text}[/brightRed]`,
+    brightGreen: (text) => `[brightGreen]${text}[/brightGreen]`,
+    brightYellow: (text) => `[brightYellow]${text}[/brightYellow]`,
+    brightBlue: (text) => `[brightBlue]${text}[/brightBlue]`,
+    brightCyan: (text) => `[brightCyan]${text}[/brightCyan]`,
+    brightMagenta: (text) => `[brightMagenta]${text}[/brightMagenta]`,
+    brightWhite: (text) => `[brightWhite]${text}[/brightWhite]`,
+    reset: (text) => `[reset]${text}[/reset]`,
+    strip: (text) => text.replace(/\[[^\]]+\]/g, "")
+  };
+  const originalLog = console.log;
+  const originalError = console.error;
+  console.log = (...args) => {
+    stdout.push(args.join(" "));
+  };
+  console.error = (...args) => {
+    stderr.push(args.join(" "));
+  };
+  try {
+    const handlerArgs = {
+      flags: options.flags || {},
+      positional: options.args || [],
+      env: { ...process.env, ...options.env || {} },
+      cwd: options.cwd || process.cwd(),
+      prompt: mockPrompt,
+      spinner: mockSpinner,
+      shell: mockShell,
+      colors: mockColors
+    };
+    if (command.handler) {
+      await command.handler(handlerArgs);
+    }
+    exitCode = options.exitCode || 0;
+  } catch (err) {
+    error = err;
+    exitCode = 1;
+    stderr.push(error.message);
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+  }
+  const duration = performance.now() - startTime;
+  return {
+    stdout: stdout.join(`
+`),
+    stderr: stderr.join(`
+`),
+    exitCode,
+    duration,
+    error
+  };
+}
+async function testCLI(setupCLI, argv, options = {}) {
+  const startTime = performance.now();
+  const stdout = [];
+  const stderr = [];
+  let exitCode = 0;
+  let error;
+  const originalLog = console.log;
+  const originalError = console.error;
+  const originalExit = process.exit;
+  console.log = (...args) => {
+    stdout.push(args.join(" "));
+  };
+  console.error = (...args) => {
+    stderr.push(args.join(" "));
+  };
+  process.exit = (code) => {
+    exitCode = code || 0;
+    throw new Error(`Process exited with code ${exitCode}`);
+  };
+  try {
+    const cli = createCLI({
+      name: "test-cli",
+      version: "1.0.0",
+      description: "Test CLI"
+    });
+    setupCLI(cli);
+    await cli.run(argv);
+  } catch (err) {
+    if (!err.message.startsWith("Process exited with code")) {
+      error = err;
+      exitCode = 1;
+      stderr.push(error?.message || "Unknown error");
+    }
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+    process.exit = originalExit;
+  }
+  const duration = performance.now() - startTime;
+  return {
+    stdout: stdout.join(`
+`),
+    stderr: stderr.join(`
+`),
+    exitCode,
+    duration,
+    error
+  };
+}
+// src/matchers.ts
+function createMatchers(result) {
+  return {
+    toHaveExitCode(code) {
+      if (result.exitCode !== code) {
+        throw new Error(`Expected exit code ${code}, but got ${result.exitCode}
+` + `stdout: ${result.stdout}
+` + `stderr: ${result.stderr}`);
+      }
+    },
+    toHaveSucceeded() {
+      if (result.exitCode !== 0) {
+        throw new Error(`Expected command to succeed (exit code 0), but got ${result.exitCode}
+` + `stdout: ${result.stdout}
+` + `stderr: ${result.stderr}
+` + (result.error ? `error: ${result.error.message}` : ""));
+      }
+    },
+    toHaveFailed() {
+      if (result.exitCode === 0) {
+        throw new Error(`Expected command to fail (non-zero exit code), but it succeeded
+` + `stdout: ${result.stdout}`);
+      }
+    },
+    toContainInStdout(text) {
+      if (!result.stdout.includes(text)) {
+        throw new Error(`Expected stdout to contain "${text}"
+` + `stdout: ${result.stdout}`);
+      }
+    },
+    toContainInStderr(text) {
+      if (!result.stderr.includes(text)) {
+        throw new Error(`Expected stderr to contain "${text}"
+` + `stderr: ${result.stderr}`);
+      }
+    },
+    toMatchStdout(pattern) {
+      if (!pattern.test(result.stdout)) {
+        throw new Error(`Expected stdout to match ${pattern}
+` + `stdout: ${result.stdout}`);
+      }
+    },
+    toMatchStderr(pattern) {
+      if (!pattern.test(result.stderr)) {
+        throw new Error(`Expected stderr to match ${pattern}
+` + `stderr: ${result.stderr}`);
+      }
+    }
+  };
+}
+function expectCommand(result) {
+  const matchers = createMatchers(result);
+  return {
+    ...result,
+    ...matchers
+  };
+}
+// src/helpers.ts
+function mockPromptResponses(responses) {
+  return { mockPrompts: responses };
+}
+function mockShellCommands(commands) {
+  return { mockShellCommands: commands };
+}
+function mockInteractive(prompts, commands) {
+  return {
+    ...mockPromptResponses(prompts),
+    ...commands ? mockShellCommands(commands) : {}
+  };
+}
+function mockValidationAttempts(attempts) {
+  return { stdin: attempts };
+}
+function mergeTestOptions(...options) {
+  const merged = {};
+  for (const opt of options) {
+    if (opt.stdin || opt.mockPrompts) {
+      const stdinArray = [];
+      if (merged.stdin) {
+        if (Array.isArray(merged.stdin)) {
+          stdinArray.push(...merged.stdin);
+        } else {
+          stdinArray.push(merged.stdin);
+        }
+      }
+      if (opt.stdin) {
+        if (Array.isArray(opt.stdin)) {
+          stdinArray.push(...opt.stdin);
+        } else {
+          stdinArray.push(opt.stdin);
+        }
+      }
+      if (stdinArray.length > 0) {
+        merged.stdin = stdinArray;
+      }
+    }
+    Object.assign(merged, opt);
+  }
+  return merged;
+}
+export {
+  testCommand,
+  testCLI,
+  mockValidationAttempts,
+  mockShellCommands,
+  mockPromptResponses,
+  mockInteractive,
+  mergeTestOptions,
+  expectCommand,
+  createMatchers
+};
+
+//# debugId=CC322262A7E5B8FD64756E2164756E21