libretto 0.6.13 → 0.6.14

package/dist/cli/framework/simple-cli.js

@@ -1,880 +0,0 @@
-import { z } from "zod";
-const EXPERIMENTAL_COMMAND_PREFIX = "experimental";
-const EXPERIMENTAL_GROUP_DESCRIPTION = "Experimental commands";
-function toCamelCase(input2) {
-  return input2.replace(
-    /-([a-zA-Z0-9])/g,
-    (_match, letter) => letter.toUpperCase()
-  );
-}
-function toKebabCase(input2) {
-  return input2.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-}
-function zodObjectFromShape(shape) {
-  return z.object(shape);
-}
-function schemaAcceptsUndefined(schema) {
-  return schema.safeParse(void 0).success;
-}
-function pathToRouteKey(path) {
-  return path.join(".");
-}
-function pathStartsWith(path, prefix) {
-  if (prefix.length > path.length) return false;
-  return prefix.every((token, index) => path[index] === token);
-}
-function formatListEntry(label, description) {
-  return description ? `  ${label}  ${description}` : `  ${label}`;
-}
-function isHelpFlag(arg) {
-  return arg === "--help" || arg === "-h";
-}
-function parseBooleanFlagValue(rawValue, flagName) {
-  if (rawValue === "true") return true;
-  if (rawValue === "false") return false;
-  throw new Error(`Invalid value for --${flagName}: expected true or false.`);
-}
-function buildUsagePositionalToken(positional2) {
-  return schemaAcceptsUndefined(positional2.schema) ? `[${positional2.key}]` : `<${positional2.key}>`;
-}
-function buildNamedArgFlagName(key, spec) {
-  if (spec.source === "--") return "--";
-  return spec.name ?? toKebabCase(key);
-}
-function buildNamedArgHelpLabel(key, spec) {
-  if (spec.source === "--") return "-- <args...>";
-  const flagName = buildNamedArgFlagName(key, spec);
-  if (spec.kind === "flag") {
-    return `--${flagName}`;
-  }
-  return `--${flagName} <value>`;
-}
-function normalizeNamedArgToken(token) {
-  return token.replace(/^-{1,2}/, "");
-}
-class SimpleCLIInput {
-  constructor(normalize, schema, definition) {
-    this.normalize = normalize;
-    this.schema = schema;
-    this.definition = definition;
-  }
-  parse(raw) {
-    try {
-      return this.schema.parse(this.normalize(raw));
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        const messages = error.issues.map((issue) => issue.message).filter((message) => message.length > 0);
-        if (messages.length > 0) {
-          throw new Error(messages.join("\n"));
-        }
-      }
-      throw error;
-    }
-  }
-  getDefinition() {
-    return this.definition;
-  }
-  refine(check, message) {
-    const nextSchema = this.schema.refine(
-      (value) => Boolean(check(value)),
-      message ? { message } : void 0
-    );
-    return new SimpleCLIInput(this.normalize, nextSchema, this.definition);
-  }
-  superRefine(check) {
-    const nextSchema = this.schema.superRefine(check);
-    return new SimpleCLIInput(this.normalize, nextSchema, this.definition);
-  }
-}
-class SimpleCLICommandBuilder {
-  constructor(definition) {
-    this.definition = definition;
-  }
-  input(input2) {
-    return new SimpleCLICommandBuilder({
-      config: this.definition.config,
-      input: input2,
-      middlewares: this.definition.middlewares,
-      handler: this.definition.handler
-    });
-  }
-  use(middleware) {
-    return new SimpleCLICommandBuilder({
-      config: this.definition.config,
-      input: this.definition.input,
-      middlewares: [...this.definition.middlewares, middleware],
-      handler: this.definition.handler
-    });
-  }
-  handle(handler) {
-    return new SimpleCLICommandBuilder({
-      config: this.definition.config,
-      input: this.definition.input,
-      middlewares: this.definition.middlewares,
-      handler
-    });
-  }
-  getDefinition() {
-    return this.definition;
-  }
-}
-class SimpleCLIApp {
-  constructor(name, routes, config = {}) {
-    this.name = name;
-    const resolution = resolveRouteTree(routes);
-    this.globalNamed = config.globalNamed ?? {};
-    for (const group2 of resolution.groups) {
-      if (this.resolvedGroups.has(group2.routeKey)) {
-        throw new Error(`Duplicate group route key: ${group2.routeKey}`);
-      }
-      this.resolvedGroups.set(group2.routeKey, group2);
-    }
-    for (const command2 of resolution.commands) {
-      if (this.resolvedCommands.has(command2.routeKey)) {
-        throw new Error(`Duplicate command route key: ${command2.routeKey}`);
-      }
-      this.resolvedCommands.set(command2.routeKey, command2);
-    }
-    this.routeEntries = resolution.routeEntries;
-  }
-  resolvedCommands = /* @__PURE__ */ new Map();
-  resolvedGroups = /* @__PURE__ */ new Map();
-  routeEntries;
-  globalNamed;
-  getCommands() {
-    return [...this.resolvedCommands.values()].map((command2) => ({
-      routeKey: command2.routeKey,
-      path: command2.path,
-      description: command2.description
-    }));
-  }
-  async invoke(routeKey, rawInput, initialContext = {}) {
-    const command2 = this.resolvedCommands.get(routeKey);
-    if (!command2) {
-      throw new Error(`Unknown command route key "${routeKey}".`);
-    }
-    const input2 = command2.input ? command2.input.parse(rawInput) : rawInput;
-    let ctx = { ...initialContext };
-    const meta = {
-      routeKey: command2.routeKey,
-      path: command2.path,
-      description: command2.description
-    };
-    for (const middleware of command2.middlewares) {
-      const next = await middleware({ input: input2, ctx, command: meta });
-      if (next !== void 0) {
-        ctx = next;
-      }
-    }
-    return command2.handler({ input: input2, ctx, command: meta });
-  }
-  async run(args) {
-    const extractedGlobalArgs = this.extractGlobalArgs(args);
-    const normalizedArgs = extractedGlobalArgs.args;
-    const helpPath = this.resolveHelpPath(normalizedArgs);
-    if (helpPath) {
-      return this.renderHelp(helpPath);
-    }
-    const exactGroup = this.findGroupByPath(normalizedArgs);
-    if (exactGroup) {
-      return this.renderGroupHelp(exactGroup);
-    }
-    const parsed = this.parseInvocation(normalizedArgs);
-    return this.invoke(
-      parsed.routeKey,
-      this.injectGlobalNamedArgs(
-        parsed.routeKey,
-        parsed.rawInput,
-        extractedGlobalArgs.named
-      )
-    );
-  }
-  renderHelp(path = []) {
-    if (path.length === 0) {
-      return this.renderRootHelp();
-    }
-    const group2 = this.findGroupByPath(path);
-    if (group2) {
-      return this.renderGroupHelp(group2);
-    }
-    const command2 = this.findCommandByPath(path);
-    if (command2) {
-      return this.renderCommandHelp(command2);
-    }
-    throw new Error(`Unknown help topic "${path.join(" ")}".`);
-  }
-  resolveHelpPath(args) {
-    if (args.length === 0) return [];
-    if (args[0] === "help") {
-      return args.slice(1);
-    }
-    const passthroughIndex = args.indexOf("--");
-    const argsBeforePassthrough = passthroughIndex >= 0 ? args.slice(0, passthroughIndex) : args;
-    if (argsBeforePassthrough.length === 0) {
-      return null;
-    }
-    if (isHelpFlag(argsBeforePassthrough[0])) {
-      return [];
-    }
-    const helpFlagIndex = argsBeforePassthrough.findIndex(
-      (arg) => isHelpFlag(arg)
-    );
-    if (helpFlagIndex >= 0) {
-      return argsBeforePassthrough.slice(0, helpFlagIndex);
-    }
-    return null;
-  }
-  parseInvocation(args) {
-    const command2 = this.findBestMatchingCommand(args);
-    if (!command2) {
-      const exactGroup = this.findGroupByPath(args);
-      if (exactGroup) {
-        throw new Error(this.renderGroupHelp(exactGroup));
-      }
-      throw new Error(`Unknown command: ${args.join(" ")}`);
-    }
-    const rawInput = this.parseCommandInput(
-      command2,
-      args.slice(command2.path.length)
-    );
-    return {
-      routeKey: command2.routeKey,
-      rawInput
-    };
-  }
-  parseCommandInput(command2, args) {
-    const inputDefinition = command2.input?.getDefinition();
-    if (!inputDefinition) {
-      if (args.length > 0) {
-        throw new Error(
-          `Unexpected arguments for ${this.name} ${command2.path.join(" ")}.`
-        );
-      }
-      return {
-        positionals: [],
-        named: {}
-      };
-    }
-    const positionals = [];
-    const named = {};
-    const namedSpecs = buildNamedArgLookup(inputDefinition.named);
-    const passthroughEntry = Object.entries(inputDefinition.named).find(
-      ([, spec]) => spec.source === "--"
-    );
-    for (let index = 0; index < args.length; index++) {
-      const arg = args[index];
-      if (arg === "--") {
-        if (!passthroughEntry) {
-          throw new Error(
-            `Unexpected "--" for ${this.name} ${command2.path.join(" ")}.`
-          );
-        }
-        named["--"] = args.slice(index + 1);
-        break;
-      }
-      if (arg === "-") {
-        positionals.push(arg);
-        continue;
-      }
-      if (arg.startsWith("--")) {
-        const [rawName, inlineValue] = splitNamedArg(arg.slice(2));
-        const namedEntry = namedSpecs.get(rawName);
-        if (!namedEntry) {
-          throw new Error(`Unknown option: --${rawName}`);
-        }
-        const storeKey = buildNamedArgFlagName(namedEntry.key, namedEntry.spec);
-        named[storeKey] = readNamedArgValue(
-          args,
-          index,
-          rawName,
-          `--${rawName}`,
-          namedEntry.spec,
-          inlineValue,
-          namedSpecs
-        );
-        if (inlineValue === void 0 && namedEntry.spec.kind !== "flag") {
-          index += 1;
-        }
-        continue;
-      }
-      if (arg.startsWith("-")) {
-        const [rawName, inlineValue] = splitNamedArg(arg.slice(1));
-        const namedEntry = namedSpecs.get(rawName);
-        if (!namedEntry) {
-          throw new Error(`Unknown option: ${arg}`);
-        }
-        const storeKey = buildNamedArgFlagName(namedEntry.key, namedEntry.spec);
-        named[storeKey] = readNamedArgValue(
-          args,
-          index,
-          rawName,
-          `-${rawName}`,
-          namedEntry.spec,
-          inlineValue,
-          namedSpecs
-        );
-        if (inlineValue === void 0 && namedEntry.spec.kind !== "flag") {
-          index += 1;
-        }
-        continue;
-      }
-      positionals.push(arg);
-    }
-    validateParsedPositionals(
-      command2,
-      inputDefinition.positionals,
-      positionals
-    );
-    validateRequiredNamedArgs(inputDefinition.named, named);
-    return {
-      positionals,
-      named
-    };
-  }
-  extractGlobalArgs(args) {
-    if (Object.keys(this.globalNamed).length === 0) {
-      return {
-        args,
-        named: {}
-      };
-    }
-    const remainingArgs = [];
-    const named = {};
-    const namedSpecs = buildNamedArgLookup(this.globalNamed);
-    for (let index = 0; index < args.length; index += 1) {
-      const arg = args[index];
-      if (arg === "--") {
-        remainingArgs.push(...args.slice(index));
-        break;
-      }
-      if (arg.startsWith("--")) {
-        const [rawName, inlineValue] = splitNamedArg(arg.slice(2));
-        const namedEntry = namedSpecs.get(rawName);
-        if (!namedEntry) {
-          remainingArgs.push(arg);
-          continue;
-        }
-        named[namedEntry.key] = readNamedArgValue(
-          args,
-          index,
-          rawName,
-          `--${rawName}`,
-          namedEntry.spec,
-          inlineValue,
-          namedSpecs
-        );
-        if (inlineValue === void 0 && namedEntry.spec.kind !== "flag") {
-          index += 1;
-        }
-        continue;
-      }
-      if (arg.startsWith("-")) {
-        const [rawName, inlineValue] = splitNamedArg(arg.slice(1));
-        const namedEntry = namedSpecs.get(rawName);
-        if (!namedEntry) {
-          remainingArgs.push(arg);
-          continue;
-        }
-        named[namedEntry.key] = readNamedArgValue(
-          args,
-          index,
-          rawName,
-          `-${rawName}`,
-          namedEntry.spec,
-          inlineValue,
-          namedSpecs
-        );
-        if (inlineValue === void 0 && namedEntry.spec.kind !== "flag") {
-          index += 1;
-        }
-        continue;
-      }
-      remainingArgs.push(arg);
-    }
-    return {
-      args: remainingArgs,
-      named
-    };
-  }
-  injectGlobalNamedArgs(routeKey, rawInput, globalNamed) {
-    if (Object.keys(globalNamed).length === 0) {
-      return rawInput;
-    }
-    const inputDefinition = this.resolvedCommands.get(routeKey)?.input?.getDefinition();
-    if (!inputDefinition) {
-      return rawInput;
-    }
-    const named = { ...rawInput.named ?? {} };
-    let changed = false;
-    for (const key of Object.keys(inputDefinition.named)) {
-      if (Object.prototype.hasOwnProperty.call(named, key)) continue;
-      if (!Object.prototype.hasOwnProperty.call(globalNamed, key)) continue;
-      named[key] = globalNamed[key];
-      changed = true;
-    }
-    if (!changed) {
-      return rawInput;
-    }
-    return {
-      positionals: rawInput.positionals ?? [],
-      named
-    };
-  }
-  renderRootHelp() {
-    const lines = [`Usage: ${this.name} <command>`, "", "Commands:"];
-    for (const entry of this.getRootHelpEntries()) {
-      lines.push(formatListEntry(entry.label, entry.description));
-    }
-    return lines.join("\n");
-  }
-  renderGroupHelp(group2) {
-    const lines = [];
-    if (group2.description) {
-      lines.push(group2.description, "");
-    }
-    lines.push(`Usage: ${this.name} ${group2.path.join(" ")} <subcommand>`);
-    lines.push("", "Commands:");
-    for (const entry of this.getImmediateRouteEntries(group2.path)) {
-      lines.push(formatListEntry(entry.label, entry.description));
-    }
-    return lines.join("\n");
-  }
-  renderCommandHelp(command2) {
-    const lines = [
-      command2.description,
-      "",
-      `Usage: ${this.buildCommandUsage(command2)}`
-    ];
-    const inputDefinition = command2.input?.getDefinition();
-    if (!inputDefinition) {
-      return lines.join("\n");
-    }
-    const argumentLines = inputDefinition.positionals.map(
-      (positional2) => formatListEntry(buildUsagePositionalToken(positional2), positional2.help)
-    );
-    if (argumentLines.length > 0) {
-      lines.push("", "Arguments:");
-      lines.push(...argumentLines);
-    }
-    const optionLines = Object.entries(inputDefinition.named).map(
-      ([key, spec]) => formatListEntry(buildNamedArgHelpLabel(key, spec), spec.help)
-    );
-    if (optionLines.length > 0) {
-      lines.push("", "Options:");
-      lines.push(...optionLines);
-    }
-    return lines.join("\n");
-  }
-  buildCommandUsage(command2) {
-    const tokens = [this.name, ...command2.path];
-    const inputDefinition = command2.input?.getDefinition();
-    if (!inputDefinition) {
-      return tokens.join(" ");
-    }
-    tokens.push(...inputDefinition.positionals.map(buildUsagePositionalToken));
-    if (Object.keys(inputDefinition.named).length > 0) {
-      tokens.push("[options]");
-    }
-    return tokens.join(" ");
-  }
-  getImmediateRouteEntries(path) {
-    const seen = /* @__PURE__ */ new Set();
-    const entries = [];
-    for (const routeEntry of this.routeEntries) {
-      if (!pathStartsWith(routeEntry.path, path)) continue;
-      if (routeEntry.path.length !== path.length + 1) continue;
-      const token = routeEntry.path[path.length];
-      if (seen.has(token)) continue;
-      seen.add(token);
-      if (routeEntry.kind === "group") {
-        const group2 = this.findGroupByPath(routeEntry.path);
-        entries.push({
-          label: `${token} <subcommand>`,
-          description: group2?.description
-        });
-        continue;
-      }
-      const command2 = this.findCommandByPath(routeEntry.path);
-      entries.push({
-        label: token,
-        description: command2?.description
-      });
-    }
-    return entries;
-  }
-  getRootHelpEntries() {
-    return this.getImmediateRouteEntries([]).filter((entry) => {
-      const token = entry.label.replace(/\s+<subcommand>$/, "");
-      const group2 = this.findGroupByPath([token]);
-      if (!group2) {
-        return true;
-      }
-      if (token === EXPERIMENTAL_COMMAND_PREFIX) {
-        return this.groupHasExperimentalCommand(group2.path);
-      }
-      return this.groupHasVisibleNonExperimentalCommand(group2.path);
-    });
-  }
-  groupHasVisibleNonExperimentalCommand(path) {
-    for (const routeEntry of this.routeEntries) {
-      if (routeEntry.kind !== "command") continue;
-      if (!pathStartsWith(routeEntry.path, path)) continue;
-      const command2 = this.findCommandByPath(routeEntry.path);
-      if (command2 && !command2.experimental) {
-        return true;
-      }
-    }
-    return false;
-  }
-  groupHasExperimentalCommand(path) {
-    for (const routeEntry of this.routeEntries) {
-      if (routeEntry.kind !== "command") continue;
-      if (!pathStartsWith(routeEntry.path, path)) continue;
-      const command2 = this.findCommandByPath(routeEntry.path);
-      if (command2?.experimental) {
-        return true;
-      }
-    }
-    return false;
-  }
-  findBestMatchingCommand(args) {
-    let bestMatch = null;
-    for (const command2 of this.resolvedCommands.values()) {
-      if (command2.path.length > args.length) continue;
-      if (!pathStartsWith(args, command2.path)) continue;
-      if (!bestMatch || command2.path.length > bestMatch.path.length) {
-        bestMatch = command2;
-      }
-    }
-    return bestMatch;
-  }
-  findCommandByPath(path) {
-    const routeKey = pathToRouteKey(path);
-    return this.resolvedCommands.get(routeKey) ?? null;
-  }
-  findGroupByPath(path) {
-    const routeKey = pathToRouteKey(path);
-    return this.resolvedGroups.get(routeKey) ?? null;
-  }
-}
-function splitNamedArg(arg) {
-  const separatorIndex = arg.indexOf("=");
-  if (separatorIndex < 0) return [arg, void 0];
-  return [arg.slice(0, separatorIndex), arg.slice(separatorIndex + 1)];
-}
-function readNamedArgValue(args, index, rawName, displayName, spec, inlineValue, namedSpecs) {
-  if (spec.kind === "flag") {
-    return inlineValue === void 0 ? true : parseBooleanFlagValue(inlineValue, rawName);
-  }
-  if (inlineValue !== void 0) {
-    return inlineValue;
-  }
-  const nextValue = args[index + 1];
-  if (nextValue === void 0 || nextValue === "--" || isRecognizedNamedArgToken(nextValue, namedSpecs)) {
-    throw new Error(`Missing value for ${displayName}.`);
-  }
-  return nextValue;
-}
-function isRecognizedNamedArgToken(token, namedSpecs) {
-  if (token === "-" || !token.startsWith("-")) {
-    return false;
-  }
-  const normalizedToken = token.startsWith("--") ? token.slice(2) : token.slice(1);
-  const [rawName] = splitNamedArg(normalizedToken);
-  return namedSpecs.has(rawName);
-}
-function buildNamedArgLookup(namedDefinition) {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const [key, spec] of Object.entries(namedDefinition)) {
-    if (spec.source === "--") continue;
-    const flagName = buildNamedArgFlagName(key, spec);
-    lookup.set(flagName, { key, spec });
-    lookup.set(key, { key, spec });
-    lookup.set(toCamelCase(flagName), { key, spec });
-    for (const alias of spec.aliases ?? []) {
-      const normalizedAlias = normalizeNamedArgToken(alias);
-      lookup.set(normalizedAlias, { key, spec });
-      lookup.set(toCamelCase(normalizedAlias), { key, spec });
-    }
-  }
-  return lookup;
-}
-function validateParsedPositionals(command2, definitions, positionals) {
-  const variadicDefinition = definitions.find(
-    (definition) => definition.variadic
-  );
-  if (!variadicDefinition && positionals.length > definitions.length) {
-    throw new Error(`Unexpected arguments for ${command2.path.join(" ")}.`);
-  }
-  definitions.forEach((definition, index) => {
-    const value = definition.variadic ? positionals.slice(index) : positionals[index];
-    if (value !== void 0 && (!Array.isArray(value) || value.length > 0))
-      return;
-    if (schemaAcceptsUndefined(definition.schema)) return;
-    throw new Error(`Missing required argument <${definition.key}>.`);
-  });
-}
-function validateInputDefinition(definition) {
-  const variadicIndex = definition.positionals.findIndex(
-    (positional2) => positional2.variadic
-  );
-  if (variadicIndex < 0) return;
-  if (variadicIndex !== definition.positionals.length - 1) {
-    throw new Error(
-      "Variadic positional arguments must be the last positional."
-    );
-  }
-}
-function validateRequiredNamedArgs(definitions, named) {
-  for (const [key, spec] of Object.entries(definitions)) {
-    if (schemaAcceptsUndefined(spec.schema)) continue;
-    const flagName = spec.source === "--" ? "--" : buildNamedArgFlagName(key, spec);
-    if (Object.prototype.hasOwnProperty.call(named, flagName)) continue;
-    if (spec.source === "--") {
-      throw new Error(`Missing required passthrough arguments after --.`);
-    }
-    throw new Error(`Missing required option --${flagName}.`);
-  }
-}
-function resolveRouteTree(routes) {
-  const collected = collectRouteTree(routes);
-  const { groups, routeEntries } = buildResolvedRouteEntries(
-    collected.commands,
-    collected.groupDescriptions
-  );
-  return {
-    commands: collected.commands,
-    groups,
-    routeEntries
-  };
-}
-function collectRouteTree(routes, parentPath = [], parentMiddlewares = []) {
-  const resolved = {
-    commands: [],
-    groupDescriptions: /* @__PURE__ */ new Map()
-  };
-  for (const [token, routeValue] of Object.entries(routes)) {
-    if (isGroup(routeValue)) {
-      const groupPath = [...parentPath, token];
-      resolved.groupDescriptions.set(
-        pathToRouteKey(groupPath),
-        routeValue.description
-      );
-      const nested = collectRouteTree(routeValue.routes, groupPath, [
-        ...parentMiddlewares,
-        ...routeValue.middlewares
-      ]);
-      resolved.commands.push(...nested.commands);
-      for (const [routeKey, description] of nested.groupDescriptions) {
-        resolved.groupDescriptions.set(routeKey, description);
-      }
-      continue;
-    }
-    const command2 = routeValue.getDefinition();
-    if (!command2.handler) {
-      throw new Error(
-        `Command "${[...parentPath, token].join(" ")}" is missing a handler.`
-      );
-    }
-    const rawPath = [...parentPath, token];
-    const path = command2.config.experimental ? [EXPERIMENTAL_COMMAND_PREFIX, ...rawPath] : rawPath;
-    resolved.commands.push({
-      routeKey: pathToRouteKey(path),
-      path,
-      description: command2.config.description,
-      experimental: command2.config.experimental,
-      input: command2.input,
-      middlewares: mergeInheritedMiddlewares(
-        parentMiddlewares,
-        command2.middlewares
-      ),
-      handler: command2.handler
-    });
-  }
-  return resolved;
-}
-function buildResolvedRouteEntries(commands, groupDescriptions) {
-  const groups = /* @__PURE__ */ new Map();
-  const routeEntries = [];
-  for (const command2 of commands) {
-    for (let depth = 1; depth < command2.path.length; depth += 1) {
-      const path = command2.path.slice(0, depth);
-      const routeKey = pathToRouteKey(path);
-      if (groups.has(routeKey)) continue;
-      groups.set(routeKey, {
-        routeKey,
-        path,
-        description: resolveGroupDescription(path, groupDescriptions)
-      });
-      routeEntries.push({
-        kind: "group",
-        path
-      });
-    }
-    routeEntries.push({
-      kind: "command",
-      path: command2.path
-    });
-  }
-  return {
-    groups: [...groups.values()],
-    routeEntries
-  };
-}
-function resolveGroupDescription(path, groupDescriptions) {
-  if (path.length === 1 && path[0] === EXPERIMENTAL_COMMAND_PREFIX) {
-    return EXPERIMENTAL_GROUP_DESCRIPTION;
-  }
-  const originalPath = path[0] === EXPERIMENTAL_COMMAND_PREFIX ? path.slice(1) : path;
-  return groupDescriptions.get(pathToRouteKey(originalPath));
-}
-function mergeInheritedMiddlewares(parentMiddlewares, commandMiddlewares) {
-  if (parentMiddlewares.length === 0) {
-    return [...commandMiddlewares];
-  }
-  if (commandMiddlewares.length >= parentMiddlewares.length && parentMiddlewares.every(
-    (middleware, index) => commandMiddlewares[index] === middleware
-  )) {
-    return [...commandMiddlewares];
-  }
-  return [...parentMiddlewares, ...commandMiddlewares];
-}
-function isGroup(value) {
-  return value.kind === "group";
-}
-function buildInputNormalizer(definition) {
-  return (raw) => {
-    const output = {};
-    const positionals = raw.positionals ?? [];
-    const named = raw.named ?? {};
-    definition.positionals.forEach((positional2, index) => {
-      output[positional2.key] = positional2.variadic ? positionals.slice(index) : positionals[index];
-    });
-    for (const [key, spec] of Object.entries(definition.named)) {
-      const sourceKey = spec.source === "--" ? "--" : spec.name ?? key;
-      const normalizedCandidates = [
-        sourceKey,
-        spec.name ? toCamelCase(spec.name) : "",
-        ...(spec.aliases ?? []).flatMap((alias) => {
-          const normalizedAlias = normalizeNamedArgToken(alias);
-          return [normalizedAlias, toCamelCase(normalizedAlias)];
-        }),
-        toKebabCase(key),
-        key
-      ].filter((candidate) => candidate.length > 0);
-      let found = false;
-      for (const candidate of normalizedCandidates) {
-        if (Object.prototype.hasOwnProperty.call(named, candidate)) {
-          output[key] = named[candidate];
-          found = true;
-          break;
-        }
-      }
-      if (!found && !Object.prototype.hasOwnProperty.call(output, key)) {
-        output[key] = void 0;
-      }
-    }
-    return output;
-  };
-}
-function buildInputSchema(definition) {
-  const shape = {};
-  for (const positional2 of definition.positionals) {
-    shape[positional2.key] = positional2.schema;
-  }
-  for (const [key, named] of Object.entries(definition.named)) {
-    shape[key] = named.schema;
-  }
-  return zodObjectFromShape(shape);
-}
-function positional(key, schema, options) {
-  return {
-    kind: "positional",
-    key,
-    schema,
-    help: options?.help,
-    variadic: options?.variadic
-  };
-}
-function option(schema, options) {
-  return {
-    kind: "option",
-    schema,
-    help: options?.help,
-    name: options?.name,
-    aliases: options?.aliases,
-    source: options?.source
-  };
-}
-function flag(options) {
-  return {
-    kind: "flag",
-    schema: z.boolean().default(false),
-    help: options?.help,
-    name: options?.name,
-    aliases: options?.aliases
-  };
-}
-function input(definition) {
-  validateInputDefinition(definition);
-  return new SimpleCLIInput(
-    buildInputNormalizer(definition),
-    buildInputSchema(definition),
-    definition
-  );
-}
-function command(config) {
-  return new SimpleCLICommandBuilder({
-    config,
-    middlewares: []
-  });
-}
-function group(config) {
-  return createScope([]).group(config);
-}
-function createScope(middlewares) {
-  return {
-    use(middleware) {
-      return createScope([
-        ...middlewares,
-        middleware
-      ]);
-    },
-    group(config) {
-      return {
-        kind: "group",
-        description: config.description,
-        routes: config.routes,
-        middlewares: [...middlewares]
-      };
-    },
-    command(config) {
-      return new SimpleCLICommandBuilder({
-        config,
-        middlewares: [...middlewares]
-      });
-    }
-  };
-}
-function use(middleware) {
-  return createScope([middleware]);
-}
-function define(name, routes, config) {
-  return new SimpleCLIApp(name, routes, config);
-}
-const SimpleCLI = {
-  define,
-  command,
-  group,
-  use,
-  input,
-  positional,
-  option,
-  flag
-};
-export {
-  SimpleCLI,
-  SimpleCLIApp,
-  SimpleCLICommandBuilder,
-  SimpleCLIInput
-};