@eldrforge/kodrdriv 1.2.25 → 1.2.26

package/MONOREPO-PUBLISH-IMPROVEMENTS.md

@@ -0,0 +1,281 @@
+# Kodrdriv Monorepo Publish Workflow Improvements
+
+## Implementation Summary
+
+This document summarizes the improvements made to the `kodrdriv tree publish --parallel` workflow based on real-world usage feedback with the Fjell monorepo (16 packages).
+
+## Completed Improvements
+
+### 1. ✅ Fixed Recovery Mode to Actually Continue Execution (#2 - High Priority)
+
+**Problem:** When using `--continue --mark-completed`, the system would apply recovery options but then exit immediately without continuing execution.
+
+**Root Cause:** The sequential execution context loading was overwriting the `runConfig`, removing the `--parallel` flag, causing the system to skip parallel execution entirely.
+
+**Solution:**
+- Modified `src/commands/tree.ts` to detect parallel mode and skip sequential context loading
+- Parallel execution now properly continues after recovery options are applied
+- Recovery is now atomic: apply recovery + continue execution in one step
+
+**Files Changed:**
+- `src/commands/tree.ts` (lines 1093-1144)
+
+### 2. ✅ Git Submodule Support (#3 - High Priority)
+
+**Status:** Already implemented and tested in previous work.
+
+**Implementation:** The file-based lock mechanism in `src/util/fileLock.ts` already handles both regular repositories and git submodules by:
+- Detecting if `.git` is a file (submodule) vs directory (regular repo)
+- Reading and parsing the `gitdir:` reference for submodules
+- Creating lock files in the actual git directory
+
+**Files:**
+- `src/util/fileLock.ts`
+- `tests/fileLock.test.ts` (comprehensive test coverage)
+- `SUBMODULE-LOCK-FIX.md` (documentation)
+
+### 3. ✅ Better Status Distinctions (#1/#4 - High Priority)
+
+**Problem:** The system reported "Completed successfully" for packages that were skipped due to no code changes, making it impossible to tell what was actually published.
+
+**Solution:**
+- Added new `skippedNoChanges` field to `ExecutionState` and `ExecutionResult` types
+- Modified `DynamicTaskPool` to track packages skipped due to no changes separately from those skipped due to failed dependencies
+- Updated progress logger to show distinct icons and messages:
+  - ✅ Published (actually executed)
+  - ⊘ Skipped (no code changes)
+  - ⊘ Skipped (dependency failed)
+  - ❌ Failed
+- Enhanced result summary to show detailed breakdown
+
+**Files Changed:**
+- `src/types/parallelExecution.ts` - Added `skippedNoChanges` to state and result types
+- `src/execution/DynamicTaskPool.ts` - Track and report skip reasons
+- `src/execution/TreeExecutionAdapter.ts` - Pass through skip status and format results
+- `src/execution/RecoveryManager.ts` - Include skippedNoChanges in validation
+- `src/commands/tree.ts` - Detect and return skip status from executePackage
+
+**Example Output:**
+```
+📊 Execution Summary:
+
+✅ Published: 3 package(s)
+   @fjell/common-config, @fjell/logging, @fjell/docs-template
+
+⊘ Skipped (no code changes): 5 package(s)
+   @fjell/core, @fjell/http-api, @fjell/registry, @fjell/client-api, @fjell/lib
+
+⊘ Skipped (dependency failed): 8 package(s)
+   @fjell/cache, @fjell/providers, @fjell/sample-app, ...
+   Blocked by: @fjell/core
+
+❌ Failed: 0 package(s)
+```
+
+### 4. ✅ Show Actual Errors Inline (#9 - High Priority)
+
+**Problem:** When packages failed, only generic error messages were shown. The actual error (test failure, build error, merge conflict) was buried in log files.
+
+**Solution:**
+- Added `errorDetails` field to `FailedPackageSnapshot` type with structured error information
+- Implemented `extractErrorDetails()` method in `DynamicTaskPool` to parse errors and extract:
+  - Error type (test_coverage, build_error, merge_conflict, test_failure, timeout, unknown)
+  - Context (specific details about the error)
+  - Log file location
+  - Suggested fix command
+- Enhanced `ProgressFormatter.createErrorSummary()` to display detailed error information
+
+**Files Changed:**
+- `src/types/parallelExecution.ts` - Added errorDetails to FailedPackageSnapshot
+- `src/execution/DynamicTaskPool.ts` - Extract and attach error details
+- `src/ui/ProgressFormatter.ts` - Display detailed error information
+
+**Example Output:**
+```
+❌ Failure Summary:
+
+  @fjell/core:
+    Type: Test Coverage
+    Details: Lines: 89.5% (threshold: 90%)
+    Log: /path/to/core/output/kodrdriv/publish_*.log
+    💡 Suggestion: cd /path/to/core && npm test -- --coverage
+    Blocked: @fjell/cache, @fjell/providers +6 more
+```
+
+### 5. ✅ Add Dry-Run Mode (#6 - Medium Priority)
+
+**Problem:** No way to preview what will happen without actually executing.
+
+**Solution:**
+- Added `generateDryRunPreview()` function that analyzes the dependency graph and shows:
+  - Build order grouped by dependency level
+  - Status for each package (will publish, will skip, etc.)
+  - For publish commands, checks git diff to determine if packages have code changes
+  - Summary statistics
+- Integrated with parallel execution to show preview before executing
+
+**Files Changed:**
+- `src/commands/tree.ts` - Added generateDryRunPreview() and integrated with parallel execution
+
+**Example Output:**
+```
+🔍 DRY RUN MODE - No changes will be made
+
+Build order determined:
+
+Level 1: (1 package)
+  @fjell/common-config
+    Status: 📝 Has changes (23 files), will publish
+    Path: /path/to/common-config
+
+Level 2: (1 package)
+  @fjell/logging
+    Status: ⊘ Only version bump, will skip
+    Path: /path/to/logging
+
+...
+
+Summary:
+  Total packages: 16
+  Dependency levels: 6
+  Command: kodrdriv publish
+  Max concurrency: 8
+
+To execute for real, run the same command without --dry-run
+```
+
+## Not Yet Implemented (Lower Priority)
+
+The following improvements were identified but not implemented in this session:
+
+### 5. Progress Indicators for Long-Running Operations
+- Show sub-step progress during PR checks
+- Display which checks are passing/failing
+- Estimate completion time
+
+### 7. Better Checkpoint Management
+- Add `kodrdriv tree --status` command
+- Add `kodrdriv tree --reset` command
+- Auto-detect and prompt when checkpoint exists
+
+### 8. Fix Concurrency Recommendation Inconsistency
+- Use recommended concurrency by default or explain why not
+
+### 10. Interactive Conflict Resolution
+- Offer to auto-resolve common conflicts (package.json versions, lockfiles)
+- Interactive prompts for manual resolution
+
+### 11. Smart Dependency Updating
+- Auto-update dependent packages when a package is published
+- `kodrdriv tree update-deps --package "@fjell/core@4.4.72"`
+
+### 12. Publish Groups/Profiles
+- Define groups of packages to publish together
+- `kodrdriv tree publish --group core`
+
+### 13. Better npm Registry Integration
+- Check npm for latest versions before publishing
+- Warn about version conflicts
+
+### 14. Automatic Changelog Generation
+- Generate changelogs based on commits since last release
+- Include in release notes automatically
+
+## Testing
+
+### Manual Testing Recommended
+
+1. **Recovery Mode:**
+   ```bash
+   # Start a publish
+   kodrdriv tree publish --parallel
+
+   # If it fails, mark packages as completed and continue
+   kodrdriv tree publish --parallel --continue --mark-completed "pkg1,pkg2"
+
+   # Verify it actually continues execution (not just exits)
+   ```
+
+2. **Status Distinctions:**
+   ```bash
+   # Publish a monorepo where some packages have no changes
+   kodrdriv tree publish --parallel
+
+   # Verify the summary shows:
+   # - ✅ Published: X packages
+   # - ⊘ Skipped (no changes): Y packages
+   # - ⊘ Skipped (dependency failed): Z packages
+   ```
+
+3. **Error Details:**
+   ```bash
+   # Cause a test failure in one package
+   # Run publish and verify the error summary shows:
+   # - Error type
+   # - Specific details
+   # - Log file location
+   # - Suggested fix
+   ```
+
+4. **Dry Run:**
+   ```bash
+   kodrdriv tree publish --parallel --dry-run
+
+   # Verify it shows:
+   # - Build order by level
+   # - Status for each package
+   # - Summary statistics
+   # - Does not actually execute
+   ```
+
+### Unit Tests
+
+The following test files should be updated to cover the new functionality:
+
+- `tests/execution/DynamicTaskPool.test.ts` - Test skippedNoChanges tracking
+- `tests/execution/TreeExecutionAdapter.test.ts` - Test result formatting
+- `tests/execution/RecoveryManager.test.ts` - Test validation with skippedNoChanges
+- `tests/commands/tree.test.ts` - Test dry-run preview and recovery continuation
+
+## Migration Notes
+
+### Breaking Changes
+
+None. All changes are backward compatible.
+
+### API Changes
+
+- `ExecutionState` now includes `skippedNoChanges: string[]`
+- `ExecutionResult` now includes `skippedNoChanges: string[]`
+- `PackageResult` now includes optional `skippedNoChanges?: boolean`
+- `FailedPackageSnapshot` now includes optional `errorDetails?: { type, context, logFile, suggestion }`
+- `executePackage()` return type now includes optional `skippedNoChanges?: boolean`
+
+### Configuration Changes
+
+None required. All new features work with existing configurations.
+
+## Performance Impact
+
+Minimal. The changes primarily affect:
+- Error handling (extracting details from error messages)
+- Status tracking (additional array in state)
+- Dry-run preview (only runs when --dry-run is specified)
+
+## Documentation Updates Needed
+
+- Update `docs/public/commands/tree.md` with:
+  - New status distinctions
+  - Dry-run mode usage
+  - Enhanced error reporting
+  - Recovery mode improvements
+- Update examples to show new output format
+
+## Related Issues/PRs
+
+This implementation addresses the feedback document "Kodrdriv Monorepo Publish Workflow Improvements" which identified 14 pain points based on real-world usage with the Fjell monorepo.
+
+## Contributors
+
+Implementation based on detailed feedback from production usage of kodrdriv with a 16-package monorepo.
+

package/dist/commands/tree.js

@@ -493,6 +493,8 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
         // Basic progress info even without flags
         logger.info(`[${index + 1}/${total}] ${packageName}: Running ${commandToRun}...`);
     }
+    // Track if publish was skipped due to no changes
+    let publishWasSkipped = false;
     try {
         if (isDryRun && !isBuiltInCommand) {
             // Handle inter-project dependency updates for publish commands in dry run mode
@@ -604,7 +606,6 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                 }
                 // For built-in commands, shell out to a separate kodrdriv process
                 // This preserves individual project configurations
-                let publishWasSkipped;
                 if (isBuiltInCommand) {
                     // Extract the command name from "kodrdriv <command>"
                     const builtInCommandName = commandToRun.replace('kodrdriv ', '');
@@ -701,13 +702,22 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
         }
         // Show completion status
         if (runConfig.debug || runConfig.verbose) {
-            packageLogger.info(`✅ Completed successfully`);
+            if (publishWasSkipped) {
+                packageLogger.info(`⊘ Skipped (no code changes)`);
+            } else {
+                packageLogger.info(`✅ Completed successfully`);
+            }
         } else if (isPublishCommand) {
             // For publish commands, always show completion even without verbose
-            logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+            if (publishWasSkipped) {
+                logger.info(`[${index + 1}/${total}] ${packageName}: ⊘ Skipped (no code changes)`);
+            } else {
+                logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+            }
         }
         return {
-            success: true
+            success: true,
+            skippedNoChanges: publishWasSkipped
         };
     } catch (error) {
         var _error_message;
@@ -726,6 +736,86 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
         };
     }
 };
+/**
+ * Generate a dry-run preview showing what would happen without executing
+ */ const generateDryRunPreview = async (dependencyGraph, buildOrder, command, runConfig)=>{
+    var _runConfig_tree;
+    const lines = [];
+    lines.push('');
+    lines.push('🔍 DRY RUN MODE - No changes will be made');
+    lines.push('');
+    lines.push('Build order determined:');
+    lines.push('');
+    // Group packages by dependency level
+    const levels = [];
+    const packageLevels = new Map();
+    for (const pkg of buildOrder){
+        const deps = dependencyGraph.edges.get(pkg) || new Set();
+        let maxDepLevel = -1;
+        for (const dep of deps){
+            var _packageLevels_get;
+            const depLevel = (_packageLevels_get = packageLevels.get(dep)) !== null && _packageLevels_get !== void 0 ? _packageLevels_get : 0;
+            maxDepLevel = Math.max(maxDepLevel, depLevel);
+        }
+        const pkgLevel = maxDepLevel + 1;
+        packageLevels.set(pkg, pkgLevel);
+        if (!levels[pkgLevel]) {
+            levels[pkgLevel] = [];
+        }
+        levels[pkgLevel].push(pkg);
+    }
+    // Show packages grouped by level
+    for(let i = 0; i < levels.length; i++){
+        const levelPackages = levels[i];
+        lines.push(`Level ${i + 1}: (${levelPackages.length} package${levelPackages.length === 1 ? '' : 's'})`);
+        for (const pkg of levelPackages){
+            const pkgInfo = dependencyGraph.packages.get(pkg);
+            if (!pkgInfo) continue;
+            // Check if package has changes (for publish command)
+            const isPublish = command.includes('publish');
+            let status = '📝 Has changes, will execute';
+            if (isPublish) {
+                try {
+                    // Check git diff to see if there are code changes
+                    const { stdout } = await runSecure('git', [
+                        'diff',
+                        '--name-only',
+                        'origin/main...HEAD'
+                    ], {
+                        cwd: pkgInfo.path
+                    });
+                    const changedFiles = stdout.split('\n').filter(Boolean);
+                    const nonVersionFiles = changedFiles.filter((f)=>f !== 'package.json' && f !== 'package-lock.json');
+                    if (changedFiles.length === 0) {
+                        status = '⊘ No changes, will skip';
+                    } else if (nonVersionFiles.length === 0) {
+                        status = '⊘ Only version bump, will skip';
+                    } else {
+                        status = `📝 Has changes (${nonVersionFiles.length} files), will publish`;
+                    }
+                } catch  {
+                    // If we can't check git status, assume changes
+                    status = '📝 Will execute';
+                }
+            }
+            lines.push(`  ${pkg}`);
+            lines.push(`    Status: ${status}`);
+            lines.push(`    Path: ${pkgInfo.path}`);
+        }
+        lines.push('');
+    }
+    lines.push('Summary:');
+    lines.push(`  Total packages: ${buildOrder.length}`);
+    lines.push(`  Dependency levels: ${levels.length}`);
+    lines.push(`  Command: ${command}`);
+    if ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.maxConcurrency) {
+        lines.push(`  Max concurrency: ${runConfig.tree.maxConcurrency}`);
+    }
+    lines.push('');
+    lines.push('To execute for real, run the same command without --dry-run');
+    lines.push('');
+    return lines.join('\n');
+};
 // Add a simple status check function
 const checkTreePublishStatus = async ()=>{
     const logger = getLogger();
@@ -880,35 +970,46 @@ const execute = async (runConfig)=>{
     }
     // Handle continue mode
     if (isContinue) {
-        const savedContext = await loadExecutionContext(runConfig.outputDirectory);
-        if (savedContext) {
-            logger.info('Continuing previous tree execution...');
-            logger.info(`Original command: ${savedContext.command}`);
-            logger.info(`Started: ${savedContext.startTime.toISOString()}`);
-            logger.info(`Previously completed: ${savedContext.completedPackages.length}/${savedContext.buildOrder.length} packages`);
-            // Restore state safely
-            let mutexLocked = false;
-            try {
-                await globalStateMutex.lock();
-                mutexLocked = true;
-                publishedVersions = savedContext.publishedVersions;
-                globalStateMutex.unlock();
-                mutexLocked = false;
-            } catch (error) {
-                if (mutexLocked) {
+        var _runConfig_tree19;
+        // For parallel execution, the checkpoint is managed by DynamicTaskPool/CheckpointManager
+        // For sequential execution, we use the legacy context file
+        const isParallelMode = (_runConfig_tree19 = runConfig.tree) === null || _runConfig_tree19 === void 0 ? void 0 : _runConfig_tree19.parallel;
+        if (!isParallelMode) {
+            // Sequential execution: load legacy context
+            const savedContext = await loadExecutionContext(runConfig.outputDirectory);
+            if (savedContext) {
+                logger.info('Continuing previous tree execution...');
+                logger.info(`Original command: ${savedContext.command}`);
+                logger.info(`Started: ${savedContext.startTime.toISOString()}`);
+                logger.info(`Previously completed: ${savedContext.completedPackages.length}/${savedContext.buildOrder.length} packages`);
+                // Restore state safely
+                let mutexLocked = false;
+                try {
+                    await globalStateMutex.lock();
+                    mutexLocked = true;
+                    publishedVersions = savedContext.publishedVersions;
                     globalStateMutex.unlock();
+                    mutexLocked = false;
+                } catch (error) {
+                    if (mutexLocked) {
+                        globalStateMutex.unlock();
+                    }
+                    throw error;
                 }
-                throw error;
+                executionContext = savedContext;
+                // Use original config but allow some overrides (like dry run)
+                runConfig = {
+                    ...savedContext.originalConfig,
+                    dryRun: runConfig.dryRun,
+                    outputDirectory: runConfig.outputDirectory || savedContext.originalConfig.outputDirectory
+                };
+            } else {
+                logger.warn('No previous execution context found. Starting new execution...');
             }
-            executionContext = savedContext;
-            // Use original config but allow some overrides (like dry run)
-            runConfig = {
-                ...savedContext.originalConfig,
-                dryRun: runConfig.dryRun,
-                outputDirectory: runConfig.outputDirectory || savedContext.originalConfig.outputDirectory
-            };
         } else {
-            logger.warn('No previous execution context found. Starting new execution...');
+            // Parallel execution: checkpoint is managed by DynamicTaskPool
+            // Just log that we're continuing - the actual checkpoint loading happens in DynamicTaskPool
+            logger.info('Continuing previous parallel execution...');
         }
     } else {
         // Reset published versions tracking for new tree execution
@@ -933,8 +1034,8 @@ const execute = async (runConfig)=>{
     }
     // Handle run subcommand - convert space-separated scripts to npm run commands
     if (builtInCommand === 'run') {
-        var _runConfig_tree19;
-        const packageArgument = (_runConfig_tree19 = runConfig.tree) === null || _runConfig_tree19 === void 0 ? void 0 : _runConfig_tree19.packageArgument;
+        var _runConfig_tree20;
+        const packageArgument = (_runConfig_tree20 = runConfig.tree) === null || _runConfig_tree20 === void 0 ? void 0 : _runConfig_tree20.packageArgument;
         if (!packageArgument) {
             throw new Error('run subcommand requires script names. Usage: kodrdriv tree run "clean build test"');
         }
@@ -1006,9 +1107,9 @@ const execute = async (runConfig)=>{
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${directories.join(', ')}`);
     }
     try {
-        var _runConfig_tree20, _runConfig_tree21, _runConfig_tree22, _runConfig_tree23;
+        var _runConfig_tree21, _runConfig_tree22, _runConfig_tree23, _runConfig_tree24;
         // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_tree20 = runConfig.tree) === null || _runConfig_tree20 === void 0 ? void 0 : _runConfig_tree20.exclude) || [];
+        const excludedPatterns = ((_runConfig_tree21 = runConfig.tree) === null || _runConfig_tree21 === void 0 ? void 0 : _runConfig_tree21.exclude) || [];
         if (excludedPatterns.length > 0) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
         }
@@ -1035,7 +1136,7 @@ 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_tree21 = runConfig.tree) === null || _runConfig_tree21 === void 0 ? void 0 : _runConfig_tree21.startFrom;
+        const startFrom = (_runConfig_tree22 = runConfig.tree) === null || _runConfig_tree22 === void 0 ? void 0 : _runConfig_tree22.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)
@@ -1092,7 +1193,7 @@ 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_tree22 = runConfig.tree) === null || _runConfig_tree22 === void 0 ? void 0 : _runConfig_tree22.stopAt;
+        const stopAt = (_runConfig_tree23 = runConfig.tree) === null || _runConfig_tree23 === void 0 ? void 0 : _runConfig_tree23.stopAt;
         if (stopAt) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for stop package: ${stopAt}`);
             // Find the package that matches the stopAt directory name
@@ -1411,8 +1512,8 @@ const execute = async (runConfig)=>{
         }
         // Handle special "checkout" command that switches all packages to specified branch
         if (builtInCommand === 'checkout') {
-            var _runConfig_tree24;
-            const targetBranch = (_runConfig_tree24 = runConfig.tree) === null || _runConfig_tree24 === void 0 ? void 0 : _runConfig_tree24.packageArgument;
+            var _runConfig_tree25;
+            const targetBranch = (_runConfig_tree25 = runConfig.tree) === null || _runConfig_tree25 === void 0 ? void 0 : _runConfig_tree25.packageArgument;
             if (!targetBranch) {
                 throw new Error('checkout subcommand requires a branch name. Usage: kodrdriv tree checkout <branch-name>');
             }
@@ -1591,12 +1692,12 @@ const execute = async (runConfig)=>{
             returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
         }
         // Execute command if provided (custom command or built-in command)
-        const cmd = (_runConfig_tree23 = runConfig.tree) === null || _runConfig_tree23 === void 0 ? void 0 : _runConfig_tree23.cmd;
+        const cmd = (_runConfig_tree24 = runConfig.tree) === null || _runConfig_tree24 === void 0 ? void 0 : _runConfig_tree24.cmd;
         // Determine command to execute
         let commandToRun;
         let isBuiltInCommand = false;
         if (builtInCommand) {
-            var _runConfig_tree25, _runConfig_tree26, _runConfig_tree27;
+            var _runConfig_tree26, _runConfig_tree27, _runConfig_tree28;
             // Built-in command mode: shell out to kodrdriv subprocess
             // Build command with propagated global options
             const globalOptions = [];
@@ -1613,14 +1714,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_tree25 = runConfig.tree) === null || _runConfig_tree25 === void 0 ? void 0 : _runConfig_tree25.packageArgument;
+            const packageArg = (_runConfig_tree26 = runConfig.tree) === null || _runConfig_tree26 === void 0 ? void 0 : _runConfig_tree26.packageArgument;
             const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink' || builtInCommand === 'updates') ? ` "${packageArg}"` : '';
             // Add command-specific options
             let commandSpecificOptions = '';
-            if (builtInCommand === 'unlink' && ((_runConfig_tree26 = runConfig.tree) === null || _runConfig_tree26 === void 0 ? void 0 : _runConfig_tree26.cleanNodeModules)) {
+            if (builtInCommand === 'unlink' && ((_runConfig_tree27 = runConfig.tree) === null || _runConfig_tree27 === void 0 ? void 0 : _runConfig_tree27.cleanNodeModules)) {
                 commandSpecificOptions += ' --clean-node-modules';
             }
-            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree27 = runConfig.tree) === null || _runConfig_tree27 === void 0 ? void 0 : _runConfig_tree27.externals) && runConfig.tree.externals.length > 0) {
+            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree28 = runConfig.tree) === null || _runConfig_tree28 === void 0 ? void 0 : _runConfig_tree28.externals) && runConfig.tree.externals.length > 0) {
                 commandSpecificOptions += ` --externals ${runConfig.tree.externals.join(' ')}`;
             }
             commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;
@@ -1630,7 +1731,7 @@ const execute = async (runConfig)=>{
             commandToRun = cmd;
         }
         if (commandToRun) {
-            var _runConfig_tree28, _runConfig_tree29;
+            var _runConfig_tree29, _runConfig_tree30;
             // Validate scripts for run command before execution
             const scriptsToValidate = runConfig.__scriptsToValidate;
             if (scriptsToValidate && scriptsToValidate.length > 0) {
@@ -1649,7 +1750,7 @@ const execute = async (runConfig)=>{
                 }
             }
             // 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) {
+            if ((_runConfig_tree29 = runConfig.tree) === null || _runConfig_tree29 === void 0 ? void 0 : _runConfig_tree29.parallel) {
                 const { CommandValidator } = await import('../execution/CommandValidator.js');
                 const validation = CommandValidator.validateForParallel(commandToRun, builtInCommand);
                 CommandValidator.logValidation(validation);
@@ -1700,9 +1801,14 @@ const execute = async (runConfig)=>{
             // 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) {
+            if ((_runConfig_tree30 = runConfig.tree) === null || _runConfig_tree30 === void 0 ? void 0 : _runConfig_tree30.parallel) {
                 var _runConfig_tree_retry1, _runConfig_tree_retry2, _runConfig_tree_retry3, _runConfig_tree_retry4;
                 logger.info('🚀 Using parallel execution mode');
+                // If dry run, show preview instead of executing
+                if (isDryRun) {
+                    const preview = await generateDryRunPreview(dependencyGraph, buildOrder, commandToRun, runConfig);
+                    return preview;
+                }
                 // Import parallel execution components
                 const { TreeExecutionAdapter, createParallelProgressLogger, formatParallelResult } = await import('../execution/TreeExecutionAdapter.js');
                 const os = await import('os');