neex 0.1.0

package/README.md

@@ -0,0 +1,161 @@
+<div align="center">
+ <a href="https://github.com/Nextpress-cc">
+<picture>
+<source media="(prefers-color-scheme: dark)" srcset="https://foshati.storage.c2.liara.space/Nextpress.png">
+<img alt="Nextpress logo" src="https://foshati.storage.c2.liara.space/Nextpress.png" height="150" style="border-radius: 12px;">
+</picture>
+</a>
+
+# Neex v0.1.0
+
+### 🚀 Neex: The Modern Build System for Polyrepo-in-Monorepo Architecture
+
+[![NPM version](https://img.shields.io/npm/v/neex.svg?style=for-the-badge&labelColor=000000&color=0066FF&borderRadius=8)](https://www.npmjs.com/package/neex)
+[![Download Count](https://img.shields.io/npm/dt/neex.svg?style=for-the-badge&labelColor=000000&color=0066FF&borderRadius=8)](https://www.npmjs.com/package/neex)
+[![MIT License](https://img.shields.io/badge/license-MIT-0066FF.svg?style=for-the-badge&labelColor=000000&borderRadius=8)](https://github.com/Nextpress-cc/neex/blob/main/LICENSE)
+[![GitHub](https://img.shields.io/badge/GitHub-Nextpress-0066FF.svg?style=for-the-badge&logo=github&labelColor=000000&logoWidth=20&borderRadius=8)](https://github.com/Nextpress-cc)
+</div>
+
+## 🎯 Overview
+
+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.
+
+## ✨ Key Features
+
+- 🎨 **Colored Output** - Distinguish commands with unique colors
+- ⚡ **Dual Execution Modes** - Run commands in parallel (`p`, `runx`) 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`
+- 💻 **Clean Output** - Structured and readable command output
+- 🛡️ **Safe Shutdown** - Graceful process termination on interrupt
+- 🤫 **Flexible Display** - Control prefixes, timing, and output visibility
+- 🧰 **Node.js API** - Programmatic usage in your applications
+
+## ⚡ Quick Start
+
+```bash
+# Global install
+npm i -g neex
+
+# Local install
+npm i -D neex    # npm
+yarn add -D neex # yarn
+pnpm add -D neex # pnpm
+bun add -D neex  # bun
+```
+
+## 🖥️ Usage
+
+### Commands
+
+- `runx` (alias: `p`) - Run in **parallel** (default)
+- `run` (alias: `s`) - Run **sequentially**
+
+### Examples
+
+```bash
+# Parallel execution (default)
+neex p "echo Task 1" "echo Task 2" "echo Task 3"
+
+# Sequential execution
+neex s "echo Step 1" "echo Step 2" "echo Step 3"
+
+# Parallel with sequential flag
+neex p -q "echo Step 1" "echo Step 2" "echo Step 3"
+```
+
+### 🛠️ Options
+
+| 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` |
+
+
+### Advanced Example
+
+```bash
+# Run tests & build with max 2 parallel tasks, stop on error
+neex p -s -m 2 -t "npm test" "npm run build" "npm run lint"
+```
+
+## 📦 Node.js API
+
+```javascript
+import { run } from 'neex';
+// or: const { run } = require('neex');
+
+async function main() {
+  try {
+    // Sequential execution
+    await run(['echo Step 1', 'echo Step 2'], {
+      parallel: false,
+      stopOnError: true,
+      color: true
+    });
+
+    // Parallel execution (max 2)
+    await run(['npm test', 'npm run build'], {
+      parallel: true,
+      maxParallel: 2,
+      stopOnError: true
+    });
+  } catch (error) {
+    console.error('Failed:', error);
+    process.exit(1);
+  }
+}
+```
+
+### API Options
+
+```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)
+}
+```
+
+## 🔄 CI/CD Integration
+
+```yaml
+# GitHub Actions example
+steps:
+  - name: Test & Build
+    run: neex s -s "npm test" "npm run build"
+
+  - name: Parallel Tasks
+    run: neex p -s -m 4 "npm run lint" "npm test" "npm run e2e"
+```
+
+## 💡 Real-world Examples
+
+```bash
+# Dev servers
+neex p "cd frontend && npm dev" "cd api && npm dev"
+
+# Monorepo build
+neex p -m 2 "npm run build:ui" "npm run build:api"
+
+# Deploy pipeline
+neex s -s "npm test" "npm run build" "npm run deploy"
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Check our [issues page](https://github.com/Nextpress-cc/neex/issues).
+
+## 📄 License
+
+MIT

package/bin/neex.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+require('../src/cli').default();
+
+// src/types.ts
+export interface RunOptions {
+    // اجرای موازی یا ترتیبی
+    parallel: boolean;
+    // حداکثر تعداد اجرای همزمان در حالت موازی
+    maxParallel?: number;
+    // نمایش خروجی هر دستور
+    printOutput: boolean;
+    // رنگی کردن خروجی
+    color: boolean;
+    // نمایش زمان اجرا
+    showTiming: boolean;
+    // نمایش نام اسکریپت در کنار خروجی
+    prefix: boolean;
+    // اگر خطا رخ دهد اجرای بقیه دستورات متوقف شود
+    stopOnError: boolean;
+}
+
+export interface RunResult {
+    command: string;
+    success: boolean;
+    code: number | null;
+    startTime: Date;
+    endTime: Date | null;
+    duration?: number;
+    error?: Error;
+}
+
+export interface CommandOutput {
+    command: string;
+    type: 'stdout' | 'stderr';
+    data: string;
+    timestamp: Date;
+}

package/dist/bin/neex.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require('../src/cli').default();

package/dist/src/cli.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/cli.ts - Updated version
+const commander_1 = require("commander");
+const index_js_1 = require("./index.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const { version } = require('../../package.json');
+function cli() {
+    const program = new commander_1.Command();
+    let cleanupRunner = null;
+    program
+        .name('neex')
+        .description('Professional script runner with beautiful colored output')
+        .version(version);
+    // Main command for sequential execution (similar to run-s)
+    program
+        .command('run <commands...>')
+        .alias('s')
+        .description('Run commands sequentially')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-p, --no-prefix', 'Hide command prefix')
+        .option('-s, --stop-on-error', 'Stop on first error')
+        .option('-o, --no-output', 'Hide command output')
+        .option('-m, --minimal', 'Use minimal output format')
+        .action(async (commands, options) => {
+        try {
+            await (0, index_js_1.run)(commands, {
+                parallel: false,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: options.output,
+                minimalOutput: options.minimal,
+                registerCleanup: (cleanup) => { cleanupRunner = cleanup; }
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // 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')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-p, --no-prefix', 'Hide command prefix')
+        .option('-s, --stop-on-error', 'Stop on first error')
+        .option('-o, --no-output', 'Hide command output')
+        .option('-m, --minimal', 'Use minimal output format')
+        .option('-x, --max-parallel <number>', 'Maximum number of parallel processes', parseInt)
+        .option('-q, --sequential', 'Run commands sequentially instead of in parallel')
+        .action(async (commands, options) => {
+        try {
+            await (0, index_js_1.run)(commands, {
+                parallel: !options.sequential,
+                maxParallel: options.maxParallel,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: options.output,
+                minimalOutput: options.minimal,
+                registerCleanup: (cleanup) => { cleanupRunner = cleanup; }
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // Add a new servers command specifically optimized for running web servers
+    program
+        .command('servers <commands...>')
+        .alias('srv')
+        .description('Run multiple servers with optimized output for API, frontend, etc.')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-p, --no-prefix', 'Hide command prefix')
+        .option('-s, --stop-on-error', 'Stop when any server crashes')
+        .option('-x, --max-parallel <number>', 'Maximum number of parallel servers', parseInt)
+        .option('-g, --group-output', 'Group outputs by server')
+        .action(async (commands, options) => {
+        try {
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting servers in parallel mode...`));
+            await (0, index_js_1.run)(commands, {
+                parallel: true,
+                maxParallel: options.maxParallel,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: true,
+                registerCleanup: (cleanup) => { cleanupRunner = cleanup; },
+                groupOutput: options.groupOutput,
+                isServerMode: true // Special flag for server mode formatting
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Server Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown server error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    program.parse(process.argv);
+    // Show help if no commands specified
+    if (program.args.length === 0) {
+        program.help();
+    }
+    // Graceful shutdown handling
+    const handleSignal = (signal) => {
+        console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Cleaning up...`)}`);
+        if (cleanupRunner) {
+            cleanupRunner();
+        }
+        // Give cleanup a moment, then exit
+        setTimeout(() => process.exit(0), 500);
+    };
+    process.on('SIGINT', () => handleSignal('SIGINT')); // Ctrl+C
+    process.on('SIGTERM', () => handleSignal('SIGTERM'));
+    process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
+}
+exports.default = cli;

package/dist/src/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServers = exports.runSequential = exports.runParallel = exports.run = void 0;
+// src/index.ts - Updated version
+const runner_1 = require("./runner");
+const logger_1 = __importDefault(require("./logger"));
+/**
+ * Run one or more commands in parallel or sequentially
+ */
+async function run(commands, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const cmdArray = Array.isArray(commands) ? commands : [commands];
+    const runOptions = {
+        parallel: (_a = options === null || options === void 0 ? void 0 : options.parallel) !== null && _a !== void 0 ? _a : false,
+        maxParallel: options === null || options === void 0 ? void 0 : options.maxParallel,
+        printOutput: (_b = options === null || options === void 0 ? void 0 : options.printOutput) !== null && _b !== void 0 ? _b : true,
+        color: (_c = options === null || options === void 0 ? void 0 : options.color) !== null && _c !== void 0 ? _c : true,
+        showTiming: (_d = options === null || options === void 0 ? void 0 : options.showTiming) !== null && _d !== void 0 ? _d : true,
+        prefix: (_e = options === null || options === void 0 ? void 0 : options.prefix) !== null && _e !== void 0 ? _e : true,
+        stopOnError: (_f = options === null || options === void 0 ? void 0 : options.stopOnError) !== null && _f !== void 0 ? _f : false,
+        minimalOutput: (_g = options === null || options === void 0 ? void 0 : options.minimalOutput) !== null && _g !== void 0 ? _g : false,
+        groupOutput: (_h = options === null || options === void 0 ? void 0 : options.groupOutput) !== null && _h !== void 0 ? _h : false,
+        isServerMode: (_j = options === null || options === void 0 ? void 0 : options.isServerMode) !== null && _j !== void 0 ? _j : false
+    };
+    const runner = new runner_1.Runner(runOptions);
+    if (options === null || options === void 0 ? void 0 : options.registerCleanup) {
+        options.registerCleanup(() => runner.cleanup());
+    }
+    const results = await runner.run(cmdArray);
+    if (runOptions.printOutput && cmdArray.length > 1) {
+        logger_1.default.printSummary(results);
+    }
+    return results;
+}
+exports.run = run;
+/**
+ * Run multiple commands in parallel
+ */
+async function runParallel(commands, options) {
+    return run(commands, { ...options, parallel: true });
+}
+exports.runParallel = runParallel;
+/**
+ * Run multiple commands sequentially
+ */
+async function runSequential(commands, options) {
+    return run(commands, { ...options, parallel: false });
+}
+exports.runSequential = runSequential;
+/**
+ * Run multiple servers with optimized output
+ */
+async function runServers(commands, options) {
+    return run(commands, {
+        ...options,
+        parallel: true,
+        isServerMode: true,
+        printOutput: true
+    });
+}
+exports.runServers = runServers;
+exports.default = {
+    run,
+    runParallel,
+    runSequential,
+    runServers
+};

package/dist/src/logger.js

@@ -0,0 +1,237 @@
+"use strict";
+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"));
+class Logger {
+    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) {
+            Logger.instance = new 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('         Nextpress         ') + '\n');
+    }
+    setCommands(commands) {
+        // Clear any existing spinner intervals
+        this.stopAllSpinners();
+        // Show NextPress 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, []);
+            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
+    }
+    generateColor(command) {
+        // Generate distinct colors for commands based on the command string
+        const vibrantColors = [
+            '#00BFFF',
+            '#32CD32',
+            '#FF6347',
+            '#9370DB',
+            '#FF8C00',
+            '#20B2AA',
+            '#0066FF',
+            '#4169E1',
+            '#FFD700',
+            '#8A2BE2' // Blue Violet
+        ];
+        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) {
+        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) || [];
+        currentBuffer.push(output);
+        this.outputBuffer.set(output.command, currentBuffer);
+    }
+    printBuffer(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, []);
+    }
+    printLine(message, level = 'info') {
+        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(`${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;
+        this.stopSpinner(command);
+        const prefix = this.formatPrefix(command);
+        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, error, code, duration } = result;
+        this.stopSpinner(command);
+        const prefix = this.formatPrefix(command);
+        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)}`);
+        }
+    }
+    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}`);
+            });
+        }
+    }
+}
+exports.default = Logger.getInstance();

package/dist/src/runner.js

@@ -0,0 +1,320 @@
+"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.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"));
+class Runner {
+    constructor(options) {
+        this.activeProcesses = new Map();
+        this.serverInfo = new Map();
+        this.portRegex = /listening on (?:port |http:\/\/localhost:|https:\/\/localhost:)(\d+)/i;
+        this.urlRegex = /(https?:\/\/localhost:[0-9]+(?:\/[^\s]*)?)/i;
+        this.options = options;
+        this.activeProcesses = new Map();
+    }
+    async resolveScriptAndCwd(scriptNameOrCommand, baseDir) {
+        try {
+            const packageJsonPath = path.join(baseDir, 'package.json');
+            const packageJsonContent = await fsPromises.readFile(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(packageJsonContent);
+            if (packageJson.scripts && packageJson.scripts[scriptNameOrCommand]) {
+                const scriptValue = packageJson.scripts[scriptNameOrCommand];
+                const cdMatch = scriptValue.match(/^cd\s+([^&]+)\s+&&\s+(.*)$/);
+                if (cdMatch) {
+                    const dir = cdMatch[1];
+                    const commandToExecute = cdMatch[2];
+                    const targetCwd = path.resolve(baseDir, dir);
+                    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 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 = {
+                name: command,
+                status: 'starting'
+            };
+            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) {
+        const { executableCommand: command, executionCwd: cwd } = await this.resolveScriptAndCwd(originalCommand, process.cwd());
+        const startTime = new Date();
+        const result = {
+            command: originalCommand,
+            success: false,
+            code: null,
+            startTime,
+            endTime: null,
+            output: []
+        };
+        if (this.options.printOutput) {
+            logger_1.default.printStart(originalCommand);
+        }
+        return new Promise((resolve) => {
+            const [cmd, ...args] = command.split(' ');
+            const env = {
+                ...process.env,
+                ...npm_run_path_1.default.env(),
+                FORCE_COLOR: this.options.color ? '1' : '0'
+            };
+            const proc = (0, child_process_1.spawn)(cmd, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+                env,
+                detached: true,
+                cwd
+            });
+            this.activeProcesses.set(originalCommand, proc);
+            if (this.options.isServerMode) {
+                this.serverInfo.set(originalCommand, {
+                    name: originalCommand,
+                    status: 'starting',
+                    pid: proc.pid,
+                    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;
+                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 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);
+                }
+                if (this.options.printOutput) {
+                    if (result.success) {
+                        logger_1.default.printSuccess(result);
+                    }
+                    else {
+                        logger_1.default.printError(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;
+                this.activeProcesses.delete(originalCommand);
+                if (this.options.isServerMode) {
+                    const serverInfo = this.serverInfo.get(originalCommand);
+                    if (serverInfo) {
+                        serverInfo.status = 'error';
+                        this.serverInfo.set(originalCommand, serverInfo);
+                    }
+                }
+                if (this.options.printOutput) {
+                    logger_1.default.printError(result);
+                }
+                resolve(result);
+            });
+        });
+    }
+    async runSequential(commands) {
+        const results = [];
+        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;
+            }
+        }
+        return results;
+    }
+    async runParallel(commands) {
+        const concurrency = this.options.maxParallel || commands.length;
+        const mapper = async (cmd) => {
+            return this.runCommand(cmd);
+        };
+        try {
+            return await (0, p_map_1.default)(commands, mapper, {
+                concurrency,
+                stopOnError: this.options.stopOnError
+            });
+        }
+        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) {
+        if (commands.length === 0) {
+            return [];
+        }
+        // Set up logger with 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) {
+                        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/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "neex",
+  "version": "0.1.0",
+  "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "neex": "./dist/bin/neex.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "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\"",
+    "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\""
+  },
+  "keywords": [
+    "npm",
+    "run",
+    "script",
+    "parallel",
+    "sequential",
+    "command",
+    "cli"
+  ],
+  "author": "foshati",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^9.4.0",
+    "figlet": "^1.8.1",
+    "figures": "^3.2.0",
+    "gradient-string": "^3.0.0",
+    "npm-run-path": "^4.0.1",
+    "p-map": "^4.0.0",
+    "string-width": "^4.2.3"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/jest": "^29.2.3",
+    "@types/node": "^18.11.9",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Nextpress-cc"
+  }
+}