@reliverse/rempts-core 1.6.1 → 2.3.2

package/dist/cli.js

@@ -0,0 +1,731 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { relico } from "@reliverse/relico";
+import { getDotPath, SchemaError } from "@standard-schema/utils";
+import { remptsConfigSchema, remptsConfigStrictSchema } from "./config.js";
+import { loadConfig } from "./config-loader.js";
+import { createFileCommandLoader } from "./file-loader.js";
+import { GLOBAL_FLAGS } from "./global-flags.js";
+import { parseArgs } from "./parser.js";
+import {
+  createPluginManager,
+  loadPlugins,
+  runAfterCommand,
+  runBeforeCommand,
+  runConfigResolved,
+  runSetup
+} from "./plugin/manager.js";
+import { getTuiRenderer } from "./tui/registry.js";
+export async function createApp(options = {}) {
+  const {
+    config: configOverride,
+    defaultCommand,
+    autoInit = true,
+    configDir: customConfigDir,
+    entryFile
+  } = options;
+  let configDir = customConfigDir || process.cwd();
+  if (!customConfigDir) {
+    const args = process.argv.slice(2);
+    const cwdIndex = args.indexOf("--cwd");
+    if (cwdIndex !== -1 && cwdIndex + 1 < args.length && args[cwdIndex + 1]) {
+      const cwdArg = args[cwdIndex + 1];
+      configDir = cwdArg.startsWith("/") ? cwdArg : resolve(process.cwd(), cwdArg);
+      args.splice(cwdIndex, 2);
+      process.argv = [process.argv[0] || "", process.argv[1] || "", ...args];
+    } else {
+      try {
+        await loadConfig(process.cwd());
+        configDir = process.cwd();
+      } catch {
+        const monorepoConfigDir = resolve(process.cwd(), "apps/dler");
+        try {
+          await loadConfig(monorepoConfigDir);
+          configDir = monorepoConfigDir;
+        } catch {
+          configDir = process.cwd();
+        }
+      }
+    }
+  }
+  let loadedConfigData = null;
+  try {
+    loadedConfigData = await loadConfig(configDir);
+  } catch {
+  }
+  const finalConfigOverride = (() => {
+    let baseConfig = loadedConfigData || configOverride;
+    if (loadedConfigData && configOverride) {
+      const { plugins: overridePlugins, ...overrideRest } = configOverride;
+      baseConfig = {
+        ...loadedConfigData,
+        ...overrideRest,
+        // Override plugins only if explicitly provided in configOverride
+        ...overridePlugins !== void 0 ? { plugins: overridePlugins } : {}
+      };
+    }
+    function resolveConfigPaths(obj, baseDir) {
+      if (typeof obj === "string" && obj.startsWith("./")) {
+        return resolve(baseDir, obj);
+      }
+      if (Array.isArray(obj)) {
+        return obj.map((item) => resolveConfigPaths(item, baseDir));
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          result[key] = resolveConfigPaths(value, baseDir);
+        }
+        return result;
+      }
+      return obj;
+    }
+    if (baseConfig) {
+      baseConfig = resolveConfigPaths(baseConfig, configDir);
+    }
+    if (baseConfig?.commands?.directory && typeof baseConfig.commands.directory === "string") {
+      baseConfig.commands.directory = baseConfig.commands.directory.startsWith(".") ? resolve(configDir, baseConfig.commands.directory) : baseConfig.commands.directory;
+    }
+    return baseConfig;
+  })();
+  const cli = await createCLI(finalConfigOverride || {}, entryFile);
+  if (autoInit) {
+    await cli.init();
+  }
+  if (defaultCommand) {
+    const originalRun = cli.run.bind(cli);
+    cli.run = async (argv = process.argv.slice(2)) => {
+      if (argv.length === 0 || argv[0]?.startsWith("-")) {
+        process.argv.splice(2, 0, defaultCommand);
+        argv = [defaultCommand, ...argv];
+      } else if (argv[0] && !argv[0].startsWith("-") && argv[0] !== defaultCommand) {
+        process.argv.splice(2, 0, defaultCommand);
+        argv = [defaultCommand, ...argv];
+      }
+      return originalRun(argv);
+    };
+  }
+  return cli;
+}
+function getEntryFileFromStack() {
+  try {
+    const stack = new Error("Stack trace").stack;
+    if (!stack) return void 0;
+    const lines = stack.split("\n");
+    for (let i = 2; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line) continue;
+      const match = line.match(/\(?(file:\/\/\/?|)([^:]+\.(ts|js|mjs)):\d+:\d+\)?/);
+      if (match) {
+        const filePath = match[2];
+        if (filePath && !filePath.includes("rempts-core") && !filePath.includes("node_modules")) {
+          if (filePath.startsWith("file://")) {
+            return fileURLToPath(filePath);
+          }
+          return filePath;
+        }
+      }
+    }
+  } catch (_error) {
+  }
+  return void 0;
+}
+export async function createCLI(configOverride, entryFile) {
+  let loadedConfigData = null;
+  try {
+    loadedConfigData = await loadConfig();
+  } catch {
+    loadedConfigData = null;
+  }
+  let baseConfig = loadedConfigData || remptsConfigSchema.assert(configOverride || {});
+  let cmdsDir;
+  const detectedEntryFile = entryFile || getEntryFileFromStack();
+  if (detectedEntryFile) {
+    const entryFilePath = detectedEntryFile.startsWith("file://") ? fileURLToPath(detectedEntryFile) : resolve(detectedEntryFile);
+    const entryDir = dirname(entryFilePath);
+    cmdsDir = join(entryDir, "cmds");
+  } else {
+    if (baseConfig.commands?.directory) {
+      cmdsDir = resolve(baseConfig.commands.directory);
+    } else {
+      cmdsDir = join(process.cwd(), "cmds");
+    }
+  }
+  baseConfig = {
+    ...baseConfig,
+    commands: {
+      ...baseConfig.commands,
+      directory: cmdsDir
+    }
+  };
+  const loadedConfig = baseConfig;
+  const mergedConfig = {
+    ...loadedConfig,
+    ...configOverride,
+    // Deep merge plugins arrays
+    plugins: configOverride?.plugins || loadedConfig.plugins || []
+  };
+  let fullConfig;
+  try {
+    if (mergedConfig.name && mergedConfig.version) {
+      fullConfig = remptsConfigStrictSchema.assert(mergedConfig);
+    } else {
+      const minimalConfig = {
+        name: mergedConfig.name || "cli",
+        version: mergedConfig.version || "1.0.0",
+        ...mergedConfig
+      };
+      fullConfig = remptsConfigStrictSchema.assert(minimalConfig);
+    }
+  } catch (error) {
+    throw new Error(
+      "[rempts] Invalid config: " + (error instanceof Error ? error.message : String(error))
+    );
+  }
+  const commands = /* @__PURE__ */ new Map();
+  const commandSources = /* @__PURE__ */ new Map();
+  const subcommandIndex = /* @__PURE__ */ new Map();
+  const beforeHooks = [];
+  const afterHooks = [];
+  let globalHookContext = {};
+  function getTerminalInfo() {
+    const isInteractive = process.stdout.isTTY;
+    const isCI = !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS);
+    return {
+      width: process.stdout.columns || 80,
+      height: process.stdout.rows || 24,
+      isInteractive,
+      isCI,
+      supportsColor: isInteractive && !isCI && process.env.TERM !== "dumb",
+      supportsMouse: isInteractive && !isCI && process.env.TERM_PROGRAM !== "Apple_Terminal"
+    };
+  }
+  const pluginManagerState = createPluginManager();
+  if (mergedConfig.plugins && mergedConfig.plugins.length > 0) {
+    await loadPlugins(pluginManagerState, mergedConfig.plugins);
+    const { config: updatedConfig, commands: pluginCommands } = await runSetup(
+      pluginManagerState,
+      fullConfig
+    );
+    fullConfig = remptsConfigStrictSchema.assert(updatedConfig);
+    if (pluginCommands.length > 0) {
+      console.warn(
+        "Warning: Plugin command registration is deprecated. Rempts is file-based only - register commands via file structure: <cmds-dir>/<cmd-name>/cmd.{ts,js,mjs}"
+      );
+      pluginCommands.forEach((cmd) => {
+        const cmdName = cmd.name || "unknown";
+        if (cmdName === "unknown") {
+          console.warn("Skipping plugin command without name - use file-based commands instead");
+          return;
+        }
+        registerCommand(cmdName, cmd, [], "directory");
+      });
+    }
+  }
+  const resolvedConfig = {
+    name: fullConfig.name,
+    version: fullConfig.version,
+    description: fullConfig.description || "",
+    commands: fullConfig.commands || {},
+    build: fullConfig.build || {
+      targets: ["native"],
+      compress: false,
+      minify: false,
+      sourcemap: true
+    },
+    dev: fullConfig.dev || {
+      watch: true,
+      inspect: false
+    },
+    test: fullConfig.test || {
+      pattern: ["**/*.test.ts", "**/*.spec.ts"],
+      coverage: false,
+      watch: false
+    },
+    workspace: fullConfig.workspace || {
+      versionStrategy: "fixed"
+    },
+    release: fullConfig.release || {
+      npm: true,
+      github: false,
+      tagFormat: "v{{version}}",
+      conventionalCommits: true
+    },
+    plugins: fullConfig.plugins || []
+  };
+  if (mergedConfig.plugins && mergedConfig.plugins.length > 0) {
+    await runConfigResolved(pluginManagerState, resolvedConfig);
+  }
+  function registerCommand(name, cmd, path = [], source = "directory") {
+    const fullName = [...path, name].join(" ");
+    if (commands.has(fullName)) {
+      return;
+    }
+    commands.set(fullName, cmd);
+    commandSources.set(fullName, source);
+    const nameParts = fullName.split(" ");
+    const validParts = nameParts.filter((part) => part.length > 0);
+    for (let i = 0; i < validParts.length - 1; i++) {
+      const parentName = validParts.slice(0, i + 1).join(" ");
+      if (!subcommandIndex.has(parentName)) {
+        subcommandIndex.set(parentName, /* @__PURE__ */ new Set());
+      }
+      subcommandIndex.get(parentName).add(fullName);
+    }
+    if (cmd.alias) {
+      const aliases = Array.isArray(cmd.alias) ? cmd.alias : [cmd.alias];
+      aliases.forEach((alias) => {
+        const aliasPath = [...path, alias].join(" ");
+        if (commands.has(aliasPath)) {
+          return;
+        }
+        commands.set(aliasPath, cmd);
+        commandSources.set(aliasPath, source);
+        const aliasParts = aliasPath.split(" ").filter((part) => part.length > 0);
+        for (let i = 0; i < aliasParts.length - 1; i++) {
+          const parentName = aliasParts.slice(0, i + 1).join(" ");
+          if (!subcommandIndex.has(parentName)) {
+            subcommandIndex.set(parentName, /* @__PURE__ */ new Set());
+          }
+          subcommandIndex.get(parentName).add(fullName);
+        }
+        const subcommandNames = subcommandIndex.get(fullName);
+        if (subcommandNames) {
+          if (!subcommandIndex.has(aliasPath)) {
+            subcommandIndex.set(aliasPath, /* @__PURE__ */ new Set());
+          }
+          for (const subCmdName of subcommandNames) {
+            subcommandIndex.get(aliasPath).add(subCmdName);
+          }
+        }
+      });
+    }
+  }
+  function findCommand(args) {
+    for (let i = args.length; i > 0; i--) {
+      const cmdPath = args.slice(0, i).join(" ");
+      const command = commands.get(cmdPath);
+      if (command) {
+        return { command, commandName: cmdPath, remainingArgs: args.slice(i) };
+      }
+    }
+    return { command: void 0, commandName: void 0, remainingArgs: args };
+  }
+  function showHelp(cmdName, cmd, path = []) {
+    if (cmd && cmdName) {
+      const fullPath = [...path, cmdName].join(" ");
+      console.log(relico.bold(`Usage: ${fullConfig.name} ${fullPath} [options]`));
+      console.log(`
+${relico.dim(cmd.description)}`);
+      if (cmd.options && Object.keys(cmd.options).length > 0) {
+        console.log(`
+${relico.bold("Options:")}`);
+        for (const [name, opt] of Object.entries(cmd.options)) {
+          const option = opt;
+          const flag = `--${name}${option.short ? `, -${option.short}` : ""}`;
+          const description = option.description || "";
+          console.log(`  ${relico.yellow(flag.padEnd(20))} ${relico.dim(description)}`);
+        }
+      }
+      const subcommandNames = subcommandIndex.get(fullPath);
+      const subCommands = [];
+      if (subcommandNames) {
+        const parentDepth = fullPath.split(" ").length;
+        for (const subCmdFullName of subcommandNames) {
+          if (subCmdFullName.split(" ").length === parentDepth + 1) {
+            const subCmdName = subCmdFullName.slice(fullPath.length + 1);
+            const command = commands.get(subCmdFullName);
+            if (command) {
+              subCommands.push({ name: subCmdName, command });
+            }
+          }
+        }
+      }
+      if (subCommands.length > 0) {
+        console.log(`
+${relico.bold("Subcommands:")}`);
+        for (const { name: subCmdName, command: subCmd } of subCommands) {
+          console.log(`  ${relico.green(subCmdName.padEnd(20))} ${relico.dim(subCmd.description)}`);
+        }
+      }
+    } else {
+      console.log(relico.bold(relico.cyan(`${fullConfig.name} v${fullConfig.version}`)));
+      if (fullConfig.description) {
+        console.log(relico.dim(fullConfig.description));
+      }
+      console.log(`
+${relico.bold("Commands:")}`);
+      for (const [name, command] of commands) {
+        if (!(name.includes(" ") || command.alias?.includes(name))) {
+          console.log(`  ${relico.green(name.padEnd(20))} ${relico.dim(command.description)}`);
+        }
+      }
+    }
+  }
+  function ensureRenderAvailable(commandName, command) {
+    if (!command.render) {
+      throw new Error(`Command ${commandName} does not support TUI rendering.`);
+    }
+    if (!getTuiRenderer()) {
+      throw new Error(
+        `TUI renderer not registered. Import '@reliverse/rempts-tui/register' or call registerTuiRenderer before running commands with render.`
+      );
+    }
+  }
+  async function loadFromConfig() {
+    if (fullConfig.commands?.directory) {
+      try {
+        const cmdsDir2 = fullConfig.commands.directory;
+        const fileLoader = createFileCommandLoader();
+        const commandTree = await fileLoader.loadFromDirectory(cmdsDir2);
+        const fileCommands = await fileLoader.loadCommandsFromTree(commandTree);
+        fileCommands.forEach(({ name, command }) => {
+          registerCommand(name, command, [], "directory");
+        });
+      } catch (error) {
+        console.error(
+          `Failed to load commands from directory ${fullConfig.commands.directory}:`,
+          error
+        );
+        throw error;
+      }
+    }
+  }
+  async function runCommandInternal(commandName, command, argv, providedFlags) {
+    let context;
+    let resultParsed;
+    try {
+      const mergedOptions = {
+        ...GLOBAL_FLAGS,
+        ...command.options || {}
+      };
+      const parsed = providedFlags ? (() => {
+        return parseArgs([], mergedOptions, commandName).then(
+          (p) => (Object.assign(p.flags, providedFlags), p)
+        );
+      })() : parseArgs(argv, mergedOptions, commandName);
+      resultParsed = await parsed;
+      const { prompt, spinner } = await import("@reliverse/rempts-utils");
+      if (mergedConfig.plugins && mergedConfig.plugins.length > 0) {
+        context = await runBeforeCommand(
+          pluginManagerState,
+          commandName,
+          command,
+          providedFlags ? [] : resultParsed.positional,
+          resultParsed.flags
+        );
+      }
+      if (beforeHooks.length > 0) {
+        globalHookContext = {};
+        const hookContext = {
+          flags: resultParsed.flags,
+          store: context?.store?.getState() || {},
+          env: process.env,
+          cwd: process.cwd(),
+          set: (key, value) => {
+            globalHookContext[key] = value;
+          },
+          get: (key) => {
+            return globalHookContext[key];
+          }
+        };
+        for (const hook of beforeHooks) {
+          await hook(hookContext);
+        }
+      }
+      const terminalInfo = getTerminalInfo();
+      const globalFlags = resultParsed.flags;
+      const runtimeInfo = {
+        startTime: Date.now(),
+        args: providedFlags ? [] : argv,
+        command: commandName
+      };
+      let render = false;
+      if (command.render) {
+        if (globalFlags["no-tui"]) {
+          render = false;
+        } else if (globalFlags.tui || globalFlags.interactive) {
+          render = true;
+        } else {
+          render = terminalInfo.isInteractive && !terminalInfo.isCI;
+        }
+      }
+      if (render) {
+        ensureRenderAvailable(commandName, command);
+        await getTuiRenderer()?.({
+          command,
+          flags: resultParsed.flags,
+          positional: resultParsed.positional,
+          shell: Bun.$,
+          env: process.env,
+          cwd: process.cwd(),
+          prompt,
+          spinner,
+          colors: relico,
+          terminal: terminalInfo,
+          runtime: runtimeInfo,
+          ...context ? { context } : {},
+          ...Object.keys(globalHookContext).length > 0 ? { hooks: globalHookContext } : {}
+        });
+      } else {
+        if (!command.handler) {
+          throw new Error("Command does not provide a handler for non-TUI execution");
+        }
+        const typedFlags = resultParsed.flags;
+        await command.handler({
+          flags: typedFlags,
+          positional: resultParsed.positional,
+          shell: Bun.$,
+          env: process.env,
+          cwd: process.cwd(),
+          prompt,
+          spinner,
+          colors: relico,
+          terminal: terminalInfo,
+          runtime: runtimeInfo,
+          ...context ? { context } : {},
+          ...Object.keys(globalHookContext).length > 0 ? { hooks: globalHookContext } : {}
+        });
+      }
+      if (mergedConfig.plugins && mergedConfig.plugins.length > 0 && context) {
+        await runAfterCommand(pluginManagerState, context, { exitCode: 0 });
+      }
+      if (afterHooks.length > 0) {
+        const hookContext = {
+          flags: resultParsed.flags,
+          store: context?.store?.getState() || {},
+          env: process.env,
+          cwd: process.cwd(),
+          set: () => {
+          },
+          // Not used in after hooks
+          get: () => void 0,
+          // Not used in after hooks
+          exitCode: 0
+        };
+        for (const hook of afterHooks) {
+          await hook(hookContext);
+        }
+      }
+    } catch (error) {
+      if (mergedConfig.plugins && mergedConfig.plugins.length > 0 && context) {
+        await runAfterCommand(pluginManagerState, context, { exitCode: 1 });
+      }
+      if (afterHooks.length > 0) {
+        const hookContext = {
+          flags: resultParsed?.flags || {},
+          store: context?.store?.getState() || {},
+          env: process.env,
+          cwd: process.cwd(),
+          set: () => {
+          },
+          // Not used in after hooks
+          get: () => void 0,
+          // Not used in after hooks
+          exitCode: 1,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+        for (const hook of afterHooks) {
+          await hook(hookContext);
+        }
+      }
+      if (error instanceof SchemaError) {
+        console.error(relico.red("Validation Error:"));
+        const generalErrors = [];
+        const fieldErrors = {};
+        for (const issue of error.issues) {
+          const path = getDotPath(issue);
+          if (path) {
+            if (!fieldErrors[path]) {
+              fieldErrors[path] = [];
+            }
+            fieldErrors[path].push(issue.message);
+          } else {
+            generalErrors.push(issue.message);
+          }
+        }
+        for (const [field, messages] of Object.entries(fieldErrors)) {
+          console.error(relico.dim(`  ${field}:`));
+          for (const message of messages) {
+            console.error(relico.dim(`    \u2022 ${message}`));
+          }
+        }
+        for (const message of generalErrors) {
+          console.error(relico.dim(`  \u2022 ${message}`));
+        }
+        process.exit(1);
+      } else if (error instanceof Error) {
+        console.error(relico.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+  const api = {
+    // Internal method for command registration (not part of public API)
+    command(name, cmd) {
+      registerCommand(name, cmd, [], "directory");
+    },
+    async init() {
+      await loadFromConfig();
+    },
+    async run(argv = process.argv.slice(2)) {
+      if (argv.length === 0) {
+        showHelp(void 0, void 0, []);
+        return;
+      }
+      const separatorIndex = argv.indexOf("--");
+      const commandArgs = separatorIndex >= 0 ? argv.slice(0, separatorIndex) : argv;
+      const passthroughArgs = separatorIndex >= 0 ? argv.slice(separatorIndex + 1) : [];
+      if (commandArgs.includes("--version") || commandArgs.includes("-v")) {
+        console.log(relico.bold(relico.cyan(`${fullConfig.name} v${fullConfig.version}`)));
+        return;
+      }
+      if (commandArgs.includes("--help") || commandArgs.includes("-h")) {
+        const helpIndex = Math.max(commandArgs.indexOf("--help"), commandArgs.indexOf("-h"));
+        const cmdArgs = commandArgs.slice(0, helpIndex);
+        if (cmdArgs.length === 0) {
+          showHelp(void 0, void 0, []);
+        } else {
+          const { command: command2, commandName: commandName2, remainingArgs: _remainingArgs } = findCommand(cmdArgs);
+          if (command2 && commandName2) {
+            const pathParts = commandName2.split(" ").slice(0, -1);
+            showHelp(commandName2, command2, pathParts);
+          } else {
+            console.error(`Unknown command: ${cmdArgs.join(" ")}`);
+            process.exit(1);
+          }
+        }
+        return;
+      }
+      const { command, commandName, remainingArgs } = findCommand(commandArgs);
+      if (!(command && commandName)) {
+        console.error(`Unknown command: ${commandArgs[0]}`);
+        process.exit(1);
+      }
+      const hasSubcommands = subcommandIndex.has(commandName) && Array.from(subcommandIndex.get(commandName)).some(
+        (name) => name.split(" ").length === commandName.split(" ").length + 1
+      );
+      if (!(command.handler || command.render) && hasSubcommands) {
+        const pathParts = commandName.split(" ").slice(0, -1);
+        showHelp(commandName, command, pathParts);
+        return;
+      }
+      if (command.handler || command.render) {
+        const allArgs = [...remainingArgs, ...passthroughArgs];
+        await runCommandInternal(commandName, command, allArgs);
+      }
+    },
+    async execute(commandName, argsOrOptions, options) {
+      const commandPath = commandName.replace(/\//g, " ").split(" ");
+      const { command, commandName: foundCommandName, remainingArgs } = findCommand(commandPath);
+      if (!(command && foundCommandName)) {
+        throw new Error(`Command '${commandName}' not found`);
+      }
+      let finalArgs = [];
+      let finalOptions = {};
+      if (argsOrOptions && !Array.isArray(argsOrOptions)) {
+        finalOptions = argsOrOptions;
+      } else if (Array.isArray(argsOrOptions) && options) {
+        finalArgs = argsOrOptions;
+        finalOptions = options;
+      } else if (Array.isArray(argsOrOptions)) {
+        finalArgs = argsOrOptions;
+      }
+      if (Object.keys(finalOptions).length > 0) {
+        const mergedOptions = {
+          ...GLOBAL_FLAGS,
+          ...command.options || {}
+        };
+        const parsed = await parseArgs([], mergedOptions, foundCommandName);
+        Object.assign(parsed.flags, finalOptions);
+        const { prompt, spinner } = await import("@reliverse/rempts-utils");
+        let context;
+        if (mergedConfig.plugins && mergedConfig.plugins.length > 0) {
+          context = await runBeforeCommand(
+            pluginManagerState,
+            foundCommandName,
+            command,
+            [],
+            parsed.flags
+          );
+        }
+        if (beforeHooks.length > 0) {
+          globalHookContext = {};
+          const hookContext = {
+            flags: parsed.flags,
+            store: context?.store?.getState() || {},
+            env: process.env,
+            cwd: process.cwd(),
+            set: (key, value) => {
+              globalHookContext[key] = value;
+            },
+            get: (key) => {
+              return globalHookContext[key];
+            }
+          };
+          for (const hook of beforeHooks) {
+            await hook(hookContext);
+          }
+        }
+        const runtimeInfo = {
+          startTime: Date.now(),
+          args: [],
+          command: foundCommandName
+        };
+        const terminalInfo = getTerminalInfo();
+        if (command.handler) {
+          const typedFlags = parsed.flags;
+          await command.handler({
+            flags: typedFlags,
+            positional: [],
+            shell: Bun.$,
+            env: process.env,
+            cwd: process.cwd(),
+            prompt,
+            spinner,
+            colors: relico,
+            terminal: terminalInfo,
+            runtime: runtimeInfo,
+            ...context ? { context } : {},
+            ...Object.keys(globalHookContext).length > 0 ? { hooks: globalHookContext } : {}
+          });
+        }
+        if (mergedConfig.plugins && mergedConfig.plugins.length > 0 && context) {
+          await runAfterCommand(pluginManagerState, context, { exitCode: 0 });
+        }
+        if (afterHooks.length > 0) {
+          const hookContext = {
+            flags: parsed.flags,
+            store: context?.store?.getState() || {},
+            env: process.env,
+            cwd: process.cwd(),
+            set: () => {
+            },
+            // Not used in after hooks
+            get: () => void 0,
+            // Not used in after hooks
+            exitCode: 0
+          };
+          for (const hook of afterHooks) {
+            await hook(hookContext);
+          }
+        }
+        return;
+      }
+      const args = finalArgs.length > 0 ? finalArgs : argsOrOptions || [];
+      const foundCommand = command;
+      const finalArgsToUse = [...remainingArgs, ...args];
+      if (foundCommand.handler || foundCommand.render) {
+        await runCommandInternal(foundCommandName, foundCommand, finalArgsToUse);
+      }
+    },
+    before(hook) {
+      beforeHooks.push(hook);
+    },
+    after(hook) {
+      afterHooks.push(hook);
+    }
+  };
+  return api;
+}