neex 0.6.83 → 0.6.87

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

@@ -7,45 +7,36 @@ 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 figures_1 = __importDefault(require("figures"));
 function addDevCommands(program) {
     let devManager = null;
-    // Enhanced dev command with built-in TypeScript compilation
+    // Ultra-fast 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('-c, --no-color', 'Disable colored output')
-        .option('-q, --quiet', 'Reduce output verbosity')
-        .option('-v, --verbose', 'Verbose output')
+        .description('Start ultra-fast TypeScript development server (like tsx)')
+        .option('-w, --watch <patterns>', 'Watch patterns (comma-separated)', 'src/**/*')
+        .option('-i, --ignore <patterns>', 'Ignore patterns (comma-separated)', 'node_modules,dist,build,.git')
+        .option('-e, --ext <extensions>', 'File extensions to watch', 'ts,tsx,js,jsx')
+        .option('-d, --delay <ms>', 'Restart delay in milliseconds', parseInt, 100)
+        .option('--fast', 'Ultra-fast mode (50ms delay)')
         .option('--no-clear', 'Don\'t clear console on restart')
+        .option('--no-color', 'Disable colored output')
+        .option('-q, --quiet', 'Minimal output')
+        .option('-v, --verbose', 'Verbose logging')
         .option('--inspect', 'Enable Node.js inspector')
-        .option('--inspect-brk', 'Enable Node.js inspector with break')
-        .option('--env <file>', 'Load environment variables from file', '.env')
-        .option('--exec <command>', 'Command to execute instead of built-in TypeScript compilation')
-        .option('--tsconfig <path>', 'Path to TypeScript configuration file')
-        .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('--inspect-brk', 'Enable Node.js inspector with breakpoint')
+        .option('--env <file>', 'Environment file to load', '.env')
+        .option('--exec <command>', 'Custom command to execute')
+        .option('--tsconfig <path>', 'TypeScript config file path')
+        .option('--no-source-maps', 'Disable source map generation')
+        .option('--transpile-only', 'Skip type checking (faster)')
+        .option('--node-args <args>', 'Node.js arguments (comma-separated)', '')
         .action(async (file, options) => {
         try {
             const targetFile = file || 'src/index.ts';
-            // تنظیمات fast mode
-            const delay = options.fast ? 200 : options.delay;
+            const delay = options.fast ? 50 : 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) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Features:')}`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Built-in TypeScript compilation`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Hot reloading with intelligent caching`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Source map support`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Fast transpilation mode`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Dependency tracking`, 'info');
-                }
+                console.log(''); // Empty line for better visual separation
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('⚡')} ${chalk_1.default.bold('neex dev')} ${chalk_1.default.dim('v1.0.0')} - ${chalk_1.default.cyan(targetFile)}`, 'info');
             }
             devManager = new dev_manager_js_1.DevManager({
                 file: targetFile,
@@ -70,58 +61,119 @@ function addDevCommands(program) {
         }
         catch (error) {
             if (error instanceof Error) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Development server error: ${error.message}`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('✖')} ${error.message}`, 'error');
             }
             else {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown development server error occurred`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('✖')} Unknown error occurred`, 'error');
             }
             process.exit(1);
         }
     });
-    // Additional helper commands
+    // Clean cache command
     program
         .command('dev:clean')
-        .description('Clean development server cache and temporary files')
+        .description('Clean development cache and temp files')
         .action(() => {
         const path = require('path');
         const fs = require('fs');
         const tempDir = path.join(process.cwd(), '.neex-temp');
+        const nodeModulesCache = path.join(process.cwd(), 'node_modules/.cache');
+        let cleaned = false;
         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');
+            cleaned = true;
+        }
+        if (fs.existsSync(nodeModulesCache)) {
+            try {
+                fs.rmSync(nodeModulesCache, { recursive: true, force: true });
+                cleaned = true;
+            }
+            catch (error) {
+                // Ignore cache cleanup errors
+            }
+        }
+        if (cleaned) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('✓')} Cache cleaned successfully`, 'info');
         }
         else {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.info)} No cache to clean`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('ℹ')} No cache to clean`, 'info');
         }
     });
+    // TypeScript config check
     program
         .command('dev:check')
-        .description('Check TypeScript configuration and dependencies')
-        .option('--tsconfig <path>', 'Path to TypeScript configuration file')
+        .description('Check TypeScript configuration')
+        .option('--tsconfig <path>', 'TypeScript config file path')
         .action((options) => {
         const path = require('path');
         const fs = require('fs');
         const configPath = options.tsconfig || 'tsconfig.json';
         if (!fs.existsSync(configPath)) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} TypeScript config not found: ${configPath}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('✖')} TypeScript config not found: ${configPath}`, 'error');
             process.exit(1);
         }
         try {
             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');
-                logger_manager_js_1.loggerManager.printLine(`  Target: ${config.compilerOptions.target || 'default'}`, 'info');
-                logger_manager_js_1.loggerManager.printLine(`  Module: ${config.compilerOptions.module || 'default'}`, 'info');
-                logger_manager_js_1.loggerManager.printLine(`  Strict: ${config.compilerOptions.strict || 'false'}`, 'info');
-                logger_manager_js_1.loggerManager.printLine(`  Source Maps: ${config.compilerOptions.sourceMap || 'false'}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('✓')} TypeScript config is valid`, 'info');
+            if (config.compilerOptions && !options.quiet) {
+                const opts = config.compilerOptions;
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Configuration:')}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`  Target: ${opts.target || 'ES5'}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`  Module: ${opts.module || 'CommonJS'}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`  Strict: ${opts.strict || false}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`  Source Maps: ${opts.sourceMap || false}`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`  Skip Lib Check: ${opts.skipLibCheck || false}`, 'info');
             }
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Invalid TypeScript config: ${error.message}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red('✖')} Invalid TypeScript config: ${error.message}`, 'error');
             process.exit(1);
         }
     });
+    // Performance info command
+    program
+        .command('dev:info')
+        .description('Show development server information')
+        .action(() => {
+        const path = require('path');
+        const fs = require('fs');
+        const os = require('os');
+        console.log('');
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('⚡')} ${chalk_1.default.bold('neex dev')} - Development Server Info`, 'info');
+        console.log('');
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('System:')}`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  Platform: ${os.platform()} ${os.arch()}`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  Node.js: ${process.version}`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  Memory: ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB used`, 'info');
+        console.log('');
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Features:')}`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Ultra-fast TypeScript compilation`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Intelligent module caching`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Hot reload with dependency tracking`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Source map support`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  ${chalk_1.default.green('✓')} Memory-optimized processing`, 'info');
+        const tsConfigExists = fs.existsSync('tsconfig.json');
+        const packageJsonExists = fs.existsSync('package.json');
+        console.log('');
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.dim('Project:')}`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  TypeScript Config: ${tsConfigExists ? chalk_1.default.green('✓') : chalk_1.default.red('✖')}`, 'info');
+        logger_manager_js_1.loggerManager.printLine(`  Package.json: ${packageJsonExists ? chalk_1.default.green('✓') : chalk_1.default.red('✖')}`, 'info');
+        if (packageJsonExists) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+                if (pkg.name) {
+                    logger_manager_js_1.loggerManager.printLine(`  Name: ${pkg.name}`, 'info');
+                }
+                if (pkg.version) {
+                    logger_manager_js_1.loggerManager.printLine(`  Version: ${pkg.version}`, 'info');
+                }
+            }
+            catch (error) {
+                // Ignore package.json parsing errors
+            }
+        }
+        console.log('');
+    });
     // Cleanup function
     const cleanupDev = () => {
         if (devManager) {
@@ -129,20 +181,27 @@ function addDevCommands(program) {
             devManager = null;
         }
     };
-    // Handle process termination
-    process.on('SIGINT', () => {
+    // Enhanced signal handling
+    const handleSignal = (signal) => {
         if (devManager) {
-            logger_manager_js_1.loggerManager.printLine(`\n${chalk_1.default.yellow(figures_1.default.warning)} Received SIGINT, shutting down gracefully...`, 'info');
+            console.log(''); // New line for better formatting
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow('⏹')} Received ${signal}, shutting down...`, 'info');
             cleanupDev();
             process.exit(0);
         }
+    };
+    process.on('SIGINT', () => handleSignal('SIGINT'));
+    process.on('SIGTERM', () => handleSignal('SIGTERM'));
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+        console.error(chalk_1.default.red('Uncaught Exception:'), error);
+        cleanupDev();
+        process.exit(1);
     });
-    process.on('SIGTERM', () => {
-        if (devManager) {
-            logger_manager_js_1.loggerManager.printLine(`\n${chalk_1.default.yellow(figures_1.default.warning)} Received SIGTERM, shutting down gracefully...`, 'info');
-            cleanupDev();
-            process.exit(0);
-        }
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error(chalk_1.default.red('Unhandled Rejection at:'), promise, 'reason:', reason);
+        cleanupDev();
+        process.exit(1);
     });
     return { cleanupDev };
 }

package/dist/src/dev-manager.js

@@ -27,16 +27,16 @@ 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 built-in compilation
+// src/dev-manager.ts - Ultra-fast TypeScript development server like tsx
 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"));
 class DevManager {
     constructor(options) {
         this.process = null;
@@ -45,10 +45,23 @@ class DevManager {
         this.restartCount = 0;
         this.startTime = null;
         this.moduleCache = new Map();
-        this.fileWatcher = new Map();
+        this.currentTempFile = null;
         this.options = options;
-        this.debouncedRestart = (0, lodash_1.debounce)(this.restart.bind(this), options.delay);
+        this.tempDir = path_1.default.join(process.cwd(), '.neex-temp');
+        this.debouncedRestart = (0, lodash_1.debounce)(this.restart.bind(this), Math.max(options.delay, 100));
         this.tsCompilerOptions = this.loadTsConfig();
+        this.setupTempDir();
+    }
+    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 });
     }
     loadTsConfig() {
         const configPath = this.options.tsConfig || 'tsconfig.json';
@@ -57,8 +70,6 @@ class DevManager {
             module: ts.ModuleKind.CommonJS,
             moduleResolution: ts.ModuleResolutionKind.NodeJs,
             allowJs: true,
-            outDir: undefined,
-            rootDir: undefined,
             strict: false,
             esModuleInterop: true,
             skipLibCheck: true,
@@ -68,28 +79,22 @@ class DevManager {
             sourceMap: this.options.sourceMaps,
             inlineSourceMap: false,
             inlineSources: false,
+            removeComments: false,
+            preserveConstEnums: false,
+            isolatedModules: true, // For faster compilation
         };
         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;
-                }
-                // 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');
+                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;
@@ -99,190 +104,196 @@ class DevManager {
             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++;
                         }
                     }
                 }
-                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) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Failed to load ${this.options.envFile}: ${error.message}`, 'warn');
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`Failed to load ${this.options.envFile}: ${error.message}`, 'warn');
+                }
             }
         }
     }
-    compileTypeScript(filePath) {
-        const absolutePath = path_1.default.resolve(filePath);
-        // 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 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);
-            }
-            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}`);
+    createHash(content) {
+        return crypto_1.default.createHash('md5').update(content).digest('hex');
+    }
+    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 ['.ts', '.tsx', '.js', '.jsx']) {
+                        const withExt = resolvedPath + ext;
+                        if (fs_1.default.existsSync(withExt)) {
+                            resolvedPath = withExt;
+                            break;
+                        }
+                    }
                 }
-                // 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}`;
+                // Try index files
+                if (!fs_1.default.existsSync(resolvedPath)) {
+                    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+                        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(`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
-                });
+                if (fs_1.default.existsSync(resolvedPath)) {
+                    dependencies.push(resolvedPath);
+                }
+            }
+        }
+        return dependencies;
+    }
+    compileModule(filePath, forceRecompile = false) {
+        const absolutePath = path_1.default.resolve(filePath);
+        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) {
+                return cached;
             }
-            const compiled = {
+            const dependencies = this.extractDependencies(sourceCode, absolutePath);
+            // Fast transpile without type checking for development
+            const result = ts.transpileModule(sourceCode, {
+                compilerOptions: this.tsCompilerOptions,
+                fileName: absolutePath,
+                reportDiagnostics: false // Skip diagnostics for speed
+            });
+            const moduleInfo = {
                 code: result.outputText,
                 map: result.sourceMapText,
+                hash,
+                timestamp: Date.now(),
                 dependencies
             };
-            this.moduleCache.set(absolutePath, compiled);
-            return compiled;
+            this.moduleCache.set(absolutePath, moduleInfo);
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`Compiled ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            return moduleInfo;
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`Compilation error in ${filePath}: ${error.message}`, 'error');
+            logger_manager_js_1.loggerManager.printLine(`Compilation error: ${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);
+        // Remove the file itself
+        this.moduleCache.delete(absolutePath);
+        // Remove any modules that depend on this file
+        const toRemove = [];
+        for (const [cachedPath, info] of this.moduleCache.entries()) {
+            if (info.dependencies.includes(absolutePath)) {
+                toRemove.push(cachedPath);
+            }
+        }
+        for (const pathToRemove of toRemove) {
+            this.moduleCache.delete(pathToRemove);
+        }
+        if (this.options.verbose && toRemove.length > 0) {
+            logger_manager_js_1.loggerManager.printLine(`Invalidated ${toRemove.length + 1} modules`, 'info');
         }
-        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) {
+    }
+    createExecutableFile() {
+        // 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, `main-${timestamp}-${random}.js`);
+        let code = mainModule.code;
+        // 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 {
-                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                fs_1.default.unlinkSync(this.currentTempFile);
+                const mapFile = this.currentTempFile + '.map';
+                if (fs_1.default.existsSync(mapFile)) {
+                    fs_1.default.unlinkSync(mapFile);
+                }
             }
             catch (error) {
                 // Ignore cleanup errors
             }
         }
+        this.currentTempFile = tempFile;
+        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) };
         }
-        // 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');
-        }
         return { command: 'node', args };
     }
     clearConsole() {
         if (this.options.clearConsole && process.stdout.isTTY) {
-            process.stdout.write('\x1b[2J\x1b[0f');
+            process.stdout.write('\x1Bc'); // Clear screen and scrollback
         }
     }
     async startProcess() {
         var _a, _b;
-        if (this.process) {
+        if (this.process)
             return;
-        }
         this.loadEnvFile();
         try {
             const { command, args } = await this.getExecuteCommand();
-            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',
-                    TS_NODE_DEV: '1',
-                    NEEX_DEV: '1'
+                    NODE_OPTIONS: '--max-old-space-size=4096', // Prevent memory issues
                 },
-                detached: true
+                detached: false // Keep attached for better cleanup
             });
             this.startTime = new Date();
             this.restartCount++;
             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(`(${timestamp})`)}`, 'info');
+                const fileRelative = path_1.default.relative(process.cwd(), this.options.file);
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green('▶')} ${chalk_1.default.cyan(fileRelative)} ${chalk_1.default.dim(`#${this.restartCount} ${timestamp}`)}`, 'info');
             }
+            // Handle stdout/stderr
             (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                if (!this.options.quiet) {
-                    process.stdout.write(data);
-                }
+                process.stdout.write(data);
             });
             (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-                if (!this.options.quiet) {
-                    process.stderr.write(data);
-                }
+                process.stderr.write(data);
             });
             this.process.on('error', (error) => {
                 logger_manager_js_1.loggerManager.printLine(`Process error: ${error.message}`, 'error');
@@ -290,177 +301,147 @@ class DevManager {
             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');
-                        }
+                    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(`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;
             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 {
-                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);
-                }
+                proc.kill('SIGTERM');
+                // Force kill after timeout
+                setTimeout(() => {
+                    if (!proc.killed) {
+                        proc.kill('SIGKILL');
+                    }
+                }, 1000);
             }
             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;
-        if (this.options.clearConsole) {
-            this.clearConsole();
-        }
+        // Clear console immediately 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...`, 'info');
         }
-        // Clear module cache
-        this.moduleCache.clear();
+        // Stop current process
         await this.stopProcess();
-        // Small delay to ensure cleanup
-        await new Promise(resolve => setTimeout(resolve, 100));
+        // Start new process
         await this.startProcess();
         this.isRestarting = false;
     }
     setupWatcher() {
         const watchPatterns = this.options.watch;
+        // Optimized ignore patterns
         const ignored = [
-            '**/node_modules/**',
-            '**/.git/**',
-            '**/dist/**',
-            '**/build/**',
-            '**/.neex-temp/**',
+            'node_modules/**',
+            '.git/**',
+            'dist/**',
+            'build/**',
+            '.neex-temp/**',
             '**/*.log',
             '**/*.d.ts',
-            ...this.options.ignore.map(pattern => `**/${pattern}/**`)
+            '**/*.map',
+            '**/*.tsbuildinfo',
+            ...this.options.ignore
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
             ignored,
             ignoreInitial: true,
             followSymlinks: false,
             usePolling: false,
-            atomic: 200,
+            atomic: 50,
             awaitWriteFinish: {
                 stabilityThreshold: 100,
                 pollInterval: 50
             }
         });
         this.watcher.on('change', (filePath) => {
-            this.invalidateCache(filePath);
+            this.invalidateModuleCache(filePath);
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`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(`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(`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(`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 (!['.ts', '.tsx', '.js', '.jsx'].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(`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');
+        // Clear any existing cache
+        this.moduleCache.clear();
+        this.setupTempDir();
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue('⚡')} Starting dev 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');
+        }
     }
     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 dev server...`, 'info');
+        }
         if (this.watcher) {
             await this.watcher.close();
             this.watcher = null;
         }
         await this.stopProcess();
-        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');
+        // 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();
     }
 }
 exports.DevManager = DevManager;

package/package.json

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