neex 0.1.4 → 0.1.6

package/README.md

@@ -6,7 +6,7 @@
 </picture>
 </a>
 
-# Neex v0.1.2
+# Neex v0.1.6
 
 ### 🚀 Neex: The Modern Build System for Polyrepo-in-Monorepo Architecture
 
@@ -20,12 +20,12 @@
 
 next + express = neex 🌱
 
-Neex is a modern build system designed to bridge the gap between polyrepo and monorepo architectures. It provides powerful script execution capabilities with features like parallel processing, colored output, and intelligent build orchestration. Whether you're managing a complex monorepo or coordinating multiple repositories, neex makes your development workflow more efficient and visually organized.
+Neex is a modern build system and script runner designed for **Polyrepo-in-Monorepo** architectures, but powerful enough for any project. It simplifies managing and running multiple scripts across your project, whether they are microservices, frontend applications, or build tasks. Neex offers robust features like parallel and sequential execution, live-reloading for development (`watch`), optimized server running (`servers`), and even basic process management (`pm2`-like commands), all aimed at making your development workflow more efficient, organized, and visually clear.
 
 ## ✨ Key Features
 
 - 🎨 **Colored Output** - Distinguish commands with unique colors
-- ⚡ **Dual Execution Modes** - Run commands in parallel (`p`, `runx`) or sequence (`s`, `run`)
+- ⚡ **Dual Execution Modes** - Run commands in parallel (`px`) or sequence (`s`, `run`)
 - ⏱️ **Smart Timing** - Track execution time for each command
 - 🛑 **Error Control** - Stop on first error (perfect for CI/CD)
 - 🔢 **Parallel Control** - Limit concurrent processes with `--max-parallel`
@@ -34,7 +34,24 @@ Neex is a modern build system designed to bridge the gap between polyrepo and mo
 - 🤫 **Flexible Display** - Control prefixes, timing, and output visibility
 - 🧰 **Node.js API** - Programmatic usage in your applications
 
-## ⚡ Quick Start
+## 🚀 Installation
+
+Install Neex globally to use it anywhere, or locally in your project.
+
+```bash
+# Global install
+npm install -g neex
+
+# Local install
+npm install --save-dev neex    # npm
+yarn add --dev neex          # yarn
+pnpm add --save-dev neex     # pnpm
+bun add --dev neex           # bun
+```
+
+When installed locally, you can run Neex commands using `npx neex ...` or by adding them to your `package.json` scripts.
+
+## 🖥️ Usage
 
 ```bash
 # Global install
@@ -49,35 +66,147 @@ bun add -D neex  # bun
 
 ## 🖥️ Usage
 
-### Commands
+### Core Commands
+
+Neex provides several commands to manage and run your scripts:
+
+- **`px <commands...>`** (*default command*)
+  - Runs specified commands in **parallel** by default.
+  - Use the `-q` or `--sequential` flag to run them sequentially.
+  - Ideal for build steps, tests, or any tasks that can run concurrently.
+
+- **`run <commands...>`** (alias: `s`)
+  - Runs specified commands **sequentially**.
+  - Useful for tasks that depend on the completion of previous ones (e.g., build then deploy).
 
-- `runx` (alias: `p`) - Run in **parallel** (default)
-- `run` (alias: `s`) - Run **sequentially**
+- **`servers <commands...>`** (alias: `srv`)
+  - Optimized for running multiple development **servers** (e.g., backend API, frontend app) in parallel.
+  - Provides grouped and clear output for each server, making it easy to monitor logs.
+  - Detects and displays server ports and URLs.
 
-### Examples
+- **`watch <commands...>`** (alias: `w`)
+  - Runs commands and **watches for file changes** to automatically restart them (Nodemon-like functionality).
+  - Highly configurable with options for watched paths, ignored patterns, extensions, and restart delays.
+  - Perfect for development workflows where you need instant feedback on code changes.
+
+- **Process Management Commands**
+  - Neex provides built-in process management capabilities, similar to PM2, for long-running applications. These commands operate directly under `neex`:
+    - **`start <script_path_or_command> [--name <name>] [--watch] [-- <args...>]`**: Start a new process.
+    - **`stop <name_or_id>`**: Stop a running process.
+    - **`restart <name_or_id>`**: Restart a running process.
+    - **`delete <name_or_id>`**: Stop and delete a process from the list.
+    - **`list`** (aliases: `ls`, `status`): List all managed processes.
+    - **`logs [name_or_id] [--lines <number>] [--follow]`**: Display logs for a specific process or all if no ID is given.
+    - **`monit`**: Launch a monitoring interface for all managed processes.
+    - **`save`**: Save the current list of running processes.
+    - **`resurrect`**: Restart processes that were previously saved.
+    - **`startup`**: Generate a sample startup script (e.g., for systemd).
+
+### General Command Examples
 
 ```bash
-# Parallel execution (default)
-neex p "echo Task 1" "echo Task 2" "echo Task 3"
+# Parallel execution (default behavior for px)
+neex px "npm run build:api" "npm run build:frontend" "npm run lint"
+# px is the command for parallel execution
+neex px "npm run test:unit" "npm run test:integration"
 
 # Sequential execution
-neex s "echo Step 1" "echo Step 2" "echo Step 3"
+neex run "npm run clean" "npm run build" "npm run deploy"
+# Alias for sequential
+neex s "echo First" "echo Second" "echo Third"
+
+# Run 'px' commands sequentially using the -q flag
+neex px -q "npm run step1" "npm run step2"
+```
+
+### `servers` Command Examples
+
+```bash
+# Start frontend and backend development servers
+neex servers "cd frontend && npm start" "cd backend && npm start"
 
-# Parallel with sequential flag
-neex p -q "echo Step 1" "echo Step 2" "echo Step 3"
+# Group output for better readability
+neex servers --group-output "npm run dev:service-a" "npm run dev:service-b"
 ```
 
-### 🛠️ Options
+### `watch` Command Examples
+
+```bash
+# Watch for changes in './src' and restart 'npm run build'
+neex watch "npm run build" -w ./src
+
+# Watch for .ts file changes in 'services/' and restart two commands, ignoring 'node_modules'
+neex watch "npm run start:service1" "npm run start:service2" -w services/ -e ts -i node_modules/**
 
-| Flag | Alias | Description | Default |
-|------|-------|-------------|----------|
-| `--no-color` | `-c` | Disable colors | `false` |
-| `--no-timing` | `-t` | Hide timing | `false` |
-| `--no-prefix` | `-p` | Hide prefixes | `false` |
-| `--stop-on-error` | `-s` | Stop on failure | `false` |
-| `--no-output` | `-o` | Hide all output | `false` |
-| `--max-parallel` | `-m` | Max parallel tasks | CPU count |
-| `--sequential` | `-q` | Force sequential | `false` |
+# Clear console on restart and set a delay
+neex watch "node server.js" --clear --delay 1500
+```
+
+### Process Management Command Examples
+
+```bash
+# Start a Node.js app and give it a name
+neex start server.js --name my-app
+
+# Start an app and watch for file changes
+neex start api/index.js --name my-api --watch
+
+# List all running processes managed by neex
+neex list
+
+# View logs for 'my-app'
+neex logs my-app
+
+# Stop 'my-api'
+neex stop my-api
+
+# Restart 'my-app'
+neex restart my-app
+
+# Delete 'my-api' from neex management
+neex delete my-api
+```
+
+### 🛠️ Global Options (for `run`, `px`, `servers`)
+
+These options can be used with `run`, `px`, and `servers` commands:
+
+| Flag                     | Alias | Description                                       | Default        |
+|--------------------------|-------|---------------------------------------------------|----------------|
+| `--no-color`             | `-c`  | Disable colored output                            | `true` (color on) |
+| `--no-timing`            | `-t`  | Hide timing information for each command          | `true` (timing on) |
+| `--no-prefix`            | `-p`  | Hide command prefix in output                     | `true` (prefix on) |
+| `--stop-on-error`        | `-s`  | Stop all further execution if a command fails     | `false`        |
+| `--no-output`            | `-o`  | Hide all `stdout` and `stderr` from commands      | `true` (output on) |
+| `--minimal`              |       | Use minimal output format (less verbose)          | `false`        |
+| `--max-parallel <number>`|       | Maximum number of commands to run in parallel     | CPU count      |
+| `--sequential`           | `-q`  | (For `px`) Run commands sequentially instead of parallel | `false`        |
+| `--retry <count>`        |       | Number of times to retry a failed command         | `0`            |
+| `--retry-delay <ms>`     |       | Delay in milliseconds between retries             | `1000`         |
+| `--group-output`         | `-g`  | (For `servers`) Group output by server            | `false`        |
+
+### `watch` Command Options
+
+| Flag                        | Alias | Description                                          | Default                                    |
+|-----------------------------|-------|------------------------------------------------------|--------------------------------------------|
+| `--watch <paths...>`        | `-w`  | Paths/glob patterns to watch                         | `['./']`                                   |
+| `--ignore <patterns...>`    | `-i`  | Paths/glob patterns to ignore                        | `['node_modules/**', '.git/**', ...]`       |
+| `--ext <extensions...>`     | `-e`  | File extensions to watch                             | `['js', 'mjs', 'json', 'ts', 'tsx', 'jsx']`|
+| `--delay <ms>`              | `-d`  | Delay in milliseconds before restarting after a change | `1000`                                     |
+| `--clear`                   |       | Clear console on restart                             | `false`                                    |
+| `--verbose`                 |       | Show verbose output from the watcher                 | `false`                                    |
+| `--signal <signal>`         |       | Signal to send to processes on restart               | `SIGTERM`                                  |
+| *Global options also apply* |       | `no-color`, `no-timing`, etc.                        |                                            |
+
+### `start` Command Options
+
+| Flag                        | Description                                      | Default   |
+|-----------------------------|--------------------------------------------------|-----------|
+| `--name <name>`             | Specify a name for the process                   | Script name |
+| `--watch`                   | Enable file watching and auto-restart            | `false`   |
+| `--ignore-watch <paths...>` | Paths/patterns to ignore when watching           |           |
+| `--watch-delay <ms>`        | Delay for watch restarts                         | `1000`    |
+| `-- <args...>`              | Arguments to pass to the script                  |           |
 
 
 ### Advanced Example
@@ -115,17 +244,38 @@ async function main() {
 }
 ```
 
-### API Options
+### API Options (`RunOptions`)
+
+When using Neex programmatically, you can pass an options object to the `run` function:
 
 ```typescript
-interface RunOptions {
-  parallel?: boolean;     // Run in parallel (default: true)
-  maxParallel?: number;  // Max parallel processes (default: CPU count)
-  color?: boolean;       // Enable colors (default: true)
-  prefix?: boolean;      // Show command prefix (default: true)
-  showTiming?: boolean;  // Show timing info (default: true)
-  printOutput?: boolean; // Show command output (default: true)
-  stopOnError?: boolean; // Stop on failure (default: false)
+export interface RunOptions {
+  // Run in parallel or sequentially
+  parallel: boolean;
+  // Maximum number of parallel processes (default: CPU count)
+  maxParallel?: number;
+  // Show command output (default: true)
+  printOutput: boolean;
+  // Color output (default: true)
+  color: boolean;
+  // Show timing information (default: true)
+  showTiming: boolean;
+  // Show command prefix (default: true)
+  prefix: boolean;
+  // Stop on error (default: false)
+  stopOnError: boolean;
+  // Use minimal output format (default: false)
+  minimalOutput: boolean;
+  // Group output by command (default: false, mainly for server mode)
+  groupOutput: boolean;
+  // Use server mode formatting (default: false)
+  isServerMode: boolean;
+  // Number of times to retry a failed command (default: 0)
+  retry?: number;
+  // Delay in milliseconds between retries (default: 1000)
+  retryDelay?: number;
+  // Callback to register a cleanup function, called on SIGINT/SIGTERM
+  registerCleanup?: (cleanupFn: () => void) => void;
 }
 ```
 
@@ -141,17 +291,54 @@ steps:
     run: neex p -s -m 4 "npm run lint" "npm test" "npm run e2e"
 ```
 
-## 💡 Real-world Examples
+## 💡 Real-world Scenarios & `package.json` Integration
+
+Neex shines when integrated into your `package.json` scripts.
+
+**Example `package.json` scripts:**
+
+```json
+{
+  "scripts": {
+    "dev:frontend": "cd packages/frontend && npm run dev",
+    "dev:backend": "cd packages/api && npm run dev",
+    "dev": "neex servers \"npm run dev:frontend\" \"npm run dev:backend\" --group-output",
+
+    "build:ui": "cd packages/ui-library && npm run build",
+    "build:app": "cd packages/main-app && npm run build",
+    "build": "neex runx \"npm run build:ui\" \"npm run build:app\"",
+
+    "test": "neex runx -s \"npm run test:unit\" \"npm run test:e2e\"",
+    "test:unit": "jest",
+    "test:e2e": "playwright test",
+
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "check-all": "neex p \"npm run lint\" \"npm run format -- --check\" \"npm run test\"",
+
+    "start:prod": "neex pm2 start dist/server.js --name my-prod-app",
+    "watch:build": "neex watch \"npm run build:app\" -w packages/main-app/src -e ts,tsx"
+  }
+}
+```
+
+**Running these scripts:**
 
 ```bash
-# Dev servers
-neex p "cd frontend && npm dev" "cd api && npm dev"
+# Start all development servers with grouped output
+npm run dev
+
+# Build UI library and main application in parallel
+npm run build
+
+# Run linters, format check, and all tests in parallel
+npm run check-all
 
-# Monorepo build
-neex p -m 2 "npm run build:ui" "npm run build:api"
+# Start the production application using neex's pm2
+npm run start:prod
 
-# Deploy pipeline
-neex s -s "npm test" "npm run build" "npm run deploy"
+# Watch for changes in the main app's src and rebuild it
+npm run watch:build
 ```
 
 ## 🤝 Contributing

package/dist/src/cli.js

@@ -34,7 +34,49 @@ const process_manager_js_1 = require("./process-manager.js");
 const chalk_1 = __importDefault(require("chalk"));
 const figures_1 = __importDefault(require("figures"));
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises")); // Added for reading package.json
 const { version } = require('../../package.json');
+// Helper function to find default command from package.json
+async function findDefaultCommand() {
+    var _a, _b;
+    try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        await fs.access(packageJsonPath);
+        const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(packageJsonContent);
+        if ((_a = packageJson.scripts) === null || _a === void 0 ? void 0 : _a.dev) {
+            console.log(chalk_1.default.blue(`${figures_1.default.info} No command provided. Using "dev" script from package.json: npm run dev`));
+            return 'npm run dev';
+        }
+        if ((_b = packageJson.scripts) === null || _b === void 0 ? void 0 : _b.start) {
+            console.log(chalk_1.default.blue(`${figures_1.default.info} No command provided. Using "start" script from package.json: npm run start`));
+            return 'npm run start';
+        }
+        if (packageJson.main) {
+            const mainFile = packageJson.main;
+            const mainFilePath = path.resolve(process.cwd(), mainFile);
+            try {
+                await fs.access(mainFilePath);
+                if (mainFile.endsWith('.ts') || mainFile.endsWith('.mts') || mainFile.endsWith('.cts')) {
+                    console.log(chalk_1.default.blue(`${figures_1.default.info} No command or script found. Using "main" field (TypeScript): npx ts-node ${mainFile}`));
+                    return `npx ts-node ${mainFile}`;
+                }
+                else {
+                    console.log(chalk_1.default.blue(`${figures_1.default.info} No command or script found. Using "main" field (JavaScript): node ${mainFile}`));
+                    return `node ${mainFile}`;
+                }
+            }
+            catch (e) {
+                // Main file doesn't exist, do nothing, will fall through to return null
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        // package.json doesn't exist or other error, do nothing
+        return null;
+    }
+}
 function cli() {
     const program = new commander_1.Command();
     let cleanupRunner = null;
@@ -80,9 +122,8 @@ function cli() {
     });
     // runx command: parallel execution by default (with alias 'p'), can run sequentially with -q
     program
-        .command('runx <commands...>', { isDefault: true })
-        .alias('p')
-        .description('Run commands in parallel (default) or sequentially with -q. Alias: p')
+        .command('px <commands...>', { isDefault: true })
+        .description('Run commands in parallel (default) or sequentially with -q. This is the default command.')
         .option('-c, --no-color', 'Disable colored output')
         .option('-t, --no-timing', 'Hide timing information')
         .option('-p, --no-prefix', 'Hide command prefix')
@@ -158,7 +199,7 @@ function cli() {
     });
     // Watch command (Nodemon functionality)
     program
-        .command('watch <commands...>')
+        .command('watch [commands...]') // Made commands optional
         .alias('w')
         .description('Run commands with file watching (nodemon functionality)')
         .option('-c, --no-color', 'Disable colored output')
@@ -176,21 +217,66 @@ function cli() {
         .option('--signal <signal>', 'Signal to send to processes on restart', 'SIGTERM')
         .action(async (commands, options) => {
         try {
-            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting development server with file watching...`));
+            let effectiveCommands = commands;
+            if (!effectiveCommands || effectiveCommands.length === 0) {
+                const foundCommand = await findDefaultCommand();
+                if (foundCommand) {
+                    effectiveCommands = [foundCommand];
+                    console.log(chalk_1.default.blue(`${figures_1.default.info} No command specified for 'neex w', using default: "${foundCommand}"`));
+                }
+                else {
+                    console.error(chalk_1.default.red(`${figures_1.default.cross} No command specified for 'neex w' and no default script (dev, start) or main file found in package.json.`));
+                    console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Please specify a command to run (e.g., neex w "npm run dev") or define a "dev" or "start" script in your package.json.`));
+                    process.exit(1);
+                }
+            }
+            else { // At least one command/argument is provided
+                const firstArg = effectiveCommands[0];
+                const remainingArgs = effectiveCommands.slice(1);
+                const isLikelyCommandOrScript = firstArg.includes(' ') || firstArg.startsWith('npm') || firstArg.startsWith('yarn') || firstArg.startsWith('pnpm');
+                if (!isLikelyCommandOrScript) {
+                    const filePath = path.resolve(process.cwd(), firstArg);
+                    try {
+                        await fs.access(filePath); // Check if file exists
+                        let commandToExecute = '';
+                        if (firstArg.endsWith('.js') || firstArg.endsWith('.mjs') || firstArg.endsWith('.cjs')) {
+                            commandToExecute = `node ${firstArg}`;
+                            console.log(chalk_1.default.blue(`${figures_1.default.info} Detected .js file, prepending with node.`));
+                        }
+                        else if (firstArg.endsWith('.ts') || firstArg.endsWith('.mts') || firstArg.endsWith('.cts')) {
+                            commandToExecute = `npx ts-node ${firstArg}`;
+                            console.log(chalk_1.default.blue(`${figures_1.default.info} Detected .ts file, prepending with npx ts-node.`));
+                        }
+                        if (commandToExecute) {
+                            effectiveCommands = [commandToExecute, ...remainingArgs];
+                            console.log(chalk_1.default.cyan(`${figures_1.default.pointer} Executing: ${effectiveCommands.join(' ')}`));
+                        }
+                        else {
+                            // Not a .js or .ts file, or file doesn't exist but doesn't look like a command either.
+                            // We'll let it try to run as is. If it was meant to be a file, it will likely fail.
+                            // If it was a command like 'echo', it will run.
+                            console.log(chalk_1.default.yellow(`${figures_1.default.warning} First argument "${firstArg}" is not a recognized .js/.ts file and doesn't look like a script. Attempting to run as is.`));
+                        }
+                    }
+                    catch (e) {
+                        // File doesn't exist. Could be a command like 'echo foo' where 'echo' is firstArg.
+                        // Or could be 'my-script --arg' where 'my-script' is not found.
+                        // We'll let it try to run as is. DevRunner will handle if the command is not found.
+                        console.log(chalk_1.default.yellow(`${figures_1.default.warning} File "${firstArg}" not found. Attempting to run as command.`));
+                    }
+                }
+                // If isLikelyCommandOrScript is true, or if the file auto-detection didn't apply,
+                // effectiveCommands remains as the user provided it (joined later by DevRunner).
+            }
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting development server with file watching (neex w) for command(s): ${effectiveCommands.map(cmd => `"${cmd}"`).join(' && ')}...`));
             const watchPaths = options.watch || ['./'];
             const ignorePatterns = options.ignore || [
-                'node_modules/**',
-                '.git/**',
-                '*.log',
-                'dist/**',
-                'build/**',
-                'coverage/**',
-                '.nyc_output/**',
-                '*.tmp',
-                '*.temp'
+                'node_modules/**', '.git/**', '*.log', 'dist/**', 'build/**',
+                'coverage/**', '.nyc_output/**', '*.tmp', '*.temp'
             ];
             const extensions = options.ext || ['js', 'mjs', 'json', 'ts', 'tsx', 'jsx'];
             devRunner = new dev_runner_js_1.DevRunner({
+                runnerName: 'neex w',
                 parallel: false,
                 color: options.color,
                 showTiming: options.timing,
@@ -207,9 +293,9 @@ function cli() {
                 signal: options.signal,
                 restartOnChange: true,
                 groupOutput: false,
-                isServerMode: false // Added missing property
+                isServerMode: false
             });
-            await devRunner.start(commands);
+            await devRunner.start(effectiveCommands);
         }
         catch (error) {
             if (error instanceof Error) {
@@ -221,10 +307,9 @@ function cli() {
             process.exit(1);
         }
     });
-    // PM2-like process management commands
-    const pm2Group = program.command('pm2').description('Process management commands (PM2 alternative)');
+    // Process management commands
     // Start command
-    pm2Group
+    program
         .command('start <script>')
         .description('Start a new process')
         .option('-n, --name <name>', 'Process name')
@@ -270,7 +355,7 @@ function cli() {
         }
     });
     // Stop command
-    pm2Group
+    program
         .command('stop <id>')
         .description('Stop a process')
         .action(async (id) => {
@@ -299,7 +384,7 @@ function cli() {
         }
     });
     // Restart command
-    pm2Group
+    program
         .command('restart <id>')
         .description('Restart a process')
         .action(async (id) => {
@@ -328,7 +413,7 @@ function cli() {
         }
     });
     // Delete command
-    pm2Group
+    program
         .command('delete <id>')
         .description('Delete a process')
         .action(async (id) => {
@@ -357,7 +442,7 @@ function cli() {
         }
     });
     // List/Status command
-    pm2Group
+    program
         .command('list')
         .alias('status')
         .alias('ls')
@@ -403,7 +488,7 @@ function cli() {
         }
     });
     // Logs command
-    pm2Group
+    program
         .command('logs [id]')
         .description('Show process logs')
         .option('-f, --follow', 'Follow log output')
@@ -442,7 +527,7 @@ function cli() {
         }
     });
     // Save command
-    pm2Group
+    program
         .command('save')
         .description('Save current process list')
         .action(async () => {
@@ -465,7 +550,7 @@ function cli() {
         }
     });
     // Startup command (placeholder for system startup configuration)
-    pm2Group
+    program
         .command('startup')
         .description('Generate startup script')
         .action(() => {
@@ -492,7 +577,7 @@ WantedBy=multi-user.target
             `));
     });
     // Resurrect command (start saved processes)
-    pm2Group
+    program
         .command('resurrect')
         .description('Resurrect previously saved processes')
         .action(async () => {
@@ -527,7 +612,7 @@ WantedBy=multi-user.target
         }
     });
     // Monit command (monitoring interface)
-    pm2Group
+    program
         .command('monit')
         .description('Launch monitoring interface')
         .action(async () => {

package/dist/src/dev-runner.js

@@ -44,6 +44,7 @@ class DevRunner {
             ext: ['js', 'mjs', 'json', 'ts', 'tsx', 'jsx'],
             delay: 1000,
             verbose: false,
+            runnerName: 'watch', // Default runner name if not specified
         };
         this.options = {
             ...defaultOptions,
@@ -66,7 +67,8 @@ class DevRunner {
         });
     }
     async handleFileChange(event) {
-        logger_1.default.printLine(`File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        logger_1.default.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
         if (this.options.clearConsole) {
             console.clear();
         }
@@ -87,17 +89,18 @@ class DevRunner {
         }
     }
     printDevBanner() {
-        var _a;
+        var _a, _b;
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
         const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
         const uptimeStr = this.formatUptime(uptime);
-        console.log('\n' + chalk_1.default.bgGreen.black('         DEV MODE         ') + '\n');
+        console.log('\n' + chalk_1.default.bgGreen.black(`    ${(_a = this.options.runnerName) === null || _a === void 0 ? void 0 : _a.toUpperCase()} MODE    `) + '\n');
         if (this.restartCount > 0) {
-            console.log(chalk_1.default.green(`${figures_1.default.arrowUp} Restarted ${this.restartCount} times`));
+            console.log(`${prefix} ${chalk_1.default.green(`${figures_1.default.arrowUp} Restarted ${this.restartCount} times`)}`);
         }
-        console.log(chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`));
-        console.log(chalk_1.default.blue(`${figures_1.default.info} Watching: ${((_a = this.options.watch) === null || _a === void 0 ? void 0 : _a.join(', ')) || 'current directory'}`));
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Watching: ${((_b = this.options.watch) === null || _b === void 0 ? void 0 : _b.join(', ')) || 'current directory'}`)}`);
         if (this.options.ext && this.options.ext.length > 0) {
-            console.log(chalk_1.default.blue(`${figures_1.default.info} Extensions: ${this.options.ext.join(', ')}`));
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Extensions: ${this.options.ext.join(', ')}`)}`);
         }
         console.log('');
     }
@@ -129,18 +132,20 @@ class DevRunner {
             await this.fileWatcher.start();
         }
         // Run initial commands
-        logger_1.default.printLine('Starting development server...', 'info');
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        logger_1.default.printLine(`${prefix} Starting development server...`, 'info');
         await this.runCommands();
         // Set up graceful shutdown
         this.setupGracefulShutdown();
-        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() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
         if (!this.isRunning) {
             return;
         }
-        logger_1.default.printLine('Restarting due to file changes...', 'info');
+        logger_1.default.printLine(`${prefix} Restarting due to file changes...`, 'info');
         this.restartCount++;
         // Stop current processes
         if (this.runner) {
@@ -152,13 +157,14 @@ class DevRunner {
         this.printDevBanner();
         // Run commands again
         await this.runCommands();
-        logger_1.default.printLine('Restart completed. Watching for changes...', 'info');
+        logger_1.default.printLine(`${prefix} Restart completed. Watching for changes...`, 'info');
     }
     async stop() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
         if (!this.isRunning) {
             return;
         }
-        logger_1.default.printLine('Stopping development server...', 'info');
+        logger_1.default.printLine(`${prefix} Stopping development server...`, 'info');
         this.isRunning = false;
         // Stop file watcher
         if (this.fileWatcher) {
@@ -170,9 +176,9 @@ class DevRunner {
         }
         const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
         const uptimeStr = this.formatUptime(uptime);
-        logger_1.default.printLine(`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');
         }
     }
     setupGracefulShutdown() {

package/feet.txt

@@ -0,0 +1,16 @@
+
+نمیشه توی این cli که ترکیب nodemon cuncurently pm2 هست بهش یک قابلیت اضافه کنم که یک چیز شبیه به nginx باشه که اگر بدونی هنگام دیپلوی بهینه pm2 با nginx استفاده میکنن منم میخوام وقتی neex دارن توی حالت production به عنوان pm2 ازش استفاده میکنن یک چیزی باشه که توی پروژه های شبیه به nginx درونی در neex که وظیفه نقش: وب سرور معکوس (Reverse Proxy)
+
+کارهایی که NGINX انجام می‌دهد:
+
+مدیریت درخواست‌ها به پورت 80 یا 443 (HTTP/HTTPS)
+
+به طور پیش‌فرض، اپلیکیشن‌های Node روی پورت‌هایی مثل 3000 یا 5000 کار می‌کنند. NGINX روی پورت‌های استاندارد (مثل 80 برای HTTP) گوش می‌دهد و درخواست‌ها را به اپلیکیشن Node فوروارد می‌کند.  لود بالانسینگ (در صورت نیاز)
+
+اگر چند نسخه از اپلیکیشن را اجرا کرده‌اید (مثلاً با PM2 در حالت cluster)، NGINX می‌تواند بین آن‌ها توزیع بار انجام دهد.
+
+سرویس‌دهی فایل‌های استاتیک
+
+مثلاً فایل‌های HTML، CSS، JS یا تصاویر می‌توانند مستقیماً از طریق NGINX سرو شوند بدون درگیر کردن Node.js.
+
+مثال کانفیگ ساده در /etc/nginx/sites-available/default: این توی پروژه های neex انجام بده  این یک جوری حرفه ای بهش اضافه کن تا به خوبی اتوماتیک این داشته باشه neex 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neex",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -12,7 +12,9 @@
     "start": "node dist/bin/neex.js",
     "prepublishOnly": "npm run build",
     "test": "jest",
-    "test:dev": "node ./dist/bin/neex.js runx \"echo Starting frontend\" \"echo Starting backend\"",
+    "dev": "neex w \"ts-node src/server.ts\"",
+    "w": "neex w \"ts-node src/server.ts\"",
+    "test:dev": "node ./dist/bin/neex.js px \"echo Starting frontend\" \"echo Starting backend\"",
     "test:parallel": "node ./dist/src/cli.js parallel \"echo Building frontend\" \"echo Building backend\"",
     "test:sequence": "node ./dist/src/cli.js run \"echo Step 1\" \"echo Step 2\" \"echo Step 3\""
   },