@atmyapp/cli 0.0.2 → 0.0.4

package/dist/cli/utils/worker-pool.js

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = void 0;
+const worker_threads_1 = require("worker_threads");
+const os_1 = require("os");
+class WorkerPool {
+    constructor(logger, maxWorkers) {
+        this.workers = [];
+        this.taskQueue = [];
+        this.activeWorkers = new Set();
+        this.results = new Map();
+        this.logger = logger;
+        this.maxWorkers = maxWorkers || Math.min((0, os_1.cpus)().length, 8); // Cap at 8 workers
+    }
+    processFiles(tasks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.taskQueue = [...tasks];
+            this.results.clear();
+            this.logger.info(`🚀 Starting parallel processing with ${this.maxWorkers} workers`);
+            this.logger.verbose_log(`Processing ${tasks.length} tasks in parallel`);
+            // Create workers
+            const workerPromises = [];
+            const workersToCreate = Math.min(this.maxWorkers, tasks.length);
+            // Determine the correct worker script path
+            const workerScriptPath = __filename.endsWith(".ts")
+                ? __filename.replace(".ts", ".js").replace("/src/", "/dist/")
+                : __filename;
+            for (let i = 0; i < workersToCreate; i++) {
+                const worker = new worker_threads_1.Worker(workerScriptPath);
+                this.workers.push(worker);
+                workerPromises.push(this.setupWorker(worker));
+            }
+            // Wait for all workers to complete
+            yield Promise.all(workerPromises);
+            // Cleanup workers
+            yield this.cleanup();
+            // Return results in original order
+            return tasks.map((task) => this.results.get(task.id));
+        });
+    }
+    setupWorker(worker) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                worker.on("message", (result) => {
+                    this.results.set(result.id, result);
+                    if (result.success) {
+                        this.logger.verbose_log(`✅ Worker completed task ${result.id}`);
+                    }
+                    else {
+                        this.logger.error(`❌ Worker failed task ${result.id}: ${result.error}`);
+                    }
+                    // Assign next task or finish
+                    this.assignNextTask(worker, resolve);
+                });
+                worker.on("error", (error) => {
+                    this.logger.error(`Worker error: ${error.message}`);
+                    reject(error);
+                });
+                worker.on("exit", (code) => {
+                    if (code !== 0 && this.activeWorkers.has(worker)) {
+                        this.logger.error(`Worker exited with code ${code}`);
+                    }
+                    this.activeWorkers.delete(worker);
+                });
+                // Start with first task
+                this.assignNextTask(worker, resolve);
+            });
+        });
+    }
+    assignNextTask(worker, resolve) {
+        const task = this.taskQueue.shift();
+        if (task) {
+            this.activeWorkers.add(worker);
+            worker.postMessage(task);
+        }
+        else {
+            // No more tasks, resolve this worker
+            this.activeWorkers.delete(worker);
+            resolve();
+        }
+    }
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const terminationPromises = this.workers.map((worker) => worker
+                .terminate()
+                .catch((err) => this.logger.warn(`Error terminating worker: ${err.message}`)));
+            yield Promise.all(terminationPromises);
+            this.workers = [];
+        });
+    }
+}
+exports.WorkerPool = WorkerPool;
+// Worker thread implementation
+if (!worker_threads_1.isMainThread && worker_threads_1.parentPort) {
+    // Import required modules in worker context
+    const { processFileInWorker } = require("./worker-file-processor");
+    worker_threads_1.parentPort.on("message", (task) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const contents = yield processFileInWorker(task.filePath, task.tsconfigPath);
+            const result = {
+                id: task.id,
+                success: true,
+                contents,
+            };
+            worker_threads_1.parentPort.postMessage(result);
+        }
+        catch (error) {
+            const result = {
+                id: task.id,
+                success: false,
+                contents: [],
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+            worker_threads_1.parentPort.postMessage(result);
+        }
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atmyapp/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -28,7 +28,7 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@atmyapp/core": "^0.0.3",
+    "@atmyapp/core": "^0.0.5",
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",