@zintrust/core 0.1.0

package/src/cli/commands/LogsCommand.js

@@ -0,0 +1,185 @@
+/**
+ * LogsCommand - CLI command for viewing and managing logs
+ * Commands: zin logs, zin logs --follow, zin logs --level error, zin logs --clear
+ */
+import { BaseCommand } from '../BaseCommand';
+import { Logger as FileLogger } from '../logger/Logger';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import fs from '../../node-singletons/fs';
+import chalk from 'chalk';
+import * as path from 'node:path';
+const normalizeLogsOptions = (options) => {
+    const level = typeof options['level'] === 'string' ? options['level'] : 'info';
+    const clear = options['clear'] === true;
+    const follow = options['follow'] === true;
+    const linesRaw = typeof options['lines'] === 'string' ? options['lines'] : '50';
+    const linesParsed = Number.parseInt(linesRaw, 10);
+    const lines = Number.isFinite(linesParsed) ? linesParsed : 50;
+    const category = typeof options['category'] === 'string' ? options['category'] : 'app';
+    return { level, clear, follow, lines, category };
+};
+const getLevelColor = (level) => {
+    switch (level.toLowerCase()) {
+        case 'debug':
+            return chalk.gray;
+        case 'info':
+            return chalk.blue;
+        case 'warn':
+            return chalk.yellow;
+        case 'error':
+            return chalk.red;
+        default:
+            return chalk.white;
+    }
+};
+const printLogEntry = (log) => {
+    const timestamp = chalk.gray(log.timestamp);
+    const levelColor = getLevelColor(log.level);
+    const level = levelColor(`[${log.level.toUpperCase()}]`);
+    let output = `${timestamp} ${level} ${log.message}`;
+    if (log.data !== undefined && Object.keys(log.data).length > 0) {
+        output += ` ${chalk.cyan(JSON.stringify(log.data))}`;
+    }
+    Logger.info(output);
+};
+const parseLogEntry = (loggerInstance, line) => {
+    const maybe = loggerInstance;
+    if (typeof maybe.parseLogEntry !== 'function') {
+        throw ErrorFactory.createGeneralError('LoggerInstance does not support parseLogEntry');
+    }
+    return maybe.parseLogEntry(line);
+};
+const processLogChunk = (chunk, loggerInstance) => {
+    const chunkStr = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+    const lines = chunkStr.split('\n').filter((line) => line.trim() !== '');
+    for (const line of lines) {
+        try {
+            const entry = parseLogEntry(loggerInstance, line);
+            printLogEntry(entry);
+        }
+        catch (error) {
+            ErrorFactory.createTryCatchError('Failed to process log line', error);
+        }
+    }
+};
+const displayLogs = (loggerInstance, level, lines, category) => {
+    const logs = loggerInstance.getLogs(category, lines);
+    if (logs.length === 0) {
+        Logger.info(chalk.yellow('ℹ  No logs found'));
+        return;
+    }
+    let filtered = logs;
+    if (level !== '' && level !== 'all') {
+        filtered = loggerInstance.filterByLevel(logs, level);
+    }
+    if (filtered.length === 0) {
+        Logger.info(chalk.yellow(`ℹ  No logs found with level: ${level}`));
+        return;
+    }
+    Logger.info(chalk.blue(`📋 Last ${filtered.length} log entries (${category}):\n`));
+    for (const log of [...filtered].reverse()) {
+        printLogEntry(log);
+    }
+};
+const followLogs = (category) => {
+    const loggerInstance = FileLogger.getInstance();
+    const logsDir = loggerInstance.getLogsDirectory();
+    const categoryDir = path.join(logsDir, category);
+    if (!fs.existsSync(categoryDir)) {
+        Logger.info(chalk.red(`✗ Log category directory not found: ${categoryDir}`));
+        return;
+    }
+    const today = new Date().toISOString().split('T')[0];
+    const logFile = path.join(categoryDir, `${today}.log`);
+    Logger.info(chalk.blue(`👀 Following logs: ${logFile}\n`));
+    Logger.info(chalk.gray('Press Ctrl+C to stop...\n'));
+    let lastSize = 0;
+    const interval = setInterval(() => {
+        if (!fs.existsSync(logFile))
+            return;
+        const stats = fs.statSync(logFile);
+        if (stats.size <= lastSize)
+            return;
+        const stream = fs.createReadStream(logFile, {
+            start: lastSize,
+            encoding: 'utf-8',
+        });
+        stream.on('data', (chunk) => {
+            processLogChunk(chunk, loggerInstance);
+        });
+        lastSize = stats.size;
+    }, 1000);
+    process.on('SIGINT', () => {
+        clearInterval(interval);
+        Logger.info(chalk.yellow('\n\nLog following stopped'));
+        process.exit(0);
+    });
+};
+const clearLogs = (loggerInstance, category) => {
+    const confirmed = true;
+    if (!confirmed) {
+        Logger.info(chalk.yellow('Clearing logs cancelled'));
+        return;
+    }
+    const success = loggerInstance.clearLogs(category);
+    if (success === true) {
+        Logger.info(chalk.green(`✓ Cleared logs for category: ${category}`));
+    }
+    else {
+        Logger.info(chalk.red(`✗ Failed to clear logs for category: ${category}`));
+    }
+};
+const executeLogs = (options) => {
+    const normalized = normalizeLogsOptions(options);
+    const loggerInstance = FileLogger.getInstance();
+    if (normalized.clear) {
+        clearLogs(loggerInstance, normalized.category);
+        return;
+    }
+    if (normalized.follow) {
+        followLogs(normalized.category);
+        return;
+    }
+    displayLogs(loggerInstance, normalized.level, normalized.lines, normalized.category);
+};
+export const LogsCommand = Object.freeze({
+    /**
+     * Create a new logs command instance
+     */
+    create() {
+        const addOptions = (command) => {
+            command
+                .option('-l, --level <level>', 'Filter by log level (debug, info, warn, error)', 'info')
+                .option('-c, --clear', 'Clear all logs')
+                .option('-f, --follow', 'Follow logs in real-time (like tail -f)')
+                .option('-n, --lines <number>', 'Number of lines to show', '50')
+                .option('--category <category>', 'Log category (app, cli, errors, migrations, debug)', 'app');
+        };
+        const cmd = BaseCommand.create({
+            name: 'logs',
+            description: 'View and manage application logs',
+            addOptions,
+            execute: (options) => executeLogs(options),
+        });
+        return cmd;
+    },
+    /**
+     * Register the command with Commander
+     * @deprecated Use create() instead
+     */
+    register(program) {
+        const cmd = program.command('logs');
+        cmd.description('View and manage application logs');
+        cmd
+            .option('-l, --level <level>', 'Filter by log level (debug, info, warn, error)', 'info')
+            .option('-c, --clear', 'Clear all logs')
+            .option('-f, --follow', 'Follow logs in real-time (like tail -f)')
+            .option('-n, --lines <number>', 'Number of lines to show', '50')
+            .option('--category <category>', 'Log category (app, cli, errors, migrations, debug)', 'app');
+        cmd.action((options) => {
+            executeLogs(options);
+        });
+    },
+});
+export default LogsCommand;

package/src/cli/commands/MigrateCommand.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Migrate Command
+ * Run database migrations
+ */
+import { IBaseCommand } from '../BaseCommand';
+/**
+ * Migrate Command Factory
+ */
+export declare const MigrateCommand: Readonly<{
+    /**
+     * Create a new migrate command instance
+     */
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=MigrateCommand.d.ts.map

package/src/cli/commands/MigrateCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/MigrateCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAI7E;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB;;OAEG;cACO,YAAY;EA8CtB,CAAC"}

package/src/cli/commands/MigrateCommand.js

@@ -0,0 +1,56 @@
+/**
+ * Migrate Command
+ * Run database migrations
+ */
+import { BaseCommand } from '../BaseCommand';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+/**
+ * Migrate Command Factory
+ */
+export const MigrateCommand = Object.freeze({
+    /**
+     * Create a new migrate command instance
+     */
+    create() {
+        const addOptions = (command) => {
+            command
+                .option('--fresh', 'Drop all tables and re-run migrations')
+                .option('--rollback', 'Rollback last migration batch')
+                .option('--reset', 'Rollback all migrations')
+                .option('--step <number>', 'Number of batches to rollback', '0');
+        };
+        const execute = async (options, cmd) => {
+            cmd.debug(`Migrate command executed with options: ${JSON.stringify(options)}`);
+            try {
+                cmd.info('Loading configuration...');
+                // Configuration loading would go here
+                if (options['fresh'] === true) {
+                    cmd.warn('This will drop all tables and re-run migrations');
+                    // Confirmation would go here
+                    cmd.success('Fresh migration completed');
+                }
+                else if (options['rollback'] === true) {
+                    cmd.success('Migrations rolled back');
+                }
+                else if (options['reset'] === true) {
+                    cmd.warn('Resetting all migrations');
+                    cmd.success('All migrations reset');
+                }
+                else {
+                    cmd.info('Running pending migrations...');
+                    cmd.success('Migrations completed successfully');
+                }
+            }
+            catch (error) {
+                throw ErrorFactory.createTryCatchError(`Migration failed: ${error.message}`, error);
+            }
+        };
+        const cmd = BaseCommand.create({
+            name: 'migrate',
+            description: 'Run database migrations',
+            addOptions,
+            execute: async (options) => execute(options, cmd),
+        });
+        return cmd;
+    },
+});

package/src/cli/commands/NewCommand.d.ts

@@ -0,0 +1,32 @@
+import { CommandOptions, IBaseCommand } from '../BaseCommand';
+type TemplateType = 'basic' | 'api' | 'microservice';
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql' | 'mongodb';
+interface NewProjectConfigResult {
+    template: TemplateType;
+    database: DatabaseType;
+    port: number;
+    author: string;
+    description: string;
+}
+type InquirerQuestion = Record<string, unknown>;
+interface INewCommand extends IBaseCommand {
+    promptForConfig(name: string, options: CommandOptions): Promise<NewProjectConfigResult>;
+    getProjectConfig(name: string, options: CommandOptions): Promise<NewProjectConfigResult>;
+    getQuestions(name: string, defaults: NewProjectConfigResult): InquirerQuestion[];
+    getSafeEnv(): NodeJS.ProcessEnv;
+    getGitBinary(): string;
+    runScaffolding(name: string, config: NewProjectConfigResult, overwrite?: boolean): Promise<unknown>;
+    initializeGit(name: string): void;
+}
+/**
+ * New Command Factory
+ * Sealed namespace for immutability
+ */
+export declare const NewCommand: Readonly<{
+    /**
+     * Create a new project command instance
+     */
+    create(): INewCommand;
+}>;
+export {};
+//# sourceMappingURL=NewCommand.d.ts.map

package/src/cli/commands/NewCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NewCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/NewCommand.ts"],"names":[],"mappings":"AAOA,OAAO,EAAe,cAAc,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAS7E,KAAK,YAAY,GAAG,OAAO,GAAG,KAAK,GAAG,cAAc,CAAC;AACrD,KAAK,YAAY,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,CAAC;AAYlE,UAAU,sBAAsB;IAC9B,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAwLhD,UAAU,WAAY,SAAQ,YAAY;IACxC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxF,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACzF,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,EAAE,CAAC;IACjF,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC;IAChC,YAAY,IAAI,MAAM,CAAC;IACvB,cAAc,CACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,sBAAsB,EAC9B,SAAS,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAsHD;;;GAGG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;cACO,WAAW;EAGrB,CAAC"}

package/src/cli/commands/NewCommand.js

@@ -0,0 +1,280 @@
+import { appConfig } from '../../config/app';
+/**
+ * New Command - Project scaffolding CLI command
+ * Handles creation of new Zintrust projects
+ */
+import { resolveNpmPath } from '../../common';
+import { BaseCommand } from '../BaseCommand';
+import { PromptHelper } from '../PromptHelper';
+import { ProjectScaffolder } from '../scaffolding/ProjectScaffolder';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { execFileSync } from '../../node-singletons/child-process';
+import * as path from '../../node-singletons/path';
+import chalk from 'chalk';
+const errorToMessage = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    return 'Unknown error';
+};
+const getGitBinary = () => 'git';
+const checkGitInstalled = () => {
+    try {
+        execFileSync(getGitBinary(), ['--version'], { stdio: 'ignore', env: appConfig.getSafeEnv() });
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Git check failed', error);
+        return false;
+    }
+};
+const initializeGitRepo = (projectPath, log) => {
+    try {
+        const git = getGitBinary();
+        const env = appConfig.getSafeEnv();
+        execFileSync(git, ['init'], { cwd: projectPath, stdio: 'ignore', env });
+        execFileSync(git, ['add', '.'], { cwd: projectPath, stdio: 'ignore', env });
+        execFileSync(git, ['commit', '-m', 'Initial commit from Zintrust'], {
+            cwd: projectPath,
+            stdio: 'ignore',
+            env,
+        });
+        log.info('✅ Git repository initialized');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Git initialization failed', error);
+        log.warn('Could not initialize git repository');
+    }
+};
+const getStringOption = (options, key, fallback) => {
+    const value = options[key];
+    return typeof value === 'string' && value !== '' ? value : fallback;
+};
+const getBooleanOption = (options, key, fallback) => {
+    const value = options[key];
+    return typeof value === 'boolean' ? value : fallback;
+};
+const getProjectDefaults = (name, options) => {
+    const template = getStringOption(options, 'template', 'basic');
+    const database = getStringOption(options, 'database', 'sqlite');
+    const portRaw = getStringOption(options, 'port', '3003');
+    const portParsed = Number.parseInt(portRaw, 10);
+    const port = Number.isFinite(portParsed) && portParsed > 0 ? portParsed : 3000;
+    const author = getStringOption(options, 'author', '');
+    const description = getStringOption(options, 'description', `A new Zintrust project: ${name}`);
+    const interactive = getBooleanOption(options, 'interactive', true);
+    return { name, template, database, port, author, description, interactive };
+};
+const toConfigResult = (config) => ({
+    template: config.template,
+    database: config.database,
+    port: config.port,
+    author: config.author,
+    description: config.description,
+});
+const getQuestions = (name, defaults) => {
+    return [
+        {
+            type: 'list',
+            name: 'template',
+            message: 'Project template:',
+            choices: ['basic', 'api', 'microservice'],
+            default: defaults.template,
+        },
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Database driver:',
+            choices: ['sqlite', 'mysql', 'postgresql', 'mongodb'],
+            default: defaults.database,
+        },
+        {
+            type: 'input',
+            name: 'port',
+            message: 'Default port number:',
+            default: String(defaults.port),
+            validate: (value) => {
+                const port = Number.parseInt(value, 10);
+                return Number.isFinite(port) && port > 0 && port < 65536;
+            },
+        },
+        {
+            type: 'input',
+            name: 'author',
+            message: 'Project author:',
+            default: defaults.author,
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Project description:',
+            default: defaults.description === '' ? `A new Zintrust project: ${name}` : defaults.description,
+        },
+    ];
+};
+const mergePromptAnswers = (defaults, answers) => {
+    const template = typeof answers['template'] === 'string'
+        ? answers['template']
+        : defaults.template;
+    const database = typeof answers['database'] === 'string'
+        ? answers['database']
+        : defaults.database;
+    let port = defaults.port;
+    const portAnswer = answers['port'];
+    if (typeof portAnswer === 'string') {
+        const parsed = Number.parseInt(portAnswer, 10);
+        if (Number.isFinite(parsed))
+            port = parsed;
+    }
+    else if (typeof portAnswer === 'number') {
+        if (Number.isFinite(portAnswer))
+            port = portAnswer;
+    }
+    const author = typeof answers['author'] === 'string' ? answers['author'] : defaults.author;
+    const description = typeof answers['description'] === 'string' ? answers['description'] : defaults.description;
+    return {
+        ...defaults,
+        template,
+        database,
+        port,
+        author,
+        description,
+    };
+};
+const promptForConfig = async (name, options) => {
+    const defaults = getProjectDefaults(name, options);
+    if (defaults.interactive === false)
+        return defaults;
+    const questions = getQuestions(name, defaults);
+    const answers = await PromptHelper.prompt(questions);
+    return mergePromptAnswers(defaults, answers);
+};
+const isFailureResult = (result) => {
+    if (typeof result !== 'object' || result === null)
+        return false;
+    const maybe = result;
+    return maybe.success === false;
+};
+const installDependencies = (projectPath, log) => {
+    log.info('📦 Installing dependencies (this may take a minute)...');
+    try {
+        const npmPath = resolveNpmPath();
+        execFileSync(npmPath, ['install'], {
+            cwd: projectPath,
+            stdio: 'inherit',
+            env: appConfig.getSafeEnv(),
+        });
+        log.info('✅ Dependencies installed successfully');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Dependency installation failed', error);
+        log.warn('Please run "npm install" manually in the project directory');
+    }
+};
+const addOptions = (command) => {
+    command.argument('<name>', 'Project name');
+    command.option('--template <type>', 'Project template (basic, api, microservice)', 'basic');
+    command.option('--database <type>', 'Database driver (sqlite, mysql, postgresql)', 'sqlite');
+    command.option('--port <number>', 'Default port number', '3003');
+    command.option('--author <name>', 'Project author');
+    command.option('--description <text>', 'Project description');
+    command.option('--interactive', 'Run in interactive mode', true);
+    command.option('--no-interactive', 'Disable interactive mode');
+    command.option('--no-git', 'Skip git initialization');
+    command.option('--no-install', 'Skip dependency installation');
+    command.option('--force', 'Overwrite existing directory');
+    command.option('--overwrite', 'Overwrite existing directory');
+};
+const executeNewCommand = async (options, command) => {
+    try {
+        const argName = options.args?.[0];
+        const projectName = argName ?? (await PromptHelper.projectName('my-zintrust-app', true));
+        if (!projectName)
+            throw ErrorFactory.createCliError('Project name is required');
+        const config = await command.getProjectConfig(projectName, options);
+        command.info(chalk.bold(`\n🚀 Creating new Zintrust project in ${projectName}...\n`));
+        const overwrite = options['overwrite'] === true || options['force'] === true ? true : undefined;
+        const result = await command.runScaffolding(projectName, config, overwrite);
+        if (isFailureResult(result)) {
+            throw ErrorFactory.createCliError(result.message ?? 'Project scaffolding failed', result);
+        }
+        if (options['git'] !== false) {
+            command.initializeGit(projectName);
+        }
+        if (options['install'] !== false) {
+            const projectPath = path.resolve(process.cwd(), projectName);
+            installDependencies(projectPath, command);
+        }
+        command.success(`\n✨ Project ${projectName} created successfully!`);
+        command.info(`\nNext steps:\n  cd ${projectName}\n  npm run dev\n`);
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Project creation failed: ${errorToMessage(error)}`, error);
+    }
+};
+const createNewCommandInstance = () => {
+    const base = BaseCommand.create({
+        name: 'new',
+        description: 'Create a new Zintrust project',
+        addOptions,
+        execute: async (_options) => {
+            // replaced below with NewCommand-aware execute implementation
+        },
+    });
+    const commandInstance = {
+        ...base,
+        promptForConfig: async (name, options) => {
+            const config = await promptForConfig(name, options);
+            return toConfigResult(config);
+        },
+        getSafeEnv: () => appConfig.getSafeEnv(),
+        getGitBinary: () => getGitBinary(),
+        getQuestions: (name, defaults) => {
+            const fullDefaults = {
+                name,
+                template: defaults.template,
+                database: defaults.database,
+                port: defaults.port,
+                author: defaults.author,
+                description: defaults.description,
+                interactive: true,
+            };
+            return getQuestions(name, fullDefaults);
+        },
+        getProjectConfig: async (name, options) => {
+            return commandInstance.promptForConfig(name, options);
+        },
+        runScaffolding: async (name, config, overwrite) => {
+            return ProjectScaffolder.scaffold(process.cwd(), {
+                name,
+                force: overwrite === true,
+                template: config.template,
+                database: config.database,
+                port: config.port,
+                author: config.author,
+                description: config.description,
+            });
+        },
+        initializeGit: (name) => {
+            const projectPath = path.resolve(process.cwd(), name);
+            if (checkGitInstalled()) {
+                initializeGitRepo(projectPath, commandInstance);
+            }
+        },
+        execute: async (options) => {
+            await executeNewCommand(options, commandInstance);
+        },
+    };
+    return commandInstance;
+};
+/**
+ * New Command Factory
+ * Sealed namespace for immutability
+ */
+export const NewCommand = Object.freeze({
+    /**
+     * Create a new project command instance
+     */
+    create() {
+        return createNewCommandInstance();
+    },
+});

package/src/cli/commands/PluginCommand.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Plugin Command
+ * Manage framework plugins (install, uninstall, list)
+ */
+import { IBaseCommand } from '../BaseCommand';
+export declare const PluginCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=PluginCommand.d.ts.map

package/src/cli/commands/PluginCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PluginCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAK7E,eAAO,MAAM,aAAa;cACd,YAAY;EAsDtB,CAAC"}