@constructive-io/cli 0.0.2

package/commands/migrate/deps.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const core_2 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-deps');
+exports.default = async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = (0, path_1.join)(cwd, 'pgpm.plan');
+    if (!(0, fs_1.existsSync)(planPath)) {
+        log.error(`No pgpm.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get specific change to analyze
+    let changeName = argv._?.[0] || argv.change;
+    const planResult = (0, core_2.parsePlanFile)(planPath);
+    if (!planResult.data || planResult.errors.length > 0) {
+        log.error('Failed to parse plan file:', planResult.errors);
+        process.exit(1);
+    }
+    const plan = planResult.data;
+    const allChanges = plan.changes;
+    // If no change specified, prompt
+    if (!changeName && !argv.all) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'change',
+                message: 'Which change do you want to analyze?',
+                options: allChanges.map(c => ({
+                    name: c.name,
+                    value: c.name,
+                    description: c.dependencies.length > 0 ? `Depends on: ${c.dependencies.join(', ')}` : 'No dependencies'
+                }))
+            }
+        ]);
+        changeName = answer.change;
+    }
+    try {
+        if (argv.all) {
+            // Show dependency graph for all changes
+            console.log('\n🔗 Dependency Graph\n');
+            console.log(`Package: ${plan.package}`);
+            console.log(`Total Changes: ${allChanges.length}\n`);
+            // Build dependency tree
+            const dependencyTree = buildDependencyTree(allChanges);
+            // Show changes with no dependencies first (roots)
+            const roots = allChanges.filter(c => c.dependencies.length === 0);
+            console.log('📌 Root Changes (no dependencies):\n');
+            roots.forEach(change => {
+                console.log(`  • ${change.name}`);
+                showDependents(change.name, dependencyTree, '    ');
+            });
+            // Show orphaned changes (have dependencies but aren't depended on)
+            const orphans = allChanges.filter(c => c.dependencies.length > 0 &&
+                !allChanges.some(other => other.dependencies.includes(c.name)));
+            if (orphans.length > 0) {
+                console.log('\n🔸 Leaf Changes (not depended on by others):\n');
+                orphans.forEach(change => {
+                    console.log(`  • ${change.name} → [${change.dependencies.join(', ')}]`);
+                });
+            }
+        }
+        else {
+            // Show dependencies for specific change
+            const change = allChanges.find(c => c.name === changeName);
+            if (!change) {
+                log.error(`Change '${changeName}' not found in plan file`);
+                process.exit(1);
+            }
+            console.log(`\n🔍 Dependency Analysis: ${changeName}\n`);
+            // Direct dependencies
+            if (change.dependencies.length > 0) {
+                console.log('📥 Direct Dependencies:');
+                change.dependencies.forEach(dep => {
+                    console.log(`  • ${dep}`);
+                });
+            }
+            else {
+                console.log('📥 Direct Dependencies: None');
+            }
+            // All dependencies (recursive)
+            const allDeps = getAllDependencies(change.name, allChanges);
+            if (allDeps.size > 0) {
+                console.log(`\n📦 All Dependencies (${allDeps.size} total):`);
+                Array.from(allDeps).forEach(dep => {
+                    console.log(`  • ${dep}`);
+                });
+            }
+            // Dependents (what depends on this)
+            const dependents = allChanges.filter(c => c.dependencies.includes(changeName));
+            if (dependents.length > 0) {
+                console.log(`\n📤 Depended on by (${dependents.length} changes):`);
+                dependents.forEach(dep => {
+                    console.log(`  • ${dep.name}`);
+                });
+            }
+            else {
+                console.log('\n📤 Depended on by: None');
+            }
+            // Check deployment status if connected to database
+            const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+            const targetDatabase = await (0, database_1.getTargetDatabase)(argv, prompter, {
+                message: 'Select database to check deployment status'
+            });
+            const client = new core_1.LaunchQLMigrate({
+                host: pgEnv.host,
+                port: pgEnv.port,
+                user: pgEnv.user,
+                password: pgEnv.password,
+                database: pgEnv.database
+            });
+            try {
+                const deployedChanges = await client.getDeployedChanges(targetDatabase, plan.package);
+                const deployedMap = new Map(deployedChanges.map(c => [c.change_name, c]));
+                console.log('\n📊 Deployment Status:');
+                // Check if this change is deployed
+                const isDeployed = deployedMap.has(changeName);
+                console.log(`  This change: ${isDeployed ? '✅ Deployed' : '⏳ Not deployed'}`);
+                // Check dependencies
+                const undeployedDeps = Array.from(allDeps).filter(dep => !deployedMap.has(dep));
+                if (undeployedDeps.length > 0) {
+                    console.log(`  ⚠️  Undeployed dependencies: ${undeployedDeps.join(', ')}`);
+                }
+                else if (allDeps.size > 0) {
+                    console.log('  ✅ All dependencies deployed');
+                }
+                // Check dependents
+                const deployedDependents = dependents.filter(d => deployedMap.has(d.name));
+                if (deployedDependents.length > 0) {
+                    console.log(`  ⚠️  Deployed dependents: ${deployedDependents.map(d => d.name).join(', ')}`);
+                }
+            }
+            catch (dbError) {
+                // Database connection optional for dependency analysis
+                log.debug('Could not connect to database for deployment status');
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to analyze dependencies:', error);
+        process.exit(1);
+    }
+};
+function buildDependencyTree(changes) {
+    const tree = new Map();
+    changes.forEach(change => {
+        change.dependencies.forEach((dep) => {
+            if (!tree.has(dep)) {
+                tree.set(dep, []);
+            }
+            tree.get(dep).push(change.name);
+        });
+    });
+    return tree;
+}
+function showDependents(changeName, tree, indent) {
+    const dependents = tree.get(changeName) || [];
+    dependents.forEach(dep => {
+        console.log(`${indent}└─ ${dep}`);
+        showDependents(dep, tree, indent + '   ');
+    });
+}
+function getAllDependencies(changeName, changes) {
+    const deps = new Set();
+    const change = changes.find(c => c.name === changeName);
+    if (!change)
+        return deps;
+    function addDeps(change) {
+        change.dependencies.forEach((dep) => {
+            if (!deps.has(dep)) {
+                deps.add(dep);
+                const depChange = changes.find(c => c.name === dep);
+                if (depChange) {
+                    addDeps(depChange);
+                }
+            }
+        });
+    }
+    addDeps(change);
+    return deps;
+}

package/commands/migrate/init.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<ParsedArgs>>;
+export default _default;

package/commands/migrate/init.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-init');
+exports.default = async (argv, prompter, _options) => {
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    // Get target database
+    const database = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to initialize migration tracking'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: `Initialize constructive migration schema in database "${database}"?`,
+            required: true
+        }
+    ];
+    const { yes } = await prompter.prompt(argv, questions);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return;
+    }
+    log.info(`Initializing migration schema in database ${database}...`);
+    const config = {
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database
+    };
+    const client = new core_1.LaunchQLMigrate(config);
+    try {
+        await client.initialize();
+        log.success('Migration schema initialized successfully.');
+        // Check if there's an existing Sqitch deployment to import
+        const hasSquitch = await client.hasSqitchTables();
+        if (hasSquitch) {
+            const { importSquitch } = await prompter.prompt(argv, [
+                {
+                    name: 'importSquitch',
+                    type: 'confirm',
+                    message: 'Existing Sqitch deployment detected. Import it?',
+                    required: true
+                }
+            ]);
+            if (importSquitch) {
+                log.info('Importing Sqitch deployment history...');
+                await client.importFromSqitch();
+                log.success('Sqitch deployment imported successfully.');
+            }
+        }
+    }
+    catch (error) {
+        log.error(`Failed to initialize migration schema: ${error instanceof Error ? error.message : error}`);
+        throw error;
+    }
+    finally {
+        await client.close();
+    }
+    return argv;
+};

package/commands/migrate/list.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions) => Promise<void>;
+export default _default;

package/commands/migrate/list.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const core_2 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-list');
+exports.default = async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = (0, path_1.join)(cwd, 'pgpm.plan');
+    if (!(0, fs_1.existsSync)(planPath)) {
+        log.error(`No pgpm.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get database configuration
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    const targetDatabase = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to list migrations'
+    });
+    const client = new core_1.LaunchQLMigrate({
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database: pgEnv.database
+    });
+    try {
+        // Get all changes from plan file
+        const planResult = (0, core_2.parsePlanFile)(planPath);
+        if (!planResult.data || planResult.errors.length > 0) {
+            log.error('Failed to parse plan file:', planResult.errors);
+            process.exit(1);
+        }
+        const plan = planResult.data;
+        const allChanges = plan.changes;
+        // Get deployed changes from database
+        const deployedChanges = await client.getDeployedChanges(targetDatabase, plan.package);
+        console.log('\n📋 All Changes\n');
+        console.log(`Package: ${plan.package}`);
+        console.log(`Total Changes: ${allChanges.length}`);
+        console.log(`Deployed: ${deployedChanges.length}`);
+        console.log(`Pending: ${allChanges.length - deployedChanges.length}\n`);
+        // Create a map for quick lookup
+        const deployedMap = new Map(deployedChanges.map(c => [c.change_name, c]));
+        // List all changes with their status
+        const showAll = argv.all || allChanges.length <= 20;
+        const changesToShow = showAll ? allChanges : allChanges.slice(0, 20);
+        console.log('Status  Change Name                    Dependencies');
+        console.log('------  -----------------------------  --------------------------------');
+        changesToShow.forEach(change => {
+            const deployed = deployedMap.get(change.name);
+            const status = deployed ? '✅' : '⏳';
+            const deps = change.dependencies.length > 0 ? change.dependencies.join(', ') : '-';
+            const depsDisplay = deps.length > 30 ? deps.substring(0, 27) + '...' : deps;
+            console.log(`${status}      ${change.name.padEnd(30)} ${depsDisplay}`);
+        });
+        if (!showAll && allChanges.length > 20) {
+            console.log(`\n... and ${allChanges.length - 20} more changes. Use --all to see all changes.`);
+        }
+        // Show summary by status
+        if (argv.summary !== false) {
+            console.log('\n📊 Summary by Status:\n');
+            const pending = allChanges.filter(c => !deployedMap.has(c.name));
+            const deployed = allChanges.filter(c => deployedMap.has(c.name));
+            console.log(`✅ Deployed: ${deployed.length}`);
+            console.log(`⏳ Pending:  ${pending.length}`);
+            // Show deployment timeline
+            if (deployedChanges.length > 0) {
+                const sortedDeployed = [...deployedChanges].sort((a, b) => new Date(a.deployed_at).getTime() - new Date(b.deployed_at).getTime());
+                const firstDeploy = new Date(sortedDeployed[0].deployed_at);
+                const lastDeploy = new Date(sortedDeployed[sortedDeployed.length - 1].deployed_at);
+                console.log(`\n📅 Deployment Timeline:`);
+                console.log(`   First: ${firstDeploy.toLocaleString()}`);
+                console.log(`   Last:  ${lastDeploy.toLocaleString()}`);
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to list changes:', error);
+        process.exit(1);
+    }
+};

package/commands/migrate/status.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions) => Promise<void>;
+export default _default;

package/commands/migrate/status.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const core_2 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-status');
+exports.default = async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = (0, path_1.join)(cwd, 'pgpm.plan');
+    if (!(0, fs_1.existsSync)(planPath)) {
+        log.error(`No pgpm.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get database configuration
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    const targetDatabase = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to check migration status'
+    });
+    const client = new core_1.LaunchQLMigrate({
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database: pgEnv.database
+    });
+    try {
+        // Parse plan file to get package name
+        const planResult = (0, core_2.parsePlanFile)(planPath);
+        if (!planResult.data || planResult.errors.length > 0) {
+            log.error('Failed to parse plan file:', planResult.errors);
+            process.exit(1);
+        }
+        const plan = planResult.data;
+        // Switch to target database
+        const targetClient = new core_1.LaunchQLMigrate({
+            host: pgEnv.host,
+            port: pgEnv.port,
+            user: pgEnv.user,
+            password: pgEnv.password,
+            database: targetDatabase
+        });
+        const statusResults = await targetClient.status(plan.package);
+        console.log('\n📊 Migration Status\n');
+        console.log(`Database: ${targetDatabase}`);
+        if (statusResults.length > 0) {
+            const status = statusResults[0];
+            console.log(`Package: ${status.package}`);
+            console.log(`Total Deployed: ${status.totalDeployed}`);
+            if (status.lastChange) {
+                console.log(`Last Change: ${status.lastChange}`);
+                console.log(`Last Deployed: ${status.lastDeployed.toLocaleString()}`);
+            }
+            else {
+                console.log('No changes deployed yet');
+            }
+        }
+        else {
+            console.log(`Package: ${plan.package}`);
+            console.log('No deployment history found');
+        }
+        // Show recent changes
+        const recentChanges = await targetClient.getRecentChanges(targetDatabase, 5);
+        if (recentChanges.length > 0) {
+            console.log('\n📋 Recent Changes:\n');
+            recentChanges.forEach((change) => {
+                const status = change.deployed_at ? '✅' : '⏳';
+                const date = change.deployed_at ? new Date(change.deployed_at).toLocaleString() : 'Not deployed';
+                console.log(`${status} ${change.change_name.padEnd(30)} ${date}`);
+            });
+        }
+        // Show pending changes
+        const pendingChanges = await targetClient.getPendingChanges(planPath, targetDatabase);
+        if (pendingChanges.length > 0) {
+            console.log(`\n⏳ Pending Changes: ${pendingChanges.length}\n`);
+            pendingChanges.slice(0, 5).forEach((change) => {
+                console.log(`   - ${change}`);
+            });
+            if (pendingChanges.length > 5) {
+                console.log(`   ... and ${pendingChanges.length - 5} more`);
+            }
+        }
+        else {
+            console.log('\n✅ All changes deployed');
+        }
+    }
+    catch (error) {
+        log.error('Failed to get migration status:', error);
+        process.exit(1);
+    }
+};

package/commands/migrate.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions) => Promise<void>;
+export default _default;

package/commands/migrate.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const deps_1 = __importDefault(require("./migrate/deps"));
+// Migrate subcommands
+const init_1 = __importDefault(require("./migrate/init"));
+const list_1 = __importDefault(require("./migrate/list"));
+const status_1 = __importDefault(require("./migrate/status"));
+const subcommandMap = {
+    init: init_1.default,
+    status: status_1.default,
+    list: list_1.default,
+    deps: deps_1.default
+};
+const migrateUsageText = `
+Migrate Commands:
+
+  launchql migrate init      Initialize migration tracking in database
+  launchql migrate status    Show current migration status
+  launchql migrate list      List all changes (deployed and pending)
+  launchql migrate deps      Show change dependencies
+
+Options:
+  --help, -h     Show this help message
+  --cwd          Working directory (default: current directory)
+`;
+exports.default = async (argv, prompter, options) => {
+    let { first: subcommand, newArgv } = (0, utils_1.extractFirst)(argv);
+    // Show usage if explicitly requested
+    if (argv.help || argv.h || subcommand === 'help') {
+        console.log(migrateUsageText);
+        process.exit(0);
+    }
+    // Prompt if no subcommand provided
+    if (!subcommand) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'subcommand',
+                message: 'What migrate operation do you want to perform?',
+                options: Object.keys(subcommandMap).map(cmd => ({
+                    name: cmd,
+                    value: cmd,
+                    description: getSubcommandDescription(cmd)
+                }))
+            }
+        ]);
+        subcommand = answer.subcommand;
+    }
+    const subcommandFn = subcommandMap[subcommand];
+    if (!subcommandFn) {
+        console.error(`Unknown migrate subcommand: ${subcommand}`);
+        console.log(migrateUsageText);
+        process.exit(1);
+    }
+    await subcommandFn(newArgv, prompter, options);
+};
+function getSubcommandDescription(cmd) {
+    const descriptions = {
+        init: 'Initialize migration tracking in database',
+        status: 'Show current migration status',
+        list: 'List all changes (deployed and pending)',
+        deps: 'Show change dependencies'
+    };
+    return descriptions[cmd] || '';
+}

package/commands/package.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;

package/commands/package.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const packageUsageText = `
+Package Command:
+
+  constructive package [OPTIONS]
+
+  Package module for distribution.
+
+Options:
+  --help, -h                      Show this help message
+  --plan                          Include deployment plan (default: true)
+  --pretty                        Pretty-print output (default: true)
+  --functionDelimiter <delimiter> Function delimiter (default: $EOFCODE$)
+  --cwd <directory>               Working directory (default: current directory)
+
+Examples:
+  constructive package                     Package with defaults
+  constructive package --no-plan           Package without plan
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(packageUsageText);
+        process.exit(0);
+    }
+    const questions = [
+        {
+            type: 'confirm',
+            name: 'plan',
+            default: true,
+            useDefault: true,
+            required: true
+        },
+        {
+            type: 'confirm',
+            name: 'pretty',
+            default: true,
+            useDefault: true,
+            required: true
+        },
+        {
+            type: 'text',
+            name: 'functionDelimiter',
+            default: '$EOFCODE$',
+            useDefault: true,
+            required: false
+        }
+    ];
+    let { cwd, plan, pretty, functionDelimiter } = await prompter.prompt(argv, questions);
+    const project = new core_1.LaunchQLPackage(cwd);
+    project.ensureModule();
+    const info = project.getModuleInfo();
+    info.version;
+    await (0, core_1.writePackage)({
+        version: info.version,
+        extension: true,
+        usePlan: plan,
+        packageDir: project.modulePath,
+        pretty,
+        functionDelimiter
+    });
+    return argv;
+};

package/commands/plan.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;

package/commands/plan.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const log = new logger_1.Logger('plan');
+const planUsageText = `
+Plan Command:
+
+  constructive plan [OPTIONS]
+
+  Generate module deployment plans.
+
+Options:
+  --help, -h                     Show this help message
+  --includePackages              Include packages in plan (default: true)
+  --includeTags                  Prefer @tag references for external packages when available (default: true)
+  --cwd <directory>              Working directory (default: current directory)
+
+Examples:
+  constructive plan                                 Generate deployment plan for current module with defaults
+  constructive plan --includePackages false         Disable including external packages
+  constructive plan --includeTags false              Do not prefer tags for external packages
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(planUsageText);
+        process.exit(0);
+    }
+    const questions = [
+        {
+            type: 'confirm',
+            name: 'includePackages',
+            message: 'Include packages in plan?',
+            useDefault: true,
+            default: true
+        },
+        {
+            type: 'confirm',
+            name: 'includeTags',
+            message: 'Prefer @tag references for external packages when available?',
+            useDefault: true,
+            default: true
+        }
+    ];
+    let { cwd, includePackages, includeTags } = await prompter.prompt(argv, questions);
+    if (!cwd) {
+        cwd = process.cwd();
+        log.info(`Using current directory: ${cwd}`);
+    }
+    const pkg = new core_1.LaunchQLPackage(cwd);
+    if (!pkg.isInModule()) {
+        throw new Error('This command must be run inside a LaunchQL module.');
+    }
+    const includePackagesFlag = typeof includePackages === 'boolean' ? includePackages : true;
+    const includeTagsFlag = typeof includeTags === 'boolean' ? includeTags : true;
+    pkg.writeModulePlan({
+        includePackages: includePackagesFlag,
+        includeTags: includeTagsFlag
+    });
+    return argv;
+};

package/commands/remove.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;