neex 0.4.4 → 0.5.0

package/README.md

@@ -6,26 +6,26 @@
 </picture>
 </a>
 
-# Neex v0.4.1
+# Neex v0.5.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/neexjs/blob/main/LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-Neex-0066FF.svg?style=for-the-badge&logo=github&labelColor=000000&logoWidth=20&borderRadius=8)](https://github.com/Neexjs)
-
 </div>
 
 ## 🎯 Overview
 
 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`) or sequence (`s`)
+- ⚡ **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,58 +66,155 @@ bun add -D neex  # bun
 
 ## 🖥️ Usage
 
-### Process Management 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).
+
+- **`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.
+
+- **`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
-# Start a process
-neex startx app.js -n "my-app" -w
+# 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"
 
-# startx options
--n, --name <name>           Process name
--w, --watch                 Watch for file changes
--r, --max-restarts <number> Maximum restart attempts
--d, --restart-delay <ms>    Delay between restarts
+# Sequential execution
+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"
+
+# Group output for better readability
+neex servers --group-output "npm run dev:service-a" "npm run dev:service-b"
+```
+
+### `watch` Command Examples
 
-# Stop a process
-neex stopx <process-id>
+```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/**
+
+# Clear console on restart and set a delay
+neex watch "node server.js" --clear --delay 1500
+```
+
+### Process Management Command Examples
 
-# List processes
+```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
-neex list -a               # Show all processes
-neex list -j               # JSON output
 
-# Monitor process
-neex monit <process-id>
-neex monit <process-id> -i 1000  # Set update interval
+# View logs for 'my-app'
+neex logs my-app
+
+# Stop 'my-api'
+neex stop my-api
 
-# View logs
-neex log <process-id>
-neex log <process-id> -f   # Follow logs
-neex log <process-id> -e   # Show only errors
-neex log <process-id> -w   # Show only warnings
+# Restart 'my-app'
+neex restart my-app
+
+# Delete 'my-api' from neex management
+neex delete my-api
 ```
 
-### Script Execution Commands
+### 📚 Examples
+
+### Parallel Execution
 
 ```bash
-# Sequential execution
-neex s "npm install" "npm run build"
+# Parallel execution (default behavior for p)
+neex p "npm run build:api" "npm run build:frontend" "npm run lint"
+neex par "npm run test:unit" "npm run test:integration"
+neex parallel "npm run test:frontend" "npm run test:backend"
+```
+
+### Sequential Execution
+
+```bash
+# Sequential execution using s command
+neex s "npm run clean" "npm run build" "npm run deploy"
+neex seq "echo First" "echo Second" "echo Third"
+neex sequential "npm run step1" "npm run step2" "npm run step3"
+```
+
+### Parallel with Sequential Flag
 
-# Parallel execution
-neex p "npm run dev" "npm run watch"
+```bash
+# Run parallel commands sequentially using the -q flag
+neex p -q "npm run step1" "npm run step2"
+neex par -q "npm run build" "npm run test"
+neex parallel -q "npm run lint" "npm run format"
 ```
 
-### 🛠️ Options
+### Advanced Options
+
+```bash
+# With retry options
+neex p --retry 3 --retry-delay 1000 "npm run test"
 
-| 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` |
+# With output control
+neex s --no-color --no-timing --no-output "npm run build"
+
+# With parallel limits
+neex p --max-parallel 2 "npm run build:frontend" "npm run build:backend" "npm run build:api"
+```
+
+### 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
 
@@ -130,6 +244,41 @@ async function main() {
 }
 ```
 
+### API Options (`RunOptions`)
+
+When using Neex programmatically, you can pass an options object to the `run` function:
+
+```typescript
+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;
+}
+```
+
 ## 🔄 CI/CD Integration
 
 ```yaml
@@ -142,47 +291,55 @@ steps:
     run: neex p -s -m 4 "npm run lint" "npm test" "npm run e2e"
 ```
 
-## 💡 Real-world Examples
+## 💡 Real-world Scenarios & `package.json` Integration
 
-### Multi-part Project Execution
+Neex shines when integrated into your `package.json` scripts.
+
+**Example `package.json` scripts:**
 
 ```json
 {
   "scripts": {
-    "dev": "neex p dev:client dev:server",
-    "dev:client": "cd apps/client && npm run dev",
-    "dev:server": "cd apps/server && npm run dev",
-    "build": "neex s build:client build:server",
-    "build:client": "cd apps/client && npm run build",
-    "build:server": "cd apps/server && npm run build",
-    "start": "neex p start:client start:server",
-    "start:client": "cd apps/client && npm run start",
-    "start:server": "cd apps/server && npm run start"
-  }
-}
-```
+    "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",
 
-### Production Project Management
+    "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\"",
 
-```json
-{
-  "scripts": {
-    "startx": "neex startx:client && neex startx:server",
-    "startx:client": "neex startx apps/client/index.js -n client -w",
-    "startx:server": "neex startx apps/server/index.js -n server -w",
-    "stopx": "neex stopx:client && neex stopx:server",
-    "stopx:client": "neex stopx client",
-    "stopx:server": "neex stopx server"
+    "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"
   }
 }
 ```
 
-## Important Notes
+**Running these scripts:**
+
+```bash
+# Start all development servers with grouped output
+npm run dev
 
-- Logs are stored in the `.neex-logs` directory
-- Configuration is stored in `.neex-config.json`
-- Use `Ctrl+C` to stop live monitoring
-- Use `neex stopx -f` for force stop when needed
+# Build UI library and main application in parallel
+npm run build
+
+# Run linters, format check, and all tests in parallel
+npm run check-all
+
+# Start the production application using neex's pm2
+npm run start:prod
+
+# Watch for changes in the main app's src and rebuild it
+npm run watch:build
+```
 
 ## 🤝 Contributing
 

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,50 @@
+"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 - Main CLI file (refactored)
+const commander_1 = require("commander");
+const index_js_1 = require("./commands/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();
+    // Initialize cleanup handlers
+    const cleanupHandlers = [];
+    program
+        .name('neex')
+        .description('Professional script runner with nodemon and PM2 functionality')
+        .version(version);
+    // Add all command groups
+    (0, index_js_1.addRunCommands)(program);
+    (0, index_js_1.addServerCommands)(program);
+    const devCommands = (0, index_js_1.addDevCommands)(program);
+    cleanupHandlers.push(devCommands.cleanupDev);
+    const processCommands = (0, index_js_1.addProcessCommands)(program);
+    cleanupHandlers.push(processCommands.cleanupProcess);
+    program.parse(process.argv);
+    // Show help if no commands specified
+    if (program.args.length === 0) {
+        program.help();
+    }
+    // Graceful shutdown handling
+    const handleSignal = async (signal) => {
+        console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Cleaning up...`)}`);
+        // Run all cleanup handlers
+        for (const cleanup of cleanupHandlers) {
+            try {
+                await cleanup();
+            }
+            catch (error) {
+                console.error(`Cleanup error:`, error);
+            }
+        }
+        setTimeout(() => process.exit(0), 500);
+    };
+    process.on('SIGINT', () => handleSignal('SIGINT').catch(err => console.error('SIGINT handler error:', err)));
+    process.on('SIGTERM', () => handleSignal('SIGTERM').catch(err => console.error('SIGTERM handler error:', err)));
+    process.on('SIGQUIT', () => handleSignal('SIGQUIT').catch(err => console.error('SIGQUIT handler error:', err)));
+}
+exports.default = cli;

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

@@ -0,0 +1,190 @@
+"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.addDevCommands = void 0;
+const dev_runner_js_1 = require("../dev-runner.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+// 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 addDevCommands(program) {
+    let devRunner = null;
+    // Dev command (Nodemon functionality - formerly watch)
+    program
+        .command('dev [commands...]') // Made commands optional
+        .alias('d')
+        .description('Run commands with file watching and auto-restart (nodemon functionality)')
+        .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('-w, --watch <paths...>', 'Paths to watch (default: current directory)')
+        .option('-i, --ignore <patterns...>', 'Patterns to ignore')
+        .option('-e, --ext <extensions...>', 'File extensions to watch (default: js,mjs,json,ts,tsx,jsx)')
+        .option('-d, --delay <ms>', 'Delay before restart in milliseconds', parseInt)
+        .option('--clear', 'Clear console on restart')
+        .option('--verbose', 'Verbose output')
+        .option('--signal <signal>', 'Signal to send to processes on restart', 'SIGTERM')
+        .action(async (commands, options) => {
+        try {
+            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 dev', using default: "${foundCommand}"`));
+                }
+                else {
+                    console.error(chalk_1.default.red(`${figures_1.default.cross} No command specified for 'neex dev' 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 dev "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 {
+                            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) {
+                        console.log(chalk_1.default.yellow(`${figures_1.default.warning} File "${firstArg}" not found. Attempting to run as command.`));
+                    }
+                }
+            }
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting development server with file watching (neex dev) 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'
+            ];
+            const extensions = options.ext || ['js', 'mjs', 'json', 'ts', 'tsx', 'jsx'];
+            devRunner = new dev_runner_js_1.DevRunner({
+                runnerName: 'neex dev',
+                parallel: false,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: options.output,
+                minimalOutput: options.minimal,
+                watch: watchPaths,
+                ignore: ignorePatterns,
+                ext: extensions,
+                delay: options.delay || 1000,
+                clearConsole: options.clear,
+                verbose: options.verbose,
+                signal: options.signal,
+                restartOnChange: true,
+                groupOutput: false,
+                isServerMode: false
+            });
+            await devRunner.start(effectiveCommands);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Dev Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown dev error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // Return cleanup function for dev runner
+    return {
+        getDevRunner: () => devRunner,
+        cleanupDev: () => {
+            if (devRunner && devRunner.isActive()) {
+                devRunner.stop();
+            }
+        }
+    };
+}
+exports.addDevCommands = addDevCommands;

package/dist/src/commands/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/commands/index.ts - Export all commands
+__exportStar(require("./run-commands.js"), exports);
+__exportStar(require("./dev-commands.js"), exports);
+__exportStar(require("./process-commands.js"), exports);
+__exportStar(require("./server-commands.js"), exports);