@eldrforge/kodrdriv 1.2.124 → 1.2.125

package/dist/commands/tree.js

@@ -520,10 +520,11 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
         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 publish and commit commands, default to full output to show AI progress and other details
     // For other commands, require --verbose or --debug for output
     const isPublishCommand = isBuiltInCommand && commandToRun.includes('publish');
-    let showOutput = isPublishCommand ? 'full' : 'none';
+    const isCommitCommand = isBuiltInCommand && commandToRun.includes('commit');
+    let showOutput = isPublishCommand || isCommitCommand ? 'full' : 'none';
     if (runConfig.debug) {
         showOutput = 'full';
     } else if (runConfig.verbose) {
@@ -531,8 +532,12 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
     }
     // Show package start info - always visible for progress tracking
     if (runConfig.debug) {
-        packageLogger.debug(`Starting execution in ${packageDir}`);
-        packageLogger.debug(`Command: ${commandToRun}`);
+        packageLogger.debug('MULTI_PROJECT_START: Starting package execution | Package: %s | Index: %d/%d | Path: %s | Command: %s | Context: tree execution', packageName, index + 1, total, packageDir, commandToRun);
+        packageLogger.debug('MULTI_PROJECT_CONTEXT: Execution details | Directory: %s | Built-in Command: %s | Dry Run: %s | Output Level: %s', packageDir, isBuiltInCommand, isDryRun, showOutput);
+        // Show dependencies if available
+        if (packageInfo.dependencies && Array.isArray(packageInfo.dependencies) && packageInfo.dependencies.length > 0) {
+            packageLogger.debug('MULTI_PROJECT_DEPS: Package dependencies | Package: %s | Dependencies: [%s]', packageName, packageInfo.dependencies.join(', '));
+        }
     } else if (runConfig.verbose) {
         packageLogger.verbose(`Starting execution in ${packageDir}`);
     } else {
@@ -791,16 +796,16 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     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)
+                    } else if (!isPublishCommand && !isCommitCommand) {
+                        // Show timing in completion message (publish/commit commands have their own completion message)
                         logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed (${seconds}s)`);
                     }
                 } else {
                     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)
+                    } else if (!isPublishCommand && !isCommitCommand) {
+                        // Basic completion info (publish/commit commands have their own completion message)
                         logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
                     }
                 }
@@ -822,15 +827,15 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                 }
             }
         }
-        // Show completion status (for publish commands, this supplements the timing message above)
+        // Show completion status (for publish/commit commands, this supplements the timing message above)
         if (runConfig.debug || runConfig.verbose) {
             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
+        } else if (isPublishCommand || isCommitCommand) {
+            // For publish/commit commands, always show completion even without verbose
             // Include timing if available
             const timeStr = executionDuration !== undefined ? ` (${(executionDuration / 1000).toFixed(1)}s)` : '';
             if (publishWasSkipped) {
@@ -1930,9 +1935,72 @@ const execute = async (runConfig)=>{
             const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink' || builtInCommand === 'updates') ? ` "${packageArg}"` : '';
             // Add command-specific options
             let commandSpecificOptions = '';
+            // Commit command options
+            if (builtInCommand === 'commit') {
+                var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7, _runConfig_commit8, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14, _runConfig_commit15, _runConfig_commit16;
+                if ((_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.agentic) {
+                    commandSpecificOptions += ' --agentic';
+                }
+                if ((_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.selfReflection) {
+                    commandSpecificOptions += ' --self-reflection';
+                }
+                if ((_runConfig_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.add) {
+                    commandSpecificOptions += ' --add';
+                }
+                if ((_runConfig_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.cached) {
+                    commandSpecificOptions += ' --cached';
+                }
+                if ((_runConfig_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.interactive) {
+                    commandSpecificOptions += ' --interactive';
+                }
+                if ((_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.amend) {
+                    commandSpecificOptions += ' --amend';
+                }
+                if ((_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.skipFileCheck) {
+                    commandSpecificOptions += ' --skip-file-check';
+                }
+                if ((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.maxAgenticIterations) {
+                    commandSpecificOptions += ` --max-agentic-iterations ${runConfig.commit.maxAgenticIterations}`;
+                }
+                if ((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.allowCommitSplitting) {
+                    commandSpecificOptions += ' --allow-commit-splitting';
+                }
+                if ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.messageLimit) {
+                    commandSpecificOptions += ` --message-limit ${runConfig.commit.messageLimit}`;
+                }
+                if ((_runConfig_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.maxDiffBytes) {
+                    commandSpecificOptions += ` --max-diff-bytes ${runConfig.commit.maxDiffBytes}`;
+                }
+                if ((_runConfig_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.direction) {
+                    commandSpecificOptions += ` --direction "${runConfig.commit.direction}"`;
+                }
+                if ((_runConfig_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.context) {
+                    commandSpecificOptions += ` --context "${runConfig.commit.context}"`;
+                }
+                // Push option can be boolean or string (remote name)
+                if ((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.push) {
+                    if (typeof runConfig.commit.push === 'string') {
+                        commandSpecificOptions += ` --push "${runConfig.commit.push}"`;
+                    } else {
+                        commandSpecificOptions += ' --push';
+                    }
+                }
+                // Model-specific options for commit
+                if ((_runConfig_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.model) {
+                    commandSpecificOptions += ` --model "${runConfig.commit.model}"`;
+                }
+                if ((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.openaiReasoning) {
+                    commandSpecificOptions += ` --openai-reasoning ${runConfig.commit.openaiReasoning}`;
+                }
+                if ((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.openaiMaxOutputTokens) {
+                    commandSpecificOptions += ` --openai-max-output-tokens ${runConfig.commit.openaiMaxOutputTokens}`;
+                }
+            }
+            // Unlink command options
             if (builtInCommand === 'unlink' && ((_runConfig_tree31 = runConfig.tree) === null || _runConfig_tree31 === void 0 ? void 0 : _runConfig_tree31.cleanNodeModules)) {
                 commandSpecificOptions += ' --clean-node-modules';
             }
+            // Link/Unlink externals
             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(' ')}`;
             }
@@ -2005,6 +2073,55 @@ const execute = async (runConfig)=>{
             logger.info('');
             const executionDescription = isBuiltInCommand ? `built-in command "${builtInCommand}"` : `"${commandToRun}"`;
             logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Executing ${executionDescription} in ${buildOrder.length} packages...`);
+            // Add detailed multi-project execution context for debug mode
+            if (runConfig.debug) {
+                var _runConfig_tree35, _runConfig_tree36;
+                logger.debug('MULTI_PROJECT_PLAN: Execution plan initialized | Total Packages: %d | Command: %s | Built-in: %s | Dry Run: %s | Parallel: %s', buildOrder.length, commandToRun, isBuiltInCommand, isDryRun, ((_runConfig_tree35 = runConfig.tree) === null || _runConfig_tree35 === void 0 ? void 0 : _runConfig_tree35.parallel) || false);
+                // Log package execution order with dependencies
+                logger.debug('MULTI_PROJECT_ORDER: Package execution sequence:');
+                buildOrder.forEach((pkgName, idx)=>{
+                    const pkgInfo = dependencyGraph.packages.get(pkgName);
+                    if (pkgInfo) {
+                        const deps = Array.isArray(pkgInfo.dependencies) ? pkgInfo.dependencies : [];
+                        const depStr = deps.length > 0 ? ` | Dependencies: [${deps.join(', ')}]` : ' | Dependencies: none';
+                        logger.debug('  %d. %s%s', idx + 1, pkgName, depStr);
+                    }
+                });
+                // Log dependency levels for parallel execution understanding
+                const levels = new Map();
+                const calculateLevels = (pkg, visited = new Set())=>{
+                    if (levels.has(pkg)) return levels.get(pkg);
+                    if (visited.has(pkg)) return 0; // Circular dependency
+                    visited.add(pkg);
+                    const pkgInfo = dependencyGraph.packages.get(pkg);
+                    const deps = Array.isArray(pkgInfo === null || pkgInfo === void 0 ? void 0 : pkgInfo.dependencies) ? pkgInfo.dependencies : [];
+                    if (!pkgInfo || deps.length === 0) {
+                        levels.set(pkg, 0);
+                        return 0;
+                    }
+                    const maxDepLevel = Math.max(...deps.map((dep)=>calculateLevels(dep, new Set(visited))));
+                    const level = maxDepLevel + 1;
+                    levels.set(pkg, level);
+                    return level;
+                };
+                buildOrder.forEach((pkg)=>calculateLevels(pkg));
+                const maxLevel = Math.max(...Array.from(levels.values()));
+                logger.debug('MULTI_PROJECT_LEVELS: Dependency depth analysis | Max Depth: %d levels', maxLevel + 1);
+                for(let level = 0; level <= maxLevel; level++){
+                    const packagesAtLevel = buildOrder.filter((pkg)=>levels.get(pkg) === level);
+                    logger.debug('  Level %d (%d packages): %s', level, packagesAtLevel.length, packagesAtLevel.join(', '));
+                }
+                if ((_runConfig_tree36 = runConfig.tree) === null || _runConfig_tree36 === void 0 ? void 0 : _runConfig_tree36.parallel) {
+                    var _runConfig_tree_retry1;
+                    const os = await import('os');
+                    const concurrency = runConfig.tree.maxConcurrency || os.cpus().length;
+                    logger.debug('MULTI_PROJECT_PARALLEL: Parallel execution configuration | Max Concurrency: %d | Retry Attempts: %d', concurrency, ((_runConfig_tree_retry1 = runConfig.tree.retry) === null || _runConfig_tree_retry1 === void 0 ? void 0 : _runConfig_tree_retry1.maxAttempts) || 3);
+                }
+                if (isContinue) {
+                    const completed = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.completedPackages.length) || 0;
+                    logger.debug('MULTI_PROJECT_RESUME: Continuing previous execution | Completed: %d | Remaining: %d', completed, buildOrder.length - completed);
+                }
+            }
             // Show info for publish commands
             if (isBuiltInCommand && builtInCommand === 'publish') {
                 logger.info('Inter-project dependencies will be automatically updated before each publish.');
@@ -2015,7 +2132,7 @@ const execute = async (runConfig)=>{
             const startIndex = isContinue && executionContext ? executionContext.completedPackages.length : 0;
             // Check if parallel execution is enabled
             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;
+                var _runConfig_tree_retry2, _runConfig_tree_retry3, _runConfig_tree_retry4, _runConfig_tree_retry5;
                 logger.info('🚀 Using parallel execution mode');
                 // If dry run, show preview instead of executing
                 if (isDryRun) {
@@ -2033,10 +2150,10 @@ const execute = async (runConfig)=>{
                     config: runConfig,
                     checkpointPath: runConfig.outputDirectory,
                     continue: isContinue,
-                    maxRetries: ((_runConfig_tree_retry1 = runConfig.tree.retry) === null || _runConfig_tree_retry1 === void 0 ? void 0 : _runConfig_tree_retry1.maxAttempts) || 3,
-                    initialRetryDelay: ((_runConfig_tree_retry2 = runConfig.tree.retry) === null || _runConfig_tree_retry2 === void 0 ? void 0 : _runConfig_tree_retry2.initialDelayMs) || 5000,
-                    maxRetryDelay: ((_runConfig_tree_retry3 = runConfig.tree.retry) === null || _runConfig_tree_retry3 === void 0 ? void 0 : _runConfig_tree_retry3.maxDelayMs) || 60000,
-                    backoffMultiplier: ((_runConfig_tree_retry4 = runConfig.tree.retry) === null || _runConfig_tree_retry4 === void 0 ? void 0 : _runConfig_tree_retry4.backoffMultiplier) || 2
+                    maxRetries: ((_runConfig_tree_retry2 = runConfig.tree.retry) === null || _runConfig_tree_retry2 === void 0 ? void 0 : _runConfig_tree_retry2.maxAttempts) || 3,
+                    initialRetryDelay: ((_runConfig_tree_retry3 = runConfig.tree.retry) === null || _runConfig_tree_retry3 === void 0 ? void 0 : _runConfig_tree_retry3.initialDelayMs) || 5000,
+                    maxRetryDelay: ((_runConfig_tree_retry4 = runConfig.tree.retry) === null || _runConfig_tree_retry4 === void 0 ? void 0 : _runConfig_tree_retry4.maxDelayMs) || 60000,
+                    backoffMultiplier: ((_runConfig_tree_retry5 = runConfig.tree.retry) === null || _runConfig_tree_retry5 === void 0 ? void 0 : _runConfig_tree_retry5.backoffMultiplier) || 2
                 }, executePackage);
                 // Set up progress logging
                 createParallelProgressLogger(adapter.getPool(), runConfig);