pgpm 0.0.1

package/package.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndParsePackageJson = readAndParsePackageJson;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// need to search due to the dist/ folder and src/, etc.
+function findPackageJson(currentDir) {
+    const filePath = (0, path_1.join)(currentDir, 'package.json');
+    // Check if package.json exists in the current directory
+    if ((0, fs_1.existsSync)(filePath)) {
+        return filePath;
+    }
+    // Get the parent directory
+    const parentDir = (0, path_1.dirname)(currentDir);
+    // If reached the root directory, package.json is not found
+    if (parentDir === currentDir) {
+        throw new Error('package.json not found in any parent directory');
+    }
+    // Recursively look in the parent directory
+    return findPackageJson(parentDir);
+}
+function readAndParsePackageJson() {
+    // Start searching from the current directory
+    const pkgPath = findPackageJson(__dirname);
+    // Read and parse the package.json
+    const str = (0, fs_1.readFileSync)(pkgPath, 'utf8');
+    const pkg = JSON.parse(str);
+    return pkg;
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "pgpm",
+  "version": "0.0.1",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "description": "LaunchQL CLI",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/launchql/launchql",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "bin": {
+    "lql": "index.js",
+    "launchql": "index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchql/launchql"
+  },
+  "bugs": {
+    "url": "https://github.com/launchql/launchql/issues"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepare": "npm run build",
+    "build": "npm run clean; tsc -p tsconfig.json; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc -p tsconfig.json --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "dev": "ts-node ./src/index.ts",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^20.12.7",
+    "@types/pg": "^8.15.2",
+    "@types/shelljs": "^0.8.16",
+    "glob": "^11.0.2",
+    "pg": "^8.16.0",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "@launchql/core": "^2.14.3",
+    "@launchql/env": "^2.4.5",
+    "@launchql/explorer": "^2.6.1",
+    "@launchql/logger": "^1.1.3",
+    "@launchql/server": "^2.6.1",
+    "@launchql/server-utils": "^2.5.1",
+    "@launchql/templatizer": "^2.4.5",
+    "@launchql/types": "^2.7.0",
+    "chalk": "^4.1.0",
+    "inquirerer": "^2.0.8",
+    "js-yaml": "^4.1.0",
+    "minimist": "^1.2.8",
+    "pg-cache": "^1.3.8",
+    "pg-env": "^1.1.1",
+    "shelljs": "^0.9.2"
+  },
+  "keywords": [
+    "cli",
+    "command-line",
+    "tool",
+    "launchql",
+    "utilities",
+    "pg",
+    "pgsql",
+    "postgres",
+    "graphile"
+  ],
+  "gitHead": "2e8a123c53d33ee10377b0f034392b0dff1e8a88"
+}

package/utils/argv.d.ts

@@ -0,0 +1,46 @@
+import { ParsedArgs } from 'minimist';
+export declare const extractFirst: (argv: Partial<ParsedArgs>) => {
+    first: string;
+    newArgv: {
+        _: string[];
+        "--"?: string[] | undefined;
+    };
+};
+/**
+ * Common CLI argument validation and processing utilities
+ */
+export interface ValidatedArgv extends ParsedArgs {
+    cwd: string;
+    database?: string;
+    package?: string;
+    to?: string;
+    recursive?: boolean;
+    yes?: boolean;
+    tx?: boolean;
+    fast?: boolean;
+    logOnly?: boolean;
+    createdb?: boolean;
+    usePlan?: boolean;
+    cache?: boolean;
+    drop?: boolean;
+    all?: boolean;
+    summary?: boolean;
+    help?: boolean;
+    h?: boolean;
+}
+/**
+ * Validates and normalizes common CLI arguments
+ */
+export declare function validateCommonArgs(argv: Partial<ParsedArgs>): ValidatedArgv;
+/**
+ * Checks if required flags are provided when certain conditions are met
+ */
+export declare function validateFlagDependencies(argv: ValidatedArgv): void;
+/**
+ * Logs the effective CLI arguments for debugging
+ */
+export declare function logEffectiveArgs(argv: ValidatedArgv, commandName: string): void;
+/**
+ * Constructs a deployment target string from package and to arguments
+ */
+export declare function constructTarget(argv: ValidatedArgv, packageName?: string): string | undefined;

package/utils/argv.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFirst = void 0;
+exports.validateCommonArgs = validateCommonArgs;
+exports.validateFlagDependencies = validateFlagDependencies;
+exports.logEffectiveArgs = logEffectiveArgs;
+exports.constructTarget = constructTarget;
+const logger_1 = require("@launchql/logger");
+const log = new logger_1.Logger('argv-utils');
+const extractFirst = (argv) => {
+    const first = argv._?.[0];
+    const newArgv = {
+        ...argv,
+        _: argv._?.slice(1) ?? []
+    };
+    return { first, newArgv };
+};
+exports.extractFirst = extractFirst;
+/**
+ * Validates and normalizes common CLI arguments
+ */
+function validateCommonArgs(argv) {
+    const validated = {
+        ...argv,
+        cwd: argv.cwd || process.cwd(),
+        _: argv._ || []
+    };
+    const booleanFlags = ['recursive', 'yes', 'tx', 'fast', 'logOnly', 'createdb', 'usePlan', 'cache', 'drop', 'all', 'summary', 'help', 'h'];
+    for (const flag of booleanFlags) {
+        if (argv[flag] !== undefined && typeof argv[flag] !== 'boolean') {
+            log.warn(`--${flag} flag should be boolean, converting to true`);
+            validated[flag] = true;
+        }
+    }
+    const stringFlags = ['package', 'to', 'database'];
+    for (const flag of stringFlags) {
+        if (argv[flag] !== undefined && typeof argv[flag] !== 'string') {
+            log.warn(`--${flag} should be a string, converting`);
+            validated[flag] = String(argv[flag]);
+        }
+    }
+    return validated;
+}
+/**
+ * Checks if required flags are provided when certain conditions are met
+ */
+function validateFlagDependencies(argv) {
+    if (argv.to && !argv.package && !argv.recursive) {
+        log.warn('--to flag provided without --package or --recursive. Target may not work as expected.');
+    }
+    if (argv.package && argv.recursive) {
+        if (argv.package.includes(':')) {
+            log.warn('--package should not contain ":" when using --recursive. Use --to for target specification.');
+        }
+    }
+}
+/**
+ * Logs the effective CLI arguments for debugging
+ */
+function logEffectiveArgs(argv, commandName) {
+    const relevantArgs = {
+        cwd: argv.cwd,
+        database: argv.database,
+        package: argv.package,
+        to: argv.to,
+        recursive: argv.recursive,
+        yes: argv.yes,
+        tx: argv.tx,
+        fast: argv.fast,
+        logOnly: argv.logOnly,
+        createdb: argv.createdb,
+        usePlan: argv.usePlan,
+        cache: argv.cache,
+        drop: argv.drop,
+        all: argv.all,
+        summary: argv.summary
+    };
+    const definedArgs = Object.fromEntries(Object.entries(relevantArgs).filter(([_, value]) => value !== undefined));
+    if (Object.keys(definedArgs).length > 1) { // More than just cwd
+        log.debug(`${commandName} effective arguments:`, definedArgs);
+    }
+}
+/**
+ * Constructs a deployment target string from package and to arguments
+ */
+function constructTarget(argv, packageName) {
+    if (packageName && argv.to) {
+        return `${packageName}:${argv.to}`;
+    }
+    else if (packageName) {
+        return packageName;
+    }
+    else if (argv.package && argv.to) {
+        return `${argv.package}:${argv.to}`;
+    }
+    else if (argv.package) {
+        return argv.package;
+    }
+    return undefined;
+}

package/utils/cli-error.d.ts

@@ -0,0 +1,8 @@
+import { LaunchQLError } from '@launchql/types';
+/**
+ * CLI error utility that logs error information and exits with code 1.
+ * Provides consistent error handling and user experience across all CLI commands.
+ *
+ * IMPORTANT: This function properly cleans up PostgreSQL connections before exiting.
+ */
+export declare const cliExitWithError: (error: LaunchQLError | Error | string, context?: Record<string, any>) => Promise<never>;

package/utils/cli-error.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliExitWithError = void 0;
+const types_1 = require("@launchql/types");
+const logger_1 = require("@launchql/logger");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.Logger('cli');
+/**
+ * CLI error utility that logs error information and exits with code 1.
+ * Provides consistent error handling and user experience across all CLI commands.
+ *
+ * IMPORTANT: This function properly cleans up PostgreSQL connections before exiting.
+ */
+const cliExitWithError = async (error, context) => {
+    if (error instanceof types_1.LaunchQLError) {
+        // For LaunchQLError instances, use structured logging
+        log.error(`Error: ${error.message}`);
+        // Log additional context if available
+        if (error.context && Object.keys(error.context).length > 0) {
+            log.debug('Error context:', error.context);
+        }
+        // Log any additional context provided
+        if (context) {
+            log.debug('Additional context:', context);
+        }
+    }
+    else if (error instanceof Error) {
+        // For generic Error instances
+        log.error(`Error: ${error.message}`);
+        if (context) {
+            log.debug('Context:', context);
+        }
+    }
+    else if (typeof error === 'string') {
+        // For simple string messages
+        log.error(`Error: ${error}`);
+        if (context) {
+            log.debug('Context:', context);
+        }
+    }
+    // Perform cleanup before exiting
+    try {
+        await (0, pg_cache_1.teardownPgPools)();
+        log.debug('Database connections cleaned up');
+    }
+    catch (cleanupError) {
+        log.warn('Failed to cleanup database connections:', cleanupError);
+        // Don't let cleanup errors prevent the exit
+    }
+    process.exit(1);
+};
+exports.cliExitWithError = cliExitWithError;

package/utils/database.d.ts

@@ -0,0 +1,21 @@
+import { Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+export interface DatabaseSelectionOptions {
+    message?: string;
+    excludeTemplates?: boolean;
+    excludePostgres?: boolean;
+    excludeSystemDbs?: boolean;
+    multiple?: boolean;
+}
+/**
+ * Get list of available databases from PostgreSQL
+ */
+export declare function getAvailableDatabases(options?: DatabaseSelectionOptions): Promise<string[]>;
+/**
+ * Prompt user to select a database
+ */
+export declare function selectDatabase(argv: Partial<ParsedArgs>, prompter: Inquirerer, options?: DatabaseSelectionOptions): Promise<string>;
+/**
+ * Get target database with fallback to environment
+ */
+export declare function getTargetDatabase(argv: Partial<ParsedArgs>, prompter: Inquirerer, options?: DatabaseSelectionOptions): Promise<string>;

package/utils/database.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableDatabases = getAvailableDatabases;
+exports.selectDatabase = selectDatabase;
+exports.getTargetDatabase = getTargetDatabase;
+const pg_cache_1 = require("pg-cache");
+const pg_env_1 = require("pg-env");
+/**
+ * Get list of available databases from PostgreSQL
+ */
+async function getAvailableDatabases(options = {}) {
+    const { excludeTemplates = true, excludePostgres = true, excludeSystemDbs = true } = options;
+    const db = await (0, pg_cache_1.getPgPool)({
+        database: 'postgres'
+    });
+    let query = `
+    SELECT datname FROM pg_catalog.pg_database
+    WHERE 1=1
+  `;
+    if (excludeTemplates) {
+        query += ` AND datistemplate = FALSE`;
+    }
+    if (excludePostgres) {
+        query += ` AND datname NOT IN ('postgres')`;
+    }
+    if (excludeSystemDbs) {
+        query += ` AND datname !~ '^pg_'`;
+    }
+    query += ` ORDER BY datname`;
+    const result = await db.query(query);
+    return result.rows.map((row) => row.datname);
+}
+/**
+ * Prompt user to select a database
+ */
+async function selectDatabase(argv, prompter, options = {}) {
+    const { message = 'Select target database', multiple = false } = options;
+    // Check if database is already specified
+    if (!multiple && (argv.db || argv.database)) {
+        return argv.db || argv.database;
+    }
+    // Get available databases
+    const databases = await getAvailableDatabases(options);
+    if (databases.length === 0) {
+        throw new Error('No databases found');
+    }
+    // If only one database and not forcing selection, use it
+    if (!multiple && databases.length === 1 && !argv.interactive) {
+        return databases[0];
+    }
+    // Prompt for selection
+    const answer = await prompter.prompt(argv, [
+        {
+            type: multiple ? 'checkbox' : 'autocomplete',
+            name: 'database',
+            message,
+            options: databases,
+            required: true
+        }
+    ]);
+    return answer.database;
+}
+/**
+ * Get target database with fallback to environment
+ */
+async function getTargetDatabase(argv, prompter, options = {}) {
+    // If database is specified in args, use it
+    if (argv.db || argv.database) {
+        return argv.db || argv.database;
+    }
+    // Try to select from available databases
+    try {
+        return await selectDatabase(argv, prompter, options);
+    }
+    catch (error) {
+        // Fall back to environment database
+        const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+        if (pgEnv.database) {
+            return pgEnv.database;
+        }
+        throw new Error('No database specified and no default database found');
+    }
+}

package/utils/deployed-changes.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '@launchql/logger';
+import { Inquirerer } from 'inquirerer';
+export declare function selectDeployedChange(database: string, argv: Partial<Record<string, any>>, prompter: Inquirerer, log: Logger, action?: 'revert' | 'verify'): Promise<string | undefined>;
+export declare function selectDeployedPackage(database: string, argv: Partial<Record<string, any>>, prompter: Inquirerer, log: Logger, action?: 'revert' | 'verify'): Promise<string | undefined>;

package/utils/deployed-changes.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectDeployedChange = selectDeployedChange;
+exports.selectDeployedPackage = selectDeployedPackage;
+const core_1 = require("@launchql/core");
+const pg_env_1 = require("pg-env");
+async function selectDeployedChange(database, argv, prompter, log, action = 'revert') {
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)({ database });
+    const client = new core_1.LaunchQLMigrate(pgEnv);
+    let selectedPackage;
+    if (argv.package) {
+        selectedPackage = argv.package;
+    }
+    else {
+        const packageStatuses = await client.status();
+        if (packageStatuses.length === 0) {
+            log.warn('No deployed packages found in database');
+            return undefined;
+        }
+        const packageAnswer = await prompter.prompt(argv, [{
+                type: 'autocomplete',
+                name: 'package',
+                message: `Select package to ${action} from:`,
+                options: packageStatuses.map(status => ({
+                    name: status.package,
+                    value: status.package,
+                    description: `${status.totalDeployed} changes, last: ${status.lastChange}`
+                }))
+            }]);
+        selectedPackage = packageAnswer.package;
+    }
+    const deployedChanges = await client.getDeployedChanges(database, selectedPackage);
+    if (deployedChanges.length === 0) {
+        log.warn(`No deployed changes found for package ${selectedPackage}`);
+        return undefined;
+    }
+    const changeAnswer = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'change',
+            message: `Select change to ${action} to in ${selectedPackage}:`,
+            options: deployedChanges.map(change => ({
+                name: change.change_name,
+                value: change.change_name,
+                description: `Deployed: ${new Date(change.deployed_at).toLocaleString()}`
+            }))
+        }]);
+    const selectedChange = changeAnswer.change;
+    return `${selectedPackage}:${selectedChange}`;
+}
+async function selectDeployedPackage(database, argv, prompter, log, action = 'revert') {
+    if (argv.package) {
+        return argv.package;
+    }
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)({ database });
+    const client = new core_1.LaunchQLMigrate(pgEnv);
+    const packageStatuses = await client.status();
+    if (packageStatuses.length === 0) {
+        log.warn('No deployed packages found in database');
+        return undefined;
+    }
+    const packageAnswer = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'package',
+            message: `Select package to ${action}:`,
+            options: packageStatuses.map(status => ({
+                name: status.package,
+                value: status.package,
+                description: `${status.totalDeployed} changes, last: ${status.lastChange}`
+            }))
+        }]);
+    return packageAnswer.package;
+}

package/utils/display.d.ts

@@ -0,0 +1,3 @@
+export declare function displayVersion(): void;
+export declare const usageText = "\n  Usage: lql <command> [options]\n         launchql <command> [options]\n  \n  Core Database Operations:\n    add                Add database changes to plans and create SQL files\n    deploy             Deploy database changes and migrations\n    verify             Verify database state and migrations\n    revert             Revert database changes and migrations\n  \n  Project Management:\n    init               Initialize LaunchQL workspace or module\n    extension          Manage module dependencies\n    plan               Generate module deployment plans\n    package            Package module for distribution\n  \n  Development Tools:\n    server             Start LaunchQL GraphQL server\n    explorer           Launch GraphiQL explorer interface\n    export             Export database migrations from existing databases\n  \n  Database Administration:\n    kill               Terminate database connections and optionally drop databases\n    install            Install LaunchQL modules\n    tag                Add tags to changes for versioning\n  \n  Migration Tools:\n    migrate            Migration management subcommands\n      init             Initialize migration tracking\n      status           Show migration status\n      list             List all changes\n      deps             Show change dependencies\n  \n  Global Options:\n    -h, --help         Display this help information\n    -v, --version      Display version information\n    --cwd <directory>  Working directory (default: current directory)\n  \n  Individual Command Help:\n    lql <command> --help    Display detailed help for specific command\n    lql <command> -h        Display detailed help for specific command\n  \n  Examples:\n    lql deploy --help       Show deploy command options\n    lql server --port 8080  Start server on port 8080\n    lql init --workspace    Initialize new workspace\n  ";
+export declare function displayUsage(): void;

package/utils/display.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usageText = void 0;
+exports.displayVersion = displayVersion;
+exports.displayUsage = displayUsage;
+const chalk_1 = __importDefault(require("chalk"));
+const package_1 = require("../package");
+// Function to display the version information
+function displayVersion() {
+    const pkg = (0, package_1.readAndParsePackageJson)();
+    console.log(chalk_1.default.green(`Name: ${pkg.name}`));
+    console.log(chalk_1.default.blue(`Version: ${pkg.version}`));
+}
+exports.usageText = `
+  Usage: lql <command> [options]
+         launchql <command> [options]
+  
+  Core Database Operations:
+    add                Add database changes to plans and create SQL files
+    deploy             Deploy database changes and migrations
+    verify             Verify database state and migrations
+    revert             Revert database changes and migrations
+  
+  Project Management:
+    init               Initialize LaunchQL workspace or module
+    extension          Manage module dependencies
+    plan               Generate module deployment plans
+    package            Package module for distribution
+  
+  Development Tools:
+    server             Start LaunchQL GraphQL server
+    explorer           Launch GraphiQL explorer interface
+    export             Export database migrations from existing databases
+  
+  Database Administration:
+    kill               Terminate database connections and optionally drop databases
+    install            Install LaunchQL modules
+    tag                Add tags to changes for versioning
+  
+  Migration Tools:
+    migrate            Migration management subcommands
+      init             Initialize migration tracking
+      status           Show migration status
+      list             List all changes
+      deps             Show change dependencies
+  
+  Global Options:
+    -h, --help         Display this help information
+    -v, --version      Display version information
+    --cwd <directory>  Working directory (default: current directory)
+  
+  Individual Command Help:
+    lql <command> --help    Display detailed help for specific command
+    lql <command> -h        Display detailed help for specific command
+  
+  Examples:
+    lql deploy --help       Show deploy command options
+    lql server --port 8080  Start server on port 8080
+    lql init --workspace    Initialize new workspace
+  `;
+function displayUsage() {
+    console.log(exports.usageText);
+}

package/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './argv';
+export * from './database';
+export * from './display';

package/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./argv"), exports);
+__exportStar(require("./database"), exports);
+__exportStar(require("./display"), exports);

package/utils/module-utils.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from '@launchql/logger';
+import { Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+/**
+ * Handle package selection for operations that need a specific package
+ * Returns the selected package name, or undefined if validation fails or no packages exist
+ */
+export declare function selectPackage(argv: Partial<ParsedArgs>, prompter: Inquirerer, cwd: string, operationName: string, log?: Logger): Promise<string | undefined>;

package/utils/module-utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectPackage = selectPackage;
+const core_1 = require("@launchql/core");
+const types_1 = require("@launchql/types");
+/**
+ * Handle package selection for operations that need a specific package
+ * Returns the selected package name, or undefined if validation fails or no packages exist
+ */
+async function selectPackage(argv, prompter, cwd, operationName, log) {
+    const pkg = new core_1.LaunchQLPackage(cwd);
+    const modules = await pkg.getModules();
+    const moduleNames = modules.map(mod => mod.getModuleName());
+    // Check if any modules exist
+    if (!moduleNames.length) {
+        const errorMsg = 'No modules found in the specified directory.';
+        if (log) {
+            log.error(errorMsg);
+            return undefined;
+        }
+        else {
+            prompter.close();
+            throw types_1.errors.NOT_FOUND({}, errorMsg);
+        }
+    }
+    // If a specific package was provided, validate it
+    if (argv.package) {
+        const packageName = argv.package;
+        if (log)
+            log.info(`Using specified package: ${packageName}`);
+        if (!moduleNames.includes(packageName)) {
+            const errorMsg = `Package '${packageName}' not found. Available packages: ${moduleNames.join(', ')}`;
+            if (log) {
+                log.error(errorMsg);
+                return undefined;
+            }
+            else {
+                throw types_1.errors.NOT_FOUND({}, errorMsg);
+            }
+        }
+        return packageName;
+    }
+    // Interactive selection
+    const { package: selectedPackage } = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'package',
+            message: `Choose a package to ${operationName}`,
+            options: moduleNames,
+            required: true
+        }]);
+    if (log)
+        log.info(`Selected package: ${selectedPackage}`);
+    return selectedPackage;
+}