@zintrust/core 0.1.28 → 0.1.29

package/src/cache/drivers/RedisDriver.js

@@ -0,0 +1,84 @@
+/**
+ * Redis Cache Driver
+ * Zero-dependency implementation using Node.js native net module
+ */
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import * as net from '../../node-singletons/net.js';
+import { createCacheKey } from '../../tools/redis/RedisKeyManager.js';
+/**
+ * Create a new Redis driver instance
+ */
+const create = () => {
+    let client = null;
+    const host = Env.REDIS_HOST;
+    const port = Env.REDIS_PORT;
+    const connect = async () => {
+        if (client && !client.destroyed)
+            return client;
+        return new Promise((resolve, reject) => {
+            const socket = net.connect(port, host, () => {
+                client = socket;
+                resolve(socket);
+            });
+            socket.on('error', (err) => {
+                Logger.error(`Redis Connection Error: ${err.message}`);
+                reject(err);
+            });
+        });
+    };
+    const sendCommand = async (command) => {
+        const socket = await connect();
+        return new Promise((resolve, _reject) => {
+            socket.once('data', (data) => {
+                resolve(data.toString());
+            });
+            socket.write(command);
+        });
+    };
+    return {
+        async get(key) {
+            try {
+                const prefixedKey = createCacheKey(key);
+                const response = await sendCommand(`GET ${prefixedKey}\r\n`);
+                if (response.startsWith('$-1'))
+                    return null;
+                // Basic RESP parsing
+                const lines = response.split('\r\n');
+                const value = lines[1];
+                return JSON.parse(value);
+            }
+            catch (error) {
+                Logger.error('Redis GET failed', error);
+                return null;
+            }
+        },
+        async set(key, value, ttl) {
+            const prefixedKey = createCacheKey(key);
+            const jsonValue = JSON.stringify(value);
+            let command = `SET ${prefixedKey} ${jsonValue}\r\n`;
+            if (ttl !== undefined) {
+                command = `SETEX ${prefixedKey} ${ttl} ${jsonValue}\r\n`;
+            }
+            await sendCommand(command);
+        },
+        async delete(key) {
+            const prefixedKey = createCacheKey(key);
+            await sendCommand(`DEL ${prefixedKey}\r\n`);
+        },
+        async clear() {
+            await sendCommand(`FLUSHDB\r\n`);
+        },
+        async has(key) {
+            const prefixedKey = createCacheKey(key);
+            const response = await sendCommand(`EXISTS ${prefixedKey}\r\n`);
+            return response.includes(':1');
+        },
+    };
+};
+/**
+ * RedisDriver namespace - sealed for immutability
+ */
+export const RedisDriver = Object.freeze({
+    create,
+});

package/src/cli/BaseCommand.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Base Command - Abstract Command Class
+ * All CLI commands extend this class
+ */
+import { Command } from 'commander';
+export interface CommandOptions {
+    verbose?: boolean;
+    args?: string[];
+    [key: string]: unknown;
+}
+export interface IBaseCommand {
+    [x: string]: unknown;
+    name: string;
+    description: string;
+    verbose?: boolean;
+    getCommand(): Command;
+    addOptions?: (command: Command) => void;
+    execute(options: CommandOptions): void | Promise<void>;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    debug(message: unknown): void;
+}
+/**
+ * Command Factory Helper
+ * Sealed namespace for immutability
+ */
+export declare const BaseCommand: Readonly<{
+    /**
+     * Create a command instance with common logic
+     */
+    create<T extends IBaseCommand = IBaseCommand>(config: {
+        name: string;
+        description: string;
+        /** Optional alias or aliases for the command (e.g. 'make:mail') */
+        aliases?: string | string[];
+        addOptions?: (command: Command) => void;
+        execute: (options: CommandOptions) => void | Promise<void>;
+    }): T;
+}>;
+//# sourceMappingURL=BaseCommand.d.ts.map

package/src/cli/BaseCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseCommand.d.ts","sourceRoot":"","sources":["../../../src/cli/BaseCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,IAAI,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;WACI,CAAC,SAAS,YAAY,yBAAyB;QACpD,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,mEAAmE;QACnE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAC5B,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;QACxC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KAC5D,GAAG,CAAC;EA6DL,CAAC"}

package/src/cli/BaseCommand.js

@@ -0,0 +1,69 @@
+/**
+ * Base Command - Abstract Command Class
+ * All CLI commands extend this class
+ */
+import { ErrorHandler } from './ErrorHandler.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { Command } from 'commander';
+/**
+ * Command Factory Helper
+ * Sealed namespace for immutability
+ */
+export const BaseCommand = Object.freeze({
+    /**
+     * Create a command instance with common logic
+     */
+    create(config) {
+        const getCommand = () => {
+            const command = new Command(config.name);
+            command.description(config.description);
+            command.option('--verbose', 'Enable verbose output');
+            if (typeof config.aliases === 'string' && config.aliases.length > 0) {
+                command.alias(config.aliases);
+            }
+            if (Array.isArray(config.aliases)) {
+                for (const alias of config.aliases) {
+                    if (typeof alias === 'string' && alias.length > 0) {
+                        command.alias(alias);
+                    }
+                }
+            }
+            // Add custom options
+            if (config.addOptions) {
+                config.addOptions(command);
+            }
+            // Set action handler
+            command.action(async (...args) => {
+                const options = args.at(-2);
+                const commandArgs = args.slice(0, -2);
+                options.args = commandArgs;
+                try {
+                    await config.execute(options);
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        ErrorFactory.createTryCatchError('Command execution failed', error);
+                        ErrorHandler.handle(error, undefined, false);
+                        return;
+                    }
+                    const wrapped = ErrorFactory.createTryCatchError('Command execution failed', error);
+                    ErrorHandler.handle(wrapped, undefined, false);
+                }
+            });
+            return command;
+        };
+        const base = {
+            name: config.name,
+            description: config.description,
+            verbose: false,
+            addOptions: config.addOptions,
+            getCommand,
+            execute: config.execute,
+            info: (msg) => ErrorHandler.info(msg),
+            success: (msg) => ErrorHandler.success(msg),
+            warn: (msg) => ErrorHandler.warn(msg),
+            debug: (msg) => ErrorHandler.debug(msg, true),
+        };
+        return base;
+    },
+});

package/src/cli/CLI.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ */
+import { Command } from 'commander';
+export interface ICLI {
+    run(args: string[]): Promise<void>;
+    getProgram(): Command;
+}
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ *
+ * Notes:
+ * - `CLI.create()` is the preferred API (used by current bin scripts/tests).
+ * - `new CLI()` remains supported for backward compatibility with older bin scripts.
+ */
+export declare const CLI: Readonly<{
+    create(): ICLI;
+}>;
+//# sourceMappingURL=CLI.d.ts.map

package/src/cli/CLI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CLI.d.ts","sourceRoot":"","sources":["../../../src/cli/CLI.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA0CH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,MAAM,WAAW,IAAI;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,IAAI,OAAO,CAAC;CACvB;AA2MD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}

package/src/cli/CLI.js

@@ -0,0 +1,242 @@
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ */
+import { AddCommand } from './commands/AddCommand.js';
+import { BroadcastWorkCommand } from './commands/BroadcastWorkCommand.js';
+import { ConfigCommand } from './commands/ConfigCommand.js';
+import { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from './commands/CreateCommand.js';
+import { D1MigrateCommand } from './commands/D1MigrateCommand.js';
+import { DbSeedCommand } from './commands/DbSeedCommand.js';
+import { DebugCommand } from './commands/DebugCommand.js';
+import { FixCommand } from './commands/FixCommand.js';
+import { JwtDevCommand } from './commands/JwtDevCommand.js';
+import { KeyGenerateCommand } from './commands/KeyGenerateCommand.js';
+import { MakeMailTemplateCommand } from './commands/MakeMailTemplateCommand.js';
+import { MakeNotificationTemplateCommand } from './commands/MakeNotificationTemplateCommand.js';
+import { MigrateCommand } from './commands/MigrateCommand.js';
+import { MigrateWorkerCommand } from './commands/MigrateWorkerCommand.js';
+import { NewCommand } from './commands/NewCommand.js';
+import { NotificationWorkCommand } from './commands/NotificationWorkCommand.js';
+import { PluginCommand } from './commands/PluginCommand.js';
+import { PrepareCommand } from './commands/PrepareCommand.js';
+import { PublishCommand } from './commands/PublishCommand.js';
+import { QACommand } from './commands/QACommand.js';
+import { QueueCommand } from './commands/QueueCommand.js';
+import { ResourceControlCommand } from './commands/ResourceControlCommand.js';
+import { RoutesCommand } from './commands/RoutesCommand.js';
+import { SecretsCommand } from './commands/SecretsCommand.js';
+import { SimulateCommand } from './commands/SimulateCommand.js';
+import { StartCommand } from './commands/StartCommand.js';
+import { TemplatesCommand } from './commands/TemplatesCommand.js';
+import { UpgradeCommand } from './commands/UpgradeCommand.js';
+import { WorkerCommands } from './commands/WorkerCommands.js';
+import { ErrorHandler } from './ErrorHandler.js';
+import { VersionChecker } from './services/VersionChecker.js';
+import { esmDirname } from '../common/index.js';
+import { Logger } from '../config/logger.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { readFileSync } from '../node-singletons/fs.js';
+import { join } from '../node-singletons/path.js';
+import { Command } from 'commander';
+const __dirname = esmDirname(import.meta.url);
+/**
+ * Load version from package.json
+ */
+const loadVersion = () => {
+    try {
+        const packagePath = join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : '1.0.0';
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Failed to load version from package.json', error);
+        // Use default version if package.json not found
+        return '1.0.0';
+    }
+};
+/**
+ * Setup program metadata
+ */
+const setupProgram = (program, version) => {
+    program
+        .name('zintrust')
+        .description('ZinTrust Framework CLI - Build production-grade TypeScript APIs')
+        .version(version, '-v, --version', 'Output version number')
+        .helpOption('-h, --help', 'Display help for command')
+        .usage('[command] [options]');
+    // Global error handling
+    program.exitOverride();
+};
+/**
+ * Register all available commands
+ */
+const registerCommands = (program) => {
+    const commands = [
+        NewCommand.create(),
+        UpgradeCommand.create(),
+        PrepareCommand,
+        AddCommand.create(),
+        CreateCommand.create(),
+        CreateMigrationCommand.create(),
+        AddMigrationCommand.create(),
+        StartCommand.create(),
+        QueueCommand.create(),
+        BroadcastWorkCommand.create(),
+        NotificationWorkCommand.create(),
+        ResourceControlCommand,
+        MigrateWorkerCommand.create(),
+        MigrateCommand.create(),
+        DbSeedCommand.create(),
+        D1MigrateCommand.create(),
+        DebugCommand.create(),
+        SecretsCommand.create(),
+        ConfigCommand.create(),
+        PluginCommand.create(),
+        PublishCommand.create(),
+        QACommand(),
+        FixCommand.create(),
+        KeyGenerateCommand.create(),
+        SimulateCommand,
+        TemplatesCommand,
+        MakeMailTemplateCommand.create(),
+        MakeNotificationTemplateCommand.create(),
+        RoutesCommand.create(),
+        JwtDevCommand,
+        // Worker management commands
+        WorkerCommands.createWorkerListCommand(),
+        WorkerCommands.createWorkerStatusCommand(),
+        WorkerCommands.createWorkerStartCommand(),
+        WorkerCommands.createWorkerStopCommand(),
+        WorkerCommands.createWorkerRestartCommand(),
+        WorkerCommands.createWorkerSummaryCommand(),
+    ];
+    for (const command of commands) {
+        program.addCommand(command.getCommand());
+    }
+    // Help command
+    program
+        .command('help [command]')
+        .description('Display help for a command')
+        .action((commandName) => {
+        if (commandName) {
+            const cmd = program.commands.find((c) => c.name() === commandName);
+            if (cmd) {
+                cmd.help();
+            }
+            else {
+                Logger.error(`Unknown command: ${commandName}`);
+                program.help();
+            }
+        }
+        else {
+            program.help();
+        }
+    });
+};
+/**
+ * Check if error is a commander error that can be safely ignored
+ */
+const isIgnorableCommanderError = (error) => {
+    if (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code.startsWith('commander.')) {
+        const commanderError = error;
+        return typeof commanderError.exitCode === 'number' && commanderError.exitCode === 0;
+    }
+    return false;
+};
+/**
+ * Get exit code from error
+ */
+const getExitCode = (error) => {
+    if (error instanceof Error &&
+        'exitCode' in error &&
+        typeof error.exitCode === 'number') {
+        return error.exitCode;
+    }
+    return 1;
+};
+/**
+ * Handle CLI execution error
+ */
+const handleExecutionError = (error, version, log = true) => {
+    if (isIgnorableCommanderError(error)) {
+        return;
+    }
+    if (error === version) {
+        return;
+    }
+    const exitCode = getExitCode(error);
+    if (error instanceof Error) {
+        ErrorHandler.handle(error, undefined, log);
+    }
+    // Check for commander-specific errors that need special handling
+    if (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code.startsWith('commander.')) {
+        ErrorFactory.createCliError('CLI execution failed', error);
+        process.exit(exitCode);
+        return;
+    }
+    throw ErrorFactory.createCliError('Unhandled CLI execution error', error);
+};
+/**
+ * Run CLI with arguments
+ */
+const runCLI = async (program, version, args) => {
+    try {
+        // If version is requested, let Commander print it (no banner, fast/clean output).
+        if (args.includes('-v') || args.includes('--version')) {
+            await program.parseAsync(['node', 'zintrust', ...args]);
+            return;
+        }
+        // Always show banner for normal commands
+        ErrorHandler.banner(version);
+        // Run version check in background (non-blocking)
+        VersionChecker.runVersionCheck().catch((error) => {
+            // Version check should never crash the CLI
+            Logger.debug('Version check encountered an error', error);
+        });
+        // Show help if no arguments provided
+        if (args.length === 0) {
+            program.help();
+            return;
+        }
+        // Convert global aliases to subcommand format
+        // e.g., `zin -sim my-app` -> `zin simulate my-app`
+        let processedArgs = args;
+        if (args[0] === '-sim' || args[0] === '--sim') {
+            processedArgs = ['simulate', ...args.slice(1)];
+        }
+        await program.parseAsync(['node', 'zintrust', ...processedArgs]);
+    }
+    catch (error) {
+        // Handle all errors with proper logging and exit logic
+        handleExecutionError(error, version, false);
+    }
+};
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ *
+ * Notes:
+ * - `CLI.create()` is the preferred API (used by current bin scripts/tests).
+ * - `new CLI()` remains supported for backward compatibility with older bin scripts.
+ */
+export const CLI = Object.freeze({
+    create() {
+        const program = new Command();
+        const version = loadVersion();
+        setupProgram(program, version);
+        registerCommands(program);
+        const run = async (args) => runCLI(program, version, args);
+        const getProgram = () => program;
+        return Object.freeze({
+            run,
+            getProgram,
+        });
+    },
+});

package/src/cli/ErrorHandler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Error Handler - CLI Error Formatting & Exit Codes
+ * Provides consistent error formatting and proper Unix exit codes
+ * Sealed namespace with immutable error handling methods
+ */
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly RUNTIME_ERROR: 1;
+    readonly USAGE_ERROR: 2;
+};
+/**
+ * ErrorHandler namespace - sealed for immutability
+ */
+export declare const ErrorHandler: Readonly<{
+    handle: (error: Error | string, exitCode?: number, log?: boolean) => void;
+    usageError: (message: string, command?: string) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string, verbose?: boolean) => void;
+    banner: (version: string) => void;
+}>;
+//# sourceMappingURL=ErrorHandler.d.ts.map

package/src/cli/ErrorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorHandler.d.ts","sourceRoot":"","sources":["../../../src/cli/ErrorHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,eAAO,MAAM,UAAU;;;;CAIb,CAAC;AAwGX;;GAEG;AACH,eAAO,MAAM,YAAY;oBApGhB,KAAK,GAAG,MAAM,aACX,MAAM,QACX,OAAO,KACX,IAAI;0BAYsB,MAAM,YAAY,MAAM,KAAG,IAAI;oBAY9B,MAAM,KAAG,IAAI;uBA+CV,MAAM,KAAG,IAAI;oBAQb,MAAM,KAAG,IAAI;qBAQf,MAAM,YAAW,OAAO,KAAW,IAAI;sBAvDtC,MAAM,KAAG,IAAI;EAyE3C,CAAC"}

package/src/cli/ErrorHandler.js

@@ -0,0 +1,99 @@
+/**
+ * Error Handler - CLI Error Formatting & Exit Codes
+ * Provides consistent error formatting and proper Unix exit codes
+ * Sealed namespace with immutable error handling methods
+ */
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import chalk from 'chalk';
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    RUNTIME_ERROR: 1,
+    USAGE_ERROR: 2,
+};
+/**
+ * Format and display error
+ * Exit codes: 0 (success), 1 (runtime error), 2 (usage error)
+ */
+const handleError = (error, exitCode = EXIT_CODES.RUNTIME_ERROR, log = true) => {
+    const message = typeof error === 'string' ? error : error.message;
+    if (log) {
+        Logger.error(message);
+    }
+    process.exit(exitCode);
+};
+/**
+ * Display usage error with help hint
+ */
+const usageError = (message, command) => {
+    const helpText = `Run: zin ${command} --help`;
+    const hint = command !== undefined && command !== '' ? `\n${chalk.gray(helpText)}` : '';
+    Logger.error(`${message}${hint}`);
+    process.exit(EXIT_CODES.USAGE_ERROR);
+};
+/**
+ * Display info message
+ */
+const displayInfo = (message) => {
+    const formatted = `${chalk.blue('[i]')} ${message}`;
+    Logger.info(formatted);
+};
+/**
+ * Display framework banner
+ */
+const displayBanner = (version) => {
+    /* eslint-disable no-console */
+    const framework = 'ZinTrust Framework';
+    const bannerWidth = 46;
+    const env = Env.NODE_ENV ?? 'development';
+    const db = Env.DB_CONNECTION ?? 'sqlite';
+    const border = chalk.cyanBright;
+    const label = chalk.bold.white;
+    const frameworkValue = chalk.bold.cyanBright;
+    const versionValue = chalk.bold.greenBright;
+    const envValue = chalk.bold.yellowBright;
+    const dbValue = chalk.bold.magentaBright;
+    console.log(border('┌' + '─'.repeat(bannerWidth) + '┐'));
+    console.log(`${border('│')} ${label('Framework: ')}${frameworkValue(framework.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(`${border('│')} ${label('Version:   ')}${versionValue(version.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(`${border('│')} ${label('Env:       ')}${envValue(env.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(`${border('│')} ${label('Database:  ')}${dbValue(db.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(border('└' + '─'.repeat(bannerWidth) + '┘'));
+    console.log();
+    /* eslint-enable no-console */
+};
+/**
+ * Display success message
+ */
+const displaySuccess = (message) => {
+    const formatted = `${chalk.green('[✓]')} ${message}`;
+    Logger.info(formatted);
+};
+/**
+ * Display warning message
+ */
+const displayWarning = (message) => {
+    const formatted = `${chalk.yellow('[!]')} ${message}`;
+    Logger.warn(formatted);
+};
+/**
+ * Display debug message (only if verbose)
+ */
+const displayDebug = (message, verbose = false) => {
+    if (verbose) {
+        const formatted = `${chalk.gray('[DEBUG]')} ${message}`;
+        Logger.debug(formatted);
+    }
+};
+/**
+ * ErrorHandler namespace - sealed for immutability
+ */
+export const ErrorHandler = Object.freeze({
+    handle: handleError,
+    usageError,
+    info: displayInfo,
+    success: displaySuccess,
+    warn: displayWarning,
+    debug: displayDebug,
+    banner: displayBanner,
+});

package/src/cli/PromptHelper.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Prompt Helper - Interactive CLI Prompts
+ * Provides reusable prompt utilities using inquirer
+ */
+export interface PromptOptions {
+    interactive?: boolean;
+    defaults?: Record<string, unknown>;
+}
+/**
+ * Prompt Helper Factory
+ * Sealed namespace for immutability
+ */
+export declare const PromptHelper: Readonly<{
+    /**
+     * Generic prompt method for custom questions
+     */
+    prompt(questions: unknown): Promise<Record<string, unknown>>;
+    /**
+     * Ask for project name
+     */
+    projectName(defaultName?: string, interactive?: boolean): Promise<string>;
+    /**
+     * Ask for database type
+     */
+    databaseType(defaultDb?: string, interactive?: boolean): Promise<string>;
+    /**
+     * Ask for port number
+     */
+    port(defaultPort?: number, interactive?: boolean): Promise<number>;
+    /**
+     * Ask for feature selection
+     */
+    selectFeatures(availableFeatures?: string[], interactive?: boolean): Promise<string[]>;
+    /**
+     * Confirm action
+     */
+    confirm(message: string, defaultConfirm?: boolean, interactive?: boolean): Promise<boolean>;
+    /**
+     * Choose from list
+     */
+    chooseFrom(message: string, choices: string[], defaultChoice?: string, interactive?: boolean): Promise<string>;
+    /**
+     * Get text input
+     */
+    textInput(message: string, defaultValue?: string, interactive?: boolean): Promise<string>;
+}>;
+//# sourceMappingURL=PromptHelper.d.ts.map

package/src/cli/PromptHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromptHelper.d.ts","sourceRoot":"","sources":["../../../src/cli/PromptHelper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;sBACqB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMlE;;OAEG;8BAC6B,MAAM,gBAAe,OAAO,GAAU,OAAO,CAAC,MAAM,CAAC;IAuBrF;;OAEG;6BAEU,MAAM,gBACJ,OAAO,GACnB,OAAO,CAAC,MAAM,CAAC;IAuBlB;;OAEG;uBACqB,MAAM,gBAAsB,OAAO,GAAU,OAAO,CAAC,MAAM,CAAC;IAqBpF;;OAEG;uCAEkB,MAAM,EAAE,gBACd,OAAO,GACnB,OAAO,CAAC,MAAM,EAAE,CAAC;IAkBpB;;OAEG;qBAEQ,MAAM,mBACC,OAAO,gBACV,OAAO,GACnB,OAAO,CAAC,OAAO,CAAC;IAiBnB;;OAEG;wBAEQ,MAAM,WACN,MAAM,EAAE,kBACF,MAAM,gBACR,OAAO,GACnB,OAAO,CAAC,MAAM,CAAC;IAkBlB;;OAEG;uBAEQ,MAAM,iBACD,MAAM,gBACP,OAAO,GACnB,OAAO,CAAC,MAAM,CAAC;EAgBlB,CAAC"}