neex 0.6.46 → 0.6.50

package/dist/src/build-manager.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuildManager = void 0;
-// src/build-manager.ts - Build manager for TypeScript projects using tsx
+// src/build-manager.ts - Build manager for TypeScript projects using tsc
 const child_process_1 = require("child_process");
 const chokidar_1 = require("chokidar");
 const logger_manager_js_1 = require("./logger-manager.js");
@@ -19,7 +19,7 @@ class BuildManager {
         this.buildProcess = null;
         this.isBuilding = false;
         this.buildCount = 0;
-        this.debouncedBuild = this.debounce(this.runBuild.bind(this), 500);
+        this.debouncedBuild = this.debounce(this.runBuild.bind(this), 300);
         this.options = options;
     }
     async cleanOutputDirectory() {
@@ -78,49 +78,28 @@ class BuildManager {
             }
         }
     }
-    getBuildCommand() {
-        if (this.options.bundle) {
-            // Use tsx for bundling
-            const args = [
-                'build',
-                this.options.source,
-                '--out-dir',
-                this.options.output,
-                '--target',
-                this.options.target
-            ];
-            if (this.options.minify) {
-                args.push('--minify');
-            }
-            if (this.options.sourcemap) {
-                args.push('--sourcemap');
-            }
-            if (this.options.format === 'esm') {
-                args.push('--format', 'esm');
-            }
-            if (this.options.external.length > 0) {
-                args.push('--external', this.options.external.join(','));
-            }
-            return { command: 'tsx', args };
+    getTscCommand() {
+        const args = [
+            '--project',
+            this.options.tsconfig,
+            '--outDir',
+            this.options.output,
+            '--target',
+            this.options.target,
+            '--declaration'
+        ];
+        if (this.options.sourcemap) {
+            args.push('--sourceMap');
+        }
+        if (this.options.format === 'esm') {
+            args.push('--module', 'es2020', '--moduleResolution', 'node');
         }
         else {
-            // Use TypeScript compiler directly
-            const args = [
-                '--project',
-                this.options.tsconfig,
-                '--outDir',
-                this.options.output,
-                '--target',
-                this.options.target
-            ];
-            if (this.options.sourcemap) {
-                args.push('--sourceMap');
-            }
-            if (this.options.format === 'esm') {
-                args.push('--module', 'es2020');
-            }
-            return { command: 'tsc', args };
+            args.push('--module', 'commonjs');
         }
+        // Always include these for better compatibility
+        args.push('--esModuleInterop', '--allowSyntheticDefaultImports', '--strict');
+        return { command: 'tsc', args };
     }
     async runBuild() {
         if (this.isBuilding) {
@@ -135,31 +114,28 @@ class BuildManager {
         }
         try {
             await this.ensureOutputDirectory();
-            const { command, args } = this.getBuildCommand();
+            const { command, args } = this.getTscCommand();
             if (this.options.verbose) {
                 logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
             }
             return new Promise((resolve, reject) => {
                 var _a, _b;
                 this.buildProcess = (0, child_process_1.spawn)(command, args, {
-                    stdio: this.options.verbose ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'ignore', 'pipe'],
+                    stdio: ['ignore', 'pipe', 'pipe'],
                     shell: false,
                     env: {
                         ...process.env,
-                        FORCE_COLOR: this.options.color ? '1' : '0'
+                        FORCE_COLOR: '0' // Disable TSC colors to avoid log pollution
                     }
                 });
+                let stdout = '';
                 let stderr = '';
-                if (this.options.verbose) {
-                    (_a = this.buildProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                        process.stdout.write(data);
-                    });
-                }
+                // Capture all output but don't display TSC logs
+                (_a = this.buildProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                    stdout += data.toString();
+                });
                 (_b = this.buildProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
                     stderr += data.toString();
-                    if (this.options.verbose) {
-                        process.stderr.write(data);
-                    }
                 });
                 this.buildProcess.on('error', (error) => {
                     this.buildProcess = null;
@@ -182,11 +158,15 @@ class BuildManager {
                         resolve();
                     }
                     else {
-                        const error = new Error(`Build failed with code ${code}`);
-                        if (stderr) {
-                            logger_manager_js_1.loggerManager.printLine(`Build errors:\n${stderr}`, 'error');
+                        // Only show meaningful errors, filter out TSC verbosity
+                        const meaningfulErrors = this.filterTscErrors(stderr);
+                        if (meaningfulErrors) {
+                            logger_manager_js_1.loggerManager.printLine(`Build failed:\n${meaningfulErrors}`, 'error');
                         }
-                        reject(error);
+                        else {
+                            logger_manager_js_1.loggerManager.printLine(`Build failed with code ${code}`, 'error');
+                        }
+                        reject(new Error(`Build failed with code ${code}`));
                     }
                 });
             });
@@ -196,14 +176,28 @@ class BuildManager {
             throw error;
         }
     }
+    filterTscErrors(stderr) {
+        if (!stderr)
+            return '';
+        const lines = stderr.split('\n');
+        const meaningfulLines = lines.filter(line => {
+            const trimmed = line.trim();
+            // Filter out TSC verbose output, keep only actual errors
+            return trimmed &&
+                !trimmed.includes('message TS') &&
+                !trimmed.includes('Found 0 errors') &&
+                !trimmed.match(/^\s*\d+\s*$/) && // Filter line numbers
+                !trimmed.includes('Watching for file changes');
+        });
+        return meaningfulLines.join('\n').trim();
+    }
     async analyzeBuild() {
         try {
-            const stats = await promises_1.default.stat(this.options.output);
             const files = await promises_1.default.readdir(this.options.output, { withFileTypes: true });
             let totalSize = 0;
             const fileStats = [];
             for (const file of files) {
-                if (file.isFile()) {
+                if (file.isFile() && (file.name.endsWith('.js') || file.name.endsWith('.d.ts'))) {
                     const filePath = path_1.default.join(this.options.output, file.name);
                     const stat = await promises_1.default.stat(filePath);
                     totalSize += stat.size;
@@ -211,11 +205,13 @@ class BuildManager {
                 }
             }
             fileStats.sort((a, b) => b.size - a.size);
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Bundle Analysis:`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Build Analysis:`, 'info');
             logger_manager_js_1.loggerManager.printLine(`Total size: ${chalk_1.default.cyan(this.formatBytes(totalSize))}`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`Files: ${files.length}`, 'info');
-            if (this.options.verbose) {
-                fileStats.slice(0, 10).forEach(file => {
+            logger_manager_js_1.loggerManager.printLine(`Generated files: ${fileStats.length}`, 'info');
+            if (this.options.verbose && fileStats.length > 0) {
+                const topFiles = fileStats.slice(0, 5);
+                logger_manager_js_1.loggerManager.printLine('Largest files:', 'info');
+                topFiles.forEach(file => {
                     logger_manager_js_1.loggerManager.printLine(`  ${file.name}: ${this.formatBytes(file.size)}`, 'info');
                 });
             }
@@ -237,7 +233,7 @@ class BuildManager {
             this.buildProcess = null;
             const cleanup = () => {
                 if (!this.options.quiet) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Stopped build process`, 'info');
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Build process stopped`, 'info');
                 }
                 resolve();
             };
@@ -257,7 +253,7 @@ class BuildManager {
                                 // Ignore
                             }
                         }
-                    }, 5000);
+                    }, 3000);
                 }
             }
             catch (error) {
@@ -286,12 +282,13 @@ class BuildManager {
             ignoreInitial: true,
             followSymlinks: false,
             usePolling: false,
-            atomic: 300,
+            atomic: 200,
             ignored: [
                 '**/node_modules/**',
                 '**/.git/**',
                 `**/${this.options.output}/**`,
-                '**/*.log'
+                '**/*.log',
+                '**/*.map'
             ]
         });
         this.watcher.on('change', (filePath) => {
@@ -342,7 +339,7 @@ class BuildManager {
             if (this.options.watch) {
                 this.setupWatcher();
                 if (!this.options.quiet) {
-                    logger_manager_js_1.loggerManager.printLine('Watching for file changes...', 'info');
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Watching for changes...`, 'info');
                 }
             }
         }
@@ -354,13 +351,15 @@ class BuildManager {
         }
     }
     async stop() {
-        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping build process...`, 'info');
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping build process...`, 'info');
+        }
         if (this.watcher) {
             await this.watcher.close();
             this.watcher = null;
         }
         await this.stopProcess();
-        if (this.buildCount > 0) {
+        if (this.buildCount > 0 && !this.options.quiet) {
             logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Build process stopped after ${this.buildCount} build(s)`, 'info');
         }
     }

package/dist/src/commands/build-commands.js

@@ -7,6 +7,7 @@ exports.addBuildCommands = void 0;
 const build_manager_js_1 = require("../build-manager.js");
 const logger_manager_js_1 = require("../logger-manager.js");
 const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
 function addBuildCommands(program) {
     let buildManager = null;
     // Build command for TypeScript projects
@@ -15,13 +16,10 @@ function addBuildCommands(program) {
         .description('Build TypeScript project for production (default: src)')
         .option('-o, --output <dir>', 'Output directory', 'dist')
         .option('-w, --watch', 'Watch mode for continuous building')
-        .option('-c, --clean', 'Clean output directory before build')
-        .option('-m, --minify', 'Minify output')
+        .option('-c, --clean', 'Clean output directory before build', true)
         .option('-s, --sourcemap', 'Generate source maps')
         .option('-t, --target <target>', 'TypeScript target (es2020, es2022, etc.)', 'es2020')
         .option('-f, --format <format>', 'Output format (cjs, esm)', 'cjs')
-        .option('--no-bundle', 'Don\'t bundle, just compile')
-        .option('--external <packages>', 'External packages (comma-separated)')
         .option('--tsconfig <file>', 'TypeScript config file', 'tsconfig.json')
         .option('-v, --verbose', 'Verbose output')
         .option('-q, --quiet', 'Quiet output')
@@ -30,18 +28,20 @@ function addBuildCommands(program) {
         .action(async (source, options) => {
         try {
             const sourceDir = source || 'src';
-            logger_manager_js_1.loggerManager.printLine(`Building TypeScript project from ${chalk_1.default.cyan(sourceDir)}`, 'info');
+            if (!options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Building TypeScript project from ${chalk_1.default.cyan(sourceDir)}`, 'info');
+            }
             buildManager = new build_manager_js_1.BuildManager({
                 source: sourceDir,
                 output: options.output,
                 watch: options.watch,
                 clean: options.clean,
-                minify: options.minify,
+                minify: false,
                 sourcemap: options.sourcemap,
                 target: options.target,
                 format: options.format,
-                bundle: options.bundle,
-                external: options.external ? options.external.split(',').map((p) => p.trim()) : [],
+                bundle: false,
+                external: [],
                 tsconfig: options.tsconfig,
                 verbose: options.verbose,
                 quiet: options.quiet,
@@ -49,24 +49,94 @@ function addBuildCommands(program) {
                 analyze: options.analyze
             });
             await buildManager.build();
+            // If not in watch mode, show completion message
+            if (!options.watch && !options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Build completed successfully`, 'info');
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Build failed: ${error.message}`, 'error');
+            }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown build error occurred`, 'error');
+            }
+            process.exit(1);
+        }
+    });
+    // Add a quick build command without options
+    program
+        .command('compile [source]')
+        .alias('tsc')
+        .description('Quick TypeScript compilation (alias for build)')
+        .action(async (source) => {
+        try {
+            const sourceDir = source || 'src';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Compiling TypeScript...`, 'info');
+            buildManager = new build_manager_js_1.BuildManager({
+                source: sourceDir,
+                output: 'dist',
+                watch: false,
+                clean: true,
+                minify: false,
+                sourcemap: false,
+                target: 'es2020',
+                format: 'cjs',
+                bundle: false,
+                external: [],
+                tsconfig: 'tsconfig.json',
+                verbose: false,
+                quiet: false,
+                color: true,
+                analyze: false
+            });
+            await buildManager.build();
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Compilation completed`, 'info');
         }
         catch (error) {
             if (error instanceof Error) {
-                logger_manager_js_1.loggerManager.printLine(`Build error: ${error.message}`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Compilation failed: ${error.message}`, 'error');
             }
             else {
-                logger_manager_js_1.loggerManager.printLine('An unknown build error occurred', 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown compilation error occurred`, 'error');
             }
             process.exit(1);
         }
     });
     // Cleanup function
-    const cleanupBuild = () => {
+    const cleanupBuild = async () => {
+        if (buildManager) {
+            try {
+                await buildManager.stop();
+                buildManager = null;
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    };
+    // Handle process termination
+    const handleExit = (signal) => {
         if (buildManager) {
-            buildManager.stop();
-            buildManager = null;
+            logger_manager_js_1.loggerManager.printLine(`\n${chalk_1.default.yellow(figures_1.default.warning)} Received ${signal}, stopping build process...`, 'info');
+            cleanupBuild().then(() => {
+                process.exit(0);
+            }).catch(() => {
+                process.exit(1);
+            });
+        }
+        else {
+            process.exit(0);
         }
     };
+    // Register signal handlers
+    process.on('SIGINT', () => handleExit('SIGINT'));
+    process.on('SIGTERM', () => handleExit('SIGTERM'));
+    process.on('exit', () => {
+        if (buildManager) {
+            cleanupBuild();
+        }
+    });
     return { cleanupBuild };
 }
 exports.addBuildCommands = addBuildCommands;

package/dist/src/commands/start-commands.js

@@ -6,55 +6,250 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addStartCommands = void 0;
 const start_manager_js_1 = require("../start-manager.js");
 const logger_manager_js_1 = require("../logger-manager.js");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const os_1 = __importDefault(require("os"));
 function addStartCommands(program) {
-    let manager = null;
-    const startCommand = program
+    let startManager = null;
+    // Main start command
+    program
         .command('start [entry]')
-        .description('Start a production-ready application')
-        .option('-n, --name <name>', 'Application name')
-        .option('-w, --watch', 'Watch for file changes and restart the application', false)
-        .option('--quiet', 'Suppress all output', false)
-        .option('--color', 'Force color output', true)
-        .option('--verbose', 'Enable verbose logging', false)
-        .option('--node-args <args>', 'Arguments to pass to the node process', (value) => value.split(' '), [])
+        .description('Start the production server (default: dist/index.js)')
+        .option('-p, --port <port>', 'Port to run the server on', '3000')
+        .option('-h, --host <host>', 'Host to bind the server to', '0.0.0.0')
+        .option('-e, --env <env>', 'Environment mode', 'production')
+        .option('-w, --watch', 'Watch for file changes and restart')
+        .option('-c, --cluster', 'Enable cluster mode')
+        .option('--workers <count>', 'Number of worker processes (default: CPU count)', os_1.default.cpus().length.toString())
+        .option('-m, --memory <mb>', 'Memory limit in MB', '512')
+        .option('-t, --timeout <ms>', 'Startup timeout in milliseconds', '30000')
+        .option('--graceful-timeout <ms>', 'Graceful shutdown timeout in milliseconds', '5000')
+        .option('-v, --verbose', 'Verbose output')
+        .option('-q, --quiet', 'Quiet output')
+        .option('--no-color', 'Disable colored output')
+        .option('--log-level <level>', 'Log level (error, warn, info, debug)', 'info')
+        .option('--node-args <args>', 'Additional Node.js arguments (comma-separated)')
+        .option('--inspect', 'Enable Node.js inspector')
+        .option('--inspect-port <port>', 'Inspector port', '9229')
+        .option('--pid <file>', 'Write process ID to file')
+        .option('--restart', 'Auto-restart on failure', true)
+        .option('--restart-delay <ms>', 'Delay between restarts in milliseconds', '1000')
+        .option('--max-restarts <count>', 'Maximum restart attempts', '10')
         .action(async (entry, options) => {
-        let entryPoint = entry;
-        if (!entryPoint) {
-            const defaultPath = path_1.default.join(process.cwd(), 'dist', 'index.js');
-            if (fs_1.default.existsSync(defaultPath)) {
-                entryPoint = defaultPath;
+        try {
+            const entryFile = entry || 'dist/index.js';
+            if (!options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting production server...`, 'info');
+            }
+            const nodeArgs = options.nodeArgs ?
+                options.nodeArgs.split(',').map((arg) => arg.trim()) : [];
+            startManager = new start_manager_js_1.StartManager({
+                entry: entryFile,
+                port: parseInt(options.port),
+                host: options.host,
+                env: options.env,
+                watch: options.watch,
+                cluster: options.cluster,
+                workers: parseInt(options.workers),
+                memory: parseInt(options.memory),
+                timeout: parseInt(options.timeout),
+                gracefulTimeout: parseInt(options.gracefulTimeout),
+                verbose: options.verbose,
+                quiet: options.quiet,
+                color: options.color,
+                logLevel: options.logLevel,
+                nodeArgs,
+                inspect: options.inspect,
+                inspectPort: parseInt(options.inspectPort),
+                pid: options.pid,
+                restart: options.restart,
+                restartDelay: parseInt(options.restartDelay),
+                maxRestarts: parseInt(options.maxRestarts)
+            });
+            await startManager.start();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Start failed: ${error.message}`, 'error');
             }
             else {
-                logger_manager_js_1.loggerManager.printLine('Entry file not found. Please specify an entry file or build the project first.', 'error');
-                process.exit(1);
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown start error occurred`, 'error');
+            }
+            process.exit(1);
+        }
+    });
+    // Quick start command for development
+    program
+        .command('serve [entry]')
+        .description('Quick start with watch mode (development)')
+        .option('-p, --port <port>', 'Port to run the server on', '3000')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (entry, options) => {
+        try {
+            const entryFile = entry || 'dist/index.js';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting development server...`, 'info');
+            startManager = new start_manager_js_1.StartManager({
+                entry: entryFile,
+                port: parseInt(options.port),
+                host: '127.0.0.1',
+                env: 'development',
+                watch: true,
+                cluster: false,
+                workers: 1,
+                memory: 256,
+                timeout: 15000,
+                gracefulTimeout: 3000,
+                verbose: options.verbose,
+                quiet: false,
+                color: true,
+                logLevel: 'info',
+                nodeArgs: [],
+                inspect: false,
+                inspectPort: 9229,
+                pid: '',
+                restart: true,
+                restartDelay: 500,
+                maxRestarts: 50
+            });
+            await startManager.start();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Serve failed: ${error.message}`, 'error');
             }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown serve error occurred`, 'error');
+            }
+            process.exit(1);
         }
-        const startOptions = {
-            entry: entryPoint,
-            name: options.name,
-            watch: options.watch,
-            quiet: options.quiet,
-            color: options.color,
-            verbose: options.verbose,
-            nodeArgs: options.nodeArgs,
-        };
-        manager = new start_manager_js_1.StartManager(startOptions);
+    });
+    // Production deployment command
+    program
+        .command('deploy [entry]')
+        .description('Deploy to production with optimal settings')
+        .option('-p, --port <port>', 'Port to run the server on', process.env.PORT || '3000')
+        .option('-w, --workers <count>', 'Number of worker processes', os_1.default.cpus().length.toString())
+        .option('-m, --memory <mb>', 'Memory limit in MB', '1024')
+        .option('--pid <file>', 'Write process ID to file', 'server.pid')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (entry, options) => {
         try {
-            await manager.start();
+            const entryFile = entry || 'dist/index.js';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Deploying to production...`, 'info');
+            startManager = new start_manager_js_1.StartManager({
+                entry: entryFile,
+                port: parseInt(options.port),
+                host: '0.0.0.0',
+                env: 'production',
+                watch: false,
+                cluster: true,
+                workers: parseInt(options.workers),
+                memory: parseInt(options.memory),
+                timeout: 30000,
+                gracefulTimeout: 10000,
+                verbose: options.verbose,
+                quiet: false,
+                color: false,
+                logLevel: 'warn',
+                nodeArgs: ['--optimize-for-size'],
+                inspect: false,
+                inspectPort: 9229,
+                pid: options.pid,
+                restart: true,
+                restartDelay: 2000,
+                maxRestarts: 5
+            });
+            await startManager.start();
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(error.message, 'error');
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Deploy failed: ${error.message}`, 'error');
+            }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown deploy error occurred`, 'error');
+            }
             process.exit(1);
         }
     });
-    return {
-        cleanupStart: async () => {
-            if (manager) {
-                await manager.stop();
+    // Health check command
+    program
+        .command('health [url]')
+        .description('Check server health')
+        .option('-t, --timeout <ms>', 'Request timeout in milliseconds', '5000')
+        .option('-i, --interval <ms>', 'Check interval in milliseconds', '1000')
+        .option('-c, --count <number>', 'Number of checks', '1')
+        .action(async (url, options) => {
+        const checkUrl = url || 'http://localhost:3000/health';
+        const timeout = parseInt(options.timeout);
+        const interval = parseInt(options.interval);
+        const count = parseInt(options.count);
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Health check: ${checkUrl}`, 'info');
+        for (let i = 0; i < count; i++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), timeout);
+                const response = await fetch(checkUrl, {
+                    signal: controller.signal
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Health check ${i + 1}/${count}: OK (${response.status})`, 'info');
+                }
+                else {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Health check ${i + 1}/${count}: Failed (${response.status})`, 'error');
+                }
+            }
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Health check ${i + 1}/${count}: Error (${error.message})`, 'error');
+            }
+            if (i < count - 1) {
+                await new Promise(resolve => setTimeout(resolve, interval));
+            }
+        }
+    });
+    // Cleanup function
+    const cleanupStart = async () => {
+        if (startManager) {
+            try {
+                await startManager.stop();
+                startManager = null;
+            }
+            catch (error) {
+                // Ignore cleanup errors
             }
-        },
+        }
+    };
+    // Handle process termination
+    const handleExit = (signal) => {
+        if (startManager) {
+            logger_manager_js_1.loggerManager.printLine(`\n${chalk_1.default.yellow(figures_1.default.warning)} Received ${signal}, shutting down gracefully...`, 'info');
+            cleanupStart().then(() => {
+                process.exit(0);
+            }).catch(() => {
+                process.exit(1);
+            });
+        }
+        else {
+            process.exit(0);
+        }
     };
+    // Register signal handlers
+    process.on('SIGINT', () => handleExit('SIGINT'));
+    process.on('SIGTERM', () => handleExit('SIGTERM'));
+    process.on('SIGQUIT', () => handleExit('SIGQUIT'));
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Uncaught exception: ${error.message}`, 'error');
+        cleanupStart().then(() => {
+            process.exit(1);
+        });
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Unhandled rejection at: ${promise} reason: ${reason}`, 'error');
+        cleanupStart().then(() => {
+            process.exit(1);
+        });
+    });
+    return { cleanupStart };
 }
 exports.addStartCommands = addStartCommands;

package/dist/src/start-manager.js

@@ -4,118 +4,407 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartManager = void 0;
-// src/start-manager.ts - Production application runner
+// src/start-manager.ts - Production server manager for built TypeScript projects
 const child_process_1 = require("child_process");
+const chokidar_1 = require("chokidar");
 const logger_manager_js_1 = require("./logger-manager.js");
 const chalk_1 = __importDefault(require("chalk"));
 const figures_1 = __importDefault(require("figures"));
-const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const perf_hooks_1 = require("perf_hooks");
 class StartManager {
     constructor(options) {
-        this.process = null;
-        this.isStopping = false;
+        this.serverProcess = null;
+        this.watcher = null;
+        this.isStarting = false;
+        this.restartCount = 0;
+        this.startTime = 0;
+        this.isShuttingDown = false;
+        this.restartTimer = null;
         this.options = options;
     }
-    async startProcess() {
-        var _a, _b;
-        if (this.process) {
-            return;
+    async validateEntry() {
+        let entryPath = this.options.entry;
+        // Check if entry exists as provided
+        if ((0, fs_1.existsSync)(entryPath)) {
+            return path_1.default.resolve(entryPath);
         }
-        const nodeArgs = this.options.nodeArgs || [];
-        const args = [...nodeArgs, this.options.entry];
-        if (this.options.verbose) {
-            logger_manager_js_1.loggerManager.printLine(`Executing: node ${args.join(' ')}`, 'info');
-        }
-        this.process = (0, child_process_1.spawn)('node', args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            shell: false,
-            env: {
-                ...process.env,
-                NODE_ENV: 'production',
-                FORCE_COLOR: this.options.color ? '1' : '0'
-            },
-            detached: true
-        });
-        const appName = this.options.name || path_1.default.basename(this.options.entry);
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Starting ${chalk_1.default.cyan(appName)} in production mode...`, 'info');
+        // Try with .js extension
+        if (!entryPath.endsWith('.js')) {
+            const jsPath = entryPath + '.js';
+            if ((0, fs_1.existsSync)(jsPath)) {
+                return path_1.default.resolve(jsPath);
+            }
         }
-        (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-            if (!this.options.quiet) {
-                process.stdout.write(data);
+        // Try in dist directory
+        const distPath = path_1.default.join('dist', entryPath);
+        if ((0, fs_1.existsSync)(distPath)) {
+            return path_1.default.resolve(distPath);
+        }
+        // Try in dist with .js extension
+        if (!entryPath.endsWith('.js')) {
+            const distJsPath = path_1.default.join('dist', entryPath + '.js');
+            if ((0, fs_1.existsSync)(distJsPath)) {
+                return path_1.default.resolve(distJsPath);
             }
-        });
-        (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+        }
+        // Try common entry points
+        const commonEntries = [
+            'dist/index.js',
+            'dist/server.js',
+            'dist/app.js',
+            'dist/main.js',
+            'index.js',
+            'server.js'
+        ];
+        for (const entry of commonEntries) {
+            if ((0, fs_1.existsSync)(entry)) {
+                if (!this.options.quiet) {
+                    logger_manager_js_1.loggerManager.printLine(`Using entry point: ${entry}`, 'info');
+                }
+                return path_1.default.resolve(entry);
+            }
+        }
+        throw new Error(`Entry file not found: ${entryPath}`);
+    }
+    async loadPackageJson() {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if ((0, fs_1.existsSync)(packageJsonPath)) {
+                const content = await promises_1.default.readFile(packageJsonPath, 'utf8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            // Ignore package.json errors
+        }
+        return null;
+    }
+    getNodeArgs() {
+        const args = [];
+        // Add custom node arguments
+        if (this.options.nodeArgs.length > 0) {
+            args.push(...this.options.nodeArgs);
+        }
+        // Memory limit
+        if (this.options.memory > 0) {
+            args.push(`--max-old-space-size=${this.options.memory}`);
+        }
+        // Debugging
+        if (this.options.inspect) {
+            args.push(`--inspect=${this.options.inspectPort}`);
+        }
+        // Production optimizations
+        if (this.options.env === 'production') {
+            args.push('--optimize-for-size');
+        }
+        return args;
+    }
+    getEnvironment() {
+        const env = {
+            ...process.env,
+            NODE_ENV: this.options.env,
+            PORT: this.options.port.toString(),
+            HOST: this.options.host,
+            LOG_LEVEL: this.options.logLevel
+        };
+        // Add color support
+        if (this.options.color) {
+            env.FORCE_COLOR = '1';
+        }
+        return env;
+    }
+    async writePidFile(pid) {
+        if (this.options.pid) {
+            try {
+                await promises_1.default.writeFile(this.options.pid, pid.toString());
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`PID file written: ${this.options.pid}`, 'info');
+                }
+            }
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`Failed to write PID file: ${error.message}`, 'warn');
+            }
+        }
+    }
+    async removePidFile() {
+        if (this.options.pid && (0, fs_1.existsSync)(this.options.pid)) {
+            try {
+                await promises_1.default.unlink(this.options.pid);
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`PID file removed: ${this.options.pid}`, 'info');
+                }
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    async startServer() {
+        if (this.isStarting || this.isShuttingDown) {
+            return;
+        }
+        this.isStarting = true;
+        this.startTime = perf_hooks_1.performance.now();
+        try {
+            const entryPath = await this.validateEntry();
+            const nodeArgs = this.getNodeArgs();
+            const env = this.getEnvironment();
             if (!this.options.quiet) {
-                process.stderr.write(data);
+                const restartInfo = this.restartCount > 0 ? ` (restart #${this.restartCount})` : '';
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting server${restartInfo}...`, 'info');
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`Entry: ${entryPath}`, 'info');
+                    logger_manager_js_1.loggerManager.printLine(`Environment: ${this.options.env}`, 'info');
+                    logger_manager_js_1.loggerManager.printLine(`Host: ${this.options.host}:${this.options.port}`, 'info');
+                    if (nodeArgs.length > 0) {
+                        logger_manager_js_1.loggerManager.printLine(`Node args: ${nodeArgs.join(' ')}`, 'info');
+                    }
+                }
             }
-        });
-        this.process.on('error', (error) => {
-            logger_manager_js_1.loggerManager.printLine(`Application error: ${error.message}`, 'error');
-        });
-        this.process.on('exit', (code) => {
-            this.process = null;
-            if (!this.isStopping) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Application ${appName} exited with code ${code}`, 'error');
-                if (this.options.watch) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.arrowRight)} Restarting application...`, 'info');
-                    this.startProcess();
+            const args = [...nodeArgs, entryPath];
+            this.serverProcess = (0, child_process_1.spawn)('node', args, {
+                stdio: this.options.verbose ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'ignore', 'pipe'],
+                env,
+                detached: false,
+                cwd: process.cwd()
+            });
+            if (this.serverProcess.pid) {
+                await this.writePidFile(this.serverProcess.pid);
+            }
+            // Handle server output
+            if (this.options.verbose && this.serverProcess.stdout) {
+                this.serverProcess.stdout.on('data', (data) => {
+                    const output = data.toString().trim();
+                    if (output) {
+                        logger_manager_js_1.loggerManager.printLine(`[SERVER] ${output}`, 'info');
+                    }
+                });
+            }
+            // Handle server errors
+            if (this.serverProcess.stderr) {
+                this.serverProcess.stderr.on('data', (data) => {
+                    const error = data.toString().trim();
+                    if (error && !this.options.quiet) {
+                        logger_manager_js_1.loggerManager.printLine(`[SERVER] ${error}`, 'error');
+                    }
+                });
+            }
+            // Handle process events
+            this.serverProcess.on('error', (error) => {
+                this.isStarting = false;
+                if (!this.isShuttingDown) {
+                    logger_manager_js_1.loggerManager.printLine(`Server process error: ${error.message}`, 'error');
+                    this.handleServerExit(1);
+                }
+            });
+            this.serverProcess.on('exit', (code, signal) => {
+                this.isStarting = false;
+                if (!this.isShuttingDown) {
+                    this.handleServerExit(code || 0, signal || undefined);
                 }
+            });
+            // Wait for server to start
+            await this.waitForServerStart();
+            this.isStarting = false;
+            const duration = Math.round(perf_hooks_1.performance.now() - this.startTime);
+            if (!this.options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server started successfully in ${duration}ms`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Running on ${chalk_1.default.cyan(`http://${this.options.host}:${this.options.port}`)}`, 'info');
+            }
+        }
+        catch (error) {
+            this.isStarting = false;
+            throw error;
+        }
+    }
+    async waitForServerStart() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Server startup timeout after ${this.options.timeout}ms`));
+            }, this.options.timeout);
+            if (this.serverProcess) {
+                // If process exits immediately, it's likely an error
+                const exitHandler = (code) => {
+                    clearTimeout(timeout);
+                    if (code !== 0) {
+                        reject(new Error(`Server exited with code ${code}`));
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                this.serverProcess.once('exit', exitHandler);
+                // Give some time for the server to start
+                setTimeout(() => {
+                    if (this.serverProcess && !this.serverProcess.killed) {
+                        this.serverProcess.removeListener('exit', exitHandler);
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                }, 1000);
+            }
+            else {
+                clearTimeout(timeout);
+                reject(new Error('Server process not created'));
             }
         });
     }
-    async start() {
-        if (!fs_1.default.existsSync(this.options.entry)) {
-            throw new Error(`Entry file not found: ${this.options.entry}`);
+    handleServerExit(code, signal) {
+        this.removePidFile();
+        if (this.isShuttingDown) {
+            return;
+        }
+        const exitMessage = signal
+            ? `Server process killed with signal ${signal}`
+            : `Server process exited with code ${code}`;
+        if (code !== 0 && !this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} ${exitMessage}`, 'error');
+        }
+        // Handle restart logic
+        if (this.options.restart && code !== 0 && this.restartCount < this.options.maxRestarts) {
+            this.scheduleRestart();
         }
-        await this.startProcess();
+        else if (this.restartCount >= this.options.maxRestarts) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Maximum restart attempts reached (${this.options.maxRestarts})`, 'error');
+            process.exit(1);
+        }
+        else if (code !== 0) {
+            process.exit(code);
+        }
+    }
+    scheduleRestart() {
+        this.restartCount++;
+        const delay = this.options.restartDelay * Math.min(this.restartCount, 5); // Exponential backoff
         if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Application is running.`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Restarting server in ${delay}ms... (${this.restartCount}/${this.options.maxRestarts})`, 'info');
         }
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            this.startServer().catch(error => {
+                logger_manager_js_1.loggerManager.printLine(`Restart failed: ${error.message}`, 'error');
+                this.handleServerExit(1);
+            });
+        }, delay);
     }
-    async stop() {
-        this.isStopping = true;
-        const proc = this.process;
-        if (!proc) {
+    setupWatcher() {
+        if (!this.options.watch)
+            return;
+        const watchPatterns = [
+            'dist/**/*.js',
+            'package.json',
+            'dist/package.json'
+        ];
+        this.watcher = (0, chokidar_1.watch)(watchPatterns, {
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: false,
+            atomic: 500,
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/*.log',
+                '**/*.map'
+            ]
+        });
+        this.watcher.on('change', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File changed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            this.restart();
+        });
+        this.watcher.on('error', (error) => {
+            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
+        });
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
+        }
+    }
+    async restart() {
+        if (this.isShuttingDown)
             return;
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Restarting server...`, 'info');
         }
-        this.process = null;
+        await this.stopServer();
+        // Small delay before restart
+        setTimeout(() => {
+            this.startServer().catch(error => {
+                logger_manager_js_1.loggerManager.printLine(`Restart failed: ${error.message}`, 'error');
+                process.exit(1);
+            });
+        }, 100);
+    }
+    async stopServer() {
+        if (!this.serverProcess)
+            return;
         return new Promise((resolve) => {
-            const appName = this.options.name || path_1.default.basename(this.options.entry);
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping application ${appName}...`, 'info');
-            proc.on('exit', () => {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Application stopped.`, 'info');
+            if (!this.serverProcess) {
                 resolve();
-            });
-            proc.on('error', () => {
-                // Handle errors during shutdown, e.g., if the process is already gone
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Application stopped.`, 'info');
+                return;
+            }
+            const proc = this.serverProcess;
+            this.serverProcess = null;
+            if (this.restartTimer) {
+                clearTimeout(this.restartTimer);
+                this.restartTimer = null;
+            }
+            const cleanup = () => {
+                this.removePidFile();
                 resolve();
-            });
+            };
+            proc.on('exit', cleanup);
+            proc.on('error', cleanup);
             try {
                 if (proc.pid) {
-                    const pid = proc.pid;
-                    // Kill the entire process group
-                    process.kill(-pid, 'SIGTERM');
-                    // Set a timeout to force kill if it doesn't terminate gracefully
+                    // Graceful shutdown
+                    proc.kill('SIGTERM');
+                    // Force kill after timeout
                     setTimeout(() => {
-                        if (!proc.killed) {
+                        if (proc.pid && !proc.killed) {
                             try {
-                                process.kill(-pid, 'SIGKILL');
+                                proc.kill('SIGKILL');
                             }
                             catch (e) {
-                                // Ignore errors if the process is already gone
+                                // Ignore
                             }
                         }
-                    }, 5000).unref(); // .unref() allows the main process to exit if this is the only thing running
+                    }, this.options.gracefulTimeout);
                 }
             }
-            catch (e) {
-                // This can happen if the process is already dead
-                resolve();
+            catch (error) {
+                cleanup();
             }
         });
     }
+    async start() {
+        try {
+            await this.startServer();
+            this.setupWatcher();
+            if (this.options.watch && !this.options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Watching for changes...`, 'info');
+            }
+        }
+        catch (error) {
+            logger_manager_js_1.loggerManager.printLine(`Failed to start server: ${error.message}`, 'error');
+            process.exit(1);
+        }
+    }
+    async stop() {
+        this.isShuttingDown = true;
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping server...`, 'info');
+        }
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        await this.stopServer();
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server stopped successfully`, 'info');
+        }
+    }
 }
 exports.StartManager = StartManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neex",
-  "version": "0.6.46",
+  "version": "0.6.50",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",