@eldrforge/kodrdriv 0.0.48 → 0.0.50

package/dist/commands/publish-tree.js

@@ -1,674 +0,0 @@
-#!/usr/bin/env node
-import path from 'path';
-import fs from 'fs/promises';
-import { getLogger, getDryRunLogger } from '../logging.js';
-import { create } from '../util/storage.js';
-import { run } from '../util/child.js';
-import { execute as execute$1 } from './publish.js';
-import { safeJsonParse, validatePackageJson } from '../util/validation.js';
-
-// 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)
-    };
-};
-// Execute an operation with package context logging for nested operations
-const withPackageContext = async (packageName, sequenceNumber, totalCount, isDryRun, operation)=>{
-    const packageLogger = createPackageLogger(packageName, sequenceNumber, totalCount, isDryRun);
-    // For now, just execute the operation directly
-    // In the future, we could implement more sophisticated context passing
-    try {
-        packageLogger.verbose(`Starting nested operation...`);
-        const result = await operation();
-        packageLogger.verbose(`Nested operation completed`);
-        return result;
-    } catch (error) {
-        packageLogger.error(`Nested operation failed: ${error.message}`);
-        throw error;
-    }
-};
-// Helper function to format subproject error output
-const formatSubprojectError = (packageName, error)=>{
-    const lines = [];
-    lines.push(`❌ Script 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, '.*') // ** 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 {
-        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;
-};
-// Per-package prechecks that apply to each individual package
-const runPackagePrechecks = async (packageName, packageInfo, runConfig, index, total)=>{
-    var _runConfig_publish;
-    const isDryRun = runConfig.dryRun || false;
-    const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
-    const storage = create({
-        log: packageLogger.info
-    });
-    const packageDir = packageInfo.path;
-    packageLogger.verbose('Running package prechecks...');
-    // Check if prepublishOnly script exists in package.json
-    packageLogger.verbose('Checking for prepublishOnly script...');
-    const packageJsonPath = path.join(packageDir, 'package.json');
-    if (!await storage.exists(packageJsonPath)) {
-        if (!isDryRun) {
-            throw new Error(`package.json not found in ${packageDir}`);
-        } else {
-            packageLogger.warn(`package.json not found in ${packageDir}`);
-        }
-    } else {
-        var _packageJson_scripts;
-        let packageJson;
-        try {
-            const packageJsonContents = await storage.readFile(packageJsonPath, 'utf-8');
-            const parsed = safeJsonParse(packageJsonContents, packageJsonPath);
-            packageJson = validatePackageJson(parsed, packageJsonPath);
-        } catch  {
-            if (!isDryRun) {
-                throw new Error(`Failed to parse package.json in ${packageDir}. Please ensure it contains valid JSON.`);
-            } else {
-                packageLogger.warn(`Failed to parse package.json in ${packageDir}. Please ensure it contains valid JSON.`);
-            }
-        }
-        if (packageJson && !((_packageJson_scripts = packageJson.scripts) === null || _packageJson_scripts === void 0 ? void 0 : _packageJson_scripts.prepublishOnly)) {
-            if (!isDryRun) {
-                throw new Error(`prepublishOnly script is required in package.json but was not found in ${packageDir}. Please add a prepublishOnly script that runs your pre-flight checks (e.g., clean, lint, build, test).`);
-            } else {
-                packageLogger.warn(`prepublishOnly script is required in package.json but was not found in ${packageDir}.`);
-            }
-        }
-    }
-    // Check required environment variables for this package
-    packageLogger.verbose('Checking required environment variables...');
-    const coreRequiredEnvVars = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.requiredEnvVars) || [];
-    // Scan for .npmrc environment variables in this package directory
-    const npmrcEnvVars = [];
-    if (!isDryRun) {
-        const npmrcPath = path.join(packageDir, '.npmrc');
-        if (await storage.exists(npmrcPath)) {
-            try {
-                const npmrcContent = await storage.readFile(npmrcPath, 'utf-8');
-                const envVarMatches = npmrcContent.match(/\$\{([^}]+)\}|\$([A-Z_][A-Z0-9_]*)/g);
-                if (envVarMatches) {
-                    for (const match of envVarMatches){
-                        const varName = match.replace(/\$\{|\}|\$/g, '');
-                        if (varName && !npmrcEnvVars.includes(varName)) {
-                            npmrcEnvVars.push(varName);
-                        }
-                    }
-                }
-            } catch (error) {
-                packageLogger.warn(`Failed to read .npmrc file at ${npmrcPath}: ${error.message}`);
-            }
-        }
-    }
-    const allRequiredEnvVars = [
-        ...new Set([
-            ...coreRequiredEnvVars,
-            ...npmrcEnvVars
-        ])
-    ];
-    if (allRequiredEnvVars.length > 0) {
-        packageLogger.verbose(`Required environment variables: ${allRequiredEnvVars.join(', ')}`);
-        const missingEnvVars = [];
-        for (const envVar of allRequiredEnvVars){
-            if (!process.env[envVar]) {
-                missingEnvVars.push(envVar);
-            }
-        }
-        if (missingEnvVars.length > 0) {
-            if (isDryRun) {
-                packageLogger.warn(`Missing required environment variables: ${missingEnvVars.join(', ')}`);
-            } else {
-                throw new Error(`Missing required environment variables for ${packageName}: ${missingEnvVars.join(', ')}. Please set these environment variables before running publish-tree.`);
-            }
-        }
-    }
-    packageLogger.verbose('Package prechecks passed.');
-};
-// Run all prechecks for publish-tree operation
-const runTreePrechecks = async (graph, buildOrder, runConfig)=>{
-    const isDryRun = runConfig.dryRun || false;
-    const logger = getDryRunLogger(isDryRun);
-    logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running prechecks for all ${buildOrder.length} packages...`);
-    // Run package-level prechecks for each package
-    const failedPackages = [];
-    for(let i = 0; i < buildOrder.length; i++){
-        const packageName = buildOrder[i];
-        const packageInfo = graph.packages.get(packageName);
-        try {
-            await runPackagePrechecks(packageName, packageInfo, runConfig, i, buildOrder.length);
-        } catch (error) {
-            failedPackages.push({
-                name: packageName,
-                error: error.message
-            });
-            if (!isDryRun) {
-                // Continue checking other packages to give a complete picture
-                const packageLogger = createPackageLogger(packageName, i + 1, buildOrder.length, isDryRun);
-                packageLogger.error(`Prechecks failed: ${error.message}`);
-            }
-        }
-    }
-    if (failedPackages.length > 0 && !isDryRun) {
-        logger.error(`❌ Prechecks failed for ${failedPackages.length} package${failedPackages.length === 1 ? '' : 's'}:`);
-        logger.error('');
-        for (const failed of failedPackages){
-            logger.error(`   • ${failed.name}: ${failed.error}`);
-        }
-        logger.error('');
-        logger.error('📋 To fix these issues:');
-        logger.error('');
-        logger.error('   1. For missing prepublishOnly scripts:');
-        logger.error('      Add a "prepublishOnly" script to package.json that runs pre-flight checks');
-        logger.error('      Example: "prepublishOnly": "npm run clean && npm run lint && npm run build && npm run test"');
-        logger.error('');
-        logger.error('   2. For missing environment variables:');
-        logger.error('      Set the required environment variables in your shell or .env file');
-        logger.error('      Check your .npmrc files for variable references like ${NPM_TOKEN}');
-        logger.error('');
-        logger.error('   3. For invalid package.json files:');
-        logger.error('      Fix JSON syntax errors and ensure all required fields are present');
-        logger.error('');
-        logger.error('💡 After fixing these issues, re-run the command to continue with the publish process.');
-        throw new Error(`Prechecks failed for ${failedPackages.length} package${failedPackages.length === 1 ? '' : 's'}. Please fix the issues above and try again.`);
-    }
-    if (isDryRun && failedPackages.length > 0) {
-        logger.warn(`DRY RUN: Found potential issues in ${failedPackages.length} package${failedPackages.length === 1 ? '' : 's'} that would cause publish to fail.`);
-    }
-    logger.info(`${isDryRun ? 'DRY RUN: ' : ''}All prechecks passed for ${buildOrder.length} packages.`);
-};
-// Group packages into dependency levels for parallel execution
-const groupPackagesByDependencyLevels = (graph, buildOrder)=>{
-    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);
-            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);
-        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);
-    }
-    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, shouldPublish, runConfig, isDryRun, index, total)=>{
-    const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
-    const packageDir = packageInfo.path;
-    packageLogger.info(`Starting execution...`);
-    packageLogger.verbose(`Working directory: ${packageDir}`);
-    try {
-        if (isDryRun) {
-            if (shouldPublish) {
-                packageLogger.info(`Would execute publish command directly`);
-            } else {
-                // Use main logger for the specific message tests expect
-                const logger = getLogger();
-                logger.info(`DRY RUN: Would execute: ${commandToRun}`);
-                packageLogger.info(`In directory: ${packageDir}`);
-            }
-        } else {
-            // Change to the package directory and run the command
-            const originalCwd = process.cwd();
-            try {
-                process.chdir(packageDir);
-                packageLogger.verbose(`Changed to directory: ${packageDir}`);
-                if (shouldPublish) {
-                    packageLogger.info(`Starting publish process...`);
-                    // Call publish command with package context so all nested logs are prefixed
-                    await withPackageContext(packageName, index + 1, total, isDryRun, async ()=>{
-                        await execute$1(runConfig);
-                    });
-                    packageLogger.info(`Publish completed successfully`);
-                } else {
-                    packageLogger.info(`Executing command: ${commandToRun}`);
-                    // Wrap command execution in package context
-                    await withPackageContext(packageName, index + 1, total, isDryRun, async ()=>{
-                        await run(commandToRun); // Non-null assertion since we're inside if (commandToRun)
-                    });
-                    packageLogger.info(`Command completed successfully`);
-                }
-                packageLogger.info(`✅ Execution completed successfully`);
-            } finally{
-                process.chdir(originalCwd);
-                packageLogger.verbose(`Restored working directory to: ${originalCwd}`);
-            }
-        }
-        return {
-            success: true
-        };
-    } catch (error) {
-        packageLogger.error(`❌ Execution failed: ${error.message}`);
-        return {
-            success: false,
-            error
-        };
-    }
-};
-const execute = async (runConfig)=>{
-    var _runConfig_publishTree;
-    const logger = getLogger();
-    const isDryRun = runConfig.dryRun || false;
-    // Determine the target directory - either specified or current working directory
-    const targetDirectory = ((_runConfig_publishTree = runConfig.publishTree) === null || _runConfig_publishTree === void 0 ? void 0 : _runConfig_publishTree.directory) || process.cwd();
-    logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspace at: ${targetDirectory}`);
-    try {
-        var _runConfig_publishTree1, _runConfig_publishTree2, _runConfig_publishTree3, _runConfig_publishTree4, _runConfig_publishTree5, _runConfig_publishTree6;
-        // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_publishTree1 = runConfig.publishTree) === null || _runConfig_publishTree1 === void 0 ? void 0 : _runConfig_publishTree1.excludedPatterns) || [];
-        if (excludedPatterns.length > 0) {
-            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
-        }
-        // Scan for package.json files
-        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Scanning for package.json files...`);
-        const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
-        if (packageJsonPaths.length === 0) {
-            const message = `No package.json files found in subdirectories of ${targetDirectory}`;
-            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_publishTree2 = runConfig.publishTree) === null || _runConfig_publishTree2 === void 0 ? void 0 : _runConfig_publishTree2.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) {
-                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 output = `\nBuild Order for ${buildOrder.length} packages${startFrom ? ` (starting from ${startFrom})` : ''}:\n`;
-        output += '==========================================\n\n';
-        buildOrder.forEach((packageName, index)=>{
-            const packageInfo = dependencyGraph.packages.get(packageName);
-            const localDeps = Array.from(packageInfo.localDependencies);
-            output += `${index + 1}. ${packageName} (${packageInfo.version})\n`;
-            output += `   Path: ${packageInfo.path}\n`;
-            if (localDeps.length > 0) {
-                output += `   Local Dependencies: ${localDeps.join(', ')}\n`;
-            } else {
-                output += `   Local Dependencies: none\n`;
-            }
-            output += '\n';
-            // 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)`);
-            }
-        });
-        // Execute script, cmd, or publish if provided
-        const script = (_runConfig_publishTree3 = runConfig.publishTree) === null || _runConfig_publishTree3 === void 0 ? void 0 : _runConfig_publishTree3.script;
-        const cmd = (_runConfig_publishTree4 = runConfig.publishTree) === null || _runConfig_publishTree4 === void 0 ? void 0 : _runConfig_publishTree4.cmd;
-        const shouldPublish = ((_runConfig_publishTree5 = runConfig.publishTree) === null || _runConfig_publishTree5 === void 0 ? void 0 : _runConfig_publishTree5.publish) || false;
-        const useParallel = ((_runConfig_publishTree6 = runConfig.publishTree) === null || _runConfig_publishTree6 === void 0 ? void 0 : _runConfig_publishTree6.parallel) || false;
-        // Handle conflicts between --script, --cmd, and --publish
-        // Priority order: --publish > --cmd > --script
-        let commandToRun;
-        let actionName = 'script'; // Default value
-        if (shouldPublish) {
-            if (script || cmd) {
-                const conflicting = [
-                    script && '--script',
-                    cmd && '--cmd'
-                ].filter(Boolean).join(' and ');
-                logger.warn(`Multiple execution options provided (${conflicting} and --publish). Using --publish (ignoring others).`);
-            }
-            // Will use direct function call instead of npx command
-            actionName = 'publish';
-        } else if (cmd) {
-            if (script) {
-                logger.warn('Both --script and --cmd provided. Using --cmd (ignoring --script).');
-            }
-            commandToRun = cmd;
-            actionName = 'command';
-        } else if (script) {
-            commandToRun = script;
-            actionName = 'script';
-        }
-        if (commandToRun || shouldPublish) {
-            // Run prechecks for publish operations
-            if (shouldPublish) {
-                await runTreePrechecks(dependencyGraph, buildOrder, runConfig);
-            }
-            const executionDescription = shouldPublish ? 'publish command' : `"${commandToRun}"`;
-            const parallelInfo = useParallel ? ' (with parallel execution)' : '';
-            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Executing ${actionName} ${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);
-                for(let levelIndex = 0; levelIndex < dependencyLevels.length; levelIndex++){
-                    const currentLevel = dependencyLevels[levelIndex];
-                    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, shouldPublish, runConfig, isDryRun, globalIndex, buildOrder.length);
-                    });
-                    // 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++;
-                            } 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:`);
-                                    logger.error(`    kodrdriv publish-tree --start-from ${packageDirName}`);
-                                    throw new Error(`Script 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:`);
-                                logger.error(`    kodrdriv publish-tree --start-from ${packageDirName}`);
-                                throw new Error(`Unexpected error in package ${packageName}`);
-                            }
-                            break;
-                        }
-                    }
-                    // If any package failed, stop execution
-                    if (failedPackage) {
-                        break;
-                    }
-                    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];
-                        const globalIndex = buildOrder.indexOf(packageName);
-                        const packageLogger = createPackageLogger(packageName, globalIndex + 1, buildOrder.length, isDryRun);
-                        packageLogger.info(`✅ Level ${levelIndex + 1} completed successfully`);
-                    }
-                }
-            } else {
-                // Sequential execution (original logic)
-                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, shouldPublish, runConfig, isDryRun, i, buildOrder.length);
-                    if (result.success) {
-                        successCount++;
-                    } 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:`);
-                            logger.error(`    kodrdriv publish-tree --start-from ${packageDirName}`);
-                            throw new Error(`Script failed in package ${packageName}`);
-                        }
-                        break;
-                    }
-                }
-            }
-            if (!failedPackage) {
-                const summary = `${isDryRun ? 'DRY RUN: ' : ''}All ${buildOrder.length} packages completed successfully! 🎉`;
-                logger.info(summary);
-                return output + `\n${summary}\n`;
-            }
-        }
-        return output;
-    } catch (error) {
-        const errorMessage = `Failed to analyze workspace: ${error.message}`;
-        logger.error(errorMessage);
-        throw new Error(errorMessage);
-    }
-};
-
-export { execute };
-//# sourceMappingURL=publish-tree.js.map