unicommand 0.0.1

package/dist/index.js

@@ -0,0 +1,1671 @@
+// src/index.ts
+import { z as z4 } from "zod";
+
+// src/command/runtime-metadata.ts
+var commandMetadata = /* @__PURE__ */ new WeakMap();
+var setCommandMetadata = (command, metadata) => {
+  commandMetadata.set(command, metadata);
+};
+var getCommandMetadata = (command) => commandMetadata.get(command);
+
+// src/cli/completion.ts
+var CompletionShell = /* @__PURE__ */ ((CompletionShell2) => {
+  CompletionShell2["Bash"] = "bash";
+  CompletionShell2["Fish"] = "fish";
+  CompletionShell2["Zsh"] = "zsh";
+  return CompletionShell2;
+})(CompletionShell || {});
+var COMPLETION_COMMAND_NAME = "completion";
+var COMPLETION_COMMAND_DESCRIPTION = "Generate shell completion scripts";
+var COMPLETION_SHELL_ARGUMENT = "[shell]";
+var COMPLETION_SHELL_DESCRIPTION = "Shell to generate completion for";
+var EMPTY_DISPLAY_VALUE = "<empty>";
+var completionShells = Object.values(CompletionShell);
+var completionScriptGenerators = {
+  ["bash" /* Bash */]: getBashCompletionScript,
+  ["fish" /* Fish */]: getFishCompletionScript,
+  ["zsh" /* Zsh */]: getZshCompletionScript
+};
+var registerCompletionCommand = (program, config = {}) => {
+  program.command(COMPLETION_COMMAND_NAME, COMPLETION_COMMAND_DESCRIPTION).argument(COMPLETION_SHELL_ARGUMENT, COMPLETION_SHELL_DESCRIPTION).strict(false).action(async ({ args, program: program2 }) => {
+    const shell = args.shell ? String(args.shell) : "";
+    if (isCompletionShell(shell)) {
+      console.log(await getCompletionScript(program2, shell, config));
+      return 0;
+    }
+    console.log(`error: unsupported shell '${shell || EMPTY_DISPLAY_VALUE}'`);
+    console.log(`supported: ${completionShells.join(", ")}`);
+    return 1;
+  });
+};
+var isCompletionShell = (value) => {
+  return completionShells.includes(value);
+};
+var getCompletionScript = async (program, shell, config) => {
+  const binName = program.getBin();
+  const binNames = uniqueBinNames([binName, ...config.binNames ?? []]);
+  const commands = sortCommands(
+    (await program.getAllCommands()).filter(
+      (command) => command.visible && command.name !== COMPLETION_COMMAND_NAME
+    )
+  );
+  const roots = getRootCommands(commands);
+  const subcommands = getSubcommandGroups(commands);
+  const options = getCommandOptions(commands);
+  return completionScriptGenerators[shell](binNames, roots, subcommands, options, commands);
+};
+function getZshCompletionScript(binNames, roots, subcommands, options, commands) {
+  return binNames.map((binName) => formatZshCompletionScript(binName, roots, subcommands, options, commands)).join("\n\n");
+}
+function getBashCompletionScript(binNames, roots, subcommands, options, commands) {
+  return binNames.map((binName) => formatBashCompletionScript(binName, roots, subcommands, options, commands)).join("\n\n");
+}
+function formatZshCompletionScript(binName, roots, subcommands, options, commands) {
+  const functionName = completionFunctionName(binName);
+  return `#compdef ${binName}
+
+_${functionName}() {
+  local -a commands
+  commands=(
+${formatZshItems(roots)}
+  )
+${formatSubcommandArrays(subcommands)}
+${formatOptionArrays(options)}
+${formatZshCustomCompletions(binName, commands)}
+
+  if [[ "$words[$CURRENT]" == -* ]]; then
+    local command_key="$words[2]"
+    if [[ -n "$words[3]" && "$words[3]" != -* ]]; then
+      command_key="$command_key $words[3]"
+    fi
+    case "$command_key" in
+${formatOptionCases(binName, options)}
+    esac
+  fi
+
+  _arguments -C \\
+    '1:command:->command' \\
+    '2:subcommand:->subcommand'
+
+  case $state in
+    command)
+      _describe '${binName} commands' commands
+      ;;
+    subcommand)
+      case $words[2] in
+${formatZshCustomCases(binName, commands)}
+${formatSubcommandCases(binName, subcommands)}
+      esac
+      ;;
+  esac
+}
+
+compdef _${functionName} ${binName}`;
+}
+function formatBashCompletionScript(binName, roots, subcommands, options, commands) {
+  const functionName = `${completionFunctionName(binName)}_completion`;
+  return `_${functionName}() {
+  local cur command_key
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  command_key="\${COMP_WORDS[1]}"
+  if [[ -n "\${COMP_WORDS[2]}" && "\${COMP_WORDS[2]}" != -* ]]; then
+    command_key="\${command_key} \${COMP_WORDS[2]}"
+  fi
+  COMPREPLY=()
+
+  if [[ "$cur" == -* ]]; then
+    case "$command_key" in
+${formatBashOptionCases(options)}
+    esac
+    return 0
+  fi
+
+  case "$COMP_CWORD" in
+    1)
+      COMPREPLY=($(compgen -W "${roots.map((item) => item.name).join(" ")}" -- "$cur"))
+      ;;
+    2)
+      case "\${COMP_WORDS[1]}" in
+${formatBashCustomCases(binName, commands)}
+${formatBashSubcommandCases(subcommands)}
+      esac
+      ;;
+  esac
+}
+
+complete -F _${functionName} ${binName}`;
+}
+function getFishCompletionScript(binNames, roots, subcommands, options, commands) {
+  const rootNames = roots.map((item) => item.name).join(" ");
+  return `${binNames.map((name) => formatFishFunctions(name, rootNames)).join("\n")}
+${binNames.map((name) => formatFishCustomFunctions(name, commands)).join("\n")}
+${binNames.map((name) => `complete -c ${name} -f`).join("\n")}
+${binNames.map((name) => formatFishRootCompletions(name, roots)).join("\n")}
+${binNames.map((name) => formatFishSubcommandCompletions(name, subcommands)).join("\n")}
+${binNames.map((name) => formatFishOptionCompletions(name, options)).join("\n")}
+${binNames.map((name) => formatFishCustomCompletions(name, commands)).join("\n")}`;
+}
+var uniqueBinNames = (binNames) => [...new Set(binNames)];
+var sortCommands = (commands) => {
+  return [...commands].sort((left, right) => {
+    const leftOrder = getCommandMetadata(left)?.order;
+    const rightOrder = getCommandMetadata(right)?.order;
+    if (leftOrder !== void 0 || rightOrder !== void 0) {
+      return (leftOrder ?? Number.MAX_SAFE_INTEGER) - (rightOrder ?? Number.MAX_SAFE_INTEGER);
+    }
+    return left.name.localeCompare(right.name);
+  });
+};
+var getRootCommands = (commands) => {
+  const roots = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const parts = command.name.split(" ");
+    const root = parts[0];
+    if (!root || roots.has(root)) {
+      continue;
+    }
+    roots.set(root, {
+      name: root,
+      description: parts.length === 1 ? command.description : `${root} commands`
+    });
+  }
+  return [...roots.values()];
+};
+var getSubcommandGroups = (commands) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const [root, subcommand] = command.name.split(" ");
+    if (!root || !subcommand) {
+      continue;
+    }
+    const group = groups.get(root) ?? [];
+    if (!group.some((item) => item.name === subcommand)) {
+      group.push({ name: subcommand, description: command.description });
+    }
+    groups.set(root, group);
+  }
+  return groups;
+};
+var getCommandOptions = (commands) => {
+  const commandOptions = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const options = command.options.filter((option) => option.visible).flatMap(
+      (option) => option.allNotations.map((notation) => ({
+        name: notation,
+        description: option.description
+      }))
+    );
+    if (options.length > 0) {
+      commandOptions.set(command.name, options);
+    }
+  }
+  return commandOptions;
+};
+var formatZshItems = (items) => {
+  return items.map((item) => `    '${escapeZshItem(item)}'`).join("\n");
+};
+var formatSubcommandArrays = (groups) => {
+  return [...groups.entries()].map(
+    ([root, items]) => `
+  local -a ${root}_commands
+  ${root}_commands=(
+${formatZshItems(items)}
+  )`
+  ).join("\n");
+};
+var formatZshCustomCompletions = (binName, commands) => {
+  return commands.flatMap((command) => {
+    const functions = getCommandMetadata(command)?.completion?.zsh?.(binName).functions;
+    return functions ? [functions] : [];
+  }).join("\n");
+};
+var formatZshCustomCases = (binName, commands) => {
+  return commands.flatMap((command) => {
+    const complete = getCommandMetadata(command)?.completion?.zsh?.(binName).complete;
+    return complete ? [
+      `        ${command.name})
+${complete}
+          ;;`
+    ] : [];
+  }).join("\n");
+};
+var formatSubcommandCases = (binName, groups) => {
+  return [...groups.keys()].map(
+    (root) => `        ${root})
+          _describe '${binName} ${root} commands' ${root}_commands
+          ;;`
+  ).join("\n");
+};
+var formatOptionArrays = (groups) => {
+  return [...groups.entries()].map(
+    ([command, items]) => `
+  local -a ${optionVariable(command)}
+  ${optionVariable(command)}=(
+${formatZshItems(items)}
+  )`
+  ).join("\n");
+};
+var formatOptionCases = (binName, groups) => {
+  return [...groups.keys()].map(
+    (command) => `      ${JSON.stringify(command)})
+        _describe '${binName} ${command} options' ${optionVariable(command)}
+        return
+        ;;`
+  ).join("\n");
+};
+var formatBashCustomCases = (binName, commands) => {
+  return commands.flatMap((command) => {
+    const complete = getCommandMetadata(command)?.completion?.bash?.(binName);
+    return complete ? [
+      `        ${command.name})
+${complete}
+          ;;`
+    ] : [];
+  }).join("\n");
+};
+var formatBashSubcommandCases = (groups) => {
+  return [...groups.entries()].map(
+    ([root, items]) => `        ${root})
+          COMPREPLY=($(compgen -W "${items.map((item) => item.name).join(" ")}" -- "$cur"))
+          ;;`
+  ).join("\n");
+};
+var formatFishFunctions = (binName, rootNames) => {
+  return `function __${binName}_seen_command
+  set -l tokens (commandline -opc)
+  for token in $tokens[2..-1]
+    switch $token
+      case ${rootNames}
+        return 0
+    end
+  end
+  return 1
+end
+
+function __${binName}_using_command
+  set -l tokens (commandline -opc)
+  test (count $tokens) -ge 2; and test "$tokens[2]" = "$argv[1]"
+end`;
+};
+var formatFishCustomFunctions = (binName, commands) => {
+  return commands.flatMap((command) => {
+    const functions = getCommandMetadata(command)?.completion?.fish?.(binName).functions;
+    return functions ? [functions] : [];
+  }).join("\n");
+};
+var formatFishCustomCompletions = (binName, commands) => {
+  return commands.flatMap((command) => {
+    const complete = getCommandMetadata(command)?.completion?.fish?.(binName).complete;
+    return complete ? [complete] : [];
+  }).join("\n");
+};
+var formatFishRootCompletions = (binName, roots) => {
+  return roots.map(
+    (item) => `complete -c ${binName} -f -n "not __${binName}_seen_command" -a ${quoteFish(item.name)} -d ${quoteFish(item.description ?? "")}`
+  ).join("\n");
+};
+var formatFishSubcommandCompletions = (binName, groups) => {
+  return [...groups.entries()].flatMap(
+    ([root, items]) => items.map(
+      (item) => `complete -c ${binName} -f -n "__${binName}_using_command ${quoteFish(root)}" -a ${quoteFish(item.name)} -d ${quoteFish(item.description ?? "")}`
+    )
+  ).join("\n");
+};
+var formatBashOptionCases = (groups) => {
+  return [...groups.entries()].map(
+    ([command, items]) => `      ${JSON.stringify(command)})
+        COMPREPLY=($(compgen -W "${items.map((item) => item.name).join(" ")}" -- "$cur"))
+        ;;`
+  ).join("\n");
+};
+var formatFishOptionCompletions = (binName, groups) => {
+  return [...groups.entries()].flatMap(
+    ([command, items]) => items.map((item) => {
+      const nameOption = fishOptionName(item.name);
+      return `complete -c ${binName} -f -n "__${binName}_using_command ${quoteFish(command)}" ${nameOption} -d ${quoteFish(item.description ?? "")}`;
+    })
+  ).join("\n");
+};
+var fishOptionName = (name) => {
+  if (name.startsWith("--")) return `-l ${quoteFish(name.slice(2))}`;
+  if (name.startsWith("-")) return `-s ${quoteFish(name.slice(1))}`;
+  return `-a ${quoteFish(name)}`;
+};
+var completionFunctionName = (binName) => {
+  return binName.replace(/\W/g, "_");
+};
+var optionVariable = (command) => {
+  return `${command.replace(/\W/g, "_")}_options`;
+};
+var escapeZshItem = (item) => {
+  const text = item.description ? `${item.name}:${item.description}` : item.name;
+  return text.replace(/'/g, "'\\''");
+};
+var quoteFish = (value) => {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+};
+
+// src/cli/help.ts
+var programExamples = /* @__PURE__ */ new WeakMap();
+var setProgramExamples = (program, examples) => {
+  programExamples.set(program, examples);
+};
+var isGlobalHelpRequest = (args) => args.length === 0 || args.length === 1 && ["--help", "-h"].includes(args[0] ?? "");
+var printProgramHelp = async (program) => {
+  const help = cleanHelp(await captureHelp(() => program.run(["--help"])));
+  const examples = programExamples.get(program) ?? [];
+  console.log([help.trimEnd(), formatExamples(examples)].filter(Boolean).join("\n\n"));
+};
+async function captureHelp(callback) {
+  const originalLog = console.log;
+  const lines = [];
+  console.log = (...args) => {
+    lines.push(args.map(String).join(" "));
+  };
+  try {
+    await callback();
+  } finally {
+    console.log = originalLog;
+  }
+  return lines.join("\n");
+}
+function cleanHelp(help) {
+  return help.replace(
+    /COMMANDS\s+—\s+Type '[^']+ help <command>' to get some help about a command/g,
+    "COMMANDS"
+  );
+}
+function formatExamples(examples) {
+  if (examples.length === 0) return "";
+  return ["  EXAMPLES", "", ...examples.map((example) => `    ${example}`)].join("\n");
+}
+
+// src/cli/program.ts
+import { createRequire } from "module";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/command/loader.ts
+import { readdir } from "fs/promises";
+import { basename, join } from "path";
+import { pathToFileURL } from "url";
+var COMMAND_FILE_EXTENSION = ".ts";
+var IGNORED_COMMAND_FILES = /* @__PURE__ */ new Set(["index.ts", "options.ts"]);
+var loadCommandModules = async (commandsDir) => {
+  return loadCommandModulesFromFiles(await commandFiles(commandsDir));
+};
+var loadCommandModulesFromFiles = async (files) => {
+  return Promise.all(
+    files.map((file) => import(pathToFileURL(file).href))
+  );
+};
+var commandDefinitionsFromModules = (modules) => {
+  return modules.flatMap(
+    (module) => Object.values(module).flatMap(
+      (value) => isCommandAdapterExport(value) && value.metadata ? [value.metadata] : []
+    )
+  );
+};
+var commandExportsFromModules = (modules, isExport) => {
+  return modules.flatMap(
+    (module) => Object.entries(module).filter(([name, value]) => isExport(name, value)).map(([, value]) => value)
+  );
+};
+var commandFiles = async (dir) => {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const nestedFiles = await Promise.all(
+    entries.map((entry) => {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) return commandFiles(path);
+      if (entry.isFile() && isCommandFile(path)) return [path];
+      return [];
+    })
+  );
+  return nestedFiles.flat().sort();
+};
+var isCommandFile = (path) => {
+  const fileName = basename(path);
+  return path.endsWith(COMMAND_FILE_EXTENSION) && !IGNORED_COMMAND_FILES.has(fileName);
+};
+var isCommandAdapterExport = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const command = value;
+  return typeof command.cli === "function";
+};
+
+// src/constants.ts
+var DEFAULT_COMMANDS_DIR = "commands";
+var PROGRAM_NAME_ENV_SUFFIX = "_PROG_NAME";
+
+// src/cli/update.ts
+import { exec } from "child_process";
+import { platform } from "os";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var PackageManager = /* @__PURE__ */ ((PackageManager2) => {
+  PackageManager2["Npm"] = "npm";
+  PackageManager2["Pnpm"] = "pnpm";
+  PackageManager2["Yarn"] = "yarn";
+  return PackageManager2;
+})(PackageManager || {});
+var registerUpdateCommand = (program, options) => {
+  program.command("update", `Update ${options.packageName} to latest version`).action(async () => {
+    if (options.isDevRun) {
+      console.log("Skipping update because this is a dev command");
+      return 0;
+    }
+    console.log("Checking current version...");
+    const currentVersion = options.version ?? "0.0.0";
+    console.log("Checking latest version...");
+    const latestVersion = await getLatestVersion(options.packageName);
+    if (!latestVersion) {
+      console.log("error: could not fetch latest version from npm");
+      return 1;
+    }
+    console.log(`Current version: ${currentVersion}`);
+    console.log(`Latest version: ${latestVersion}`);
+    if (currentVersion === latestVersion) {
+      console.log(`${options.packageName} is already up to date`);
+      return 0;
+    }
+    console.log("Detecting package manager...");
+    const packageManager = await detectPackageManager(options.packageName);
+    if (!packageManager) {
+      console.log(`error: could not detect how ${options.packageName} was installed`);
+      console.log("Please update manually using your package manager");
+      return 1;
+    }
+    console.log(`Detected package manager: ${packageManager}`);
+    console.log(`Updating ${options.packageName} from ${currentVersion} to ${latestVersion}...`);
+    const { stdout, stderr } = await execAsync(updateCommand(packageManager, options.packageName));
+    console.log(
+      `${options.packageName} updated successfully from ${currentVersion} to ${latestVersion}`
+    );
+    if (stdout) console.log(stdout.trim());
+    if (stderr) console.log(stderr.trim());
+    return 0;
+  });
+};
+async function detectPackageManager(packageName) {
+  const globalBinPath = await getGlobalBinPath(packageName);
+  if (!globalBinPath) return await isInstalledWithNpm(packageName) ? "npm" /* Npm */ : null;
+  return getPackageManagerFromPath(globalBinPath) ?? "npm" /* Npm */;
+}
+function getPackageManagerFromPath(globalBinPath) {
+  const possiblePaths = [
+    { manager: "yarn" /* Yarn */, patterns: ["/yarn/", "\\yarn\\", "/.yarn/", "\\.yarn\\"] },
+    { manager: "pnpm" /* Pnpm */, patterns: ["/pnpm/", "\\pnpm\\", "/.pnpm/", "\\.pnpm\\"] },
+    {
+      manager: "npm" /* Npm */,
+      patterns: ["/npm/", "\\npm\\", "/node/", "\\node\\", "/node_modules/"]
+    }
+  ];
+  for (const { manager, patterns } of possiblePaths) {
+    if (patterns.some((pattern) => globalBinPath.includes(pattern))) return manager;
+  }
+  return null;
+}
+async function getGlobalBinPath(binName) {
+  const isWindows = platform() === "win32";
+  try {
+    const whereCommand = isWindows ? "where" : "which";
+    const { stdout } = await execAsync(`${whereCommand} ${binName}`);
+    const execPath = stdout.trim();
+    if (!execPath) return null;
+    if (isWindows) return execPath;
+    try {
+      const { stdout: realPath } = await execAsync(`readlink -f "${execPath}"`);
+      return realPath.trim() || execPath;
+    } catch {
+      return execPath;
+    }
+  } catch {
+    return null;
+  }
+}
+async function isInstalledWithNpm(packageName) {
+  try {
+    const { stdout } = await execAsync(`npm list -g --depth=0 ${packageName}`);
+    return stdout.includes(packageName);
+  } catch {
+    return false;
+  }
+}
+async function getLatestVersion(packageName) {
+  try {
+    const { stdout } = await execAsync(`npm view ${packageName} version`);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function updateCommand(packageManager, packageName) {
+  return {
+    ["npm" /* Npm */]: `npm update -g ${packageName}`,
+    ["pnpm" /* Pnpm */]: `pnpm update -g ${packageName}`,
+    ["yarn" /* Yarn */]: `yarn global upgrade ${packageName}`
+  }[packageManager];
+}
+
+// src/cli/program.ts
+var VERSION_OPTION = "-v, --version";
+var DISABLED_GLOBAL_OPTIONS = ["--no-color", "--quiet", "--silent", "-v", "-V"];
+var DEFAULT_CLI_VERSION = "0.0.0";
+var createCommandProgram = async ({
+  binName,
+  binNames,
+  commandsDir,
+  description,
+  getContext,
+  importMetaUrl,
+  isDevRun = false,
+  packageName,
+  printVersion = console.log,
+  version = DEFAULT_CLI_VERSION
+}) => {
+  const program = new (getProgramConstructor())().bin(binName).name(binName).description(description).version(version);
+  disableDefaultGlobalOptions(program);
+  registerVersionOption(program, version, printVersion);
+  const commandDefinitions = await registerCliCommandsFromDirectory({
+    binName,
+    commandsDir: commandsDir ?? defaultCommandsDir(importMetaUrl),
+    getContext,
+    program
+  });
+  registerUpdateCommand(program, { isDevRun, packageName: packageName ?? binName, version });
+  registerCompletionCommand(program, { binNames });
+  setProgramExamples(
+    program,
+    commandDefinitions.flatMap((command) => command.examples?.(binName) ?? [])
+  );
+  return program;
+};
+var registerParentCommandsFromDefinitions = (program, definitions, options = {}) => {
+  const description = options.description ?? parentCommandDescription;
+  const print = options.print ?? console.log;
+  for (const [name, subcommands] of parentCommands(definitions)) {
+    program.command(name, description(name)).action(() => {
+      print(`Usage: ${program.getBin()} ${name} <command>`);
+      print("");
+      print(`Available commands: ${subcommands.join(", ")}`);
+    });
+  }
+};
+var registerCliCommandsFromDirectory = async ({
+  binName,
+  commandsDir,
+  getContext,
+  program
+}) => {
+  const modules = await loadCommandModules(commandsDir);
+  const definitions = commandDefinitionsFromModules(modules);
+  registerParentCommandsFromDefinitions(program, definitions);
+  const commands = commandExportsFromModules(
+    modules,
+    (_name, value) => isCommandAdapterExport(value)
+  );
+  for (const command of commands.sort(compareCommands)) {
+    command.cli(program, { binName, getContext });
+  }
+  return definitions;
+};
+var getProgramConstructor = () => {
+  const require2 = createRequire(import.meta.url);
+  const module = require2("@caporal/core");
+  return module.Program;
+};
+var disableDefaultGlobalOptions = (program) => {
+  for (const option of DISABLED_GLOBAL_OPTIONS) {
+    program.disableGlobalOption(option);
+  }
+};
+var registerVersionOption = (program, version, printVersion) => {
+  program.option(VERSION_OPTION, "Show version", {
+    global: true,
+    action: () => {
+      printVersion(version);
+      return false;
+    }
+  });
+};
+var defaultCommandsDir = (importMetaUrl) => join2(dirname(fileURLToPath(importMetaUrl)), DEFAULT_COMMANDS_DIR);
+var compareCommands = (left, right) => {
+  const leftName = left.metadata?.name ?? "";
+  const rightName = right.metadata?.name ?? "";
+  const leftOrder = left.metadata?.order;
+  const rightOrder = right.metadata?.order;
+  if (leftOrder !== void 0 || rightOrder !== void 0) {
+    return (leftOrder ?? Number.MAX_SAFE_INTEGER) - (rightOrder ?? Number.MAX_SAFE_INTEGER);
+  }
+  return leftName.localeCompare(rightName);
+};
+var parentCommandDescription = (name) => `${name} commands`;
+var parentCommands = (definitions) => {
+  const groups = /* @__PURE__ */ new Map();
+  const commandNames = new Set(definitions.map((definition) => definition.name));
+  for (const definition of definitions) {
+    const [parent, subcommand] = definition.name.split(" ");
+    const hasGeneratedParentCommand = parent && subcommand && !commandNames.has(parent);
+    if (!hasGeneratedParentCommand) continue;
+    groups.set(parent, [...groups.get(parent) ?? [], subcommand]);
+  }
+  return [...groups.entries()].sort(([left], [right]) => left.localeCompare(right));
+};
+
+// src/package/json.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var PACKAGE_JSON_FILE = "package.json";
+var PACKAGE_JSON_ENCODING = "utf8";
+var packageRoot = (importMetaUrl) => {
+  const startDir = dirname2(fileURLToPath2(importMetaUrl));
+  return findPackageRoot(startDir);
+};
+var readPackageJson = (packageDir) => {
+  return JSON.parse(
+    readFileSync(join3(packageDir, PACKAGE_JSON_FILE), PACKAGE_JSON_ENCODING)
+  );
+};
+var shortPackageName = (name) => {
+  const packageName = name?.split("/").at(-1);
+  if (!packageName) {
+    throw new Error("Missing package name");
+  }
+  return packageName;
+};
+var packageEnvPrefix = (name) => shortPackageName(name).replaceAll("-", "_").toUpperCase();
+var packageBinEntry = (packageDir, packageJson) => {
+  const [commandName, binPath] = Object.entries(packageJson.bin ?? {})[0] ?? [];
+  if (!commandName || !binPath) {
+    throw new Error(`Missing bin in ${join3(packageDir, PACKAGE_JSON_FILE)}`);
+  }
+  return { binPath, commandName };
+};
+function findPackageRoot(startDir) {
+  const packageJsonPath = join3(startDir, PACKAGE_JSON_FILE);
+  if (existsSync(packageJsonPath)) return startDir;
+  const parentDir = dirname2(startDir);
+  if (parentDir === startDir) throw new Error(`Missing ${PACKAGE_JSON_FILE}`);
+  return findPackageRoot(parentDir);
+}
+
+// src/package/metadata.ts
+var packageCommandMetadata = (importMetaUrl, options = {}) => {
+  const packageDir = packageRoot(importMetaUrl);
+  const packageJson = readPackageJson(packageDir);
+  const packageName = shortPackageName(packageJson.name);
+  const { commandName } = packageBinEntry(packageDir, packageJson);
+  return {
+    binName: commandName,
+    binNames: Object.keys(packageJson.bin ?? {}),
+    description: packageJson.description,
+    envBinName: `${packageEnvPrefix(packageName)}${PROGRAM_NAME_ENV_SUFFIX}`,
+    mcpPrefix: packageName,
+    mcpServerName: mcpServerName(packageName, options.mcpServerPrefix),
+    packageDir,
+    packageName,
+    version: packageJson.version
+  };
+};
+var mcpServerName = (packageName, prefix) => prefix ? `${prefix}-${packageName}` : packageName;
+
+// src/cli/runtime.ts
+import { realpathSync } from "fs";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
+var getProgramBin = (config) => {
+  const envBinName = process.env[config.envBinName];
+  if (envBinName) {
+    return envBinName;
+  }
+  return config.defaultBinName;
+};
+var isDirectRun = (importMetaUrl) => {
+  if (!process.argv[1]) {
+    return false;
+  }
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath3(importMetaUrl));
+  } catch {
+    return importMetaUrl === pathToFileURL2(process.argv[1]).href;
+  }
+};
+
+// src/cli/runner.ts
+var createCliRunner = (config) => {
+  let programInstance;
+  let programInstanceBin;
+  const getProgram = async () => {
+    const binName = getProgramBin(config);
+    const shouldCreateProgram = !programInstance || programInstanceBin !== binName;
+    if (shouldCreateProgram) {
+      const program = await config.createProgram(binName);
+      programInstance = program;
+      programInstanceBin = binName;
+      return program;
+    }
+    return programInstance;
+  };
+  const runCli = async (args = process.argv.slice(2)) => {
+    try {
+      const program = await getProgram();
+      if (isGlobalHelpRequest(args)) {
+        await printProgramHelp(program);
+        return 0;
+      }
+      const result = await program.run(args);
+      return typeof result === "number" && result > 0 ? result : 0;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`error: ${message}`);
+      return 1;
+    }
+  };
+  return { isDirectRun: () => isDirectRun(config.importMetaUrl), runCli };
+};
+var createPackageCommandCliRunner = ({
+  defaultBinName,
+  envBinName,
+  importMetaUrl,
+  ...options
+}) => {
+  const metadata = packageCommandMetadata(importMetaUrl);
+  return createCommandCliRunner({
+    ...options,
+    binNames: options.binNames ?? metadata.binNames,
+    defaultBinName: defaultBinName ?? metadata.binName,
+    description: options.description ?? metadata.description ?? metadata.packageName,
+    envBinName: envBinName ?? metadata.envBinName,
+    importMetaUrl,
+    isDevRun: process.env[envBinName ?? metadata.envBinName] !== void 0,
+    packageName: metadata.packageName,
+    version: options.version ?? metadata.version
+  });
+};
+var createCommandCliRunner = ({
+  binNames,
+  commandsDir,
+  defaultBinName,
+  description,
+  envBinName,
+  getContext,
+  importMetaUrl,
+  isDevRun,
+  packageName,
+  printVersion,
+  version
+}) => {
+  return createCliRunner({
+    createProgram: (binName) => createCommandProgram({
+      binName,
+      binNames,
+      commandsDir,
+      description,
+      getContext,
+      importMetaUrl,
+      isDevRun,
+      packageName,
+      printVersion,
+      version
+    }),
+    defaultBinName,
+    envBinName,
+    importMetaUrl
+  });
+};
+
+// src/mcp/router.ts
+import { z as z3 } from "zod";
+
+// src/command/metadata.ts
+import { z } from "zod";
+var isCommandMcpToolMetadata = (metadata) => metadata !== void 0 && metadata !== false && metadata.kind === "tool";
+var isCommandMcpResourceMetadata = (metadata) => metadata !== void 0 && metadata !== false && metadata.kind === "resource";
+var defineCommand = (definition) => {
+  const command = {
+    outputSchema: z.unknown(),
+    ...definition
+  };
+  return {
+    ...command,
+    inputSchema: definition.inputSchema ?? commandDefinitionToZodInputSchema(command)
+  };
+};
+var registerCommand = (program, definition) => {
+  const command = definition.arguments?.reduce(
+    (currentCommand, argument) => currentCommand.argument(argument.synopsis, argument.description),
+    program.command(definition.name, definition.description, definition.config)
+  ) ?? program.command(definition.name, definition.description, definition.config);
+  const commandWithOptions = definition.options?.reduce(
+    (currentCommand, option) => currentCommand.option(commandOptionSynopsis(option), option.description, option.config),
+    command
+  ) ?? command;
+  const registeredCommand = definition.aliases?.reduce(
+    (currentCommand, alias) => currentCommand.alias(alias),
+    commandWithOptions
+  ) ?? commandWithOptions;
+  setCommandMetadata(registeredCommand, definition);
+  return registeredCommand;
+};
+var commandInputValue = (args, name) => args[name];
+var commandInputString = (args, name) => {
+  const value = commandInputValue(args, name);
+  return value === void 0 ? "" : String(value);
+};
+var commandActionInput = (definition, args, options) => normalizeCommandInputAliases(definition, {
+  ...normalizeArgumentInput(definition, args),
+  ...options
+});
+var normalizeCommandInputAliases = (definition, input) => ({
+  ...input,
+  ...Object.fromEntries(
+    (definition.options ?? []).flatMap((option) => {
+      const name = optionInputName(option);
+      if (input[name] !== void 0) return [];
+      const alias = optionAliasInputNames(option).find(
+        (candidate) => input[candidate] !== void 0
+      );
+      return alias ? [[name, input[alias]]] : [];
+    })
+  )
+});
+var normalizeArgumentInput = (definition, args) => ({
+  ...args,
+  ...Object.fromEntries(
+    (definition.arguments ?? []).map((argument) => {
+      const name = argumentName(argument.synopsis);
+      const value = commandInputValue(args, name);
+      return value === void 0 ? void 0 : [name, value];
+    }).filter((entry) => entry !== void 0)
+  )
+});
+var commandDefinitionToZodInputSchema = (definition) => {
+  const jsonSchema = commandDefinitionToInputSchema(definition);
+  const shape = Object.fromEntries(
+    Object.entries(jsonSchema.properties).map(([name, property]) => [
+      name,
+      zodInputProperty(property, jsonSchema.required.includes(name))
+    ])
+  );
+  return z.object(shape);
+};
+var commandDefinitionToInputSchema = (definition) => ({
+  type: "object",
+  properties: Object.fromEntries([
+    ...(definition.arguments ?? []).map((argument) => [
+      argumentName(argument.synopsis),
+      argumentSchema(argument)
+    ]),
+    ...(definition.options ?? []).map((option) => [
+      optionInputName(option),
+      option.schema ?? optionSchema(option)
+    ])
+  ]),
+  required: [
+    ...(definition.arguments ?? []).filter((argument) => isRequiredSynopsis(argument.synopsis)).map((argument) => argumentName(argument.synopsis)),
+    ...(definition.options ?? []).filter((option) => option.config?.required).map(optionInputName)
+  ],
+  additionalProperties: false
+});
+var zodInputProperty = (property, required) => {
+  const schema = zodProperty(property);
+  const describedSchema = property.description ? schema.describe(property.description) : schema;
+  return required ? describedSchema : describedSchema.optional();
+};
+var zodProperty = (property) => {
+  if (property.type === "array") return z.array(z.string());
+  if (property.type === "boolean") return z.boolean();
+  if (property.type === "number") return z.number();
+  return z.string();
+};
+var argumentSchema = (argument) => ({
+  type: isVariadicSynopsis(argument.synopsis) ? "array" : "string",
+  description: argument.description,
+  ...isVariadicSynopsis(argument.synopsis) ? { items: { type: "string" } } : {}
+});
+var optionSchema = (option) => ({
+  type: option.value ? "string" : "boolean",
+  description: option.description
+});
+var argumentName = (synopsis) => {
+  return kebabToCamel(
+    synopsis.replace(/[<>[\].]/g, "").replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase())
+  );
+};
+var commandOptionSynopsis = (option) => {
+  const longName = `${option.negated ? "--no-" : "--"}${option.name}`;
+  const aliases = (option.aliases ?? []).map(
+    (alias) => alias.length === 1 ? `-${alias}` : `--${alias}`
+  );
+  return [...aliases, `${longName}${option.value ? ` ${option.value}` : ""}`].join(", ");
+};
+var optionInputName = (option) => kebabToCamel(option.name);
+var optionAliasInputNames = (option) => (option.aliases ?? []).map(kebabToCamel);
+var kebabToCamel = (value) => value.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+var isRequiredSynopsis = (synopsis) => synopsis.trim().startsWith("<");
+var isVariadicSynopsis = (synopsis) => synopsis.includes("...");
+
+// src/mcp/constants.ts
+var DEFAULT_MCP_SERVER_VERSION = "0.0.0";
+var DEFAULT_RESOURCE_MIME_TYPE = "application/json";
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var JSON_RPC_METHOD_NOT_FOUND = -32601;
+var JSON_RPC_INTERNAL_ERROR = -32603;
+var JSON_RPC_VERSION = "2.0";
+var MCP_STATUS_COMPLETED = "completed";
+var MCP_STATUS_ERROR = "error";
+var MCP_TEXT_CONTENT_TYPE = "text";
+var TOOL_NAME_SEPARATOR = "_";
+var COMMAND_NAME_SEPARATOR = " ";
+var EMPTY_DISPLAY_VALUE2 = "<empty>";
+var RESULT_ENVELOPE_DATA_KEY = "data";
+var RESULT_ENVELOPE_PROGRESS_KEY = "progress";
+var PROGRESS_LIST_KEYS = ["items", "threads", "files", "events", "messages"];
+var CURSOR_KEYS = ["nextCursor", "nextPageToken"];
+var MCP_METHOD_INITIALIZE = "initialize";
+var MCP_METHOD_TOOLS_LIST = "tools/list";
+var MCP_METHOD_TOOLS_CALL = "tools/call";
+var MCP_METHOD_RESOURCES_LIST = "resources/list";
+var MCP_METHOD_RESOURCES_TEMPLATES_LIST = "resources/templates/list";
+var MCP_METHOD_RESOURCES_READ = "resources/read";
+
+// src/mcp/errors.ts
+var assertToolName = (expectedName, actualName) => {
+  if (actualName !== expectedName) {
+    throwUnknownTool(actualName);
+  }
+};
+var throwUnknownTool = (name) => {
+  throw new Error(`Unknown tool: ${name ?? EMPTY_DISPLAY_VALUE2}`);
+};
+
+// src/mcp/progress.ts
+var toolResult = (result, startedAt) => {
+  const envelope = resultEnvelope(result);
+  const data = envelope.data;
+  const structuredContent = {
+    status: MCP_STATUS_COMPLETED,
+    progress: progressSummary(data, startedAt, envelope.progress),
+    data
+  };
+  return {
+    structuredContent,
+    content: [{ type: MCP_TEXT_CONTENT_TYPE, text: JSON.stringify(structuredContent, null, 2) }]
+  };
+};
+var toolErrorResult = (caught, startedAt = Date.now()) => {
+  const message = caught instanceof Error ? caught.message : String(caught);
+  const structuredContent = {
+    status: MCP_STATUS_ERROR,
+    progress: { elapsedMs: elapsedMs(startedAt), errors: [message] },
+    error: { message }
+  };
+  return {
+    structuredContent,
+    content: [{ type: MCP_TEXT_CONTENT_TYPE, text: JSON.stringify(structuredContent, null, 2) }]
+  };
+};
+var commandProgressSummary = (data, command) => {
+  const mcp = command.mcp;
+  if (!isCommandMcpToolMetadata(mcp) || mcp.readOnly) {
+    return void 0;
+  }
+  const processed = processedOf(data) ?? countOf(data) ?? 1;
+  return { changed: processed, matched: processed, processed, skipped: 0 };
+};
+var progressSummary = (data, startedAt, progress) => {
+  const summary = {
+    count: countOf(data),
+    elapsedMs: elapsedMs(startedAt),
+    errors: [],
+    nextCursor: cursorOf(data),
+    processed: processedOf(data),
+    ...progress
+  };
+  return Object.fromEntries(Object.entries(summary).filter(([, value]) => value !== void 0));
+};
+var resultEnvelope = (result) => {
+  if (isRecord(result) && RESULT_ENVELOPE_DATA_KEY in result && RESULT_ENVELOPE_PROGRESS_KEY in result) {
+    return {
+      data: result[RESULT_ENVELOPE_DATA_KEY],
+      progress: recordOf(result[RESULT_ENVELOPE_PROGRESS_KEY])
+    };
+  }
+  return { data: result };
+};
+var recordOf = (value) => isRecord(value) ? value : void 0;
+var elapsedMs = (startedAt) => Date.now() - startedAt;
+var countOf = (data) => {
+  if (!isRecord(data)) return void 0;
+  return typeof data.count === "number" ? data.count : processedOf(data);
+};
+var processedOf = (data) => {
+  if (Array.isArray(data)) return data.length;
+  if (!isRecord(data)) return void 0;
+  const list = PROGRESS_LIST_KEYS.map((key) => data[key]).find(Array.isArray);
+  return list ? list.length : void 0;
+};
+var cursorOf = (data) => {
+  if (!isRecord(data)) return void 0;
+  const cursor = CURSOR_KEYS.map((key) => data[key]).find((value) => typeof value === "string");
+  return typeof cursor === "string" ? cursor : void 0;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// src/mcp/resources.ts
+var commandMcpRouteToResourceRoute = (route) => {
+  const mcp = route.command.mcp;
+  if (!isCommandMcpResourceMetadata(mcp)) return [];
+  const inputNames = resourceInputNames(mcp.uriTemplate);
+  return [
+    {
+      command: route.command,
+      handler: route.handler,
+      inputNames,
+      mimeType: mcp.mimeType ?? DEFAULT_RESOURCE_MIME_TYPE,
+      name: route.command.name,
+      uriTemplate: mcp.uriTemplate
+    }
+  ];
+};
+var commandResourceRouteToResource = (route) => ({
+  uri: route.uriTemplate,
+  name: route.name,
+  description: route.command.description,
+  mimeType: route.mimeType
+});
+var commandResourceRouteToResourceTemplate = (route) => ({
+  uriTemplate: route.uriTemplate,
+  name: route.name,
+  description: route.command.description,
+  mimeType: route.mimeType
+});
+var commandResourceInput = (route, uri) => {
+  if (!uri) return void 0;
+  const prefix = route.uriTemplate.split("{")[0] ?? "";
+  if (!uri.startsWith(prefix)) return void 0;
+  const values = uri.slice(prefix.length).split("/").filter(Boolean).map(decodeURIComponent);
+  if (values.length !== route.inputNames.length) return void 0;
+  return Object.fromEntries(
+    route.inputNames.map((inputName, index) => [inputName, values[index] ?? ""])
+  );
+};
+var isResourceTemplate = (uri) => resourceInputNames(uri).length > 0;
+var resourceResult = (params, data) => {
+  const resourceRead = params;
+  return {
+    contents: [
+      {
+        uri: resourceRead.uri ?? "",
+        mimeType: DEFAULT_RESOURCE_MIME_TYPE,
+        text: JSON.stringify({ data }, null, 2)
+      }
+    ]
+  };
+};
+var resourceInputNames = (uriTemplate) => [...uriTemplate.matchAll(/\{([^}]+)\}/g)].flatMap((match) => {
+  const inputName = match[1];
+  return inputName ? [inputName] : [];
+});
+
+// src/mcp/schema.ts
+import { z as z2 } from "zod";
+var mcpToolOutputSchema = (dataSchema) => ({
+  type: "object",
+  properties: {
+    data: z2.toJSONSchema(dataSchema),
+    progress: {
+      type: "object",
+      properties: {
+        count: { type: "number" },
+        elapsedMs: { type: "number" },
+        changed: { type: "number" },
+        errors: { type: "array", items: { type: "string" } },
+        matched: { type: "number" },
+        nextCursor: { type: "string" },
+        processed: { type: "number" },
+        skipped: { type: "number" }
+      },
+      required: ["elapsedMs", "errors"],
+      additionalProperties: false
+    },
+    status: { type: "string", enum: [MCP_STATUS_COMPLETED, MCP_STATUS_ERROR] }
+  },
+  required: ["data", "progress", "status"],
+  additionalProperties: false
+});
+var emptyMcpInputSchema = {
+  type: "object",
+  properties: {},
+  required: [],
+  additionalProperties: false
+};
+
+// src/mcp/router.ts
+var createCommandMcpRoute = ({
+  command,
+  handler,
+  inputSchema,
+  outputSchema
+}) => ({
+  command,
+  handler,
+  inputSchema,
+  outputSchema
+});
+var commandMcpRouteToTool = (route, prefix) => ({
+  name: commandNameToMcpToolName(route.command.name, prefix),
+  description: route.command.description,
+  inputSchema: z3.toJSONSchema(route.inputSchema),
+  outputSchema: mcpToolOutputSchema(route.outputSchema),
+  annotations: commandMcpAnnotations(route.command)
+});
+var commandNameToMcpToolName = (name, prefix) => {
+  const baseName = name.replaceAll(COMMAND_NAME_SEPARATOR, TOOL_NAME_SEPARATOR);
+  return prefix ? `${prefix}_${baseName}` : baseName;
+};
+var createCommandMcpRouter = ({ prefix, routes }) => {
+  const mcpRoutes = routes.filter((route) => route.command.mcp);
+  const toolRoutes = mcpRoutes.filter((route) => isCommandMcpToolMetadata(route.command.mcp));
+  const resourceRoutes = mcpRoutes.flatMap(commandMcpRouteToResourceRoute);
+  return {
+    tools: toolRoutes.map((route) => commandMcpRouteToTool(route, prefix)),
+    resources: resourceRoutes.filter((route) => !isResourceTemplate(route.uriTemplate)).map(commandResourceRouteToResource),
+    resourceTemplates: resourceRoutes.filter((route) => isResourceTemplate(route.uriTemplate)).map(commandResourceRouteToResourceTemplate),
+    callTool: async (params) => {
+      const toolCall = params;
+      const route = toolRoutes.find(
+        (candidate) => toolCall.name === commandNameToMcpToolName(candidate.command.name, prefix)
+      );
+      if (!route) {
+        return throwUnknownTool(toolCall.name);
+      }
+      const input = route.inputSchema.parse(toolCall.arguments ?? {});
+      const data = route.outputSchema.parse(await route.handler(input));
+      return { data, progress: commandProgressSummary(data, route.command) };
+    },
+    readResource: async (params) => {
+      const resourceRead = params;
+      const routeMatch = resourceRoutes.map((route) => ({ input: commandResourceInput(route, resourceRead.uri), route })).find((candidate) => candidate.input !== void 0);
+      if (!routeMatch?.input) {
+        throw new Error(`Unknown resource: ${resourceRead.uri ?? EMPTY_DISPLAY_VALUE2}`);
+      }
+      return routeMatch.route.command.outputSchema.parse(
+        await routeMatch.route.handler(routeMatch.input)
+      );
+    }
+  };
+};
+var commandMcpAnnotations = (command) => {
+  const mcp = command.mcp;
+  if (!isCommandMcpToolMetadata(mcp)) return void 0;
+  return {
+    readOnlyHint: mcp.readOnly,
+    destructiveHint: mcp.destructive,
+    idempotentHint: mcp.idempotent,
+    openWorldHint: mcp.openWorld,
+    requiresConfirmation: mcp.requiresConfirmation,
+    sideEffects: mcp.sideEffects
+  };
+};
+
+// src/command/adapters.ts
+function createCommandAdapters({
+  handler,
+  metadata,
+  print
+}) {
+  const parseInput = ({ args, options }) => metadata.inputSchema.parse(commandActionInput(metadata, args, options));
+  const run = async (input, context) => {
+    if (context === void 0) {
+      return handler(input);
+    }
+    return handler(context, input);
+  };
+  return {
+    metadata,
+    cli: (program, context) => {
+      registerCommand(program, metadata).action(async ({ args, options }) => {
+        const input = parseInput({ args, options });
+        const getContext = context?.getContext;
+        const resolvedContext = getContext ? await getContext() : void 0;
+        const output = await run(input, resolvedContext);
+        await print?.(output, input, resolvedContext);
+        return typeof output === "number" ? output : void 0;
+      });
+    },
+    handler,
+    mcp: (getContext) => createCommandMcpRoute({
+      command: metadata,
+      inputSchema: metadata.inputSchema,
+      outputSchema: metadata.outputSchema,
+      handler: async (args) => run(args, getContext ? await getContext() : void 0)
+    })
+  };
+}
+
+// src/docs/readme.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join4 } from "path";
+var generateReadmeCommandDocs = async ({
+  binName,
+  commandDefinitions = [],
+  commandsDir = join4(process.cwd(), "src", "commands"),
+  markerName = "COMMANDS",
+  readmePath = "README.md"
+}) => {
+  const readme = readFileSync2(readmePath, "utf8");
+  const loadedCommandDefinitions = commandDefinitionsFromModules(
+    await loadCommandModules(commandsDir)
+  );
+  const generated = formatCommandDocs(
+    [...commandDefinitions, ...loadedCommandDefinitions],
+    binName
+  );
+  writeFileSync(readmePath, replaceMarker(readme, markerName, generated), "utf8");
+};
+var formatCommandDocs = (commands, binName) => {
+  const visibleCommands = commands.filter(isVisibleCommand).sort(commandSort);
+  const groups = [...parentCommands2(visibleCommands)].map(
+    ([parent, subcommands]) => parentCommandDocs(parent, subcommands, binName)
+  );
+  const standaloneCommands = visibleCommands.filter((command) => !command.name.includes(" "));
+  if (standaloneCommands.length > 0) groups.push(otherCommandDocs(standaloneCommands, binName));
+  const lines = groups.flatMap(
+    (commandLines, index) => index === 0 ? commandLines : ["", ...commandLines]
+  );
+  return ["```sh", ...lines, "```"].join("\n");
+};
+var isVisibleCommand = (command) => command.config?.visible !== false;
+var commandSort = (left, right) => (left.order ?? 0) - (right.order ?? 0) || left.name.localeCompare(right.name);
+var parentCommands2 = (commands) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const [parent, subcommand] = command.name.split(" ");
+    if (!parent || !subcommand) continue;
+    groups.set(parent, [...groups.get(parent) ?? [], command]);
+  }
+  return [...groups.entries()].sort(([left], [right]) => left.localeCompare(right));
+};
+var parentCommandDocs = (parent, commands, binName) => [`# ${parent} commands`, ...commands.flatMap((command) => commandDocs(command, binName))];
+var otherCommandDocs = (commands, binName) => [
+  "# other commands",
+  ...commands.flatMap((command) => commandDocs(command, binName))
+];
+var commandDocs = (command, binName) => [
+  `${binName} ${command.name}${usageSuffix(command)}`
+];
+var usageSuffix = (command) => {
+  const args = command.arguments?.map((arg) => arg.synopsis) ?? [];
+  const options = command.options?.map((option) => optionUsage(option)) ?? [];
+  const usage = [...args, ...options];
+  return usage.length > 0 ? ` ${usage.join(" ")}` : "";
+};
+var optionUsage = (option) => {
+  const synopsis = option.value ? commandOptionSynopsis(option) : `--${option.name}`;
+  return option.config?.required ? synopsis : `[${synopsis}]`;
+};
+var replaceMarker = (source, markerName, replacement) => {
+  const startMarker = `<!-- <DYNFIELD:${markerName}> -->`;
+  const endMarker = `<!-- </DYNFIELD:${markerName}> -->`;
+  const hasOneMarkerPair = countOccurrences(source, startMarker) === 1 && countOccurrences(source, endMarker) === 1;
+  if (!hasOneMarkerPair) throw new Error(`${readmeMarkerError(startMarker, endMarker)}`);
+  const before = source.slice(0, source.indexOf(startMarker) + startMarker.length);
+  const after = source.slice(source.indexOf(endMarker));
+  return `${before}
+${replacement}
+${after}`;
+};
+var readmeMarkerError = (startMarker, endMarker) => `README must contain one ${startMarker} and one ${endMarker}`;
+var countOccurrences = (source, value) => source.split(value).length - 1;
+
+// src/mcp/command-server.ts
+import { dirname as dirname3, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/mcp/server.ts
+import { createInterface } from "readline";
+var createSingleToolMcpServer = ({
+  serverName,
+  tool,
+  callTool
+}) => {
+  return createMcpServer({
+    name: serverName,
+    tools: [tool],
+    callTool: (params) => {
+      const toolCall = params;
+      assertToolName(tool.name, toolCall.name);
+      return callTool(toolCall.arguments ?? {});
+    }
+  });
+};
+var createMcpServer = ({
+  name,
+  tools,
+  resources = [],
+  resourceTemplates = [],
+  callTool,
+  readResource
+}) => {
+  const send = (message) => {
+    process.stdout.write(`${JSON.stringify(message)}
+`);
+  };
+  const result = (id, value) => {
+    send({ jsonrpc: JSON_RPC_VERSION, id, result: value });
+  };
+  const error = (id, code, message) => {
+    send({ jsonrpc: JSON_RPC_VERSION, id, error: { code, message } });
+  };
+  const handleRequest = async (request) => {
+    if (request.method === MCP_METHOD_INITIALIZE) {
+      result(request.id, {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: { resources: {}, tools: {} },
+        serverInfo: { name, version: DEFAULT_MCP_SERVER_VERSION }
+      });
+      return;
+    }
+    if (request.method === MCP_METHOD_TOOLS_LIST) {
+      result(request.id, { tools });
+      return;
+    }
+    if (request.method === MCP_METHOD_RESOURCES_LIST) {
+      result(request.id, { resources });
+      return;
+    }
+    if (request.method === MCP_METHOD_RESOURCES_TEMPLATES_LIST) {
+      result(request.id, { resourceTemplates });
+      return;
+    }
+    if (request.method === MCP_METHOD_RESOURCES_READ) {
+      if (!readResource) {
+        error(
+          request.id,
+          JSON_RPC_METHOD_NOT_FOUND,
+          `Method not found: ${MCP_METHOD_RESOURCES_READ}`
+        );
+        return;
+      }
+      const startedAt = Date.now();
+      try {
+        result(request.id, resourceResult(request.params, await readResource(request.params)));
+      } catch (caught) {
+        result(request.id, toolErrorResult(caught, startedAt));
+      }
+      return;
+    }
+    if (request.method === MCP_METHOD_TOOLS_CALL) {
+      const startedAt = Date.now();
+      try {
+        result(request.id, toolResult(await callTool(request.params), startedAt));
+      } catch (caught) {
+        result(request.id, toolErrorResult(caught, startedAt));
+      }
+      return;
+    }
+    if (request.id !== void 0) {
+      error(
+        request.id,
+        JSON_RPC_METHOD_NOT_FOUND,
+        `Method not found: ${request.method ?? EMPTY_DISPLAY_VALUE2}`
+      );
+    }
+  };
+  return {
+    start: async () => {
+      const input = createInterface({ input: process.stdin });
+      for await (const line of input) {
+        if (!line.trim()) continue;
+        try {
+          await handleRequest(JSON.parse(line));
+        } catch (caught) {
+          error(
+            void 0,
+            JSON_RPC_INTERNAL_ERROR,
+            caught instanceof Error ? caught.message : String(caught)
+          );
+        }
+      }
+    }
+  };
+};
+
+// src/mcp/command-server.ts
+var loadCommandMcpRoutes = async (commandsDir, getContext = () => void 0) => {
+  const modules = await loadCommandModules(commandsDir);
+  const factories = commandExportsFromModules(
+    modules,
+    (_name, value) => isCommandAdapterExport(value)
+  ).flatMap((command) => command.mcp ? [command.mcp] : []);
+  return factories.map((factory) => factory(getContext)).filter((route) => route.command.mcp);
+};
+var createCommandMcpServer = async ({
+  commandsDir,
+  getContext,
+  importMetaUrl,
+  name,
+  prefix
+}) => {
+  const commandDirectory = commandsDir ?? join5(dirname3(fileURLToPath4(importMetaUrl)), DEFAULT_COMMANDS_DIR);
+  const { tools, resources, resourceTemplates, callTool, readResource } = createCommandMcpRouter({
+    prefix,
+    routes: await loadCommandMcpRoutes(commandDirectory, getContext)
+  });
+  return createMcpServer({ name, tools, resources, resourceTemplates, callTool, readResource });
+};
+var startCommandMcpServer = async (options) => {
+  await (await createCommandMcpServer(options)).start();
+};
+var startPackageCommandMcpServer = async ({
+  importMetaUrl,
+  mcpServerPrefix,
+  name,
+  prefix,
+  ...options
+}) => {
+  const metadata = packageCommandMetadata(importMetaUrl, { mcpServerPrefix });
+  await startCommandMcpServer({
+    ...options,
+    importMetaUrl,
+    name: name ?? metadata.mcpServerName,
+    prefix: prefix ?? metadata.mcpPrefix
+  });
+};
+
+// src/scripts/dev-command.ts
+import { mkdirSync, rmSync as rmSync2 } from "fs";
+import { join as join7 } from "path";
+
+// src/scripts/shims.ts
+import { execFileSync } from "child_process";
+import { chmodSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join6 } from "path";
+var POSIX_SHIM_MODE = 493;
+var WINDOWS_PLATFORM = "win32";
+var NPM_COMMAND = "npm";
+var NPM_WINDOWS_COMMAND = "npm.cmd";
+var NPM_PREFIX_ARGS = ["config", "get", "prefix"];
+var COMMAND_OUTPUT_ENCODING = "utf8";
+var WINDOWS_NPM_DIR = ["AppData", "Roaming", "npm"];
+var NODE_MODULES_BIN = ["node_modules", ".bin"];
+var TSX_BIN = "tsx";
+var TSX_WINDOWS_BIN = "tsx.cmd";
+var installCommandShim = (binDir, config) => {
+  if (process.platform === WINDOWS_PLATFORM) {
+    installWindowsShim(binDir, config);
+    return;
+  }
+  installPosixShim(binDir, config);
+};
+var getBinDir = (envName) => {
+  const envValue = process.env[envName];
+  if (envValue) {
+    return envValue;
+  }
+  if (process.platform === WINDOWS_PLATFORM) {
+    return getNpmPrefix() ?? join6(homedir(), ...WINDOWS_NPM_DIR);
+  }
+  return join6(homedir(), ".local", "bin");
+};
+var installPosixShim = (binDir, config) => {
+  const target = join6(binDir, config.commandName);
+  rmSync(target, { force: true });
+  writeFileSync2(target, getPosixShim(config));
+  chmodSync(target, POSIX_SHIM_MODE);
+};
+var installWindowsShim = (binDir, config) => {
+  const target = join6(binDir, `${config.commandName}.cmd`);
+  rmSync(target, { force: true });
+  writeFileSync2(target, getWindowsShim(config));
+};
+var getNpmPrefix = () => {
+  try {
+    return execFileSync(
+      process.platform === WINDOWS_PLATFORM ? NPM_WINDOWS_COMMAND : NPM_COMMAND,
+      NPM_PREFIX_ARGS,
+      {
+        encoding: COMMAND_OUTPUT_ENCODING,
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+  } catch {
+    return null;
+  }
+};
+var getPosixShim = (config) => {
+  return `#!/usr/bin/env sh
+set -eu
+export ${config.programNameEnvName}=${config.commandName}
+exec ${shellQuote(join6(config.packageDir, ...NODE_MODULES_BIN, TSX_BIN))} ${shellQuote(config.cliPath)} "$@"
+`;
+};
+var getWindowsShim = (config) => {
+  return `@echo off
+set "${config.programNameEnvName}=${config.commandName}"
+"${join6(config.packageDir, ...NODE_MODULES_BIN, TSX_WINDOWS_BIN)}" "${config.cliPath}" %*
+`;
+};
+var shellQuote = (value) => {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+};
+
+// src/scripts/dev-command.ts
+var DEV_BIN_DIR_ENV_SUFFIX = "_DEV_BIN_DIR";
+var SOURCE_CLI_PATH = "src/cli.ts";
+var installDevCommand = (config) => {
+  const binDir = getBinDir(config.binDirEnvName);
+  mkdirSync(binDir, { recursive: true });
+  installCommandShim(binDir, config);
+};
+var installPackageDevCommand = (importMetaUrl, options) => {
+  installDevCommand(packageDevCommandConfig(importMetaUrl, options));
+};
+var installPackageDevCommands = (importMetaUrl, options) => {
+  for (const commandName of options.commandNames) {
+    installPackageDevCommand(importMetaUrl, { commandName });
+  }
+};
+var uninstallDevCommand = (config) => {
+  const binDir = getBinDir(config.binDirEnvName);
+  rmSync2(join7(binDir, config.commandName), { force: true });
+  rmSync2(join7(binDir, `${config.commandName}.cmd`), { force: true });
+};
+var uninstallPackageDevCommand = (importMetaUrl, options) => {
+  const { binDirEnvName, commandName } = packageDevCommandConfig(importMetaUrl, options);
+  uninstallDevCommand({ binDirEnvName, commandName });
+};
+var uninstallPackageDevCommands = (importMetaUrl, options) => {
+  for (const commandName of options.commandNames) {
+    uninstallPackageDevCommand(importMetaUrl, { commandName });
+  }
+};
+var packageDevCommandConfig = (importMetaUrl, options) => {
+  const packageDir = packageRoot(importMetaUrl);
+  const packageJson = readPackageJson(packageDir);
+  const appEnvPrefix = packageEnvPrefix(packageJson.name);
+  return {
+    binDirEnvName: `${appEnvPrefix}${DEV_BIN_DIR_ENV_SUFFIX}`,
+    cliPath: join7(packageDir, SOURCE_CLI_PATH),
+    commandName: options.commandName,
+    packageDir,
+    programNameEnvName: `${appEnvPrefix}${PROGRAM_NAME_ENV_SUFFIX}`
+  };
+};
+export {
+  DEFAULT_COMMANDS_DIR,
+  PROGRAM_NAME_ENV_SUFFIX,
+  PackageManager,
+  assertToolName,
+  commandActionInput,
+  commandDefinitionToInputSchema,
+  commandDefinitionToZodInputSchema,
+  commandDefinitionsFromModules,
+  commandExportsFromModules,
+  commandInputString,
+  commandInputValue,
+  commandMcpRouteToResourceRoute,
+  commandMcpRouteToTool,
+  commandNameToMcpToolName,
+  commandOptionSynopsis,
+  commandResourceInput,
+  commandResourceRouteToResource,
+  commandResourceRouteToResourceTemplate,
+  createCliRunner,
+  createCommandAdapters,
+  createCommandCliRunner,
+  createCommandMcpRoute,
+  createCommandMcpRouter,
+  createCommandMcpServer,
+  createCommandProgram,
+  createMcpServer,
+  createPackageCommandCliRunner,
+  createSingleToolMcpServer,
+  defineCommand,
+  emptyMcpInputSchema,
+  formatCommandDocs,
+  generateReadmeCommandDocs,
+  getBinDir,
+  getPackageManagerFromPath,
+  getProgramBin,
+  getProgramConstructor,
+  installCommandShim,
+  installDevCommand,
+  installPackageDevCommand,
+  installPackageDevCommands,
+  isCommandAdapterExport,
+  isCommandMcpResourceMetadata,
+  isCommandMcpToolMetadata,
+  isDirectRun,
+  isGlobalHelpRequest,
+  isResourceTemplate,
+  loadCommandMcpRoutes,
+  loadCommandModules,
+  loadCommandModulesFromFiles,
+  mcpToolOutputSchema,
+  normalizeCommandInputAliases,
+  packageBinEntry,
+  packageCommandMetadata,
+  packageEnvPrefix,
+  packageRoot,
+  printProgramHelp,
+  readPackageJson,
+  registerCliCommandsFromDirectory,
+  registerCommand,
+  registerCompletionCommand,
+  registerParentCommandsFromDefinitions,
+  registerUpdateCommand,
+  resourceResult,
+  setProgramExamples,
+  shortPackageName,
+  startCommandMcpServer,
+  startPackageCommandMcpServer,
+  throwUnknownTool,
+  uninstallDevCommand,
+  uninstallPackageDevCommand,
+  uninstallPackageDevCommands,
+  z4 as z
+};
+//# sourceMappingURL=index.js.map