neex 0.1.2 → 0.1.4

package/dist/src/runner.js

@@ -35,6 +35,7 @@ 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"));
+const fs = __importStar(require("fs"));
 class Runner {
     constructor(options) {
         this.activeProcesses = new Map();
@@ -44,6 +45,41 @@ class Runner {
         this.options = options;
         this.activeProcesses = new Map();
     }
+    async expandWildcardCommands(commands) {
+        const expandedCommands = [];
+        let packageJson;
+        try {
+            const packageJsonPath = path.join(process.cwd(), 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const packageJsonContent = await fsPromises.readFile(packageJsonPath, 'utf-8');
+                packageJson = JSON.parse(packageJsonContent);
+            }
+        }
+        catch (error) {
+            logger_1.default.printLine(`Could not read or parse package.json: ${error.message}`, 'warn');
+            packageJson = { scripts: {} };
+        }
+        for (const command of commands) {
+            if (command.includes('*') && packageJson && packageJson.scripts) {
+                const pattern = new RegExp(`^${command.replace(/\*/g, '.*')}$`);
+                let foundMatch = false;
+                for (const scriptName in packageJson.scripts) {
+                    if (pattern.test(scriptName)) {
+                        expandedCommands.push(scriptName); // Or packageJson.scripts[scriptName] if you want the script value
+                        foundMatch = true;
+                    }
+                }
+                if (!foundMatch) {
+                    logger_1.default.printLine(`No scripts found in package.json matching wildcard: ${command}`, 'warn');
+                    expandedCommands.push(command); // Add original command if no match
+                }
+            }
+            else {
+                expandedCommands.push(command);
+            }
+        }
+        return expandedCommands;
+    }
     async resolveScriptAndCwd(scriptNameOrCommand, baseDir) {
         try {
             const packageJsonPath = path.join(baseDir, 'package.json');
@@ -103,7 +139,7 @@ class Runner {
         // Update server info
         this.serverInfo.set(command, serverInfo);
     }
-    async runCommand(originalCommand) {
+    async runCommand(originalCommand, currentRetry = 0) {
         const { executableCommand: command, executionCwd: cwd } = await this.resolveScriptAndCwd(originalCommand, process.cwd());
         const startTime = new Date();
         const result = {
@@ -117,7 +153,8 @@ class Runner {
         if (this.options.printOutput) {
             logger_1.default.printStart(originalCommand);
         }
-        return new Promise((resolve) => {
+        return new Promise(async (resolve) => {
+            var _a, _b;
             const [cmd, ...args] = command.split(' ');
             const env = {
                 ...process.env,
@@ -140,96 +177,93 @@ class Runner {
                     startTime: new Date()
                 });
             }
-            // Capture and display output
-            if (this.options.printOutput) {
-                proc.stdout.on('data', (data) => {
-                    const output = {
-                        command: originalCommand,
-                        type: 'stdout',
-                        data: data.toString(),
-                        timestamp: new Date()
-                    };
-                    if (this.options.isServerMode) {
-                        this.detectServerInfo(originalCommand, data.toString());
-                    }
-                    // Store output for logging
-                    if (result.output)
-                        result.output.push(output);
-                    logger_1.default.bufferOutput(output);
-                    // Print immediately unless we're in group mode
-                    if (!this.options.groupOutput) {
-                        logger_1.default.printBuffer(originalCommand);
-                    }
-                });
-                proc.stderr.on('data', (data) => {
-                    const output = {
-                        command: originalCommand,
-                        type: 'stderr',
-                        data: data.toString(),
-                        timestamp: new Date()
-                    };
-                    // Store output for logging
-                    if (result.output)
-                        result.output.push(output);
-                    logger_1.default.bufferOutput(output);
-                    // Print immediately unless we're in group mode
-                    if (!this.options.groupOutput) {
-                        logger_1.default.printBuffer(originalCommand);
-                    }
-                });
-            }
-            proc.on('close', (code) => {
-                const endTime = new Date();
-                const duration = endTime.getTime() - startTime.getTime();
-                result.endTime = endTime;
-                result.duration = duration;
-                result.code = code;
-                result.success = code === 0;
+            (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                const output = {
+                    command: originalCommand,
+                    type: 'stdout',
+                    data: data.toString(),
+                    timestamp: new Date()
+                };
+                if (this.options.isServerMode)
+                    this.detectServerInfo(originalCommand, data.toString());
+                if (result.output)
+                    result.output.push(output);
+                logger_1.default.bufferOutput(output);
+                if (!this.options.groupOutput && this.options.printOutput)
+                    logger_1.default.printBuffer(originalCommand);
+            });
+            (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                const output = {
+                    command: originalCommand,
+                    type: 'stderr',
+                    data: data.toString(),
+                    timestamp: new Date()
+                };
+                if (result.output)
+                    result.output.push(output);
+                logger_1.default.bufferOutput(output);
+                if (!this.options.groupOutput && this.options.printOutput)
+                    logger_1.default.printBuffer(originalCommand);
+            });
+            proc.on('error', async (err) => {
+                result.endTime = new Date();
+                result.error = err;
+                result.success = false;
+                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';
+                        serverInfo.status = 'error';
                         this.serverInfo.set(originalCommand, serverInfo);
                     }
-                    // If this is server mode and a server failed, print prominent error
-                    if (code !== 0) {
-                        logger_1.default.printLine(`Server ${originalCommand} crashed with code ${code}`, 'error');
-                    }
-                }
-                // Print grouped output at the end if enabled
-                if (this.options.groupOutput && result.output && result.output.length > 0) {
-                    logger_1.default.printBuffer(originalCommand);
+                    logger_1.default.printLine(`Command "${originalCommand}" failed to start: ${err.message}`, 'error');
                 }
-                if (this.options.printOutput) {
-                    if (result.success) {
-                        logger_1.default.printSuccess(result);
-                    }
-                    else {
-                        logger_1.default.printError(result);
+                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));
                     }
+                    logger_1.default.clearBuffer(originalCommand);
+                    resolve(this.runCommand(originalCommand, currentRetry + 1));
+                }
+                else {
+                    resolve(result);
                 }
-                resolve(result);
             });
-            proc.on('error', (error) => {
-                const endTime = new Date();
-                const duration = endTime.getTime() - startTime.getTime();
-                result.endTime = endTime;
-                result.duration = duration;
-                result.error = error;
-                result.success = false;
+            proc.on('close', async (code) => {
+                result.code = code;
+                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 = 'error';
+                        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');
+                    }
                 }
-                if (this.options.printOutput) {
-                    logger_1.default.printError(result);
+                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));
+                    }
+                    logger_1.default.clearBuffer(originalCommand);
+                    resolve(this.runCommand(originalCommand, currentRetry + 1));
+                }
+                else {
+                    resolve(result);
                 }
-                resolve(result);
             });
         });
     }
@@ -238,7 +272,6 @@ class Runner {
         for (const cmd of commands) {
             const result = await this.runCommand(cmd);
             results.push(result);
-            // Stop on error if enabled
             if (!result.success && this.options.stopOnError) {
                 break;
             }
@@ -257,18 +290,19 @@ class Runner {
             });
         }
         catch (error) {
-            // If pMap stops due to stopOnError
             if (this.options.isServerMode) {
                 logger_1.default.printLine('One or more servers failed to start. Stopping all servers.', 'error');
             }
             return [];
         }
     }
-    async run(commands) {
+    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 [];
         }
-        // Set up logger with commands
+        // Initialize logger with the final list of commands
         logger_1.default.setCommands(commands);
         // Run in parallel or sequential mode
         if (this.options.parallel) {

package/dist/src/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDuration = void 0;
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+exports.formatDuration = formatDuration;

package/dist/src/watcher.js

@@ -0,0 +1,245 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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();
+        this.watchers = [];
+        this.watchedFiles = new Set();
+        this.debounceTimer = null;
+        this.isWatching = false;
+        this.ignorePatterns = [];
+        // Initialize with a copy of user-provided options.
+        const processedOptions = { ...options };
+        // Apply defaults if properties were not set in the provided 'options'.
+        if (processedOptions.watch === undefined) {
+            processedOptions.watch = ['./'];
+        }
+        if (processedOptions.ignore === undefined) {
+            processedOptions.ignore = [
+                'node_modules/**',
+                '.git/**',
+                '*.log',
+                'dist/**',
+                'build/**',
+                'coverage/**',
+                '.nyc_output/**',
+                '*.tmp',
+                '*.temp'
+            ];
+        }
+        if (processedOptions.ext === undefined) {
+            processedOptions.ext = ['js', 'mjs', 'json', 'ts', 'tsx', 'jsx'];
+        }
+        if (processedOptions.delay === undefined) {
+            processedOptions.delay = 1000;
+        }
+        if (processedOptions.verbose === undefined) {
+            processedOptions.verbose = false;
+        }
+        if (processedOptions.legacyWatch === undefined) {
+            processedOptions.legacyWatch = false;
+        }
+        if (processedOptions.pollingInterval === undefined) {
+            processedOptions.pollingInterval = 1000;
+        }
+        // 'cwd' and 'env' are optional and don't have explicit defaults in this setup;
+        // they will be taken from 'options' or remain undefined if not provided.
+        this.options = processedOptions;
+        this.setupIgnorePatterns();
+    }
+    setupIgnorePatterns() {
+        this.ignorePatterns = (this.options.ignore || []).map(pattern => {
+            // Convert glob patterns to regex
+            const regexPattern = pattern
+                .replace(/\*\*/g, '.*')
+                .replace(/\*/g, '[^/]*')
+                .replace(/\?/g, '[^/]')
+                .replace(/\./g, '\\.');
+            return new RegExp(regexPattern, 'i');
+        });
+    }
+    shouldIgnoreFile(filePath) {
+        const relativePath = path.relative(process.cwd(), filePath);
+        // Check ignore patterns
+        for (const pattern of this.ignorePatterns) {
+            if (pattern.test(relativePath) || pattern.test(filePath)) {
+                return true;
+            }
+        }
+        // Check file extension
+        if (this.options.ext && this.options.ext.length > 0) {
+            const ext = path.extname(filePath).slice(1);
+            if (!this.options.ext.includes(ext)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async isValidFile(filePath) {
+        try {
+            const stats = await fs.promises.stat(filePath);
+            return stats.isFile();
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async watchDirectory(dirPath) {
+        try {
+            const absolutePath = path.resolve(dirPath);
+            if (this.options.verbose) {
+                logger_1.default.printLine(`Watching directory: ${chalk_1.default.cyan(absolutePath)}`, 'info');
+            }
+            const watcher = fs.watch(absolutePath, { recursive: true }, async (eventType, filename) => {
+                if (!filename)
+                    return;
+                const fullPath = path.join(absolutePath, filename);
+                if (this.shouldIgnoreFile(fullPath)) {
+                    return;
+                }
+                if (!(await this.isValidFile(fullPath))) {
+                    return;
+                }
+                this.handleFileChange(fullPath, eventType);
+            });
+            this.watchers.push(watcher);
+        }
+        catch (error) {
+            if (this.options.verbose) {
+                logger_1.default.printLine(`Failed to watch directory ${dirPath}: ${error.message}`, 'warn');
+            }
+        }
+    }
+    async watchFile(filePath) {
+        try {
+            const absolutePath = path.resolve(filePath);
+            if (this.shouldIgnoreFile(absolutePath)) {
+                return;
+            }
+            if (!(await this.isValidFile(absolutePath))) {
+                return;
+            }
+            if (this.options.verbose) {
+                logger_1.default.printLine(`Watching file: ${chalk_1.default.cyan(absolutePath)}`, 'info');
+            }
+            const watcher = fs.watch(absolutePath, (eventType) => {
+                this.handleFileChange(absolutePath, eventType);
+            });
+            this.watchers.push(watcher);
+            this.watchedFiles.add(absolutePath);
+        }
+        catch (error) {
+            if (this.options.verbose) {
+                logger_1.default.printLine(`Failed to watch file ${filePath}: ${error.message}`, 'warn');
+            }
+        }
+    }
+    handleFileChange(filePath, eventType) {
+        if (this.options.verbose) {
+            logger_1.default.printLine(`File ${eventType}: ${chalk_1.default.yellow(path.relative(process.cwd(), filePath))}`, 'info');
+        }
+        // Debounce file changes
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.emit('change', {
+                path: filePath,
+                event: eventType,
+                relativePath: path.relative(process.cwd(), filePath)
+            });
+        }, this.options.delay);
+    }
+    async start() {
+        if (this.isWatching) {
+            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 {
+                const stats = await fs.promises.stat(absolutePath);
+                if (stats.isDirectory()) {
+                    await this.watchDirectory(absolutePath);
+                }
+                else if (stats.isFile()) {
+                    await this.watchFile(absolutePath);
+                }
+            }
+            catch (error) {
+                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();
+            }
+            catch (error) {
+                // Ignore errors when closing watchers
+            }
+        });
+        this.watchers = [];
+        this.watchedFiles.clear();
+        this.isWatching = false;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        logger_1.default.printLine('File watcher stopped', 'info');
+    }
+    isActive() {
+        return this.isWatching;
+    }
+    getWatchedFiles() {
+        return Array.from(this.watchedFiles);
+    }
+    getOptions() {
+        return { ...this.options };
+    }
+}
+exports.FileWatcher = FileWatcher;

package/package.json

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