neex 0.6.18 → 0.6.21

package/README.md

@@ -6,7 +6,7 @@
 </picture>
 </a>
 
-# Neex v0.6.4
+# Neex v0.6.21
 
 ### 🚀 Neex: The Modern Build System for Polyrepo-in-Monorepo Architecture
 

package/dist/src/build-manager.js

@@ -0,0 +1,340 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildManager = void 0;
+// src/build-manager.ts - Build manager with file watching and compilation
+const watcher_1 = require("./watcher");
+const runner_1 = require("./runner");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const logger_1 = __importDefault(require("./logger"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+class BuildManager {
+    constructor(options) {
+        this.isBuilding = false;
+        this.buildCount = 0;
+        this.startTime = new Date();
+        const defaultOptions = {
+            parallel: false,
+            printOutput: true,
+            color: true,
+            showTiming: true,
+            prefix: true,
+            stopOnError: false,
+            minimalOutput: false,
+            groupOutput: false,
+            isServerMode: false,
+            watch: false,
+            ignore: [
+                'node_modules/**',
+                '.git/**',
+                '*.log',
+                'dist/**',
+                'build/**',
+                'coverage/**',
+                '.nyc_output/**',
+                '*.tmp',
+                '*.temp'
+            ],
+            delay: 1000,
+            verbose: false,
+            showInfo: false,
+            runnerName: 'neex build',
+            clean: false,
+            sourceMap: false,
+            target: 'es2020',
+            module: 'commonjs'
+        };
+        this.options = {
+            ...defaultOptions,
+            ...options
+        };
+    }
+    setupFileWatcher() {
+        if (!this.options.watch) {
+            return;
+        }
+        const inputDir = path.dirname(this.options.inputFile);
+        const watchOptions = {
+            watch: [inputDir],
+            ignore: this.options.ignore,
+            ext: this.options.buildType === 'typescript' ? ['ts', 'tsx'] : ['js', 'jsx', 'mjs', 'cjs'],
+            delay: this.options.delay,
+            verbose: this.options.verbose && this.options.showInfo
+        };
+        this.fileWatcher = new watcher_1.FileWatcher(watchOptions);
+        this.fileWatcher.on('change', (event) => {
+            if (this.options.watch && !this.isBuilding) {
+                this.handleFileChange(event);
+            }
+        });
+    }
+    async handleFileChange(event) {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
+        }
+        await this.rebuild();
+    }
+    async ensureOutputDirectory() {
+        try {
+            await fs.mkdir(this.options.outputDir, { recursive: true });
+        }
+        catch (error) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`Failed to create output directory: ${error.message}`, 'error');
+            }
+            throw error;
+        }
+    }
+    async cleanOutputDirectory() {
+        if (!this.options.clean) {
+            return;
+        }
+        try {
+            await fs.rm(this.options.outputDir, { recursive: true, force: true });
+            if (this.options.showInfo) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} Cleaned output directory: ${chalk_1.default.yellow(this.options.outputDir)}`, 'info');
+            }
+        }
+        catch (error) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`Failed to clean output directory: ${error.message}`, 'error');
+            }
+            throw error;
+        }
+    }
+    generateBuildCommand() {
+        const { inputFile, outputDir, buildType, sourceMap, target, module } = this.options;
+        switch (buildType) {
+            case 'typescript':
+                let tsCommand = `npx tsc ${inputFile} --outDir ${outputDir} --target ${target} --module ${module} --moduleResolution node --esModuleInterop --allowSyntheticDefaultImports --strict --skipLibCheck`;
+                if (sourceMap) {
+                    tsCommand += ' --sourceMap';
+                }
+                return tsCommand;
+            case 'javascript':
+            case 'copy':
+                return `cp ${inputFile} ${path.join(outputDir, path.basename(inputFile))}`;
+            default:
+                return `cp ${inputFile} ${path.join(outputDir, path.basename(inputFile))}`;
+        }
+    }
+    async runBuild() {
+        const buildCommand = this.generateBuildCommand();
+        // Create a modified options object for the runner
+        const runnerOptions = {
+            ...this.options,
+            customPrefix: () => `build`
+        };
+        this.runner = new runner_1.Runner(runnerOptions);
+        try {
+            this.isBuilding = true;
+            this.buildCount++;
+            this.lastBuildTime = new Date();
+            // Ensure output directory exists
+            await this.ensureOutputDirectory();
+            // Clean if requested
+            if (this.options.clean && this.buildCount === 1) {
+                await this.cleanOutputDirectory();
+                await this.ensureOutputDirectory();
+            }
+            const results = await this.runner.run([buildCommand]);
+            // Handle build results
+            const success = results.every(result => result.success);
+            const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+            if (success) {
+                if (this.options.showInfo) {
+                    logger_1.default.printLine(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} Build completed successfully`)}`, 'info');
+                }
+            }
+            else {
+                if (this.options.showInfo) {
+                    logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Build failed`)}`, 'error');
+                }
+            }
+            return results;
+        }
+        catch (error) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`Build failed: ${error.message}`, 'error');
+            }
+            return [];
+        }
+        finally {
+            this.isBuilding = false;
+        }
+    }
+    printBuildBanner() {
+        var _a;
+        if (!this.options.showInfo) {
+            return;
+        }
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        console.log('\n' + chalk_1.default.bgBlue.black(`    ${(_a = this.options.runnerName) === null || _a === void 0 ? void 0 : _a.toUpperCase()} MODE    `) + '\n');
+        if (this.buildCount > 0) {
+            console.log(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} Build #${this.buildCount}`)}`);
+        }
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Input: ${this.options.inputFile}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Output: ${this.options.outputDir}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Build type: ${this.options.buildType}`)}`);
+        if (this.options.watch) {
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Watching for changes...`)}`);
+        }
+        console.log('');
+    }
+    formatUptime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        else if (seconds < 3600) {
+            const minutes = Math.floor(seconds / 60);
+            const remainingSeconds = seconds % 60;
+            return `${minutes}m ${remainingSeconds}s`;
+        }
+        else {
+            const hours = Math.floor(seconds / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            return `${hours}h ${minutes}m`;
+        }
+    }
+    async start() {
+        this.startTime = new Date();
+        // Setup file watcher if watch mode is enabled
+        if (this.options.watch) {
+            this.setupFileWatcher();
+        }
+        // Print build banner only if showInfo is true
+        this.printBuildBanner();
+        // Start file watcher if enabled
+        if (this.fileWatcher) {
+            await this.fileWatcher.start();
+        }
+        // Run initial build
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Starting build process...`, 'info');
+        }
+        await this.runBuild();
+        // Set up graceful shutdown
+        this.setupGracefulShutdown();
+        if (this.options.watch) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`${prefix} Build completed. Watching for changes...`, 'info');
+                logger_1.default.printLine(`${prefix} Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+            }
+        }
+        else {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`${prefix} Build process completed`, 'info');
+            }
+        }
+    }
+    async rebuild() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.isBuilding) {
+            return;
+        }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Rebuilding due to file changes...`, 'info');
+        }
+        // Stop current processes
+        if (this.runner) {
+            this.runner.cleanup('SIGTERM');
+        }
+        // Wait a moment before rebuilding
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Print rebuild banner only if showInfo is true
+        this.printBuildBanner();
+        // Run build again
+        await this.runBuild();
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Rebuild completed. Watching for changes...`, 'info');
+        }
+    }
+    async stop() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isBuilding && !this.options.watch) {
+            return;
+        }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Stopping build process...`, 'info');
+        }
+        // Stop file watcher
+        if (this.fileWatcher) {
+            this.fileWatcher.stop();
+        }
+        // Stop current processes
+        if (this.runner) {
+            this.runner.cleanup('SIGTERM');
+        }
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Build process stopped after ${uptimeStr}`, 'info');
+            if (this.buildCount > 0) {
+                logger_1.default.printLine(`${prefix} Total builds: ${this.buildCount}`, 'info');
+            }
+        }
+    }
+    setupGracefulShutdown() {
+        const handleSignal = (signal) => {
+            if (this.options.showInfo) {
+                console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Shutting down build process...`)}`);
+            }
+            this.stop().then(() => {
+                process.exit(0);
+            });
+        };
+        process.on('SIGINT', () => handleSignal('SIGINT'));
+        process.on('SIGTERM', () => handleSignal('SIGTERM'));
+        process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
+    }
+    isActive() {
+        return this.isBuilding || (this.options.watch || false);
+    }
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+    }
+    getBuildCount() {
+        return this.buildCount;
+    }
+    getLastBuildTime() {
+        return this.lastBuildTime;
+    }
+    getWatchedFiles() {
+        var _a;
+        return ((_a = this.fileWatcher) === null || _a === void 0 ? void 0 : _a.getWatchedFiles()) || [];
+    }
+}
+exports.BuildManager = BuildManager;

package/dist/src/cli.js

@@ -22,8 +22,10 @@ function cli() {
     (0, index_js_1.addServerCommands)(program);
     const devCommands = (0, index_js_1.addDevCommands)(program);
     cleanupHandlers.push(devCommands.cleanupDev);
-    const processCommands = (0, index_js_1.addProcessCommands)(program);
-    cleanupHandlers.push(processCommands.cleanupProcess);
+    const buildCommands = (0, index_js_1.addBuildCommands)(program);
+    cleanupHandlers.push(buildCommands.cleanupBuild);
+    const startCommands = (0, index_js_1.addStartCommands)(program);
+    cleanupHandlers.push(startCommands.cleanupStart);
     program.parse(process.argv);
     // Show help if no commands specified
     if (program.args.length === 0) {

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

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBuildCommands = void 0;
+const build_manager_js_1 = require("../build-manager.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+// Helper function to check if file exists
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// Helper function to determine build configuration
+async function getBuildConfig(filePath, outputDir, showInfo) {
+    const ext = path.extname(filePath).toLowerCase();
+    const absolutePath = path.resolve(process.cwd(), filePath);
+    const fileName = path.basename(filePath, ext);
+    const outputPath = path.resolve(process.cwd(), outputDir);
+    // Check if file exists
+    if (!(await fileExists(absolutePath))) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    if (showInfo) {
+        console.log(chalk_1.default.blue(`${figures_1.default.info} neex build: Analyzing ${chalk_1.default.cyan(path.basename(filePath))}`));
+    }
+    switch (ext) {
+        case '.ts':
+        case '.mts':
+        case '.cts':
+            if (showInfo) {
+                console.log(chalk_1.default.green(`${figures_1.default.tick} neex build: TypeScript detected, compiling to JavaScript`));
+            }
+            return {
+                inputFile: absolutePath,
+                outputFile: path.join(outputPath, `${fileName}.js`),
+                buildCommand: `npx tsc ${filePath} --outDir ${outputDir} --target es2020 --module commonjs --moduleResolution node --esModuleInterop --allowSyntheticDefaultImports --strict --skipLibCheck`,
+                buildType: 'typescript'
+            };
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            if (showInfo) {
+                console.log(chalk_1.default.green(`${figures_1.default.tick} neex build: JavaScript detected, copying to output directory`));
+            }
+            return {
+                inputFile: absolutePath,
+                outputFile: path.join(outputPath, path.basename(filePath)),
+                buildCommand: `cp ${filePath} ${path.join(outputDir, path.basename(filePath))}`,
+                buildType: 'copy'
+            };
+        default:
+            if (showInfo) {
+                console.log(chalk_1.default.yellow(`${figures_1.default.warning} neex build: Unknown file type, copying as-is`));
+            }
+            return {
+                inputFile: absolutePath,
+                outputFile: path.join(outputPath, path.basename(filePath)),
+                buildCommand: `cp ${filePath} ${path.join(outputDir, path.basename(filePath))}`,
+                buildType: 'copy'
+            };
+    }
+}
+function addBuildCommands(program) {
+    let buildManager = null;
+    // Build command - compile TypeScript/JavaScript projects
+    program
+        .command('build <file>') // Made file mandatory
+        .alias('b')
+        .description('Build TypeScript/JavaScript files for production')
+        .option('-o, --output <dir>', 'Output directory', 'dist')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-p, --no-prefix', 'Hide command prefix')
+        .option('-s, --stop-on-error', 'Stop on first error')
+        .option('-m, --minimal', 'Use minimal output format')
+        .option('-w, --watch', 'Watch for changes and rebuild')
+        .option('-i, --ignore <patterns...>', 'Patterns to ignore when watching')
+        .option('-d, --delay <ms>', 'Delay before rebuild in milliseconds', parseInt)
+        .option('--clean', 'Clean output directory before build')
+        .option('--verbose', 'Verbose output')
+        .option('--info', 'Show detailed information during build')
+        .option('--source-map', 'Generate source maps')
+        .option('--target <target>', 'Target ECMAScript version', 'es2020')
+        .option('--module <module>', 'Module system', 'commonjs')
+        .action(async (file, options) => {
+        try {
+            const showInfo = options.info || false;
+            if (showInfo) {
+                console.log(chalk_1.default.blue(`${figures_1.default.info} neex build: Starting build process...`));
+                console.log(chalk_1.default.blue(`${figures_1.default.info} neex build: Target file: ${chalk_1.default.cyan(file)}`));
+            }
+            // Validate file parameter
+            if (!file || file.trim() === '') {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} neex build: Error - No file specified!`));
+                console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Usage: neex build <file>`));
+                console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Example: neex build src/server.ts`));
+                process.exit(1);
+            }
+            // Get build configuration
+            let buildConfig;
+            try {
+                buildConfig = await getBuildConfig(file, options.output, showInfo);
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} neex build: ${error instanceof Error ? error.message : 'Unknown error occurred'}`));
+                process.exit(1);
+            }
+            // Setup ignore patterns for watch mode
+            const ignorePatterns = options.ignore || [
+                'node_modules/**',
+                '.git/**',
+                '*.log',
+                'dist/**',
+                'build/**',
+                'coverage/**',
+                '.nyc_output/**',
+                '*.tmp',
+                '*.temp',
+                '.DS_Store',
+                'Thumbs.db'
+            ];
+            // Log configuration only if --info flag is set
+            if (showInfo) {
+                console.log(chalk_1.default.blue(`${figures_1.default.info} neex build: Configuration:`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Input: ${chalk_1.default.cyan(file)}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Output: ${chalk_1.default.cyan(options.output)}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Build type: ${chalk_1.default.cyan(buildConfig.buildType)}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Target: ${chalk_1.default.cyan(options.target)}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Module: ${chalk_1.default.cyan(options.module)}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Watch mode: ${chalk_1.default.cyan(options.watch ? 'Yes' : 'No')}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Clean before build: ${chalk_1.default.cyan(options.clean ? 'Yes' : 'No')}`));
+                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Source maps: ${chalk_1.default.cyan(options.sourceMap ? 'Yes' : 'No')}`));
+                if (options.verbose) {
+                    console.log(chalk_1.default.blue(`${figures_1.default.info} neex build: Verbose mode enabled - showing detailed logs`));
+                }
+                console.log(chalk_1.default.green(`${figures_1.default.tick} neex build: Starting build process...`));
+                console.log(chalk_1.default.gray(`${'='.repeat(60)}`));
+            }
+            // Create BuildManager instance
+            buildManager = new build_manager_js_1.BuildManager({
+                runnerName: 'neex build',
+                inputFile: file,
+                outputDir: options.output,
+                buildType: buildConfig.buildType,
+                buildCommand: buildConfig.buildCommand,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: true,
+                minimalOutput: options.minimal,
+                watch: options.watch,
+                ignore: ignorePatterns,
+                delay: options.delay || 1000,
+                verbose: options.verbose,
+                showInfo: showInfo,
+                clean: options.clean,
+                sourceMap: options.sourceMap,
+                target: options.target,
+                module: options.module,
+                parallel: false,
+                groupOutput: false,
+                isServerMode: false
+            });
+            // Start the build process
+            try {
+                await buildManager.start();
+                console.log(chalk_1.default.green(`${figures_1.default.tick} Build completed successfully`));
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Build failed`));
+                if (error instanceof Error) {
+                    console.error(chalk_1.default.red(`Error: ${error.message}`));
+                }
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`${figures_1.default.cross} neex build: Fatal error occurred`));
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Details: ${error.message}`));
+                if (options.verbose && error.stack) {
+                    console.error(chalk_1.default.gray(`Stack trace:\n${error.stack}`));
+                }
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Unknown error occurred`));
+            }
+            console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Try running with --verbose flag for more details`));
+            process.exit(1);
+        }
+    });
+    // Return cleanup function for build manager
+    return {
+        getBuildManager: () => buildManager,
+        cleanupBuild: () => {
+            if (buildManager && buildManager.isActive()) {
+                console.log(chalk_1.default.blue(`${figures_1.default.info} neex build: Stopping build process...`));
+                buildManager.stop();
+                console.log(chalk_1.default.green(`${figures_1.default.tick} neex build: Build process stopped successfully`));
+            }
+        }
+    };
+}
+exports.addBuildCommands = addBuildCommands;

package/dist/src/commands/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // src/commands/index.ts - Export all commands
 __exportStar(require("./run-commands.js"), exports);
 __exportStar(require("./dev-commands.js"), exports);
-__exportStar(require("./process-commands.js"), exports);
 __exportStar(require("./server-commands.js"), exports);
+__exportStar(require("./start-commands.js"), exports);
+__exportStar(require("./build-commands"), exports);

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

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addStartCommands = void 0;
+const start_manager_js_1 = require("../start-manager.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+// Helper function to check if file exists
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// Helper function to determine the best command to start the application
+async function getStartCommand(filePath, showInfo) {
+    const ext = path.extname(filePath).toLowerCase();
+    const absolutePath = path.resolve(process.cwd(), filePath);
+    const fileName = path.basename(filePath, ext);
+    // Check if file exists
+    if (!(await fileExists(absolutePath))) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    if (showInfo) {
+        console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Analyzing ${chalk_1.default.cyan(path.basename(filePath))}`));
+    }
+    switch (ext) {
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            if (showInfo) {
+                console.log(chalk_1.default.green(`${figures_1.default.tick} neex start: JavaScript detected, using Node.js runtime`));
+            }
+            return {
+                command: `node ${filePath}`,
+                runtime: 'Node.js',
+                processName: fileName
+            };
+        case '.ts':
+        case '.mts':
+        case '.cts':
+            if (showInfo) {
+                console.log(chalk_1.default.yellow(`${figures_1.default.warning} neex start: TypeScript detected, consider building first`));
+                console.log(chalk_1.default.yellow(`${figures_1.default.pointer} Tip: Run 'neex build ${filePath}' first, then start the built .js file`));
+            }
+            return {
+                command: `npx ts-node ${filePath}`,
+                runtime: 'TypeScript (ts-node)',
+                processName: fileName
+            };
+        default:
+            if (showInfo) {
+                console.log(chalk_1.default.yellow(`${figures_1.default.warning} neex start: Unknown file type, using Node.js`));
+            }
+            return {
+                command: `node ${filePath}`,
+                runtime: 'Node.js',
+                processName: fileName
+            };
+    }
+}
+function addStartCommands(program) {
+    let startManager = null;
+    const cleanupStart = () => {
+        if (startManager) {
+            startManager.stop();
+            startManager = null;
+        }
+    };
+    program
+        .command('start <file>')
+        .alias('s')
+        .description('Start a production application')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-v, --verbose', 'Show detailed logs')
+        .option('-w, --watch', 'Watch for file changes')
+        .option('--delay <ms>', 'Delay between file changes (ms)', '1000')
+        .option('--environment <env>', 'Application environment', 'production')
+        .option('--cluster', 'Enable cluster mode')
+        .option('--instances <num>', 'Number of cluster instances', '1')
+        .option('--memory <mb>', 'Memory limit (MB)', '0')
+        .option('--cpu <percent>', 'CPU limit (%)', '0')
+        .action(async (file, options) => {
+        try {
+            // Get start command configuration
+            const startConfig = await getStartCommand(file, true);
+            // Create StartManager instance
+            const startManager = new start_manager_js_1.StartManager({
+                runnerName: 'neex start',
+                targetFile: file,
+                command: startConfig.command,
+                processName: startConfig.processName,
+                runtime: startConfig.runtime,
+                environment: options.environment,
+                showInfo: true,
+                color: !options.color,
+                showTiming: !options.timing,
+                watch: options.watch,
+                delay: parseInt(options.delay),
+                verbose: options.verbose,
+                cluster: options.cluster,
+                clusterInstances: parseInt(options.instances),
+                memoryLimit: parseInt(options.memory),
+                cpuLimit: parseInt(options.cpu),
+                parallel: false,
+                printOutput: true,
+                prefix: true,
+                stopOnError: false,
+                minimalOutput: false,
+                groupOutput: false,
+                isServerMode: true
+            });
+            // Start the application
+            await startManager.start();
+            console.log(chalk_1.default.green(`${figures_1.default.tick} Application started successfully`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`${figures_1.default.cross} Failed to start application`));
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`Error: ${error.message}`));
+            }
+            process.exit(1);
+        }
+    });
+    return {
+        getStartManager: () => startManager,
+        cleanupStart
+    };
+}
+exports.addStartCommands = addStartCommands;

package/dist/src/start-manager.js

@@ -0,0 +1,471 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartManager = void 0;
+// src/start-manager.ts - Production application start manager with monitoring
+const watcher_1 = require("./watcher");
+const runner_1 = require("./runner");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const logger_1 = __importDefault(require("./logger"));
+const os = __importStar(require("os"));
+class StartManager {
+    constructor(options) {
+        this.isRunning = false;
+        this.restartCount = 0;
+        this.crashCount = 0;
+        this.startTime = new Date();
+        this.processStats = {
+            memoryUsage: 0,
+            cpuUsage: 0,
+            uptime: 0
+        };
+        if (!options.targetFile || !options.command || !options.processName || !options.runtime) {
+            throw new Error('Missing required options: targetFile, command, processName, and runtime are required');
+        }
+        const defaultOptions = {
+            parallel: false,
+            printOutput: true,
+            color: true,
+            showTiming: true,
+            prefix: true,
+            stopOnError: false,
+            minimalOutput: false,
+            groupOutput: false,
+            isServerMode: true,
+            watch: false,
+            watchPaths: [],
+            ignore: [
+                'node_modules/**',
+                '.git/**',
+                '*.log',
+                'src/**',
+                'test/**',
+                'tests/**',
+                'coverage/**',
+                '.nyc_output/**',
+                '*.tmp',
+                '*.temp'
+            ],
+            ext: ['js', 'mjs', 'json'],
+            delay: 1000,
+            verbose: false,
+            showInfo: false,
+            runnerName: 'neex start',
+            environment: 'production',
+            maxRestarts: 10,
+            restartDelay: 3000,
+            signal: 'SIGTERM',
+            cluster: false,
+            clusterInstances: os.cpus().length
+        };
+        // Validate numeric values
+        const validateNumber = (value, name) => {
+            const num = parseInt(value);
+            if (isNaN(num) || num < 0) {
+                throw new Error(`Invalid ${name}: must be a non-negative number`);
+            }
+            return num;
+        };
+        this.options = {
+            ...defaultOptions,
+            ...options,
+            delay: validateNumber(options.delay || defaultOptions.delay, 'delay'),
+            clusterInstances: validateNumber(options.clusterInstances || defaultOptions.clusterInstances, 'clusterInstances'),
+            memoryLimit: options.memoryLimit ? validateNumber(options.memoryLimit, 'memoryLimit') : undefined,
+            cpuLimit: options.cpuLimit ? validateNumber(options.cpuLimit, 'cpuLimit') : undefined,
+            maxRestarts: options.maxRestarts ? validateNumber(options.maxRestarts, 'maxRestarts') : undefined,
+            restartDelay: validateNumber(options.restartDelay || defaultOptions.restartDelay, 'restartDelay')
+        };
+        // Validate environment
+        if (this.options.environment) {
+            this.options.environment = this.options.environment.toLowerCase();
+            if (!['production', 'development', 'staging', 'test'].includes(this.options.environment)) {
+                throw new Error(`Invalid environment: ${this.options.environment}. Must be one of: production, development, staging, test`);
+            }
+        }
+    }
+    setupFileWatcher() {
+        var _a;
+        if (!this.options.watch || !((_a = this.options.watchPaths) === null || _a === void 0 ? void 0 : _a.length)) {
+            return;
+        }
+        const watchOptions = {
+            watch: this.options.watchPaths,
+            ignore: this.options.ignore,
+            ext: this.options.ext,
+            delay: this.options.delay,
+            verbose: this.options.verbose && this.options.showInfo
+        };
+        this.fileWatcher = new watcher_1.FileWatcher(watchOptions);
+        this.fileWatcher.on('change', (event) => {
+            if (this.options.watch && this.isRunning) {
+                this.handleFileChange(event);
+            }
+        });
+    }
+    async handleFileChange(event) {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
+        }
+        await this.gracefulRestart();
+    }
+    generateClusterCommand() {
+        if (!this.options.cluster) {
+            return this.options.command;
+        }
+        const instances = this.options.clusterInstances || os.cpus().length;
+        const baseCommand = this.options.command;
+        // For cluster mode, we'll use a simple approach with PM2-like clustering
+        // This is a simplified implementation - in real production, you'd use PM2 or similar
+        return `${baseCommand} --cluster=${instances}`;
+    }
+    async startApplication() {
+        const command = this.generateClusterCommand();
+        // Set environment variables
+        const env = {
+            ...process.env,
+            NODE_ENV: this.options.environment,
+            NEEX_START_MODE: 'production',
+            NEEX_PROCESS_NAME: this.options.processName
+        };
+        // Create a modified options object for the runner
+        const runnerOptions = {
+            ...this.options,
+            env,
+            customPrefix: () => this.options.processName,
+            // Override some options for production
+            stopOnError: false,
+            restartOnFailure: true,
+            maxRestarts: this.options.maxRestarts,
+            restartDelay: this.options.restartDelay
+        };
+        this.runner = new runner_1.Runner(runnerOptions);
+        try {
+            const results = await this.runner.run([command]);
+            return results;
+        }
+        catch (error) {
+            this.crashCount++;
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`Application crashed: ${error.message}`, 'error');
+            }
+            // Check if we should restart
+            if (this.shouldRestart()) {
+                await this.handleCrash();
+            }
+            return [];
+        }
+    }
+    shouldRestart() {
+        if (!this.options.maxRestarts) {
+            return true;
+        }
+        return this.restartCount < this.options.maxRestarts;
+    }
+    async handleCrash() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Application crashed`)}`, 'error');
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Attempting restart in ${this.options.restartDelay}ms...`)}`, 'info');
+        }
+        // Check if we should restart
+        if (!this.shouldRestart()) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Max restarts reached (${this.options.maxRestarts}). Stopping application.`)}`, 'error');
+            }
+            await this.stop();
+            return;
+        }
+        // Wait before restarting
+        await new Promise(resolve => setTimeout(resolve, this.options.restartDelay));
+        try {
+            await this.gracefulRestart();
+        }
+        catch (error) {
+            logger_1.default.printLine(`Failed to restart application: ${error.message}`, 'error');
+            if (this.options.stopOnError) {
+                await this.stop();
+            }
+        }
+    }
+    collectProcessStats() {
+        var _a;
+        if (!this.options.showInfo) {
+            return;
+        }
+        try {
+            const memUsage = process.memoryUsage();
+            this.processStats.memoryUsage = Math.round(memUsage.heapUsed / 1024 / 1024);
+            this.processStats.uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+            // More accurate CPU usage calculation
+            const cpuUsage = process.cpuUsage();
+            const totalCpuTime = cpuUsage.user + cpuUsage.system;
+            const timeDiff = Date.now() - (((_a = this.lastRestartTime) === null || _a === void 0 ? void 0 : _a.getTime()) || this.startTime.getTime());
+            this.processStats.cpuUsage = Math.round((totalCpuTime / timeDiff) * 100);
+            // Check resource limits
+            if (this.options.memoryLimit && this.processStats.memoryUsage > this.options.memoryLimit) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.warning} Memory limit exceeded: ${this.processStats.memoryUsage}MB > ${this.options.memoryLimit}MB`)}`, 'warn');
+                if (this.options.stopOnError) {
+                    this.stop();
+                }
+            }
+            if (this.options.cpuLimit && this.processStats.cpuUsage > this.options.cpuLimit) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.warning} CPU limit exceeded: ${this.processStats.cpuUsage}% > ${this.options.cpuLimit}%`)}`, 'warn');
+                if (this.options.stopOnError) {
+                    this.stop();
+                }
+            }
+        }
+        catch (error) {
+            logger_1.default.printLine(`Failed to collect process stats: ${error.message}`, 'error');
+        }
+    }
+    printStartBanner() {
+        var _a, _b;
+        if (!this.options.showInfo) {
+            return;
+        }
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        console.log('\n' + chalk_1.default.bgGreen.black(`    ${(_a = this.options.runnerName) === null || _a === void 0 ? void 0 : _a.toUpperCase()} - ${(_b = this.options.environment) === null || _b === void 0 ? void 0 : _b.toUpperCase()} MODE    `) + '\n');
+        console.log(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} ${this.options.processName} started successfully`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Runtime: ${this.options.runtime}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Environment: ${this.options.environment}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`)}`);
+        if (this.options.cluster) {
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Cluster mode: ${this.options.clusterInstances} instances`)}`);
+        }
+        if (this.options.watch) {
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Hot reload: enabled`)}`);
+        }
+        if (this.restartCount > 0) {
+            console.log(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Restarts: ${this.restartCount}`)}`);
+        }
+        if (this.crashCount > 0) {
+            console.log(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Crashes: ${this.crashCount}`)}`);
+        }
+        // Show process stats
+        this.collectProcessStats();
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Memory: ${this.processStats.memoryUsage}MB`)}`);
+        if (this.options.memoryLimit) {
+            const memoryPercent = Math.round((this.processStats.memoryUsage / this.options.memoryLimit) * 100);
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Memory usage: ${memoryPercent}%`)}`);
+        }
+        console.log('');
+    }
+    formatUptime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        else if (seconds < 3600) {
+            const minutes = Math.floor(seconds / 60);
+            const remainingSeconds = seconds % 60;
+            return `${minutes}m ${remainingSeconds}s`;
+        }
+        else {
+            const hours = Math.floor(seconds / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            return `${hours}h ${minutes}m`;
+        }
+    }
+    monitorResources() {
+        if (!this.options.showInfo) {
+            return;
+        }
+        const checkInterval = setInterval(() => {
+            if (!this.isRunning) {
+                clearInterval(checkInterval);
+                return;
+            }
+            this.collectProcessStats();
+            // Check memory limit
+            if (this.options.memoryLimit && this.processStats.memoryUsage > this.options.memoryLimit) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.warning} Memory limit exceeded: ${this.processStats.memoryUsage}MB > ${this.options.memoryLimit}MB`)}`, 'warn');
+            }
+            // Log stats every 30 seconds in verbose mode
+            if (this.options.verbose && this.processStats.uptime % 30 === 0) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.gray(`Stats: ${this.processStats.memoryUsage}MB memory, ${this.formatUptime(this.processStats.uptime)} uptime`)}`, 'info');
+            }
+        }, 1000);
+    }
+    async start() {
+        this.isRunning = true;
+        this.startTime = new Date();
+        // Setup file watcher if enabled
+        if (this.options.watch) {
+            this.setupFileWatcher();
+        }
+        // Print start banner
+        this.printStartBanner();
+        // Start file watcher if enabled
+        if (this.fileWatcher) {
+            await this.fileWatcher.start();
+        }
+        // Start resource monitoring
+        this.monitorResources();
+        // Start application
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Starting ${this.options.processName}...`, 'info');
+        }
+        await this.startApplication();
+        // Set up graceful shutdown
+        this.setupGracefulShutdown();
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${this.options.processName} is running in ${this.options.environment} mode`, 'info');
+            if (this.options.watch) {
+                logger_1.default.printLine(`${prefix} Watching for changes...`, 'info');
+            }
+            logger_1.default.printLine(`${prefix} Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+        }
+    }
+    async gracefulRestart() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isRunning) {
+            return;
+        }
+        if (!this.shouldRestart()) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Max restarts reached (${this.options.maxRestarts}). Stopping application.`)}`, 'error');
+            }
+            await this.stop();
+            return;
+        }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Gracefully restarting ${this.options.processName}...`)}`, 'info');
+        }
+        this.restartCount++;
+        this.lastRestartTime = new Date();
+        // Stop current processes gracefully
+        if (this.runner) {
+            this.runner.cleanup(this.options.signal);
+        }
+        // Wait for graceful shutdown
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Print restart banner
+        this.printStartBanner();
+        // Start application again
+        await this.startApplication();
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} ${this.options.processName} restarted successfully`)}`, 'info');
+        }
+    }
+    setupGracefulShutdown() {
+        const handleSignal = async (signal) => {
+            if (!this.isRunning) {
+                return;
+            }
+            try {
+                if (this.options.showInfo) {
+                    console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Gracefully shutting down ${this.options.processName}...`)}`);
+                }
+                await this.stop();
+                process.exit(0);
+            }
+            catch (error) {
+                logger_1.default.printLine(`Failed to handle ${signal}: ${error.message}`, 'error');
+                process.exit(1);
+            }
+        };
+        process.on('SIGINT', () => handleSignal('SIGINT'));
+        process.on('SIGTERM', () => handleSignal('SIGTERM'));
+        process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
+        process.on('uncaughtException', (error) => {
+            logger_1.default.printLine(`Uncaught Exception: ${error.message}`, 'error');
+            handleSignal('SIGTERM');
+        });
+        process.on('unhandledRejection', (reason) => {
+            logger_1.default.printLine(`Unhandled Rejection: ${reason}`, 'error');
+            handleSignal('SIGTERM');
+        });
+    }
+    async stop() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isRunning) {
+            return;
+        }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Stopping ${this.options.processName}...`)}`, 'info');
+        }
+        this.isRunning = false;
+        try {
+            // Stop file watcher
+            if (this.fileWatcher) {
+                await this.fileWatcher.stop();
+            }
+            // Stop application gracefully
+            if (this.runner) {
+                await this.runner.cleanup(this.options.signal);
+            }
+            // Calculate final stats
+            const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+            const uptimeStr = this.formatUptime(uptime);
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} ${this.options.processName} stopped successfully`)}`, 'info');
+                logger_1.default.printLine(`${prefix} Final stats: ${uptimeStr} uptime, ${this.restartCount} restarts, ${this.crashCount} crashes`, 'info');
+            }
+        }
+        catch (error) {
+            logger_1.default.printLine(`Failed to stop application: ${error.message}`, 'error');
+            if (this.options.stopOnError) {
+                process.exit(1);
+            }
+        }
+    }
+    isActive() {
+        return this.isRunning;
+    }
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+    }
+    getRestartCount() {
+        return this.restartCount;
+    }
+    getCrashCount() {
+        return this.crashCount;
+    }
+    getProcessStats() {
+        this.collectProcessStats();
+        return { ...this.processStats };
+    }
+    getLastRestartTime() {
+        return this.lastRestartTime;
+    }
+    getWatchedFiles() {
+        var _a;
+        return ((_a = this.fileWatcher) === null || _a === void 0 ? void 0 : _a.getWatchedFiles()) || [];
+    }
+}
+exports.StartManager = StartManager;

package/package.json

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