@eldrforge/kodrdriv 1.2.28 → 1.2.123

package/dist/commands/tree.js

@@ -5,15 +5,17 @@ import { exec } from 'child_process';
 import { safeJsonParse, validatePackageJson, getGloballyLinkedPackages, getGitStatusSummary, getLinkedDependencies, getLinkCompatibilityProblems, runSecure, run } from '@eldrforge/git-tools';
 import util from 'util';
 import { getLogger } from '../logging.js';
-import { create } from '../util/storage.js';
+import { createStorage } from '@eldrforge/shared';
 import { getOutputPath } from '../util/general.js';
 import { DEFAULT_OUTPUT_DIRECTORY } from '../constants.js';
 import { execute as execute$3 } from './commit.js';
 import { execute as execute$1 } from './link.js';
 import { execute as execute$2 } from './unlink.js';
 import { execute as execute$4 } from './updates.js';
-import { runGitWithLock } from '../util/gitMutex.js';
+import { isInGitRepository, runGitWithLock } from '../util/gitMutex.js';
 import { scanForPackageJsonFiles, buildDependencyGraph, topologicalSort, parsePackageJson, shouldExclude } from '../util/dependencyGraph.js';
+import { optimizePrecommitCommand, recordTestRun } from '../util/precommitOptimizations.js';
+import { PerformanceTimer } from '../util/performance.js';
 import { SimpleMutex } from '../util/mutex.js';
 
 // Global state to track published versions during tree execution - protected by mutex
@@ -22,9 +24,7 @@ let executionContext = null;
 const globalStateMutex = new SimpleMutex();
 // Update inter-project dependencies in package.json based on published versions
 const updateInterProjectDependencies = async (packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun)=>{
-    const storage = create({
-        log: packageLogger.info
-    });
+    const storage = createStorage();
     const packageJsonPath = path__default.join(packageDir, 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         packageLogger.verbose('No package.json found, skipping dependency updates');
@@ -83,9 +83,7 @@ const updateInterProjectDependencies = async (packageDir, publishedVersions, all
 };
 // Detect scoped dependencies from package.json and run updates for them
 const updateScopedDependencies = async (packageDir, packageLogger, isDryRun, runConfig)=>{
-    const storage = create({
-        log: packageLogger.info
-    });
+    const storage = createStorage();
     const packageJsonPath = path__default.join(packageDir, 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         packageLogger.verbose('No package.json found, skipping scoped dependency updates');
@@ -167,9 +165,7 @@ const getContextFilePath = (outputDirectory)=>{
 };
 // Save execution context to file
 const saveExecutionContext = async (context, outputDirectory)=>{
-    const storage = create({
-        log: ()=>{}
-    }); // Silent storage for context operations
+    const storage = createStorage(); // Silent storage for context operations
     const contextFilePath = getContextFilePath(outputDirectory);
     try {
         // Ensure output directory exists
@@ -193,9 +189,7 @@ const saveExecutionContext = async (context, outputDirectory)=>{
 };
 // Load execution context from file
 const loadExecutionContext = async (outputDirectory)=>{
-    const storage = create({
-        log: ()=>{}
-    }); // Silent storage for context operations
+    const storage = createStorage(); // Silent storage for context operations
     const contextFilePath = getContextFilePath(outputDirectory);
     try {
         if (!await storage.exists(contextFilePath)) {
@@ -221,9 +215,7 @@ const loadExecutionContext = async (outputDirectory)=>{
 };
 // Clean up context file
 const cleanupContext = async (outputDirectory)=>{
-    const storage = create({
-        log: ()=>{}
-    }); // Silent storage for context operations
+    const storage = createStorage(); // Silent storage for context operations
     const contextFilePath = getContextFilePath(outputDirectory);
     try {
         if (await storage.exists(contextFilePath)) {
@@ -237,9 +229,7 @@ const cleanupContext = async (outputDirectory)=>{
 };
 // Helper function to promote a package to completed status in the context
 const promotePackageToCompleted = async (packageName, outputDirectory)=>{
-    const storage = create({
-        log: ()=>{}
-    });
+    const storage = createStorage();
     const contextFilePath = getContextFilePath(outputDirectory);
     try {
         if (!await storage.exists(contextFilePath)) {
@@ -272,9 +262,7 @@ const promotePackageToCompleted = async (packageName, outputDirectory)=>{
 const validateScripts = async (packages, scripts)=>{
     const logger = getLogger();
     const missingScripts = new Map();
-    const storage = create({
-        log: ()=>{}
-    });
+    const storage = createStorage();
     logger.debug(`Validating scripts: ${scripts.join(', ')}`);
     for (const [packageName, packageInfo] of packages){
         const packageJsonPath = path__default.join(packageInfo.path, 'package.json');
@@ -317,9 +305,7 @@ const validateScripts = async (packages, scripts)=>{
 // After kodrdriv publish, the release version is captured in the git tag,
 // while package.json contains the next dev version
 const extractPublishedVersion = async (packageDir, packageLogger)=>{
-    const storage = create({
-        log: packageLogger.info
-    });
+    const storage = createStorage();
     const packageJsonPath = path__default.join(packageDir, 'package.json');
     try {
         // Get package name from package.json
@@ -363,7 +349,7 @@ const extractPublishedVersion = async (packageDir, packageLogger)=>{
     }
 };
 // Enhanced run function that can show output based on log level
-const runWithLogging = async (command, packageLogger, options = {}, showOutput = 'none')=>{
+const runWithLogging = async (command, packageLogger, options = {}, showOutput = 'none', logFilePath)=>{
     const execPromise = util.promisify(exec);
     // Ensure encoding is set to 'utf8' to get string output instead of Buffer
     const execOptions = {
@@ -377,6 +363,24 @@ const runWithLogging = async (command, packageLogger, options = {}, showOutput =
     } else if (showOutput === 'minimal') {
         packageLogger.verbose(`Running: ${command}`);
     }
+    // Helper to write to log file
+    const writeToLogFile = async (content)=>{
+        if (!logFilePath) return;
+        try {
+            const logDir = path__default.dirname(logFilePath);
+            await fs.mkdir(logDir, {
+                recursive: true
+            });
+            await fs.appendFile(logFilePath, content + '\n', 'utf-8');
+        } catch (err) {
+            packageLogger.warn(`Failed to write to log file ${logFilePath}: ${err.message}`);
+        }
+    };
+    // Write command to log file
+    if (logFilePath) {
+        const timestamp = new Date().toISOString();
+        await writeToLogFile(`[${timestamp}] Executing: ${command}\n`);
+    }
     try {
         const result = await execPromise(command, execOptions);
         if (showOutput === 'full') {
@@ -401,29 +405,62 @@ const runWithLogging = async (command, packageLogger, options = {}, showOutput =
                 });
             }
         }
+        // Write output to log file
+        if (logFilePath) {
+            const stdout = String(result.stdout);
+            const stderr = String(result.stderr);
+            if (stdout.trim()) {
+                await writeToLogFile(`\n=== STDOUT ===\n${stdout}`);
+            }
+            if (stderr.trim()) {
+                await writeToLogFile(`\n=== STDERR ===\n${stderr}`);
+            }
+            await writeToLogFile(`\n[${new Date().toISOString()}] Command completed successfully\n`);
+        }
         // Ensure result is properly typed as strings
         return {
             stdout: String(result.stdout),
             stderr: String(result.stderr)
         };
     } catch (error) {
+        // Always show error message
+        packageLogger.error(`Command failed: ${command}`);
+        // Always show stderr on failure (contains important error details like coverage failures)
+        if (error.stderr && error.stderr.trim()) {
+            packageLogger.error(`❌ STDERR:`);
+            error.stderr.split('\n').forEach((line)=>{
+                if (line.trim()) packageLogger.error(`${line}`);
+            });
+        }
+        // Show stdout on failure if available (may contain error context)
+        if (error.stdout && error.stdout.trim() && (showOutput === 'full' || showOutput === 'minimal')) {
+            packageLogger.info(`📤 STDOUT:`);
+            error.stdout.split('\n').forEach((line)=>{
+                if (line.trim()) packageLogger.info(`${line}`);
+            });
+        }
+        // Show full output in debug/verbose mode
         if (showOutput === 'full' || showOutput === 'minimal') {
-            packageLogger.error(`Command failed: ${command}`);
-            if (error.stdout && showOutput === 'full') {
+            if (error.stdout && error.stdout.trim() && 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') {
+            if (error.stderr && error.stderr.trim() && showOutput === 'full') {
                 packageLogger.debug('STDERR:');
                 packageLogger.debug(error.stderr);
-                packageLogger.info(`❌ STDERR:`);
-                error.stderr.split('\n').forEach((line)=>{
-                    if (line.trim()) packageLogger.info(`${line}`);
-                });
+            }
+        }
+        // Write error output to log file
+        if (logFilePath) {
+            await writeToLogFile(`\n[${new Date().toISOString()}] Command failed: ${error.message}`);
+            if (error.stdout) {
+                await writeToLogFile(`\n=== STDOUT ===\n${error.stdout}`);
+            }
+            if (error.stderr) {
+                await writeToLogFile(`\n=== STDERR ===\n${error.stderr}`);
+            }
+            if (error.stack) {
+                await writeToLogFile(`\n=== STACK TRACE ===\n${error.stack}`);
             }
         }
         throw error;
@@ -473,6 +510,15 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
     const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
     const packageDir = packageInfo.path;
     const logger = getLogger();
+    // Create log file path for publish commands
+    let logFilePath;
+    if (isBuiltInCommand && commandToRun.includes('publish')) {
+        var _commandToRun_split_;
+        const outputDir = runConfig.outputDirectory || 'output/kodrdriv';
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').split('.')[0];
+        const commandName = ((_commandToRun_split_ = commandToRun.split(' ')[1]) === null || _commandToRun_split_ === void 0 ? void 0 : _commandToRun_split_.split(' ')[0]) || 'command';
+        logFilePath = path__default.join(packageDir, outputDir, `${commandName}_${timestamp}.log`);
+    }
     // Determine output level based on flags
     // For publish commands, default to full output to show OpenAI progress and other details
     // For other commands, require --verbose or --debug for output
@@ -495,6 +541,9 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
     }
     // Track if publish was skipped due to no changes
     let publishWasSkipped = false;
+    // Track execution timing
+    const executionTimer = PerformanceTimer.start(packageLogger, `Package ${packageName} execution`);
+    let executionDuration;
     try {
         if (isDryRun && !isBuiltInCommand) {
             // Handle inter-project dependency updates for publish commands in dry run mode
@@ -597,18 +646,53 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                         }
                     }, `${packageName}: dependency updates`);
                 }
+                // Optimize precommit commands for custom commands (not built-in)
+                let effectiveCommandToRun = commandToRun;
+                let optimizationInfo = null;
+                if (!isBuiltInCommand && !isDryRun) {
+                    const isPrecommitCommand = commandToRun.includes('precommit') || commandToRun.includes('pre-commit');
+                    if (isPrecommitCommand) {
+                        try {
+                            const optimization = await optimizePrecommitCommand(packageDir, commandToRun);
+                            effectiveCommandToRun = optimization.optimizedCommand;
+                            optimizationInfo = {
+                                skipped: optimization.skipped,
+                                reasons: optimization.reasons
+                            };
+                            if (optimization.skipped.clean || optimization.skipped.test) {
+                                const skippedParts = [];
+                                if (optimization.skipped.clean) {
+                                    skippedParts.push(`clean (${optimization.reasons.clean})`);
+                                }
+                                if (optimization.skipped.test) {
+                                    skippedParts.push(`test (${optimization.reasons.test})`);
+                                }
+                                packageLogger.info(`⚡ Optimized: Skipped ${skippedParts.join(', ')}`);
+                                if (runConfig.verbose || runConfig.debug) {
+                                    packageLogger.info(`   Original: ${commandToRun}`);
+                                    packageLogger.info(`   Optimized: ${effectiveCommandToRun}`);
+                                }
+                            }
+                        } catch (error) {
+                            // If optimization fails, fall back to original command
+                            logger.debug(`Precommit optimization failed for ${packageName}: ${error.message}`);
+                        }
+                    }
+                }
                 if (runConfig.debug || runConfig.verbose) {
                     if (isBuiltInCommand) {
                         packageLogger.info(`Executing built-in command: ${commandToRun}`);
                     } else {
-                        packageLogger.info(`Executing command: ${commandToRun}`);
+                        packageLogger.info(`Executing command: ${effectiveCommandToRun}`);
                     }
                 }
                 // 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 ', '');
+                    // Extract the command name from "kodrdriv <command> [args...]"
+                    // Split by space and take the second element (after "kodrdriv")
+                    const commandParts = commandToRun.replace(/^kodrdriv\s+/, '').split(/\s+/);
+                    const builtInCommandName = commandParts[0];
                     if (runConfig.debug) {
                         packageLogger.debug(`Shelling out to separate kodrdriv process for ${builtInCommandName} command`);
                     }
@@ -618,21 +702,35 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                         packageLogger.info('⏱️  This may take several minutes (AI processing, PR creation, etc.)');
                     }
                     // Ensure dry-run propagates to subprocess even during overall dry-run mode
-                    const effectiveCommand = runConfig.dryRun && !commandToRun.includes('--dry-run') ? `${commandToRun} --dry-run` : commandToRun;
-                    // Add timeout wrapper for publish commands
-                    const commandTimeoutMs = 1800000; // 30 minutes for publish commands
+                    let effectiveCommand = runConfig.dryRun && !commandToRun.includes('--dry-run') ? `${commandToRun} --dry-run` : commandToRun;
+                    // For commit commands, ensure --sendit is used to avoid interactive prompts
+                    // This prevents hanging when running via tree command
+                    if (builtInCommandName === 'commit' && !effectiveCommand.includes('--sendit') && !runConfig.dryRun) {
+                        effectiveCommand = `${effectiveCommand} --sendit`;
+                        packageLogger.info('💡 Auto-adding --sendit flag to avoid interactive prompts in tree mode');
+                    }
+                    // Set timeout based on command type
+                    let commandTimeoutMs;
                     if (builtInCommandName === 'publish') {
+                        commandTimeoutMs = 1800000; // 30 minutes for publish commands
                         packageLogger.info(`⏰ Setting timeout of ${commandTimeoutMs / 60000} minutes for publish command`);
+                    } else if (builtInCommandName === 'commit') {
+                        commandTimeoutMs = 600000; // 10 minutes for commit commands (AI processing can take time)
+                        packageLogger.info(`⏰ Setting timeout of ${commandTimeoutMs / 60000} minutes for commit command`);
+                    } else {
+                        commandTimeoutMs = 300000; // 5 minutes default for other commands
                     }
-                    const commandPromise = runWithLogging(effectiveCommand, packageLogger, {}, showOutput);
+                    const commandPromise = runWithLogging(effectiveCommand, packageLogger, {}, showOutput, logFilePath);
                     const commandTimeoutPromise = new Promise((_, reject)=>{
                         setTimeout(()=>reject(new Error(`Command timed out after ${commandTimeoutMs / 60000} minutes`)), commandTimeoutMs);
                     });
                     try {
+                        const startTime = Date.now();
                         const { stdout, stderr } = await Promise.race([
                             commandPromise,
                             commandTimeoutPromise
                         ]);
+                        executionDuration = Date.now() - startTime;
                         // Detect explicit skip marker from publish to avoid propagating versions
                         // Check both stdout (where we now write it) and stderr (winston logger output, for backward compat)
                         if (builtInCommandName === 'publish' && (stdout && stdout.includes('KODRDRIV_PUBLISH_SKIPPED') || stderr && stderr.includes('KODRDRIV_PUBLISH_SKIPPED'))) {
@@ -649,7 +747,9 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     }
                 } else {
                     // For custom commands, use the existing logic
-                    await runWithLogging(commandToRun, packageLogger, {}, showOutput);
+                    const startTime = Date.now();
+                    await runWithLogging(effectiveCommandToRun, packageLogger, {}, showOutput, logFilePath);
+                    executionDuration = Date.now() - startTime;
                 }
                 // Track published version after successful publish (skip during dry run)
                 if (!isDryRun && isBuiltInCommand && commandToRun.includes('publish')) {
@@ -677,11 +777,32 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                         }
                     }
                 }
-                if (runConfig.debug || runConfig.verbose) {
-                    packageLogger.info(`Command completed successfully`);
+                // Record test run if tests were executed (not skipped)
+                if (!isDryRun && !isBuiltInCommand && effectiveCommandToRun.includes('test') && (!optimizationInfo || !optimizationInfo.skipped.test)) {
+                    try {
+                        await recordTestRun(packageDir);
+                    } catch (error) {
+                        logger.debug(`Failed to record test run for ${packageName}: ${error.message}`);
+                    }
+                }
+                // End timing and show duration
+                if (executionDuration !== undefined) {
+                    executionTimer.end(`Package ${packageName} execution`);
+                    const seconds = (executionDuration / 1000).toFixed(1);
+                    if (runConfig.debug || runConfig.verbose) {
+                        packageLogger.info(`⏱️  Execution time: ${seconds}s`);
+                    } else if (!isPublishCommand) {
+                        // Show timing in completion message (publish commands have their own completion message)
+                        logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed (${seconds}s)`);
+                    }
                 } else {
-                    // Basic completion info
-                    logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+                    executionTimer.end(`Package ${packageName} execution`);
+                    if (runConfig.debug || runConfig.verbose) {
+                        packageLogger.info(`Command completed successfully`);
+                    } else if (!isPublishCommand) {
+                        // Basic completion info (publish commands have their own completion message)
+                        logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+                    }
                 }
             } finally{
                 // Safely restore working directory
@@ -701,7 +822,7 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                 }
             }
         }
-        // Show completion status
+        // Show completion status (for publish commands, this supplements the timing message above)
         if (runConfig.debug || runConfig.verbose) {
             if (publishWasSkipped) {
                 packageLogger.info(`⊘ Skipped (no code changes)`);
@@ -710,30 +831,65 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
             }
         } else if (isPublishCommand) {
             // For publish commands, always show completion even without verbose
+            // Include timing if available
+            const timeStr = executionDuration !== undefined ? ` (${(executionDuration / 1000).toFixed(1)}s)` : '';
             if (publishWasSkipped) {
                 logger.info(`[${index + 1}/${total}] ${packageName}: ⊘ Skipped (no code changes)`);
             } else {
-                logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+                logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed${timeStr}`);
             }
         }
+        // Ensure timing is recorded even if there was an early return
+        if (executionDuration === undefined) {
+            executionDuration = executionTimer.end(`Package ${packageName} execution`);
+        }
         return {
             success: true,
-            skippedNoChanges: publishWasSkipped
+            skippedNoChanges: publishWasSkipped,
+            logFile: logFilePath
         };
     } catch (error) {
         var _error_message;
+        // Record timing even on error
+        if (executionDuration === undefined) {
+            executionDuration = executionTimer.end(`Package ${packageName} execution`);
+            const seconds = (executionDuration / 1000).toFixed(1);
+            if (runConfig.debug || runConfig.verbose) {
+                packageLogger.error(`⏱️  Execution time before failure: ${seconds}s`);
+            }
+        }
         if (runConfig.debug || runConfig.verbose) {
             packageLogger.error(`❌ Execution failed: ${error.message}`);
         } else {
             logger.error(`[${index + 1}/${total}] ${packageName}: ❌ Failed - ${error.message}`);
         }
+        // Always show stderr if available (contains important error details)
+        // Note: runWithLogging already logs stderr, but we show it here too for visibility
+        // when error is caught at this level (e.g., from timeout wrapper)
+        if (error.stderr && error.stderr.trim() && !runConfig.debug && !runConfig.verbose) {
+            // Extract key error lines from stderr (coverage failures, test failures, etc.)
+            const stderrLines = error.stderr.split('\n').filter((line)=>{
+                const trimmed = line.trim();
+                return trimmed && (trimmed.includes('ERROR:') || trimmed.includes('FAIL') || trimmed.includes('coverage') || trimmed.includes('threshold') || trimmed.includes('fatal:') || trimmed.startsWith('❌'));
+            });
+            if (stderrLines.length > 0) {
+                logger.error(`   Error details:`);
+                stderrLines.slice(0, 10).forEach((line)=>{
+                    logger.error(`   ${line.trim()}`);
+                });
+                if (stderrLines.length > 10) {
+                    logger.error(`   ... and ${stderrLines.length - 10} more error lines (use --verbose to see full output)`);
+                }
+            }
+        }
         // Check if this is a timeout error
         const errorMessage = ((_error_message = error.message) === null || _error_message === void 0 ? void 0 : _error_message.toLowerCase()) || '';
         const isTimeoutError = errorMessage && (errorMessage.includes('timeout waiting for pr') || errorMessage.includes('timeout waiting for release workflows') || errorMessage.includes('timeout reached') || errorMessage.includes('timeout') || errorMessage.includes('timed out') || errorMessage.includes('timed_out'));
         return {
             success: false,
             error,
-            isTimeoutError
+            isTimeoutError,
+            logFile: logFilePath
         };
     }
 };
@@ -868,7 +1024,7 @@ const execute = async (runConfig)=>{
     }
     // Handle audit-branches command
     if ((_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.auditBranches) {
-        var _runConfig_tree16, _runConfig_tree17, _runConfig_publish;
+        var _runConfig_tree16, _runConfig_tree17, _runConfig_publish, _runConfig_tree18;
         logger.info('🔍 Auditing branch state across all packages...');
         const directories = ((_runConfig_tree16 = runConfig.tree) === null || _runConfig_tree16 === void 0 ? void 0 : _runConfig_tree16.directories) || [
             process.cwd()
@@ -888,14 +1044,30 @@ const execute = async (runConfig)=>{
                 path: pkg.path
             }));
         const { auditBranchState, formatAuditResults } = await import('../utils/branchState.js');
+        const { getRemoteDefaultBranch } = await import('@eldrforge/git-tools');
         // For publish workflows, check branch consistency, merge conflicts, and existing PRs
         // Don't pass an expected branch - let the audit find the most common branch
-        const targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
+        let targetBranch = (_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch;
+        if (!targetBranch) {
+            // Try to detect default branch from the first package that is a git repo
+            const firstGitPkg = packages.find((pkg)=>isInGitRepository(pkg.path));
+            if (firstGitPkg) {
+                try {
+                    // Cast to any to avoid type mismatch with node_modules version
+                    targetBranch = await getRemoteDefaultBranch(firstGitPkg.path) || 'main';
+                } catch  {
+                    targetBranch = 'main';
+                }
+            } else {
+                targetBranch = 'main';
+            }
+        }
         logger.info(`Checking for merge conflicts with '${targetBranch}' and existing pull requests...`);
         const auditResult = await auditBranchState(packages, undefined, {
             targetBranch,
             checkPR: true,
-            checkConflicts: true
+            checkConflicts: true,
+            concurrency: ((_runConfig_tree18 = runConfig.tree) === null || _runConfig_tree18 === void 0 ? void 0 : _runConfig_tree18.maxConcurrency) || 10
         });
         const formatted = formatAuditResults(auditResult);
         logger.info('\n' + formatted);
@@ -910,13 +1082,13 @@ const execute = async (runConfig)=>{
     const { loadRecoveryManager } = await import('../execution/RecoveryManager.js');
     // Handle status-parallel command
     if ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.statusParallel) {
-        var _runConfig_tree18, _runConfig_tree19;
+        var _runConfig_tree19, _runConfig_tree20;
         logger.info('📊 Checking parallel execution status...');
         // Need to build dependency graph first
-        const directories = ((_runConfig_tree18 = runConfig.tree) === null || _runConfig_tree18 === void 0 ? void 0 : _runConfig_tree18.directories) || [
+        const directories = ((_runConfig_tree19 = runConfig.tree) === null || _runConfig_tree19 === void 0 ? void 0 : _runConfig_tree19.directories) || [
             process.cwd()
         ];
-        const excludedPatterns = ((_runConfig_tree19 = runConfig.tree) === null || _runConfig_tree19 === void 0 ? void 0 : _runConfig_tree19.exclude) || [];
+        const excludedPatterns = ((_runConfig_tree20 = runConfig.tree) === null || _runConfig_tree20 === void 0 ? void 0 : _runConfig_tree20.exclude) || [];
         let allPackageJsonPaths = [];
         for (const targetDirectory of directories){
             const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
@@ -937,12 +1109,12 @@ const execute = async (runConfig)=>{
     }
     // Handle validate-state command
     if ((_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.validateState) {
-        var _runConfig_tree20, _runConfig_tree21;
+        var _runConfig_tree21, _runConfig_tree22;
         logger.info('🔍 Validating checkpoint state...');
-        const directories = ((_runConfig_tree20 = runConfig.tree) === null || _runConfig_tree20 === void 0 ? void 0 : _runConfig_tree20.directories) || [
+        const directories = ((_runConfig_tree21 = runConfig.tree) === null || _runConfig_tree21 === void 0 ? void 0 : _runConfig_tree21.directories) || [
             process.cwd()
         ];
-        const excludedPatterns = ((_runConfig_tree21 = runConfig.tree) === null || _runConfig_tree21 === void 0 ? void 0 : _runConfig_tree21.exclude) || [];
+        const excludedPatterns = ((_runConfig_tree22 = runConfig.tree) === null || _runConfig_tree22 === void 0 ? void 0 : _runConfig_tree22.exclude) || [];
         let allPackageJsonPaths = [];
         for (const targetDirectory of directories){
             const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
@@ -1011,10 +1183,10 @@ const execute = async (runConfig)=>{
     }
     // Handle continue mode
     if (isContinue) {
-        var _runConfig_tree22;
+        var _runConfig_tree23;
         // For parallel execution, the checkpoint is managed by DynamicTaskPool/CheckpointManager
         // For sequential execution, we use the legacy context file
-        const isParallelMode = (_runConfig_tree22 = runConfig.tree) === null || _runConfig_tree22 === void 0 ? void 0 : _runConfig_tree22.parallel;
+        const isParallelMode = (_runConfig_tree23 = runConfig.tree) === null || _runConfig_tree23 === void 0 ? void 0 : _runConfig_tree23.parallel;
         if (!isParallelMode) {
             // Sequential execution: load legacy context
             const savedContext = await loadExecutionContext(runConfig.outputDirectory);
@@ -1068,15 +1240,16 @@ const execute = async (runConfig)=>{
         'branches',
         'run',
         'checkout',
-        'updates'
+        'updates',
+        'precommit'
     ];
     if (builtInCommand && !supportedBuiltInCommands.includes(builtInCommand)) {
         throw new Error(`Unsupported built-in command: ${builtInCommand}. Supported commands: ${supportedBuiltInCommands.join(', ')}`);
     }
     // Handle run subcommand - convert space-separated scripts to npm run commands
     if (builtInCommand === 'run') {
-        var _runConfig_tree23;
-        const packageArgument = (_runConfig_tree23 = runConfig.tree) === null || _runConfig_tree23 === void 0 ? void 0 : _runConfig_tree23.packageArgument;
+        var _runConfig_tree24;
+        const packageArgument = (_runConfig_tree24 = runConfig.tree) === null || _runConfig_tree24 === void 0 ? void 0 : _runConfig_tree24.packageArgument;
         if (!packageArgument) {
             throw new Error('run subcommand requires script names. Usage: kodrdriv tree run "clean build test"');
         }
@@ -1148,9 +1321,9 @@ const execute = async (runConfig)=>{
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${directories.join(', ')}`);
     }
     try {
-        var _runConfig_tree24, _runConfig_tree25, _runConfig_tree26, _runConfig_tree27;
+        var _runConfig_tree25, _runConfig_tree26, _runConfig_tree27, _runConfig_tree28;
         // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_tree24 = runConfig.tree) === null || _runConfig_tree24 === void 0 ? void 0 : _runConfig_tree24.exclude) || [];
+        const excludedPatterns = ((_runConfig_tree25 = runConfig.tree) === null || _runConfig_tree25 === void 0 ? void 0 : _runConfig_tree25.exclude) || [];
         if (excludedPatterns.length > 0) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
         }
@@ -1177,7 +1350,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_tree25 = runConfig.tree) === null || _runConfig_tree25 === void 0 ? void 0 : _runConfig_tree25.startFrom;
+        const startFrom = (_runConfig_tree26 = runConfig.tree) === null || _runConfig_tree26 === void 0 ? void 0 : _runConfig_tree26.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)
@@ -1234,7 +1407,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_tree26 = runConfig.tree) === null || _runConfig_tree26 === void 0 ? void 0 : _runConfig_tree26.stopAt;
+        const stopAt = (_runConfig_tree27 = runConfig.tree) === null || _runConfig_tree27 === void 0 ? void 0 : _runConfig_tree27.stopAt;
         if (stopAt) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for stop package: ${stopAt}`);
             // Find the package that matches the stopAt directory name
@@ -1366,9 +1539,7 @@ const execute = async (runConfig)=>{
             let maxConsumersLength = 'Consumers'.length;
             const branchInfos = [];
             // Create storage instance for consumer lookup
-            const storage = create({
-                log: ()=>{}
-            });
+            const storage = createStorage();
             // Get globally linked packages once at the beginning
             const globallyLinkedPackages = await getGloballyLinkedPackages();
             // ANSI escape codes for progress display
@@ -1553,8 +1724,8 @@ const execute = async (runConfig)=>{
         }
         // Handle special "checkout" command that switches all packages to specified branch
         if (builtInCommand === 'checkout') {
-            var _runConfig_tree28;
-            const targetBranch = (_runConfig_tree28 = runConfig.tree) === null || _runConfig_tree28 === void 0 ? void 0 : _runConfig_tree28.packageArgument;
+            var _runConfig_tree29;
+            const targetBranch = (_runConfig_tree29 = runConfig.tree) === null || _runConfig_tree29 === void 0 ? void 0 : _runConfig_tree29.packageArgument;
             if (!targetBranch) {
                 throw new Error('checkout subcommand requires a branch name. Usage: kodrdriv tree checkout <branch-name>');
             }
@@ -1733,12 +1904,12 @@ const execute = async (runConfig)=>{
             returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
         }
         // Execute command if provided (custom command or built-in command)
-        const cmd = (_runConfig_tree27 = runConfig.tree) === null || _runConfig_tree27 === void 0 ? void 0 : _runConfig_tree27.cmd;
+        const cmd = (_runConfig_tree28 = runConfig.tree) === null || _runConfig_tree28 === void 0 ? void 0 : _runConfig_tree28.cmd;
         // Determine command to execute
         let commandToRun;
         let isBuiltInCommand = false;
         if (builtInCommand) {
-            var _runConfig_tree29, _runConfig_tree30, _runConfig_tree31;
+            var _runConfig_tree30, _runConfig_tree31, _runConfig_tree32;
             // Built-in command mode: shell out to kodrdriv subprocess
             // Build command with propagated global options
             const globalOptions = [];
@@ -1755,14 +1926,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_tree29 = runConfig.tree) === null || _runConfig_tree29 === void 0 ? void 0 : _runConfig_tree29.packageArgument;
+            const packageArg = (_runConfig_tree30 = runConfig.tree) === null || _runConfig_tree30 === void 0 ? void 0 : _runConfig_tree30.packageArgument;
             const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink' || builtInCommand === 'updates') ? ` "${packageArg}"` : '';
             // Add command-specific options
             let commandSpecificOptions = '';
-            if (builtInCommand === 'unlink' && ((_runConfig_tree30 = runConfig.tree) === null || _runConfig_tree30 === void 0 ? void 0 : _runConfig_tree30.cleanNodeModules)) {
+            if (builtInCommand === 'unlink' && ((_runConfig_tree31 = runConfig.tree) === null || _runConfig_tree31 === void 0 ? void 0 : _runConfig_tree31.cleanNodeModules)) {
                 commandSpecificOptions += ' --clean-node-modules';
             }
-            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree31 = runConfig.tree) === null || _runConfig_tree31 === void 0 ? void 0 : _runConfig_tree31.externals) && runConfig.tree.externals.length > 0) {
+            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree32 = runConfig.tree) === null || _runConfig_tree32 === void 0 ? void 0 : _runConfig_tree32.externals) && runConfig.tree.externals.length > 0) {
                 commandSpecificOptions += ` --externals ${runConfig.tree.externals.join(' ')}`;
             }
             commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;
@@ -1772,7 +1943,7 @@ const execute = async (runConfig)=>{
             commandToRun = cmd;
         }
         if (commandToRun) {
-            var _runConfig_tree32, _runConfig_tree33;
+            var _runConfig_tree33, _runConfig_tree34;
             // Validate scripts for run command before execution
             const scriptsToValidate = runConfig.__scriptsToValidate;
             if (scriptsToValidate && scriptsToValidate.length > 0) {
@@ -1791,7 +1962,7 @@ const execute = async (runConfig)=>{
                 }
             }
             // Validate command for parallel execution if parallel mode is enabled
-            if ((_runConfig_tree32 = runConfig.tree) === null || _runConfig_tree32 === void 0 ? void 0 : _runConfig_tree32.parallel) {
+            if ((_runConfig_tree33 = runConfig.tree) === null || _runConfig_tree33 === void 0 ? void 0 : _runConfig_tree33.parallel) {
                 const { CommandValidator } = await import('../execution/CommandValidator.js');
                 const validation = CommandValidator.validateForParallel(commandToRun, builtInCommand);
                 CommandValidator.logValidation(validation);
@@ -1802,11 +1973,12 @@ const execute = async (runConfig)=>{
                     throw new Error('Command validation failed for parallel execution');
                 }
                 // Apply recommended concurrency if not explicitly set
-                if (!runConfig.tree.maxConcurrency && builtInCommand) {
+                if (!runConfig.tree.maxConcurrency) {
                     const os = await import('os');
-                    const recommended = CommandValidator.getRecommendedConcurrency(builtInCommand, os.cpus().length);
+                    const recommended = CommandValidator.getRecommendedConcurrency(builtInCommand, os.cpus().length, commandToRun);
                     if (recommended !== os.cpus().length) {
-                        logger.info(`💡 Using recommended concurrency for ${builtInCommand}: ${recommended}`);
+                        const reason = builtInCommand ? builtInCommand : `custom command "${commandToRun}"`;
+                        logger.info(`💡 Using recommended concurrency for ${reason}: ${recommended}`);
                         runConfig.tree.maxConcurrency = recommended;
                     }
                 }
@@ -1842,7 +2014,7 @@ 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_tree33 = runConfig.tree) === null || _runConfig_tree33 === void 0 ? void 0 : _runConfig_tree33.parallel) {
+            if ((_runConfig_tree34 = runConfig.tree) === null || _runConfig_tree34 === void 0 ? void 0 : _runConfig_tree34.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
@@ -1875,6 +2047,7 @@ const execute = async (runConfig)=>{
                 return formattedResult;
             }
             // Sequential execution
+            const executionStartTime = Date.now();
             for(let i = startIndex; i < buildOrder.length; i++){
                 const packageName = buildOrder[i];
                 // Skip if already completed (in continue mode)
@@ -1977,8 +2150,18 @@ const execute = async (runConfig)=>{
                 }
             }
             if (!failedPackage) {
+                const totalExecutionTime = Date.now() - executionStartTime;
+                const totalSeconds = (totalExecutionTime / 1000).toFixed(1);
+                const totalMinutes = (totalExecutionTime / 60000).toFixed(1);
+                const timeDisplay = totalExecutionTime < 60000 ? `${totalSeconds}s` : `${totalMinutes}min (${totalSeconds}s)`;
+                logger.info('');
+                logger.info('═══════════════════════════════════════════════════════════');
                 const summary = `${isDryRun ? 'DRY RUN: ' : ''}All ${buildOrder.length} packages completed successfully! 🎉`;
                 logger.info(summary);
+                logger.info(`⏱️  Total execution time: ${timeDisplay}`);
+                logger.info(`📦 Packages processed: ${successCount}/${buildOrder.length}`);
+                logger.info('═══════════════════════════════════════════════════════════');
+                logger.info('');
                 // Clean up context on successful completion
                 if (isBuiltInCommand && (builtInCommand === 'publish' || builtInCommand === 'run') && !isDryRun) {
                     await cleanupContext(runConfig.outputDirectory);