@eldrforge/commands-git 0.1.3 → 0.1.5

package/dist/index.js

@@ -3,7 +3,7 @@ import 'dotenv/config';
 import shellescape from 'shell-escape';
 import { getDryRunLogger, DEFAULT_MAX_DIFF_BYTES, DEFAULT_EXCLUDED_PATTERNS, Diff, Files, Log, DEFAULT_OUTPUT_DIRECTORY, sanitizeDirection, toAIConfig, createStorageAdapter, createLoggerAdapter, getOutputPath, getTimestampedResponseFilename, getTimestampedRequestFilename, filterContent, getTimestampedCommitFilename, improveContentWithLLM, getLogger, getTimestampedReviewNotesFilename, getTimestampedReviewFilename } from '@eldrforge/core';
 import { ValidationError, ExternalDependencyError, CommandError, createStorage, checkForFileDependencies as checkForFileDependencies$1, logFileDependencyWarning, logFileDependencySuggestions, FileOperationError } from '@eldrforge/shared';
-import { run, validateString, safeJsonParse, validatePackageJson, unstageAll, stageFiles, verifyStagedFiles, runSecure } from '@eldrforge/git-tools';
+import { run, validateString, safeJsonParse, validatePackageJson, unstageAll, stageFiles, verifyStagedFiles, runSecure, getCurrentBranch, getGitStatusSummary } from '@eldrforge/git-tools';
 import { getRecentClosedIssuesForCommit, handleIssueCreation, getReleaseNotesContent, getIssuesContent } from '@eldrforge/github-tools';
 import { runAgenticCommit, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createCommitPrompt, createReviewPrompt, createCompletion } from '@eldrforge/ai-service';
 import path from 'path';
@@ -311,6 +311,41 @@ const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
         }
     }
 };
+/**
+ * Deduplicate files across splits - each file can only be in one split
+ * Later splits lose files that were already claimed by earlier splits
+ * Returns filtered splits with empty splits removed
+ */ function deduplicateSplits(splits, logger) {
+    const claimedFiles = new Set();
+    const result = [];
+    for (const split of splits){
+        // Find files in this split that haven't been claimed yet
+        const uniqueFiles = [];
+        const duplicates = [];
+        for (const file of split.files){
+            if (claimedFiles.has(file)) {
+                duplicates.push(file);
+            } else {
+                uniqueFiles.push(file);
+                claimedFiles.add(file);
+            }
+        }
+        // Log if duplicates were found
+        if (duplicates.length > 0) {
+            logger.warn(`Removing duplicate files from split "${split.message.split('\n')[0]}": ${duplicates.join(', ')}`);
+        }
+        // Only include split if it has files
+        if (uniqueFiles.length > 0) {
+            result.push({
+                ...split,
+                files: uniqueFiles
+            });
+        } else {
+            logger.warn(`Skipping empty split after deduplication: "${split.message.split('\n')[0]}"`);
+        }
+    }
+    return result;
+}
 /**
  * Interactive review of a single split before committing
  */ async function reviewSplitInteractively(split, index, total, logger) {
@@ -516,7 +551,7 @@ const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
     lines.push('═'.repeat(80));
     return lines.join('\n');
 }
-const executeInternal$2 = async (runConfig)=>{
+const executeInternal$3 = async (runConfig)=>{
     var _ref, _runConfig_excludedPatterns;
     var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _aiConfig_commands_commit, _aiConfig_commands, _runConfig_commit7, _aiConfig_commands_commit1, _aiConfig_commands1, _runConfig_commit8, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14;
     const isDryRun = runConfig.dryRun || false;
@@ -722,8 +757,14 @@ const executeInternal$2 = async (runConfig)=>{
         if (autoSplitEnabled) {
             var _runConfig_commit19, _runConfig_commit20;
             logger.info('\n🔄 Auto-split enabled - creating separate commits...\n');
+            // Deduplicate files across splits to prevent staging errors
+            // (AI sometimes suggests the same file in multiple splits)
+            const deduplicatedSplits = deduplicateSplits(agenticResult.suggestedSplits, logger);
+            if (deduplicatedSplits.length === 0) {
+                throw new CommandError('All splits were empty after deduplication - no files to commit', 'SPLIT_EMPTY', false);
+            }
             const splitResult = await executeSplitCommits({
-                splits: agenticResult.suggestedSplits,
+                splits: deduplicatedSplits,
                 isDryRun,
                 interactive: !!(((_runConfig_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.interactive) && !((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.sendit)),
                 logger});
@@ -876,9 +917,9 @@ const executeInternal$2 = async (runConfig)=>{
     }
     return summary;
 };
-const execute$3 = async (runConfig)=>{
+const execute$4 = async (runConfig)=>{
     try {
-        return await executeInternal$2(runConfig);
+        return await executeInternal$3(runConfig);
     } catch (error) {
         // Import getLogger for error handling
         const { getLogger } = await import('@eldrforge/core');
@@ -1502,7 +1543,7 @@ const checkForFileDependencies = (packageJsonFiles)=>{
  * Execute precommit checks: lint -> build -> test
  * Skips clean step (clean should be run separately if needed)
  * Uses optimization to skip steps when unchanged
- */ const execute$2 = async (runConfig)=>{
+ */ const execute$3 = async (runConfig)=>{
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
     const packageDir = process.cwd();
@@ -1588,7 +1629,7 @@ const checkForFileDependencies = (packageJsonFiles)=>{
     }
 };
 
-const executeInternal$1 = async (runConfig)=>{
+const executeInternal$2 = async (runConfig)=>{
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     const storage = createStorage();
@@ -1612,9 +1653,9 @@ const executeInternal$1 = async (runConfig)=>{
         throw new FileOperationError('Failed to remove output directory', outputDirectory, error);
     }
 };
-const execute$1 = async (runConfig)=>{
+const execute$2 = async (runConfig)=>{
     try {
-        await executeInternal$1(runConfig);
+        await executeInternal$2(runConfig);
     } catch (error) {
         const logger = getLogger();
         if (error instanceof FileOperationError) {
@@ -2083,7 +2124,7 @@ const processSingleReview = async (reviewNote, runConfig, outputDirectory)=>{
     }
     return analysisResult;
 };
-const executeInternal = async (runConfig)=>{
+const executeInternal$1 = async (runConfig)=>{
     var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review4, _runConfig_review5, _runConfig_review6, _runConfig_review7, _runConfig_review8, _runConfig_review9, _runConfig_review10, _runConfig_review11, _runConfig_review12, _runConfig_review13, _runConfig_review14, _runConfig_review15, _runConfig_review16, _runConfig_review17, _runConfig_review18;
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
@@ -2313,9 +2354,9 @@ const executeInternal = async (runConfig)=>{
     const senditMode = ((_runConfig_review18 = runConfig.review) === null || _runConfig_review18 === void 0 ? void 0 : _runConfig_review18.sendit) || false;
     return await handleIssueCreation(analysisResult, senditMode);
 };
-const execute = async (runConfig)=>{
+const execute$1 = async (runConfig)=>{
     try {
-        return await executeInternal(runConfig);
+        return await executeInternal$1(runConfig);
     } catch (error) {
         const logger = getLogger();
         if (error instanceof ValidationError) {
@@ -2342,5 +2383,585 @@ const execute = async (runConfig)=>{
     }
 };
 
-export { PerformanceTimer, batchReadPackageJsonFiles, checkForFileDependencies, execute$1 as clean, collectAllDependencies, execute$3 as commit, findAllPackageJsonFiles, findPackagesByScope, isCleanNeeded, isTestNeeded, optimizePrecommitCommand, execute$2 as precommit, recordTestRun, execute as review, scanDirectoryForPackages };
+// Patterns for files that can be auto-resolved
+const AUTO_RESOLVABLE_PATTERNS = {
+    // Package lock files - just regenerate
+    packageLock: /^package-lock\.json$/,
+    yarnLock: /^yarn\.lock$/,
+    pnpmLock: /^pnpm-lock\.yaml$/,
+    // Generated files - take theirs and regenerate
+    dist: /^dist\//,
+    coverage: /^coverage\//,
+    nodeModules: /^node_modules\//,
+    // Build artifacts
+    buildOutput: /\.(js\.map|d\.ts)$/
+};
+/**
+ * Check if a file can be auto-resolved
+ */ function canAutoResolve(filename) {
+    if (AUTO_RESOLVABLE_PATTERNS.packageLock.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'regenerate-lock'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.yarnLock.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'regenerate-lock'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.pnpmLock.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'regenerate-lock'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.dist.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs-regenerate'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.coverage.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.nodeModules.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.buildOutput.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs-regenerate'
+        };
+    }
+    return {
+        canResolve: false,
+        strategy: 'manual'
+    };
+}
+/**
+ * Check if this is a package.json version conflict that can be auto-resolved
+ */ async function tryResolvePackageJsonConflict(filepath, logger) {
+    const storage = createStorage();
+    try {
+        const content = await storage.readFile(filepath, 'utf-8');
+        // Check if this is actually a conflict file
+        if (!content.includes('<<<<<<<') || !content.includes('>>>>>>>')) {
+            return {
+                resolved: false,
+                error: 'Not a conflict file'
+            };
+        }
+        // Try to parse ours and theirs versions
+        const oursMatch = content.match(/<<<<<<< .*?\n([\s\S]*?)=======\n/);
+        const theirsMatch = content.match(/=======\n([\s\S]*?)>>>>>>> /);
+        if (!oursMatch || !theirsMatch) {
+            return {
+                resolved: false,
+                error: 'Cannot parse conflict markers'
+            };
+        }
+        // For package.json, if only version differs, take the higher version
+        // This is a simplified heuristic - real conflicts may need more logic
+        const oursPart = oursMatch[1];
+        const theirsPart = theirsMatch[1];
+        // Check if this is just a version conflict
+        const versionPattern = /"version":\s*"([^"]+)"/;
+        const oursVersion = oursPart.match(versionPattern);
+        const theirsVersion = theirsPart.match(versionPattern);
+        if (oursVersion && theirsVersion) {
+            // Both have versions - take higher one
+            const semver = await import('semver');
+            const higher = semver.gt(oursVersion[1].replace(/-.*$/, ''), theirsVersion[1].replace(/-.*$/, '')) ? oursVersion[1] : theirsVersion[1];
+            // Replace the conflicted version with the higher one
+            let resolvedContent = content;
+            // Simple approach: take theirs but use higher version
+            // Remove conflict markers and use theirs as base
+            resolvedContent = content.replace(/<<<<<<< .*?\n[\s\S]*?=======\n([\s\S]*?)>>>>>>> .*?\n/g, '$1');
+            // Update version to higher one
+            resolvedContent = resolvedContent.replace(/"version":\s*"[^"]+"/, `"version": "${higher}"`);
+            await storage.writeFile(filepath, resolvedContent, 'utf-8');
+            logger.info(`PULL_RESOLVED_VERSION: Auto-resolved version conflict | File: ${filepath} | Version: ${higher}`);
+            return {
+                resolved: true
+            };
+        }
+        return {
+            resolved: false,
+            error: 'Complex conflict - not just version'
+        };
+    } catch (error) {
+        return {
+            resolved: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Resolve a single conflict file
+ */ async function resolveConflict(filepath, strategy, logger, isDryRun) {
+    if (isDryRun) {
+        logger.info(`PULL_RESOLVE_DRY_RUN: Would resolve conflict | File: ${filepath} | Strategy: ${strategy}`);
+        return {
+            file: filepath,
+            resolved: true,
+            strategy
+        };
+    }
+    try {
+        switch(strategy){
+            case 'regenerate-lock':
+                {
+                    // Accept theirs and regenerate
+                    await runSecure('git', [
+                        'checkout',
+                        '--theirs',
+                        filepath
+                    ]);
+                    await runSecure('git', [
+                        'add',
+                        filepath
+                    ]);
+                    logger.info(`PULL_CONFLICT_RESOLVED: Accepted remote lock file | File: ${filepath} | Strategy: ${strategy} | Note: Will regenerate after pull`);
+                    return {
+                        file: filepath,
+                        resolved: true,
+                        strategy
+                    };
+                }
+            case 'take-theirs':
+            case 'take-theirs-regenerate':
+                {
+                    await runSecure('git', [
+                        'checkout',
+                        '--theirs',
+                        filepath
+                    ]);
+                    await runSecure('git', [
+                        'add',
+                        filepath
+                    ]);
+                    logger.info(`PULL_CONFLICT_RESOLVED: Accepted remote version | File: ${filepath} | Strategy: ${strategy}`);
+                    return {
+                        file: filepath,
+                        resolved: true,
+                        strategy
+                    };
+                }
+            case 'version-bump':
+                {
+                    const result = await tryResolvePackageJsonConflict(filepath, logger);
+                    if (result.resolved) {
+                        await runSecure('git', [
+                            'add',
+                            filepath
+                        ]);
+                        return {
+                            file: filepath,
+                            resolved: true,
+                            strategy
+                        };
+                    }
+                    return {
+                        file: filepath,
+                        resolved: false,
+                        strategy,
+                        error: result.error
+                    };
+                }
+            default:
+                return {
+                    file: filepath,
+                    resolved: false,
+                    strategy,
+                    error: 'Unknown resolution strategy'
+                };
+        }
+    } catch (error) {
+        return {
+            file: filepath,
+            resolved: false,
+            strategy,
+            error: error.message
+        };
+    }
+}
+/**
+ * Get list of conflicted files
+ */ async function getConflictedFiles() {
+    try {
+        const { stdout } = await runSecure('git', [
+            'diff',
+            '--name-only',
+            '--diff-filter=U'
+        ]);
+        return stdout.trim().split('\n').filter((f)=>f.trim());
+    } catch  {
+        return [];
+    }
+}
+/**
+ * Try to auto-resolve all conflicts
+ */ async function autoResolveConflicts(logger, isDryRun) {
+    const conflictedFiles = await getConflictedFiles();
+    const resolved = [];
+    const manual = [];
+    for (const file of conflictedFiles){
+        const { canResolve, strategy } = canAutoResolve(file);
+        // Special handling for package.json
+        if (file === 'package.json' || file.endsWith('/package.json')) {
+            const result = await resolveConflict(file, 'version-bump', logger, isDryRun);
+            if (result.resolved) {
+                resolved.push(file);
+            } else {
+                manual.push(file);
+            }
+            continue;
+        }
+        if (canResolve) {
+            const result = await resolveConflict(file, strategy, logger, isDryRun);
+            if (result.resolved) {
+                resolved.push(file);
+            } else {
+                manual.push(file);
+            }
+        } else {
+            manual.push(file);
+        }
+    }
+    return {
+        resolved,
+        manual
+    };
+}
+/**
+ * Stash local changes if any
+ */ async function stashIfNeeded(logger, isDryRun) {
+    const status = await getGitStatusSummary();
+    if (status.hasUncommittedChanges || status.hasUnstagedFiles) {
+        const changeCount = status.uncommittedCount + status.unstagedCount;
+        logger.info(`PULL_STASHING: Stashing ${changeCount} local changes before pull | Staged: ${status.uncommittedCount} | Unstaged: ${status.unstagedCount}`);
+        if (!isDryRun) {
+            await runSecure('git', [
+                'stash',
+                'push',
+                '-m',
+                `kodrdriv-pull-auto-stash-${Date.now()}`
+            ]);
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Apply stash if we created one
+ */ async function applyStashIfNeeded(didStash, logger, isDryRun) {
+    if (!didStash) return false;
+    logger.info('PULL_STASH_POP: Restoring stashed changes');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'stash',
+                'pop'
+            ]);
+            return true;
+        } catch (error) {
+            logger.warn(`PULL_STASH_CONFLICT: Stash pop had conflicts | Error: ${error.message} | Action: Stash preserved, manual intervention needed`);
+            // Don't fail - user can manually resolve stash conflicts
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Regenerate lock files after pull
+ */ async function regenerateLockFiles(resolvedFiles, logger, isDryRun) {
+    const needsRegenerate = resolvedFiles.some((f)=>f === 'package-lock.json' || f.endsWith('/package-lock.json'));
+    if (needsRegenerate) {
+        logger.info('PULL_REGENERATE_LOCK: Regenerating package-lock.json');
+        if (!isDryRun) {
+            try {
+                await run('npm install');
+                logger.info('PULL_REGENERATE_SUCCESS: Lock file regenerated successfully');
+            } catch (error) {
+                logger.warn(`PULL_REGENERATE_FAILED: Failed to regenerate lock file | Error: ${error.message}`);
+            }
+        }
+    }
+}
+/**
+ * Main pull execution
+ */ async function executePull(remote, branch, logger, isDryRun) {
+    const currentBranch = await getCurrentBranch();
+    const targetBranch = branch || currentBranch;
+    logger.info(`PULL_STARTING: Pulling changes | Remote: ${remote} | Branch: ${targetBranch} | Current: ${currentBranch}`);
+    // Step 1: Stash any local changes
+    const didStash = await stashIfNeeded(logger, isDryRun);
+    // Step 2: Fetch first to see what's coming
+    logger.info(`PULL_FETCH: Fetching from ${remote}`);
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'fetch',
+                remote,
+                targetBranch
+            ]);
+        } catch (error) {
+            logger.error(`PULL_FETCH_FAILED: Failed to fetch | Error: ${error.message}`);
+            if (didStash) await applyStashIfNeeded(true, logger, isDryRun);
+            return {
+                success: false,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'failed',
+                message: `Fetch failed: ${error.message}`
+            };
+        }
+    }
+    // Step 3: Try fast-forward first
+    logger.info('PULL_STRATEGY: Attempting fast-forward merge');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'merge',
+                '--ff-only',
+                `${remote}/${targetBranch}`
+            ]);
+            await applyStashIfNeeded(didStash, logger, isDryRun);
+            logger.info('PULL_SUCCESS: Fast-forward merge successful');
+            return {
+                success: true,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'fast-forward',
+                message: 'Fast-forward merge successful'
+            };
+        } catch  {
+            logger.info('PULL_FF_FAILED: Fast-forward not possible, trying rebase');
+        }
+    }
+    // Step 4: Try rebase
+    logger.info('PULL_STRATEGY: Attempting rebase');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'rebase',
+                `${remote}/${targetBranch}`
+            ]);
+            await applyStashIfNeeded(didStash, logger, isDryRun);
+            logger.info('PULL_SUCCESS: Rebase successful');
+            return {
+                success: true,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'rebase',
+                message: 'Rebase successful'
+            };
+        } catch  {
+            // Check if rebase is in progress with conflicts
+            const conflictedFiles = await getConflictedFiles();
+            if (conflictedFiles.length > 0) {
+                logger.info(`PULL_CONFLICTS: Rebase has ${conflictedFiles.length} conflicts, attempting auto-resolution`);
+                // Step 5: Try to auto-resolve conflicts
+                const { resolved, manual } = await autoResolveConflicts(logger, isDryRun);
+                if (manual.length === 0) {
+                    // All conflicts resolved, continue rebase
+                    logger.info('PULL_ALL_RESOLVED: All conflicts auto-resolved, continuing rebase');
+                    try {
+                        await runSecure('git', [
+                            'rebase',
+                            '--continue'
+                        ]);
+                        await regenerateLockFiles(resolved, logger, isDryRun);
+                        await applyStashIfNeeded(didStash, logger, isDryRun);
+                        return {
+                            success: true,
+                            hadConflicts: true,
+                            autoResolved: resolved,
+                            manualRequired: [],
+                            stashApplied: didStash,
+                            strategy: 'rebase',
+                            message: `Rebase successful with ${resolved.length} auto-resolved conflicts`
+                        };
+                    } catch (continueError) {
+                        logger.warn(`PULL_CONTINUE_FAILED: Rebase continue failed | Error: ${continueError.message}`);
+                    }
+                } else {
+                    // Some conflicts need manual resolution
+                    logger.warn(`PULL_MANUAL_REQUIRED: ${manual.length} conflicts require manual resolution`);
+                    logger.warn('PULL_MANUAL_FILES: Files needing manual resolution:');
+                    manual.forEach((f)=>logger.warn(`  - ${f}`));
+                    logger.info('PULL_HINT: After resolving conflicts manually, run: git rebase --continue');
+                    // Keep rebase in progress so user can finish
+                    return {
+                        success: false,
+                        hadConflicts: true,
+                        autoResolved: resolved,
+                        manualRequired: manual,
+                        stashApplied: false,
+                        strategy: 'rebase',
+                        message: `Rebase paused: ${manual.length} files need manual conflict resolution`
+                    };
+                }
+            } else {
+                // Rebase failed for other reason, abort and try merge
+                logger.info('PULL_REBASE_ABORT: Rebase failed, aborting and trying merge');
+                try {
+                    await runSecure('git', [
+                        'rebase',
+                        '--abort'
+                    ]);
+                } catch  {
+                // Ignore abort errors
+                }
+            }
+        }
+    }
+    // Step 6: Fall back to regular merge
+    logger.info('PULL_STRATEGY: Attempting merge');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'merge',
+                `${remote}/${targetBranch}`
+            ]);
+            await applyStashIfNeeded(didStash, logger, isDryRun);
+            logger.info('PULL_SUCCESS: Merge successful');
+            return {
+                success: true,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'merge',
+                message: 'Merge successful'
+            };
+        } catch  {
+            // Check for merge conflicts
+            const conflictedFiles = await getConflictedFiles();
+            if (conflictedFiles.length > 0) {
+                logger.info(`PULL_CONFLICTS: Merge has ${conflictedFiles.length} conflicts, attempting auto-resolution`);
+                const { resolved, manual } = await autoResolveConflicts(logger, isDryRun);
+                if (manual.length === 0) {
+                    // All conflicts resolved, commit the merge
+                    logger.info('PULL_ALL_RESOLVED: All conflicts auto-resolved, completing merge');
+                    try {
+                        await runSecure('git', [
+                            'commit',
+                            '-m',
+                            `Merge ${remote}/${targetBranch} (auto-resolved by kodrdriv)`
+                        ]);
+                        await regenerateLockFiles(resolved, logger, isDryRun);
+                        await applyStashIfNeeded(didStash, logger, isDryRun);
+                        return {
+                            success: true,
+                            hadConflicts: true,
+                            autoResolved: resolved,
+                            manualRequired: [],
+                            stashApplied: didStash,
+                            strategy: 'merge',
+                            message: `Merge successful with ${resolved.length} auto-resolved conflicts`
+                        };
+                    } catch (commitError) {
+                        logger.error(`PULL_COMMIT_FAILED: Merge commit failed | Error: ${commitError.message}`);
+                    }
+                } else {
+                    logger.warn(`PULL_MANUAL_REQUIRED: ${manual.length} conflicts require manual resolution`);
+                    manual.forEach((f)=>logger.warn(`  - ${f}`));
+                    logger.info('PULL_HINT: After resolving conflicts manually, run: git commit');
+                    return {
+                        success: false,
+                        hadConflicts: true,
+                        autoResolved: resolved,
+                        manualRequired: manual,
+                        stashApplied: false,
+                        strategy: 'merge',
+                        message: `Merge paused: ${manual.length} files need manual conflict resolution`
+                    };
+                }
+            }
+        }
+    }
+    // If we got here, something went wrong
+    if (didStash) {
+        logger.warn('PULL_STASH_PRESERVED: Local changes still stashed, use "git stash pop" to restore');
+    }
+    return {
+        success: false,
+        hadConflicts: false,
+        autoResolved: [],
+        manualRequired: [],
+        stashApplied: false,
+        strategy: 'failed',
+        message: 'Pull failed - unable to merge or rebase'
+    };
+}
+/**
+ * Internal execution
+ */ const executeInternal = async (runConfig)=>{
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+    // Get pull configuration
+    const pullConfig = runConfig.pull || {};
+    const remote = pullConfig.remote || 'origin';
+    const branch = pullConfig.branch;
+    // Execute pull
+    const result = await executePull(remote, branch, logger, isDryRun);
+    // Format output
+    const lines = [];
+    lines.push('');
+    lines.push('═'.repeat(60));
+    lines.push(result.success ? '✅ PULL COMPLETE' : '⚠️  PULL NEEDS ATTENTION');
+    lines.push('═'.repeat(60));
+    lines.push('');
+    lines.push(`Strategy: ${result.strategy}`);
+    lines.push(`Message: ${result.message}`);
+    if (result.hadConflicts) {
+        lines.push('');
+        lines.push(`Conflicts detected: ${result.autoResolved.length + result.manualRequired.length}`);
+        if (result.autoResolved.length > 0) {
+            lines.push(`✓ Auto-resolved: ${result.autoResolved.length}`);
+            result.autoResolved.forEach((f)=>lines.push(`   - ${f}`));
+        }
+        if (result.manualRequired.length > 0) {
+            lines.push(`✗ Manual resolution needed: ${result.manualRequired.length}`);
+            result.manualRequired.forEach((f)=>lines.push(`   - ${f}`));
+        }
+    }
+    if (result.stashApplied) {
+        lines.push('');
+        lines.push('ℹ️  Local changes have been restored from stash');
+    }
+    lines.push('');
+    lines.push('═'.repeat(60));
+    const output = lines.join('\n');
+    logger.info(output);
+    return output;
+};
+/**
+ * Execute pull command
+ */ const execute = async (runConfig)=>{
+    try {
+        return await executeInternal(runConfig);
+    } catch (error) {
+        const logger = getLogger();
+        logger.error(`PULL_COMMAND_FAILED: Pull command failed | Error: ${error.message}`);
+        throw error;
+    }
+};
+
+export { PerformanceTimer, batchReadPackageJsonFiles, checkForFileDependencies, execute$2 as clean, collectAllDependencies, execute$4 as commit, findAllPackageJsonFiles, findPackagesByScope, isCleanNeeded, isTestNeeded, optimizePrecommitCommand, execute$3 as precommit, execute as pull, recordTestRun, execute$1 as review, scanDirectoryForPackages };
 //# sourceMappingURL=index.js.map