libretto 0.4.0 → 0.4.2

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

@@ -0,0 +1,776 @@
+import { z } from "zod";
+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.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.getImmediateRouteEntries([])) {
+      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;
+  }
+  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, parentPath = [], parentMiddlewares = []) {
+  const resolved = {
+    commands: [],
+    groups: [],
+    routeEntries: []
+  };
+  for (const [token, routeValue] of Object.entries(routes)) {
+    if (isGroup(routeValue)) {
+      const groupPath = [...parentPath, token];
+      resolved.groups.push({
+        routeKey: pathToRouteKey(groupPath),
+        path: groupPath,
+        description: routeValue.description
+      });
+      resolved.routeEntries.push({
+        kind: "group",
+        path: groupPath
+      });
+      const nested = resolveRouteTree(
+        routeValue.routes,
+        groupPath,
+        [...parentMiddlewares, ...routeValue.middlewares]
+      );
+      resolved.commands.push(...nested.commands);
+      resolved.groups.push(...nested.groups);
+      resolved.routeEntries.push(...nested.routeEntries);
+      continue;
+    }
+    const command2 = routeValue.getDefinition();
+    if (!command2.handler) {
+      throw new Error(`Command "${[...parentPath, token].join(" ")}" is missing a handler.`);
+    }
+    const path = [...parentPath, token];
+    resolved.commands.push({
+      routeKey: pathToRouteKey(path),
+      path,
+      description: command2.config.description,
+      input: command2.input,
+      middlewares: mergeInheritedMiddlewares(parentMiddlewares, command2.middlewares),
+      handler: command2.handler
+    });
+    resolved.routeEntries.push({
+      kind: "command",
+      path
+    });
+  }
+  return resolved;
+}
+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 value = void 0;
+      for (const candidate of normalizedCandidates) {
+        if (Object.prototype.hasOwnProperty.call(named, candidate)) {
+          value = named[candidate];
+          break;
+        }
+      }
+      output[key] = value;
+    }
+    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
+};