neex 0.6.85 → 0.6.88

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

@@ -7,18 +7,20 @@ exports.addDevCommands = void 0;
 const dev_manager_js_1 = require("../dev-manager.js");
 const logger_manager_js_1 = require("../logger-manager.js");
 const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const figures_1 = __importDefault(require("figures"));
 function addDevCommands(program) {
     let devManager = null;
-    // Enhanced dev command with built-in TypeScript compilation
+    let isShuttingDown = false;
+    // Ultra-fast Express dev command optimized for speed
     program
         .command('dev [file]')
         .description('Start TypeScript development server with hot reloading (default: src/index.ts)')
         .option('-w, --watch <patterns>', 'Watch additional patterns (comma-separated)', 'src/**/*')
         .option('-i, --ignore <patterns>', 'Ignore patterns (comma-separated)', 'node_modules,dist,build,.git,coverage')
         .option('-e, --ext <extensions>', 'File extensions to watch (comma-separated)', 'ts,tsx,js,jsx,json')
-        .option('-d, --delay <ms>', 'Delay before restart (ms)', parseInt, 500)
-        .option('--fast', 'Enable fast hot reload (shorter delays)')
+        .option('-d, --delay <ms>', 'Delay before restart (ms)', parseInt, 800)
         .option('-c, --no-color', 'Disable colored output')
         .option('-q, --quiet', 'Reduce output verbosity')
         .option('-v, --verbose', 'Verbose output')
@@ -31,11 +33,13 @@ function addDevCommands(program) {
         .option('--no-source-maps', 'Disable source maps')
         .option('--transpile-only', 'Skip type checking for faster compilation')
         .option('--node-args <args>', 'Additional Node.js arguments (comma-separated)', '')
+        .option('--port <port>', 'Port to use if available', parseInt)
+        .option('--host <host>', 'Host to bind to')
+        .option('--hot-reload', 'Enable hot reloading for supported frameworks (e.g., Express)')
+        .option('--middleware', 'Inject middleware for features like hot reloading')
         .action(async (file, options) => {
         try {
             const targetFile = file || 'src/index.ts';
-            // تنظیمات fast mode
-            const delay = options.fast ? 200 : options.delay;
             if (!options.quiet) {
                 logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting ${chalk_1.default.cyan('neex dev')} for ${chalk_1.default.cyan(targetFile)}`, 'info');
                 if (options.verbose) {
@@ -52,7 +56,7 @@ function addDevCommands(program) {
                 watch: options.watch.split(',').map((p) => p.trim()),
                 ignore: options.ignore.split(',').map((p) => p.trim()),
                 extensions: options.ext.split(',').map((e) => e.trim()),
-                delay: delay,
+                delay: options.delay,
                 color: options.color,
                 quiet: options.quiet,
                 verbose: options.verbose,
@@ -64,7 +68,11 @@ function addDevCommands(program) {
                 tsConfig: options.tsconfig,
                 sourceMaps: options.sourceMaps,
                 transpileOnly: options.transpileOnly,
-                nodeArgs: options.nodeArgs ? options.nodeArgs.split(',').map((arg) => arg.trim()) : []
+                nodeArgs: options.nodeArgs ? options.nodeArgs.split(',').map((arg) => arg.trim()) : [],
+                port: options.port,
+                host: options.host,
+                hotReload: options.hotReload,
+                middleware: options.middleware
             });
             await devManager.start();
         }
@@ -83,11 +91,9 @@ function addDevCommands(program) {
         .command('dev:clean')
         .description('Clean development server cache and temporary files')
         .action(() => {
-        const path = require('path');
-        const fs = require('fs');
-        const tempDir = path.join(process.cwd(), '.neex-temp');
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
+        const tempDir = path_1.default.join(process.cwd(), '.neex');
+        if (fs_1.default.existsSync(tempDir)) {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
             logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Cleaned development cache`, 'info');
         }
         else {
@@ -99,15 +105,13 @@ function addDevCommands(program) {
         .description('Check TypeScript configuration and dependencies')
         .option('--tsconfig <path>', 'Path to TypeScript configuration file')
         .action((options) => {
-        const path = require('path');
-        const fs = require('fs');
         const configPath = options.tsconfig || 'tsconfig.json';
-        if (!fs.existsSync(configPath)) {
+        if (!fs_1.default.existsSync(configPath)) {
             logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} TypeScript config not found: ${configPath}`, 'error');
             process.exit(1);
         }
         try {
-            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
             logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} TypeScript config is valid`, 'info');
             if (config.compilerOptions) {
                 logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Compiler Options:')}`, 'info');

package/dist/src/dev-manager.js

@@ -27,16 +27,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevManager = void 0;
-// src/dev-manager.ts - Enhanced TypeScript development server with improved caching
+// src/dev-manager.ts - Development process manager for Node.js applications
 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 path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const lodash_1 = require("lodash");
 const ts = __importStar(require("typescript"));
+const crypto_1 = __importDefault(require("crypto"));
+const net_1 = __importDefault(require("net"));
 class DevManager {
     constructor(options) {
         this.process = null;
@@ -45,10 +46,93 @@ class DevManager {
         this.restartCount = 0;
         this.startTime = null;
         this.moduleCache = new Map();
-        this.fileWatcher = new Map();
+        this.currentTempFile = null;
+        this.serverInfo = null;
+        this.hotReloadClient = null;
+        this.isExpressApp = false;
+        this.lastCompileTime = 0;
+        this.performanceMetrics = {
+            averageRestartTime: 0,
+            totalRestarts: 0,
+            cacheHits: 0,
+            cacheMisses: 0
+        };
         this.options = options;
-        this.debouncedRestart = (0, lodash_1.debounce)(this.restart.bind(this), options.delay);
+        this.tempDir = path_1.default.join(process.cwd(), '.neex');
+        this.debouncedRestart = (0, lodash_1.debounce)(this.restart.bind(this), Math.max(options.delay, 100));
         this.tsCompilerOptions = this.loadTsConfig();
+        this.setupTempDir();
+        this.detectExpressApp();
+        this.setupHotReloadClient();
+    }
+    setupTempDir() {
+        if (fs_1.default.existsSync(this.tempDir)) {
+            try {
+                fs_1.default.rmSync(this.tempDir, { recursive: true, force: true });
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+        fs_1.default.mkdirSync(this.tempDir, { recursive: true });
+        // Create cache directory
+        const cacheDir = path_1.default.join(this.tempDir, 'cache');
+        fs_1.default.mkdirSync(cacheDir, { recursive: true });
+    }
+    detectExpressApp() {
+        try {
+            const fileContent = fs_1.default.readFileSync(this.options.file, 'utf8');
+            this.isExpressApp = /import.*express|require.*express|app\.listen|server\.listen/.test(fileContent);
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`Detected ${this.isExpressApp ? 'Express' : 'Node.js'} application`, 'info');
+            }
+        }
+        catch (error) {
+            this.isExpressApp = false;
+        }
+    }
+    setupHotReloadClient() {
+        if (!this.options.hotReload || !this.isExpressApp)
+            return;
+        this.hotReloadClient = `
+// Hot reload client for Express development
+(function() {
+    if (typeof window === 'undefined') return;
+    
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = protocol + '//' + window.location.host + '/__neex_hot_reload';
+    
+    function connect() {
+        const ws = new WebSocket(wsUrl);
+        
+        ws.onopen = function() {
+            console.log('🔥 Hot reload connected');
+        };
+        
+        ws.onmessage = function(event) {
+            const data = JSON.parse(event.data);
+            
+            if (data.type === 'reload') {
+                console.log('🔄 Reloading page...');
+                window.location.reload();
+            } else if (data.type === 'error') {
+                console.error('🚨 Build error:', data.message);
+            }
+        };
+        
+        ws.onclose = function() {
+            console.log('🔌 Hot reload disconnected, retrying...');
+            setTimeout(connect, 1000);
+        };
+        
+        ws.onerror = function(error) {
+            console.error('❌ Hot reload error:', error);
+        };
+    }
+    
+    connect();
+})();
+`;
     }
     loadTsConfig() {
         const configPath = this.options.tsConfig || 'tsconfig.json';
@@ -57,8 +141,6 @@ class DevManager {
             module: ts.ModuleKind.CommonJS,
             moduleResolution: ts.ModuleResolutionKind.NodeJs,
             allowJs: true,
-            outDir: undefined,
-            rootDir: undefined,
             strict: false,
             esModuleInterop: true,
             skipLibCheck: true,
@@ -68,408 +150,423 @@ class DevManager {
             sourceMap: this.options.sourceMaps,
             inlineSourceMap: false,
             inlineSources: false,
+            removeComments: false,
+            preserveConstEnums: false,
+            isolatedModules: true,
+            incremental: true,
+            tsBuildInfoFile: path_1.default.join(this.tempDir, 'tsconfig.tsbuildinfo'),
         };
         if (fs_1.default.existsSync(configPath)) {
             try {
                 const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-                if (configFile.error) {
-                    logger_manager_js_1.loggerManager.printLine(`Error reading tsconfig.json: ${configFile.error.messageText}`, 'warn');
-                    return defaultOptions;
-                }
-                const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path_1.default.dirname(configPath));
-                if (parsedConfig.errors.length > 0) {
-                    logger_manager_js_1.loggerManager.printLine(`Error parsing tsconfig.json: ${parsedConfig.errors[0].messageText}`, 'warn');
-                    return defaultOptions;
-                }
-                const options = { ...parsedConfig.options, ...defaultOptions };
-                if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`Loaded TypeScript config from ${configPath}`, 'info');
+                if (!configFile.error) {
+                    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path_1.default.dirname(configPath));
+                    if (parsedConfig.errors.length === 0) {
+                        return { ...defaultOptions, ...parsedConfig.options };
+                    }
                 }
-                return options;
             }
             catch (error) {
-                logger_manager_js_1.loggerManager.printLine(`Failed to load tsconfig.json: ${error.message}`, 'warn');
+                // Fall back to defaults
             }
         }
         return defaultOptions;
     }
     loadEnvFile() {
-        if (this.options.envFile && fs_1.default.existsSync(this.options.envFile)) {
-            try {
-                const envContent = fs_1.default.readFileSync(this.options.envFile, 'utf8');
-                const lines = envContent.split('\n');
-                let loadedCount = 0;
-                for (const line of lines) {
-                    const trimmed = line.trim();
-                    if (trimmed && !trimmed.startsWith('#')) {
-                        const [key, ...values] = trimmed.split('=');
-                        if (key && values.length > 0) {
-                            process.env[key.trim()] = values.join('=').trim().replace(/^["']|["']$/g, '');
-                            loadedCount++;
+        const envFiles = [
+            this.options.envFile,
+            '.env.development',
+            '.env.local',
+            '.env'
+        ].filter(Boolean);
+        for (const envFile of envFiles) {
+            if (fs_1.default.existsSync(envFile)) {
+                try {
+                    const envContent = fs_1.default.readFileSync(envFile, 'utf8');
+                    const lines = envContent.split('\n');
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (trimmed && !trimmed.startsWith('#')) {
+                            const [key, ...values] = trimmed.split('=');
+                            if (key && values.length > 0) {
+                                const value = values.join('=').trim().replace(/^["']|["']$/g, '');
+                                if (!process.env[key.trim()]) {
+                                    process.env[key.trim()] = value;
+                                }
+                            }
                         }
                     }
+                    if (this.options.verbose) {
+                        logger_manager_js_1.loggerManager.printLine(`Loaded environment from ${envFile}`, 'info');
+                    }
+                    break;
                 }
-                if (!this.options.quiet && loadedCount > 0) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim(figures_1.default.info)} Loaded ${loadedCount} env variable${loadedCount > 1 ? 's' : ''} from ${path_1.default.basename(this.options.envFile)}`, 'info');
-                }
-                else if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim(figures_1.default.info)} No env variables found in ${this.options.envFile}`, 'info');
+                catch (error) {
+                    if (this.options.verbose) {
+                        logger_manager_js_1.loggerManager.printLine(`Failed to load ${envFile}: ${error.message}`, 'warn');
+                    }
                 }
             }
-            catch (error) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Failed to load ${this.options.envFile}: ${error.message}`, 'warn');
-            }
         }
     }
-    generateFileHash(content) {
-        // Simple hash function for content
-        let hash = 0;
-        for (let i = 0; i < content.length; i++) {
-            const char = content.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32bit integer
-        }
-        return hash.toString(16);
+    createHash(content) {
+        return crypto_1.default.createHash('sha256').update(content).digest('hex').substring(0, 16);
     }
-    shouldRecompile(filePath, sourceCode) {
-        const absolutePath = path_1.default.resolve(filePath);
-        const cached = this.moduleCache.get(absolutePath);
-        if (!cached) {
-            return true;
-        }
-        // Check if file was modified
-        const stat = fs_1.default.statSync(absolutePath);
-        if (stat.mtimeMs > cached.lastModified) {
-            return true;
-        }
-        // Check if content hash changed
-        const currentHash = this.generateFileHash(sourceCode);
-        if (currentHash !== cached.hash) {
-            return true;
-        }
-        return false;
-    }
-    compileTypeScript(filePath) {
-        const absolutePath = path_1.default.resolve(filePath);
-        try {
-            const sourceCode = fs_1.default.readFileSync(absolutePath, 'utf8');
-            const currentHash = this.generateFileHash(sourceCode);
-            // Check if we need to recompile
-            if (!this.shouldRecompile(absolutePath, sourceCode)) {
-                const cached = this.moduleCache.get(absolutePath);
-                if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`Using cached compilation for ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
-                }
-                return cached;
-            }
-            if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`Compiling ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
-            }
-            const dependencies = new Set();
-            // Extract import/require dependencies with better regex
-            const importRegex = /(?:import|require)\s*(?:\([^)]*\)|[^;]+from\s+)['"`]([^'"`]+)['"`]/g;
-            let match;
-            while ((match = importRegex.exec(sourceCode)) !== null) {
-                if (match[1].startsWith('.')) {
-                    let depPath = path_1.default.resolve(path_1.default.dirname(absolutePath), match[1]);
-                    // Handle file extensions
-                    if (!path_1.default.extname(depPath)) {
-                        // Try common extensions
-                        for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
-                            if (fs_1.default.existsSync(depPath + ext)) {
-                                depPath = depPath + ext;
-                                break;
-                            }
-                        }
-                        // Try index files
-                        if (!fs_1.default.existsSync(depPath)) {
-                            for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
-                                const indexPath = path_1.default.join(depPath, 'index' + ext);
-                                if (fs_1.default.existsSync(indexPath)) {
-                                    depPath = indexPath;
-                                    break;
-                                }
-                            }
+    extractDependencies(sourceCode, filePath) {
+        const dependencies = [];
+        const importRegex = /(?:import|require)\s*(?:\([^)]*\)|[^;]+?from\s+)?['"`]([^'"`]+)['"`]/g;
+        let match;
+        while ((match = importRegex.exec(sourceCode)) !== null) {
+            const importPath = match[1];
+            if (importPath.startsWith('.')) {
+                let resolvedPath = path_1.default.resolve(path_1.default.dirname(filePath), importPath);
+                // Try to resolve with extensions
+                if (!fs_1.default.existsSync(resolvedPath)) {
+                    for (const ext of this.options.extensions.map(e => `.${e}`)) {
+                        const withExt = resolvedPath + ext;
+                        if (fs_1.default.existsSync(withExt)) {
+                            resolvedPath = withExt;
+                            break;
                         }
                     }
-                    if (fs_1.default.existsSync(depPath)) {
-                        dependencies.add(depPath);
-                    }
                 }
-            }
-            let result;
-            if (this.options.transpileOnly) {
-                result = ts.transpileModule(sourceCode, {
-                    compilerOptions: this.tsCompilerOptions,
-                    fileName: absolutePath,
-                    reportDiagnostics: false
-                });
-            }
-            else {
-                // Create a program for better error reporting
-                const program = ts.createProgram([absolutePath], this.tsCompilerOptions);
-                const sourceFile = program.getSourceFile(absolutePath);
-                if (!sourceFile) {
-                    throw new Error(`Could not load source file: ${absolutePath}`);
-                }
-                // Check for compilation errors
-                const diagnostics = ts.getPreEmitDiagnostics(program, sourceFile);
-                if (diagnostics.length > 0) {
-                    const errors = diagnostics.map(diagnostic => {
-                        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-                        if (diagnostic.file && diagnostic.start !== undefined) {
-                            const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-                            return `${path_1.default.relative(process.cwd(), diagnostic.file.fileName)}:${line + 1}:${character + 1} - ${message}`;
+                // Try index files
+                if (!fs_1.default.existsSync(resolvedPath)) {
+                    for (const ext of this.options.extensions.map(e => `.${e}`)) {
+                        const indexPath = path_1.default.join(resolvedPath, 'index' + ext);
+                        if (fs_1.default.existsSync(indexPath)) {
+                            resolvedPath = indexPath;
+                            break;
                         }
-                        return message;
-                    });
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} TypeScript compilation errors:\n${errors.join('\n')}`, 'error');
-                    // Don't exit in dev mode, just show errors
-                    if (!this.options.quiet) {
-                        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Continuing with compilation errors...`, 'warn');
                     }
                 }
-                result = ts.transpileModule(sourceCode, {
-                    compilerOptions: this.tsCompilerOptions,
-                    fileName: absolutePath,
-                    reportDiagnostics: false
-                });
+                if (fs_1.default.existsSync(resolvedPath)) {
+                    dependencies.push(resolvedPath);
+                }
             }
-            const stat = fs_1.default.statSync(absolutePath);
-            const compiled = {
+        }
+        return dependencies;
+    }
+    extractExports(sourceCode) {
+        const exports = [];
+        const exportRegex = /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+        let match;
+        while ((match = exportRegex.exec(sourceCode)) !== null) {
+            exports.push(match[1]);
+        }
+        return exports;
+    }
+    compileModule(filePath, forceRecompile = false) {
+        const absolutePath = path_1.default.resolve(filePath);
+        const compileStart = Date.now();
+        try {
+            const sourceCode = fs_1.default.readFileSync(absolutePath, 'utf8');
+            const hash = this.createHash(sourceCode);
+            const cached = this.moduleCache.get(absolutePath);
+            // Check if we can use cached version
+            if (!forceRecompile && cached && cached.hash === hash) {
+                this.performanceMetrics.cacheHits++;
+                return cached;
+            }
+            this.performanceMetrics.cacheMisses++;
+            const dependencies = this.extractDependencies(sourceCode, absolutePath);
+            const exports = this.extractExports(sourceCode);
+            // Fast transpile without type checking for development
+            const result = ts.transpileModule(sourceCode, {
+                compilerOptions: this.tsCompilerOptions,
+                fileName: absolutePath,
+                reportDiagnostics: this.options.verbose
+            });
+            const moduleInfo = {
                 code: result.outputText,
                 map: result.sourceMapText,
+                hash,
+                timestamp: Date.now(),
                 dependencies,
-                lastModified: stat.mtimeMs,
-                hash: currentHash
+                exports
             };
-            this.moduleCache.set(absolutePath, compiled);
+            this.moduleCache.set(absolutePath, moduleInfo);
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`Compiled ${path_1.default.relative(process.cwd(), filePath)} (${dependencies.size} dependencies)`, 'info');
+                const compileTime = Date.now() - compileStart;
+                logger_manager_js_1.loggerManager.printLine(`Compiled ${path_1.default.relative(process.cwd(), filePath)} (${compileTime}ms)`, 'info');
             }
-            return compiled;
+            return moduleInfo;
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Compilation error in ${path_1.default.relative(process.cwd(), filePath)}: ${error.message}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`Compilation error in ${filePath}: ${error.message}`, 'error');
             throw error;
         }
     }
-    createTempFile(compiled, originalPath) {
-        const tempDir = path_1.default.join(process.cwd(), '.neex-temp');
-        if (!fs_1.default.existsSync(tempDir)) {
-            fs_1.default.mkdirSync(tempDir, { recursive: true });
+    invalidateModuleCache(filePath) {
+        const absolutePath = path_1.default.resolve(filePath);
+        const toRemove = new Set();
+        // Remove the file itself
+        toRemove.add(absolutePath);
+        // Remove any modules that depend on this file (recursive)
+        const findDependents = (targetPath) => {
+            for (const [cachedPath, info] of this.moduleCache.entries()) {
+                if (info.dependencies.includes(targetPath) && !toRemove.has(cachedPath)) {
+                    toRemove.add(cachedPath);
+                    findDependents(cachedPath);
+                }
+            }
+        };
+        findDependents(absolutePath);
+        // Remove all affected modules
+        for (const pathToRemove of toRemove) {
+            this.moduleCache.delete(pathToRemove);
+        }
+        if (this.options.verbose && toRemove.size > 1) {
+            logger_manager_js_1.loggerManager.printLine(`Invalidated ${toRemove.size} modules`, 'info');
+        }
+    }
+    async findFreePort(startPort = 3000) {
+        return new Promise((resolve, reject) => {
+            const server = net_1.default.createServer();
+            server.listen(startPort, () => {
+                const port = server.address().port;
+                server.close(() => resolve(port));
+            });
+            server.on('error', () => {
+                this.findFreePort(startPort + 1).then(resolve).catch(reject);
+            });
+        });
+    }
+    createExecutableFile() {
+        const startCompile = Date.now();
+        // Always force recompile the main file
+        const mainModule = this.compileModule(this.options.file, true);
+        // Create a unique temp file
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substr(2, 9);
+        const tempFile = path_1.default.join(this.tempDir, `server-${timestamp}-${random}.js`);
+        let code = mainModule.code;
+        // Add hot reload middleware for Express apps
+        if (this.isExpressApp && this.options.hotReload) {
+            const hotReloadMiddleware = `
+// Hot reload middleware injected by neex
+const originalListen = require('http').Server.prototype.listen;
+require('http').Server.prototype.listen = function(...args) {
+    const server = originalListen.apply(this, args);
+    
+    // Setup WebSocket for hot reload
+    const WebSocket = require('ws');
+    const wss = new WebSocket.Server({ server, path: '/__neex_hot_reload' });
+    
+    global.__neex_hot_reload = (type, data) => {
+        wss.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ type, ...data }));
+            }
+        });
+    };
+    
+    return server;
+};
+`;
+            code = hotReloadMiddleware + '\n' + code;
         }
-        const baseName = path_1.default.basename(originalPath, path_1.default.extname(originalPath));
-        const tempFile = path_1.default.join(tempDir, `${baseName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.js`);
-        let code = compiled.code;
-        // Handle source maps
-        if (compiled.map && this.options.sourceMaps) {
+        // Add source map support
+        if (mainModule.map && this.options.sourceMaps) {
             const mapFile = tempFile + '.map';
-            fs_1.default.writeFileSync(mapFile, compiled.map);
+            fs_1.default.writeFileSync(mapFile, mainModule.map);
             code += `\n//# sourceMappingURL=${path_1.default.basename(mapFile)}`;
         }
         fs_1.default.writeFileSync(tempFile, code);
-        return tempFile;
-    }
-    cleanupTempFiles() {
-        const tempDir = path_1.default.join(process.cwd(), '.neex-temp');
-        if (fs_1.default.existsSync(tempDir)) {
+        // Clean up old temp file
+        if (this.currentTempFile && fs_1.default.existsSync(this.currentTempFile)) {
             try {
-                const files = fs_1.default.readdirSync(tempDir);
-                for (const file of files) {
-                    const filePath = path_1.default.join(tempDir, file);
-                    try {
-                        fs_1.default.unlinkSync(filePath);
-                    }
-                    catch (error) {
-                        // Ignore individual file errors
-                    }
+                fs_1.default.unlinkSync(this.currentTempFile);
+                const mapFile = this.currentTempFile + '.map';
+                if (fs_1.default.existsSync(mapFile)) {
+                    fs_1.default.unlinkSync(mapFile);
                 }
-                fs_1.default.rmdirSync(tempDir);
             }
             catch (error) {
                 // Ignore cleanup errors
             }
         }
-    }
-    invalidateCache(filePath) {
-        const absolutePath = path_1.default.resolve(filePath);
-        // Remove from cache
-        const removed = this.moduleCache.delete(absolutePath);
-        if (this.options.verbose && removed) {
-            logger_manager_js_1.loggerManager.printLine(`Invalidated cache for ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
-        }
-        // Remove dependent modules from cache
-        const dependents = [];
-        for (const [cachedPath, module] of this.moduleCache.entries()) {
-            if (module.dependencies.has(absolutePath)) {
-                this.moduleCache.delete(cachedPath);
-                dependents.push(cachedPath);
-            }
-        }
-        if (this.options.verbose && dependents.length > 0) {
-            logger_manager_js_1.loggerManager.printLine(`Invalidated ${dependents.length} dependent modules`, 'info');
-        }
+        this.currentTempFile = tempFile;
+        this.lastCompileTime = Date.now() - startCompile;
+        return tempFile;
     }
     async getExecuteCommand() {
         if (this.options.execCommand) {
             const parts = this.options.execCommand.split(' ');
-            return { command: parts[0], args: [...parts.slice(1)] };
+            return { command: parts[0], args: parts.slice(1) };
         }
-        // Always recompile the main file to ensure fresh execution
-        this.invalidateCache(this.options.file);
-        // Compile TypeScript file
-        const compiled = this.compileTypeScript(this.options.file);
-        const tempFile = this.createTempFile(compiled, this.options.file);
-        const args = [...this.options.nodeArgs, tempFile];
-        if (this.options.inspect) {
+        const executableFile = this.createExecutableFile();
+        const args = [...this.options.nodeArgs, executableFile];
+        // Add Node.js flags
+        if (this.options.inspect)
             args.unshift('--inspect');
-        }
-        if (this.options.inspectBrk) {
+        if (this.options.inspectBrk)
             args.unshift('--inspect-brk');
-        }
-        // Enable source map support
-        if (this.options.sourceMaps) {
+        if (this.options.sourceMaps)
             args.unshift('--enable-source-maps');
-        }
+        // Memory optimization
+        args.unshift('--max-old-space-size=4096');
+        args.unshift('--optimize-for-size');
         return { command: 'node', args };
     }
     clearConsole() {
         if (this.options.clearConsole && process.stdout.isTTY) {
-            process.stdout.write('\x1b[2J\x1b[0f');
+            process.stdout.write('\x1Bc');
         }
     }
     async startProcess() {
         var _a, _b;
-        if (this.process) {
+        if (this.process)
             return;
-        }
+        const restartStart = Date.now();
         this.loadEnvFile();
         try {
             const { command, args } = await this.getExecuteCommand();
-            if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
+            // Find free port for Express apps
+            if (this.isExpressApp && !process.env.PORT) {
+                const port = await this.findFreePort(this.options.port || 3000);
+                process.env.PORT = port.toString();
             }
             this.process = (0, child_process_1.spawn)(command, args, {
                 stdio: ['ignore', 'pipe', 'pipe'],
-                shell: false,
                 env: {
                     ...process.env,
                     NODE_ENV: process.env.NODE_ENV || 'development',
                     FORCE_COLOR: this.options.color ? '1' : '0',
-                    TS_NODE_DEV: '1',
-                    NEEX_DEV: '1'
+                    NEEX_DEV_MODE: '1',
+                    NEEX_HOT_RELOAD: this.options.hotReload ? '1' : '0',
                 },
-                detached: true
+                detached: false
             });
             this.startTime = new Date();
             this.restartCount++;
+            // Update performance metrics
+            if (this.restartCount > 1) {
+                const restartTime = Date.now() - restartStart;
+                this.performanceMetrics.averageRestartTime =
+                    (this.performanceMetrics.averageRestartTime * (this.restartCount - 2) + restartTime) / (this.restartCount - 1);
+                this.performanceMetrics.totalRestarts++;
+            }
             if (!this.options.quiet) {
                 const timestamp = new Date().toLocaleTimeString();
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Started ${chalk_1.default.cyan(path_1.default.relative(process.cwd(), this.options.file))} ${chalk_1.default.dim(`(#${this.restartCount} - ${timestamp})`)}`, 'info');
+                const fileRelative = path_1.default.relative(process.cwd(), this.options.file);
+                const port = process.env.PORT ? `:${process.env.PORT}` : '';
+                const url = this.isExpressApp ? `http://localhost${port}` : '';
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('▶')} ${chalk_1.default.cyan(fileRelative)} ${chalk_1.default.dim(`#${this.restartCount} ${timestamp}`)}`, 'info');
+                if (url) {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('🌐')} ${chalk_1.default.underline(url)}`, 'info');
+                }
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Compile time:')} ${this.lastCompileTime}ms`, 'info');
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Cache hits:')} ${this.performanceMetrics.cacheHits}`, 'info');
+                }
             }
+            this.serverInfo = {
+                port: parseInt(process.env.PORT || '3000'),
+                host: this.options.host || 'localhost',
+                pid: this.process.pid,
+                startTime: Date.now(),
+                restarts: this.restartCount
+            };
+            // Handle stdout/stderr with better formatting
             (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                const output = data.toString();
                 if (!this.options.quiet) {
-                    process.stdout.write(data);
+                    process.stdout.write(output);
                 }
             });
             (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                const output = data.toString();
                 if (!this.options.quiet) {
-                    process.stderr.write(data);
+                    process.stderr.write(output);
                 }
             });
             this.process.on('error', (error) => {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Process error: ${error.message}`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`Process error: ${error.message}`, 'error');
+                if (this.options.hotReload && global.__neex_hot_reload) {
+                    global.__neex_hot_reload('error', { message: error.message });
+                }
             });
             this.process.on('exit', (code, signal) => {
                 if (this.process) {
                     this.process = null;
-                    if (!this.isRestarting) {
-                        if (code !== 0) {
-                            const duration = this.startTime ? Date.now() - this.startTime.getTime() : 0;
-                            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Process exited with code ${code} after ${duration}ms`, 'error');
-                        }
+                    this.serverInfo = null;
+                    if (!this.isRestarting && code !== 0) {
+                        const duration = this.startTime ? Date.now() - this.startTime.getTime() : 0;
+                        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('✖')} Process exited with code ${code} (${duration}ms)`, 'error');
                     }
                 }
             });
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Failed to start process: ${error.message}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`Failed to start: ${error.message}`, 'error');
             throw error;
         }
     }
     async stopProcess() {
-        if (!this.process) {
+        if (!this.process)
             return;
-        }
         return new Promise((resolve) => {
-            if (!this.process) {
-                resolve();
-                return;
-            }
             const proc = this.process;
             this.process = null;
+            this.serverInfo = null;
             const cleanup = () => {
-                if (!this.options.quiet) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Process stopped`, 'info');
-                }
-                this.cleanupTempFiles();
                 resolve();
             };
             proc.on('exit', cleanup);
             proc.on('error', cleanup);
             try {
-                if (proc.pid) {
-                    // Kill process group
-                    process.kill(-proc.pid, 'SIGTERM');
-                    // Fallback after timeout
-                    setTimeout(() => {
-                        if (proc.pid && !proc.killed) {
-                            try {
-                                process.kill(-proc.pid, 'SIGKILL');
-                            }
-                            catch (e) {
-                                // Ignore
-                            }
-                        }
-                    }, 2000);
-                }
+                proc.kill('SIGTERM');
+                // Force kill after timeout
+                setTimeout(() => {
+                    if (!proc.killed) {
+                        proc.kill('SIGKILL');
+                    }
+                    cleanup();
+                }, 2000);
             }
             catch (error) {
-                // Process might already be dead
                 cleanup();
             }
         });
     }
     async restart() {
-        if (this.isRestarting) {
+        if (this.isRestarting)
             return;
-        }
         this.isRestarting = true;
-        if (this.options.clearConsole) {
-            this.clearConsole();
-        }
+        // Clear console for better UX
+        this.clearConsole();
         if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.arrowRight)} Restarting due to changes...`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow('⟳')} Restarting server...`, 'info');
+        }
+        // Notify hot reload clients
+        if (this.options.hotReload && global.__neex_hot_reload) {
+            global.__neex_hot_reload('reload', {});
         }
+        // Stop current process
         await this.stopProcess();
-        // Small delay to ensure cleanup
-        await new Promise(resolve => setTimeout(resolve, 50));
+        // Start new process
         await this.startProcess();
         this.isRestarting = false;
     }
     setupWatcher() {
         const watchPatterns = this.options.watch;
+        // Optimized ignore patterns for Express projects
         const ignored = [
-            '**/node_modules/**',
-            '**/.git/**',
-            '**/dist/**',
-            '**/build/**',
-            '**/.neex-temp/**',
+            'node_modules/**',
+            '.git/**',
+            'dist/**',
+            'build/**',
+            '.neex/**',
+            'coverage/**',
+            'logs/**',
             '**/*.log',
             '**/*.d.ts',
             '**/*.map',
-            ...this.options.ignore.map(pattern => `**/${pattern}/**`)
+            '**/*.tsbuildinfo',
+            '**/package-lock.json',
+            '**/yarn.lock',
+            ...this.options.ignore
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
             ignored,
@@ -478,75 +575,94 @@ class DevManager {
             usePolling: false,
             atomic: 100,
             awaitWriteFinish: {
-                stabilityThreshold: 50,
-                pollInterval: 25
+                stabilityThreshold: 150,
+                pollInterval: 100
             }
         });
         this.watcher.on('change', (filePath) => {
-            this.invalidateCache(filePath);
+            this.invalidateModuleCache(filePath);
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} File changed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('●')} ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
             }
             this.debouncedRestart();
         });
         this.watcher.on('add', (filePath) => {
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('+')} File added: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('+')} ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
             }
             this.debouncedRestart();
         });
         this.watcher.on('unlink', (filePath) => {
-            this.invalidateCache(filePath);
+            this.invalidateModuleCache(filePath);
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('-')} File removed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('-')} ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
             }
             this.debouncedRestart();
         });
         this.watcher.on('error', (error) => {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Watcher error: ${error.message}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
         });
-        if (this.options.verbose) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim(figures_1.default.info)} Watching: ${watchPatterns.join(', ')}`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim(figures_1.default.info)} Ignoring: ${ignored.join(', ')}`, 'info');
-        }
     }
     async start() {
-        // Check if target file exists
         if (!fs_1.default.existsSync(this.options.file)) {
             throw new Error(`Target file not found: ${this.options.file}`);
         }
-        // Validate TypeScript file
         const ext = path_1.default.extname(this.options.file);
-        if (!['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+        if (!this.options.extensions.map(e => `.${e}`).includes(ext)) {
             throw new Error(`Unsupported file extension: ${ext}`);
         }
-        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting TypeScript development server...`, 'info');
-        // Show configuration in verbose mode
-        if (this.options.verbose) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Target file:')} ${this.options.file}`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Watch patterns:')} ${this.options.watch.join(', ')}`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Restart delay:')} ${this.options.delay}ms`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Transpile only:')} ${this.options.transpileOnly}`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Source maps:')} ${this.options.sourceMaps}`, 'info');
-        }
         // Clear any existing cache
         this.moduleCache.clear();
+        this.setupTempDir();
+        if (!this.options.quiet) {
+            const appType = this.isExpressApp ? 'Express' : 'Node.js';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('⚡')} Starting ${appType} development server...`, 'info');
+        }
         this.setupWatcher();
         await this.startProcess();
-        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} TypeScript development server started. Watching for changes...`, 'info');
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('✓')} Watching for changes...`, 'info');
+            if (this.options.hotReload) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('🔥')} Hot reload enabled`, 'info');
+            }
+        }
     }
     async stop() {
-        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping development server...`, 'info');
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow('⏹')} Stopping development server...`, 'info');
+        }
         if (this.watcher) {
             await this.watcher.close();
             this.watcher = null;
         }
         await this.stopProcess();
-        // Clear cache on stop
+        // Cleanup temp files
+        if (fs_1.default.existsSync(this.tempDir)) {
+            try {
+                fs_1.default.rmSync(this.tempDir, { recursive: true, force: true });
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
         this.moduleCache.clear();
-        if (this.restartCount > 0) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Development server stopped after ${this.restartCount} restart(s)`, 'info');
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine('Development server stopped', 'info');
         }
     }
+    getServerInfo() {
+        return this.serverInfo;
+    }
+    getPerformanceMetrics() {
+        return {
+            ...this.performanceMetrics,
+            modulesCached: this.moduleCache.size,
+            lastCompileTime: this.lastCompileTime
+        };
+    }
+    async forceRestart() {
+        this.moduleCache.clear();
+        await this.restart();
+    }
 }
 exports.DevManager = DevManager;

package/package.json

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