@reliverse/rempts 2.2.9 → 2.3.1

package/dist/launcher/help.js

@@ -1,145 +0,0 @@
-import pMap from "@reliverse/mapkit";
-import { re } from "@reliverse/relico";
-const HELP_TEMPLATES = {
-  commandHeader: (name, description) => `
-${re.bold.cyan(name)} - ${re.gray(description)}`,
-  version: (version) => `${re.yellow("Version:")} ${re.white(version)}`,
-  usage: (name) => `
-${re.bold("Usage:")}
-  ${re.green(name)} ${re.gray("[options]")}`,
-  usageWithSubCommands: (name) => `
-${re.bold("Usage:")}
-  ${re.green(name)} ${re.gray("[subcommand] [options]")}`,
-  usageWithPositionals: (name, positionalStr) => `
-${re.bold("Usage:")}
-  ${re.green(name)} ${positionalStr} ${re.gray("[options]")}`,
-  optionsHeader: `
-${re.bold("Options:")}`,
-  argumentsHeader: `
-${re.bold("Arguments:")}`,
-  requiredNote: `
-${re.red("*")} = ${re.gray("required")}`,
-  examplesHeader: `
-${re.bold("Examples:")}`,
-  globalHeader: `
-${re.bold("Available commands:")}
-`,
-  helpFooter: `
-${re.gray('Use "command --help" for command-specific help')}
-`
-};
-const getPositionalName = (name) => {
-  return name.toUpperCase();
-};
-const formatArgName = (name, def) => {
-  const aliases = def.aliases ? re.gray(` (-${def.aliases.join(", -")})`) : "";
-  const required = def.required ? re.red("*") : "";
-  return `${re.cyan(`--${name}`)}${aliases}${required}`;
-};
-const formatArgType = (def) => {
-  if (def.type === "boolean") return "";
-  return re.dim(`<${def.type}>`);
-};
-const getArgHelp = (name, def) => {
-  const argName = formatArgName(name, def);
-  const argType = formatArgType(def);
-  const desc = def.description ?? "";
-  const defaultVal = "default" in def && def.default !== void 0 ? re.gray(` (default: ${def.default})`) : "";
-  const allowedVal = "allowed" in def && def.allowed && def.allowed.length > 0 ? re.gray(
-    ` (allowed: ${def.allowed.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(", ")})`
-  ) : "";
-  return `  ${argName} ${argType}
-      ${desc}${defaultVal}${allowedVal}`;
-};
-const getPositionalArgHelp = (name, def) => {
-  const required = def.required ? re.red("*") : "";
-  const argName = `${re.cyan(getPositionalName(name))}${required}`;
-  const argType = def.type ? re.dim(`<${def.type}>`) : "";
-  const desc = def.description ?? "";
-  const defaultVal = "default" in def && def.default !== void 0 ? re.gray(` (default: ${def.default})`) : "";
-  const allowedVal = "allowed" in def && def.allowed && def.allowed.length > 0 ? re.gray(
-    ` (allowed: ${def.allowed.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(", ")})`
-  ) : "";
-  return `  ${argName} ${argType}
-      ${desc}${defaultVal}${allowedVal}`;
-};
-export const generateCommandHelp = async (definition) => {
-  const { meta, args } = definition;
-  const lines = [
-    HELP_TEMPLATES.commandHeader(
-      meta.name,
-      meta.description || "No description available"
-    )
-  ];
-  if (meta.version) {
-    lines.push(HELP_TEMPLATES.version(meta.version));
-  }
-  const positionalArgs = [];
-  const flagArgs = [];
-  for (const [name, def] of Object.entries(args)) {
-    if (def.positional === true) {
-      positionalArgs.push([name, def]);
-    } else {
-      flagArgs.push([name, def]);
-    }
-  }
-  let positionalStr = "";
-  if (positionalArgs.length > 0) {
-    const positionalParts = positionalArgs.map(
-      ([name, def]) => `${def.required ? "" : "["}${getPositionalName(name)}${def.required ? "" : "]"}`
-    );
-    positionalStr = positionalParts.join(" ");
-  }
-  if (positionalArgs.length > 0) {
-    lines.push(HELP_TEMPLATES.usageWithPositionals(meta.name, positionalStr));
-  } else {
-    lines.push(HELP_TEMPLATES.usage(meta.name));
-  }
-  if (positionalArgs.length > 0) {
-    lines.push(HELP_TEMPLATES.argumentsHeader);
-    for (const [name, def] of positionalArgs) {
-      lines.push(getPositionalArgHelp(name, def));
-    }
-    lines.push(HELP_TEMPLATES.requiredNote);
-  }
-  if (flagArgs.length > 0) {
-    lines.push(HELP_TEMPLATES.optionsHeader);
-    for (const [name, def] of flagArgs) {
-      lines.push(getArgHelp(name, def));
-    }
-    if (positionalArgs.length === 0) {
-      lines.push(HELP_TEMPLATES.requiredNote);
-    }
-  }
-  if (meta.examples && meta.examples.length > 0) {
-    lines.push(HELP_TEMPLATES.examplesHeader);
-    for (const example of meta.examples) {
-      lines.push(`  ${re.cyan(example)}`);
-    }
-  }
-  return lines.join("\n");
-};
-const formatCommandHelp = (name, metadata) => {
-  const aliases = metadata.aliases ? re.gray(` (${metadata.aliases.join(", ")})`) : "";
-  const description = metadata.description || "No description available";
-  return `  ${re.cyan(name)}${aliases}
-      ${re.gray(description)}`;
-};
-export const generateGlobalHelp = async (registry) => {
-  const lines = [HELP_TEMPLATES.globalHeader];
-  const metadataResults = await pMap(
-    Array.from(registry.metadata.entries()),
-    async ([name, metadataLoader]) => {
-      const metadata = await metadataLoader();
-      return [name, metadata];
-    },
-    { concurrency: 5 }
-    // Limit concurrency for metadata loading
-  );
-  metadataResults.sort(([a], [b]) => a.localeCompare(b));
-  for (const [name, metadata] of metadataResults) {
-    lines.push(formatCommandHelp(name, metadata));
-  }
-  lines.push(HELP_TEMPLATES.helpFooter);
-  return lines.join("\n");
-};

package/dist/launcher/mod.d.ts

@@ -1,12 +0,0 @@
-import { LauncherError } from "./errors.js";
-export { defineArgs, defineCommand } from "./command.js";
-export { ArgumentValidationError, CommandLoadError, CommandNotFoundError, LauncherError, } from "./errors.js";
-export type { CmdArgDefinition, CmdArgsSchema, CmdDefinition, CmdHandler, CmdLoader, CmdMeta, CmdRegistry, DiscoveryResult, ParsedArgs, } from "./types.js";
-export type PackageManager = "bun" | "npm" | "yarn" | "pnpm";
-export interface LauncherOptions {
-    cmdsDir?: string;
-    onError?: (error: LauncherError) => void;
-    verbose?: boolean;
-    supportedPkgManagers?: PackageManager[];
-}
-export declare const runLauncher: (importMetaUrl: string, options?: LauncherOptions) => Promise<void>;

package/dist/launcher/mod.js

@@ -1,222 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { writeErrorLines } from "@reliverse/helpers";
-import { re } from "@reliverse/relico";
-import { logger } from "@reliverse/relinka";
-import { discoverCommands } from "./discovery.js";
-import {
-  CommandLoadError,
-  CommandNotFoundError,
-  LauncherError
-} from "./errors.js";
-import { generateCommandHelp, generateGlobalHelp } from "./help.js";
-import { kebabCase, parseArgs } from "./parser.js";
-import {
-  clearRegistry,
-  getRegistry,
-  resolveCommand,
-  setRegistry
-} from "./registry.js";
-export { defineArgs, defineCommand } from "./command.js";
-export {
-  ArgumentValidationError,
-  CommandLoadError,
-  CommandNotFoundError,
-  LauncherError
-} from "./errors.js";
-const getCallerDirectory = (importMetaUrl) => {
-  return dirname(fileURLToPath(importMetaUrl));
-};
-const detectPackageManager = (cwd) => {
-  if (typeof process.versions.bun !== "undefined") {
-    return "bun";
-  }
-  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (existsSync(join(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (existsSync(join(cwd, "package-lock.json"))) {
-    return "npm";
-  }
-  try {
-    const packageJsonPath = join(cwd, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const content = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-      if (content.packageManager) {
-        const pkgManager = content.packageManager.split("@")[0];
-        if (pkgManager === "bun" || pkgManager === "npm" || pkgManager === "yarn" || pkgManager === "pnpm") {
-          return pkgManager;
-        }
-      }
-    }
-  } catch {
-  }
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (userAgent.includes("pnpm")) {
-    return "pnpm";
-  }
-  if (userAgent.includes("yarn")) {
-    return "yarn";
-  }
-  if (userAgent.includes("npm")) {
-    return "npm";
-  }
-  return "npm";
-};
-export const runLauncher = async (importMetaUrl, options = {}) => {
-  const {
-    cmdsDir = "./cmds",
-    onError,
-    verbose = false,
-    supportedPkgManagers
-  } = options;
-  if (supportedPkgManagers && supportedPkgManagers.length > 0) {
-    const callerDir = getCallerDirectory(importMetaUrl);
-    const detectedPkgManager = detectPackageManager(callerDir);
-    if (!supportedPkgManagers.includes(detectedPkgManager)) {
-      const errorMessage = `\u274C Unsupported package manager: ${detectedPkgManager}. Supported: ${supportedPkgManagers.join(", ")}`;
-      if (onError) {
-        onError(new LauncherError(errorMessage, "UNSUPPORTED_PKG_MANAGER"));
-      } else {
-        writeErrorLines([`
-${re.red.bold(errorMessage)}
-`]);
-      }
-      process.exit(1);
-    }
-    if (verbose) {
-      console.debug(`\u2713 Package manager: ${detectedPkgManager}`);
-    }
-  }
-  try {
-    clearRegistry();
-    let registry = getRegistry();
-    if (!registry) {
-      const callerDir = getCallerDirectory(importMetaUrl);
-      if (verbose) {
-        console.debug(`\u{1F4CD} Caller directory: ${callerDir}`);
-      }
-      registry = await discoverCommands(cmdsDir, callerDir, verbose);
-      setRegistry(registry);
-    }
-    const argv = process.argv.slice(2);
-    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
-      logger.log(await generateGlobalHelp(registry));
-      process.exit(0);
-    }
-    let isSubCommand = false;
-    let parentName;
-    let subCommandName;
-    let parentNode;
-    let subCommandNode;
-    if (argv.length > 1 && !argv[1]?.startsWith("-")) {
-      const potentialParentName = resolveCommand(registry, argv[0]);
-      const potentialParentNode = registry.hierarchy.get(potentialParentName);
-      if (potentialParentNode && potentialParentNode.children.size > 0) {
-        const potentialSubCommandName = resolveCommand(registry, argv[1]);
-        const potentialSubCommandNode = registry.hierarchy.get(
-          potentialSubCommandName
-        );
-        if (potentialSubCommandNode && potentialSubCommandNode.parent === potentialParentName) {
-          isSubCommand = true;
-          parentName = potentialParentName;
-          subCommandName = potentialSubCommandName;
-          parentNode = potentialParentNode;
-          subCommandNode = potentialSubCommandNode;
-        }
-      }
-    }
-    if (isSubCommand && parentName && subCommandName && parentNode && subCommandNode) {
-      const parentDefinition = await parentNode.loader();
-      const subCommandDefinition = await subCommandNode.loader();
-      if (argv.includes("--help") || argv.includes("-h")) {
-        logger.log(await generateCommandHelp(subCommandDefinition));
-        process.exit(0);
-      }
-      const subCommandIndex = argv.findIndex(
-        (arg, index) => index > 0 && !arg.startsWith("-")
-      );
-      const parentArgs = [];
-      const subCommandArgsFiltered = [];
-      for (let i = 1; i < argv.length; i++) {
-        const arg = argv[i];
-        if (i === subCommandIndex) {
-          continue;
-        }
-        const isParentArg = Object.keys(parentDefinition.args).some((key) => {
-          const def = parentDefinition.args[key];
-          if (!def) return false;
-          const kebabKey = kebabCase(key);
-          return arg === `--${key}` || arg === `-${key}` || arg === `--${kebabKey}` || arg === `--no-${key}` || arg === `--no-${kebabKey}` || def.aliases?.some((alias) => {
-            const kebabAlias = kebabCase(alias);
-            return arg === `-${alias}` || arg === `--${alias}` || arg === `--${kebabAlias}` || arg === `--no-${alias}` || arg === `--no-${kebabAlias}`;
-          });
-        });
-        if (isParentArg) {
-          parentArgs.push(arg);
-          if (i + 1 < argv.length && !argv[i + 1]?.startsWith("-")) {
-            parentArgs.push(argv[i + 1]);
-            i++;
-          }
-        } else {
-          subCommandArgsFiltered.push(arg);
-        }
-      }
-      let parentParsedArgs = {};
-      if (parentArgs.length > 0) {
-        const { parsedArgs } = parseArgs(
-          [parentName, ...parentArgs],
-          parentDefinition.args
-        );
-        parentParsedArgs = parsedArgs;
-      }
-      const { parsedArgs: subCommandParsedArgs } = parseArgs(
-        [subCommandName, ...subCommandArgsFiltered],
-        subCommandDefinition.args
-      );
-      await subCommandDefinition.handler({
-        args: subCommandParsedArgs,
-        parentArgs: parentParsedArgs
-      });
-    } else {
-      const cmdNameOrAlias = argv[0];
-      const cmdName = resolveCommand(registry, cmdNameOrAlias);
-      const loader = registry.registry.get(cmdName);
-      if (!loader) {
-        throw new CommandNotFoundError(
-          cmdNameOrAlias,
-          Array.from(registry.registry.keys())
-        );
-      }
-      const definition = await loader();
-      if (argv.includes("--help") || argv.includes("-h")) {
-        logger.log(await generateCommandHelp(definition));
-        process.exit(0);
-      }
-      const { parsedArgs } = parseArgs(argv, definition.args);
-      await definition.handler({ args: parsedArgs });
-    }
-  } catch (error) {
-    if (error instanceof LauncherError) {
-      if (onError) {
-        onError(error);
-      } else {
-        const errorLines = [
-          `
-${re.red.bold("\u274C Error:")} ${re.red(error.message)}`
-        ];
-        if (error instanceof CommandLoadError && error.cause) {
-          errorLines.push(`${re.yellow("Cause:")} ${error.cause}`);
-        }
-        errorLines.push("");
-        writeErrorLines(errorLines);
-      }
-      process.exit(1);
-    } else {
-      throw error;
-    }
-  }
-};

package/dist/launcher/parser.d.ts

@@ -1,14 +0,0 @@
-import type { CmdArgsSchema } from "./types.js";
-interface ParseResult {
-    cmdName: string;
-    parsedArgs: Record<string, unknown>;
-}
-interface ChainParseResult {
-    cmdChain: string[];
-    parsedArgs: Record<string, unknown>[];
-    remainingArgs: string[];
-}
-export declare const kebabCase: (str: string) => string;
-export declare const parseArgs: (argv: string[], schema: CmdArgsSchema) => ParseResult;
-export declare const parseCommandChain: (argv: string[], schemas: CmdArgsSchema[]) => ChainParseResult;
-export {};

package/dist/launcher/parser.js

@@ -1,255 +0,0 @@
-import { ArgumentValidationError } from "./errors.js";
-import { validateArgValue } from "./validator.js";
-const camelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-export const kebabCase = (str) => {
-  if (!str) return str;
-  let result = str.replace(
-    /([a-z])([0-9])([A-Z])/g,
-    (_, g1, g2, g3) => `${g1}-${g2}${g3}`
-  );
-  result = result.replace(
-    /([a-z0-9])([A-Z])/g,
-    (match, g1, g2, offset, string) => {
-      if (offset > 0 && string[offset - 1] === "-") {
-        return match;
-      }
-      return `${g1}-${g2}`;
-    }
-  );
-  result = result.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2");
-  return result.toLowerCase();
-};
-const createSchemaMetadata = (schema) => {
-  const aliasMap = /* @__PURE__ */ new Map();
-  const camelCaseCache = /* @__PURE__ */ new Map();
-  const kebabCaseMap = /* @__PURE__ */ new Map();
-  const defaults = {};
-  const requiredKeys = /* @__PURE__ */ new Set();
-  const availableKeys = [];
-  for (const [key, def] of Object.entries(schema)) {
-    availableKeys.push(key);
-    const camelKey = camelCase(key);
-    if (camelKey !== key) {
-      camelCaseCache.set(key, camelKey);
-    }
-    const kebabKey = kebabCase(key);
-    if (kebabKey !== key) {
-      kebabCaseMap.set(kebabKey, key);
-    }
-    if (def.aliases) {
-      for (const alias of def.aliases) {
-        aliasMap.set(alias, key);
-        const camelAlias = camelCase(alias);
-        if (camelAlias !== alias) {
-          camelCaseCache.set(alias, camelAlias);
-        }
-        const kebabAlias = kebabCase(alias);
-        if (kebabAlias !== alias) {
-          kebabCaseMap.set(kebabAlias, key);
-        }
-      }
-    }
-    if ("default" in def && def.default !== void 0) {
-      if ("allowed" in def && def.allowed) {
-        if (!def.allowed.includes(def.default)) {
-          const allowedValues = def.allowed.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(", ");
-          throw new ArgumentValidationError(
-            key,
-            `Default value must be one of: ${allowedValues}. Got: ${typeof def.default === "string" ? `"${def.default}"` : def.default}`
-          );
-        }
-      }
-      defaults[key] = def.default;
-    }
-    if (def.required) {
-      requiredKeys.add(key);
-    }
-  }
-  return {
-    aliasMap,
-    camelCaseCache,
-    kebabCaseMap,
-    defaults,
-    requiredKeys,
-    availableKeys
-  };
-};
-const getSchemaMetadata = (schema) => {
-  return createSchemaMetadata(schema);
-};
-export const parseArgs = (argv, schema) => {
-  const [cmdName, ...rawArgs] = argv;
-  if (!cmdName) {
-    throw new ArgumentValidationError("command", "No command provided");
-  }
-  const positionalKeys = Object.entries(schema).filter(([, def]) => def.positional === true).map(([key]) => key);
-  return parseArgsWithPositionalSupport(
-    cmdName,
-    rawArgs,
-    schema,
-    positionalKeys
-  );
-};
-const parseArgsWithPositionalSupport = (cmdName, rawArgs, schema, positionalKeys) => {
-  const {
-    aliasMap,
-    camelCaseCache,
-    kebabCaseMap,
-    defaults,
-    requiredKeys,
-    availableKeys
-  } = getSchemaMetadata(schema);
-  const parsedArgs = { ...defaults };
-  let positionalIndex = 0;
-  for (let i = 0; i < rawArgs.length; i++) {
-    const arg = rawArgs[i];
-    if (!arg || !arg.startsWith("-")) {
-      if (!arg) continue;
-      if (positionalIndex < positionalKeys.length) {
-        const positionalKey = positionalKeys[positionalIndex];
-        const definition2 = schema[positionalKey];
-        let value2 = arg;
-        if (definition2.type === "number") {
-          value2 = Number(arg);
-          if (Number.isNaN(value2)) {
-            throw new ArgumentValidationError(
-              positionalKey,
-              `Expected number for positional argument "${positionalKey}", got "${arg}"`
-            );
-          }
-        }
-        validateArgValue(positionalKey, value2, definition2);
-        parsedArgs[positionalKey] = value2;
-        positionalIndex++;
-      } else {
-        throw new ArgumentValidationError(
-          `positional_${positionalIndex}`,
-          `Too many positional arguments. Expected ${positionalKeys.length}, got at least ${positionalIndex + 1}`
-        );
-      }
-      continue;
-    }
-    const isLongForm = arg.startsWith("--");
-    let flagName = arg.slice(isLongForm ? 2 : 1);
-    let isNegated = false;
-    if (isLongForm && flagName.startsWith("no-")) {
-      flagName = flagName.slice(3);
-      isNegated = true;
-    }
-    const actualKey = aliasMap.get(flagName) ?? kebabCaseMap.get(flagName) ?? camelCaseCache.get(flagName) ?? camelCase(flagName);
-    const definition = schema[actualKey];
-    if (!definition) {
-      throw new ArgumentValidationError(
-        flagName,
-        `Unknown argument. Available: ${availableKeys.join(", ")}`
-      );
-    }
-    if (definition.type === "boolean") {
-      if (isNegated) {
-        const nextArg3 = rawArgs[i + 1];
-        if (nextArg3 !== void 0 && !nextArg3.startsWith("-")) {
-          const lowerNext = nextArg3.toLowerCase();
-          if (lowerNext === "true" || lowerNext === "false" || lowerNext === "1" || lowerNext === "0" || lowerNext === "yes" || lowerNext === "no" || lowerNext === "on" || lowerNext === "off") {
-            throw new ArgumentValidationError(
-              flagName,
-              `--no-* flags cannot accept values. Use --${flagName} ${nextArg3} instead of --no-${flagName} ${nextArg3}`
-            );
-          }
-        }
-        const falseValue = false;
-        validateArgValue(actualKey, falseValue, definition);
-        parsedArgs[actualKey] = falseValue;
-        continue;
-      }
-      const nextArg2 = rawArgs[i + 1];
-      if (nextArg2 !== void 0 && !nextArg2.startsWith("-")) {
-        const lowerNext = nextArg2.toLowerCase();
-        if (lowerNext === "true" || lowerNext === "1" || lowerNext === "yes" || lowerNext === "on") {
-          const trueValue2 = true;
-          validateArgValue(actualKey, trueValue2, definition);
-          parsedArgs[actualKey] = trueValue2;
-          i++;
-          continue;
-        }
-        if (lowerNext === "false" || lowerNext === "0" || lowerNext === "no" || lowerNext === "off") {
-          const falseValue = false;
-          validateArgValue(actualKey, falseValue, definition);
-          parsedArgs[actualKey] = falseValue;
-          i++;
-          continue;
-        }
-      }
-      const trueValue = true;
-      validateArgValue(actualKey, trueValue, definition);
-      parsedArgs[actualKey] = trueValue;
-      continue;
-    }
-    const nextArg = rawArgs[++i];
-    if (nextArg === void 0 || nextArg.startsWith("-")) {
-      throw new ArgumentValidationError(
-        flagName,
-        `Expected value for argument "${flagName}"`
-      );
-    }
-    let value = nextArg;
-    if (definition.type === "number") {
-      value = Number(nextArg);
-      if (Number.isNaN(value)) {
-        throw new ArgumentValidationError(
-          flagName,
-          `Expected number, got "${nextArg}"`
-        );
-      }
-    }
-    validateArgValue(actualKey, value, definition);
-    parsedArgs[actualKey] = value;
-  }
-  for (const requiredKey of requiredKeys) {
-    if (!(requiredKey in parsedArgs)) {
-      throw new ArgumentValidationError(
-        requiredKey,
-        `Required argument "${requiredKey}" is missing`
-      );
-    }
-  }
-  return { cmdName, parsedArgs };
-};
-export const parseCommandChain = (argv, schemas) => {
-  const cmdChain = [];
-  const parsedArgs = [];
-  let remainingArgs = [...argv];
-  for (let i = 0; i < schemas.length; i++) {
-    const schema = schemas[i];
-    if (!schema) break;
-    let cmdName = "";
-    let argsStartIndex = 0;
-    for (let j = 0; j < remainingArgs.length; j++) {
-      const arg = remainingArgs[j];
-      if (arg && !arg.startsWith("-")) {
-        cmdName = arg;
-        argsStartIndex = j + 1;
-        break;
-      }
-    }
-    if (!cmdName) {
-      throw new ArgumentValidationError("command", "No command provided");
-    }
-    cmdChain.push(cmdName);
-    const commandArgs = [];
-    for (let j = argsStartIndex; j < remainingArgs.length; j++) {
-      const arg = remainingArgs[j];
-      if (!arg) continue;
-      if (!arg.startsWith("-")) {
-        remainingArgs = remainingArgs.slice(j);
-        break;
-      }
-      commandArgs.push(arg);
-    }
-    const { parsedArgs: cmdParsedArgs } = parseArgs(
-      [cmdName, ...commandArgs],
-      schema
-    );
-    parsedArgs.push(cmdParsedArgs);
-  }
-  return { cmdChain, parsedArgs, remainingArgs };
-};

package/dist/launcher/registry.d.ts

@@ -1,10 +0,0 @@
-import type { CmdNode, DiscoveryResult } from "./types.js";
-export declare const getRegistry: () => DiscoveryResult | null;
-export declare const setRegistry: (registry: DiscoveryResult) => void;
-export declare const clearRegistry: () => void;
-export declare const resolveCommand: (registry: DiscoveryResult, cmdNameOrAlias: string) => string;
-export declare const resolveCommandChain: (registry: DiscoveryResult, cmdChain: string[]) => {
-    parent?: CmdNode;
-    child?: CmdNode;
-    fullPath: string[];
-};