@eldrforge/kodrdriv 1.2.6 → 1.2.8

package/dist/commands/tree.js

@@ -2,6 +2,7 @@
 import path__default from 'path';
 import fs__default from 'fs/promises';
 import { exec } from 'child_process';
+import { runSecure } from '../util/child.js';
 import util from 'util';
 import { getLogger } from '../logging.js';
 import { create } from '../util/storage.js';
@@ -654,16 +655,44 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     if (hasUpdates) {
                         // Commit the dependency updates using kodrdriv commit
                         packageLogger.info('Committing inter-project dependency updates...');
+                        packageLogger.info('⏱️  This step may take a few minutes as it generates a commit message using AI...');
+                        // Add timeout wrapper around commit execution
+                        const commitTimeoutMs = 300000; // 5 minutes
+                        const commitPromise = execute$3({
+                            ...runConfig,
+                            dryRun: false
+                        });
+                        const timeoutPromise = new Promise((_, reject)=>{
+                            setTimeout(()=>reject(new Error(`Commit operation timed out after ${commitTimeoutMs / 1000} seconds`)), commitTimeoutMs);
+                        });
+                        // Add progress indicator
+                        let progressInterval = null;
                         try {
-                            await execute$3({
-                                ...runConfig,
-                                dryRun: false
-                            });
-                            packageLogger.info('Inter-project dependency updates committed successfully');
+                            // Start progress indicator
+                            progressInterval = setInterval(()=>{
+                                packageLogger.info('⏳ Still generating commit message... (this can take 1-3 minutes)');
+                            }, 30000); // Every 30 seconds
+                            await Promise.race([
+                                commitPromise,
+                                timeoutPromise
+                            ]);
+                            packageLogger.info('✅ Inter-project dependency updates committed successfully');
                         } catch (commitError) {
-                            packageLogger.warn(`Failed to commit inter-project dependency updates: ${commitError.message}`);
+                            if (commitError.message.includes('timed out')) {
+                                packageLogger.error(`❌ Commit operation timed out after ${commitTimeoutMs / 1000} seconds`);
+                                packageLogger.error('This usually indicates an issue with the AI service or very large changes');
+                                packageLogger.error('You may need to manually commit the dependency updates');
+                            } else {
+                                packageLogger.warn(`Failed to commit inter-project dependency updates: ${commitError.message}`);
+                            }
                         // Continue with publish anyway - the updates are still in place
+                        } finally{
+                            if (progressInterval) {
+                                clearInterval(progressInterval);
+                            }
                         }
+                    } else {
+                        packageLogger.info('No inter-project dependency updates needed');
                     }
                 }
                 if (runConfig.debug || runConfig.verbose) {
@@ -682,14 +711,39 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     if (runConfig.debug) {
                         packageLogger.debug(`Shelling out to separate kodrdriv process for ${builtInCommandName} command`);
                     }
+                    // Add progress indication for publish commands
+                    if (builtInCommandName === 'publish') {
+                        packageLogger.info('🚀 Starting publish process...');
+                        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;
-                    // Use runWithLogging for built-in commands to capture all output
-                    const { stdout } = await runWithLogging(effectiveCommand, packageLogger, {}, showOutput);
-                    // Detect explicit skip marker from publish to avoid propagating versions
-                    if (builtInCommandName === 'publish' && stdout && stdout.includes('KODRDRIV_PUBLISH_SKIPPED')) {
-                        packageLogger.info('Publish skipped for this package; will not record or propagate a version.');
-                        publishWasSkipped = true;
+                    // Add timeout wrapper for publish commands
+                    const commandTimeoutMs = 1800000; // 30 minutes for publish commands
+                    if (builtInCommandName === 'publish') {
+                        packageLogger.info(`⏰ Setting timeout of ${commandTimeoutMs / 60000} minutes for publish command`);
+                    }
+                    const commandPromise = runWithLogging(effectiveCommand, packageLogger, {}, showOutput);
+                    const commandTimeoutPromise = new Promise((_, reject)=>{
+                        setTimeout(()=>reject(new Error(`Command timed out after ${commandTimeoutMs / 60000} minutes`)), commandTimeoutMs);
+                    });
+                    try {
+                        const { stdout } = await Promise.race([
+                            commandPromise,
+                            commandTimeoutPromise
+                        ]);
+                        // Detect explicit skip marker from publish to avoid propagating versions
+                        if (builtInCommandName === 'publish' && stdout && stdout.includes('KODRDRIV_PUBLISH_SKIPPED')) {
+                            packageLogger.info('Publish skipped for this package; will not record or propagate a version.');
+                            publishWasSkipped = true;
+                        }
+                    } catch (error) {
+                        if (error.message.includes('timed out')) {
+                            packageLogger.error(`❌ ${builtInCommandName} command timed out after ${commandTimeoutMs / 60000} minutes`);
+                            packageLogger.error('This usually indicates the command is stuck waiting for user input or an external service');
+                            throw error;
+                        }
+                        throw error;
                     }
                 } else {
                     // For custom commands, use the existing logic
@@ -765,12 +819,47 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
         };
     }
 };
+// Add a simple status check function
+const checkTreePublishStatus = async ()=>{
+    const logger = getLogger();
+    try {
+        // Check for running kodrdriv processes
+        const { stdout } = await runSecure('ps', [
+            'aux'
+        ], {});
+        const kodrdrivProcesses = stdout.split('\n').filter((line)=>line.includes('kodrdriv') && !line.includes('grep') && !line.includes('ps aux') && !line.includes('tree --status') // Exclude the current status command
+        );
+        if (kodrdrivProcesses.length > 0) {
+            logger.info('🔍 Found running kodrdriv processes:');
+            kodrdrivProcesses.forEach((process1)=>{
+                const parts = process1.trim().split(/\s+/);
+                const pid = parts[1];
+                const command = parts.slice(10).join(' ');
+                logger.info(`  PID ${pid}: ${command}`);
+            });
+        } else {
+            logger.info('No kodrdriv processes currently running');
+        }
+    } catch (error) {
+        logger.warn('Could not check process status:', error);
+    }
+};
 const execute = async (runConfig)=>{
-    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5;
+    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5, _runConfig_tree6, _runConfig_tree7;
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
     const isContinue = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.continue) || false;
     const promotePackage = (_runConfig_tree1 = runConfig.tree) === null || _runConfig_tree1 === void 0 ? void 0 : _runConfig_tree1.promote;
+    // Debug logging
+    logger.debug('Tree config:', JSON.stringify(runConfig.tree, null, 2));
+    logger.debug('Status flag:', (_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.status);
+    logger.debug('Full runConfig:', JSON.stringify(runConfig, null, 2));
+    // Handle status check
+    if ((_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.status) {
+        logger.info('🔍 Checking for running kodrdriv processes...');
+        await checkTreePublishStatus();
+        return 'Status check completed';
+    }
     // Handle promote mode
     if (promotePackage) {
         logger.info(`Promoting package '${promotePackage}' to completed status...`);
@@ -817,7 +906,7 @@ const execute = async (runConfig)=>{
         executionContext = null;
     }
     // Check if we're in built-in command mode (tree command with second argument)
-    const builtInCommand = (_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.builtInCommand;
+    const builtInCommand = (_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.builtInCommand;
     const supportedBuiltInCommands = [
         'commit',
         'publish',
@@ -825,15 +914,17 @@ const execute = async (runConfig)=>{
         'unlink',
         'development',
         'branches',
-        'run'
+        'run',
+        'checkout',
+        'updates'
     ];
     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_tree6;
-        const packageArgument = (_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.packageArgument;
+        var _runConfig_tree8;
+        const packageArgument = (_runConfig_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.packageArgument;
         if (!packageArgument) {
             throw new Error('run subcommand requires script names. Usage: kodrdriv tree run "clean build test"');
         }
@@ -856,11 +947,11 @@ const execute = async (runConfig)=>{
         runConfig.__scriptsToValidate = scripts;
     }
     // Determine the target directories - either specified or current working directory
-    const directories = ((_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.directories) || [
+    const directories = ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.directories) || [
         process.cwd()
     ];
     // Handle link status subcommand
-    if (builtInCommand === 'link' && ((_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.packageArgument) === 'status') {
+    if (builtInCommand === 'link' && ((_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.packageArgument) === 'status') {
         // For tree link status, we want to show status across all packages
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running link status across workspace...`);
         // Create a config that will be passed to the link command
@@ -880,7 +971,7 @@ const execute = async (runConfig)=>{
         }
     }
     // Handle unlink status subcommand
-    if (builtInCommand === 'unlink' && ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.packageArgument) === 'status') {
+    if (builtInCommand === 'unlink' && ((_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.packageArgument) === 'status') {
         // For tree unlink status, we want to show status across all packages
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running unlink status across workspace...`);
         // Create a config that will be passed to the unlink command
@@ -905,9 +996,9 @@ const execute = async (runConfig)=>{
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${directories.join(', ')}`);
     }
     try {
-        var _runConfig_tree7, _runConfig_tree8, _runConfig_tree9, _runConfig_tree10;
+        var _runConfig_tree9, _runConfig_tree10, _runConfig_tree11, _runConfig_tree12;
         // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.exclude) || [];
+        const excludedPatterns = ((_runConfig_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.exclude) || [];
         if (excludedPatterns.length > 0) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
         }
@@ -934,7 +1025,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_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.startFrom;
+        const startFrom = (_runConfig_tree10 = runConfig.tree) === null || _runConfig_tree10 === void 0 ? void 0 : _runConfig_tree10.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)
@@ -991,7 +1082,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_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.stopAt;
+        const stopAt = (_runConfig_tree11 = runConfig.tree) === null || _runConfig_tree11 === void 0 ? void 0 : _runConfig_tree11.stopAt;
         if (stopAt) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for stop package: ${stopAt}`);
             // Find the package that matches the stopAt directory name
@@ -1308,6 +1399,146 @@ const execute = async (runConfig)=>{
             logger.info('');
             return `Branch status summary for ${branchInfos.length} packages completed.`;
         }
+        // Handle special "checkout" command that switches all packages to specified branch
+        if (builtInCommand === 'checkout') {
+            var _runConfig_tree13;
+            const targetBranch = (_runConfig_tree13 = runConfig.tree) === null || _runConfig_tree13 === void 0 ? void 0 : _runConfig_tree13.packageArgument;
+            if (!targetBranch) {
+                throw new Error('checkout subcommand requires a branch name. Usage: kodrdriv tree checkout <branch-name>');
+            }
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Workspace Checkout to Branch: ${targetBranch}`);
+            logger.info('');
+            // Phase 1: Safety check - scan all packages for uncommitted changes
+            logger.info('🔍 Phase 1: Checking for uncommitted changes across workspace...');
+            const packagesWithChanges = [];
+            for (const packageName of buildOrder){
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                try {
+                    const gitStatus = await getGitStatusSummary(packageInfo.path);
+                    const hasProblems = gitStatus.hasUncommittedChanges || gitStatus.hasUnstagedFiles;
+                    packagesWithChanges.push({
+                        name: packageName,
+                        path: packageInfo.path,
+                        status: gitStatus.status,
+                        hasUncommittedChanges: gitStatus.hasUncommittedChanges,
+                        hasUnstagedFiles: gitStatus.hasUnstagedFiles
+                    });
+                    if (hasProblems) {
+                        logger.warn(`⚠️  ${packageName}: ${gitStatus.status}`);
+                    } else {
+                        logger.verbose(`✅ ${packageName}: clean`);
+                    }
+                } catch (error) {
+                    logger.warn(`❌ ${packageName}: error checking status - ${error.message}`);
+                    packagesWithChanges.push({
+                        name: packageName,
+                        path: packageInfo.path,
+                        status: 'error',
+                        hasUncommittedChanges: false,
+                        hasUnstagedFiles: false
+                    });
+                }
+            }
+            // Check if any packages have uncommitted changes
+            const problemPackages = packagesWithChanges.filter((pkg)=>pkg.hasUncommittedChanges || pkg.hasUnstagedFiles || pkg.status === 'error');
+            if (problemPackages.length > 0) {
+                logger.error(`❌ Cannot proceed with checkout: ${problemPackages.length} packages have uncommitted changes or errors:`);
+                logger.error('');
+                for (const pkg of problemPackages){
+                    logger.error(`  📦 ${pkg.name} (${pkg.path}):`);
+                    logger.error(`      Status: ${pkg.status}`);
+                }
+                logger.error('');
+                logger.error('🔧 To resolve this issue:');
+                logger.error('   1. Commit or stash changes in the packages listed above');
+                logger.error('   2. Or use "kodrdriv tree commit" to commit changes across all packages');
+                logger.error('   3. Then re-run the checkout command');
+                logger.error('');
+                throw new Error(`Workspace checkout blocked: ${problemPackages.length} packages have uncommitted changes`);
+            }
+            logger.info(`✅ Phase 1 complete: All ${packagesWithChanges.length} packages are clean`);
+            logger.info('');
+            // Phase 2: Perform the checkout
+            logger.info(`🔄 Phase 2: Checking out all packages to branch '${targetBranch}'...`);
+            let successCount = 0;
+            const failedPackages = [];
+            for(let i = 0; i < buildOrder.length; i++){
+                const packageName = buildOrder[i];
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                if (isDryRun) {
+                    logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: Would checkout ${targetBranch}`);
+                    successCount++;
+                } else {
+                    try {
+                        const originalCwd = process.cwd();
+                        process.chdir(packageInfo.path);
+                        try {
+                            // Check if target branch exists locally
+                            let branchExists = false;
+                            try {
+                                await runSecure('git', [
+                                    'rev-parse',
+                                    '--verify',
+                                    targetBranch
+                                ]);
+                                branchExists = true;
+                            } catch  {
+                                // Branch doesn't exist locally
+                                branchExists = false;
+                            }
+                            if (branchExists) {
+                                await runSecure('git', [
+                                    'checkout',
+                                    targetBranch
+                                ]);
+                                logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: ✅ Checked out ${targetBranch}`);
+                            } else {
+                                // Try to check out branch from remote
+                                try {
+                                    await runSecure('git', [
+                                        'checkout',
+                                        '-b',
+                                        targetBranch,
+                                        `origin/${targetBranch}`
+                                    ]);
+                                    logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: ✅ Checked out ${targetBranch} from origin`);
+                                } catch  {
+                                    // If that fails, create a new branch
+                                    await runSecure('git', [
+                                        'checkout',
+                                        '-b',
+                                        targetBranch
+                                    ]);
+                                    logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: ✅ Created new branch ${targetBranch}`);
+                                }
+                            }
+                            successCount++;
+                        } finally{
+                            process.chdir(originalCwd);
+                        }
+                    } catch (error) {
+                        logger.error(`[${i + 1}/${buildOrder.length}] ${packageName}: ❌ Failed - ${error.message}`);
+                        failedPackages.push({
+                            name: packageName,
+                            error: error.message
+                        });
+                    }
+                }
+            }
+            // Report results
+            if (failedPackages.length > 0) {
+                logger.error(`❌ Checkout completed with errors: ${successCount}/${buildOrder.length} packages successful`);
+                logger.error('');
+                logger.error('Failed packages:');
+                for (const failed of failedPackages){
+                    logger.error(`  - ${failed.name}: ${failed.error}`);
+                }
+                throw new Error(`Checkout failed for ${failedPackages.length} packages`);
+            } else {
+                logger.info(`✅ Checkout complete: All ${buildOrder.length} packages successfully checked out to '${targetBranch}'`);
+                return `Workspace checkout complete: ${successCount} packages checked out to '${targetBranch}'`;
+            }
+        }
         // Display results
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Build order determined:`);
         let returnOutput = '';
@@ -1350,12 +1581,12 @@ const execute = async (runConfig)=>{
             returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
         }
         // Execute command if provided (custom command or built-in command)
-        const cmd = (_runConfig_tree10 = runConfig.tree) === null || _runConfig_tree10 === void 0 ? void 0 : _runConfig_tree10.cmd;
+        const cmd = (_runConfig_tree12 = runConfig.tree) === null || _runConfig_tree12 === void 0 ? void 0 : _runConfig_tree12.cmd;
         // Determine command to execute
         let commandToRun;
         let isBuiltInCommand = false;
         if (builtInCommand) {
-            var _runConfig_tree11, _runConfig_tree12, _runConfig_tree13;
+            var _runConfig_tree14, _runConfig_tree15, _runConfig_tree16;
             // Built-in command mode: shell out to kodrdriv subprocess
             // Build command with propagated global options
             const globalOptions = [];
@@ -1371,15 +1602,15 @@ const execute = async (runConfig)=>{
             if (runConfig.preferencesDirectory) globalOptions.push(`--preferences-dir "${runConfig.preferencesDirectory}"`);
             // Build the command with global options
             const optionsString = globalOptions.length > 0 ? ` ${globalOptions.join(' ')}` : '';
-            // Add package argument for link/unlink commands
-            const packageArg = (_runConfig_tree11 = runConfig.tree) === null || _runConfig_tree11 === void 0 ? void 0 : _runConfig_tree11.packageArgument;
-            const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink') ? ` "${packageArg}"` : '';
+            // Add package argument for link/unlink/updates commands
+            const packageArg = (_runConfig_tree14 = runConfig.tree) === null || _runConfig_tree14 === void 0 ? void 0 : _runConfig_tree14.packageArgument;
+            const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink' || builtInCommand === 'updates') ? ` "${packageArg}"` : '';
             // Add command-specific options
             let commandSpecificOptions = '';
-            if (builtInCommand === 'unlink' && ((_runConfig_tree12 = runConfig.tree) === null || _runConfig_tree12 === void 0 ? void 0 : _runConfig_tree12.cleanNodeModules)) {
+            if (builtInCommand === 'unlink' && ((_runConfig_tree15 = runConfig.tree) === null || _runConfig_tree15 === void 0 ? void 0 : _runConfig_tree15.cleanNodeModules)) {
                 commandSpecificOptions += ' --clean-node-modules';
             }
-            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree13 = runConfig.tree) === null || _runConfig_tree13 === void 0 ? void 0 : _runConfig_tree13.externals) && runConfig.tree.externals.length > 0) {
+            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree16 = runConfig.tree) === null || _runConfig_tree16 === void 0 ? void 0 : _runConfig_tree16.externals) && runConfig.tree.externals.length > 0) {
                 commandSpecificOptions += ` --externals ${runConfig.tree.externals.join(' ')}`;
             }
             commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;