@depup/nestjs__cli 11.0.24-depup.8 → 12.0.0-depup.0

package/actions/new.action.js

@@ -1,36 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exit = exports.retrieveCols = exports.NewAction = void 0;
-const prompts_1 = require("@inquirer/prompts");
-const ansis = require("ansis");
-const child_process_1 = require("child_process");
-const fs = require("fs");
-const path_1 = require("path");
-const defaults_1 = require("../lib/configuration/defaults");
-const package_managers_1 = require("../lib/package-managers");
-const questions_1 = require("../lib/questions/questions");
-const git_runner_1 = require("../lib/runners/git.runner");
-const schematics_1 = require("../lib/schematics");
-const ui_1 = require("../lib/ui");
-const formatting_1 = require("../lib/utils/formatting");
-const gracefully_exit_on_prompt_error_1 = require("../lib/utils/gracefully-exit-on-prompt-error");
-const abstract_action_1 = require("./abstract.action");
-const type_assertions_1 = require("../lib/utils/type-assertions");
-class NewAction extends abstract_action_1.AbstractAction {
-    async handle(inputs, options) {
-        const directoryOption = options.find((option) => option.name === 'directory');
-        const dryRunOption = options.find((option) => option.name === 'dry-run');
-        const isDryRunEnabled = dryRunOption && dryRunOption.value;
-        await askForMissingInformation(inputs, options);
-        await generateApplicationFiles(inputs, options).catch(exports.exit);
-        const shouldSkipInstall = options.some((option) => option.name === 'skip-install' && option.value === true);
-        const shouldSkipGit = options.some((option) => option.name === 'skip-git' && option.value === true);
-        const projectDirectory = getProjectDirectory(getApplicationNameInput(inputs), directoryOption);
-        if (!shouldSkipInstall) {
-            await installPackages(options, isDryRunEnabled, projectDirectory);
+import { confirm, input, select } from '@inquirer/prompts';
+import ansis from 'ansis';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import { join } from 'path';
+import { defaultGitIgnore } from '../lib/configuration/defaults.js';
+import { PackageManager, PackageManagerFactory, } from '../lib/package-managers/index.js';
+import { generateInput, generateSelect } from '../lib/questions/questions.js';
+import { GitRunner } from '../lib/runners/git.runner.js';
+import { Collection, CollectionFactory, SchematicOption, } from '../lib/schematics/index.js';
+import { EMOJIS, MESSAGES } from '../lib/ui/index.js';
+import { normalizeToKebabOrSnakeCase } from '../lib/utils/formatting.js';
+import { gracefullyExitOnPromptError } from '../lib/utils/gracefully-exit-on-prompt-error.js';
+import { isInteractive } from '../lib/utils/is-interactive.js';
+import { AbstractAction } from './abstract.action.js';
+export class NewAction extends AbstractAction {
+    async handle(context) {
+        await askForMissingInformation(context);
+        await generateApplicationFiles(context).catch(exit);
+        const projectDirectory = getProjectDirectory(context);
+        if (!context.skipInstall) {
+            await installPackages(context, projectDirectory);
         }
-        if (!isDryRunEnabled) {
-            if (!shouldSkipGit) {
+        if (!context.dryRun) {
+            if (!context.skipGit) {
                 await initializeGitRepository(projectDirectory);
                 await createGitIgnoreFile(projectDirectory);
             }
@@ -39,81 +31,98 @@ class NewAction extends abstract_action_1.AbstractAction {
         process.exit(0);
     }
 }
-exports.NewAction = NewAction;
-const getApplicationNameInput = (inputs) => inputs.find((input) => input.name === 'name');
-const getPackageManagerInput = (inputs) => inputs.find((options) => options.name === 'packageManager');
-const getProjectDirectory = (applicationName, directoryOption) => {
-    return ((directoryOption && directoryOption.value) ||
-        (0, formatting_1.normalizeToKebabOrSnakeCase)(applicationName.value));
+const getProjectDirectory = (context) => {
+    return (context.directory || normalizeToKebabOrSnakeCase(context.name));
 };
-const askForMissingInformation = async (inputs, options) => {
-    console.info(ui_1.MESSAGES.PROJECT_INFORMATION_START);
+const askForMissingInformation = async (context) => {
+    console.info(MESSAGES.PROJECT_INFORMATION_START);
     console.info();
-    const nameInput = getApplicationNameInput(inputs);
-    if (!nameInput.value) {
-        const message = ui_1.MESSAGES.PROJECT_NAME_QUESTION;
-        const question = (0, questions_1.generateInput)('name', message)('nest-app');
-        const answer = await (0, prompts_1.input)(question).catch(gracefully_exit_on_prompt_error_1.gracefullyExitOnPromptError);
-        replaceInputMissingInformation(inputs, { name: 'name', value: answer });
+    if (!context.name) {
+        const message = MESSAGES.PROJECT_NAME_QUESTION;
+        const question = generateInput('name', message)('nest-app');
+        context.name = (await input(question).catch(gracefullyExitOnPromptError));
     }
-    const packageManagerInput = getPackageManagerInput(options);
-    if (!packageManagerInput.value) {
-        const answer = await askForPackageManager();
-        replaceInputMissingInformation(options, {
-            name: 'packageManager',
-            value: answer,
-        });
+    if (!context.packageManager) {
+        context.packageManager = (await askForPackageManager());
     }
-};
-const replaceInputMissingInformation = (inputs, answer) => {
-    const input = inputs.find((input) => input.name === answer.name);
-    if (input) {
-        input.value = input.value !== undefined ? input.value : answer.value;
+    if (context.observe === undefined) {
+        context.observe = await askForObservability();
     }
 };
-const generateApplicationFiles = async (args, options) => {
-    const collectionName = options.find((option) => option.name === 'collection' && option.value != null).value;
-    const collection = schematics_1.CollectionFactory.create(collectionName || schematics_1.Collection.NESTJS);
-    const schematicOptions = mapSchematicOptions(args.concat(options));
+const generateApplicationFiles = async (context) => {
+    const collection = CollectionFactory.create(context.collection || Collection.NESTJS);
+    const schematicOptions = mapContextToSchematicOptions(context);
     await collection.execute('application', schematicOptions);
     console.info();
 };
-const mapSchematicOptions = (options) => {
-    return options.reduce((schematicOptions, option) => {
-        if (option.name !== 'skip-install') {
-            (0, type_assertions_1.assertNonArray)(option.value);
-            schematicOptions.push(new schematics_1.SchematicOption(option.name, option.value));
-        }
-        return schematicOptions;
-    }, []);
+const mapContextToSchematicOptions = (context) => {
+    const options = [];
+    if (context.name !== undefined)
+        options.push(new SchematicOption('name', context.name));
+    if (context.directory !== undefined)
+        options.push(new SchematicOption('directory', context.directory));
+    if (context.dryRun)
+        options.push(new SchematicOption('dry-run', true));
+    options.push(new SchematicOption('skip-git', context.skipGit));
+    options.push(new SchematicOption('strict', context.strict));
+    if (context.skipTests) {
+        options.push(new SchematicOption('spec', false));
+    }
+    if (context.packageManager !== undefined)
+        options.push(new SchematicOption('packageManager', context.packageManager));
+    if (context.collection !== undefined)
+        options.push(new SchematicOption('collection', context.collection));
+    options.push(new SchematicOption('language', context.language));
+    options.push(new SchematicOption('format', context.format));
+    if (context.observe) {
+        options.push(new SchematicOption('observe', true));
+    }
+    // note: skip-install is intentionally excluded — not sent to schematics
+    return options;
 };
-const installPackages = async (options, dryRunMode, installDirectory) => {
-    const inputPackageManager = getPackageManagerInput(options).value;
+const installPackages = async (context, installDirectory) => {
+    const inputPackageManager = context.packageManager;
     let packageManager;
-    if (dryRunMode) {
+    if (context.dryRun) {
         console.info();
-        console.info(ansis.green(ui_1.MESSAGES.DRY_RUN_MODE));
+        console.info(ansis.green(MESSAGES.DRY_RUN_MODE));
         console.info();
         return;
     }
     try {
-        packageManager = package_managers_1.PackageManagerFactory.create(inputPackageManager);
+        packageManager = PackageManagerFactory.create(inputPackageManager);
         await packageManager.install(installDirectory, inputPackageManager);
     }
     catch (error) {
-        if (error && error.message) {
+        if (error instanceof Error) {
             console.error(ansis.red(error.message));
         }
     }
 };
+const askForObservability = async () => {
+    // Without a TTY (CI, piped input, `execSync`) there is nobody to answer, so
+    // fall back to the opt-out default instead of blocking the scaffold.
+    if (!isInteractive()) {
+        return false;
+    }
+    return (await confirm({
+        message: MESSAGES.OBSERVABILITY_QUESTION,
+        default: false,
+    }).catch(gracefullyExitOnPromptError));
+};
 const askForPackageManager = async () => {
-    const question = (0, questions_1.generateSelect)('packageManager')(ui_1.MESSAGES.PACKAGE_MANAGER_QUESTION)([package_managers_1.PackageManager.NPM, package_managers_1.PackageManager.YARN, package_managers_1.PackageManager.PNPM]);
-    return (0, prompts_1.select)(question).catch(gracefully_exit_on_prompt_error_1.gracefullyExitOnPromptError);
+    const question = generateSelect('packageManager')(MESSAGES.PACKAGE_MANAGER_QUESTION)([
+        PackageManager.NPM,
+        PackageManager.YARN,
+        PackageManager.PNPM,
+        PackageManager.BUN,
+    ]);
+    return select(question).catch(gracefullyExitOnPromptError);
 };
 const initializeGitRepository = async (dir) => {
-    const runner = new git_runner_1.GitRunner();
-    await runner.run('init', true, (0, path_1.join)(process.cwd(), dir)).catch(() => {
-        console.error(ansis.red(ui_1.MESSAGES.GIT_INITIALIZATION_ERROR));
+    const runner = new GitRunner();
+    await runner.run('init', true, join(process.cwd(), dir)).catch(() => {
+        console.error(ansis.red(MESSAGES.GIT_INITIALIZATION_ERROR));
     });
 };
 /**
@@ -127,8 +136,8 @@ const initializeGitRepository = async (dir) => {
  * @return Resolves when succeeds, or rejects with any error from `fn.writeFile`.
  */
 const createGitIgnoreFile = (dir, content) => {
-    const fileContent = content || defaults_1.defaultGitIgnore;
-    const filePath = (0, path_1.join)(process.cwd(), dir, '.gitignore');
+    const fileContent = content || defaultGitIgnore;
+    const filePath = join(process.cwd(), dir, '.gitignore');
     if (fileExists(filePath)) {
         return;
     }
@@ -139,17 +148,18 @@ const printCollective = () => {
     const yellow = print('yellow');
     const emptyLine = print();
     emptyLine();
-    yellow(`Thanks for installing Nest ${ui_1.EMOJIS.PRAY}`);
+    yellow(`Thanks for installing Nest ${EMOJIS.PRAY}`);
     dim('Please consider donating to our open collective');
     dim('to help us maintain this package.');
     emptyLine();
     emptyLine();
-    print()(`${ansis.bold `${ui_1.EMOJIS.WINE}  Donate:`} ${ansis.underline('https://opencollective.com/nest')}`);
+    print()(`${ansis.bold `${EMOJIS.WINE}  Donate:`} ${ansis.underline('https://opencollective.com/nest')}`);
     emptyLine();
 };
 const print = (color = null) => (str = '') => {
-    const terminalCols = (0, exports.retrieveCols)();
-    const strLength = str.replace(/\u001b\[[0-9]{2}m/g, '').length;
+    const terminalCols = retrieveCols();
+    // eslint-disable-next-line no-control-regex
+    const strLength = str.replace(/\x1b\[[0-9]+m/g, '').length;
     const leftPaddingLength = Math.floor((terminalCols - strLength) / 2);
     const leftPadding = ' '.repeat(Math.max(leftPaddingLength, 0));
     if (color) {
@@ -157,10 +167,17 @@ const print = (color = null) => (str = '') => {
     }
     console.log(leftPadding, str);
 };
-const retrieveCols = () => {
+export const retrieveCols = () => {
     const defaultCols = 80;
+    // Prefer process.stdout.columns: it works on every platform (including
+    // Windows, where `tput` is not available by default) and reflects the
+    // actual terminal size instead of always falling back to the default.
+    const stdoutCols = process.stdout.columns;
+    if (typeof stdoutCols === 'number' && stdoutCols > 0) {
+        return stdoutCols;
+    }
     try {
-        const terminalCols = (0, child_process_1.execSync)('tput cols', {
+        const terminalCols = execSync('tput cols', {
             stdio: ['pipe', 'pipe', 'ignore'],
         });
         return parseInt(terminalCols.toString(), 10) || defaultCols;
@@ -169,18 +186,5 @@ const retrieveCols = () => {
         return defaultCols;
     }
 };
-exports.retrieveCols = retrieveCols;
-const fileExists = (path) => {
-    try {
-        fs.accessSync(path);
-        return true;
-    }
-    catch (err) {
-        if (err.code === 'ENOENT') {
-            return false;
-        }
-        throw err;
-    }
-};
-const exit = () => process.exit(1);
-exports.exit = exit;
+const fileExists = (path) => fs.existsSync(path);
+export const exit = () => process.exit(1);

package/actions/start.action.d.ts

@@ -1,10 +1,7 @@
-import { Input } from '../commands';
-import { BuildAction } from './build.action';
+import { StartCommandContext } from '../commands/index.js';
+import { BuildAction } from './build.action.js';
 export declare class StartAction extends BuildAction {
-    handle(commandInputs: Input[], commandOptions: Input[]): Promise<void>;
-    createOnSuccessHook(entryFile: string, sourceRoot: string, debugFlag: boolean | string | undefined, outDirName: string, binaryToRun: string, options: {
-        shell: boolean;
-        envFile?: string[];
-    }): () => void;
+    handle(context: StartCommandContext): Promise<void>;
+    private createOnSuccessHook;
     private spawnChildProcess;
 }

package/actions/start.action.js

@@ -1,60 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartAction = void 0;
-const ansis_1 = require("ansis");
-const child_process_1 = require("child_process");
-const fs = require("fs");
-const path_1 = require("path");
-const get_tsc_config_path_1 = require("../lib/compiler/helpers/get-tsc-config.path");
-const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
-const defaults_1 = require("../lib/configuration/defaults");
-const ui_1 = require("../lib/ui");
-const tree_kill_1 = require("../lib/utils/tree-kill");
-const type_assertions_1 = require("../lib/utils/type-assertions");
-const build_action_1 = require("./build.action");
-class StartAction extends build_action_1.BuildAction {
-    async handle(commandInputs, commandOptions) {
+import { red } from 'ansis';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import { join } from 'path';
+import { getTscConfigPath } from '../lib/compiler/helpers/get-tsc-config.path.js';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { defaultConfiguration, defaultOutDir, } from '../lib/configuration/defaults.js';
+import { ERROR_PREFIX } from '../lib/ui/index.js';
+import { treeKillSync as killProcessSync } from '../lib/utils/tree-kill.js';
+import { assertNonArray } from '../lib/utils/type-assertions.js';
+import { BuildAction } from './build.action.js';
+export class StartAction extends BuildAction {
+    async handle(context) {
         try {
-            const configFileName = commandOptions.find((option) => option.name === 'config').value;
+            const configFileName = context.config;
             const configuration = await this.loader.load(configFileName);
-            const appName = commandInputs.find((input) => input.name === 'app')
-                .value;
-            const pathToTsconfig = (0, get_tsc_config_path_1.getTscConfigPath)(configuration, commandOptions, appName);
-            const debugModeOption = commandOptions.find((option) => option.name === 'debug');
-            const watchModeOption = commandOptions.find((option) => option.name === 'watch');
-            const isWatchEnabled = !!(watchModeOption && watchModeOption.value);
-            const watchAssetsModeOption = commandOptions.find((option) => option.name === 'watchAssets');
-            const isWatchAssetsEnabled = !!(watchAssetsModeOption && watchAssetsModeOption.value);
-            const debugFlag = debugModeOption && debugModeOption.value;
-            (0, type_assertions_1.assertNonArray)(debugFlag);
-            const binaryToRun = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'exec', appName, 'exec', commandOptions, defaults_1.defaultConfiguration.exec);
+            const appName = context.app;
+            const pathToTsconfig = getTscConfigPath(configuration, context, appName);
+            const isWatchEnabled = !!context.watch;
+            const isWatchAssetsEnabled = !!context.watchAssets;
+            const debugFlag = context.debug;
+            assertNonArray(debugFlag);
+            const binaryToRun = getValueOrDefault(configuration, 'exec', appName, 'exec', context, defaultConfiguration.exec);
             const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
-            const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
-            const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName, 'entryFile', commandOptions, defaults_1.defaultConfiguration.entryFile);
-            const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName, 'sourceRoot', commandOptions, defaults_1.defaultConfiguration.sourceRoot);
-            const shellOption = commandOptions.find((option) => option.name === 'shell');
-            const useShell = !!shellOption?.value;
-            const envFileOption = commandOptions.find((option) => option.name === 'envFile');
-            const envFile = (envFileOption?.value ?? []);
+            const outDir = tsOptions.outDir || defaultOutDir;
+            const entryFile = getValueOrDefault(configuration, 'entryFile', appName, 'entryFile', context, defaultConfiguration.entryFile);
+            const sourceRoot = getValueOrDefault(configuration, 'sourceRoot', appName, 'sourceRoot', context, defaultConfiguration.sourceRoot);
+            const useShell = !!context.shell;
+            const envFile = context.envFile ?? [];
             const onSuccess = this.createOnSuccessHook(entryFile, sourceRoot, debugFlag, outDir, binaryToRun, {
                 shell: useShell,
                 envFile,
             });
-            await this.runBuild(commandInputs, commandOptions, isWatchEnabled, isWatchAssetsEnabled, !!debugFlag, onSuccess);
+            await this.runBuild(appName ? [appName] : [], context, isWatchEnabled, isWatchAssetsEnabled, !!debugFlag, onSuccess);
         }
         catch (err) {
             if (err instanceof Error) {
-                console.log(`\n${ui_1.ERROR_PREFIX} ${err.message}\n`);
+                console.error(`\n${ERROR_PREFIX} ${err.message}\n`);
             }
             else {
-                console.error(`\n${(0, ansis_1.red)(err)}\n`);
+                console.error(`\n${red(err)}\n`);
             }
+            // A failed build (e.g. SWC type-check errors, which now reject instead of
+            // exiting the process themselves) must not report success to the caller.
+            process.exit(1);
         }
     }
     createOnSuccessHook(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, options) {
         let childProcessRef;
         let shuttingDown = false;
-        process.on('exit', () => childProcessRef && (0, tree_kill_1.treeKillSync)(childProcessRef.pid));
+        process.on('exit', () => childProcessRef && killProcessSync(childProcessRef.pid));
         const signalHandler = (signal) => {
             shuttingDown = true;
             if (childProcessRef) {
@@ -88,8 +82,8 @@ class StartAction extends build_action_1.BuildAction {
                         }
                     });
                 });
-                childProcessRef.stdin && childProcessRef.stdin.pause();
-                (0, tree_kill_1.treeKillSync)(childProcessRef.pid);
+                childProcessRef.stdin?.pause?.();
+                killProcessSync(childProcessRef.pid);
             }
             else {
                 childProcessRef = this.spawnChildProcess(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, {
@@ -110,9 +104,9 @@ class StartAction extends build_action_1.BuildAction {
         };
     }
     spawnChildProcess(entryFile, sourceRoot, debug, outDirName, binaryToRun, options) {
-        let outputFilePath = (0, path_1.join)(outDirName, sourceRoot, entryFile);
+        let outputFilePath = join(outDirName, sourceRoot, entryFile);
         if (!fs.existsSync(outputFilePath + '.js')) {
-            outputFilePath = (0, path_1.join)(outDirName, entryFile);
+            outputFilePath = join(outDirName, entryFile);
         }
         let childProcessArgs = [];
         const argsStartIndex = process.argv.indexOf('--');
@@ -135,7 +129,7 @@ class StartAction extends build_action_1.BuildAction {
         }
         if (options.envFile && options.envFile.length > 0) {
             const envFileNodeArgs = options.envFile.map((envFilePath) => `--env-file=${envFilePath}`);
-            processArgs.unshift(envFileNodeArgs.join(' '));
+            processArgs.unshift(...envFileNodeArgs);
         }
         processArgs.unshift('--enable-source-maps');
         const spawnOptions = {
@@ -144,9 +138,8 @@ class StartAction extends build_action_1.BuildAction {
         };
         if (options.shell) {
             const command = [binaryToRun, ...processArgs].join(' ');
-            return (0, child_process_1.spawn)(command, spawnOptions);
+            return spawn(command, spawnOptions);
         }
-        return (0, child_process_1.spawn)(binaryToRun, processArgs, spawnOptions);
+        return spawn(binaryToRun, processArgs, spawnOptions);
     }
 }
-exports.StartAction = StartAction;

package/actions/upgrade.action.d.ts

@@ -0,0 +1,6 @@
+import { UpgradeCommandContext } from '../commands/index.js';
+import { AbstractAction } from './abstract.action.js';
+export declare class UpgradeAction extends AbstractAction {
+    handle(context: UpgradeCommandContext): Promise<void>;
+    private mapSchematicOptions;
+}

package/actions/upgrade.action.js

@@ -0,0 +1,53 @@
+import { green, red } from 'ansis';
+import { Collection, CollectionFactory, SchematicOption, } from '../lib/schematics/index.js';
+import { INFO_PREFIX, MESSAGES } from '../lib/ui/index.js';
+import { isInteractive } from '../lib/utils/is-interactive.js';
+import { loadConfiguration } from '../lib/utils/load-configuration.js';
+import { AbstractAction } from './abstract.action.js';
+const schematicName = 'upgrade';
+export class UpgradeAction extends AbstractAction {
+    async handle(context) {
+        const configuration = await loadConfiguration();
+        const collectionName = context.collection || configuration.collection || Collection.NESTJS;
+        const schematicOptions = this.mapSchematicOptions(context);
+        console.info(MESSAGES.UPGRADE_IN_PROGRESS);
+        try {
+            const collection = CollectionFactory.create(collectionName);
+            await collection.execute(schematicName, schematicOptions);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(red(error.message));
+            }
+            throw error;
+        }
+        if (context.dryRun) {
+            console.info();
+            console.info(green(MESSAGES.DRY_RUN_MODE));
+            console.info();
+            return;
+        }
+        // The schematic only bumps the project's local @nestjs/cli.
+        console.info(`\n${INFO_PREFIX} ${MESSAGES.UPGRADE_GLOBAL_CLI_HINT}\n`);
+    }
+    mapSchematicOptions(context) {
+        const options = [];
+        if (context.dryRun)
+            options.push(new SchematicOption('dry-run', true));
+        if (context.skipInstall) {
+            options.push(new SchematicOption('skip-install', true));
+        }
+        if (context.tag !== undefined) {
+            options.push(new SchematicOption('tag', context.tag));
+        }
+        if (context.observe !== undefined) {
+            options.push(new SchematicOption('observe', context.observe));
+        }
+        else if (!isInteractive()) {
+            // The schematic's `x-prompt` would block forever without a TTY (CI,
+            // pipes), so answer it up front and leave prompting to TTY sessions.
+            options.push(new SchematicOption('observe', false));
+        }
+        return options;
+    }
+}

package/bin/nest.js

@@ -1,23 +1,24 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander = require("commander");
-const commands_1 = require("../commands");
-const local_binaries_1 = require("../lib/utils/local-binaries");
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { CommandLoader } from '../commands/index.js';
+import { loadLocalBinCommandLoader, localBinExists, } from '../lib/utils/local-binaries.js';
+const require = createRequire(import.meta.url);
 const bootstrap = async () => {
-    const program = commander;
+    const program = new Command();
+    program.__nestCliEsm = true;
     program
         .version(require('../package.json').version, '-v, --version', 'Output the current version.')
         .usage('<command> [options]')
         .helpOption('-h, --help', 'Output usage information.');
-    if ((0, local_binaries_1.localBinExists)()) {
-        const localCommandLoader = (0, local_binaries_1.loadLocalBinCommandLoader)();
+    if (localBinExists()) {
+        const localCommandLoader = await loadLocalBinCommandLoader();
         await localCommandLoader.load(program);
     }
     else {
-        await commands_1.CommandLoader.load(program);
+        await CommandLoader.load(program);
     }
-    await commander.parseAsync(process.argv);
+    await program.parseAsync(process.argv);
     if (!process.argv.slice(2).length) {
         program.outputHelp();
     }

package/changes.json

@@ -1,54 +1,22 @@
 {
   "bumped": {
     "@angular-devkit/core": {
-      "from": "19.2.27",
+      "from": "22.1.5",
       "to": "^22.1.6"
     },
     "@angular-devkit/schematics": {
-      "from": "19.2.27",
+      "from": "22.1.5",
       "to": "^22.1.6"
     },
     "@angular-devkit/schematics-cli": {
-      "from": "19.2.27",
+      "from": "22.1.5",
       "to": "^22.1.6"
     },
-    "@inquirer/prompts": {
-      "from": "7.10.1",
-      "to": "^8.7.0"
-    },
-    "@nestjs/schematics": {
-      "from": "^11.0.1",
-      "to": "^11.1.0"
-    },
-    "ansis": {
-      "from": "4.2.0",
-      "to": "^4.3.1"
-    },
-    "chokidar": {
-      "from": "4.0.3",
-      "to": "^5.0.0"
-    },
-    "commander": {
-      "from": "4.1.1",
-      "to": "^15.0.0"
-    },
-    "node-emoji": {
-      "from": "1.11.0",
-      "to": "^2.2.0"
-    },
-    "ora": {
-      "from": "5.4.1",
-      "to": "^9.4.1"
-    },
     "typescript": {
-      "from": "5.9.3",
+      "from": "~6.0.2",
       "to": "^7.0.2"
-    },
-    "webpack": {
-      "from": "5.106.2",
-      "to": "^5.109.2"
     }
   },
-  "timestamp": "2026-08-27T01:37:40.713Z",
-  "totalUpdated": 12
+  "timestamp": "2026-08-27T11:23:37.886Z",
+  "totalUpdated": 4
 }

package/commands/abstract.command.d.ts

@@ -1,7 +1,7 @@
-import { CommanderStatic } from 'commander';
-import { AbstractAction } from '../actions/abstract.action';
+import { Command } from 'commander';
+import { AbstractAction } from '../actions/abstract.action.js';
 export declare abstract class AbstractCommand {
     protected action: AbstractAction;
     constructor(action: AbstractAction);
-    abstract load(program: CommanderStatic): void;
+    abstract load(program: Command): void;
 }

package/commands/abstract.command.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractCommand = void 0;
-class AbstractCommand {
+export class AbstractCommand {
+    action;
     constructor(action) {
         this.action = action;
     }
 }
-exports.AbstractCommand = AbstractCommand;

package/commands/add.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class AddCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }