neex 0.6.40 → 0.6.41

package/dist/src/dev-runner.js

@@ -68,6 +68,10 @@ class DevRunner {
         });
     }
     async handleFileChange(event) {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
+        }
         if (this.options.clearConsole) {
             console.clear();
         }
@@ -98,6 +102,9 @@ class DevRunner {
             return results;
         }
         catch (error) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`Execution failed: ${error.message}`, 'error');
+            }
             return [];
         }
     }
@@ -148,12 +155,16 @@ class DevRunner {
             await this.fileWatcher.start();
         }
         // Run initial commands
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Starting development server...`, 'info');
+        }
         await this.runCommands();
         // Set up graceful shutdown
         this.setupGracefulShutdown();
         if (this.options.showInfo) {
-            logger_1.default.printLine(`Development server started. Watching for changes...`, 'info');
-            logger_1.default.printLine(`Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+            logger_1.default.printLine(`${prefix} Development server started. Watching for changes...`, 'info');
+            logger_1.default.printLine(`${prefix} Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
         }
     }
     async restart() {
@@ -161,6 +172,9 @@ class DevRunner {
         if (!this.isRunning) {
             return;
         }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Restarting due to file changes...`, 'info');
+        }
         this.restartCount++;
         // Stop current processes
         if (this.runner) {
@@ -172,6 +186,9 @@ class DevRunner {
         this.printDevBanner();
         // Run commands again
         await this.runCommands();
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Restart completed. Watching for changes...`, 'info');
+        }
     }
     async stop() {
         const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
@@ -179,7 +196,7 @@ class DevRunner {
             return;
         }
         if (this.options.showInfo) {
-            logger_1.default.printLine(`Stopping development server...`, 'info');
+            logger_1.default.printLine(`${prefix} Stopping development server...`, 'info');
         }
         this.isRunning = false;
         // Stop file watcher
@@ -193,9 +210,9 @@ class DevRunner {
         const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
         const uptimeStr = this.formatUptime(uptime);
         if (this.options.showInfo) {
-            logger_1.default.printLine(`${this.options.runnerName} development server stopped after ${uptimeStr}`, 'info');
+            logger_1.default.printLine(`${prefix} ${this.options.runnerName} development server stopped after ${uptimeStr}`, 'info');
             if (this.restartCount > 0) {
-                logger_1.default.printLine(`Total restarts: ${this.restartCount}`, 'info');
+                logger_1.default.printLine(`${prefix} Total restarts: ${this.restartCount}`, 'info');
             }
         }
     }

package/dist/src/logger.js

@@ -3,16 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// src/logger.ts
 const chalk_1 = __importDefault(require("chalk"));
 const figures_1 = __importDefault(require("figures"));
+const string_width_1 = __importDefault(require("string-width"));
+const utils_1 = require("./utils");
 class Logger {
-    printSummary(results) {
-        throw new Error('Method not implemented.');
-    }
     constructor() {
+        this.prefixLength = 0;
         this.outputBuffer = new Map();
         this.commandColors = new Map();
         this.startTimes = new Map();
+        this.spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.spinnerIndex = 0;
+        this.spinnerIntervals = new Map();
+        this.isSpinnerActive = false;
     }
     static getInstance() {
         if (!Logger.instance) {
@@ -20,28 +25,60 @@ class Logger {
         }
         return Logger.instance;
     }
+    getSpinnerFrame() {
+        const frame = this.spinnerFrames[this.spinnerIndex];
+        this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+        return frame;
+    }
     showBanner() {
         console.log('\n' + chalk_1.default.bgHex('#0066FF').black('         Neex         ') + '\n');
     }
     setCommands(commands) {
-        // this.showBanner(); // Banner is now called manually where needed
+        // Clear any existing spinner intervals
+        this.stopAllSpinners();
+        // Show Neex banner
+        this.showBanner();
+        // Calculate prefix length for aligning output
+        this.prefixLength = Math.max(...commands.map(cmd => (0, string_width_1.default)(cmd))) + 3;
+        // Initialize buffers and colors for each command
         commands.forEach(cmd => {
             this.outputBuffer.set(cmd, []);
-            if (!this.commandColors.has(cmd)) {
-                this.commandColors.set(cmd, this.getRandomColor());
-            }
+            this.commandColors.set(cmd, this.generateColor(cmd));
         });
+        // Log commands that will be executed
+        console.log(chalk_1.default.dim('» Commands to execute:'));
+        commands.forEach(cmd => {
+            const color = this.commandColors.get(cmd) || chalk_1.default.white;
+            console.log(chalk_1.default.dim('  ┌') + color(` ${cmd}`));
+        });
+        console.log(''); // Add a blank line after commands list
     }
-    getRandomColor() {
+    generateColor(command) {
+        // Generate distinct colors for commands based on the command string
         const vibrantColors = [
-            '#FF5733', '#33FF57', '#3357FF', '#FF33A1', '#A133FF',
-            '#33FFA1', '#FFC300', '#C70039', '#900C3F', '#581845'
+            '#00BFFF',
+            '#32CD32',
+            '#FF6347',
+            '#9370DB',
+            '#FF8C00',
+            '#20B2AA',
+            '#0066FF',
+            '#4169E1',
+            '#FFD700',
+            '#8A2BE2' // Blue Violet
         ];
-        const colorIndex = Math.floor(Math.random() * vibrantColors.length);
+        let hash = 0;
+        for (let i = 0; i < command.length; i++) {
+            hash = (hash << 5) - hash + command.charCodeAt(i);
+            hash |= 0; // Convert to 32bit integer
+        }
+        const colorIndex = Math.abs(hash) % vibrantColors.length;
         return chalk_1.default.hex(vibrantColors[colorIndex]);
     }
     formatPrefix(command) {
-        return '';
+        const color = this.commandColors.get(command) || chalk_1.default.white;
+        const prefix = `${command}:`.padEnd(this.prefixLength);
+        return color(prefix);
     }
     bufferOutput(output) {
         const currentBuffer = this.outputBuffer.get(output.command) || [];
@@ -49,92 +86,186 @@ class Logger {
         this.outputBuffer.set(output.command, currentBuffer);
     }
     printBuffer(command) {
-        this.flushBuffer(command);
+        const buffer = this.outputBuffer.get(command) || [];
+        const color = this.commandColors.get(command) || chalk_1.default.white;
+        // Stop spinner for this command if running
+        this.stopSpinner(command);
+        buffer.forEach(output => {
+            const prefix = this.formatPrefix(output.command);
+            const content = output.data.trim();
+            if (content) {
+                const lines = content.split('\n');
+                lines.forEach(line => {
+                    if (line.trim()) {
+                        const outputLine = `${prefix} ${line}`;
+                        // Show stderr in appropriate colors
+                        if (output.type === 'stderr') {
+                            // Not all stderr is an error, check for warning or info patterns
+                            if (line.toLowerCase().includes('warn') || line.toLowerCase().includes('warning')) {
+                                console.log(`${prefix} ${chalk_1.default.yellow(line)}`);
+                            }
+                            else if (line.toLowerCase().includes('error')) {
+                                console.log(`${prefix} ${chalk_1.default.red(line)}`);
+                            }
+                            else {
+                                console.log(`${prefix} ${line}`);
+                            }
+                        }
+                        else {
+                            console.log(outputLine);
+                        }
+                    }
+                });
+            }
+        });
+        // Clear buffer after printing
+        this.outputBuffer.set(command, []);
     }
     clearBuffer(command) {
         this.outputBuffer.set(command, []);
     }
-    flushBuffer(command) {
-        const buffer = this.outputBuffer.get(command);
-        if (buffer) {
-            buffer.forEach(output => {
-                const prefix = this.formatPrefix(output.command);
-                const color = this.commandColors.get(output.command) || chalk_1.default.white;
-                const formattedOutput = output.data
-                    .split('\n')
-                    .filter(line => line.trim() !== '')
-                    .map(line => `${prefix}${color(line)}`)
-                    .join('\n');
-                if (formattedOutput) {
-                    if (output.type === 'stderr') {
-                        console.error(formattedOutput);
-                    }
-                    else {
-                        console.log(formattedOutput);
-                    }
-                }
-            });
-            this.outputBuffer.set(command, []);
-        }
-    }
     printLine(message, level = 'info') {
-        // This is intentionally left blank to suppress verbose logs
-    }
-    printEnd(result, minimalOutput) {
-        this.printExit(result.command, result.code);
+        if (level === 'error') {
+            console.error(chalk_1.default.red(`${figures_1.default.cross} ${message}`));
+        }
+        else if (level === 'warn') {
+            console.warn(chalk_1.default.yellow(`${figures_1.default.warning} ${message}`));
+        }
+        else {
+            console.log(chalk_1.default.blue(`${figures_1.default.info} ${message}`));
+        }
     }
     printStart(command) {
+        // Record start time
         this.startTimes.set(command, new Date());
+        const prefix = this.formatPrefix(command);
         const color = this.commandColors.get(command) || chalk_1.default.white;
-        console.log(`${color('Starting...')}`);
+        // Stop any previous spinner for this command (e.g. if retrying)
+        this.stopSpinner(command);
+        // Clear the line before printing "Starting..."
+        if (this.isSpinnerActive) { // Check if any spinner was active to avoid clearing unnecessarily
+            process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
+        }
+        console.log(`${prefix} ${color('Starting...')}`);
+        // Start spinner for this command
+        this.startSpinner(command);
+    }
+    startSpinner(command) {
+        // Only create a spinner if one doesn't already exist for this command
+        if (this.spinnerIntervals.has(command)) {
+            return;
+        }
+        this.isSpinnerActive = true;
+        const color = this.commandColors.get(command) || chalk_1.default.white;
+        const prefix = this.formatPrefix(command);
+        const interval = setInterval(() => {
+            const frame = this.getSpinnerFrame();
+            process.stdout.write(`\r${prefix} ${color(frame)} ${chalk_1.default.dim('Running...')}`);
+        }, 80);
+        this.spinnerIntervals.set(command, interval);
+    }
+    stopSpinner(command) {
+        const interval = this.spinnerIntervals.get(command);
+        if (interval) {
+            clearInterval(interval);
+            this.spinnerIntervals.delete(command);
+            // Clear the spinner line
+            if (this.isSpinnerActive) {
+                process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
+            }
+        }
+    }
+    stopAllSpinners() {
+        this.spinnerIntervals.forEach((interval, command) => {
+            clearInterval(interval);
+        });
+        this.spinnerIntervals.clear();
+        this.isSpinnerActive = false;
+        // Clear the spinner line if any spinner was active
+        if (this.isSpinnerActive) {
+            process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
+        }
     }
     printSuccess(result) {
         const { command, duration } = result;
-        const color = this.commandColors.get(command) || chalk_1.default.green;
+        this.stopSpinner(command);
         const prefix = this.formatPrefix(command);
-        console.log(color(`${prefix}${figures_1.default.tick} Success! (${duration.toFixed(2)}ms)`));
+        const color = this.commandColors.get(command) || chalk_1.default.white;
+        const durationStr = duration
+            ? ` ${chalk_1.default.dim(`(${(duration / 1000).toFixed(2)}s)`)}`
+            : '';
+        console.log(`${prefix} ${chalk_1.default.green(figures_1.default.tick)} ${chalk_1.default.green('Completed')}${durationStr}`);
     }
     printError(result) {
-        const { command, duration, code } = result;
-        const color = this.commandColors.get(command) || chalk_1.default.red;
+        const { command, error, code, duration } = result;
+        this.stopSpinner(command);
         const prefix = this.formatPrefix(command);
-        console.error(color(`${prefix}${figures_1.default.cross} Failed with exit code ${code} (${duration.toFixed(2)}ms)`));
-    }
-    printExit(command, code) {
-        const startTime = this.startTimes.get(command);
-        const duration = startTime ? new Date().getTime() - startTime.getTime() : 0;
-        const result = { command, code: code !== null && code !== void 0 ? code : 1, duration };
-        this.flushBuffer(command);
-        if (code === 0) {
-            this.printSuccess(result);
+        const durationStr = duration ? ` ${chalk_1.default.dim(`(${(duration / 1000).toFixed(2)}s)`)}` : '';
+        const errorCode = code !== null ? ` ${chalk_1.default.red(`[code: ${code}]`)}` : '';
+        console.error(`${prefix} ${chalk_1.default.red(figures_1.default.cross)} ${chalk_1.default.red('Failed')}${errorCode}${durationStr}`);
+        if (error) {
+            console.error(`${prefix} ${chalk_1.default.red(error.message)}`);
+        }
+    }
+    printEnd(result, minimalOutput) {
+        this.stopSpinner(result.command);
+        const prefix = this.formatPrefix(result.command); // Corrected to formatPrefix
+        let durationDisplay = '';
+        if (result.duration !== null) {
+            // Ensure result.duration is treated as a number here
+            durationDisplay = `(${(0, utils_1.formatDuration)(result.duration)})`;
+        }
+        const duration = durationDisplay;
+        if (minimalOutput) {
+            if (!result.success) {
+                const status = result.code !== null ? `failed (code ${result.code})` : 'failed';
+                this.printLine(`${prefix} ${chalk_1.default.red(figures_1.default.cross)} ${result.command} ${status} ${duration}`, 'error');
+            }
         }
         else {
-            this.printError(result);
+            if (result.success) {
+                this.printLine(`${prefix} ${chalk_1.default.green(figures_1.default.tick)} Command "${result.command}" finished successfully ${duration}`, 'info');
+            }
+            else {
+                const errorCode = result.code !== null ? ` (code ${result.code})` : '';
+                const errorMessage = result.error ? `: ${result.error.message}` : '';
+                this.printLine(`${prefix} ${chalk_1.default.red(figures_1.default.cross)} Command "${result.command}" failed${errorCode}${errorMessage} ${duration}`, 'error');
+            }
         }
     }
-    printBulkOutput(outputs) {
-        if (outputs.length > 0) {
-            outputs
-                .map(output => {
-                const color = this.commandColors.get(output.command) || chalk_1.default.white;
-                const prefix = this.formatPrefix(output.command);
-                return {
-                    ...output,
-                    prefix,
-                    color
-                };
-            })
-                .forEach(({ command, type, data, prefix, color }) => {
-                const lines = data.split('\n').filter(line => line.trim() !== '');
-                if (lines.length > 0) {
-                    const formatted = lines.map(line => `${prefix}${color(line)}`).join('\n');
-                    if (type === 'stderr') {
-                        console.error(formatted);
-                    }
-                    else {
-                        console.log(formatted);
-                    }
-                }
+    printSummary(results) {
+        // Stop any remaining spinners
+        this.stopAllSpinners();
+        const successful = results.filter(r => r.success).length;
+        const failed = results.length - successful;
+        const totalDuration = results.reduce((sum, result) => sum + (result.duration || 0), 0);
+        const totalSeconds = (totalDuration / 1000).toFixed(2);
+        console.log('\n' + chalk_1.default.bgHex('#0066FF').black('         Execution Summary         ') + '\n');
+        console.log(`${chalk_1.default.green(`${figures_1.default.tick} ${successful} succeeded`)}, ${chalk_1.default.red(`${figures_1.default.cross} ${failed} failed`)}`);
+        console.log(`${chalk_1.default.blue(figures_1.default.info)} ${chalk_1.default.dim(`Total execution time: ${totalSeconds}s`)}`);
+        if (successful > 0) {
+            console.log('\n' + chalk_1.default.green.bold('Successful commands:'));
+            results
+                .filter(r => r.success)
+                .forEach(result => {
+                const color = this.commandColors.get(result.command) || chalk_1.default.white;
+                const duration = result.duration
+                    ? chalk_1.default.dim(` (${(result.duration / 1000).toFixed(2)}s)`)
+                    : '';
+                console.log(`  ${chalk_1.default.green(figures_1.default.tick)} ${color(result.command)}${duration}`);
+            });
+        }
+        if (failed > 0) {
+            console.log('\n' + chalk_1.default.red.bold('Failed commands:'));
+            results
+                .filter(r => !r.success)
+                .forEach(result => {
+                const color = this.commandColors.get(result.command) || chalk_1.default.white;
+                const duration = result.duration
+                    ? chalk_1.default.dim(` (${(result.duration / 1000).toFixed(2)}s)`)
+                    : '';
+                const code = result.code !== null ? chalk_1.default.red(` [code: ${result.code}]`) : '';
+                console.log(`  ${chalk_1.default.red(figures_1.default.cross)} ${color(result.command)}${code}${duration}`);
             });
         }
     }

package/dist/src/runner.js

@@ -27,9 +27,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Runner = void 0;
+// src/runner.ts - Updated version
 const child_process_1 = require("child_process");
 const fsPromises = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
 const logger_1 = __importDefault(require("./logger"));
 const p_map_1 = __importDefault(require("p-map"));
 const npm_run_path_1 = __importDefault(require("npm-run-path"));
@@ -54,6 +56,7 @@ class Runner {
             }
         }
         catch (error) {
+            logger_1.default.printLine(`Could not read or parse package.json: ${error.message}`, 'warn');
             packageJson = { scripts: {} };
         }
         for (const command of commands) {
@@ -62,12 +65,13 @@ class Runner {
                 let foundMatch = false;
                 for (const scriptName in packageJson.scripts) {
                     if (pattern.test(scriptName)) {
-                        expandedCommands.push(scriptName);
+                        expandedCommands.push(scriptName); // Or packageJson.scripts[scriptName] if you want the script value
                         foundMatch = true;
                     }
                 }
                 if (!foundMatch) {
-                    expandedCommands.push(command);
+                    logger_1.default.printLine(`No scripts found in package.json matching wildcard: ${command}`, 'warn');
+                    expandedCommands.push(command); // Add original command if no match
                 }
             }
             else {
@@ -91,18 +95,21 @@ class Runner {
                     return { executableCommand: commandToExecute, executionCwd: targetCwd };
                 }
                 else {
+                    // It's a script from package.json, but no 'cd ... && ...' pattern
                     return { executableCommand: scriptValue, executionCwd: baseDir };
                 }
             }
         }
         catch (error) {
-            // Errors will treat as direct command
+            // Errors like package.json not found, or script not in package.json
+            // Will treat as direct command
         }
         return { executableCommand: scriptNameOrCommand, executionCwd: undefined };
     }
     detectServerInfo(command, data) {
         if (!this.options.isServerMode)
             return;
+        // Get or create server info
         let serverInfo = this.serverInfo.get(command);
         if (!serverInfo) {
             serverInfo = {
@@ -111,16 +118,25 @@ class Runner {
             };
             this.serverInfo.set(command, serverInfo);
         }
+        // Try to detect port from output
         const portMatch = data.match(this.portRegex);
         if (portMatch && portMatch[1]) {
             serverInfo.port = parseInt(portMatch[1], 10);
             serverInfo.status = 'running';
+            // Only log if we just discovered the port
+            if (!serverInfo.url) {
+                logger_1.default.printLine(`Server ${command} running on port ${serverInfo.port}`, 'info');
+            }
         }
+        // Try to detect full URL from output
         const urlMatch = data.match(this.urlRegex);
         if (urlMatch && urlMatch[1]) {
             serverInfo.url = urlMatch[1];
             serverInfo.status = 'running';
+            // Log the full URL once we detect it
+            logger_1.default.printLine(`Server ${command} available at ${chalk_1.default.cyan(serverInfo.url)}`, 'info');
         }
+        // Update server info
         this.serverInfo.set(command, serverInfo);
     }
     async runCommand(originalCommand, currentRetry = 0) {
@@ -132,7 +148,6 @@ class Runner {
             code: null,
             startTime,
             endTime: null,
-            duration: 0,
             output: [],
             stderr: []
         };
@@ -203,11 +218,13 @@ class Runner {
                         serverInfo.status = 'error';
                         this.serverInfo.set(originalCommand, serverInfo);
                     }
+                    logger_1.default.printLine(`Command "${originalCommand}" failed to start: ${err.message}`, 'error');
                 }
                 logger_1.default.printBuffer(originalCommand);
                 if (this.options.printOutput)
                     logger_1.default.printEnd(result, this.options.minimalOutput);
                 if (this.options.retry && this.options.retry > 0 && currentRetry < this.options.retry) {
+                    logger_1.default.printLine(`Command "${originalCommand}" failed with error. Retrying (${currentRetry + 1}/${this.options.retry})...`, 'warn');
                     if (this.options.retryDelay && this.options.retryDelay > 0) {
                         await new Promise(res => setTimeout(res, this.options.retryDelay));
                     }
@@ -223,17 +240,22 @@ class Runner {
                 result.success = code === 0;
                 result.endTime = new Date();
                 result.duration = result.endTime.getTime() - startTime.getTime();
+                this.activeProcesses.delete(originalCommand);
                 if (this.options.isServerMode) {
                     const serverInfo = this.serverInfo.get(originalCommand);
                     if (serverInfo) {
                         serverInfo.status = code === 0 ? 'stopped' : 'error';
                         this.serverInfo.set(originalCommand, serverInfo);
                     }
+                    if (code !== 0) {
+                        logger_1.default.printLine(`Server "${originalCommand}" exited with code ${code}`, 'error');
+                    }
                 }
                 logger_1.default.printBuffer(originalCommand);
                 if (this.options.printOutput)
                     logger_1.default.printEnd(result, this.options.minimalOutput);
                 if (!result.success && this.options.retry && this.options.retry > 0 && currentRetry < this.options.retry) {
+                    logger_1.default.printLine(`Command "${originalCommand}" failed with code ${code}. Retrying (${currentRetry + 1}/${this.options.retry})...`, 'warn');
                     if (this.options.retryDelay && this.options.retryDelay > 0) {
                         await new Promise(res => setTimeout(res, this.options.retryDelay));
                     }
@@ -269,39 +291,65 @@ class Runner {
             });
         }
         catch (error) {
+            if (this.options.isServerMode) {
+                logger_1.default.printLine('One or more servers failed to start. Stopping all servers.', 'error');
+            }
             return [];
         }
     }
     async run(initialCommands) {
         const commands = await this.expandWildcardCommands(initialCommands);
         if (commands.length === 0) {
+            logger_1.default.printLine('No commands to run after wildcard expansion.', 'warn');
             return [];
         }
+        // Initialize logger with the final list of commands
         logger_1.default.setCommands(commands);
+        // Run in parallel or sequential mode
         if (this.options.parallel) {
+            if (this.options.isServerMode) {
+                logger_1.default.printLine('Starting servers in parallel mode', 'info');
+            }
             return this.runParallel(commands);
         }
         else {
+            if (this.options.isServerMode) {
+                logger_1.default.printLine('Starting servers in sequential mode', 'info');
+            }
             return this.runSequential(commands);
         }
     }
     cleanup(signal = 'SIGTERM') {
+        logger_1.default.printLine('Cleaning up child processes...', 'warn');
         this.activeProcesses.forEach((proc, command) => {
             if (proc.pid && !proc.killed) {
                 try {
+                    // Kill process group
                     process.kill(-proc.pid, signal);
+                    logger_1.default.printLine(`Sent ${signal} to process group ${proc.pid} (${command})`, 'info');
                 }
                 catch (e) {
+                    // Fallback if killing group failed
                     try {
                         proc.kill(signal);
+                        logger_1.default.printLine(`Sent ${signal} to process ${proc.pid} (${command})`, 'info');
                     }
                     catch (errInner) {
-                        // Failed to kill
+                        logger_1.default.printLine(`Failed to kill process ${proc.pid} (${command}): ${errInner.message}`, 'error');
                     }
                 }
             }
         });
         this.activeProcesses.clear();
+        // Print server status summary if in server mode
+        if (this.options.isServerMode && this.serverInfo.size > 0) {
+            logger_1.default.printLine('Server shutdown summary:', 'info');
+            this.serverInfo.forEach((info, command) => {
+                const statusColor = info.status === 'running' ? chalk_1.default.green :
+                    info.status === 'error' ? chalk_1.default.red : chalk_1.default.yellow;
+                logger_1.default.printLine(`  ${command}: ${statusColor(info.status)}`, 'info');
+            });
+        }
     }
 }
 exports.Runner = Runner;

package/dist/src/watcher.js

@@ -22,12 +22,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileWatcher = void 0;
 // src/watcher.ts - File watcher for development (nodemon functionality)
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const events_1 = require("events");
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = __importDefault(require("./logger"));
 class FileWatcher extends events_1.EventEmitter {
     constructor(options) {
         super();
@@ -116,7 +121,7 @@ class FileWatcher extends events_1.EventEmitter {
         try {
             const absolutePath = path.resolve(dirPath);
             if (this.options.verbose) {
-                // logger.printLine(`Watching directory: ${chalk.cyan(absolutePath)}`, 'info');
+                logger_1.default.printLine(`Watching directory: ${chalk_1.default.cyan(absolutePath)}`, 'info');
             }
             const watcher = fs.watch(absolutePath, { recursive: true }, async (eventType, filename) => {
                 if (!filename)
@@ -134,7 +139,7 @@ class FileWatcher extends events_1.EventEmitter {
         }
         catch (error) {
             if (this.options.verbose) {
-                // logger.printLine(`Failed to watch directory ${dirPath}: ${(error as Error).message}`, 'warn');
+                logger_1.default.printLine(`Failed to watch directory ${dirPath}: ${error.message}`, 'warn');
             }
         }
     }
@@ -148,7 +153,7 @@ class FileWatcher extends events_1.EventEmitter {
                 return;
             }
             if (this.options.verbose) {
-                // logger.printLine(`Watching file: ${chalk.cyan(absolutePath)}`, 'info');
+                logger_1.default.printLine(`Watching file: ${chalk_1.default.cyan(absolutePath)}`, 'info');
             }
             const watcher = fs.watch(absolutePath, (eventType) => {
                 this.handleFileChange(absolutePath, eventType);
@@ -158,13 +163,13 @@ class FileWatcher extends events_1.EventEmitter {
         }
         catch (error) {
             if (this.options.verbose) {
-                // logger.printLine(`Failed to watch file ${filePath}: ${(error as Error).message}`, 'warn');
+                logger_1.default.printLine(`Failed to watch file ${filePath}: ${error.message}`, 'warn');
             }
         }
     }
     handleFileChange(filePath, eventType) {
         if (this.options.verbose) {
-            // logger.printLine(`File ${eventType}: ${chalk.yellow(path.relative(process.cwd(), filePath))}`, 'info');
+            logger_1.default.printLine(`File ${eventType}: ${chalk_1.default.yellow(path.relative(process.cwd(), filePath))}`, 'info');
         }
         // Debounce file changes
         if (this.debounceTimer) {
@@ -183,6 +188,7 @@ class FileWatcher extends events_1.EventEmitter {
             return;
         }
         this.isWatching = true;
+        logger_1.default.printLine('Starting file watcher...', 'info');
         for (const watchPath of this.options.watch) {
             const absolutePath = path.resolve(watchPath);
             try {
@@ -195,17 +201,20 @@ class FileWatcher extends events_1.EventEmitter {
                 }
             }
             catch (error) {
-                // logger.printLine(`Cannot watch ${watchPath}: ${(error as Error).message}`, 'warn');
+                logger_1.default.printLine(`Cannot watch ${watchPath}: ${error.message}`, 'warn');
             }
         }
         const watchedCount = this.watchers.length;
+        logger_1.default.printLine(`File watcher started. Monitoring ${chalk_1.default.green(watchedCount)} locations`, 'info');
         if (this.options.ext && this.options.ext.length > 0) {
+            logger_1.default.printLine(`Watching extensions: ${chalk_1.default.cyan(this.options.ext.join(', '))}`, 'info');
         }
     }
     stop() {
         if (!this.isWatching) {
             return;
         }
+        logger_1.default.printLine('Stopping file watcher...', 'info');
         this.watchers.forEach(watcher => {
             try {
                 watcher.close();
@@ -221,6 +230,7 @@ class FileWatcher extends events_1.EventEmitter {
             clearTimeout(this.debounceTimer);
             this.debounceTimer = null;
         }
+        logger_1.default.printLine('File watcher stopped', 'info');
     }
     isActive() {
         return this.isWatching;

package/package.json

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