@eldrforge/kodrdriv 1.2.22 → 1.2.24

package/dist/commands/tree.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import path from 'path';
+import path__default from 'path';
 import fs from 'fs/promises';
 import { exec } from 'child_process';
 import { safeJsonParse, validatePackageJson, getGloballyLinkedPackages, getGitStatusSummary, getLinkedDependencies, getLinkCompatibilityProblems, runSecure, run } from '@eldrforge/git-tools';
@@ -12,92 +12,20 @@ import { execute as execute$3 } from './commit.js';
 import { execute as execute$1 } from './link.js';
 import { execute as execute$2 } from './unlink.js';
 import { execute as execute$4 } from './updates.js';
+import { runGitWithLock } from '../util/gitMutex.js';
+import { scanForPackageJsonFiles, buildDependencyGraph, topologicalSort, parsePackageJson, shouldExclude } from '../util/dependencyGraph.js';
+import { SimpleMutex } from '../util/mutex.js';
 
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 // Global state to track published versions during tree execution - protected by mutex
 let publishedVersions = [];
 let executionContext = null;
-// Simple mutex to prevent race conditions in global state access
-class SimpleMutex {
-    async lock() {
-        return new Promise((resolve, reject)=>{
-            if (this.destroyed) {
-                reject(new Error('Mutex has been destroyed'));
-                return;
-            }
-            if (!this.locked) {
-                this.locked = true;
-                resolve();
-            } else {
-                this.queue.push(resolve);
-            }
-        });
-    }
-    unlock() {
-        if (this.destroyed) {
-            return;
-        }
-        this.locked = false;
-        const next = this.queue.shift();
-        if (next) {
-            this.locked = true;
-            try {
-                next();
-            } catch  {
-                // If resolver throws, unlock and continue with next in queue
-                this.locked = false;
-                const nextInQueue = this.queue.shift();
-                if (nextInQueue) {
-                    this.locked = true;
-                    nextInQueue();
-                }
-            }
-        }
-    }
-    destroy() {
-        this.destroyed = true;
-        this.locked = false;
-        // Reject all queued promises to prevent memory leaks
-        while(this.queue.length > 0){
-            const resolver = this.queue.shift();
-            if (resolver) {
-                try {
-                    // Treat as rejected promise to clean up
-                    resolver(new Error('Mutex destroyed'));
-                } catch  {
-                // Ignore errors from rejected resolvers
-                }
-            }
-        }
-    }
-    isDestroyed() {
-        return this.destroyed;
-    }
-    constructor(){
-        _define_property(this, "locked", false);
-        _define_property(this, "queue", []);
-        _define_property(this, "destroyed", false);
-    }
-}
 const globalStateMutex = new SimpleMutex();
 // Update inter-project dependencies in package.json based on published versions
 const updateInterProjectDependencies = async (packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun)=>{
     const storage = create({
         log: packageLogger.info
     });
-    const packageJsonPath = path.join(packageDir, 'package.json');
+    const packageJsonPath = path__default.join(packageDir, 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         packageLogger.verbose('No package.json found, skipping dependency updates');
         return false;
@@ -158,7 +86,7 @@ const updateScopedDependencies = async (packageDir, packageLogger, isDryRun, run
     const storage = create({
         log: packageLogger.info
     });
-    const packageJsonPath = path.join(packageDir, 'package.json');
+    const packageJsonPath = path__default.join(packageDir, 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         packageLogger.verbose('No package.json found, skipping scoped dependency updates');
         return false;
@@ -245,7 +173,7 @@ const saveExecutionContext = async (context, outputDirectory)=>{
     const contextFilePath = getContextFilePath(outputDirectory);
     try {
         // Ensure output directory exists
-        await storage.ensureDirectory(path.dirname(contextFilePath));
+        await storage.ensureDirectory(path__default.dirname(contextFilePath));
         // Save context with JSON serialization that handles dates
         const contextData = {
             ...context,
@@ -349,7 +277,7 @@ const validateScripts = async (packages, scripts)=>{
     });
     logger.debug(`Validating scripts: ${scripts.join(', ')}`);
     for (const [packageName, packageInfo] of packages){
-        const packageJsonPath = path.join(packageInfo.path, 'package.json');
+        const packageJsonPath = path__default.join(packageInfo.path, 'package.json');
         const missingForPackage = [];
         try {
             const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
@@ -392,7 +320,7 @@ const extractPublishedVersion = async (packageDir, packageLogger)=>{
     const storage = create({
         log: packageLogger.info
     });
-    const packageJsonPath = path.join(packageDir, 'package.json');
+    const packageJsonPath = path__default.join(packageDir, 'package.json');
     try {
         // Get package name from package.json
         const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
@@ -538,168 +466,8 @@ const formatSubprojectError = (packageName, error, _packageInfo, _position, _tot
     }
     return lines.join('\n');
 };
-const matchesPattern = (filePath, pattern)=>{
-    // Convert simple glob patterns to regex
-    const regexPattern = pattern.replace(/\\/g, '\\\\') // Escape backslashes
-    .replace(/\*\*/g, '.*') // ** matches any path segments
-    .replace(/\*/g, '[^/]*') // * matches any characters except path separator
-    .replace(/\?/g, '.') // ? matches any single character
-    .replace(/\./g, '\\.'); // Escape literal dots
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(filePath) || regex.test(path.basename(filePath));
-};
-const shouldExclude = (packageJsonPath, excludedPatterns)=>{
-    if (!excludedPatterns || excludedPatterns.length === 0) {
-        return false;
-    }
-    // Check both the full path and relative path patterns
-    const relativePath = path.relative(process.cwd(), packageJsonPath);
-    return excludedPatterns.some((pattern)=>matchesPattern(packageJsonPath, pattern) || matchesPattern(relativePath, pattern) || matchesPattern(path.dirname(packageJsonPath), pattern) || matchesPattern(path.dirname(relativePath), pattern));
-};
-const scanForPackageJsonFiles = async (directory, excludedPatterns = [])=>{
-    const logger = getLogger();
-    const packageJsonPaths = [];
-    try {
-        // First check if there's a package.json in the specified directory itself
-        const directPackageJsonPath = path.join(directory, 'package.json');
-        try {
-            await fs.access(directPackageJsonPath);
-            // Check if this package should be excluded
-            if (!shouldExclude(directPackageJsonPath, excludedPatterns)) {
-                packageJsonPaths.push(directPackageJsonPath);
-                logger.verbose(`Found package.json at: ${directPackageJsonPath}`);
-            } else {
-                logger.verbose(`Excluding package.json at: ${directPackageJsonPath} (matches exclusion pattern)`);
-            }
-        } catch  {
-        // No package.json in the root of this directory, that's fine
-        }
-        // Then scan subdirectories for package.json files
-        const entries = await fs.readdir(directory, {
-            withFileTypes: true
-        });
-        for (const entry of entries){
-            if (entry.isDirectory()) {
-                const subDirPath = path.join(directory, entry.name);
-                const packageJsonPath = path.join(subDirPath, 'package.json');
-                try {
-                    await fs.access(packageJsonPath);
-                    // Check if this package should be excluded
-                    if (shouldExclude(packageJsonPath, excludedPatterns)) {
-                        logger.verbose(`Excluding package.json at: ${packageJsonPath} (matches exclusion pattern)`);
-                        continue;
-                    }
-                    packageJsonPaths.push(packageJsonPath);
-                    logger.verbose(`Found package.json at: ${packageJsonPath}`);
-                } catch  {
-                // No package.json in this directory, continue
-                }
-            }
-        }
-    } catch (error) {
-        logger.error(`Failed to scan directory ${directory}: ${error}`);
-        throw error;
-    }
-    return packageJsonPaths;
-};
-const parsePackageJson = async (packageJsonPath)=>{
-    const logger = getLogger();
-    const storage = create({
-        log: logger.info
-    });
-    try {
-        const content = await storage.readFile(packageJsonPath, 'utf-8');
-        const parsed = safeJsonParse(content, packageJsonPath);
-        const packageJson = validatePackageJson(parsed, packageJsonPath);
-        if (!packageJson.name) {
-            throw new Error(`Package at ${packageJsonPath} has no name field`);
-        }
-        const dependencies = new Set();
-        // Collect all types of dependencies
-        const depTypes = [
-            'dependencies',
-            'devDependencies',
-            'peerDependencies',
-            'optionalDependencies'
-        ];
-        for (const depType of depTypes){
-            if (packageJson[depType]) {
-                Object.keys(packageJson[depType]).forEach((dep)=>dependencies.add(dep));
-            }
-        }
-        return {
-            name: packageJson.name,
-            version: packageJson.version || '0.0.0',
-            path: path.dirname(packageJsonPath),
-            dependencies,
-            localDependencies: new Set() // Will be populated later
-        };
-    } catch (error) {
-        logger.error(`Failed to parse package.json at ${packageJsonPath}: ${error}`);
-        throw error;
-    }
-};
-const buildDependencyGraph = async (packageJsonPaths)=>{
-    const logger = getLogger();
-    const packages = new Map();
-    const edges = new Map();
-    // First pass: parse all package.json files
-    for (const packageJsonPath of packageJsonPaths){
-        const packageInfo = await parsePackageJson(packageJsonPath);
-        packages.set(packageInfo.name, packageInfo);
-        logger.verbose(`Parsed package: ${packageInfo.name} at ${packageInfo.path}`);
-    }
-    // Second pass: identify local dependencies and build edges
-    for (const [packageName, packageInfo] of packages){
-        const localDeps = new Set();
-        const edges_set = new Set();
-        for (const dep of packageInfo.dependencies){
-            if (packages.has(dep)) {
-                localDeps.add(dep);
-                edges_set.add(dep);
-                logger.verbose(`${packageName} depends on local package: ${dep}`);
-            }
-        }
-        packageInfo.localDependencies = localDeps;
-        edges.set(packageName, edges_set);
-    }
-    return {
-        packages,
-        edges
-    };
-};
-const topologicalSort = (graph)=>{
-    const logger = getLogger();
-    const { packages, edges } = graph;
-    const visited = new Set();
-    const visiting = new Set();
-    const result = [];
-    const visit = (packageName)=>{
-        if (visited.has(packageName)) {
-            return;
-        }
-        if (visiting.has(packageName)) {
-            throw new Error(`Circular dependency detected involving package: ${packageName}`);
-        }
-        visiting.add(packageName);
-        // Visit all dependencies first
-        const deps = edges.get(packageName) || new Set();
-        for (const dep of deps){
-            visit(dep);
-        }
-        visiting.delete(packageName);
-        visited.add(packageName);
-        result.push(packageName);
-    };
-    // Visit all packages
-    for (const packageName of packages.keys()){
-        if (!visited.has(packageName)) {
-            visit(packageName);
-        }
-    }
-    logger.verbose(`Topological sort completed. Build order determined for ${result.length} packages.`);
-    return result;
-};
+// Note: PackageInfo, DependencyGraph, scanForPackageJsonFiles, parsePackageJson,
+// buildDependencyGraph, and topologicalSort are now imported from ../util/dependencyGraph
 // Execute a single package and return execution result
 const executePackage = async (packageName, packageInfo, commandToRun, runConfig, isDryRun, index, total, allPackageNames, isBuiltInCommand = false)=>{
     const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
@@ -771,58 +539,61 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     packageLogger.debug(`Changed to directory: ${packageDir}`);
                 }
                 // Handle dependency updates for publish commands before executing (skip during dry run)
+                // Wrap in git lock to prevent parallel packages from conflicting with npm install and git operations
                 if (!isDryRun && isBuiltInCommand && commandToRun.includes('publish')) {
-                    let hasAnyUpdates = false;
-                    // First, update all scoped dependencies from npm registry
-                    const hasScopedUpdates = await updateScopedDependencies(packageDir, packageLogger, isDryRun, runConfig);
-                    hasAnyUpdates = hasAnyUpdates || hasScopedUpdates;
-                    // Then update inter-project dependencies based on previously published packages
-                    if (publishedVersions.length > 0) {
-                        packageLogger.info('Updating inter-project dependencies based on previously published packages...');
-                        const hasInterProjectUpdates = await updateInterProjectDependencies(packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun);
-                        hasAnyUpdates = hasAnyUpdates || hasInterProjectUpdates;
-                    }
-                    // If either type of update occurred, commit the changes
-                    if (hasAnyUpdates) {
-                        // Commit the dependency updates using kodrdriv commit
-                        packageLogger.info('Committing dependency updates...');
-                        packageLogger.info('⏱️  This step may take a few minutes as it generates a commit message using AI...');
-                        // Add timeout wrapper around commit execution
-                        const commitTimeoutMs = 300000; // 5 minutes
-                        const commitPromise = execute$3({
-                            ...runConfig,
-                            dryRun: false
-                        });
-                        const timeoutPromise = new Promise((_, reject)=>{
-                            setTimeout(()=>reject(new Error(`Commit operation timed out after ${commitTimeoutMs / 1000} seconds`)), commitTimeoutMs);
-                        });
-                        // Add progress indicator
-                        let progressInterval = null;
-                        try {
-                            // Start progress indicator
-                            progressInterval = setInterval(()=>{
-                                packageLogger.info('⏳ Still generating commit message... (this can take 1-3 minutes)');
-                            }, 30000); // Every 30 seconds
-                            await Promise.race([
-                                commitPromise,
-                                timeoutPromise
-                            ]);
-                            packageLogger.info('✅ Dependency updates committed successfully');
-                        } catch (commitError) {
-                            if (commitError.message.includes('timed out')) {
-                                packageLogger.error(`❌ Commit operation timed out after ${commitTimeoutMs / 1000} seconds`);
-                                packageLogger.error('This usually indicates an issue with the AI service or very large changes');
-                                packageLogger.error('You may need to manually commit the dependency updates');
-                            } else {
-                                packageLogger.warn(`Failed to commit dependency updates: ${commitError.message}`);
-                            }
-                        // Continue with publish anyway - the updates are still in place
-                        } finally{
-                            if (progressInterval) {
-                                clearInterval(progressInterval);
+                    await runGitWithLock(packageDir, async ()=>{
+                        let hasAnyUpdates = false;
+                        // First, update all scoped dependencies from npm registry
+                        const hasScopedUpdates = await updateScopedDependencies(packageDir, packageLogger, isDryRun, runConfig);
+                        hasAnyUpdates = hasAnyUpdates || hasScopedUpdates;
+                        // Then update inter-project dependencies based on previously published packages
+                        if (publishedVersions.length > 0) {
+                            packageLogger.info('Updating inter-project dependencies based on previously published packages...');
+                            const hasInterProjectUpdates = await updateInterProjectDependencies(packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun);
+                            hasAnyUpdates = hasAnyUpdates || hasInterProjectUpdates;
+                        }
+                        // If either type of update occurred, commit the changes
+                        if (hasAnyUpdates) {
+                            // Commit the dependency updates using kodrdriv commit
+                            packageLogger.info('Committing dependency updates...');
+                            packageLogger.info('⏱️  This step may take a few minutes as it generates a commit message using AI...');
+                            // Add timeout wrapper around commit execution
+                            const commitTimeoutMs = 300000; // 5 minutes
+                            const commitPromise = execute$3({
+                                ...runConfig,
+                                dryRun: false
+                            });
+                            const timeoutPromise = new Promise((_, reject)=>{
+                                setTimeout(()=>reject(new Error(`Commit operation timed out after ${commitTimeoutMs / 1000} seconds`)), commitTimeoutMs);
+                            });
+                            // Add progress indicator
+                            let progressInterval = null;
+                            try {
+                                // Start progress indicator
+                                progressInterval = setInterval(()=>{
+                                    packageLogger.info('⏳ Still generating commit message... (this can take 1-3 minutes)');
+                                }, 30000); // Every 30 seconds
+                                await Promise.race([
+                                    commitPromise,
+                                    timeoutPromise
+                                ]);
+                                packageLogger.info('✅ Dependency updates committed successfully');
+                            } catch (commitError) {
+                                if (commitError.message.includes('timed out')) {
+                                    packageLogger.error(`❌ Commit operation timed out after ${commitTimeoutMs / 1000} seconds`);
+                                    packageLogger.error('This usually indicates an issue with the AI service or very large changes');
+                                    packageLogger.error('You may need to manually commit the dependency updates');
+                                } else {
+                                    packageLogger.warn(`Failed to commit dependency updates: ${commitError.message}`);
+                                }
+                            // Continue with publish anyway - the updates are still in place
+                            } finally{
+                                if (progressInterval) {
+                                    clearInterval(progressInterval);
+                                }
                             }
                         }
-                    }
+                    }, `${packageName}: dependency updates`);
                 }
                 if (runConfig.debug || runConfig.verbose) {
                     if (isBuiltInCommand) {
@@ -981,7 +752,7 @@ const checkTreePublishStatus = async ()=>{
     }
 };
 const execute = async (runConfig)=>{
-    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5, _runConfig_tree6, _runConfig_tree7;
+    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5, _runConfig_tree6, _runConfig_tree7, _runConfig_tree8, _runConfig_tree9, _runConfig_tree10, _runConfig_tree11, _runConfig_tree12, _runConfig_tree13, _runConfig_tree14;
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
     const isContinue = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.continue) || false;
@@ -1004,6 +775,109 @@ const execute = async (runConfig)=>{
         logger.info('You can now run the tree command with --continue to resume from the next package.');
         return `Package '${promotePackage}' promoted to completed status.`;
     }
+    // Handle parallel execution recovery commands
+    const { loadRecoveryManager } = await import('../execution/RecoveryManager.js');
+    // Handle status-parallel command
+    if ((_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.statusParallel) {
+        var _runConfig_tree15, _runConfig_tree16;
+        logger.info('📊 Checking parallel execution status...');
+        // Need to build dependency graph first
+        const directories = ((_runConfig_tree15 = runConfig.tree) === null || _runConfig_tree15 === void 0 ? void 0 : _runConfig_tree15.directories) || [
+            process.cwd()
+        ];
+        const excludedPatterns = ((_runConfig_tree16 = runConfig.tree) === null || _runConfig_tree16 === void 0 ? void 0 : _runConfig_tree16.exclude) || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        if (allPackageJsonPaths.length === 0) {
+            return 'No packages found';
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const recoveryManager = await loadRecoveryManager(dependencyGraph, runConfig.outputDirectory);
+        if (!recoveryManager) {
+            logger.info('No parallel execution checkpoint found');
+            return 'No active parallel execution found';
+        }
+        const status = await recoveryManager.showStatus();
+        logger.info('\n' + status);
+        return status;
+    }
+    // Handle validate-state command
+    if ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.validateState) {
+        var _runConfig_tree17, _runConfig_tree18;
+        logger.info('🔍 Validating checkpoint state...');
+        const directories = ((_runConfig_tree17 = runConfig.tree) === null || _runConfig_tree17 === void 0 ? void 0 : _runConfig_tree17.directories) || [
+            process.cwd()
+        ];
+        const excludedPatterns = ((_runConfig_tree18 = runConfig.tree) === null || _runConfig_tree18 === void 0 ? void 0 : _runConfig_tree18.exclude) || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        if (allPackageJsonPaths.length === 0) {
+            return 'No packages found';
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const recoveryManager = await loadRecoveryManager(dependencyGraph, runConfig.outputDirectory);
+        if (!recoveryManager) {
+            logger.info('No checkpoint found to validate');
+            return 'No checkpoint found';
+        }
+        const validation = recoveryManager.validateState();
+        if (validation.valid) {
+            logger.info('✅ Checkpoint state is valid');
+        } else {
+            logger.error('❌ Checkpoint state has issues:');
+            for (const issue of validation.issues){
+                logger.error(`  • ${issue}`);
+            }
+        }
+        if (validation.warnings.length > 0) {
+            logger.warn('⚠️  Warnings:');
+            for (const warning of validation.warnings){
+                logger.warn(`  • ${warning}`);
+            }
+        }
+        return validation.valid ? 'Checkpoint is valid' : 'Checkpoint has issues';
+    }
+    // Handle parallel execution recovery options (must happen before main execution)
+    const hasRecoveryOptions = ((_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.markCompleted) || ((_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.skipPackages) || ((_runConfig_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.retryFailed) || ((_runConfig_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.skipFailed) || ((_runConfig_tree10 = runConfig.tree) === null || _runConfig_tree10 === void 0 ? void 0 : _runConfig_tree10.resetPackage);
+    if (hasRecoveryOptions && runConfig.tree) {
+        var _runConfig_tree_retry;
+        logger.info('🔧 Applying recovery options...');
+        // Build dependency graph
+        const directories = runConfig.tree.directories || [
+            process.cwd()
+        ];
+        const excludedPatterns = runConfig.tree.exclude || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const recoveryManager = await loadRecoveryManager(dependencyGraph, runConfig.outputDirectory);
+        if (!recoveryManager) {
+            logger.error('No checkpoint found for recovery');
+            throw new Error('No checkpoint found. Cannot apply recovery options without an existing checkpoint.');
+        }
+        await recoveryManager.applyRecoveryOptions({
+            markCompleted: runConfig.tree.markCompleted,
+            skipPackages: runConfig.tree.skipPackages,
+            retryFailed: runConfig.tree.retryFailed,
+            skipFailed: runConfig.tree.skipFailed,
+            resetPackage: runConfig.tree.resetPackage,
+            maxRetries: (_runConfig_tree_retry = runConfig.tree.retry) === null || _runConfig_tree_retry === void 0 ? void 0 : _runConfig_tree_retry.maxAttempts
+        });
+        logger.info('✅ Recovery options applied');
+        // If not also continuing, just return
+        if (!isContinue) {
+            return 'Recovery options applied. Use --continue to resume execution.';
+        }
+    }
     // Handle continue mode
     if (isContinue) {
         const savedContext = await loadExecutionContext(runConfig.outputDirectory);
@@ -1042,7 +916,7 @@ const execute = async (runConfig)=>{
         executionContext = null;
     }
     // Check if we're in built-in command mode (tree command with second argument)
-    const builtInCommand = (_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.builtInCommand;
+    const builtInCommand = (_runConfig_tree11 = runConfig.tree) === null || _runConfig_tree11 === void 0 ? void 0 : _runConfig_tree11.builtInCommand;
     const supportedBuiltInCommands = [
         'commit',
         'publish',
@@ -1059,8 +933,8 @@ const execute = async (runConfig)=>{
     }
     // Handle run subcommand - convert space-separated scripts to npm run commands
     if (builtInCommand === 'run') {
-        var _runConfig_tree8;
-        const packageArgument = (_runConfig_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.packageArgument;
+        var _runConfig_tree19;
+        const packageArgument = (_runConfig_tree19 = runConfig.tree) === null || _runConfig_tree19 === void 0 ? void 0 : _runConfig_tree19.packageArgument;
         if (!packageArgument) {
             throw new Error('run subcommand requires script names. Usage: kodrdriv tree run "clean build test"');
         }
@@ -1083,11 +957,11 @@ const execute = async (runConfig)=>{
         runConfig.__scriptsToValidate = scripts;
     }
     // Determine the target directories - either specified or current working directory
-    const directories = ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.directories) || [
+    const directories = ((_runConfig_tree12 = runConfig.tree) === null || _runConfig_tree12 === void 0 ? void 0 : _runConfig_tree12.directories) || [
         process.cwd()
     ];
     // Handle link status subcommand
-    if (builtInCommand === 'link' && ((_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.packageArgument) === 'status') {
+    if (builtInCommand === 'link' && ((_runConfig_tree13 = runConfig.tree) === null || _runConfig_tree13 === void 0 ? void 0 : _runConfig_tree13.packageArgument) === 'status') {
         // For tree link status, we want to show status across all packages
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running link status across workspace...`);
         // Create a config that will be passed to the link command
@@ -1107,7 +981,7 @@ const execute = async (runConfig)=>{
         }
     }
     // Handle unlink status subcommand
-    if (builtInCommand === 'unlink' && ((_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.packageArgument) === 'status') {
+    if (builtInCommand === 'unlink' && ((_runConfig_tree14 = runConfig.tree) === null || _runConfig_tree14 === void 0 ? void 0 : _runConfig_tree14.packageArgument) === 'status') {
         // For tree unlink status, we want to show status across all packages
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running unlink status across workspace...`);
         // Create a config that will be passed to the unlink command
@@ -1132,9 +1006,9 @@ const execute = async (runConfig)=>{
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${directories.join(', ')}`);
     }
     try {
-        var _runConfig_tree9, _runConfig_tree10, _runConfig_tree11, _runConfig_tree12;
+        var _runConfig_tree20, _runConfig_tree21, _runConfig_tree22, _runConfig_tree23;
         // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.exclude) || [];
+        const excludedPatterns = ((_runConfig_tree20 = runConfig.tree) === null || _runConfig_tree20 === void 0 ? void 0 : _runConfig_tree20.exclude) || [];
         if (excludedPatterns.length > 0) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
         }
@@ -1161,13 +1035,13 @@ const execute = async (runConfig)=>{
         logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Determining build order...`);
         let buildOrder = topologicalSort(dependencyGraph);
         // Handle start-from functionality if specified
-        const startFrom = (_runConfig_tree10 = runConfig.tree) === null || _runConfig_tree10 === void 0 ? void 0 : _runConfig_tree10.startFrom;
+        const startFrom = (_runConfig_tree21 = runConfig.tree) === null || _runConfig_tree21 === void 0 ? void 0 : _runConfig_tree21.startFrom;
         if (startFrom) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for start package: ${startFrom}`);
             // Resolve the actual package name (can be package name or directory name)
             let startPackageName = null;
             for (const [pkgName, pkgInfo] of dependencyGraph.packages){
-                const dirName = path.basename(pkgInfo.path);
+                const dirName = path__default.basename(pkgInfo.path);
                 if (dirName === startFrom || pkgName === startFrom) {
                     startPackageName = pkgName;
                     break;
@@ -1184,7 +1058,7 @@ const execute = async (runConfig)=>{
                 for (const packageJsonPath of allPackageJsonPathsForCheck){
                     try {
                         const packageInfo = await parsePackageJson(packageJsonPath);
-                        const dirName = path.basename(packageInfo.path);
+                        const dirName = path__default.basename(packageInfo.path);
                         if (dirName === startFrom || packageInfo.name === startFrom) {
                             // Check if this package was excluded
                             if (shouldExclude(packageJsonPath, excludedPatterns)) {
@@ -1202,7 +1076,7 @@ const execute = async (runConfig)=>{
                 } else {
                     const availablePackages = buildOrder.map((name)=>{
                         const packageInfo = dependencyGraph.packages.get(name);
-                        return `${path.basename(packageInfo.path)} (${name})`;
+                        return `${path__default.basename(packageInfo.path)} (${name})`;
                     }).join(', ');
                     throw new Error(`Package directory '${startFrom}' not found. Available packages: ${availablePackages}`);
                 }
@@ -1218,13 +1092,13 @@ const execute = async (runConfig)=>{
             logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Starting execution from package '${startFrom}' (${buildOrder.length} of ${originalLength} packages remaining).`);
         }
         // Handle stop-at functionality if specified
-        const stopAt = (_runConfig_tree11 = runConfig.tree) === null || _runConfig_tree11 === void 0 ? void 0 : _runConfig_tree11.stopAt;
+        const stopAt = (_runConfig_tree22 = runConfig.tree) === null || _runConfig_tree22 === void 0 ? void 0 : _runConfig_tree22.stopAt;
         if (stopAt) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for stop package: ${stopAt}`);
             // Find the package that matches the stopAt directory name
             const stopIndex = buildOrder.findIndex((packageName)=>{
                 const packageInfo = dependencyGraph.packages.get(packageName);
-                const dirName = path.basename(packageInfo.path);
+                const dirName = path__default.basename(packageInfo.path);
                 return dirName === stopAt || packageName === stopAt;
             });
             if (stopIndex === -1) {
@@ -1238,7 +1112,7 @@ const execute = async (runConfig)=>{
                 for (const packageJsonPath of allPackageJsonPathsForCheck){
                     try {
                         const packageInfo = await parsePackageJson(packageJsonPath);
-                        const dirName = path.basename(packageInfo.path);
+                        const dirName = path__default.basename(packageInfo.path);
                         if (dirName === stopAt || packageInfo.name === stopAt) {
                             // Check if this package was excluded
                             if (shouldExclude(packageJsonPath, excludedPatterns)) {
@@ -1256,7 +1130,7 @@ const execute = async (runConfig)=>{
                 } else {
                     const availablePackages = buildOrder.map((name)=>{
                         const packageInfo = dependencyGraph.packages.get(name);
-                        return `${path.basename(packageInfo.path)} (${name})`;
+                        return `${path__default.basename(packageInfo.path)} (${name})`;
                     }).join(', ');
                     throw new Error(`Package directory '${stopAt}' not found. Available packages: ${availablePackages}`);
                 }
@@ -1301,7 +1175,7 @@ const execute = async (runConfig)=>{
             for (const [packageName, packageInfo] of allPackages){
                 if (packageName === targetPackageName) continue;
                 try {
-                    const packageJsonPath = path.join(packageInfo.path, 'package.json');
+                    const packageJsonPath = path__default.join(packageInfo.path, 'package.json');
                     const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
                     const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
                     const packageJson = validatePackageJson(parsed, packageJsonPath);
@@ -1537,8 +1411,8 @@ const execute = async (runConfig)=>{
         }
         // Handle special "checkout" command that switches all packages to specified branch
         if (builtInCommand === 'checkout') {
-            var _runConfig_tree13;
-            const targetBranch = (_runConfig_tree13 = runConfig.tree) === null || _runConfig_tree13 === void 0 ? void 0 : _runConfig_tree13.packageArgument;
+            var _runConfig_tree24;
+            const targetBranch = (_runConfig_tree24 = runConfig.tree) === null || _runConfig_tree24 === void 0 ? void 0 : _runConfig_tree24.packageArgument;
             if (!targetBranch) {
                 throw new Error('checkout subcommand requires a branch name. Usage: kodrdriv tree checkout <branch-name>');
             }
@@ -1717,12 +1591,12 @@ const execute = async (runConfig)=>{
             returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
         }
         // Execute command if provided (custom command or built-in command)
-        const cmd = (_runConfig_tree12 = runConfig.tree) === null || _runConfig_tree12 === void 0 ? void 0 : _runConfig_tree12.cmd;
+        const cmd = (_runConfig_tree23 = runConfig.tree) === null || _runConfig_tree23 === void 0 ? void 0 : _runConfig_tree23.cmd;
         // Determine command to execute
         let commandToRun;
         let isBuiltInCommand = false;
         if (builtInCommand) {
-            var _runConfig_tree14, _runConfig_tree15, _runConfig_tree16;
+            var _runConfig_tree25, _runConfig_tree26, _runConfig_tree27;
             // Built-in command mode: shell out to kodrdriv subprocess
             // Build command with propagated global options
             const globalOptions = [];
@@ -1739,14 +1613,14 @@ const execute = async (runConfig)=>{
             // Build the command with global options
             const optionsString = globalOptions.length > 0 ? ` ${globalOptions.join(' ')}` : '';
             // Add package argument for link/unlink/updates commands
-            const packageArg = (_runConfig_tree14 = runConfig.tree) === null || _runConfig_tree14 === void 0 ? void 0 : _runConfig_tree14.packageArgument;
+            const packageArg = (_runConfig_tree25 = runConfig.tree) === null || _runConfig_tree25 === void 0 ? void 0 : _runConfig_tree25.packageArgument;
             const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink' || builtInCommand === 'updates') ? ` "${packageArg}"` : '';
             // Add command-specific options
             let commandSpecificOptions = '';
-            if (builtInCommand === 'unlink' && ((_runConfig_tree15 = runConfig.tree) === null || _runConfig_tree15 === void 0 ? void 0 : _runConfig_tree15.cleanNodeModules)) {
+            if (builtInCommand === 'unlink' && ((_runConfig_tree26 = runConfig.tree) === null || _runConfig_tree26 === void 0 ? void 0 : _runConfig_tree26.cleanNodeModules)) {
                 commandSpecificOptions += ' --clean-node-modules';
             }
-            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree16 = runConfig.tree) === null || _runConfig_tree16 === void 0 ? void 0 : _runConfig_tree16.externals) && runConfig.tree.externals.length > 0) {
+            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree27 = runConfig.tree) === null || _runConfig_tree27 === void 0 ? void 0 : _runConfig_tree27.externals) && runConfig.tree.externals.length > 0) {
                 commandSpecificOptions += ` --externals ${runConfig.tree.externals.join(' ')}`;
             }
             commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;
@@ -1756,6 +1630,7 @@ const execute = async (runConfig)=>{
             commandToRun = cmd;
         }
         if (commandToRun) {
+            var _runConfig_tree28, _runConfig_tree29;
             // Validate scripts for run command before execution
             const scriptsToValidate = runConfig.__scriptsToValidate;
             if (scriptsToValidate && scriptsToValidate.length > 0) {
@@ -1773,6 +1648,27 @@ const execute = async (runConfig)=>{
                     throw new Error('Script validation failed. See details above.');
                 }
             }
+            // Validate command for parallel execution if parallel mode is enabled
+            if ((_runConfig_tree28 = runConfig.tree) === null || _runConfig_tree28 === void 0 ? void 0 : _runConfig_tree28.parallel) {
+                const { CommandValidator } = await import('../execution/CommandValidator.js');
+                const validation = CommandValidator.validateForParallel(commandToRun, builtInCommand);
+                CommandValidator.logValidation(validation);
+                if (!validation.valid) {
+                    logger.error('');
+                    logger.error('Cannot proceed with parallel execution due to validation errors.');
+                    logger.error('Run without --parallel flag to execute sequentially.');
+                    throw new Error('Command validation failed for parallel execution');
+                }
+                // Apply recommended concurrency if not explicitly set
+                if (!runConfig.tree.maxConcurrency && builtInCommand) {
+                    const os = await import('os');
+                    const recommended = CommandValidator.getRecommendedConcurrency(builtInCommand, os.cpus().length);
+                    if (recommended !== os.cpus().length) {
+                        logger.info(`💡 Using recommended concurrency for ${builtInCommand}: ${recommended}`);
+                        runConfig.tree.maxConcurrency = recommended;
+                    }
+                }
+            }
             // Create set of all package names for inter-project dependency detection
             const allPackageNames = new Set(Array.from(dependencyGraph.packages.keys()));
             // Initialize execution context if not continuing
@@ -1803,6 +1699,34 @@ const execute = async (runConfig)=>{
             let failedPackage = null;
             // If continuing, start from where we left off
             const startIndex = isContinue && executionContext ? executionContext.completedPackages.length : 0;
+            // Check if parallel execution is enabled
+            if ((_runConfig_tree29 = runConfig.tree) === null || _runConfig_tree29 === void 0 ? void 0 : _runConfig_tree29.parallel) {
+                var _runConfig_tree_retry1, _runConfig_tree_retry2, _runConfig_tree_retry3, _runConfig_tree_retry4;
+                logger.info('🚀 Using parallel execution mode');
+                // Import parallel execution components
+                const { TreeExecutionAdapter, createParallelProgressLogger, formatParallelResult } = await import('../execution/TreeExecutionAdapter.js');
+                const os = await import('os');
+                // Create task pool
+                const adapter = new TreeExecutionAdapter({
+                    graph: dependencyGraph,
+                    maxConcurrency: runConfig.tree.maxConcurrency || os.cpus().length,
+                    command: commandToRun,
+                    config: runConfig,
+                    checkpointPath: runConfig.outputDirectory,
+                    continue: isContinue,
+                    maxRetries: ((_runConfig_tree_retry1 = runConfig.tree.retry) === null || _runConfig_tree_retry1 === void 0 ? void 0 : _runConfig_tree_retry1.maxAttempts) || 3,
+                    initialRetryDelay: ((_runConfig_tree_retry2 = runConfig.tree.retry) === null || _runConfig_tree_retry2 === void 0 ? void 0 : _runConfig_tree_retry2.initialDelayMs) || 5000,
+                    maxRetryDelay: ((_runConfig_tree_retry3 = runConfig.tree.retry) === null || _runConfig_tree_retry3 === void 0 ? void 0 : _runConfig_tree_retry3.maxDelayMs) || 60000,
+                    backoffMultiplier: ((_runConfig_tree_retry4 = runConfig.tree.retry) === null || _runConfig_tree_retry4 === void 0 ? void 0 : _runConfig_tree_retry4.backoffMultiplier) || 2
+                }, executePackage);
+                // Set up progress logging
+                createParallelProgressLogger(adapter.getPool(), runConfig);
+                // Execute
+                const result = await adapter.execute();
+                // Format and return result
+                const formattedResult = formatParallelResult(result);
+                return formattedResult;
+            }
             // Sequential execution
             for(let i = startIndex; i < buildOrder.length; i++){
                 const packageName = buildOrder[i];
@@ -1926,5 +1850,5 @@ const execute = async (runConfig)=>{
     }
 };
 
-export { execute };
+export { execute, executePackage };
 //# sourceMappingURL=tree.js.map