@zintrust/core 0.1.0

package/src/cache/drivers/MongoDriver.js

@@ -0,0 +1,80 @@
+/**
+ * MongoDB Cache Driver
+ * Uses MongoDB Atlas Data API (HTTPS) for zero-dependency integration
+ */
+import { Env } from '../../config/env';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+/**
+ * MongoDB Cache Driver
+ * Uses MongoDB Atlas Data API (HTTPS) for zero-dependency integration
+ * Sealed namespace for immutability
+ */
+export const MongoDriver = Object.freeze({
+    /**
+     * Create a new MongoDB driver instance
+     */
+    create() {
+        const uri = Env.MONGO_URI;
+        const db = Env.MONGO_DB;
+        const collection = 'cache';
+        const request = async (action, body) => {
+            if (uri === '') {
+                Logger.warn('MONGO_URI not configured. MongoDB Cache request ignored.');
+                return null;
+            }
+            try {
+                const response = await fetch(`${uri}/action/${action}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Access-Control-Request-Headers': '*',
+                    },
+                    body: JSON.stringify({
+                        dataSource: 'Cluster0',
+                        database: db,
+                        collection: collection,
+                        ...body,
+                    }),
+                });
+                return await response.json();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                ErrorFactory.createTryCatchError(`MongoDB Cache Error: ${message}`);
+                return null;
+            }
+        };
+        return {
+            async get(key) {
+                const result = (await request('findOne', { filter: { _id: key } }));
+                if (result?.document === undefined || result.document === null)
+                    return null;
+                const doc = result.document;
+                if (doc.expires !== null && doc.expires < Date.now()) {
+                    await this.delete(key);
+                    return null;
+                }
+                return doc.value;
+            },
+            async set(key, value, ttl) {
+                const expires = ttl === undefined ? null : Date.now() + ttl * 1000;
+                await request('updateOne', {
+                    filter: { _id: key },
+                    update: { $set: { value, expires } },
+                    upsert: true,
+                });
+            },
+            async delete(key) {
+                await request('deleteOne', { filter: { _id: key } });
+            },
+            async clear() {
+                await request('deleteMany', { filter: {} });
+            },
+            async has(key) {
+                const result = (await request('findOne', { filter: { _id: key } }));
+                return result?.document !== undefined && result.document !== null;
+            },
+        };
+    },
+});

package/src/cache/drivers/RedisDriver.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Redis Cache Driver
+ * Zero-dependency implementation using Node.js native net module
+ */
+import { CacheDriver } from '../CacheDriver';
+/**
+ * RedisDriver namespace - sealed for immutability
+ */
+export declare const RedisDriver: Readonly<{
+    create: () => CacheDriver;
+}>;
+//# sourceMappingURL=RedisDriver.d.ts.map

package/src/cache/drivers/RedisDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisDriver.d.ts","sourceRoot":"","sources":["../../../../src/cache/drivers/RedisDriver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA+EjD;;GAEG;AACH,eAAO,MAAM,WAAW;kBA1EL,WAAW;EA4E5B,CAAC"}

package/src/cache/drivers/RedisDriver.js

@@ -0,0 +1,79 @@
+/**
+ * Redis Cache Driver
+ * Zero-dependency implementation using Node.js native net module
+ */
+import { Env } from '../../config/env';
+import { Logger } from '../../config/logger';
+import * as net from 'node:net';
+/**
+ * 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 response = await sendCommand(`GET ${key}\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 jsonValue = JSON.stringify(value);
+            let command = `SET ${key} ${jsonValue}\r\n`;
+            if (ttl !== undefined) {
+                command = `SETEX ${key} ${ttl} ${jsonValue}\r\n`;
+            }
+            await sendCommand(command);
+        },
+        async delete(key) {
+            await sendCommand(`DEL ${key}\r\n`);
+        },
+        async clear() {
+            await sendCommand(`FLUSHDB\r\n`);
+        },
+        async has(key) {
+            const response = await sendCommand(`EXISTS ${key}\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,39 @@
+/**
+ * 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(config: {
+        name: string;
+        description: string;
+        addOptions?: (command: Command) => void;
+        execute: (options: CommandOptions) => void | Promise<void>;
+    }): IBaseCommand;
+}>;
+//# 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;mBACY;QACb,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,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,YAAY;EA+ChB,CAAC"}

package/src/cli/BaseCommand.js

@@ -0,0 +1,58 @@
+/**
+ * Base Command - Abstract Command Class
+ * All CLI commands extend this class
+ */
+import { ErrorHandler } from './ErrorHandler';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+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('-v, --verbose', 'Enable verbose output');
+            // 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;
+        };
+        return {
+            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),
+        };
+    },
+});

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;AAqBH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,MAAM,WAAW,IAAI;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,IAAI,OAAO,CAAC;CACvB;AAkLD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}

package/src/cli/CLI.js

@@ -0,0 +1,203 @@
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ */
+import { AddCommand } from './commands/AddCommand';
+import { ConfigCommand } from './commands/ConfigCommand';
+import { D1MigrateCommand } from './commands/D1MigrateCommand';
+import { DebugCommand } from './commands/DebugCommand';
+import { FixCommand } from './commands/FixCommand';
+import { KeyGenerateCommand } from './commands/KeyGenerateCommand';
+import { MigrateCommand } from './commands/MigrateCommand';
+import { NewCommand } from './commands/NewCommand';
+import { PluginCommand } from './commands/PluginCommand';
+import { PrepareCommand } from './commands/PrepareCommand';
+import { QACommand } from './commands/QACommand';
+import { SimulateCommand } from './commands/SimulateCommand';
+import { StartCommand } from './commands/StartCommand';
+import { ErrorHandler } from './ErrorHandler';
+import { Logger } from '../config/logger';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+import { readFileSync } from '../node-singletons/fs';
+import { dirname, join } from '../node-singletons/path';
+import { fileURLToPath } from '../node-singletons/url';
+import { Command } from 'commander';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ */
+/**
+ * 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(),
+        PrepareCommand,
+        AddCommand.create(),
+        StartCommand.create(),
+        MigrateCommand.create(),
+        D1MigrateCommand.create(),
+        DebugCommand.create(),
+        ConfigCommand.create(),
+        PluginCommand.create(),
+        QACommand(),
+        FixCommand.create(),
+        KeyGenerateCommand.create(),
+        SimulateCommand,
+    ];
+    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;
+    }
+    if (error instanceof Error) {
+        ErrorHandler.handle(error, undefined, log);
+    }
+    throw ErrorFactory.createCliError('Unhandled CLI execution error', error);
+};
+/**
+ * Run CLI with arguments
+ */
+const runCLI = async (program, version, args) => {
+    try {
+        // Always show banner
+        ErrorHandler.banner(version);
+        // If version is requested, we've already shown the banner which includes the version.
+        if (args.includes('-v') || args.includes('--version')) {
+            return;
+        }
+        // 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) {
+        // Check for commander-specific errors that need special handling
+        if (error instanceof Error &&
+            'code' in error &&
+            typeof error.code === 'string' &&
+            error.code.startsWith('commander.')) {
+            const exitCode = getExitCode(error);
+            if (exitCode !== 0) {
+                ErrorFactory.createCliError('CLI execution failed', error);
+                process.exit(exitCode);
+            }
+            return;
+        }
+        // Handle all other errors with proper logging
+        ErrorFactory.createCliError('CLI execution failed', error);
+        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;AAuGX;;GAEG;AACH,eAAO,MAAM,YAAY;oBAnGhB,KAAK,GAAG,MAAM,aACX,MAAM,QACX,OAAO,KACX,IAAI;0BAasB,MAAM,YAAY,MAAM,KAAG,IAAI;oBAa9B,MAAM,KAAG,IAAI;uBA4CV,MAAM,KAAG,IAAI;oBAQb,MAAM,KAAG,IAAI;qBAQf,MAAM,YAAW,OAAO,KAAW,IAAI;sBApDtC,MAAM,KAAG,IAAI;EAsE3C,CAAC"}

package/src/cli/ErrorHandler.js

@@ -0,0 +1,95 @@
+/**
+ * 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';
+import { Logger } from '../config/logger';
+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;
+    const formattedMessage = `${chalk.red('[ERROR]')} ${message}`;
+    if (log) {
+        Logger.error(formattedMessage);
+    }
+    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)}` : '';
+    const formattedMessage = `${chalk.red('[ERROR]')} ${message}${hint}`;
+    Logger.warn(formattedMessage);
+    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';
+    console.log(chalk.cyan('┌' + '─'.repeat(bannerWidth) + '┐'));
+    console.log(`${chalk.cyan('│')} ${chalk.bold.white('Framework: ')}${chalk.bold.cyan(framework.padEnd(bannerWidth - 12))} ${chalk.cyan('│')}`);
+    console.log(`${chalk.cyan('│')} ${chalk.bold.white('Version:   ')}${chalk.bold.green(version.padEnd(bannerWidth - 12))} ${chalk.cyan('│')}`);
+    console.log(`${chalk.cyan('│')} ${chalk.bold.white('Env:       ')}${chalk.bold.yellow(env.padEnd(bannerWidth - 12))} ${chalk.cyan('│')}`);
+    console.log(`${chalk.cyan('│')} ${chalk.bold.white('Database:  ')}${chalk.bold.magenta(db.padEnd(bannerWidth - 12))} ${chalk.cyan('│')}`);
+    console.log(chalk.cyan('└' + '─'.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;IAsBlB;;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"}