@eldrforge/kodrdriv 0.0.47 → 0.0.49

package/dist/commands/tree.js

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+import path from 'path';
+import fs from 'fs/promises';
+import { exec } from 'child_process';
+import util from 'util';
+import { getLogger } from '../logging.js';
+import { create } from '../util/storage.js';
+import { safeJsonParse, validatePackageJson } from '../util/validation.js';
+
+// Enhanced run function that can show output based on log level
+const runWithLogging = async (command, packageLogger, options = {}, showOutput = 'none')=>{
+    const execPromise = util.promisify(exec);
+    if (showOutput === 'full') {
+        packageLogger.debug(`Executing command: ${command}`);
+        // Use info level to show on console in debug mode
+        packageLogger.info(`🔧 Running: ${command}`);
+    } else if (showOutput === 'minimal') {
+        packageLogger.verbose(`Running: ${command}`);
+    }
+    try {
+        const result = await execPromise(command, options);
+        if (showOutput === 'full') {
+            if (result.stdout.trim()) {
+                packageLogger.debug('STDOUT:');
+                packageLogger.debug(result.stdout);
+                // Show on console using info level for immediate feedback
+                packageLogger.info(`📤 STDOUT:`);
+                result.stdout.split('\n').forEach((line)=>{
+                    if (line.trim()) packageLogger.info(`${line}`);
+                });
+            }
+            if (result.stderr.trim()) {
+                packageLogger.debug('STDERR:');
+                packageLogger.debug(result.stderr);
+                // Show on console using info level for immediate feedback
+                packageLogger.info(`⚠️  STDERR:`);
+                result.stderr.split('\n').forEach((line)=>{
+                    if (line.trim()) packageLogger.info(`${line}`);
+                });
+            }
+        }
+        return result;
+    } catch (error) {
+        if (showOutput === 'full' || showOutput === 'minimal') {
+            packageLogger.error(`Command failed: ${command}`);
+            if (error.stdout && showOutput === 'full') {
+                packageLogger.debug('STDOUT:');
+                packageLogger.debug(error.stdout);
+                packageLogger.info(`📤 STDOUT:`);
+                error.stdout.split('\n').forEach((line)=>{
+                    if (line.trim()) packageLogger.info(`${line}`);
+                });
+            }
+            if (error.stderr && showOutput === 'full') {
+                packageLogger.debug('STDERR:');
+                packageLogger.debug(error.stderr);
+                packageLogger.info(`❌ STDERR:`);
+                error.stderr.split('\n').forEach((line)=>{
+                    if (line.trim()) packageLogger.info(`${line}`);
+                });
+            }
+        }
+        throw error;
+    }
+};
+// Create a package-scoped logger that prefixes all messages
+const createPackageLogger = (packageName, sequenceNumber, totalCount, isDryRun = false)=>{
+    const baseLogger = getLogger();
+    const prefix = `[${sequenceNumber}/${totalCount}] ${packageName}:`;
+    const dryRunPrefix = isDryRun ? 'DRY RUN: ' : '';
+    return {
+        info: (message, ...args)=>baseLogger.info(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        warn: (message, ...args)=>baseLogger.warn(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        error: (message, ...args)=>baseLogger.error(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        debug: (message, ...args)=>baseLogger.debug(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        verbose: (message, ...args)=>baseLogger.verbose(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        silly: (message, ...args)=>baseLogger.silly(`${dryRunPrefix}${prefix} ${message}`, ...args)
+    };
+};
+// Helper function to format subproject error output
+const formatSubprojectError = (packageName, error)=>{
+    const lines = [];
+    lines.push(`❌ Command failed in package ${packageName}:`);
+    // Format the main error message with indentation
+    if (error.message) {
+        const indentedMessage = error.message.split('\n').map((line)=>`    ${line}`).join('\n');
+        lines.push(indentedMessage);
+    }
+    // If there's stderr output, show it indented as well
+    if (error.stderr && error.stderr.trim()) {
+        lines.push('    STDERR:');
+        const indentedStderr = error.stderr.split('\n').filter((line)=>line.trim()).map((line)=>`      ${line}`).join('\n');
+        lines.push(indentedStderr);
+    }
+    // If there's stdout output, show it indented as well
+    if (error.stdout && error.stdout.trim()) {
+        lines.push('    STDOUT:');
+        const indentedStdout = error.stdout.split('\n').filter((line)=>line.trim()).map((line)=>`      ${line}`).join('\n');
+        lines.push(indentedStdout);
+    }
+    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;
+};
+// Group packages into dependency levels for parallel execution
+const groupPackagesByDependencyLevels = (graph, buildOrder, runConfig)=>{
+    const logger = getLogger();
+    const { edges } = graph;
+    const levels = [];
+    const packageLevels = new Map();
+    // Calculate the dependency level for each package
+    const calculateLevel = (packageName)=>{
+        if (packageLevels.has(packageName)) {
+            return packageLevels.get(packageName);
+        }
+        const deps = edges.get(packageName) || new Set();
+        if (deps.size === 0) {
+            // No dependencies - this is level 0
+            packageLevels.set(packageName, 0);
+            if (runConfig === null || runConfig === void 0 ? void 0 : runConfig.debug) {
+                logger.debug(`${packageName}: Level 0 (no local dependencies)`);
+            }
+            return 0;
+        }
+        // Level is 1 + max level of dependencies
+        let maxDepLevel = -1;
+        for (const dep of deps){
+            const depLevel = calculateLevel(dep);
+            maxDepLevel = Math.max(maxDepLevel, depLevel);
+        }
+        const level = maxDepLevel + 1;
+        packageLevels.set(packageName, level);
+        if (runConfig === null || runConfig === void 0 ? void 0 : runConfig.debug) {
+            const depsList = Array.from(deps).join(', ');
+            logger.debug(`${packageName}: Level ${level} (depends on: ${depsList})`);
+        }
+        return level;
+    };
+    // Calculate levels for all packages
+    for (const packageName of buildOrder){
+        calculateLevel(packageName);
+    }
+    // Group packages by their levels
+    for (const packageName of buildOrder){
+        const level = packageLevels.get(packageName);
+        while(levels.length <= level){
+            levels.push([]);
+        }
+        levels[level].push(packageName);
+    }
+    // Only show grouping info if verbose or debug mode is enabled
+    if ((runConfig === null || runConfig === void 0 ? void 0 : runConfig.verbose) || (runConfig === null || runConfig === void 0 ? void 0 : runConfig.debug)) {
+        logger.verbose(`Packages grouped into ${levels.length} dependency levels for parallel execution`);
+        for(let i = 0; i < levels.length; i++){
+            logger.verbose(`  Level ${i}: ${levels[i].join(', ')}`);
+        }
+    }
+    return levels;
+};
+// Execute a single package and return execution result
+const executePackage = async (packageName, packageInfo, commandToRun, runConfig, isDryRun, index, total, isBuiltInCommand = false)=>{
+    const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
+    const packageDir = packageInfo.path;
+    const logger = getLogger();
+    // Determine output level based on flags
+    let showOutput = 'none';
+    if (runConfig.debug) {
+        showOutput = 'full';
+    } else if (runConfig.verbose) {
+        showOutput = 'minimal';
+    }
+    // Show package start info - always visible for progress tracking
+    if (runConfig.debug) {
+        packageLogger.debug(`Starting execution in ${packageDir}`);
+        packageLogger.debug(`Command: ${commandToRun}`);
+    } else if (runConfig.verbose) {
+        packageLogger.verbose(`Starting execution in ${packageDir}`);
+    } else {
+        // Basic progress info even without flags
+        logger.info(`[${index + 1}/${total}] ${packageName}: Running ${commandToRun}...`);
+    }
+    try {
+        if (isDryRun) {
+            // Use main logger for the specific message tests expect
+            logger.info(`DRY RUN: Would execute: ${commandToRun}`);
+            if (runConfig.debug || runConfig.verbose) {
+                packageLogger.info(`In directory: ${packageDir}`);
+            }
+        } else {
+            // Change to the package directory and run the command
+            const originalCwd = process.cwd();
+            try {
+                process.chdir(packageDir);
+                if (runConfig.debug) {
+                    packageLogger.debug(`Changed to directory: ${packageDir}`);
+                }
+                if (runConfig.debug || runConfig.verbose) {
+                    if (isBuiltInCommand) {
+                        packageLogger.info(`Executing built-in command: ${commandToRun}`);
+                    } else {
+                        packageLogger.info(`Executing command: ${commandToRun}`);
+                    }
+                }
+                // For built-in commands, shell out to a separate kodrdriv process
+                // This preserves individual project configurations
+                if (isBuiltInCommand) {
+                    // Extract the command name from "kodrdriv <command>"
+                    const builtInCommandName = commandToRun.replace('kodrdriv ', '');
+                    if (runConfig.debug) {
+                        packageLogger.debug(`Shelling out to separate kodrdriv process for ${builtInCommandName} command`);
+                    }
+                    // Use runWithLogging for built-in commands to capture all output
+                    await runWithLogging(commandToRun, packageLogger, {}, showOutput);
+                } else {
+                    // For custom commands, use the existing logic
+                    await runWithLogging(commandToRun, packageLogger, {}, showOutput);
+                }
+                if (runConfig.debug || runConfig.verbose) {
+                    packageLogger.info(`Command completed successfully`);
+                } else {
+                    // Basic completion info
+                    logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+                }
+            } finally{
+                process.chdir(originalCwd);
+                if (runConfig.debug) {
+                    packageLogger.debug(`Restored working directory to: ${originalCwd}`);
+                }
+            }
+        }
+        return {
+            success: true
+        };
+    } catch (error) {
+        if (runConfig.debug || runConfig.verbose) {
+            packageLogger.error(`❌ Execution failed: ${error.message}`);
+        } else {
+            logger.error(`[${index + 1}/${total}] ${packageName}: ❌ Failed - ${error.message}`);
+        }
+        return {
+            success: false,
+            error
+        };
+    }
+};
+const execute = async (runConfig)=>{
+    var _runConfig_tree, _runConfig_tree1;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    // Check if we're in built-in command mode (tree command with second argument)
+    const builtInCommand = (_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.builtInCommand;
+    const supportedBuiltInCommands = [
+        'commit',
+        'publish',
+        'link',
+        'unlink'
+    ];
+    if (builtInCommand && !supportedBuiltInCommands.includes(builtInCommand)) {
+        throw new Error(`Unsupported built-in command: ${builtInCommand}. Supported commands: ${supportedBuiltInCommands.join(', ')}`);
+    }
+    // Determine the target directories - either specified or current working directory
+    const targetDirectories = ((_runConfig_tree1 = runConfig.tree) === null || _runConfig_tree1 === void 0 ? void 0 : _runConfig_tree1.directories) || [
+        process.cwd()
+    ];
+    if (targetDirectories.length === 1) {
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspace at: ${targetDirectories[0]}`);
+    } else {
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${targetDirectories.join(', ')}`);
+    }
+    try {
+        var _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5;
+        // Get exclusion patterns from config, fallback to empty array
+        const excludedPatterns = ((_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.excludedPatterns) || [];
+        if (excludedPatterns.length > 0) {
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
+        }
+        // Scan for package.json files across all directories
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Scanning for package.json files...`);
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of targetDirectories){
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Scanning directory: ${targetDirectory}`);
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        const packageJsonPaths = allPackageJsonPaths;
+        if (packageJsonPaths.length === 0) {
+            const directoriesStr = targetDirectories.join(', ');
+            const message = `No package.json files found in subdirectories of: ${directoriesStr}`;
+            logger.warn(message);
+            return message;
+        }
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Found ${packageJsonPaths.length} package.json files`);
+        // Build dependency graph
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Building dependency graph...`);
+        const dependencyGraph = await buildDependencyGraph(packageJsonPaths);
+        // Perform topological sort to determine build order
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Determining build order...`);
+        let buildOrder = topologicalSort(dependencyGraph);
+        // Handle start-from functionality if specified
+        const startFrom = (_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.startFrom;
+        if (startFrom) {
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for start package: ${startFrom}`);
+            // Find the package that matches the startFrom directory name
+            const startIndex = buildOrder.findIndex((packageName)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const dirName = path.basename(packageInfo.path);
+                return dirName === startFrom || packageName === startFrom;
+            });
+            if (startIndex === -1) {
+                // Check if the package exists but was excluded across all directories
+                let allPackageJsonPathsForCheck = [];
+                for (const targetDirectory of targetDirectories){
+                    const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, []); // No exclusions
+                    allPackageJsonPathsForCheck = allPackageJsonPathsForCheck.concat(packageJsonPaths);
+                }
+                let wasExcluded = false;
+                for (const packageJsonPath of allPackageJsonPathsForCheck){
+                    try {
+                        const packageInfo = await parsePackageJson(packageJsonPath);
+                        const dirName = path.basename(packageInfo.path);
+                        if (dirName === startFrom || packageInfo.name === startFrom) {
+                            // Check if this package was excluded
+                            if (shouldExclude(packageJsonPath, excludedPatterns)) {
+                                wasExcluded = true;
+                                break;
+                            }
+                        }
+                    } catch  {
+                        continue;
+                    }
+                }
+                if (wasExcluded) {
+                    const excludedPatternsStr = excludedPatterns.join(', ');
+                    throw new Error(`Package directory '${startFrom}' was excluded by exclusion patterns: ${excludedPatternsStr}. Remove the exclusion pattern or choose a different starting package.`);
+                } else {
+                    const availablePackages = buildOrder.map((name)=>{
+                        const packageInfo = dependencyGraph.packages.get(name);
+                        return `${path.basename(packageInfo.path)} (${name})`;
+                    }).join(', ');
+                    throw new Error(`Package directory '${startFrom}' not found. Available packages: ${availablePackages}`);
+                }
+            }
+            const skippedCount = startIndex;
+            buildOrder = buildOrder.slice(startIndex);
+            if (skippedCount > 0) {
+                logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Resuming from '${startFrom}' - skipping ${skippedCount} package${skippedCount === 1 ? '' : 's'}`);
+            }
+        }
+        // Display results
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Build order determined:`);
+        let returnOutput = '';
+        if (runConfig.verbose || runConfig.debug) {
+            // Verbose mode: Skip simple format, show detailed format before command execution
+            logger.info(''); // Add spacing
+            logger.info(`Detailed Build Order for ${buildOrder.length} packages${startFrom ? ` (starting from ${startFrom})` : ''}:`);
+            logger.info('==========================================');
+            buildOrder.forEach((packageName, index)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const localDeps = Array.from(packageInfo.localDependencies);
+                logger.info(`${index + 1}. ${packageName} (${packageInfo.version})`);
+                logger.info(`   Path: ${packageInfo.path}`);
+                if (localDeps.length > 0) {
+                    logger.info(`   Local Dependencies: ${localDeps.join(', ')}`);
+                } else {
+                    logger.info(`   Local Dependencies: none`);
+                }
+                logger.info(''); // Add spacing between packages
+            });
+            // Simple return output for verbose mode (no need to repeat detailed info)
+            returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
+        } else {
+            // Non-verbose mode: Show simple build order
+            buildOrder.forEach((packageName, index)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const localDeps = Array.from(packageInfo.localDependencies);
+                // Log each step
+                if (localDeps.length > 0) {
+                    logger.info(`${index + 1}. ${packageName} (depends on: ${localDeps.join(', ')})`);
+                } else {
+                    logger.info(`${index + 1}. ${packageName} (no local dependencies)`);
+                }
+            });
+            // Simple return output for non-verbose mode
+            returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
+        }
+        // Execute command if provided (custom command or built-in command)
+        const cmd = (_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.cmd;
+        const useParallel = ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.parallel) || false;
+        // Determine command to execute
+        let commandToRun;
+        let isBuiltInCommand = false;
+        if (builtInCommand) {
+            // Built-in command mode: shell out to kodrdriv subprocess
+            commandToRun = `kodrdriv ${builtInCommand}`;
+            isBuiltInCommand = true;
+        } else if (cmd) {
+            // Custom command mode
+            commandToRun = cmd;
+        }
+        if (commandToRun) {
+            // Add spacing before command execution
+            logger.info('');
+            const executionDescription = isBuiltInCommand ? `built-in command "${builtInCommand}"` : `"${commandToRun}"`;
+            const parallelInfo = useParallel ? ' (with parallel execution)' : '';
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Executing ${executionDescription} in ${buildOrder.length} packages${parallelInfo}...`);
+            let successCount = 0;
+            let failedPackage = null;
+            if (useParallel) {
+                // Parallel execution: group packages by dependency levels
+                const dependencyLevels = groupPackagesByDependencyLevels(dependencyGraph, buildOrder, runConfig);
+                if (runConfig.debug) {
+                    logger.debug(`Parallel execution strategy: ${dependencyLevels.length} dependency levels identified`);
+                    for(let i = 0; i < dependencyLevels.length; i++){
+                        const level = dependencyLevels[i];
+                        logger.debug(`  Level ${i + 1}: ${level.join(', ')} ${level.length > 1 ? '(parallel)' : '(sequential)'}`);
+                    }
+                }
+                for(let levelIndex = 0; levelIndex < dependencyLevels.length; levelIndex++){
+                    const currentLevel = dependencyLevels[levelIndex];
+                    if (runConfig.debug) {
+                        if (currentLevel.length === 1) {
+                            const packageName = currentLevel[0];
+                            logger.debug(`Starting Level ${levelIndex + 1}: ${packageName} (no dependencies within this level)`);
+                        } else {
+                            logger.debug(`Starting Level ${levelIndex + 1}: ${currentLevel.length} packages can run in parallel`);
+                            logger.debug(`  Parallel packages: ${currentLevel.join(', ')}`);
+                        }
+                    } else if (runConfig.verbose) {
+                        if (currentLevel.length === 1) {
+                            const packageName = currentLevel[0];
+                            logger.verbose(`Level ${levelIndex + 1}: Executing ${packageName}...`);
+                        } else {
+                            logger.verbose(`Level ${levelIndex + 1}: Executing ${currentLevel.length} packages in parallel: ${currentLevel.join(', ')}...`);
+                        }
+                    } else {
+                        // Basic level info
+                        if (currentLevel.length === 1) {
+                            const packageName = currentLevel[0];
+                            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Level ${levelIndex + 1}: Executing ${packageName}...`);
+                        } else {
+                            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Level ${levelIndex + 1}: Executing ${currentLevel.length} packages in parallel: ${currentLevel.join(', ')}...`);
+                        }
+                    }
+                    // Execute all packages in this level in parallel
+                    const levelPromises = currentLevel.map((packageName)=>{
+                        const packageInfo = dependencyGraph.packages.get(packageName);
+                        const globalIndex = buildOrder.indexOf(packageName);
+                        return executePackage(packageName, packageInfo, commandToRun, runConfig, isDryRun, globalIndex, buildOrder.length, isBuiltInCommand);
+                    });
+                    // Wait for all packages in this level to complete
+                    const results = await Promise.allSettled(levelPromises);
+                    // Check results and handle errors
+                    for(let i = 0; i < results.length; i++){
+                        const result = results[i];
+                        const packageName = currentLevel[i];
+                        const globalIndex = buildOrder.indexOf(packageName);
+                        const packageLogger = createPackageLogger(packageName, globalIndex + 1, buildOrder.length, isDryRun);
+                        if (result.status === 'fulfilled') {
+                            if (result.value.success) {
+                                successCount++;
+                                // Add spacing between packages (except after the last one in the level)
+                                if (i < currentLevel.length - 1) {
+                                    logger.info('');
+                                    logger.info('');
+                                }
+                            } else {
+                                // Package failed
+                                failedPackage = packageName;
+                                const formattedError = formatSubprojectError(packageName, result.value.error);
+                                if (!isDryRun) {
+                                    packageLogger.error(`Execution failed`);
+                                    logger.error(formattedError);
+                                    logger.error(`Failed after ${successCount} successful packages.`);
+                                    const packageDir = dependencyGraph.packages.get(packageName).path;
+                                    const packageDirName = path.basename(packageDir);
+                                    logger.error(`To resume from this package, run:`);
+                                    if (isBuiltInCommand) {
+                                        logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
+                                    } else {
+                                        logger.error(`    kodrdriv tree --start-from ${packageDirName} --cmd "${commandToRun}"`);
+                                    }
+                                    throw new Error(`Command failed in package ${packageName}`);
+                                }
+                                break;
+                            }
+                        } else {
+                            // Promise was rejected
+                            failedPackage = packageName;
+                            if (!isDryRun) {
+                                packageLogger.error(`Unexpected error: ${result.reason}`);
+                                logger.error(`Failed after ${successCount} successful packages.`);
+                                const packageDir = dependencyGraph.packages.get(packageName).path;
+                                const packageDirName = path.basename(packageDir);
+                                logger.error(`To resume from this package, run:`);
+                                if (isBuiltInCommand) {
+                                    logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
+                                } else {
+                                    logger.error(`    kodrdriv tree --start-from ${packageDirName} --cmd "${commandToRun}"`);
+                                }
+                                throw new Error(`Unexpected error in package ${packageName}`);
+                            }
+                            break;
+                        }
+                    }
+                    // If any package failed, stop execution
+                    if (failedPackage) {
+                        break;
+                    }
+                    // Level completion logging
+                    if (runConfig.debug) {
+                        if (currentLevel.length > 1) {
+                            logger.debug(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
+                            logger.debug(`  Completed packages: ${currentLevel.join(', ')}`);
+                        } else if (currentLevel.length === 1 && successCount > 0) {
+                            const packageName = currentLevel[0];
+                            logger.debug(`✅ Level ${levelIndex + 1} completed: ${packageName} finished successfully`);
+                        }
+                    } else if (runConfig.verbose) {
+                        if (currentLevel.length > 1) {
+                            logger.verbose(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
+                        } else if (currentLevel.length === 1 && successCount > 0) {
+                            const packageName = currentLevel[0];
+                            logger.verbose(`✅ Level ${levelIndex + 1} completed: ${packageName} finished successfully`);
+                        }
+                    } else {
+                        // Basic completion info
+                        if (currentLevel.length > 1) {
+                            logger.info(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
+                        } else if (currentLevel.length === 1 && successCount > 0) {
+                            const packageName = currentLevel[0];
+                            logger.info(`✅ Level ${levelIndex + 1} completed: ${packageName} finished successfully`);
+                        }
+                    }
+                }
+            } else {
+                // Sequential execution
+                for(let i = 0; i < buildOrder.length; i++){
+                    const packageName = buildOrder[i];
+                    const packageInfo = dependencyGraph.packages.get(packageName);
+                    const packageLogger = createPackageLogger(packageName, i + 1, buildOrder.length, isDryRun);
+                    const result = await executePackage(packageName, packageInfo, commandToRun, runConfig, isDryRun, i, buildOrder.length, isBuiltInCommand);
+                    if (result.success) {
+                        successCount++;
+                        // Add spacing between packages (except after the last one)
+                        if (i < buildOrder.length - 1) {
+                            logger.info('');
+                            logger.info('');
+                        }
+                    } else {
+                        failedPackage = packageName;
+                        const formattedError = formatSubprojectError(packageName, result.error);
+                        if (!isDryRun) {
+                            packageLogger.error(`Execution failed`);
+                            logger.error(formattedError);
+                            logger.error(`Failed after ${successCount} successful packages.`);
+                            const packageDir = packageInfo.path;
+                            const packageDirName = path.basename(packageDir);
+                            logger.error(`To resume from this package, run:`);
+                            if (isBuiltInCommand) {
+                                logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
+                            } else {
+                                logger.error(`    kodrdriv tree --start-from ${packageDirName} --cmd "${commandToRun}"`);
+                            }
+                            throw new Error(`Command failed in package ${packageName}`);
+                        }
+                        break;
+                    }
+                }
+            }
+            if (!failedPackage) {
+                const summary = `${isDryRun ? 'DRY RUN: ' : ''}All ${buildOrder.length} packages completed successfully! 🎉`;
+                logger.info(summary);
+                return returnOutput; // Don't duplicate the summary in return string
+            }
+        }
+        return returnOutput;
+    } catch (error) {
+        const errorMessage = `Failed to analyze workspace: ${error.message}`;
+        logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+};
+
+export { execute };
+//# sourceMappingURL=tree.js.map