@eldrforge/tree-execution 0.1.0

package/dist/execution/ResourceMonitor.d.ts

@@ -0,0 +1,73 @@
+export interface ResourceMetrics {
+    peakConcurrency: number;
+    averageConcurrency: number;
+    totalAllocations: number;
+    totalReleases: number;
+    freeMemoryBytes?: number;
+}
+/**
+ * ResourceMonitor manages concurrency limits and tracks resource utilization
+ */
+export declare class ResourceMonitor {
+    private maxConcurrency;
+    private currentConcurrency;
+    private metrics;
+    private allocationHistory;
+    private logger;
+    private readonly MEMORY_THRESHOLD_PERCENT;
+    constructor(maxConcurrency: number);
+    /**
+     * Check if we can allocate N slots
+     */
+    canAllocate(count?: number): boolean;
+    /**
+     * Log a warning if system memory is low
+     */
+    private checkSystemMemory;
+    /**
+     * Allocate resource slots
+     * @returns true if allocation succeeded, false if not enough slots available
+     */
+    allocate(count?: number): boolean;
+    /**
+     * Release resource slots
+     */
+    release(count?: number): void;
+    /**
+     * Get number of available slots
+     */
+    getAvailableSlots(): number;
+    /**
+     * Get current concurrency level
+     */
+    getCurrentConcurrency(): number;
+    /**
+     * Get maximum concurrency limit
+     */
+    getMaxConcurrency(): number;
+    /**
+     * Get resource utilization metrics
+     */
+    getMetrics(): ResourceMetrics;
+    /**
+     * Get utilization percentage (0-100)
+     */
+    getUtilization(): number;
+    /**
+     * Check if resources are fully utilized
+     */
+    isFullyUtilized(): boolean;
+    /**
+     * Check if resources are idle
+     */
+    isIdle(): boolean;
+    /**
+     * Update average concurrency calculation
+     */
+    private updateAverageConcurrency;
+    /**
+     * Reset metrics (useful for testing)
+     */
+    reset(): void;
+}
+//# sourceMappingURL=ResourceMonitor.d.ts.map

package/dist/execution/ResourceMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceMonitor.d.ts","sourceRoot":"","sources":["../../src/execution/ResourceMonitor.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,iBAAiB,CAAgB;IACzC,OAAO,CAAC,MAAM,CAAe;IAG7B,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAK;gBAElC,cAAc,EAAE,MAAM;IAUlC;;OAEG;IACH,WAAW,CAAC,KAAK,GAAE,MAAU,GAAG,OAAO;IAYvC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;OAGG;IACH,QAAQ,CAAC,KAAK,GAAE,MAAU,GAAG,OAAO;IAoBpC;;OAEG;IACH,OAAO,CAAC,KAAK,GAAE,MAAU,GAAG,IAAI;IAUhC;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,qBAAqB,IAAI,MAAM;IAI/B;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,UAAU,IAAI,eAAe;IAI7B;;OAEG;IACH,cAAc,IAAI,MAAM;IAKxB;;OAEG;IACH,eAAe,IAAI,OAAO;IAI1B;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAUhC;;OAEG;IACH,KAAK,IAAI,IAAI;CAUhB"}

package/dist/execution/ResourceMonitor.js

@@ -0,0 +1,148 @@
+import { getLogger } from '../util/logger.js';
+import * as os from 'os';
+/**
+ * ResourceMonitor manages concurrency limits and tracks resource utilization
+ */
+export class ResourceMonitor {
+    maxConcurrency;
+    currentConcurrency = 0;
+    metrics;
+    allocationHistory = [];
+    logger = getLogger();
+    // Memory threshold: warn if free memory is below 5%
+    MEMORY_THRESHOLD_PERCENT = 5;
+    constructor(maxConcurrency) {
+        this.maxConcurrency = maxConcurrency;
+        this.metrics = {
+            peakConcurrency: 0,
+            averageConcurrency: 0,
+            totalAllocations: 0,
+            totalReleases: 0
+        };
+    }
+    /**
+     * Check if we can allocate N slots
+     */
+    canAllocate(count = 1) {
+        // Check concurrency limit
+        if (this.currentConcurrency + count > this.maxConcurrency) {
+            return false;
+        }
+        // Check system memory (soft check)
+        this.checkSystemMemory();
+        return true;
+    }
+    /**
+     * Log a warning if system memory is low
+     */
+    checkSystemMemory() {
+        try {
+            const freeMem = os.freemem();
+            const totalMem = os.totalmem();
+            const freePercent = (freeMem / totalMem) * 100;
+            if (freePercent < this.MEMORY_THRESHOLD_PERCENT) {
+                const freeGB = (freeMem / (1024 * 1024 * 1024)).toFixed(2);
+                this.logger.warn(`SYSTEM_MEMORY_LOW: System memory is running low | Free: ${freeGB}GB (${freePercent.toFixed(1)}%) | Action: Proceeding with caution`);
+            }
+        }
+        catch (error) {
+            // Ignore errors in memory check to avoid blocking execution
+            this.logger.debug(`Failed to check system memory: ${error}`);
+        }
+    }
+    /**
+     * Allocate resource slots
+     * @returns true if allocation succeeded, false if not enough slots available
+     */
+    allocate(count = 1) {
+        if (!this.canAllocate(count)) {
+            return false;
+        }
+        this.currentConcurrency += count;
+        this.metrics.totalAllocations += count;
+        this.metrics.peakConcurrency = Math.max(this.metrics.peakConcurrency, this.currentConcurrency);
+        this.allocationHistory.push(this.currentConcurrency);
+        this.updateAverageConcurrency();
+        this.logger.debug(`Allocated ${count} slot(s) (${this.currentConcurrency}/${this.maxConcurrency})`);
+        return true;
+    }
+    /**
+     * Release resource slots
+     */
+    release(count = 1) {
+        this.currentConcurrency = Math.max(0, this.currentConcurrency - count);
+        this.metrics.totalReleases += count;
+        this.allocationHistory.push(this.currentConcurrency);
+        this.updateAverageConcurrency();
+        this.logger.debug(`Released ${count} slot(s) (${this.currentConcurrency}/${this.maxConcurrency})`);
+    }
+    /**
+     * Get number of available slots
+     */
+    getAvailableSlots() {
+        return this.maxConcurrency - this.currentConcurrency;
+    }
+    /**
+     * Get current concurrency level
+     */
+    getCurrentConcurrency() {
+        return this.currentConcurrency;
+    }
+    /**
+     * Get maximum concurrency limit
+     */
+    getMaxConcurrency() {
+        return this.maxConcurrency;
+    }
+    /**
+     * Get resource utilization metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Get utilization percentage (0-100)
+     */
+    getUtilization() {
+        if (this.maxConcurrency === 0)
+            return 0;
+        return (this.currentConcurrency / this.maxConcurrency) * 100;
+    }
+    /**
+     * Check if resources are fully utilized
+     */
+    isFullyUtilized() {
+        return this.currentConcurrency >= this.maxConcurrency;
+    }
+    /**
+     * Check if resources are idle
+     */
+    isIdle() {
+        return this.currentConcurrency === 0;
+    }
+    /**
+     * Update average concurrency calculation
+     */
+    updateAverageConcurrency() {
+        if (this.allocationHistory.length === 0) {
+            this.metrics.averageConcurrency = 0;
+            return;
+        }
+        const sum = this.allocationHistory.reduce((a, b) => a + b, 0);
+        this.metrics.averageConcurrency = sum / this.allocationHistory.length;
+    }
+    /**
+     * Reset metrics (useful for testing)
+     */
+    reset() {
+        this.currentConcurrency = 0;
+        this.allocationHistory = [];
+        this.metrics = {
+            peakConcurrency: 0,
+            averageConcurrency: 0,
+            totalAllocations: 0,
+            totalReleases: 0
+        };
+    }
+}
+//# sourceMappingURL=ResourceMonitor.js.map

package/dist/execution/ResourceMonitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceMonitor.js","sourceRoot":"","sources":["../../src/execution/ResourceMonitor.ts"],"names":[],"mappings":"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"}

package/dist/execution/Scheduler.d.ts

@@ -0,0 +1,36 @@
+import type { DependencyGraph } from '@eldrforge/tree-core';
+import type { ExecutionState } from '../types/index.js';
+import { DependencyChecker } from './DependencyChecker.js';
+/**
+ * Scheduler determines which packages to execute next based on priority
+ */
+export declare class Scheduler {
+    private graph;
+    private checker;
+    constructor(graph: DependencyGraph, checker: DependencyChecker);
+    /**
+     * Get next packages to schedule based on available slots
+     * Returns packages sorted by priority (highest priority first)
+     */
+    getNext(availableSlots: number, state: ExecutionState): string[];
+    /**
+     * Calculate priority score for a package
+     * Higher score = higher priority = execute sooner
+     *
+     * Priority factors:
+     * 1. Number of dependents (more = higher priority, unblocks more packages)
+     * 2. Depth in dependency tree (shallower = higher priority, enables earlier unlocking)
+     * 3. Retry attempts (fewer = higher priority, give fresh packages a chance)
+     */
+    calculatePriority(packageName: string, state: ExecutionState): number;
+    /**
+     * Get estimated completion order (for progress reporting)
+     */
+    getEstimatedOrder(state: ExecutionState): string[];
+    /**
+     * Predict which packages will become ready next
+     * Useful for pre-loading or progress estimation
+     */
+    predictNextReady(state: ExecutionState): string[];
+}
+//# sourceMappingURL=Scheduler.d.ts.map

package/dist/execution/Scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../../src/execution/Scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;GAEG;AACH,qBAAa,SAAS;IAClB,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,OAAO,CAAoB;gBAEvB,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,iBAAiB;IAK9D;;;OAGG;IACH,OAAO,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM,EAAE;IAchE;;;;;;;;OAQG;IACH,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM;IA2BrE;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,EAAE;IAQlD;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,EAAE;CAwBpD"}

package/dist/execution/Scheduler.js

@@ -0,0 +1,83 @@
+/**
+ * Scheduler determines which packages to execute next based on priority
+ */
+export class Scheduler {
+    graph;
+    checker;
+    constructor(graph, checker) {
+        this.graph = graph;
+        this.checker = checker;
+    }
+    /**
+     * Get next packages to schedule based on available slots
+     * Returns packages sorted by priority (highest priority first)
+     */
+    getNext(availableSlots, state) {
+        if (availableSlots <= 0 || state.ready.length === 0) {
+            return [];
+        }
+        // Sort ready packages by priority
+        const sorted = [...state.ready].sort((a, b) => this.calculatePriority(b, state) - this.calculatePriority(a, state));
+        // Return top N packages that fit in available slots
+        return sorted.slice(0, availableSlots);
+    }
+    /**
+     * Calculate priority score for a package
+     * Higher score = higher priority = execute sooner
+     *
+     * Priority factors:
+     * 1. Number of dependents (more = higher priority, unblocks more packages)
+     * 2. Depth in dependency tree (shallower = higher priority, enables earlier unlocking)
+     * 3. Retry attempts (fewer = higher priority, give fresh packages a chance)
+     */
+    calculatePriority(packageName, state) {
+        let score = 0;
+        // Factor 1: More dependents = higher priority (weight: 100)
+        // Packages that unblock many others should run first
+        const dependentCount = this.checker.getDependentCount(packageName);
+        score += dependentCount * 100;
+        // Factor 2: Depth penalty (weight: -10)
+        // Prefer packages closer to the root of the dependency tree
+        const depth = this.checker.getDepth(packageName);
+        score -= depth * 10;
+        // Factor 3: Retry penalty (weight: -50)
+        // Packages that have failed before get lower priority
+        const retries = state.failed.filter(f => f.name === packageName).length;
+        score -= retries * 50;
+        // Factor 4: Bonus for packages with no dependents (leaf nodes)
+        // These are usually final deliverables and good to complete early for feedback
+        if (!this.checker.hasDependents(packageName)) {
+            score += 5;
+        }
+        return score;
+    }
+    /**
+     * Get estimated completion order (for progress reporting)
+     */
+    getEstimatedOrder(state) {
+        const allPending = [...state.pending, ...state.ready];
+        return allPending.sort((a, b) => this.calculatePriority(b, state) - this.calculatePriority(a, state));
+    }
+    /**
+     * Predict which packages will become ready next
+     * Useful for pre-loading or progress estimation
+     */
+    predictNextReady(state) {
+        const predictions = [];
+        // Look at currently running packages
+        const runningNames = state.running.map(r => r.name);
+        // For each running package, see which pending packages only depend on it
+        for (const runningPkg of runningNames) {
+            for (const pendingPkg of state.pending) {
+                const deps = this.checker.getDependencies(pendingPkg);
+                // Check if this pending package will be ready when running completes
+                const blockedBy = Array.from(deps).filter(dep => !state.completed.includes(dep) && dep !== runningPkg);
+                if (blockedBy.length === 0) {
+                    predictions.push(pendingPkg);
+                }
+            }
+        }
+        return predictions;
+    }
+}
+//# sourceMappingURL=Scheduler.js.map

package/dist/execution/Scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.js","sourceRoot":"","sources":["../../src/execution/Scheduler.ts"],"names":[],"mappings":"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"}

package/dist/execution/TreeExecutionAdapter.d.ts

@@ -0,0 +1,45 @@
+import { DynamicTaskPool, PoolConfig } from './DynamicTaskPool.js';
+import type { PackageInfo } from '@eldrforge/tree-core';
+import type { TreeExecutionConfig } from '../types/config.js';
+/**
+ * ExecutePackageFunction type matches the signature of tree.ts executePackage
+ */
+export type ExecutePackageFunction = (packageName: string, packageInfo: PackageInfo, commandToRun: string, runConfig: TreeExecutionConfig, isDryRun: boolean, index: number, total: number, allPackageNames: Set<string>, isBuiltInCommand?: boolean) => Promise<{
+    success: boolean;
+    error?: any;
+    isTimeoutError?: boolean;
+    skippedNoChanges?: boolean;
+    logFile?: string;
+}>;
+/**
+ * TreeExecutionAdapter bridges DynamicTaskPool with tree.ts executePackage
+ */
+export declare class TreeExecutionAdapter {
+    private pool;
+    private executePackageFn;
+    private config;
+    private startedCount;
+    private completedCount;
+    constructor(config: PoolConfig, executePackageFn: ExecutePackageFunction);
+    /**
+     * Create wrapper that adapts tree.ts executePackage to DynamicTaskPool format
+     */
+    private createExecutePackageWrapper;
+    /**
+     * Execute parallel execution
+     */
+    execute(): Promise<import("../types/parallelExecution.js").ExecutionResult>;
+    /**
+     * Get the underlying task pool for event listeners
+     */
+    getPool(): DynamicTaskPool;
+}
+/**
+ * Create progress logger that listens to pool events
+ */
+export declare function createParallelProgressLogger(pool: DynamicTaskPool, config: TreeExecutionConfig): void;
+/**
+ * Format parallel execution result for display
+ */
+export declare function formatParallelResult(result: any): string;
+//# sourceMappingURL=TreeExecutionAdapter.d.ts.map

package/dist/execution/TreeExecutionAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeExecutionAdapter.d.ts","sourceRoot":"","sources":["../../src/execution/TreeExecutionAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAI9D;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CACjC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAC5B,gBAAgB,CAAC,EAAE,OAAO,KACzB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,GAAG,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAExH;;GAEG;AACH,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,IAAI,CAAkB;IAC9B,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,cAAc,CAAa;gBAEvB,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,sBAAsB;IAgBxE;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAqDnC;;OAEG;IACG,OAAO;IAIb;;OAEG;IACH,OAAO,IAAI,eAAe;CAG7B;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAuErG;AAoCD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,CAuFxD"}

package/dist/execution/TreeExecutionAdapter.js

@@ -0,0 +1,249 @@
+import { DynamicTaskPool } from './DynamicTaskPool.js';
+import { getLogger } from '../util/logger.js';
+/**
+ * TreeExecutionAdapter bridges DynamicTaskPool with tree.ts executePackage
+ */
+export class TreeExecutionAdapter {
+    pool;
+    executePackageFn;
+    config;
+    startedCount = 0;
+    completedCount = 0;
+    constructor(config, executePackageFn) {
+        this.config = config;
+        this.executePackageFn = executePackageFn;
+        // Create custom pool that uses our execute function
+        this.pool = new DynamicTaskPool(config);
+        // Track completion count for progress display
+        this.pool.on('package:completed', () => {
+            this.completedCount++;
+        });
+        // Override the executePackage method to use tree.ts function
+        this.pool.executePackage = this.createExecutePackageWrapper();
+    }
+    /**
+     * Create wrapper that adapts tree.ts executePackage to DynamicTaskPool format
+     */
+    createExecutePackageWrapper() {
+        return async (packageName, _signal) => {
+            const packageInfo = this.config.graph.packages.get(packageName);
+            if (!packageInfo) {
+                throw new Error(`Package not found: ${packageName}`);
+            }
+            const allPackageNames = new Set(this.config.graph.packages.keys());
+            const isDryRun = this.config.config.dryRun || false;
+            const isBuiltInCommand = !this.config.command.startsWith('npm') &&
+                !this.config.command.includes('&&');
+            // Increment started count and use it as index for progress display
+            const currentIndex = this.startedCount++;
+            // Call tree.ts executePackage
+            const startTime = Date.now();
+            const result = await this.executePackageFn(packageName, packageInfo, this.config.command, this.config.config, isDryRun, currentIndex, // Use incremented started count for proper [N/Total] display
+            this.config.graph.packages.size, allPackageNames, isBuiltInCommand);
+            const duration = Date.now() - startTime;
+            if (!result.success) {
+                // Attach logFile path to error for better error reporting
+                const error = result.error || new Error('Package execution failed');
+                error.logFilePath = result.logFile;
+                throw error;
+            }
+            // Check if this was a "no changes" skip (result will have skippedNoChanges flag)
+            const skippedNoChanges = result.skippedNoChanges || false;
+            return {
+                success: true,
+                duration,
+                // Extract published version if available (from output or state)
+                publishedVersion: undefined,
+                stdout: undefined,
+                stderr: undefined,
+                skippedNoChanges
+            };
+        };
+    }
+    /**
+     * Execute parallel execution
+     */
+    async execute() {
+        return await this.pool.execute();
+    }
+    /**
+     * Get the underlying task pool for event listeners
+     */
+    getPool() {
+        return this.pool;
+    }
+}
+/**
+ * Create progress logger that listens to pool events
+ */
+export function createParallelProgressLogger(pool, config) {
+    const logger = getLogger();
+    const startTime = Date.now();
+    let completedCount = 0;
+    let totalPackages = 0;
+    pool.on('execution:started', ({ totalPackages: total }) => {
+        totalPackages = total;
+        logger.info(`\nPARALLEL_EXECUTION_STARTING: Initiating parallel package execution | Package Count: ${total} | Mode: parallel | Strategy: dependency-aware`);
+    });
+    pool.on('package:started', ({ packageName }) => {
+        if (config.verbose || config.debug) {
+            logger.info(`PACKAGE_STARTED: Package execution initiated | Package: ${packageName} | Status: running`);
+        }
+    });
+    pool.on('package:completed', ({ packageName, result }) => {
+        completedCount++;
+        const percent = Math.round((completedCount / totalPackages) * 100);
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        if (config.debug) {
+            logger.info(`PACKAGE_COMPLETED: Package execution finished successfully | Package: ${packageName} | Duration: ${result.duration}ms | Progress: ${completedCount}/${totalPackages} (${percent}%) | Elapsed: ${elapsed}s`);
+        }
+        else if (config.verbose) {
+            logger.info(`PACKAGE_COMPLETED: Package execution finished | Package: ${packageName} | Progress: ${completedCount}/${totalPackages}`);
+        }
+        else {
+            // Minimal output
+            logger.info(`PROGRESS: [${completedCount}/${totalPackages}] Package completed: ${packageName}`);
+        }
+    });
+    pool.on('package:failed', ({ packageName, error }) => {
+        logger.error(`PACKAGE_FAILED: Package execution failed | Package: ${packageName} | Error: ${error.message} | Status: error`);
+    });
+    pool.on('package:retrying', ({ packageName, attemptNumber }) => {
+        logger.warn(`PACKAGE_RETRYING: Retrying package execution | Package: ${packageName} | Attempt: ${attemptNumber} | Status: retrying`);
+    });
+    pool.on('package:skipped', ({ packageName, reason }) => {
+        logger.warn(`PACKAGE_SKIPPED: Package skipped due to dependency failure | Package: ${packageName} | Reason: ${reason} | Status: skipped`);
+    });
+    pool.on('package:skipped-no-changes', ({ packageName }) => {
+        if (config.verbose || config.debug) {
+            logger.info(`PACKAGE_SKIPPED_NO_CHANGES: Package skipped due to no code changes | Package: ${packageName} | Reason: no-code-changes | Status: skipped`);
+        }
+    });
+    pool.on('checkpoint:saved', () => {
+        if (config.debug) {
+            logger.debug('CHECKPOINT_SAVED: Execution checkpoint saved | Purpose: Recovery support | Action: State persisted to disk');
+        }
+    });
+    pool.on('execution:completed', ({ result }) => {
+        const totalTime = Math.round((Date.now() - startTime) / 1000);
+        logger.info(`\nPARALLEL_EXECUTION_COMPLETED: Parallel execution finished | Duration: ${totalTime}s | Status: completed`);
+        if (config.verbose || config.debug) {
+            logger.info(`\nEXECUTION_METRICS: Performance and execution statistics:`);
+            logger.info(`  METRIC_TOTAL_PACKAGES: ${result.totalPackages}`);
+            logger.info(`  METRIC_COMPLETED: ${result.completed.length} packages successfully completed`);
+            logger.info(`  METRIC_SKIPPED_NO_CHANGES: ${result.skippedNoChanges.length} packages skipped (no changes)`);
+            logger.info(`  METRIC_SKIPPED_DEPENDENCIES: ${result.skipped.length} packages skipped (dependency failures)`);
+            logger.info(`  METRIC_FAILED: ${result.failed.length} packages failed`);
+            logger.info(`  METRIC_PEAK_CONCURRENCY: ${result.metrics.peakConcurrency} packages running simultaneously`);
+            logger.info(`  METRIC_AVG_CONCURRENCY: ${result.metrics.averageConcurrency.toFixed(1)} average concurrent packages`);
+        }
+    });
+}
+/**
+ * Simple error summary formatter (inline implementation)
+ */
+function createErrorSummary(failed) {
+    const lines = [];
+    lines.push('❌ Error Details:');
+    for (const pkg of failed) {
+        lines.push(`\n  Package: ${pkg.name}`);
+        if (pkg.error) {
+            lines.push(`  Error: ${pkg.error}`);
+        }
+        if (pkg.logFile) {
+            lines.push(`  Log: ${pkg.logFile}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Simple recovery guidance formatter (inline implementation)
+ */
+function createRecoveryGuidance(hasRetriable, hasPermanent) {
+    const lines = [];
+    if (hasRetriable) {
+        lines.push('\n💡 Some failures may be temporary (network issues, etc.)');
+        lines.push('   Consider retrying with: kodrdriv tree publish --continue');
+    }
+    if (hasPermanent) {
+        lines.push('\n⚠️  Some failures appear to be permanent');
+        lines.push('   Review and fix the issues before retrying');
+    }
+    return lines;
+}
+/**
+ * Format parallel execution result for display
+ */
+export function formatParallelResult(result) {
+    const lines = [];
+    // Separator line
+    lines.push('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    lines.push('📊 Publish Summary');
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    // Detailed status breakdown by category
+    if (result.completed.length > 0) {
+        lines.push(`✅ Published (${result.completed.length}):`);
+        for (const pkg of result.completed) {
+            lines.push(`   - ${pkg}`);
+        }
+        lines.push('');
+    }
+    if (result.skippedNoChanges.length > 0) {
+        lines.push(`⏭️  Skipped (${result.skippedNoChanges.length}) - no code changes:`);
+        for (const pkg of result.skippedNoChanges) {
+            lines.push(`   - ${pkg}`);
+        }
+        lines.push('');
+    }
+    if (result.failed.length > 0) {
+        lines.push(`❌ Failed (${result.failed.length}):`);
+        for (const pkg of result.failed) {
+            lines.push(`   - ${typeof pkg === 'string' ? pkg : pkg.name}`);
+        }
+        lines.push('');
+    }
+    if (result.skipped.length > 0) {
+        lines.push(`⊘ Skipped due to dependencies (${result.skipped.length}):`);
+        for (const pkg of result.skipped) {
+            lines.push(`   - ${pkg}`);
+        }
+        lines.push('');
+    }
+    // Summary line
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    // Calculate success rate
+    const totalProcessed = result.completed.length + result.failed.length + result.skippedNoChanges.length;
+    const successRate = totalProcessed > 0 ? Math.round((result.completed.length / totalProcessed) * 100) : 0;
+    // Format elapsed time
+    const totalTimeMs = result.metrics?.totalDuration || 0;
+    const minutes = Math.floor(totalTimeMs / 60000);
+    const seconds = Math.floor((totalTimeMs % 60000) / 1000);
+    const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+    lines.push(`Total time: ${timeStr}`);
+    lines.push(`Success rate: ${successRate}% (${result.completed.length}/${totalProcessed} packages processed)`);
+    if (result.metrics?.peakConcurrency) {
+        lines.push(`Peak concurrency: ${result.metrics.peakConcurrency} packages`);
+    }
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    // Failed packages with formatted error summary
+    if (result.failed.length > 0) {
+        lines.push('');
+        const errorLines = createErrorSummary(result.failed);
+        lines.push(...errorLines);
+        // Next steps for failures
+        lines.push('\n📋 Next steps:');
+        lines.push('1. Review the errors above for each failed package');
+        lines.push('2. Fix the issues in the failed packages');
+        lines.push('3. Retry the publish command');
+        if (result.skipped.length > 0) {
+            lines.push('\nNote: Once failed packages are fixed, their dependent packages will also be published.');
+        }
+        // Recovery guidance
+        const hasRetriable = result.failed.some((f) => f.isRetriable);
+        const hasPermanent = result.failed.some((f) => !f.isRetriable);
+        const recoveryLines = createRecoveryGuidance(hasRetriable, hasPermanent);
+        lines.push(...recoveryLines);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=TreeExecutionAdapter.js.map