@constructive-io/cli 0.0.3 → 5.1.1

package/commands/{analyze.d.ts → codegen.d.ts}

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

package/commands/codegen.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const graphql_codegen_1 = require("@constructive-io/graphql-codegen");
+const graphql_server_1 = require("@constructive-io/graphql-server");
+const usage = `
+Constructive GraphQL Codegen:
+
+  cnc codegen [OPTIONS]
+
+Options:
+  --help, -h                 Show this help message
+  --config <path>            Config file (json|yaml)
+  --schema <path>            Schema SDL file path
+  --endpoint <url>           GraphQL endpoint to fetch schema via introspection
+  --headerHost <host>        Optional Host header to send with endpoint requests
+  --auth <token>             Optional Authorization header value (e.g., "Bearer 123")
+  --header "Name: Value"    Optional HTTP header; repeat to add multiple headers
+  --out <dir>                Output root directory (default: graphql/codegen/dist)
+  --format <gql|ts>          Document format (default: gql)
+  --convention <style>       Filename convention (dashed|underscore|camelcase|camelUpper)
+  --emitTypes <bool>         Emit types (default: true)
+  --emitOperations <bool>    Emit operations (default: true)
+  --emitSdk <bool>           Emit sdk (default: true)
+  --allowQuery <name>        Only generate for this root field (repeatable)
+  --excludeQuery <name>      Exclude this root field (repeatable)
+  --excludePattern <regex>   Exclude fields matching regex (repeatable)
+`;
+function parseBool(v, d) {
+    if (v === undefined)
+        return d;
+    if (typeof v === 'boolean')
+        return v;
+    const s = String(v).toLowerCase();
+    if (s === 'true')
+        return true;
+    if (s === 'false')
+        return false;
+    return d;
+}
+async function loadConfig(path) {
+    const content = await fs_1.promises.readFile(path, 'utf8');
+    if (/\.ya?ml$/i.test(path))
+        return js_yaml_1.default.load(content);
+    if (/\.json$/i.test(path))
+        return JSON.parse(content);
+    return {};
+}
+exports.default = async (argv, _prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(usage);
+        process.exit(0);
+    }
+    const cwd = argv.cwd || process.cwd();
+    const configPath = argv.config || '';
+    let fileOpts = {};
+    if (configPath)
+        fileOpts = await loadConfig(configPath);
+    const overrides = {};
+    if (argv.schema)
+        overrides.input = { ...(overrides.input || {}), schema: String(argv.schema) };
+    if (argv.endpoint)
+        overrides.input = { ...(overrides.input || {}), endpoint: String(argv.endpoint) };
+    const headerHost = argv.headerHost ?? '';
+    const auth = argv.auth ?? '';
+    const headerArg = argv.header;
+    const headerList = Array.isArray(headerArg) ? headerArg : headerArg ? [headerArg] : [];
+    const headers = {};
+    if (auth)
+        headers['Authorization'] = auth;
+    for (const h of headerList) {
+        const idx = typeof h === 'string' ? h.indexOf(':') : -1;
+        if (idx <= 0)
+            continue;
+        const name = h.slice(0, idx).trim();
+        const value = h.slice(idx + 1).trim();
+        if (!name)
+            continue;
+        headers[name] = value;
+    }
+    if (Object.keys(headers).length)
+        overrides.input = { ...(overrides.input || {}), headers };
+    if (argv.out)
+        overrides.output = { ...(overrides.output || {}), root: String(argv.out) };
+    if (argv.format)
+        overrides.documents = { ...(overrides.documents || {}), format: String(argv.format) };
+    if (argv.convention)
+        overrides.documents = { ...(overrides.documents || {}), convention: String(argv.convention) };
+    const allowQueryArg = argv.allowQuery;
+    const excludeQueryArg = argv.excludeQuery;
+    const excludePatternArg = argv.excludePattern;
+    const allowQueries = Array.isArray(allowQueryArg) ? allowQueryArg : allowQueryArg ? [String(allowQueryArg)] : [];
+    const excludeQueries = Array.isArray(excludeQueryArg) ? excludeQueryArg : excludeQueryArg ? [String(excludeQueryArg)] : [];
+    const excludePatterns = Array.isArray(excludePatternArg) ? excludePatternArg : excludePatternArg ? [String(excludePatternArg)] : [];
+    if (allowQueries.length || excludeQueries.length || excludePatterns.length) {
+        overrides.documents = { ...(overrides.documents || {}), allowQueries, excludeQueries, excludePatterns };
+    }
+    const emitTypes = parseBool(argv.emitTypes, true);
+    const emitOperations = parseBool(argv.emitOperations, true);
+    const emitSdk = parseBool(argv.emitSdk, true);
+    overrides.features = { emitTypes, emitOperations, emitSdk };
+    const merged = (0, graphql_codegen_1.mergeGraphQLCodegenOptions)(graphql_codegen_1.defaultGraphQLCodegenOptions, fileOpts);
+    const finalOptions = (0, graphql_codegen_1.mergeGraphQLCodegenOptions)(merged, overrides);
+    if (finalOptions.input.endpoint && headerHost) {
+        const opts = {};
+        if (headerHost)
+            opts.headerHost = headerHost;
+        if (auth)
+            opts.auth = auth;
+        if (Object.keys(headers).length)
+            opts.headers = headers;
+        const sdl = await graphql_server_1.fetchEndpointSchemaSDL(String(finalOptions.input.endpoint), opts);
+        const tmpSchemaPath = (0, path_1.join)(cwd, '.constructive-codegen-schema.graphql');
+        await fs_1.promises.writeFile(tmpSchemaPath, sdl, 'utf8');
+        finalOptions.input.schema = tmpSchemaPath;
+        finalOptions.input.endpoint = '';
+    }
+    const hasSchema = !!finalOptions.input.schema && String(finalOptions.input.schema).trim() !== '';
+    const hasEndpoint = !!finalOptions.input.endpoint && String(finalOptions.input.endpoint).trim() !== '';
+    if (!hasSchema && !hasEndpoint) {
+        console.error('Missing --schema or --endpoint or config.input');
+        process.exit(1);
+    }
+    const result = await (0, graphql_codegen_1.runCodegen)(finalOptions, cwd);
+    console.log(`Generated at ${(0, path_1.join)(result.root)}`);
+};

package/commands/explorer.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_env_1 = require("@constructive-io/graphql-env");
+const graphql_explorer_1 = require("@constructive-io/graphql-explorer");
+const logger_1 = require("@pgpmjs/logger");
+const log = new logger_1.Logger('explorer');
+const explorerUsageText = `
+Constructive GraphQL Explorer:
+
+  cnc explorer [OPTIONS]
+
+  Launch GraphiQL explorer interface.
+
+Options:
+  --help, -h              Show this help message
+  --port <number>         Server port (default: 5555)
+  --origin <url>          CORS origin URL (default: http://localhost:3000)
+  --simpleInflection      Use simple inflection (default: true)
+  --oppositeBaseNames     Use opposite base names (default: false)
+  --postgis               Enable PostGIS extension (default: true)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  cnc explorer                        Launch explorer with defaults
+  cnc explorer --origin http://localhost:4000  Launch explorer with custom origin
+`;
+const questions = [
+    {
+        name: 'simpleInflection',
+        message: 'Use simple inflection?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'oppositeBaseNames',
+        message: 'Use opposite base names?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true
+    },
+    {
+        name: 'postgis',
+        message: 'Enable PostGIS extension?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'port',
+        message: 'Development server port',
+        type: 'number',
+        required: false,
+        default: 5555,
+        useDefault: true
+    },
+    {
+        name: 'origin',
+        message: 'CORS origin URL',
+        type: 'text',
+        required: false,
+        default: 'http://localhost:3000',
+        useDefault: true
+    }
+];
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(explorerUsageText);
+        process.exit(0);
+    }
+    log.info('🔧 Constructive GraphQL Explorer Configuration:\n');
+    const { oppositeBaseNames, origin, port, postgis, simpleInflection } = await prompter.prompt(argv, questions);
+    const options = (0, graphql_env_1.getEnvOptions)({
+        features: {
+            oppositeBaseNames,
+            simpleInflection,
+            postgis
+        },
+        server: {
+            origin,
+            port
+        }
+    });
+    log.success('✅ Selected Configuration:');
+    for (const [key, value] of Object.entries(options)) {
+        log.debug(`${key}: ${JSON.stringify(value)}`);
+    }
+    log.success('🚀 Launching Explorer...\n');
+    (0, graphql_explorer_1.GraphQLExplorer)(options);
+};

package/commands/get-graphql-schema.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const graphql_server_1 = require("@constructive-io/graphql-server");
+const usage = `
+Constructive Get GraphQL Schema:
+
+  cnc get-graphql-schema [OPTIONS]
+
+Options:
+  --help, -h              Show this help message
+  --database <name>       Database name (default: constructive)
+  --schemas <list>        Comma-separated schemas to include
+  --endpoint <url>        GraphQL endpoint to fetch schema via introspection
+  --headerHost <host>     Optional Host header to send with endpoint requests
+  --auth <token>          Optional Authorization header value (e.g., "Bearer 123")
+  --header "Name: Value"  Optional HTTP header; repeat to add multiple headers
+  --out <path>            Output file path (default: print to stdout)
+`;
+const defaultSchemas = [
+    'collections_public',
+    'dashboard_public'
+];
+exports.default = async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(usage);
+        process.exit(0);
+    }
+    const endpoint = argv.endpoint ?? '';
+    const headerHost = argv.headerHost ?? '';
+    const auth = argv.auth ?? '';
+    const database = argv.database ?? 'constructive';
+    const schemasArg = argv.schemas ?? defaultSchemas.join(',');
+    const out = argv.out ?? '';
+    const headerArg = argv.header;
+    const headerList = Array.isArray(headerArg) ? headerArg : headerArg ? [headerArg] : [];
+    const headers = {};
+    for (const h of headerList) {
+        const idx = typeof h === 'string' ? h.indexOf(':') : -1;
+        if (idx <= 0)
+            continue;
+        const name = h.slice(0, idx).trim();
+        const value = h.slice(idx + 1).trim();
+        if (!name)
+            continue;
+        headers[name] = value;
+    }
+    const schemas = schemasArg.split(',').map(s => s.trim()).filter(Boolean);
+    let sdl;
+    if (endpoint) {
+        const opts = {};
+        if (headerHost)
+            opts.headerHost = headerHost;
+        if (auth)
+            opts.auth = auth;
+        if (Object.keys(headers).length)
+            opts.headers = headers;
+        sdl = await graphql_server_1.fetchEndpointSchemaSDL(endpoint, opts);
+    }
+    else {
+        // The server package already depends on postgraphile and graphql,
+        // and exporting a reusable programmatic builder from there
+        // avoids adding new dependencies to cli and prevents duplication.
+        sdl = await (0, graphql_server_1.buildSchemaSDL)({ database, schemas });
+    }
+    if (out) {
+        await fs_1.promises.writeFile(out, sdl, 'utf8');
+        console.log(`Wrote schema SDL to ${out}`);
+    }
+    else {
+        process.stdout.write(sdl + '\n');
+    }
+};

package/commands/server.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_env_1 = require("@constructive-io/graphql-env");
+const logger_1 = require("@pgpmjs/logger");
+const graphql_server_1 = require("@constructive-io/graphql-server");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.Logger('server');
+const serverUsageText = `
+Constructive GraphQL Server:
+
+  cnc server [OPTIONS]
+
+  Start Constructive GraphQL development server.
+
+Options:
+  --help, -h              Show this help message
+  --port <number>         Server port (default: 5555)
+  --simpleInflection      Use simple inflection (default: true)
+  --oppositeBaseNames     Use opposite base names (default: false)
+  --postgis               Enable PostGIS extension (default: true)
+  --metaApi               Enable Meta API (default: true)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  cnc server                    Start server with defaults
+  cnc server --port 8080        Start server on custom port
+  cnc server --no-postgis       Start server without PostGIS
+`;
+const questions = [
+    {
+        name: 'simpleInflection',
+        message: 'Use simple inflection?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'oppositeBaseNames',
+        message: 'Use opposite base names?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true
+    },
+    {
+        name: 'postgis',
+        message: 'Enable PostGIS extension?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'metaApi',
+        message: 'Enable Meta API?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'origin',
+        message: 'CORS origin (exact URL or *)',
+        type: 'text',
+        required: false,
+        // no default to avoid accidentally opening up CORS; pass explicitly or via env
+    },
+    {
+        name: 'port',
+        message: 'Development server port',
+        type: 'number',
+        required: false,
+        default: 5555,
+        useDefault: true
+    }
+];
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(serverUsageText);
+        process.exit(0);
+    }
+    log.info('🔧 Constructive GraphQL Server Configuration:\n');
+    let selectedDb = process.env.PGDATABASE;
+    if (!selectedDb) {
+        const db = await (0, pg_cache_1.getPgPool)({ database: 'postgres' });
+        const result = await db.query(`
+      SELECT datname FROM pg_database
+      WHERE datistemplate = false AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_'
+      ORDER BY datname;
+    `);
+        const dbChoices = result.rows.map(row => row.datname);
+        const { database } = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'database',
+                message: 'Select the database to use',
+                options: dbChoices,
+                required: true
+            }
+        ]);
+        selectedDb = database;
+        log.info(`📌 Using database: "${selectedDb}"`);
+    }
+    const { oppositeBaseNames, port, postgis, simpleInflection, metaApi, origin } = await prompter.prompt(argv, questions);
+    // Warn when passing CORS override via CLI, especially in production
+    if (origin && origin.trim().length) {
+        const env = (process.env.NODE_ENV || 'development').toLowerCase();
+        if (env === 'production') {
+            if (origin.trim() === '*') {
+                log.warn('CORS wildcard ("*") provided via --origin in production: this effectively disables CORS and is not recommended. Prefer per-API CORS via meta schema.');
+            }
+            else {
+                log.warn(`CORS override (origin=${origin.trim()}) provided via --origin in production. Prefer per-API CORS via meta schema.`);
+            }
+        }
+    }
+    let selectedSchemas = [];
+    let authRole;
+    let roleName;
+    if (!metaApi) {
+        const db = await (0, pg_cache_1.getPgPool)({ database: selectedDb });
+        const result = await db.query(`
+      SELECT nspname 
+      FROM pg_namespace 
+      WHERE nspname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY nspname;
+    `);
+        const schemaChoices = result.rows.map(row => ({
+            name: row.nspname,
+            value: row.nspname,
+            selected: true
+        }));
+        const { schemas } = await prompter.prompt(argv, [
+            {
+                type: 'checkbox',
+                name: 'schemas',
+                message: 'Select schemas to expose',
+                options: schemaChoices,
+                required: true
+            }
+        ]);
+        selectedSchemas = schemas.filter(s => s.selected).map(s => s.value);
+        const { authRole: selectedAuthRole, roleName: selectedRoleName } = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'authRole',
+                message: 'Select the authentication role',
+                options: ['postgres', 'authenticated', 'anonymous'],
+                required: true
+            },
+            {
+                type: 'autocomplete',
+                name: 'roleName',
+                message: 'Enter the default role name:',
+                options: ['postgres', 'authenticated', 'anonymous'],
+                required: true
+            }
+        ]);
+        authRole = selectedAuthRole;
+        roleName = selectedRoleName;
+    }
+    const options = (0, graphql_env_1.getEnvOptions)({
+        pg: { database: selectedDb },
+        features: {
+            oppositeBaseNames,
+            simpleInflection,
+            postgis
+        },
+        api: {
+            enableMetaApi: metaApi,
+            ...(metaApi === false && { exposedSchemas: selectedSchemas, authRole, roleName })
+        },
+        server: {
+            port,
+            ...(origin ? { origin } : {})
+        }
+    });
+    log.success('✅ Selected Configuration:');
+    for (const [key, value] of Object.entries(options)) {
+        log.debug(`${key}: ${JSON.stringify(value)}`);
+    }
+    log.success('🚀 Launching Server...\n');
+    (0, graphql_server_1.GraphQLServer)(options);
+};

package/commands.d.ts

@@ -1,6 +1,5 @@
 import { CLIOptions, Inquirerer } from 'inquirerer';
 import { ParsedArgs } from 'minimist';
-export declare const createConstructiveCommandMap: (skipPgTeardown?: boolean) => Record<string, Function>;
 export declare const commands: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions & {
     skipPgTeardown?: boolean;
 }) => Promise<Partial<ParsedArgs>>;

package/commands.js

@@ -3,83 +3,63 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.commands = exports.createConstructiveCommandMap = void 0;
-const pg_cache_1 = require("pg-cache");
-const add_1 = __importDefault(require("./commands/add"));
-const admin_users_1 = __importDefault(require("./commands/admin-users"));
-const analyze_1 = __importDefault(require("./commands/analyze"));
-const clear_1 = __importDefault(require("./commands/clear"));
-const deploy_1 = __importDefault(require("./commands/deploy"));
-const docker_1 = __importDefault(require("./commands/docker"));
-const env_1 = __importDefault(require("./commands/env"));
-const export_1 = __importDefault(require("./commands/export"));
-const extension_1 = __importDefault(require("./commands/extension"));
-const init_1 = __importDefault(require("./commands/init"));
-const install_1 = __importDefault(require("./commands/install"));
-const kill_1 = __importDefault(require("./commands/kill"));
-const migrate_1 = __importDefault(require("./commands/migrate"));
-const package_1 = __importDefault(require("./commands/package"));
-const plan_1 = __importDefault(require("./commands/plan"));
-const remove_1 = __importDefault(require("./commands/remove"));
-const rename_1 = __importDefault(require("./commands/rename"));
-const revert_1 = __importDefault(require("./commands/revert"));
-const tag_1 = __importDefault(require("./commands/tag"));
-const verify_1 = __importDefault(require("./commands/verify"));
-const package_2 = require("./package");
+exports.commands = void 0;
+const find_and_require_package_json_1 = require("find-and-require-package-json");
+const pgpm_1 = require("pgpm");
+const codegen_1 = __importDefault(require("./commands/codegen"));
+const explorer_1 = __importDefault(require("./commands/explorer"));
+const get_graphql_schema_1 = __importDefault(require("./commands/get-graphql-schema"));
+const server_1 = __importDefault(require("./commands/server"));
 const utils_1 = require("./utils");
-const cli_error_1 = require("./utils/cli-error");
-const withPgTeardown = (fn, skipTeardown = false) => async (...args) => {
-    try {
-        await fn(...args);
-    }
-    finally {
-        if (!skipTeardown) {
-            await (0, pg_cache_1.teardownPgPools)();
-        }
-    }
-};
-const createConstructiveCommandMap = (skipPgTeardown = false) => {
-    const pgt = (fn) => withPgTeardown(fn, skipPgTeardown);
+const createCommandMap = (skipPgTeardown = false) => {
+    const pgpmCommands = (0, pgpm_1.createPgpmCommandMap)(skipPgTeardown);
     return {
-        add: add_1.default,
-        'admin-users': pgt(admin_users_1.default),
-        clear: pgt(clear_1.default),
-        deploy: pgt(deploy_1.default),
-        docker: docker_1.default,
-        env: env_1.default,
-        verify: pgt(verify_1.default),
-        revert: pgt(revert_1.default),
-        remove: pgt(remove_1.default),
-        init: pgt(init_1.default),
-        extension: pgt(extension_1.default),
-        plan: pgt(plan_1.default),
-        export: pgt(export_1.default),
-        package: pgt(package_1.default),
-        tag: pgt(tag_1.default),
-        kill: pgt(kill_1.default),
-        install: pgt(install_1.default),
-        migrate: pgt(migrate_1.default),
-        analyze: pgt(analyze_1.default),
-        rename: pgt(rename_1.default)
+        ...pgpmCommands,
+        server: server_1.default,
+        explorer: explorer_1.default,
+        'get-graphql-schema': get_graphql_schema_1.default,
+        codegen: codegen_1.default
     };
 };
-exports.createConstructiveCommandMap = createConstructiveCommandMap;
 const commands = async (argv, prompter, options) => {
+    let { first: command, newArgv } = (0, utils_1.extractFirst)(argv);
+    // Run update check early so it shows on help/version paths too
+    try {
+        const pkg = (0, find_and_require_package_json_1.findAndRequirePackageJson)(__dirname);
+        await (0, pgpm_1.checkForUpdates)({
+            command: command || 'help',
+            pkgName: pkg.name,
+            pkgVersion: pkg.version,
+            toolName: 'constructive',
+            key: pkg.name,
+            updateCommand: `Run npm i -g ${pkg.name}@latest to upgrade.`
+        });
+    }
+    catch {
+        // ignore update check failures
+    }
     if (argv.version || argv.v) {
-        const pkg = (0, package_2.readAndParsePackageJson)();
+        const pkg = (0, find_and_require_package_json_1.findAndRequirePackageJson)(__dirname);
         console.log(pkg.version);
         process.exit(0);
     }
-    let { first: command, newArgv } = (0, utils_1.extractFirst)(argv);
+    // Show usage if explicitly requested but no command specified
     if ((argv.help || argv.h || command === 'help') && !command) {
         console.log(utils_1.usageText);
         process.exit(0);
     }
+    // Show usage for help command specifically
     if (command === 'help') {
         console.log(utils_1.usageText);
         process.exit(0);
     }
-    const commandMap = (0, exports.createConstructiveCommandMap)(options?.skipPgTeardown);
+    // Command-specific help for init
+    if (command === 'init' && (argv.help || argv.h)) {
+        console.log((0, pgpm_1.createInitUsageText)('constructive', 'Constructive'));
+        process.exit(0);
+    }
+    const commandMap = createCommandMap(options?.skipPgTeardown);
+    // Prompt if no command provided
     if (!command) {
         const answer = await prompter.prompt(argv, [
             {
@@ -91,6 +71,7 @@ const commands = async (argv, prompter, options) => {
         ]);
         command = answer.command;
     }
+    // Prompt for working directory
     newArgv = await prompter.prompt(newArgv, [
         {
             type: 'text',
@@ -104,7 +85,7 @@ const commands = async (argv, prompter, options) => {
     const commandFn = commandMap[command];
     if (!commandFn) {
         console.log(utils_1.usageText);
-        await (0, cli_error_1.cliExitWithError)(`Unknown command: ${command}`);
+        await (0, utils_1.cliExitWithError)(`Unknown command: ${command}`);
     }
     await commandFn(newArgv, prompter, options);
     prompter.close();