neex 0.2.7 → 0.2.9

package/dist/src/process-manager.js

@@ -1,18 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processManager = void 0;
 const child_process_1 = require("child_process");
 const chokidar_1 = require("chokidar");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
 const events_1 = require("events");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const child_process_2 = require("child_process");
 class ProcessManager extends events_1.EventEmitter {
     constructor() {
         super();
         this.processes = new Map();
         this.watchers = new Map();
         this.defaultMaxRestarts = 5;
-        this.defaultRestartDelay = 1000; // 1 second
+        this.defaultRestartDelay = 1000;
         this.logDir = (0, path_1.resolve)(process.cwd(), '.neex-logs');
         this.configFile = (0, path_1.resolve)(process.cwd(), '.neex-config.json');
         this.initialize();
@@ -33,27 +39,26 @@ class ProcessManager extends events_1.EventEmitter {
         const config = Object.fromEntries(this.processes);
         (0, fs_1.writeFileSync)(this.configFile, JSON.stringify(config, null, 2));
     }
-    generateId() {
-        return Math.random().toString(36).substring(2, 15);
+    generateName(command) {
+        const baseName = command.split(' ')[0].replace(/[^a-zA-Z0-9]/g, '');
+        const timestamp = Date.now().toString(36);
+        return `${baseName}-${timestamp}`;
     }
-    getLogPath(id) {
-        return (0, path_1.join)(this.logDir, `${id}.log`);
+    getLogPath(name) {
+        return (0, path_1.join)(this.logDir, `${name}.log`);
     }
-    async startx(path, options = {}) {
-        const id = this.generateId();
-        const name = options.name || `process-${id}`;
-        const fullPath = (0, path_1.resolve)(process.cwd(), path);
-        if (!(0, fs_1.existsSync)(fullPath)) {
-            throw new Error(`Path ${path} does not exist`);
+    async startx(command, options = {}) {
+        const name = options.name || this.generateName(command);
+        const cwd = options.cwd || process.cwd();
+        if (this.processes.has(name)) {
+            throw new Error(`Process with name ${name} already exists`);
         }
         const processInfo = {
-            id,
             name,
             pid: 0,
             status: 'stopped',
             startTime: Date.now(),
-            path: fullPath,
-            command: `node ${fullPath}`,
+            command,
             logs: [],
             memory: 0,
             cpu: 0,
@@ -61,7 +66,8 @@ class ProcessManager extends events_1.EventEmitter {
             restarts: 0,
             maxRestarts: options.maxRestarts || this.defaultMaxRestarts,
             restartDelay: options.restartDelay || this.defaultRestartDelay,
-            watch: options.watch
+            watch: options.watch,
+            cwd
         };
         try {
             await this.startProcess(processInfo);
@@ -70,56 +76,60 @@ class ProcessManager extends events_1.EventEmitter {
         catch (error) {
             processInfo.status = 'error';
             processInfo.lastError = error.message;
-            this.processes.set(id, processInfo);
+            this.processes.set(name, processInfo);
             this.saveConfig();
             throw error;
         }
     }
     async startProcess(processInfo) {
         var _a, _b;
-        const child = (0, child_process_1.spawn)('node', [processInfo.path], {
+        const [cmd, ...args] = processInfo.command.split(' ');
+        const child = (0, child_process_1.spawn)(cmd, args, {
             stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env, NODE_ENV: 'production' }
+            env: { ...process.env, NODE_ENV: 'production' },
+            cwd: processInfo.cwd,
+            shell: true
         });
         processInfo.pid = child.pid || 0;
         processInfo.status = 'running';
         processInfo.startTime = Date.now();
         // Setup logging
-        const logStream = (0, fs_1.writeFileSync)(this.getLogPath(processInfo.id), '', { flag: 'a' });
+        (0, fs_1.writeFileSync)(this.getLogPath(processInfo.name), '', { flag: 'a' });
         (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
             const log = data.toString();
             processInfo.logs.push(log);
-            (0, fs_1.writeFileSync)(this.getLogPath(processInfo.id), log, { flag: 'a' });
-            this.emit('log', { id: processInfo.id, log });
+            (0, fs_1.writeFileSync)(this.getLogPath(processInfo.name), log, { flag: 'a' });
+            this.emit('log', { name: processInfo.name, log });
         });
         (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
             const log = data.toString();
             processInfo.logs.push(log);
-            (0, fs_1.writeFileSync)(this.getLogPath(processInfo.id), log, { flag: 'a' });
-            this.emit('error', { id: processInfo.id, log });
+            (0, fs_1.writeFileSync)(this.getLogPath(processInfo.name), log, { flag: 'a' });
+            this.emit('error', { name: processInfo.name, log });
         });
         // Setup monitoring
-        if (processInfo.watch) {
-            const watcher = (0, chokidar_1.watch)(processInfo.path, {
+        if (processInfo.watch && processInfo.cwd) {
+            const watcher = (0, chokidar_1.watch)(processInfo.cwd, {
                 ignored: /(^|[\/\\])\../,
                 persistent: true
             });
             watcher.on('change', () => {
-                this.restart(processInfo.id);
+                this.restart(processInfo.name);
             });
-            this.watchers.set(processInfo.id, watcher);
+            this.watchers.set(processInfo.name, watcher);
         }
         // Monitor process
         const monitorInterval = setInterval(() => {
             if (child.pid) {
                 try {
-                    const stats = process.memoryUsage();
-                    processInfo.memory = stats.heapUsed / 1024 / 1024; // MB
+                    const stats = this.getProcessStats(child.pid);
+                    processInfo.memory = stats.memory;
+                    processInfo.cpu = stats.cpu;
                     processInfo.uptime = (Date.now() - processInfo.startTime) / 1000;
-                    this.emit('stats', { id: processInfo.id, stats: processInfo });
+                    this.emit('stats', { name: processInfo.name, stats: processInfo });
                 }
                 catch (error) {
-                    console.error(`Error monitoring process ${processInfo.id}:`, error);
+                    console.error(`Error monitoring process ${processInfo.name}:`, error);
                 }
             }
         }, 1000);
@@ -128,17 +138,16 @@ class ProcessManager extends events_1.EventEmitter {
             if (code !== 0) {
                 processInfo.status = 'error';
                 processInfo.lastError = `Process exited with code ${code}`;
-                this.emit('error', { id: processInfo.id, code });
-                // Auto-restart logic
+                this.emit('error', { name: processInfo.name, code });
                 if (processInfo.restarts < processInfo.maxRestarts) {
                     processInfo.status = 'restarting';
-                    this.emit('restart', { id: processInfo.id, attempt: processInfo.restarts + 1 });
+                    this.emit('restart', { name: processInfo.name, attempt: processInfo.restarts + 1 });
                     await new Promise(resolve => setTimeout(resolve, processInfo.restartDelay));
                     processInfo.restarts++;
                     await this.startProcess(processInfo);
                 }
                 else {
-                    this.emit('max-restarts', { id: processInfo.id, maxRestarts: processInfo.maxRestarts });
+                    this.emit('max-restarts', { name: processInfo.name, maxRestarts: processInfo.maxRestarts });
                 }
             }
             else {
@@ -146,63 +155,104 @@ class ProcessManager extends events_1.EventEmitter {
             }
             this.saveConfig();
         });
-        this.processes.set(processInfo.id, processInfo);
+        this.processes.set(processInfo.name, processInfo);
         this.saveConfig();
-        this.emit('start', { id: processInfo.id, processInfo });
+        this.emit('start', { name: processInfo.name, processInfo });
     }
-    async stopx(id) {
-        const processInfo = this.processes.get(id);
+    getProcessStats(pid) {
+        try {
+            const stats = (0, child_process_2.execSync)(`ps -p ${pid} -o %mem,%cpu`).toString().split('\n')[1].trim().split(/\s+/);
+            return {
+                memory: parseFloat(stats[0]),
+                cpu: parseFloat(stats[1])
+            };
+        }
+        catch (_a) {
+            return { memory: 0, cpu: 0 };
+        }
+    }
+    async stopx(name) {
+        const processInfo = this.processes.get(name);
         if (!processInfo) {
-            throw new Error(`Process ${id} not found`);
+            throw new Error(`Process ${name} not found`);
         }
         try {
             process.kill(processInfo.pid);
-            const watcher = this.watchers.get(id);
+            const watcher = this.watchers.get(name);
             if (watcher) {
                 watcher.close();
-                this.watchers.delete(id);
+                this.watchers.delete(name);
             }
-            this.processes.delete(id);
+            this.processes.delete(name);
             this.saveConfig();
-            this.emit('stop', { id });
+            this.emit('stop', { name });
         }
         catch (error) {
-            throw new Error(`Failed to stop process ${id}: ${error.message}`);
+            throw new Error(`Failed to stop process ${name}: ${error.message}`);
         }
     }
     list() {
-        return Array.from(this.processes.values());
+        const table = new cli_table3_1.default({
+            head: ['Name', 'Status', 'PID', 'Memory', 'CPU', 'Uptime', 'Restarts'],
+            style: { head: ['cyan'] }
+        });
+        Array.from(this.processes.values()).forEach(process => {
+            const statusColor = process.status === 'running' ? 'green' :
+                process.status === 'error' ? 'red' :
+                    process.status === 'restarting' ? 'yellow' : 'gray';
+            table.push([
+                process.name,
+                chalk_1.default[statusColor](process.status),
+                process.pid || '-',
+                `${process.memory.toFixed(2)}MB`,
+                `${process.cpu.toFixed(1)}%`,
+                `${Math.floor(process.uptime)}s`,
+                `${process.restarts}/${process.maxRestarts}`
+            ]);
+        });
+        return table.toString();
     }
-    monit(id) {
-        const processInfo = this.processes.get(id);
+    monit(name) {
+        const processInfo = this.processes.get(name);
         if (!processInfo) {
-            throw new Error(`Process ${id} not found`);
+            throw new Error(`Process ${name} not found`);
+        }
+        const table = new cli_table3_1.default({
+            style: { head: ['cyan'] }
+        });
+        table.push(['Name', processInfo.name], ['Status', chalk_1.default[processInfo.status === 'running' ? 'green' : 'red'](processInfo.status)], ['PID', processInfo.pid.toString()], ['Memory', `${processInfo.memory.toFixed(2)}MB`], ['CPU', `${processInfo.cpu.toFixed(1)}%`], ['Uptime', `${Math.floor(processInfo.uptime)}s`], ['Restarts', `${processInfo.restarts}/${processInfo.maxRestarts}`]);
+        if (processInfo.lastError) {
+            table.push(['Last Error', chalk_1.default.red(processInfo.lastError)]);
         }
         return {
-            ...processInfo,
-            logs: processInfo.logs.slice(-100) // Last 100 logs
+            table: table.toString(),
+            logs: processInfo.logs.slice(-100)
         };
     }
-    log(id, lines = 100) {
-        const processInfo = this.processes.get(id);
+    log(name, lines = 100) {
+        const processInfo = this.processes.get(name);
         if (!processInfo) {
-            throw new Error(`Process ${id} not found`);
+            throw new Error(`Process ${name} not found`);
         }
-        const logPath = this.getLogPath(id);
+        const logPath = this.getLogPath(name);
         if (!(0, fs_1.existsSync)(logPath)) {
             return [];
         }
         const logs = (0, fs_1.readFileSync)(logPath, 'utf-8').split('\n');
         return logs.slice(-lines);
     }
-    async restart(id) {
-        const processInfo = this.processes.get(id);
+    async restart(name) {
+        const processInfo = this.processes.get(name);
         if (!processInfo) {
-            throw new Error(`Process ${id} not found`);
+            throw new Error(`Process ${name} not found`);
         }
-        await this.stopx(id);
+        await this.stopx(name);
         processInfo.restarts++;
-        await this.startx(processInfo.path, { name: processInfo.name, watch: true });
+        await this.startx(processInfo.command, {
+            name: processInfo.name,
+            watch: true,
+            cwd: processInfo.cwd
+        });
     }
 }
 exports.processManager = new ProcessManager();

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+export interface RunOptions {
+    parallel: boolean;
+    maxParallel?: number;
+    printOutput: boolean;
+    color: boolean;
+    showTiming: boolean;
+    prefix: boolean;
+    stopOnError: boolean;
+    minimalOutput: boolean;
+    groupOutput: boolean;
+    isServerMode: boolean;
+}
+export interface RunResult {
+    command: string;
+    success: boolean;
+    code: number | null;
+    startTime: Date;
+    endTime: Date | null;
+    duration?: number;
+    error?: Error;
+    output?: CommandOutput[];
+}
+export interface CommandOutput {
+    command: string;
+    type: 'stdout' | 'stderr';
+    data: string;
+    timestamp: Date;
+}
+export interface ServerInfo {
+    name: string;
+    url?: string;
+    status: 'starting' | 'running' | 'error' | 'stopped';
+    pid?: number;
+    port?: number;
+    startTime?: Date;
+}
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug' | 'success';

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/typescript-runner.d.ts

@@ -0,0 +1,12 @@
+export declare class FastTypeScriptRunner {
+    private cache;
+    private compiler;
+    private tempDir;
+    constructor();
+    private detectBestCompiler;
+    compile(filePath: string): Promise<string>;
+    private compileWithSWC;
+    private compileWithESBuild;
+    private compileWithTSC;
+    clearCache(): void;
+}

package/dist/typescript-runner.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastTypeScriptRunner = void 0;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// TypeScript Cache Manager for faster transpilation
+class TypeScriptCache {
+    constructor() {
+        this.enabled = true;
+        this.cacheDir = (0, path_1.join)(process.cwd(), '.neex', 'cache');
+        if (!(0, fs_1.existsSync)(this.cacheDir)) {
+            (0, fs_1.mkdirSync)(this.cacheDir, { recursive: true });
+        }
+    }
+    getFileHash(filePath) {
+        try {
+            const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+            return (0, crypto_1.createHash)('md5').update(content).digest('hex');
+        }
+        catch {
+            return '';
+        }
+    }
+    getCachePath(filePath) {
+        const hash = this.getFileHash(filePath);
+        const fileName = `${hash}.js`;
+        return (0, path_1.join)(this.cacheDir, fileName);
+    }
+    isCached(filePath) {
+        if (!this.enabled)
+            return false;
+        const cachePath = this.getCachePath(filePath);
+        return (0, fs_1.existsSync)(cachePath);
+    }
+    getCachedFile(filePath) {
+        if (!this.isCached(filePath))
+            return null;
+        return this.getCachePath(filePath);
+    }
+    cacheFile(originalPath, compiledPath) {
+        if (!this.enabled)
+            return;
+        try {
+            const cachePath = this.getCachePath(originalPath);
+            const compiledContent = (0, fs_1.readFileSync)(compiledPath, 'utf8');
+            (0, fs_1.writeFileSync)(cachePath, compiledContent);
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`Warning: Failed to cache ${originalPath}`));
+        }
+    }
+    clear() {
+        try {
+            (0, child_process_1.exec)(`rm -rf ${this.cacheDir}`);
+            (0, fs_1.mkdirSync)(this.cacheDir, { recursive: true });
+            console.log(chalk_1.default.green(`${figures_1.default.tick} Cache cleared successfully`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`${figures_1.default.cross} Failed to clear cache`));
+        }
+    }
+}
+class FastTypeScriptRunner {
+    constructor() {
+        this.cache = new TypeScriptCache();
+        this.tempDir = (0, path_1.join)(process.cwd(), '.neex', 'temp');
+        if (!(0, fs_1.existsSync)(this.tempDir)) {
+            (0, fs_1.mkdirSync)(this.tempDir, { recursive: true });
+        }
+        this.compiler = this.detectBestCompiler();
+    }
+    detectBestCompiler() {
+        try {
+            require.resolve('@swc/core');
+            return 'swc';
+        }
+        catch {
+            try {
+                require.resolve('esbuild');
+                return 'esbuild';
+            }
+            catch {
+                return 'tsc';
+            }
+        }
+    }
+    async compile(filePath) {
+        const cachedFile = this.cache.getCachedFile(filePath);
+        if (cachedFile) {
+            return cachedFile;
+        }
+        const outputPath = (0, path_1.join)(this.tempDir, `${Date.now()}.js`);
+        try {
+            switch (this.compiler) {
+                case 'swc':
+                    await this.compileWithSWC(filePath, outputPath);
+                    break;
+                case 'esbuild':
+                    await this.compileWithESBuild(filePath, outputPath);
+                    break;
+                default:
+                    await this.compileWithTSC(filePath, outputPath);
+            }
+            this.cache.cacheFile(filePath, outputPath);
+            return outputPath;
+        }
+        catch (error) {
+            throw new Error(`Compilation failed: ${error}`);
+        }
+    }
+    async compileWithSWC(input, output) {
+        const swc = require('@swc/core');
+        const result = await swc.transformFile(input, {
+            jsc: {
+                parser: {
+                    syntax: 'typescript',
+                    tsx: false,
+                    decorators: true,
+                },
+                target: 'es2022',
+                transform: {
+                    legacyDecorator: true,
+                    decoratorMetadata: true,
+                },
+            },
+            module: {
+                type: 'commonjs',
+            },
+        });
+        (0, fs_1.writeFileSync)(output, result.code);
+    }
+    async compileWithESBuild(input, output) {
+        const esbuild = require('esbuild');
+        await esbuild.build({
+            entryPoints: [input],
+            outfile: output,
+            platform: 'node',
+            target: 'node18',
+            format: 'cjs',
+            sourcemap: true,
+            bundle: false,
+        });
+    }
+    async compileWithTSC(input, output) {
+        await execAsync(`npx tsc ${input} --outFile ${output} --target ES2022 --module commonjs --esModuleInterop --allowSyntheticDefaultImports --experimentalDecorators --emitDecoratorMetadata --skipLibCheck`);
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+exports.FastTypeScriptRunner = FastTypeScriptRunner;
+//# sourceMappingURL=typescript-runner.js.map

package/dist/typescript-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-runner.js","sourceRoot":"","sources":["../src/typescript-runner.ts"],"names":[],"mappings":";;;;;;AAAA,iDAA0D;AAC1D,+BAAqC;AACrC,2BAAwE;AACxE,kDAA0B;AAC1B,sDAA8B;AAC9B,mCAAoC;AACpC,+BAAiC;AAEjC,MAAM,SAAS,GAAG,IAAA,gBAAS,EAAC,oBAAI,CAAC,CAAC;AAElC,oDAAoD;AACpD,MAAM,eAAe;IAIjB;QAFQ,YAAO,GAAY,IAAI,CAAC;QAG5B,IAAI,CAAC,QAAQ,GAAG,IAAA,WAAI,EAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACtD,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,IAAA,cAAS,EAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAClD,CAAC;IACL,CAAC;IAEO,WAAW,CAAC,QAAgB;QAChC,IAAI,CAAC;YACD,MAAM,OAAO,GAAG,IAAA,iBAAY,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC/C,OAAO,IAAA,mBAAU,EAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3D,CAAC;QAAC,MAAM,CAAC;YACL,OAAO,EAAE,CAAC;QACd,CAAC;IACL,CAAC;IAEO,YAAY,CAAC,QAAgB;QACjC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,GAAG,IAAI,KAAK,CAAC;QAC9B,OAAO,IAAA,WAAI,EAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,QAAQ,CAAC,QAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAChC,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC9C,OAAO,IAAA,eAAU,EAAC,SAAS,CAAC,CAAC;IACjC,CAAC;IAED,aAAa,CAAC,QAAgB;QAC1B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1C,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC;IAED,SAAS,CAAC,YAAoB,EAAE,YAAoB;QAChD,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,IAAI,CAAC;YACD,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAClD,MAAM,eAAe,GAAG,IAAA,iBAAY,EAAC,YAAY,EAAE,MAAM,CAAC,CAAC;YAC3D,IAAA,kBAAa,EAAC,SAAS,EAAE,eAAe,CAAC,CAAC;QAC9C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,eAAK,CAAC,MAAM,CAAC,4BAA4B,YAAY,EAAE,CAAC,CAAC,CAAC;QAC3E,CAAC;IACL,CAAC;IAED,KAAK;QACD,IAAI,CAAC;YACD,IAAA,oBAAI,EAAC,UAAU,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;YAChC,IAAA,cAAS,EAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9C,OAAO,CAAC,GAAG,CAAC,eAAK,CAAC,KAAK,CAAC,GAAG,iBAAO,CAAC,IAAI,6BAA6B,CAAC,CAAC,CAAC;QAC3E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,eAAK,CAAC,GAAG,CAAC,GAAG,iBAAO,CAAC,KAAK,wBAAwB,CAAC,CAAC,CAAC;QACvE,CAAC;IACL,CAAC;CACJ;AAED,MAAa,oBAAoB;IAK7B;QACI,IAAI,CAAC,KAAK,GAAG,IAAI,eAAe,EAAE,CAAC;QACnC,IAAI,CAAC,OAAO,GAAG,IAAA,WAAI,EAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QACpD,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,IAAA,cAAS,EAAC,IAAI,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC9C,CAAC;IAEO,kBAAkB;QACtB,IAAI,CAAC;YACD,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAC7B,OAAO,KAAK,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACL,IAAI,CAAC;gBACD,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBAC3B,OAAO,SAAS,CAAC;YACrB,CAAC;YAAC,MAAM,CAAC;gBACL,OAAO,KAAK,CAAC;YACjB,CAAC;QACL,CAAC;IACL,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,QAAgB;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACtD,IAAI,UAAU,EAAE,CAAC;YACb,OAAO,UAAU,CAAC;QACtB,CAAC;QAED,MAAM,UAAU,GAAG,IAAA,WAAI,EAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAE1D,IAAI,CAAC;YACD,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACpB,KAAK,KAAK;oBACN,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;oBAChD,MAAM;gBACV,KAAK,SAAS;oBACV,MAAM,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;oBACpD,MAAM;gBACV;oBACI,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YACxD,CAAC;YAED,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAC3C,OAAO,UAAU,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,uBAAuB,KAAK,EAAE,CAAC,CAAC;QACpD,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,MAAc;QACtD,MAAM,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QACjC,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE;YAC1C,GAAG,EAAE;gBACD,MAAM,EAAE;oBACJ,MAAM,EAAE,YAAY;oBACpB,GAAG,EAAE,KAAK;oBACV,UAAU,EAAE,IAAI;iBACnB;gBACD,MAAM,EAAE,QAAQ;gBAChB,SAAS,EAAE;oBACP,eAAe,EAAE,IAAI;oBACrB,iBAAiB,EAAE,IAAI;iBAC1B;aACJ;YACD,MAAM,EAAE;gBACJ,IAAI,EAAE,UAAU;aACnB;SACJ,CAAC,CAAC;QACH,IAAA,kBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAAC,KAAa,EAAE,MAAc;QAC1D,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QACnC,MAAM,OAAO,CAAC,KAAK,CAAC;YAChB,WAAW,EAAE,CAAC,KAAK,CAAC;YACpB,OAAO,EAAE,MAAM;YACf,QAAQ,EAAE,MAAM;YAChB,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,KAAK;YACb,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,KAAK;SAChB,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,MAAc;QACtD,MAAM,SAAS,CAAC,WAAW,KAAK,cAAc,MAAM,qJAAqJ,CAAC,CAAC;IAC/M,CAAC;IAED,UAAU;QACN,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;CACJ;AAjGD,oDAiGC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neex",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -28,12 +28,17 @@
   "author": "foshati",
   "license": "MIT",
   "dependencies": {
+    "@types/express": "^5.0.3",
     "chalk": "^4.1.2",
-    "chokidar": "^3.5.3",
+    "chokidar": "^4.0.3",
+    "cli-table3": "^0.6.5",
     "commander": "^9.4.0",
+    "esbuild": "^0.25.5",
+    "express": "^5.1.0",
     "figlet": "^1.8.1",
     "figures": "^3.2.0",
     "gradient-string": "^3.0.0",
+    "node-notifier": "^10.0.1",
     "npm-run-path": "^4.0.1",
     "p-map": "^4.0.0",
     "string-width": "^4.2.3",