neex 0.6.88 → 0.6.90

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

@@ -7,20 +7,18 @@ 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;
-    let isShuttingDown = false;
-    // Ultra-fast Express dev command optimized for speed
+    // Enhanced dev command with built-in TypeScript compilation
     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, 800)
+        .option('-d, --delay <ms>', 'Delay before restart (ms)', parseInt, 500)
+        .option('--fast', 'Enable fast hot reload (shorter delays)')
         .option('-c, --no-color', 'Disable colored output')
         .option('-q, --quiet', 'Reduce output verbosity')
         .option('-v, --verbose', 'Verbose output')
@@ -33,13 +31,11 @@ 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) {
@@ -56,7 +52,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: options.delay,
+                delay: delay,
                 color: options.color,
                 quiet: options.quiet,
                 verbose: options.verbose,
@@ -68,11 +64,7 @@ function addDevCommands(program) {
                 tsConfig: options.tsconfig,
                 sourceMaps: options.sourceMaps,
                 transpileOnly: options.transpileOnly,
-                nodeArgs: options.nodeArgs ? options.nodeArgs.split(',').map((arg) => arg.trim()) : [],
-                port: options.port,
-                host: options.host,
-                hotReload: options.hotReload,
-                middleware: options.middleware
+                nodeArgs: options.nodeArgs ? options.nodeArgs.split(',').map((arg) => arg.trim()) : []
             });
             await devManager.start();
         }
@@ -91,9 +83,11 @@ function addDevCommands(program) {
         .command('dev:clean')
         .description('Clean development server cache and temporary files')
         .action(() => {
-        const tempDir = path_1.default.join(process.cwd(), '.neex');
-        if (fs_1.default.existsSync(tempDir)) {
-            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        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 });
             logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Cleaned development cache`, 'info');
         }
         else {
@@ -105,13 +99,15 @@ 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_1.default.existsSync(configPath)) {
+        if (!fs.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_1.default.readFileSync(configPath, 'utf8'));
+            const config = JSON.parse(fs.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,17 +27,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevManager = void 0;
-// src/dev-manager.ts - Development process manager for Node.js applications
+// src/dev-manager.ts - Enhanced TypeScript development server with built-in compilation
 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;
@@ -46,93 +45,10 @@ class DevManager {
         this.restartCount = 0;
         this.startTime = null;
         this.moduleCache = 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.fileWatcher = new Map();
         this.options = options;
-        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.debouncedRestart = (0, lodash_1.debounce)(this.restart.bind(this), options.delay);
         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';
@@ -141,6 +57,8 @@ class DevManager {
             module: ts.ModuleKind.CommonJS,
             moduleResolution: ts.ModuleResolutionKind.NodeJs,
             allowJs: true,
+            outDir: undefined,
+            rootDir: undefined,
             strict: false,
             esModuleInterop: true,
             skipLibCheck: true,
@@ -150,519 +68,399 @@ 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) {
-                    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path_1.default.dirname(configPath));
-                    if (parsedConfig.errors.length === 0) {
-                        return { ...defaultOptions, ...parsedConfig.options };
-                    }
+                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;
+                }
+                // Override some options for development
+                const options = { ...parsedConfig.options, ...defaultOptions };
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`Loaded TypeScript config from ${configPath}`, 'info');
+                }
+                return options;
             }
             catch (error) {
-                // Fall back to defaults
+                logger_manager_js_1.loggerManager.printLine(`Failed to load tsconfig.json: ${error.message}`, 'warn');
             }
         }
         return defaultOptions;
     }
     loadEnvFile() {
-        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;
-                }
-                catch (error) {
-                    if (this.options.verbose) {
-                        logger_manager_js_1.loggerManager.printLine(`Failed to load ${envFile}: ${error.message}`, 'warn');
-                    }
-                }
-            }
-        }
-    }
-    createHash(content) {
-        return crypto_1.default.createHash('sha256').update(content).digest('hex').substring(0, 16);
-    }
-    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 (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++;
                         }
                     }
                 }
-                // 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;
-                        }
-                    }
+                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');
                 }
-                if (fs_1.default.existsSync(resolvedPath)) {
-                    dependencies.push(resolvedPath);
+                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) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Failed to load ${this.options.envFile}: ${error.message}`, 'warn');
+            }
         }
-        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) {
+    compileTypeScript(filePath) {
         const absolutePath = path_1.default.resolve(filePath);
-        const compileStart = Date.now();
+        // Check cache first
+        const cached = this.moduleCache.get(absolutePath);
+        if (cached && !this.options.transpileOnly) {
+            return cached;
+        }
         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;
+            const dependencies = new Set();
+            // Extract import/require dependencies
+            const importRegex = /(?:import|require)\s*(?:\(.*?\)|.*?from\s+)['"`]([^'"`]+)['"`]/g;
+            let match;
+            while ((match = importRegex.exec(sourceCode)) !== null) {
+                if (!match[1].startsWith('.'))
+                    continue;
+                const depPath = path_1.default.resolve(path_1.default.dirname(absolutePath), match[1]);
+                dependencies.add(depPath);
             }
-            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 = {
+            let result;
+            if (this.options.transpileOnly) {
+                // Fast transpile without type checking
+                result = ts.transpileModule(sourceCode, {
+                    compilerOptions: this.tsCompilerOptions,
+                    fileName: absolutePath,
+                    reportDiagnostics: false
+                });
+            }
+            else {
+                // Full compilation with type checking
+                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 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}`;
+                        }
+                        return message;
+                    });
+                    logger_manager_js_1.loggerManager.printLine(`TypeScript compilation errors:\n${errors.join('\n')}`, 'error');
+                    if (!this.options.quiet) {
+                        process.exit(1);
+                    }
+                }
+                result = ts.transpileModule(sourceCode, {
+                    compilerOptions: this.tsCompilerOptions,
+                    fileName: absolutePath,
+                    reportDiagnostics: true
+                });
+            }
+            const compiled = {
                 code: result.outputText,
                 map: result.sourceMapText,
-                hash,
-                timestamp: Date.now(),
-                dependencies,
-                exports
+                dependencies
             };
-            this.moduleCache.set(absolutePath, moduleInfo);
-            if (this.options.verbose) {
-                const compileTime = Date.now() - compileStart;
-                logger_manager_js_1.loggerManager.printLine(`Compiled ${path_1.default.relative(process.cwd(), filePath)} (${compileTime}ms)`, 'info');
-            }
-            return moduleInfo;
+            this.moduleCache.set(absolutePath, compiled);
+            return compiled;
         }
         catch (error) {
             logger_manager_js_1.loggerManager.printLine(`Compilation error in ${filePath}: ${error.message}`, 'error');
             throw error;
         }
     }
-    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;
+    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 });
         }
-        // Add source map support
-        if (mainModule.map && this.options.sourceMaps) {
+        const tempFile = path_1.default.join(tempDir, `${path_1.default.basename(originalPath, path_1.default.extname(originalPath))}-${Date.now()}.js`);
+        let code = compiled.code;
+        // Handle source maps
+        if (compiled.map && this.options.sourceMaps) {
             const mapFile = tempFile + '.map';
-            fs_1.default.writeFileSync(mapFile, mainModule.map);
+            fs_1.default.writeFileSync(mapFile, compiled.map);
             code += `\n//# sourceMappingURL=${path_1.default.basename(mapFile)}`;
         }
         fs_1.default.writeFileSync(tempFile, code);
-        // Clean up old temp file
-        if (this.currentTempFile && fs_1.default.existsSync(this.currentTempFile)) {
+        return tempFile;
+    }
+    cleanupTempFiles() {
+        const tempDir = path_1.default.join(process.cwd(), '.neex-temp');
+        if (fs_1.default.existsSync(tempDir)) {
             try {
-                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.rmSync(tempDir, { recursive: true, force: true });
             }
             catch (error) {
                 // Ignore cleanup errors
             }
         }
-        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)] };
         }
-        const executableFile = this.createExecutableFile();
-        const args = [...this.options.nodeArgs, executableFile];
-        // Add Node.js flags
-        if (this.options.inspect)
+        // 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) {
             args.unshift('--inspect');
-        if (this.options.inspectBrk)
+        }
+        if (this.options.inspectBrk) {
             args.unshift('--inspect-brk');
-        if (this.options.sourceMaps)
+        }
+        // Enable source map support
+        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('\x1Bc');
+            process.stdout.write('\x1b[2J\x1b[0f');
         }
     }
     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();
-            // 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();
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
             }
             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',
-                    NEEX_DEV_MODE: '1',
-                    NEEX_HOT_RELOAD: this.options.hotReload ? '1' : '0',
+                    TS_NODE_DEV: '1',
+                    NEEX_DEV: '1'
                 },
-                detached: false
+                detached: true
             });
             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();
-                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');
-                }
+                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(`(${timestamp})`)}`, '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(output);
+                    process.stdout.write(data);
                 }
             });
             (_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(output);
+                    process.stderr.write(data);
                 }
             });
             this.process.on('error', (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;
-                    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');
+                    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');
+                        }
                     }
                 }
             });
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`Failed to start: ${error.message}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`Failed to start process: ${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)} Stopped process`, 'info');
+                }
+                this.cleanupTempFiles();
                 resolve();
             };
             proc.on('exit', cleanup);
             proc.on('error', cleanup);
             try {
-                proc.kill('SIGTERM');
-                // Force kill after timeout
-                setTimeout(() => {
-                    if (!proc.killed) {
-                        proc.kill('SIGKILL');
-                    }
-                    cleanup();
-                }, 2000);
+                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
+                            }
+                        }
+                    }, 3000);
+                }
             }
             catch (error) {
+                // Process might already be dead
                 cleanup();
             }
         });
     }
+    invalidateCache(filePath) {
+        const absolutePath = path_1.default.resolve(filePath);
+        // Remove from cache
+        this.moduleCache.delete(absolutePath);
+        // Remove dependent modules from cache
+        for (const [cachedPath, module] of this.moduleCache.entries()) {
+            if (module.dependencies.has(absolutePath)) {
+                this.moduleCache.delete(cachedPath);
+            }
+        }
+    }
     async restart() {
-        if (this.isRestarting)
+        if (this.isRestarting) {
             return;
+        }
         this.isRestarting = true;
-        // Clear console for better UX
-        this.clearConsole();
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow('⟳')} Restarting server...`, 'info');
+        if (this.options.clearConsole) {
+            this.clearConsole();
         }
-        // Notify hot reload clients
-        if (this.options.hotReload && global.__neex_hot_reload) {
-            global.__neex_hot_reload('reload', {});
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.arrowRight)} Restarting due to changes...`, 'info');
         }
-        // Stop current process
+        // Clear module cache
+        this.moduleCache.clear();
         await this.stopProcess();
-        // Start new process
+        // Small delay to ensure cleanup
+        await new Promise(resolve => setTimeout(resolve, 100));
         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/**',
-            'coverage/**',
-            'logs/**',
+            '**/node_modules/**',
+            '**/.git/**',
+            '**/dist/**',
+            '**/build/**',
+            '**/.neex-temp/**',
             '**/*.log',
             '**/*.d.ts',
-            '**/*.map',
-            '**/*.tsbuildinfo',
-            '**/package-lock.json',
-            '**/yarn.lock',
-            ...this.options.ignore
+            ...this.options.ignore.map(pattern => `**/${pattern}/**`)
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
             ignored,
             ignoreInitial: true,
             followSymlinks: false,
             usePolling: false,
-            atomic: 100,
+            atomic: 200,
             awaitWriteFinish: {
-                stabilityThreshold: 150,
-                pollInterval: 100
+                stabilityThreshold: 100,
+                pollInterval: 50
             }
         });
         this.watcher.on('change', (filePath) => {
-            this.invalidateModuleCache(filePath);
+            this.invalidateCache(filePath);
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('●')} ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`File changed: ${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('+')} ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`File added: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
             }
             this.debouncedRestart();
         });
         this.watcher.on('unlink', (filePath) => {
-            this.invalidateModuleCache(filePath);
+            this.invalidateCache(filePath);
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('-')} ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`File removed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
             }
             this.debouncedRestart();
         });
         this.watcher.on('error', (error) => {
             logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
         });
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`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 (!this.options.extensions.map(e => `.${e}`).includes(ext)) {
+        if (!['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
             throw new Error(`Unsupported file extension: ${ext}`);
         }
-        // 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');
+        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(`Target file: ${this.options.file}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Watch patterns: ${this.options.watch.join(', ')}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Restart delay: ${this.options.delay}ms`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Transpile only: ${this.options.transpileOnly}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Source maps: ${this.options.sourceMaps}`, 'info');
         }
         this.setupWatcher();
         await this.startProcess();
-        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');
-            }
-        }
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} TypeScript development server started. Watching for changes...`, 'info');
     }
     async stop() {
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow('⏹')} Stopping development server...`, 'info');
-        }
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping development server...`, 'info');
         if (this.watcher) {
             await this.watcher.close();
             this.watcher = null;
         }
         await this.stopProcess();
-        // 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
-            }
+        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');
         }
-        this.moduleCache.clear();
-        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.88",
+  "version": "0.6.90",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",