pm-orchestrator-enhancement/dist/workflow/parallel-executor.js

PM Orchestrator Enhancement - Multi-agent parallel execution system

"use strict";
/**
 * PM Orchestrator Enhancement - Parallel Executor
 *
 * サブエージェントの並行実行を制御します。
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.ParallelExecutor = exports.Semaphore = void 0;
/**
 * Semaphoreクラス
 *
 * 同時実行数を制限するためのセマフォ実装です。
 */
class Semaphore {
    /**
     * コンストラクタ
     *
     * @param permits 同時実行可能な数
     */
    constructor(permits) {
        this.waiting = [];
        this.permits = permits;
    }
    /**
     * セマフォを取得します（非同期）
     */
    async acquire() {
        if (this.permits > 0) {
            this.permits--;
            return Promise.resolve();
        }
        return new Promise(resolve => {
            this.waiting.push(resolve);
        });
    }
    /**
     * セマフォを解放します
     */
    release() {
        this.permits++;
        const resolve = this.waiting.shift();
        if (resolve) {
            this.permits--;
            resolve();
        }
    }
}
exports.Semaphore = Semaphore;
/**
 * ParallelExecutorクラス
 *
 * 並行実行を制御し、タスクを並行して実行します。
 */
class ParallelExecutor {
    /**
     * コンストラクタ
     *
     * @param maxConcurrent 最大同時実行数
     */
    constructor(maxConcurrent = 3) {
        this.semaphore = new Semaphore(maxConcurrent);
    }
    /**
     * タスクを並行実行します
     *
     * @param tasks 実行するタスクの配列
     * @param timeout タイムアウト時間（ミリ秒）
     * @returns タスク実行結果の配列
     */
    async executeParallel(tasks, timeout) {
        const promises = tasks.map(task => this.executeWithSemaphore(task, timeout));
        return Promise.all(promises);
    }
    /**
     * セマフォ付きでタスクを実行します（プライベートメソッド）
     *
     * @param task 実行するタスク
     * @param timeout タイムアウト時間（ミリ秒）
     * @returns タスク実行結果
     */
    async executeWithSemaphore(task, timeout) {
        await this.semaphore.acquire();
        try {
            if (timeout) {
                return await this.executeWithTimeout(task, timeout);
            }
            else {
                return await task();
            }
        }
        finally {
            this.semaphore.release();
        }
    }
    /**
     * タイムアウト付きでタスクを実行します（プライベートメソッド）
     *
     * @param task 実行するタスク
     * @param timeout タイムアウト時間（ミリ秒）
     * @returns タスク実行結果
     */
    async executeWithTimeout(task, timeout) {
        return Promise.race([
            task(),
            this.createTimeoutPromise(timeout)
        ]);
    }
    /**
     * タイムアウトPromiseを作成します（プライベートメソッド）
     *
     * @param timeout タイムアウト時間（ミリ秒）
     * @returns タイムアウトPromise
     */
    createTimeoutPromise(timeout) {
        return new Promise((_, reject) => {
            setTimeout(() => {
                reject(new Error(`Task timeout after ${timeout}ms`));
            }, timeout);
        });
    }
}
exports.ParallelExecutor = ParallelExecutor;
//# sourceMappingURL=parallel-executor.js.map