@grunnverk/commands-git 1.0.0

package/dist/index.js

@@ -0,0 +1,2976 @@
+import { Formatter } from '@riotprompt/riotprompt';
+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 '@grunnverk/core';
+import { ValidationError, ExternalDependencyError, CommandError, createStorage, checkForFileDependencies as checkForFileDependencies$1, logFileDependencyWarning, logFileDependencySuggestions, FileOperationError } from '@grunnverk/shared';
+import { run, validateString, safeJsonParse, validatePackageJson, unstageAll, stageFiles, verifyStagedFiles, getCurrentBranch, runSecure, getGitStatusSummary } from '@grunnverk/git-tools';
+import { getRecentClosedIssuesForCommit, handleIssueCreation, getReleaseNotesContent, getIssuesContent } from '@grunnverk/github-tools';
+import { runAgenticCommit, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createCommitPrompt, createReviewPrompt, createCompletion } from '@grunnverk/ai-service';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+
+// Helper function to read context files
+async function readContextFiles(contextFiles, logger) {
+    if (!contextFiles || contextFiles.length === 0) {
+        return '';
+    }
+    const storage = createStorage();
+    const contextParts = [];
+    for (const filePath of contextFiles){
+        try {
+            const content = await storage.readFile(filePath, 'utf8');
+            contextParts.push(`## Context from ${filePath}\n\n${content}\n`);
+            logger.debug(`Read context from file: ${filePath}`);
+        } catch (error) {
+            logger.warn(`Failed to read context file ${filePath}: ${error.message}`);
+        }
+    }
+    return contextParts.join('\n---\n\n');
+}
+// Helper function to generate self-reflection output using observability module
+async function generateSelfReflection(agenticResult, outputDirectory, storage, logger) {
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const reflectionPath = getOutputPath(outputDirectory, `agentic-reflection-commit-${timestamp}.md`);
+        // Use new observability reflection generator
+        const report = await generateReflectionReport({
+            iterations: agenticResult.iterations || 0,
+            toolCallsExecuted: agenticResult.toolCallsExecuted || 0,
+            maxIterations: agenticResult.maxIterations || 10,
+            toolMetrics: agenticResult.toolMetrics || [],
+            conversationHistory: agenticResult.conversationHistory || [],
+            commitMessage: agenticResult.commitMessage,
+            suggestedSplits: agenticResult.suggestedSplits || [],
+            logger
+        });
+        // Save the report to output directory
+        await storage.writeFile(reflectionPath, report, 'utf8');
+        logger.info('');
+        logger.info('═'.repeat(80));
+        logger.info('📊 SELF-REFLECTION REPORT GENERATED');
+        logger.info('═'.repeat(80));
+        logger.info('');
+        logger.info('📁 Location: %s', reflectionPath);
+        logger.info('');
+        logger.info('📈 Report Summary:');
+        const iterations = agenticResult.iterations || 0;
+        const toolCalls = agenticResult.toolCallsExecuted || 0;
+        const uniqueTools = new Set((agenticResult.toolMetrics || []).map((m)=>m.name)).size;
+        logger.info(`   • ${iterations} iterations completed`);
+        logger.info(`   • ${toolCalls} tool calls executed`);
+        logger.info(`   • ${uniqueTools} unique tools used`);
+        logger.info('');
+        logger.info('💡 Use this report to:');
+        logger.info('   • Understand which tools were most effective');
+        logger.info('   • Identify performance bottlenecks');
+        logger.info('   • Review the complete agentic conversation');
+        logger.info('   • Improve tool implementation based on metrics');
+        logger.info('');
+        logger.info('═'.repeat(80));
+    } catch (error) {
+        logger.warn('Failed to generate self-reflection output: %s', error.message);
+        logger.debug('Self-reflection error details:', error);
+    }
+}
+// Helper function to get current version from package.json
+async function getCurrentVersion(storage) {
+    try {
+        const packageJsonContents = await storage.readFile('package.json', 'utf-8');
+        const packageJson = safeJsonParse(packageJsonContents, 'package.json');
+        const validated = validatePackageJson(packageJson, 'package.json');
+        return validated.version;
+    } catch  {
+        // Return undefined if we can't read the version (not a critical failure)
+        return undefined;
+    }
+}
+// Helper function to edit commit message using editor
+async function editCommitMessageInteractively(commitMessage) {
+    const templateLines = [
+        '# Edit your commit message below. Lines starting with "#" will be ignored.',
+        '# Save and close the editor when you are done.'
+    ];
+    const result = await editContentInEditor(commitMessage, templateLines, '.txt');
+    return result.content;
+}
+// Helper function to improve commit message using LLM
+async function improveCommitMessageWithLLM(commitMessage, runConfig, promptConfig, promptContext, outputDirectory, diffContent) {
+    // Get user feedback on what to improve using the editor
+    const userFeedback = await getLLMFeedbackInEditor('commit message', commitMessage);
+    // Create AI config from kodrdriv config
+    const aiConfig = toAIConfig(runConfig);
+    const aiStorageAdapter = createStorageAdapter(outputDirectory);
+    const aiLogger = createLoggerAdapter(false);
+    const improvementConfig = {
+        contentType: 'commit message',
+        createImprovedPrompt: async (promptConfig, currentMessage, promptContext)=>{
+            var _aiConfig_commands_commit, _aiConfig_commands;
+            const improvementPromptContent = {
+                diffContent: diffContent,
+                userDirection: `Please improve this commit message based on the user's feedback: "${userFeedback}".
+
+Current commit message: "${currentMessage}"
+
+Please revise the commit message according to the user's feedback while maintaining accuracy and following conventional commit standards if appropriate.`
+            };
+            const prompt = await createCommitPrompt(promptConfig, improvementPromptContent, promptContext);
+            // Format the prompt into a proper request with messages
+            const modelToUse = ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_commit = _aiConfig_commands.commit) === null || _aiConfig_commands_commit === void 0 ? void 0 : _aiConfig_commands_commit.model) || aiConfig.model || 'gpt-4o-mini';
+            return Formatter.create({
+                logger: getDryRunLogger(false)
+            }).formatPrompt(modelToUse, prompt);
+        },
+        callLLM: async (request, runConfig, outputDirectory)=>{
+            var _aiConfig_commands_commit, _aiConfig_commands, _aiConfig_commands_commit1, _aiConfig_commands1;
+            return await createCompletionWithRetry(request.messages, {
+                model: ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_commit = _aiConfig_commands.commit) === null || _aiConfig_commands_commit === void 0 ? void 0 : _aiConfig_commands_commit.model) || aiConfig.model,
+                openaiReasoning: ((_aiConfig_commands1 = aiConfig.commands) === null || _aiConfig_commands1 === void 0 ? void 0 : (_aiConfig_commands_commit1 = _aiConfig_commands1.commit) === null || _aiConfig_commands_commit1 === void 0 ? void 0 : _aiConfig_commands_commit1.reasoning) || aiConfig.reasoning,
+                debug: runConfig.debug,
+                debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('commit-improve')),
+                debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('commit-improve')),
+                storage: aiStorageAdapter,
+                logger: aiLogger
+            });
+        }
+    };
+    return await improveContentWithLLM(commitMessage, runConfig, promptConfig, promptContext, outputDirectory, improvementConfig);
+}
+// Interactive feedback loop for commit message
+async function handleInteractiveCommitFeedback(commitMessage, runConfig, promptConfig, promptContext, outputDirectory, storage, diffContent, hasActualChanges, cached) {
+    var _runConfig_commit, _runConfig_commit1;
+    const logger = getDryRunLogger(false);
+    let currentMessage = commitMessage;
+    // Determine what the confirm action will do based on configuration
+    const senditEnabled = (_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.sendit;
+    const willActuallyCommit = senditEnabled && hasActualChanges && cached;
+    // Create dynamic confirm choice based on configuration
+    const isAmendMode = (_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.amend;
+    const confirmChoice = willActuallyCommit ? {
+        key: 'c',
+        label: isAmendMode ? 'Amend last commit with this message (sendit enabled)' : 'Commit changes with this message (sendit enabled)'
+    } : {
+        key: 'c',
+        label: 'Accept message (you will need to commit manually)'
+    };
+    while(true){
+        // Display the current commit message
+        logger.info('\n📝 Generated Commit Message:');
+        logger.info('─'.repeat(50));
+        logger.info(currentMessage);
+        logger.info('─'.repeat(50));
+        // Show configuration status
+        if (senditEnabled) {
+            if (willActuallyCommit) {
+                logger.info('\nSENDIT_MODE_ACTIVE: SendIt mode enabled | Action: Commit choice will execute git commit automatically | Staged Changes: Available');
+            } else {
+                logger.info('\nSENDIT_MODE_NO_CHANGES: SendIt mode configured but no staged changes | Action: Only message save available | Staged Changes: None');
+            }
+        } else {
+            logger.info('\nSENDIT_MODE_INACTIVE: SendIt mode not active | Action: Accept choice will only save message | Commit: Manual');
+        }
+        // Get user choice
+        const userChoice = await getUserChoice('\nWhat would you like to do with this commit message?', [
+            confirmChoice,
+            STANDARD_CHOICES.EDIT,
+            STANDARD_CHOICES.SKIP,
+            STANDARD_CHOICES.IMPROVE
+        ], {
+            nonTtyErrorSuggestions: [
+                'Use --sendit flag to auto-commit without review'
+            ]
+        });
+        switch(userChoice){
+            case 'c':
+                return {
+                    action: 'commit',
+                    finalMessage: currentMessage
+                };
+            case 'e':
+                try {
+                    currentMessage = await editCommitMessageInteractively(currentMessage);
+                } catch (error) {
+                    logger.error(`Failed to edit commit message: ${error.message}`);
+                // Continue the loop to show options again
+                }
+                break;
+            case 's':
+                return {
+                    action: 'skip',
+                    finalMessage: currentMessage
+                };
+            case 'i':
+                try {
+                    currentMessage = await improveCommitMessageWithLLM(currentMessage, runConfig, promptConfig, promptContext, outputDirectory, diffContent);
+                } catch (error) {
+                    logger.error(`Failed to improve commit message: ${error.message}`);
+                // Continue the loop to show options again
+                }
+                break;
+        }
+    }
+}
+// Helper function to check if there are any commits in the repository
+const hasCommits = async ()=>{
+    try {
+        await run('git rev-parse HEAD');
+        return true;
+    } catch  {
+        // No commits found or not a git repository
+        return false;
+    }
+};
+// Helper function to push the commit
+const pushCommit = async (pushConfig, logger, isDryRun)=>{
+    if (!pushConfig) {
+        return; // No push requested
+    }
+    // Determine the remote to push to
+    let remote = 'origin';
+    if (typeof pushConfig === 'string') {
+        remote = pushConfig;
+    }
+    const pushCommand = `git push ${remote}`;
+    if (isDryRun) {
+        logger.info('Would push to %s with: %s', remote, pushCommand);
+    } else {
+        logger.info('🚀 Pushing to %s...', remote);
+        try {
+            await run(pushCommand);
+            logger.info('✅ Push successful!');
+        } catch (error) {
+            logger.error('Failed to push to %s: %s', remote, error.message);
+            throw new ExternalDependencyError(`Failed to push to ${remote}`, 'git', error);
+        }
+    }
+};
+// Simplified cached determination with single check
+const determineCachedState = async (config)=>{
+    var _config_commit, _config_commit1, _config_commit2;
+    // If amend is used, we use staged changes (since we're amending the last commit)
+    if ((_config_commit = config.commit) === null || _config_commit === void 0 ? void 0 : _config_commit.amend) {
+        // For amend mode, check that there's a previous commit to amend
+        const hasAnyCommits = await hasCommits();
+        if (!hasAnyCommits) {
+            throw new ValidationError('Cannot use --amend: no commits found in repository. Create an initial commit first.');
+        }
+        return true;
+    }
+    // If add is used, we always look at staged changes after add
+    if ((_config_commit1 = config.commit) === null || _config_commit1 === void 0 ? void 0 : _config_commit1.add) {
+        return true;
+    }
+    // If explicitly set, use that value
+    if (((_config_commit2 = config.commit) === null || _config_commit2 === void 0 ? void 0 : _config_commit2.cached) !== undefined) {
+        return config.commit.cached;
+    }
+    // Otherwise, check if there are staged changes
+    return await Diff.hasStagedChanges();
+};
+// Single validation of sendit + cached state
+const validateSenditState = (config, cached, isDryRun, logger)=>{
+    var _config_commit;
+    if (((_config_commit = config.commit) === null || _config_commit === void 0 ? void 0 : _config_commit.sendit) && !cached && !isDryRun) {
+        const message = 'SendIt mode enabled, but no changes to commit.';
+        logger.warn(message);
+        return false; // Return false to indicate no changes to commit
+    }
+    return true; // Return true to indicate we can proceed
+};
+// Better file save handling with fallbacks
+const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
+    const timestampedFilename = getTimestampedCommitFilename();
+    const primaryPath = getOutputPath(outputDirectory, timestampedFilename);
+    try {
+        await storage.writeFile(primaryPath, summary, 'utf-8');
+        logger.debug('Saved timestamped commit message: %s', primaryPath);
+        return; // Success, no fallback needed
+    } catch (error) {
+        logger.warn('Failed to save commit message to primary location (%s): %s', primaryPath, error.message);
+        logger.debug('Primary save error details:', error);
+        // First fallback: try output directory root (in case subdirectory has issues)
+        try {
+            const outputRootPath = getOutputPath('output', timestampedFilename);
+            await storage.writeFile(outputRootPath, summary, 'utf-8');
+            logger.info('COMMIT_MESSAGE_SAVED_FALLBACK: Saved commit message to fallback location | Path: %s | Purpose: Preserve message for later use', outputRootPath);
+            return;
+        } catch (outputError) {
+            logger.warn('Failed to save to output directory fallback: %s', outputError.message);
+        }
+        // Last resort fallback: save to current directory (this creates the clutter!)
+        try {
+            const fallbackPath = `commit-message-${Date.now()}.txt`;
+            await storage.writeFile(fallbackPath, summary, 'utf-8');
+            logger.warn('⚠️  Saved commit message to current directory as last resort: %s', fallbackPath);
+            logger.warn('⚠️  This file should be moved to the output directory and may clutter your workspace');
+        } catch (fallbackError) {
+            logger.error('Failed to save commit message anywhere: %s', fallbackError.message);
+            logger.error('Commit message will only be available in console output');
+        // Continue execution - commit message is still returned
+        }
+    }
+};
+/**
+ * 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) {
+    logger.info('');
+    logger.info('═'.repeat(80));
+    logger.info(`📋 Commit ${index + 1} of ${total}`);
+    logger.info('═'.repeat(80));
+    logger.info('');
+    logger.info('Files (%d):', split.files.length);
+    split.files.forEach((f)=>logger.info(`  - ${f}`));
+    logger.info('');
+    logger.info('Rationale:');
+    logger.info(`  ${split.rationale}`);
+    logger.info('');
+    logger.info('Proposed Message:');
+    logger.info('─'.repeat(50));
+    logger.info(split.message);
+    logger.info('─'.repeat(50));
+    logger.info('');
+    const choices = [
+        {
+            key: 'c',
+            label: 'Commit with this message'
+        },
+        {
+            key: 'e',
+            label: 'Edit message before committing'
+        },
+        {
+            key: 's',
+            label: 'Skip this commit'
+        },
+        {
+            key: 't',
+            label: 'Stop - no more commits'
+        }
+    ];
+    const choice = await getUserChoice('What would you like to do?', choices, {
+        nonTtyErrorSuggestions: [
+            'Use --sendit to auto-commit without review'
+        ]
+    });
+    if (choice === 'e') {
+        // Edit the message
+        const edited = await editCommitMessageInteractively(split.message);
+        return {
+            action: 'commit',
+            modifiedMessage: edited
+        };
+    } else if (choice === 'c') {
+        return {
+            action: 'commit'
+        };
+    } else if (choice === 's') {
+        return {
+            action: 'skip'
+        };
+    } else {
+        return {
+            action: 'stop'
+        };
+    }
+}
+/**
+ * Create a single commit from a split
+ */ async function createSingleSplitCommit(split, commitMessage, isDryRun, logger) {
+    // Stage the files for this split
+    if (isDryRun) {
+        logger.debug(`[DRY RUN] Would stage: ${split.files.join(', ')}`);
+    } else {
+        await stageFiles(split.files);
+        // Verify files were staged correctly
+        const verification = await verifyStagedFiles(split.files);
+        if (!verification.allPresent) {
+            throw new ValidationError(`Stage verification failed. Missing: ${verification.missing.join(', ')}. ` + `Unexpected: ${verification.unexpected.join(', ')}`);
+        }
+    }
+    // Create the commit
+    if (isDryRun) {
+        logger.debug(`[DRY RUN] Would commit with message: ${commitMessage}`);
+        return undefined;
+    } else {
+        const validatedMessage = validateString(commitMessage, 'commit message');
+        const escapedMessage = shellescape([
+            validatedMessage
+        ]);
+        await run(`git commit -m ${escapedMessage}`);
+        // Get the SHA of the commit we just created
+        const result = await run('git rev-parse HEAD');
+        const sha = (typeof result === 'string' ? result : result.stdout).trim();
+        logger.debug(`Created commit: ${sha}`);
+        return sha;
+    }
+}
+/**
+ * Execute a series of split commits
+ */ async function executeSplitCommits(options) {
+    const { splits, isDryRun, interactive, logger } = options;
+    const result = {
+        success: false,
+        commitsCreated: 0,
+        commits: [],
+        skipped: 0
+    };
+    try {
+        logger.debug('Preparing to create split commits...');
+        logger.info('');
+        logger.info('═'.repeat(80));
+        logger.info(`🔀 Creating ${splits.length} commits from staged changes`);
+        logger.info('═'.repeat(80));
+        // Process each split
+        for(let i = 0; i < splits.length; i++){
+            const split = splits[i];
+            logger.info('');
+            logger.info(`Processing commit ${i + 1} of ${splits.length}...`);
+            // Interactive review if enabled
+            let commitMessage = split.message;
+            if (interactive && !isDryRun) {
+                const review = await reviewSplitInteractively(split, i, splits.length, logger);
+                if (review.action === 'stop') {
+                    logger.info('User stopped split commit process');
+                    logger.info(`Created ${result.commitsCreated} commits before stopping`);
+                    result.success = false;
+                    return result;
+                } else if (review.action === 'skip') {
+                    logger.info(`Skipped commit ${i + 1}`);
+                    result.skipped++;
+                    continue;
+                } else if (review.action === 'edit') {
+                    commitMessage = review.modifiedMessage;
+                }
+            }
+            try {
+                // Unstage everything first
+                if (!isDryRun) {
+                    await unstageAll();
+                }
+                // Create this split's commit
+                const sha = await createSingleSplitCommit(split, commitMessage, isDryRun, logger);
+                result.commits.push({
+                    message: commitMessage,
+                    files: split.files,
+                    sha
+                });
+                result.commitsCreated++;
+                if (isDryRun) {
+                    logger.info(`[DRY RUN] Would create commit ${i + 1}: ${commitMessage.split('\n')[0]}`);
+                } else {
+                    logger.info(`✅ Created commit ${i + 1}: ${sha === null || sha === void 0 ? void 0 : sha.substring(0, 7)} - ${commitMessage.split('\n')[0]}`);
+                }
+            } catch (error) {
+                logger.error(`Failed to create commit ${i + 1}: ${error.message}`);
+                logger.info(`Successfully created ${result.commitsCreated} commits before error`);
+                // Re-stage remaining files for user
+                if (!isDryRun) {
+                    const remainingFiles = splits.slice(i).flatMap((s)=>s.files);
+                    try {
+                        await stageFiles(remainingFiles);
+                        logger.info(`Remaining ${remainingFiles.length} files are staged for manual commit`);
+                    } catch (restageError) {
+                        logger.error(`Failed to re-stage remaining files: ${restageError.message}`);
+                    }
+                }
+                result.success = false;
+                result.error = error;
+                return result;
+            }
+        }
+        result.success = true;
+        return result;
+    } catch (error) {
+        logger.error(`Split commit process failed: ${error.message}`);
+        result.success = false;
+        result.error = error;
+        return result;
+    }
+}
+/**
+ * Format a summary message for split commits
+ */ function formatSplitCommitSummary(result) {
+    const lines = [];
+    lines.push('');
+    lines.push('═'.repeat(80));
+    lines.push('✅ COMMIT SPLITTING COMPLETE');
+    lines.push('═'.repeat(80));
+    lines.push('');
+    lines.push(`Total commits created: ${result.commitsCreated}`);
+    if (result.skipped > 0) {
+        lines.push(`Commits skipped: ${result.skipped}`);
+    }
+    lines.push('');
+    if (result.commits.length > 0) {
+        lines.push('Commits:');
+        lines.push('');
+        result.commits.forEach((commit, idx)=>{
+            const sha = commit.sha ? `${commit.sha.substring(0, 7)} ` : '';
+            const firstLine = commit.message.split('\n')[0];
+            lines.push(`  ${idx + 1}. ${sha}${firstLine}`);
+            lines.push(`     Files: ${commit.files.length}`);
+        });
+    }
+    lines.push('');
+    lines.push('═'.repeat(80));
+    return lines.join('\n');
+}
+const executeInternal$3 = async (runConfig)=>{
+    var _ref, _ref1, _runConfig_excludedPatterns;
+    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7, _aiConfig_commands_commit, _aiConfig_commands, _aiConfig_commands_commit1, _aiConfig_commands1, _aiConfig_commands_commit2, _aiConfig_commands2, _runConfig_commit8, _aiConfig_commands_commit3, _aiConfig_commands3, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14, _runConfig_commit15;
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+    logger.info('COMMIT_START: Starting commit message generation | Mode: %s', isDryRun ? 'dry-run' : 'live');
+    // Track if user explicitly chose to skip in interactive mode
+    let userSkippedCommit = false;
+    if ((_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.add) {
+        if (isDryRun) {
+            logger.info('GIT_ADD_DRY_RUN: Would stage all changes | Mode: dry-run | Command: git add -A');
+        } else {
+            logger.info('GIT_ADD_STAGING: Adding all changes to index | Command: git add -A | Scope: all files | Purpose: Stage for commit');
+            await run('git add -A');
+            logger.info('GIT_ADD_SUCCESS: Successfully staged all changes | Command: git add -A | Status: completed');
+        }
+    }
+    // Determine cached state with single, clear logic
+    logger.info('COMMIT_CHECK_STAGED: Checking for staged changes | Action: Analyzing git status');
+    const cached = await determineCachedState(runConfig);
+    logger.info('COMMIT_STAGED_STATUS: Staged changes detected: %s | Cached: %s', cached ? 'yes' : 'no', cached);
+    // Validate sendit state early - now returns boolean instead of throwing
+    validateSenditState(runConfig, cached, isDryRun, logger);
+    logger.info('COMMIT_GENERATE_DIFF: Generating diff content | Max bytes: %d', (_ref = (_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.maxDiffBytes) !== null && _ref !== void 0 ? _ref : DEFAULT_MAX_DIFF_BYTES);
+    let diffContent = '';
+    const maxDiffBytes = (_ref1 = (_runConfig_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.maxDiffBytes) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_MAX_DIFF_BYTES;
+    const options = {
+        cached,
+        excludedPatterns: (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS,
+        maxDiffBytes
+    };
+    const diff = await Diff.create(options);
+    diffContent = await diff.get();
+    logger.info('COMMIT_DIFF_GENERATED: Diff content generated | Size: %d bytes | Has changes: %s', diffContent.length, diffContent.trim().length > 0 ? 'yes' : 'no');
+    // Check if there are actually any changes in the diff
+    let hasActualChanges = diffContent.trim().length > 0;
+    // If no changes found with current patterns, check for critical excluded files
+    if (!hasActualChanges) {
+        const criticalChanges = await Diff.hasCriticalExcludedChanges();
+        if (criticalChanges.hasChanges) {
+            var _runConfig_commit16;
+            logger.info('CRITICAL_FILES_DETECTED: No changes with exclusion patterns, but critical files modified | Files: %s | Action: May need to include critical files', criticalChanges.files.join(', '));
+            if (((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.sendit) && !isDryRun) {
+                var _runConfig_excludedPatterns1;
+                // In sendit mode, automatically include critical files
+                logger.info('SENDIT_INCLUDING_CRITICAL: SendIt mode including critical files in diff | Purpose: Ensure all important changes are captured');
+                const minimalPatterns = Diff.getMinimalExcludedPatterns((_runConfig_excludedPatterns1 = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns1 !== void 0 ? _runConfig_excludedPatterns1 : DEFAULT_EXCLUDED_PATTERNS);
+                const updatedOptions = {
+                    ...options,
+                    excludedPatterns: minimalPatterns
+                };
+                const updatedDiff = await Diff.create(updatedOptions);
+                diffContent = await updatedDiff.get();
+                if (diffContent.trim().length > 0) {
+                    logger.info('CRITICAL_FILES_INCLUDED: Successfully added critical files to diff | Status: ready for commit message generation');
+                    // Update hasActualChanges since we now have content after including critical files
+                    hasActualChanges = true;
+                } else {
+                    logger.warn('No changes detected even after including critical files.');
+                    return 'No changes to commit.';
+                }
+            } else {
+                var _runConfig_excludedPatterns2;
+                // In non-sendit mode, suggest including the files
+                logger.warn('Consider including these files by using:');
+                logger.warn('  kodrdriv commit --excluded-paths %s', ((_runConfig_excludedPatterns2 = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns2 !== void 0 ? _runConfig_excludedPatterns2 : DEFAULT_EXCLUDED_PATTERNS).filter((p)=>!criticalChanges.files.some((f)=>p.includes(f.split('/').pop() || ''))).map((p)=>`"${p}"`).join(' '));
+                logger.warn('Or run with --sendit to automatically include critical files.');
+                if (!isDryRun) {
+                    return 'No changes to commit. Use suggestions above to include critical files.';
+                } else {
+                    logger.info('Generating commit message template for future use...');
+                }
+            }
+        } else {
+            var _runConfig_commit17;
+            // No changes at all - try fallback to file content for new repositories
+            logger.info('NO_CHANGES_DETECTED: No changes found in working directory | Status: clean | Action: Nothing to commit');
+            if (((_runConfig_commit17 = runConfig.commit) === null || _runConfig_commit17 === void 0 ? void 0 : _runConfig_commit17.sendit) && !isDryRun) {
+                logger.warn('No changes detected to commit. Skipping commit operation.');
+                return 'No changes to commit.';
+            } else {
+                var _runConfig_excludedPatterns3;
+                logger.info('NO_DIFF_FALLBACK: No diff content available | Action: Attempting to generate commit message from file content | Strategy: fallback');
+                // Create file content collector as fallback
+                const fileOptions = {
+                    excludedPatterns: (_runConfig_excludedPatterns3 = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns3 !== void 0 ? _runConfig_excludedPatterns3 : DEFAULT_EXCLUDED_PATTERNS,
+                    maxTotalBytes: maxDiffBytes * 5,
+                    workingDirectory: process.cwd()
+                };
+                const files = await Files.create(fileOptions);
+                const fileContent = await files.get();
+                if (fileContent && fileContent.trim().length > 0) {
+                    logger.info('FILE_CONTENT_USING: Using file content for commit message generation | Content Length: %d characters | Source: file content', fileContent.length);
+                    diffContent = fileContent;
+                    hasActualChanges = true; // We have content to work with
+                } else {
+                    var _runConfig_commit18;
+                    if ((_runConfig_commit18 = runConfig.commit) === null || _runConfig_commit18 === void 0 ? void 0 : _runConfig_commit18.sendit) {
+                        logger.info('COMMIT_SKIPPED: Skipping commit operation | Reason: No changes detected | Action: None');
+                        return 'No changes to commit.';
+                    } else {
+                        logger.info('COMMIT_TEMPLATE_GENERATING: Creating commit message template for future use | Reason: No changes | Purpose: Provide template');
+                    }
+                }
+            }
+        }
+    }
+    const logOptions = {
+        limit: (_runConfig_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.messageLimit
+    };
+    const log = await Log.create(logOptions);
+    const logContext = await log.get();
+    // Always ensure output directory exists for request/response files and GitHub issues lookup
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = createStorage();
+    await storage.ensureDirectory(outputDirectory);
+    // Get GitHub issues context for large commits [[memory:5887795]]
+    let githubIssuesContext = '';
+    try {
+        const currentVersion = await getCurrentVersion(storage);
+        if (currentVersion) {
+            logger.debug(`Found current version: ${currentVersion}, fetching related GitHub issues...`);
+            githubIssuesContext = await getRecentClosedIssuesForCommit(currentVersion, 10);
+            if (githubIssuesContext) {
+                logger.debug(`Fetched GitHub issues context (${githubIssuesContext.length} characters)`);
+            } else {
+                logger.debug('No relevant GitHub issues found for commit context');
+            }
+        } else {
+            logger.debug('Could not determine current version, fetching recent issues without milestone filtering...');
+            githubIssuesContext = await getRecentClosedIssuesForCommit(undefined, 10);
+            if (githubIssuesContext) {
+                logger.debug(`Fetched general GitHub issues context (${githubIssuesContext.length} characters)`);
+            }
+        }
+    } catch (error) {
+        logger.debug(`Failed to fetch GitHub issues for commit context: ${error.message}`);
+    // Continue without GitHub context - this shouldn't block commit generation
+    }
+    const promptConfig = {
+        overridePaths: runConfig.discoveredConfigDirs || [],
+        overrides: runConfig.overrides || false
+    };
+    const userDirection = sanitizeDirection((_runConfig_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.direction);
+    if (userDirection) {
+        logger.debug('Using user direction: %s', userDirection);
+    }
+    // Create adapters for ai-service
+    const aiConfig = toAIConfig(runConfig);
+    const aiStorageAdapter = createStorageAdapter(outputDirectory);
+    const aiLogger = createLoggerAdapter(isDryRun);
+    // Read context from files if provided
+    const contextFromFiles = await readContextFiles((_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.contextFiles, logger);
+    // Combine file context with existing context
+    const combinedContext = [
+        (_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.context,
+        contextFromFiles
+    ].filter(Boolean).join('\n\n---\n\n');
+    // Define promptContext for use in interactive improvements
+    const promptContext = {
+        logContext,
+        context: combinedContext || undefined,
+        directories: runConfig.contextDirectories
+    };
+    // Announce self-reflection if enabled
+    if ((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.selfReflection) {
+        logger.info('📊 Self-reflection enabled - detailed analysis will be generated');
+    }
+    // Get list of changed files
+    const changedFilesResult = await run(`git diff --name-only ${cached ? '--cached' : ''}`);
+    const changedFilesOutput = typeof changedFilesResult === 'string' ? changedFilesResult : changedFilesResult.stdout;
+    const changedFiles = changedFilesOutput.split('\n').filter((f)=>f.trim().length > 0);
+    logger.debug('Changed files for analysis: %d files', changedFiles.length);
+    // Run agentic commit generation
+    logger.info('COMMIT_AI_GENERATION: Starting AI-powered commit message generation | Model: %s | Reasoning: %s | Files: %d', ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_commit = _aiConfig_commands.commit) === null || _aiConfig_commands_commit === void 0 ? void 0 : _aiConfig_commands_commit.model) || aiConfig.model || 'gpt-4o-mini', ((_aiConfig_commands1 = aiConfig.commands) === null || _aiConfig_commands1 === void 0 ? void 0 : (_aiConfig_commands_commit1 = _aiConfig_commands1.commit) === null || _aiConfig_commands_commit1 === void 0 ? void 0 : _aiConfig_commands_commit1.reasoning) || aiConfig.reasoning || 'low', changedFiles.length);
+    const agenticResult = await runAgenticCommit({
+        changedFiles,
+        diffContent,
+        userDirection,
+        logContext,
+        model: ((_aiConfig_commands2 = aiConfig.commands) === null || _aiConfig_commands2 === void 0 ? void 0 : (_aiConfig_commands_commit2 = _aiConfig_commands2.commit) === null || _aiConfig_commands_commit2 === void 0 ? void 0 : _aiConfig_commands_commit2.model) || aiConfig.model,
+        maxIterations: ((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.maxAgenticIterations) || 10,
+        debug: runConfig.debug,
+        debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('commit')),
+        debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('commit')),
+        storage: aiStorageAdapter,
+        logger: aiLogger,
+        openaiReasoning: ((_aiConfig_commands3 = aiConfig.commands) === null || _aiConfig_commands3 === void 0 ? void 0 : (_aiConfig_commands_commit3 = _aiConfig_commands3.commit) === null || _aiConfig_commands_commit3 === void 0 ? void 0 : _aiConfig_commands_commit3.reasoning) || aiConfig.reasoning
+    });
+    const iterations = agenticResult.iterations || 0;
+    const toolCalls = agenticResult.toolCallsExecuted || 0;
+    logger.info(`🔍 Analysis complete: ${iterations} iterations, ${toolCalls} tool calls`);
+    // Generate self-reflection output if enabled
+    if ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.selfReflection) {
+        await generateSelfReflection(agenticResult, outputDirectory, storage, logger);
+    }
+    // Check for suggested splits
+    if (agenticResult.suggestedSplits.length > 1 && ((_runConfig_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.allowCommitSplitting)) {
+        var _runConfig_commit19;
+        logger.info('\n📋 AI suggests splitting this into %d commits:', agenticResult.suggestedSplits.length);
+        for(let i = 0; i < agenticResult.suggestedSplits.length; i++){
+            const split = agenticResult.suggestedSplits[i];
+            logger.info('\nCommit %d (%d files):', i + 1, split.files.length);
+            logger.info('  Files: %s', split.files.join(', '));
+            logger.info('  Rationale: %s', split.rationale);
+            logger.info('  Message: %s', split.message);
+        }
+        // NEW: Check if auto-split is enabled (defaults to true if not specified)
+        const autoSplitEnabled = ((_runConfig_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.autoSplit) !== false; // Default to true
+        if (autoSplitEnabled) {
+            var _runConfig_commit20, _runConfig_commit21;
+            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: deduplicatedSplits,
+                isDryRun,
+                interactive: !!(((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.interactive) && !((_runConfig_commit21 = runConfig.commit) === null || _runConfig_commit21 === void 0 ? void 0 : _runConfig_commit21.sendit)),
+                logger});
+            if (splitResult.success) {
+                var _runConfig_commit22;
+                // Push if requested (all commits)
+                if (((_runConfig_commit22 = runConfig.commit) === null || _runConfig_commit22 === void 0 ? void 0 : _runConfig_commit22.push) && !isDryRun) {
+                    await pushCommit(runConfig.commit.push, logger, isDryRun);
+                }
+                return formatSplitCommitSummary(splitResult);
+            } else {
+                var _splitResult_error;
+                const errorMessage = ((_splitResult_error = splitResult.error) === null || _splitResult_error === void 0 ? void 0 : _splitResult_error.message) || 'Unknown error';
+                throw new CommandError(`Failed to create split commits: ${errorMessage}`, 'SPLIT_COMMIT_FAILED', false, splitResult.error);
+            }
+        } else {
+            logger.info('\n⚠️  Commit splitting is not automated. Please stage and commit files separately.');
+            logger.info('Using combined message for now...\n');
+            logger.info('💡 To enable automatic splitting, add autoSplit: true to your commit configuration');
+        }
+    } else if (agenticResult.suggestedSplits.length > 1) {
+        logger.debug('AI suggested %d splits but commit splitting is not enabled', agenticResult.suggestedSplits.length);
+    }
+    const rawSummary = agenticResult.commitMessage;
+    // Apply stop-context filtering to commit message
+    const filterResult = filterContent(rawSummary, runConfig.stopContext);
+    const summary = filterResult.filtered;
+    // Save timestamped copy of commit message with better error handling
+    await saveCommitMessage(outputDirectory, summary, storage, logger);
+    // 🛡️ Universal Safety Check: Run before ANY commit operation
+    // This protects both direct commits (--sendit) and automated commits (publish, etc.)
+    const willCreateCommit = ((_runConfig_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.sendit) && hasActualChanges && cached;
+    if (willCreateCommit && !((_runConfig_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.skipFileCheck) && !isDryRun) {
+        logger.debug('Checking for file: dependencies before commit operation...');
+        try {
+            const fileDependencyIssues = await checkForFileDependencies$1(storage, process.cwd());
+            if (fileDependencyIssues.length > 0) {
+                var _runConfig_commit23;
+                logger.error('🚫 COMMIT BLOCKED: Found file: dependencies that should not be committed!');
+                logger.error('');
+                logFileDependencyWarning(fileDependencyIssues, 'commit');
+                logFileDependencySuggestions(true);
+                logger.error('Generated commit message was:');
+                logger.error('%s', summary);
+                logger.error('');
+                if ((_runConfig_commit23 = runConfig.commit) === null || _runConfig_commit23 === void 0 ? void 0 : _runConfig_commit23.sendit) {
+                    logger.error('To bypass this check, use: kodrdriv commit --skip-file-check --sendit');
+                } else {
+                    logger.error('To bypass this check, add skipFileCheck: true to your commit configuration');
+                }
+                throw new ValidationError('Found file: dependencies that should not be committed. Use --skip-file-check to bypass.');
+            }
+            logger.debug('✅ No file: dependencies found, proceeding with commit');
+        } catch (error) {
+            logger.warn('Warning: Could not check for file: dependencies: %s', error.message);
+            logger.warn('Proceeding with commit...');
+        }
+    } else if (((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.skipFileCheck) && willCreateCommit) {
+        logger.warn('⚠️  Skipping file: dependency check as requested');
+    }
+    // Handle interactive mode
+    if (((_runConfig_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.interactive) && !isDryRun) {
+        var _runConfig_commit24;
+        requireTTY('Interactive mode requires a terminal. Use --sendit or --dry-run instead.');
+        const interactiveResult = await handleInteractiveCommitFeedback(summary, runConfig, promptConfig, promptContext, outputDirectory, storage, diffContent, hasActualChanges, cached);
+        if (interactiveResult.action === 'skip') {
+            logger.info('COMMIT_ABORTED: User aborted commit operation | Reason: User choice | Action: No commit performed');
+            logger.info('COMMIT_NO_ACTION: No commit will be performed | Status: aborted | Next: User can retry or modify changes');
+            userSkippedCommit = true;
+            return interactiveResult.finalMessage;
+        }
+        // User chose to commit - check if sendit is enabled to determine what action to take
+        const senditEnabled = (_runConfig_commit24 = runConfig.commit) === null || _runConfig_commit24 === void 0 ? void 0 : _runConfig_commit24.sendit;
+        const willActuallyCommit = senditEnabled && hasActualChanges && cached;
+        if (willActuallyCommit) {
+            var _runConfig_commit25;
+            const commitAction = ((_runConfig_commit25 = runConfig.commit) === null || _runConfig_commit25 === void 0 ? void 0 : _runConfig_commit25.amend) ? 'amending last commit' : 'committing';
+            logger.info('SENDIT_EXECUTING: SendIt enabled, executing commit action | Action: %s | Message Length: %d | Final Message: \n\n%s\n\n', commitAction.charAt(0).toUpperCase() + commitAction.slice(1), interactiveResult.finalMessage.length, interactiveResult.finalMessage);
+            try {
+                var _runConfig_commit26, _runConfig_commit27;
+                const validatedSummary = validateString(interactiveResult.finalMessage, 'commit summary');
+                const escapedSummary = shellescape([
+                    validatedSummary
+                ]);
+                const commitCommand = ((_runConfig_commit26 = runConfig.commit) === null || _runConfig_commit26 === void 0 ? void 0 : _runConfig_commit26.amend) ? `git commit --amend -m ${escapedSummary}` : `git commit -m ${escapedSummary}`;
+                await run(commitCommand);
+                logger.info('COMMIT_SUCCESS: Commit operation completed successfully | Status: committed | Action: Changes saved to repository');
+                // Push if requested
+                await pushCommit((_runConfig_commit27 = runConfig.commit) === null || _runConfig_commit27 === void 0 ? void 0 : _runConfig_commit27.push, logger, isDryRun);
+            } catch (error) {
+                logger.error('Failed to commit:', error);
+                throw new ExternalDependencyError('Failed to create commit', 'git', error);
+            }
+        } else if (senditEnabled && (!hasActualChanges || !cached)) {
+            logger.info('📝 SendIt enabled but no staged changes available. Final message saved: \n\n%s\n\n', interactiveResult.finalMessage);
+            if (!hasActualChanges) {
+                logger.info('💡 No changes detected to commit');
+            } else if (!cached) {
+                logger.info('💡 No staged changes found. Use "git add" to stage changes or configure add: true in commit settings');
+            }
+        } else {
+            logger.info('📝 Message accepted (SendIt not enabled). Use this commit message manually: \n\n%s\n\n', interactiveResult.finalMessage);
+            logger.info('💡 To automatically commit, add sendit: true to your commit configuration');
+        }
+        return interactiveResult.finalMessage;
+    }
+    // Safety check: Never commit if user explicitly skipped in interactive mode
+    if (userSkippedCommit) {
+        logger.debug('Skipping sendit logic because user chose to skip in interactive mode');
+        return summary;
+    }
+    if ((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.sendit) {
+        if (isDryRun) {
+            var _runConfig_commit28, _runConfig_commit29;
+            logger.info('Would commit with message: \n\n%s\n\n', summary);
+            const commitAction = ((_runConfig_commit28 = runConfig.commit) === null || _runConfig_commit28 === void 0 ? void 0 : _runConfig_commit28.amend) ? 'git commit --amend -m <generated-message>' : 'git commit -m <generated-message>';
+            logger.info('Would execute: %s', commitAction);
+            // Show push command in dry run if requested
+            if ((_runConfig_commit29 = runConfig.commit) === null || _runConfig_commit29 === void 0 ? void 0 : _runConfig_commit29.push) {
+                const remote = typeof runConfig.commit.push === 'string' ? runConfig.commit.push : 'origin';
+                logger.info('Would push to %s with: git push %s', remote, remote);
+            }
+        } else if (hasActualChanges && cached) {
+            var _runConfig_commit30;
+            const commitAction = ((_runConfig_commit30 = runConfig.commit) === null || _runConfig_commit30 === void 0 ? void 0 : _runConfig_commit30.amend) ? 'amending commit' : 'committing';
+            logger.info('SendIt mode enabled. %s with message: \n\n%s\n\n', commitAction.charAt(0).toUpperCase() + commitAction.slice(1), summary);
+            try {
+                var _runConfig_commit31, _runConfig_commit32;
+                const validatedSummary = validateString(summary, 'commit summary');
+                const escapedSummary = shellescape([
+                    validatedSummary
+                ]);
+                const commitCommand = ((_runConfig_commit31 = runConfig.commit) === null || _runConfig_commit31 === void 0 ? void 0 : _runConfig_commit31.amend) ? `git commit --amend -m ${escapedSummary}` : `git commit -m ${escapedSummary}`;
+                await run(commitCommand);
+                logger.info('Commit successful!');
+                // Push if requested
+                await pushCommit((_runConfig_commit32 = runConfig.commit) === null || _runConfig_commit32 === void 0 ? void 0 : _runConfig_commit32.push, logger, isDryRun);
+            } catch (error) {
+                logger.error('Failed to commit:', error);
+                throw new ExternalDependencyError('Failed to create commit', 'git', error);
+            }
+        } else {
+            logger.info('SendIt mode enabled, but no changes to commit. Generated message: \n\n%s\n\n', summary);
+        }
+    } else if (isDryRun) {
+        logger.info('Generated commit message: \n\n%s\n\n', summary);
+    } else {
+        // Default behavior when neither --interactive nor --sendit is specified
+        logger.info('Generated commit message: \n\n%s\n\n', summary);
+    }
+    return summary;
+};
+const execute$4 = async (runConfig)=>{
+    try {
+        return await executeInternal$3(runConfig);
+    } catch (error) {
+        // Import getLogger for error handling
+        const { getLogger } = await import('@grunnverk/core');
+        const standardLogger = getLogger();
+        if (error instanceof ValidationError || error instanceof ExternalDependencyError || error instanceof CommandError) {
+            standardLogger.error(`commit failed: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                standardLogger.debug(`Caused by: ${error.cause.message}`);
+            } else if (error.cause) {
+                standardLogger.debug(`Caused by: ${error.cause}`);
+            }
+            throw error;
+        }
+        // Unexpected errors
+        standardLogger.error(`commit encountered unexpected error: ${error.message}`);
+        throw error;
+    }
+};
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+// Performance timing helper
+class PerformanceTimer {
+    static start(logger, operation) {
+        logger.verbose(`⏱️  Starting: ${operation}`);
+        return new PerformanceTimer(logger);
+    }
+    end(operation) {
+        const duration = Date.now() - this.startTime;
+        this.logger.verbose(`⏱️  Completed: ${operation} (${duration}ms)`);
+        return duration;
+    }
+    constructor(logger){
+        _define_property(this, "startTime", void 0);
+        _define_property(this, "logger", void 0);
+        this.logger = logger;
+        this.startTime = Date.now();
+    }
+}
+const EXCLUDED_DIRECTORIES = [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.git',
+    '.next',
+    '.nuxt',
+    'out',
+    'public',
+    'static',
+    'assets'
+];
+// Batch read multiple package.json files in parallel
+const batchReadPackageJsonFiles = async (packageJsonPaths, storage, rootDir)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, `Batch reading ${packageJsonPaths.length} package.json files`);
+    const readPromises = packageJsonPaths.map(async (packageJsonPath)=>{
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+            const packageJson = validatePackageJson(parsed, packageJsonPath, false);
+            const relativePath = path.relative(rootDir, path.dirname(packageJsonPath));
+            return {
+                path: packageJsonPath,
+                packageJson,
+                relativePath: relativePath || '.'
+            };
+        } catch (error) {
+            logger.debug(`Skipped invalid package.json at ${packageJsonPath}: ${error.message}`);
+            return null;
+        }
+    });
+    const results = await Promise.all(readPromises);
+    const validResults = results.filter((result)=>result !== null);
+    timer.end(`Successfully read ${validResults.length}/${packageJsonPaths.length} package.json files`);
+    return validResults;
+};
+// Optimized recursive package.json finder with parallel processing
+const findAllPackageJsonFiles = async (rootDir, storage)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, 'Optimized scanning for package.json files');
+    const scanForPaths = async (currentDir, depth = 0)=>{
+        // Prevent infinite recursion and overly deep scanning
+        if (depth > 5) {
+            return [];
+        }
+        try {
+            if (!await storage.exists(currentDir) || !await storage.isDirectory(currentDir)) {
+                return [];
+            }
+            const items = await storage.listFiles(currentDir);
+            const foundPaths = [];
+            // Check for package.json in current directory
+            if (items.includes('package.json')) {
+                const packageJsonPath = path.join(currentDir, 'package.json');
+                foundPaths.push(packageJsonPath);
+            }
+            // Process subdirectories in parallel
+            const subdirPromises = [];
+            for (const item of items){
+                if (EXCLUDED_DIRECTORIES.includes(item)) {
+                    continue;
+                }
+                const itemPath = path.join(currentDir, item);
+                subdirPromises.push((async ()=>{
+                    try {
+                        if (await storage.isDirectory(itemPath)) {
+                            return await scanForPaths(itemPath, depth + 1);
+                        }
+                    } catch (error) {
+                        logger.debug(`Skipped directory ${itemPath}: ${error.message}`);
+                    }
+                    return [];
+                })());
+            }
+            if (subdirPromises.length > 0) {
+                const subdirResults = await Promise.all(subdirPromises);
+                for (const subdirPaths of subdirResults){
+                    foundPaths.push(...subdirPaths);
+                }
+            }
+            return foundPaths;
+        } catch (error) {
+            logger.debug(`Failed to scan directory ${currentDir}: ${error.message}`);
+            return [];
+        }
+    };
+    const pathsTimer = PerformanceTimer.start(logger, 'Finding all package.json paths');
+    const allPaths = await scanForPaths(rootDir);
+    pathsTimer.end(`Found ${allPaths.length} package.json file paths`);
+    // Phase 2: Batch read all package.json files in parallel
+    const packageJsonFiles = await batchReadPackageJsonFiles(allPaths, storage, rootDir);
+    timer.end(`Found ${packageJsonFiles.length} valid package.json files`);
+    return packageJsonFiles;
+};
+// Optimized package scanning with parallel processing
+const scanDirectoryForPackages = async (rootDir, storage)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, `Optimized package scanning: ${rootDir}`);
+    const packageMap = new Map(); // packageName -> relativePath
+    const absoluteRootDir = path.resolve(process.cwd(), rootDir);
+    logger.verbose(`Scanning directory for packages: ${absoluteRootDir}`);
+    try {
+        // Quick existence and directory check
+        const existsTimer = PerformanceTimer.start(logger, `Checking directory: ${absoluteRootDir}`);
+        if (!await storage.exists(absoluteRootDir) || !await storage.isDirectory(absoluteRootDir)) {
+            existsTimer.end(`Directory not found or not a directory: ${absoluteRootDir}`);
+            timer.end(`Directory invalid: ${rootDir}`);
+            return packageMap;
+        }
+        existsTimer.end(`Directory verified: ${absoluteRootDir}`);
+        // Get all items and process in parallel
+        const listTimer = PerformanceTimer.start(logger, `Listing contents: ${absoluteRootDir}`);
+        const items = await storage.listFiles(absoluteRootDir);
+        listTimer.end(`Listed ${items.length} items`);
+        // Create batched promises for better performance
+        const BATCH_SIZE = 10; // Process directories in batches to avoid overwhelming filesystem
+        const batches = [];
+        for(let i = 0; i < items.length; i += BATCH_SIZE){
+            const batch = items.slice(i, i + BATCH_SIZE);
+            batches.push(batch);
+        }
+        const processTimer = PerformanceTimer.start(logger, `Processing ${batches.length} batches of directories`);
+        for (const batch of batches){
+            const batchPromises = batch.map(async (item)=>{
+                const itemPath = path.join(absoluteRootDir, item);
+                try {
+                    if (await storage.isDirectory(itemPath)) {
+                        const packageJsonPath = path.join(itemPath, 'package.json');
+                        if (await storage.exists(packageJsonPath)) {
+                            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+                            const packageJson = validatePackageJson(parsed, packageJsonPath);
+                            if (packageJson.name) {
+                                const relativePath = path.relative(process.cwd(), itemPath);
+                                return {
+                                    name: packageJson.name,
+                                    path: relativePath
+                                };
+                            }
+                        }
+                    }
+                } catch (error) {
+                    logger.debug(`Skipped ${itemPath}: ${error.message || error}`);
+                }
+                return null;
+            });
+            const batchResults = await Promise.all(batchPromises);
+            for (const result of batchResults){
+                if (result) {
+                    packageMap.set(result.name, result.path);
+                    logger.debug(`Found package: ${result.name} at ${result.path}`);
+                }
+            }
+        }
+        processTimer.end(`Processed ${items.length} directories in ${batches.length} batches`);
+        logger.verbose(`Found ${packageMap.size} packages in ${items.length} subdirectories`);
+    } catch (error) {
+        logger.warn(`PERFORMANCE_DIR_READ_FAILED: Unable to read directory | Directory: ${absoluteRootDir} | Error: ${error}`);
+    }
+    timer.end(`Found ${packageMap.size} packages in: ${rootDir}`);
+    return packageMap;
+};
+// Parallel scope processing for better performance
+const findPackagesByScope = async (dependencies, scopeRoots, storage)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, 'Finding packages by scope (optimized)');
+    const workspacePackages = new Map();
+    logger.silly(`Checking dependencies against scope roots: ${JSON.stringify(scopeRoots)}`);
+    // Process all scopes in parallel for maximum performance
+    const scopeTimer = PerformanceTimer.start(logger, 'Parallel scope scanning');
+    const scopePromises = Object.entries(scopeRoots).map(async ([scope, rootDir])=>{
+        logger.verbose(`Scanning scope ${scope} at root directory: ${rootDir}`);
+        const scopePackages = await scanDirectoryForPackages(rootDir, storage);
+        // Filter packages that match the scope
+        const matchingPackages = [];
+        for (const [packageName, packagePath] of scopePackages){
+            if (packageName.startsWith(scope)) {
+                matchingPackages.push([
+                    packageName,
+                    packagePath
+                ]);
+                logger.debug(`Registered package: ${packageName} -> ${packagePath}`);
+            }
+        }
+        return {
+            scope,
+            packages: matchingPackages
+        };
+    });
+    const allScopeResults = await Promise.all(scopePromises);
+    // Aggregate all packages from all scopes
+    const allPackages = new Map();
+    for (const { scope, packages } of allScopeResults){
+        for (const [packageName, packagePath] of packages){
+            allPackages.set(packageName, packagePath);
+        }
+    }
+    scopeTimer.end(`Scanned ${Object.keys(scopeRoots).length} scope roots, found ${allPackages.size} packages`);
+    // Match dependencies to available packages
+    const matchTimer = PerformanceTimer.start(logger, 'Matching dependencies to packages');
+    for (const [depName, depVersion] of Object.entries(dependencies)){
+        logger.debug(`Processing dependency: ${depName}@${depVersion}`);
+        if (allPackages.has(depName)) {
+            const packagePath = allPackages.get(depName);
+            workspacePackages.set(depName, packagePath);
+            logger.verbose(`Found sibling package: ${depName} at ${packagePath}`);
+        }
+    }
+    matchTimer.end(`Matched ${workspacePackages.size} dependencies to workspace packages`);
+    timer.end(`Found ${workspacePackages.size} packages to link`);
+    return workspacePackages;
+};
+// Utility to collect all dependencies from package.json files efficiently
+const collectAllDependencies = (packageJsonFiles)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, 'Collecting all dependencies');
+    const allDependencies = {};
+    for (const { packageJson } of packageJsonFiles){
+        Object.assign(allDependencies, packageJson.dependencies);
+        Object.assign(allDependencies, packageJson.devDependencies);
+        Object.assign(allDependencies, packageJson.peerDependencies);
+    }
+    timer.end(`Collected ${Object.keys(allDependencies).length} unique dependencies`);
+    return allDependencies;
+};
+// Utility to check for file: dependencies
+const checkForFileDependencies = (packageJsonFiles)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, 'Checking for file: dependencies');
+    const filesWithFileDepedencies = [];
+    for (const { path: packagePath, packageJson, relativePath } of packageJsonFiles){
+        const fileDeps = [];
+        // Check all dependency types for file: paths
+        const allDeps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+            ...packageJson.peerDependencies
+        };
+        for (const [name, version] of Object.entries(allDeps)){
+            if (version.startsWith('file:')) {
+                fileDeps.push(`${name}: ${version}`);
+            }
+        }
+        if (fileDeps.length > 0) {
+            filesWithFileDepedencies.push({
+                path: relativePath,
+                dependencies: fileDeps
+            });
+        }
+    }
+    if (filesWithFileDepedencies.length > 0) {
+        logger.warn('FILE_DEPS_WARNING: Found file: dependencies that should not be committed | Count: ' + filesWithFileDepedencies.length + ' | Impact: May cause build issues');
+        for (const file of filesWithFileDepedencies){
+            logger.warn(`FILE_DEPS_PACKAGE: Package with file dependencies | Path: ${file.path}`);
+            for (const dep of file.dependencies){
+                logger.warn(`FILE_DEPS_DETAIL: File dependency detected | Dependency: ${dep}`);
+            }
+        }
+        logger.warn('');
+        logger.warn('FILE_DEPS_RESOLUTION: Action required before committing | Command: kodrdriv unlink | Purpose: Restore registry versions');
+        logger.warn('FILE_DEPS_PREVENTION: Alternative option | Action: Add pre-commit hook | Purpose: Prevent accidental commits of linked dependencies');
+    }
+    timer.end(`Checked ${packageJsonFiles.length} files, found ${filesWithFileDepedencies.length} with file: dependencies`);
+};
+
+/**
+ * Check if running in MCP server mode
+ */ const isMcpMode = ()=>process.env.KODRDRIV_MCP_SERVER === 'true';
+/**
+ * Get an MCP-aware logger that suppresses info/warn/debug output in MCP mode.
+ * Errors are always logged since they indicate problems that need attention.
+ */ const getMcpAwareLogger = ()=>{
+    const coreLogger = getLogger();
+    if (!isMcpMode()) {
+        // In normal mode, just return the core logger
+        return coreLogger;
+    }
+    // In MCP mode, wrap the logger to suppress non-error output
+    return {
+        info: (_message, ..._args)=>{},
+        warn: (_message, ..._args)=>{},
+        debug: (_message, ..._args)=>{},
+        verbose: (_message, ..._args)=>{},
+        silly: (_message, ..._args)=>{},
+        // Always log errors - they indicate real problems
+        error: (message, ...args)=>coreLogger.error(message, ...args)
+    };
+};
+
+/**
+ * Execute precommit checks by running the package's precommit script.
+ * Expects the package to have a "precommit" script in package.json.
+ */ const execute$3 = async (runConfig)=>{
+    var _runConfig_precommit, _packageJson_scripts;
+    const logger = getMcpAwareLogger();
+    const isDryRun = runConfig.dryRun || false;
+    const packageDir = process.cwd();
+    const shouldFix = ((_runConfig_precommit = runConfig.precommit) === null || _runConfig_precommit === void 0 ? void 0 : _runConfig_precommit.fix) || false;
+    // Verify precommit script exists
+    const fs = await import('fs/promises');
+    const packageJsonPath = path.join(packageDir, 'package.json');
+    let packageName = packageDir;
+    let packageJson;
+    try {
+        var _packageJson_scripts1;
+        const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+        packageJson = JSON.parse(packageJsonContent);
+        packageName = packageJson.name || packageDir;
+        if (!((_packageJson_scripts1 = packageJson.scripts) === null || _packageJson_scripts1 === void 0 ? void 0 : _packageJson_scripts1.precommit)) {
+            throw new Error(`Package "${packageName}" is missing a "precommit" script in package.json`);
+        }
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`No package.json found at ${packageJsonPath}`);
+        }
+        throw error;
+    }
+    // If --fix is enabled, try to run lint --fix before precommit
+    if (shouldFix && ((_packageJson_scripts = packageJson.scripts) === null || _packageJson_scripts === void 0 ? void 0 : _packageJson_scripts.lint)) {
+        const lintFixCommand = 'npm run lint -- --fix';
+        if (isDryRun) {
+            logger.info(`DRY RUN: Would execute: ${lintFixCommand}`);
+        } else {
+            try {
+                logger.info(`🔧 Running lint --fix before precommit checks: ${lintFixCommand}`);
+                await run(lintFixCommand, {
+                    cwd: packageDir
+                });
+                logger.info(`✅ Lint fixes applied`);
+            } catch (error) {
+                // Log warning but continue with precommit - lint --fix may fail on some issues
+                logger.warn(`⚠️  Lint --fix had issues (continuing with precommit): ${error.message}`);
+            }
+        }
+    }
+    const commandToRun = 'npm run precommit';
+    if (isDryRun) {
+        logger.info(`DRY RUN: Would execute: ${commandToRun}`);
+        return `DRY RUN: Would run precommit checks: ${commandToRun}`;
+    }
+    // Execute the precommit script
+    const timer = PerformanceTimer.start(logger, 'Precommit checks');
+    try {
+        logger.info(`🔧 Running precommit checks: ${commandToRun}`);
+        await run(commandToRun, {
+            cwd: packageDir
+        });
+        const duration = timer.end('Precommit checks');
+        const seconds = (duration / 1000).toFixed(1);
+        logger.info(`✅ Precommit checks passed (${seconds}s)`);
+        return `Precommit checks completed successfully in ${seconds}s`;
+    } catch (error) {
+        timer.end('Precommit checks');
+        logger.error(`❌ Precommit checks failed: ${error.message}`);
+        throw error;
+    }
+};
+
+const executeInternal$2 = async (runConfig)=>{
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+    const storage = createStorage();
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    if (isDryRun) {
+        logger.info(`CLEAN_DRY_RUN: Would remove output directory | Mode: dry-run | Directory: ${outputDirectory} | Action: Would delete if exists`);
+        logger.info(`CLEAN_CHECK_DRY_RUN: Would check directory existence | Mode: dry-run | Directory: ${outputDirectory}`);
+        logger.info('CLEAN_REMOVE_DRY_RUN: Would remove directory if present | Mode: dry-run | Action: Delete');
+        return;
+    }
+    logger.info(`CLEAN_STARTING: Removing output directory | Directory: ${outputDirectory} | Action: Delete | Purpose: Clean generated files`);
+    try {
+        if (await storage.exists(outputDirectory)) {
+            await storage.removeDirectory(outputDirectory);
+            logger.info(`CLEAN_SUCCESS: Successfully removed output directory | Directory: ${outputDirectory} | Status: deleted`);
+        } else {
+            logger.info(`CLEAN_NOT_EXISTS: Output directory does not exist | Directory: ${outputDirectory} | Status: nothing-to-clean`);
+        }
+    } catch (error) {
+        logger.error(`CLEAN_FAILED: Failed to clean output directory | Directory: ${outputDirectory} | Error: ${error.message}`);
+        throw new FileOperationError('Failed to remove output directory', outputDirectory, error);
+    }
+};
+const execute$2 = async (runConfig)=>{
+    try {
+        await executeInternal$2(runConfig);
+    } catch (error) {
+        const logger = getLogger();
+        if (error instanceof FileOperationError) {
+            logger.error(`CLEAN_COMMAND_FAILED: Clean command failed | Error: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            throw error;
+        }
+        // Unexpected errors
+        logger.error(`CLEAN_UNEXPECTED_ERROR: Clean encountered unexpected error | Error: ${error.message} | Type: unexpected`);
+        throw error;
+    }
+};
+
+// Utility function to read a review note from a file
+const readReviewNoteFromFile = async (filePath)=>{
+    const logger = getLogger();
+    try {
+        logger.debug(`Reading review note from file: ${filePath}`);
+        const content = await fs.readFile(filePath, 'utf8');
+        if (!content.trim()) {
+            throw new ValidationError(`Review file is empty: ${filePath}`);
+        }
+        logger.debug(`Successfully read review note from file: ${filePath} (${content.length} characters)`);
+        return content.trim();
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new FileOperationError(`Review file not found: ${filePath}`, filePath, error);
+        }
+        if (error instanceof ValidationError) {
+            throw error;
+        }
+        throw new FileOperationError(`Failed to read review file: ${error.message}`, filePath, error);
+    }
+};
+// Utility function to get all review files in a directory
+const getReviewFilesInDirectory = async (directoryPath)=>{
+    const logger = getLogger();
+    try {
+        logger.debug(`Scanning directory for review files: ${directoryPath}`);
+        const entries = await fs.readdir(directoryPath, {
+            withFileTypes: true
+        });
+        // Filter for regular files (not directories) and get full paths
+        const files = entries.filter((entry)=>entry.isFile()).map((entry)=>path.join(directoryPath, entry.name)).sort(); // Sort alphabetically
+        logger.debug(`Found ${files.length} files in directory: ${directoryPath}`);
+        return files;
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new FileOperationError(`Directory not found: ${directoryPath}`, directoryPath, error);
+        }
+        throw new FileOperationError(`Failed to read directory: ${directoryPath}`, directoryPath, error);
+    }
+};
+// New function for file selection phase
+const selectFilesForProcessing = async (reviewFiles, senditMode)=>{
+    const logger = getLogger();
+    if (senditMode) {
+        logger.info(`REVIEW_AUTO_SELECT: Auto-selecting all files for processing | Mode: sendit | File Count: ${reviewFiles.length} | Confirmation: automatic`);
+        return reviewFiles;
+    }
+    // Check if we're in an interactive environment
+    if (!isTTYSafe()) {
+        logger.warn(`REVIEW_NON_INTERACTIVE_SELECT: Non-interactive environment detected | Action: Selecting all files | Mode: non-interactive`);
+        return reviewFiles;
+    }
+    logger.info(`\nREVIEW_SELECTION_PHASE: Starting file selection phase | File Count: ${reviewFiles.length} | Purpose: Choose files to process`);
+    logger.info(`REVIEW_SELECTION_FILES: Found files to review | Count: ${reviewFiles.length} | Action: Select files for processing`);
+    logger.info(`REVIEW_SELECTION_OPTIONS: File selection options available | [c]=Confirm | [s]=Skip | [a]=Abort`);
+    logger.info(``);
+    const selectedFiles = [];
+    let shouldAbort = false;
+    for(let i = 0; i < reviewFiles.length; i++){
+        const filePath = reviewFiles[i];
+        logger.info(`REVIEW_SELECTION_FILE: File for review | Progress: ${i + 1}/${reviewFiles.length} | File: ${filePath}`);
+        const choice = await getUserChoice(`Select action for this file:`, [
+            {
+                key: 'c',
+                label: 'Confirm and process'
+            },
+            {
+                key: 's',
+                label: 'Skip this file'
+            },
+            {
+                key: 'a',
+                label: 'Abort entire review'
+            }
+        ]);
+        if (choice === 'a') {
+            logger.info(`REVIEW_ABORTED: User aborted review process | Action: Aborting | Reason: User request`);
+            shouldAbort = true;
+            break;
+        } else if (choice === 'c') {
+            selectedFiles.push(filePath);
+            logger.info(`REVIEW_FILE_SELECTED: File selected for processing | File: ${filePath} | Action: Will be processed`);
+        } else if (choice === 's') {
+            logger.info(`REVIEW_FILE_SKIPPED: File skipped during selection | File: ${filePath} | Action: Will not be processed`);
+        }
+    }
+    if (shouldAbort) {
+        throw new Error('Review process aborted by user');
+    }
+    if (selectedFiles.length === 0) {
+        throw new Error('No files were selected for processing');
+    }
+    logger.info(`\n📋 File selection complete. ${selectedFiles.length} files selected for processing:`);
+    selectedFiles.forEach((file, index)=>{
+        logger.info(`  ${index + 1}. ${file}`);
+    });
+    logger.info(``);
+    return selectedFiles;
+};
+// Safe temp file handling with proper permissions and validation
+const createSecureTempFile = async ()=>{
+    const logger = getLogger();
+    const tmpDir = os.tmpdir();
+    // Ensure temp directory exists and is writable
+    try {
+        // Use constant value directly to avoid import restrictions
+        const W_OK = 2; // fs.constants.W_OK value
+        await fs.access(tmpDir, W_OK);
+    } catch (error) {
+        logger.error(`TEMP_DIR_NOT_WRITABLE: Temporary directory is not writable | Directory: ${tmpDir} | Impact: Cannot create temp files`);
+        throw new FileOperationError(`Temp directory not writable: ${error.message}`, tmpDir, error);
+    }
+    const tmpFilePath = path.join(tmpDir, `kodrdriv_review_${Date.now()}_${Math.random().toString(36).substring(7)}.md`);
+    // Create file with restrictive permissions (owner read/write only)
+    try {
+        const fd = await fs.open(tmpFilePath, 'w', 0o600);
+        await fd.close();
+        logger.debug(`Created secure temp file: ${tmpFilePath}`);
+        return tmpFilePath;
+    } catch (error) {
+        logger.error(`TEMP_FILE_CREATE_FAILED: Unable to create temporary file | Error: ${error.message} | Impact: Cannot proceed with review`);
+        throw new FileOperationError(`Failed to create temp file: ${error.message}`, 'temporary file', error);
+    }
+};
+// Safe file cleanup with proper error handling
+const cleanupTempFile = async (filePath)=>{
+    const logger = getLogger();
+    try {
+        await fs.unlink(filePath);
+        logger.debug(`Cleaned up temp file: ${filePath}`);
+    } catch (error) {
+        // Only ignore ENOENT (file not found) errors, log others
+        if (error.code !== 'ENOENT') {
+            logger.warn(`TEMP_FILE_CLEANUP_FAILED: Unable to cleanup temporary file | File: ${filePath} | Error: ${error.message} | Impact: File may remain`);
+        // Don't throw here to avoid masking the main operation
+        }
+    }
+};
+// Editor with optional timeout and proper error handling
+const openEditorWithTimeout = async (editorCmd, filePath, timeoutMs)=>{
+    const logger = getLogger();
+    return new Promise((resolve, reject)=>{
+        if (timeoutMs) {
+            logger.debug(`Opening editor: ${editorCmd} ${filePath} (timeout: ${timeoutMs}ms)`);
+        } else {
+            logger.debug(`Opening editor: ${editorCmd} ${filePath} (no timeout)`);
+        }
+        const child = spawn(editorCmd, [
+            filePath
+        ], {
+            stdio: 'inherit',
+            shell: false // Prevent shell injection
+        });
+        let timeout;
+        let timeoutCleared = false;
+        const clearTimeoutSafely = ()=>{
+            if (timeout && !timeoutCleared) {
+                clearTimeout(timeout);
+                timeoutCleared = true;
+            }
+        };
+        if (timeoutMs) {
+            timeout = setTimeout(()=>{
+                clearTimeoutSafely(); // Clear the timeout immediately when it fires
+                logger.warn(`Editor timed out after ${timeoutMs}ms, terminating...`);
+                child.kill('SIGTERM');
+                // Give it a moment to terminate gracefully, then force kill
+                setTimeout(()=>{
+                    if (!child.killed) {
+                        logger.warn('Editor did not terminate gracefully, force killing...');
+                        child.kill('SIGKILL');
+                    }
+                }, 5000);
+                reject(new Error(`Editor '${editorCmd}' timed out after ${timeoutMs}ms. Consider using a different editor or increasing the timeout.`));
+            }, timeoutMs);
+        }
+        child.on('exit', (code, signal)=>{
+            clearTimeoutSafely();
+            logger.debug(`Editor exited with code ${code}, signal ${signal}`);
+            if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+                reject(new Error(`Editor was terminated (${signal})`));
+            } else if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`Editor exited with non-zero code: ${code}`));
+            }
+        });
+        child.on('error', (error)=>{
+            clearTimeoutSafely();
+            logger.error(`Editor error: ${error.message}`);
+            reject(new Error(`Failed to launch editor '${editorCmd}': ${error.message}`));
+        });
+    });
+};
+// Validate API response format before use
+const validateReviewResult = (data)=>{
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid API response: expected object, got ' + typeof data);
+    }
+    if (typeof data.summary !== 'string') {
+        throw new Error('Invalid API response: missing or invalid summary field');
+    }
+    if (typeof data.totalIssues !== 'number' || data.totalIssues < 0) {
+        throw new Error('Invalid API response: missing or invalid totalIssues field');
+    }
+    if (data.issues && !Array.isArray(data.issues)) {
+        throw new Error('Invalid API response: issues field must be an array');
+    }
+    // Validate each issue if present
+    if (data.issues) {
+        for(let i = 0; i < data.issues.length; i++){
+            const issue = data.issues[i];
+            if (!issue || typeof issue !== 'object') {
+                throw new Error(`Invalid API response: issue ${i} is not an object`);
+            }
+            if (typeof issue.title !== 'string') {
+                throw new Error(`Invalid API response: issue ${i} missing title`);
+            }
+            if (typeof issue.priority !== 'string') {
+                throw new Error(`Invalid API response: issue ${i} missing priority`);
+            }
+        }
+    }
+    return data;
+};
+// Enhanced TTY detection with fallback handling
+const isTTYSafe = ()=>{
+    try {
+        // Primary check
+        if (process.stdin.isTTY === false) {
+            return false;
+        }
+        // Additional checks for edge cases
+        if (process.stdin.isTTY === true) {
+            return true;
+        }
+        // Handle undefined case (some environments)
+        if (process.stdin.isTTY === undefined) {
+            // Check if we can reasonably assume interactive mode
+            return process.stdout.isTTY === true && process.stderr.isTTY === true;
+        }
+        return false;
+    } catch (error) {
+        // If TTY detection fails entirely, assume non-interactive
+        getLogger().debug(`TTY detection failed: ${error}, assuming non-interactive`);
+        return false;
+    }
+};
+// Safe file write with disk space and permission validation
+const safeWriteFile = async (filePath, content, encoding = 'utf-8')=>{
+    const logger = getLogger();
+    try {
+        // Check if parent directory exists and is writable
+        const parentDir = path.dirname(filePath);
+        const W_OK = 2; // fs.constants.W_OK value
+        await fs.access(parentDir, W_OK);
+        // Check available disk space (basic check by writing a small test)
+        const testFile = `${filePath}.test`;
+        try {
+            await fs.writeFile(testFile, 'test', encoding);
+            await fs.unlink(testFile);
+        } catch (error) {
+            if (error.code === 'ENOSPC') {
+                throw new Error(`Insufficient disk space to write file: ${filePath}`);
+            }
+            throw error;
+        }
+        // Write the actual file
+        await fs.writeFile(filePath, content, encoding);
+        logger.debug(`Successfully wrote file: ${filePath} (${content.length} characters)`);
+    } catch (error) {
+        logger.error(`Failed to write file ${filePath}: ${error.message}`);
+        throw new Error(`Failed to write file ${filePath}: ${error.message}`);
+    }
+};
+// Helper function to process a single review note
+const processSingleReview = async (reviewNote, runConfig, outputDirectory)=>{
+    var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review_context, _runConfig_review4, _runConfig_review5, _aiConfig_commands_review, _aiConfig_commands, _analysisResult_issues;
+    const logger = getLogger();
+    // Gather additional context based on configuration with improved error handling
+    let logContext = '';
+    let diffContext = '';
+    let releaseNotesContext = '';
+    let issuesContext = '';
+    const contextErrors = [];
+    // Fetch commit history if enabled
+    if ((_runConfig_review = runConfig.review) === null || _runConfig_review === void 0 ? void 0 : _runConfig_review.includeCommitHistory) {
+        try {
+            logger.debug('Fetching recent commit history...');
+            const log = await Log.create({
+                limit: runConfig.review.commitHistoryLimit
+            });
+            const logContent = await log.get();
+            if (logContent.trim()) {
+                logContext += `\n\n[Recent Commit History]\n${logContent}`;
+                logger.debug('Added commit history to context (%d characters)', logContent.length);
+            }
+        } catch (error) {
+            const errorMsg = `Failed to fetch commit history: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
+        }
+    }
+    // Fetch recent diffs if enabled
+    if ((_runConfig_review1 = runConfig.review) === null || _runConfig_review1 === void 0 ? void 0 : _runConfig_review1.includeRecentDiffs) {
+        try {
+            var _runConfig_excludedPatterns;
+            logger.debug('Fetching recent commit diffs...');
+            const basePatterns = (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS;
+            const recentDiffs = await Diff.getRecentDiffsForReview({
+                limit: runConfig.review.diffHistoryLimit,
+                baseExcludedPatterns: basePatterns
+            });
+            diffContext += recentDiffs;
+            if (recentDiffs.trim()) {
+                logger.debug('Added recent diffs to context (%d characters)', recentDiffs.length);
+            }
+        } catch (error) {
+            const errorMsg = `Failed to fetch recent diffs: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
+        }
+    }
+    // Fetch release notes if enabled
+    if ((_runConfig_review2 = runConfig.review) === null || _runConfig_review2 === void 0 ? void 0 : _runConfig_review2.includeReleaseNotes) {
+        try {
+            logger.debug('Fetching recent release notes from GitHub...');
+            const releaseNotesContent = await getReleaseNotesContent({
+                limit: runConfig.review.releaseNotesLimit || 3
+            });
+            if (releaseNotesContent.trim()) {
+                releaseNotesContext += `\n\n[Recent Release Notes]\n${releaseNotesContent}`;
+                logger.debug('Added release notes to context (%d characters)', releaseNotesContent.length);
+            }
+        } catch (error) {
+            const errorMsg = `Failed to fetch release notes: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
+        }
+    }
+    // Fetch GitHub issues if enabled
+    if ((_runConfig_review3 = runConfig.review) === null || _runConfig_review3 === void 0 ? void 0 : _runConfig_review3.includeGithubIssues) {
+        try {
+            logger.debug('Fetching open GitHub issues...');
+            issuesContext = await getIssuesContent({
+                limit: runConfig.review.githubIssuesLimit || 20
+            });
+            if (issuesContext.trim()) {
+                logger.debug('Added GitHub issues to context (%d characters)', issuesContext.length);
+            }
+        } catch (error) {
+            const errorMsg = `Failed to fetch GitHub issues: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
+        }
+    }
+    // Report context gathering results
+    if (contextErrors.length > 0) {
+        var _runConfig_review6;
+        logger.warn(`Context gathering completed with ${contextErrors.length} error(s):`);
+        contextErrors.forEach((error)=>logger.warn(`  - ${error}`));
+        // For critical operations, consider failing if too many context sources fail
+        const maxContextErrors = ((_runConfig_review6 = runConfig.review) === null || _runConfig_review6 === void 0 ? void 0 : _runConfig_review6.maxContextErrors) || contextErrors.length; // Default: allow all errors
+        if (contextErrors.length > maxContextErrors) {
+            throw new Error(`Too many context gathering errors (${contextErrors.length}), aborting review. Consider checking your configuration and network connectivity.`);
+        }
+    }
+    // Analyze review note for issues using OpenAI
+    logger.info('REVIEW_ANALYSIS_STARTING: Analyzing review note for project issues | Source: review note | Purpose: Identify actionable issues');
+    logger.debug('Context summary:');
+    logger.debug('  - Review note: %d chars', reviewNote.length);
+    logger.debug('  - Log context: %d chars', logContext.length);
+    logger.debug('  - Diff context: %d chars', diffContext.length);
+    logger.debug('  - Release notes context: %d chars', releaseNotesContext.length);
+    logger.debug('  - Issues context: %d chars', issuesContext.length);
+    logger.debug('  - User context: %d chars', ((_runConfig_review4 = runConfig.review) === null || _runConfig_review4 === void 0 ? void 0 : (_runConfig_review_context = _runConfig_review4.context) === null || _runConfig_review_context === void 0 ? void 0 : _runConfig_review_context.length) || 0);
+    const promptConfig = {
+        overridePaths: runConfig.discoveredConfigDirs || [],
+        overrides: runConfig.overrides || false
+    };
+    // Create adapters for ai-service
+    const aiConfig = toAIConfig(runConfig);
+    const aiStorageAdapter = createStorageAdapter(outputDirectory);
+    const aiLogger = createLoggerAdapter(runConfig.dryRun || false);
+    const promptContent = {
+        notes: reviewNote
+    };
+    const promptContext = {
+        context: (_runConfig_review5 = runConfig.review) === null || _runConfig_review5 === void 0 ? void 0 : _runConfig_review5.context,
+        logContext,
+        diffContext,
+        releaseNotesContext,
+        issuesContext
+    };
+    const prompt = await createReviewPrompt(promptConfig, promptContent, promptContext);
+    const modelToUse = ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_review = _aiConfig_commands.review) === null || _aiConfig_commands_review === void 0 ? void 0 : _aiConfig_commands_review.model) || aiConfig.model || 'gpt-4o-mini';
+    const request = Formatter.create({
+        logger
+    }).formatPrompt(modelToUse, prompt);
+    let analysisResult;
+    try {
+        var _aiConfig_commands_review1, _aiConfig_commands1, _rawAnalysisResult_issues;
+        const rawResult = await createCompletion(request.messages, {
+            model: modelToUse,
+            openaiReasoning: ((_aiConfig_commands1 = aiConfig.commands) === null || _aiConfig_commands1 === void 0 ? void 0 : (_aiConfig_commands_review1 = _aiConfig_commands1.review) === null || _aiConfig_commands_review1 === void 0 ? void 0 : _aiConfig_commands_review1.reasoning) || aiConfig.reasoning,
+            responseFormat: {
+                type: 'json_object'
+            },
+            debug: runConfig.debug,
+            debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('review-analysis')),
+            debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('review-analysis')),
+            storage: aiStorageAdapter,
+            logger: aiLogger
+        });
+        // Validate the API response before using it
+        const rawAnalysisResult = validateReviewResult(rawResult);
+        // Apply stop-context filtering to issues
+        analysisResult = {
+            ...rawAnalysisResult,
+            summary: filterContent(rawAnalysisResult.summary, runConfig.stopContext).filtered,
+            issues: (_rawAnalysisResult_issues = rawAnalysisResult.issues) === null || _rawAnalysisResult_issues === void 0 ? void 0 : _rawAnalysisResult_issues.map((issue)=>({
+                    ...issue,
+                    title: filterContent(issue.title, runConfig.stopContext).filtered,
+                    description: filterContent(issue.description || '', runConfig.stopContext).filtered
+                }))
+        };
+    } catch (error) {
+        logger.error(`REVIEW_ANALYSIS_FAILED: Unable to analyze review note | Error: ${error.message} | Impact: Cannot identify issues`);
+        throw new Error(`Review analysis failed: ${error.message}`);
+    }
+    logger.info('REVIEW_ANALYSIS_COMPLETE: Review note analysis completed successfully | Status: completed | Next: Issue creation if enabled');
+    logger.debug('Analysis result summary: %s', analysisResult.summary);
+    logger.debug('Total issues found: %d', analysisResult.totalIssues);
+    logger.debug('Issues array length: %d', ((_analysisResult_issues = analysisResult.issues) === null || _analysisResult_issues === void 0 ? void 0 : _analysisResult_issues.length) || 0);
+    if (analysisResult.issues && analysisResult.issues.length > 0) {
+        analysisResult.issues.forEach((issue, index)=>{
+            logger.debug('  Issue %d: [%s] %s', index + 1, issue.priority, issue.title);
+        });
+    }
+    // Save timestamped copy of analysis result to output directory
+    try {
+        const reviewFilename = getTimestampedReviewFilename();
+        const reviewPath = getOutputPath(outputDirectory, reviewFilename);
+        // Format the analysis result as markdown
+        const reviewContent = `# Review Analysis Result\n\n` + `## Summary\n${analysisResult.summary}\n\n` + `## Total Issues Found\n${analysisResult.totalIssues}\n\n` + `## Issues\n\n${JSON.stringify(analysisResult.issues, null, 2)}\n\n` + `---\n\n*Analysis completed at ${new Date().toISOString()}*`;
+        await safeWriteFile(reviewPath, reviewContent);
+        logger.debug('Saved timestamped review analysis: %s', reviewPath);
+    } catch (error) {
+        logger.warn('Failed to save timestamped review analysis: %s', error.message);
+    // Don't fail the entire operation for this
+    }
+    return analysisResult;
+};
+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;
+    // Show configuration even in dry-run mode
+    logger.debug('Review context configuration:');
+    logger.debug('  Include commit history: %s', (_runConfig_review = runConfig.review) === null || _runConfig_review === void 0 ? void 0 : _runConfig_review.includeCommitHistory);
+    logger.debug('  Include recent diffs: %s', (_runConfig_review1 = runConfig.review) === null || _runConfig_review1 === void 0 ? void 0 : _runConfig_review1.includeRecentDiffs);
+    logger.debug('  Include release notes: %s', (_runConfig_review2 = runConfig.review) === null || _runConfig_review2 === void 0 ? void 0 : _runConfig_review2.includeReleaseNotes);
+    logger.debug('  Include GitHub issues: %s', (_runConfig_review3 = runConfig.review) === null || _runConfig_review3 === void 0 ? void 0 : _runConfig_review3.includeGithubIssues);
+    logger.debug('  Commit history limit: %d', (_runConfig_review4 = runConfig.review) === null || _runConfig_review4 === void 0 ? void 0 : _runConfig_review4.commitHistoryLimit);
+    logger.debug('  Diff history limit: %d', (_runConfig_review5 = runConfig.review) === null || _runConfig_review5 === void 0 ? void 0 : _runConfig_review5.diffHistoryLimit);
+    logger.debug('  Release notes limit: %d', (_runConfig_review6 = runConfig.review) === null || _runConfig_review6 === void 0 ? void 0 : _runConfig_review6.releaseNotesLimit);
+    logger.debug('  GitHub issues limit: %d', (_runConfig_review7 = runConfig.review) === null || _runConfig_review7 === void 0 ? void 0 : _runConfig_review7.githubIssuesLimit);
+    logger.debug('  Sendit mode (auto-create issues): %s', (_runConfig_review8 = runConfig.review) === null || _runConfig_review8 === void 0 ? void 0 : _runConfig_review8.sendit);
+    logger.debug('  File: %s', ((_runConfig_review9 = runConfig.review) === null || _runConfig_review9 === void 0 ? void 0 : _runConfig_review9.file) || 'not specified');
+    logger.debug('  Directory: %s', ((_runConfig_review10 = runConfig.review) === null || _runConfig_review10 === void 0 ? void 0 : _runConfig_review10.directory) || 'not specified');
+    if (isDryRun) {
+        var _runConfig_review19, _runConfig_review20, _runConfig_review21, _runConfig_review22, _runConfig_review23;
+        if ((_runConfig_review19 = runConfig.review) === null || _runConfig_review19 === void 0 ? void 0 : _runConfig_review19.file) {
+            logger.info('DRY RUN: Would read review note from file: %s', runConfig.review.file);
+        } else if ((_runConfig_review20 = runConfig.review) === null || _runConfig_review20 === void 0 ? void 0 : _runConfig_review20.directory) {
+            logger.info('DRY RUN: Would process review files in directory: %s', runConfig.review.directory);
+            logger.info('DRY RUN: Would first select which files to process, then analyze selected files');
+        } else if ((_runConfig_review21 = runConfig.review) === null || _runConfig_review21 === void 0 ? void 0 : _runConfig_review21.note) {
+            logger.info('DRY RUN: Would analyze provided note for review');
+        } else {
+            logger.info('DRY RUN: Would open editor to capture review note');
+        }
+        logger.info('DRY RUN: Would gather additional context based on configuration above');
+        logger.info('DRY RUN: Would analyze note and identify issues');
+        if ((_runConfig_review22 = runConfig.review) === null || _runConfig_review22 === void 0 ? void 0 : _runConfig_review22.sendit) {
+            logger.info('DRY RUN: Would automatically create GitHub issues (sendit mode enabled)');
+        } else {
+            logger.info('DRY RUN: Would prompt for confirmation before creating GitHub issues');
+        }
+        // Show what exclusion patterns would be used in dry-run mode
+        if ((_runConfig_review23 = runConfig.review) === null || _runConfig_review23 === void 0 ? void 0 : _runConfig_review23.includeRecentDiffs) {
+            var _runConfig_excludedPatterns;
+            const basePatterns = (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS;
+            const reviewExcluded = Diff.getReviewExcludedPatterns(basePatterns);
+            logger.info('DRY RUN: Would use %d exclusion patterns for diff context', reviewExcluded.length);
+            logger.debug('DRY RUN: Sample exclusions: %s', reviewExcluded.slice(0, 15).join(', ') + (reviewExcluded.length > 15 ? '...' : ''));
+        }
+        return 'DRY RUN: Review command would analyze note, gather context, and create GitHub issues';
+    }
+    // Enhanced TTY check with proper error handling
+    const isInteractive = isTTYSafe();
+    if (!isInteractive && !((_runConfig_review11 = runConfig.review) === null || _runConfig_review11 === void 0 ? void 0 : _runConfig_review11.sendit)) {
+        logger.error('❌ STDIN is piped but --sendit flag is not enabled');
+        logger.error('   Interactive prompts cannot be used when input is piped');
+        logger.error('   Solutions:');
+        logger.error('   • Add --sendit flag to auto-create all issues');
+        logger.error('   • Use terminal input instead of piping');
+        logger.error('   • Example: echo "note" | kodrdriv review --sendit');
+        throw new ValidationError('Piped input requires --sendit flag for non-interactive operation');
+    }
+    // Get the review note from configuration
+    let reviewNote = (_runConfig_review12 = runConfig.review) === null || _runConfig_review12 === void 0 ? void 0 : _runConfig_review12.note;
+    let reviewFiles = [];
+    // Check if we should process a single file
+    if ((_runConfig_review13 = runConfig.review) === null || _runConfig_review13 === void 0 ? void 0 : _runConfig_review13.file) {
+        logger.info(`📁 Reading review note from file: ${runConfig.review.file}`);
+        reviewNote = await readReviewNoteFromFile(runConfig.review.file);
+        reviewFiles = [
+            runConfig.review.file
+        ];
+    } else if ((_runConfig_review14 = runConfig.review) === null || _runConfig_review14 === void 0 ? void 0 : _runConfig_review14.directory) {
+        var _runConfig_review24;
+        logger.info(`📁 Processing review files in directory: ${runConfig.review.directory}`);
+        reviewFiles = await getReviewFilesInDirectory(runConfig.review.directory);
+        if (reviewFiles.length === 0) {
+            throw new ValidationError(`No review files found in directory: ${runConfig.review.directory}`);
+        }
+        logger.info(`📁 Found ${reviewFiles.length} files to process`);
+        // Set a dummy reviewNote for directory mode to satisfy validation
+        // The actual review notes will be read from each file during processing
+        reviewNote = `Processing ${reviewFiles.length} files from directory`;
+        // If not in sendit mode, explain the two-phase process
+        if (!((_runConfig_review24 = runConfig.review) === null || _runConfig_review24 === void 0 ? void 0 : _runConfig_review24.sendit)) {
+            logger.info(`📝 Interactive mode: You will first select which files to process, then they will be analyzed in order.`);
+            logger.info(`📝 Use --sendit to process all files automatically without confirmation.`);
+        }
+    } else if ((_runConfig_review15 = runConfig.review) === null || _runConfig_review15 === void 0 ? void 0 : _runConfig_review15.note) {
+        reviewNote = runConfig.review.note;
+        reviewFiles = [
+            'provided note'
+        ];
+    } else {
+        // Open editor to capture review note
+        const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+        let tmpFilePath = null;
+        try {
+            var _runConfig_review25;
+            // Create secure temporary file
+            tmpFilePath = await createSecureTempFile();
+            // Pre-populate the file with a helpful header so users know what to do.
+            const templateContent = [
+                '# Kodrdriv Review Note',
+                '',
+                '# Please enter your review note below. Lines starting with "#" will be ignored.',
+                '# Save and close the editor when you are done.',
+                '',
+                ''
+            ].join('\n');
+            await safeWriteFile(tmpFilePath, templateContent);
+            logger.info(`No review note provided – opening ${editor} to capture input...`);
+            // Open the editor with optional timeout protection
+            const editorTimeout = (_runConfig_review25 = runConfig.review) === null || _runConfig_review25 === void 0 ? void 0 : _runConfig_review25.editorTimeout; // No default timeout - let user take their time
+            await openEditorWithTimeout(editor, tmpFilePath, editorTimeout);
+            // Read the file back in, stripping comment lines and whitespace.
+            const fileContent = (await fs.readFile(tmpFilePath, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
+            if (!fileContent) {
+                throw new ValidationError('Review note is empty – aborting. Provide a note as an argument, via STDIN, or through the editor.');
+            }
+            reviewNote = fileContent;
+            // If the original runConfig.review object exists, update it so downstream code has the note.
+            if (runConfig.review) {
+                runConfig.review.note = reviewNote;
+            }
+        } catch (error) {
+            logger.error(`Failed to capture review note via editor: ${error.message}`);
+            throw error;
+        } finally{
+            // Always clean up the temp file
+            if (tmpFilePath) {
+                await cleanupTempFile(tmpFilePath);
+            }
+        }
+        reviewFiles = [
+            'editor input'
+        ];
+    }
+    if (!reviewNote || !reviewNote.trim()) {
+        throw new ValidationError('No review note provided or captured');
+    }
+    logger.info('📝 Starting review analysis...');
+    logger.debug('Review note: %s', reviewNote);
+    logger.debug('Review note length: %d characters', reviewNote.length);
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = createStorage();
+    await storage.ensureDirectory(outputDirectory);
+    // Save timestamped copy of review notes to output directory
+    try {
+        const reviewNotesFilename = getTimestampedReviewNotesFilename();
+        const reviewNotesPath = getOutputPath(outputDirectory, reviewNotesFilename);
+        const reviewNotesContent = `# Review Notes\n\n${reviewNote}\n\n`;
+        await safeWriteFile(reviewNotesPath, reviewNotesContent);
+        logger.debug('Saved timestamped review notes: %s', reviewNotesPath);
+    } catch (error) {
+        logger.warn('Failed to save review notes: %s', error.message);
+    }
+    // Phase 1: File selection (only for directory mode)
+    let selectedFiles;
+    if ((_runConfig_review16 = runConfig.review) === null || _runConfig_review16 === void 0 ? void 0 : _runConfig_review16.directory) {
+        var _runConfig_review26;
+        selectedFiles = await selectFilesForProcessing(reviewFiles, ((_runConfig_review26 = runConfig.review) === null || _runConfig_review26 === void 0 ? void 0 : _runConfig_review26.sendit) || false);
+    } else {
+        // For single note mode, just use the note directly
+        selectedFiles = [
+            'single note'
+        ];
+    }
+    // Phase 2: Process selected files in order
+    logger.info(`\n📝 Starting analysis phase...`);
+    const results = [];
+    const processedFiles = [];
+    if ((_runConfig_review17 = runConfig.review) === null || _runConfig_review17 === void 0 ? void 0 : _runConfig_review17.directory) {
+        // Directory mode: process each selected file
+        for(let i = 0; i < selectedFiles.length; i++){
+            const filePath = selectedFiles[i];
+            try {
+                logger.info(`📝 Processing file ${i + 1}/${selectedFiles.length}: ${filePath}`);
+                const fileNote = await readReviewNoteFromFile(filePath);
+                const fileResult = await processSingleReview(fileNote, runConfig, outputDirectory);
+                results.push(fileResult);
+                processedFiles.push(filePath);
+            } catch (error) {
+                // Check if this is a critical error that should be propagated
+                if (error.message.includes('Too many context gathering errors')) {
+                    throw error; // Propagate critical context errors
+                }
+                logger.warn(`Failed to process file ${filePath}: ${error.message}`);
+            // Continue with other files for non-critical errors
+            }
+        }
+    } else {
+        // Single note mode: process the note directly
+        try {
+            logger.info(`📝 Processing single review note`);
+            const fileResult = await processSingleReview(reviewNote, runConfig, outputDirectory);
+            results.push(fileResult);
+            processedFiles.push('single note');
+        } catch (error) {
+            logger.warn(`Failed to process review note: ${error.message}`);
+            throw error; // Re-throw for single note mode since there's only one item
+        }
+    }
+    if (results.length === 0) {
+        throw new ValidationError('No files were processed successfully');
+    }
+    // Combine results if we processed multiple files
+    let analysisResult;
+    if (results.length === 1) {
+        analysisResult = results[0];
+    } else {
+        logger.info(`✅ Successfully processed ${results.length} review files`);
+        // Create a combined summary
+        const totalIssues = results.reduce((sum, result)=>sum + result.totalIssues, 0);
+        const allIssues = results.flatMap((result)=>result.issues || []);
+        analysisResult = {
+            summary: `Combined analysis of ${results.length} review files. Total issues found: ${totalIssues}`,
+            totalIssues,
+            issues: allIssues
+        };
+        // Save combined results
+        try {
+            const combinedFilename = getTimestampedReviewFilename();
+            const combinedPath = getOutputPath(outputDirectory, combinedFilename);
+            const combinedContent = `# Combined Review Analysis Result\n\n` + `## Summary\n${analysisResult.summary}\n\n` + `## Total Issues Found\n${totalIssues}\n\n` + `## Files Processed\n${processedFiles.join('\n')}\n\n` + `## Issues\n\n${JSON.stringify(allIssues, null, 2)}\n\n` + `---\n\n*Combined analysis completed at ${new Date().toISOString()}*`;
+            await safeWriteFile(combinedPath, combinedContent);
+            logger.debug('Saved combined review analysis: %s', combinedPath);
+        } catch (error) {
+            logger.warn('Failed to save combined review analysis: %s', error.message);
+        }
+    }
+    // Handle GitHub issue creation using the issues module
+    const senditMode = ((_runConfig_review18 = runConfig.review) === null || _runConfig_review18 === void 0 ? void 0 : _runConfig_review18.sendit) || false;
+    return await handleIssueCreation(analysisResult, senditMode);
+};
+const execute$1 = async (runConfig)=>{
+    try {
+        return await executeInternal$1(runConfig);
+    } catch (error) {
+        const logger = getLogger();
+        if (error instanceof ValidationError) {
+            logger.error(`review failed: ${error.message}`);
+            throw error;
+        }
+        if (error instanceof FileOperationError) {
+            logger.error(`review failed: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            throw error;
+        }
+        if (error instanceof CommandError) {
+            logger.error(`review failed: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            throw error;
+        }
+        // Unexpected errors
+        logger.error(`review encountered unexpected error: ${error.message}`);
+        throw error;
+    }
+};
+
+// 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;
+    }
+};
+
+const logger = getLogger();
+// Cache file to store test run timestamps per package
+const TEST_CACHE_FILE = '.kodrdriv-test-cache.json';
+/**
+ * Load test cache from disk
+ */ async function loadTestCache(packageDir) {
+    const cachePath = path.join(packageDir, TEST_CACHE_FILE);
+    try {
+        const content = await fs.readFile(cachePath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return {};
+    }
+}
+/**
+ * Save test cache to disk
+ */ async function saveTestCache(packageDir, cache) {
+    const cachePath = path.join(packageDir, TEST_CACHE_FILE);
+    try {
+        await fs.writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+    } catch (error) {
+        logger.debug(`Failed to save test cache: ${error.message}`);
+    }
+}
+/**
+ * Get the current git commit hash
+ */ async function getCurrentCommitHash(packageDir) {
+    try {
+        const { stdout } = await runSecure('git', [
+            'rev-parse',
+            'HEAD'
+        ], {
+            cwd: packageDir
+        });
+        return stdout.trim();
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Check if source files have changed since the last test run
+ */ async function hasSourceFilesChanged(packageDir, lastCommitHash) {
+    if (!lastCommitHash) {
+        return {
+            changed: true,
+            reason: 'No previous test run recorded'
+        };
+    }
+    try {
+        // Get current commit hash
+        const currentCommitHash = await getCurrentCommitHash(packageDir);
+        if (!currentCommitHash) {
+            return {
+                changed: true,
+                reason: 'Not in a git repository'
+            };
+        }
+        // If commit hash changed, files definitely changed
+        if (currentCommitHash !== lastCommitHash) {
+            return {
+                changed: true,
+                reason: `Commit hash changed: ${lastCommitHash.substring(0, 7)} -> ${currentCommitHash.substring(0, 7)}`
+            };
+        }
+        // Check if there are any uncommitted changes to source files
+        const { stdout } = await runSecure('git', [
+            'status',
+            '--porcelain'
+        ], {
+            cwd: packageDir
+        });
+        const changedFiles = stdout.split('\n').filter((line)=>line.trim()).map((line)=>line.substring(3).trim()).filter((file)=>{
+            // Only consider source files, not build artifacts or config files
+            const ext = path.extname(file);
+            return(// TypeScript/JavaScript source files
+            [
+                '.ts',
+                '.tsx',
+                '.js',
+                '.jsx'
+            ].includes(ext) || // Test files
+            file.includes('.test.') || file.includes('.spec.') || // Config files that affect build/test
+            [
+                'tsconfig.json',
+                'vite.config.ts',
+                'vitest.config.ts',
+                'package.json'
+            ].includes(path.basename(file)));
+        });
+        if (changedFiles.length > 0) {
+            return {
+                changed: true,
+                reason: `Uncommitted changes in: ${changedFiles.slice(0, 3).join(', ')}${changedFiles.length > 3 ? '...' : ''}`
+            };
+        }
+        return {
+            changed: false,
+            reason: 'No source file changes detected'
+        };
+    } catch (error) {
+        logger.debug(`Error checking for source file changes: ${error.message}`);
+        // Conservative: assume changed if we can't verify
+        return {
+            changed: true,
+            reason: `Could not verify changes: ${error.message}`
+        };
+    }
+}
+/**
+ * Check if dist directory needs to be cleaned (is outdated compared to source files)
+ */ async function isCleanNeeded(packageDir) {
+    const storage = createStorage();
+    const distPath = path.join(packageDir, 'dist');
+    try {
+        // Check if dist directory exists
+        const distExists = await storage.exists('dist');
+        if (!distExists) {
+            return {
+                needed: false,
+                reason: 'dist directory does not exist'
+            };
+        }
+        // Get dist directory modification time
+        const distStats = await fs.stat(distPath);
+        const distMtime = distStats.mtimeMs;
+        // Use git to find source files that are newer than dist
+        try {
+            // Get all tracked source files
+            const { stdout: trackedFiles } = await runSecure('git', [
+                'ls-files'
+            ], {
+                cwd: packageDir
+            });
+            const files = trackedFiles.split('\n').filter(Boolean);
+            // Check if any source files are newer than dist
+            for (const file of files){
+                const ext = path.extname(file);
+                if (![
+                    '.ts',
+                    '.tsx',
+                    '.js',
+                    '.jsx',
+                    '.json'
+                ].includes(ext)) {
+                    continue;
+                }
+                // Skip dist files
+                if (file.startsWith('dist/')) {
+                    continue;
+                }
+                try {
+                    const filePath = path.join(packageDir, file);
+                    const fileStats = await fs.stat(filePath);
+                    if (fileStats.mtimeMs > distMtime) {
+                        return {
+                            needed: true,
+                            reason: `${file} is newer than dist directory`
+                        };
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+            return {
+                needed: false,
+                reason: 'dist directory is up to date with source files'
+            };
+        } catch (error) {
+            // If git check fails, fall back to checking common source directories
+            logger.debug(`Git-based check failed, using fallback: ${error.message}`);
+            const sourceDirs = [
+                'src',
+                'tests'
+            ];
+            for (const dir of sourceDirs){
+                const dirPath = path.join(packageDir, dir);
+                try {
+                    const dirStats = await fs.stat(dirPath);
+                    if (dirStats.mtimeMs > distMtime) {
+                        return {
+                            needed: true,
+                            reason: `${dir} directory is newer than dist`
+                        };
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+            // Conservative: if we can't verify, assume clean is needed
+            return {
+                needed: true,
+                reason: 'Could not verify dist freshness, cleaning to be safe'
+            };
+        }
+    } catch (error) {
+        logger.debug(`Error checking if clean is needed: ${error.message}`);
+        // Conservative: assume clean is needed if we can't check
+        return {
+            needed: true,
+            reason: `Could not verify: ${error.message}`
+        };
+    }
+}
+/**
+ * Check if tests need to be run (source files changed since last test run)
+ */ async function isTestNeeded(packageDir) {
+    try {
+        // Load test cache
+        const cache = await loadTestCache(packageDir);
+        const cacheKey = packageDir;
+        // Check if we have a cached test run for this package
+        const cached = cache[cacheKey];
+        if (!cached) {
+            return {
+                needed: true,
+                reason: 'No previous test run recorded'
+            };
+        }
+        // Check if source files have changed since last test run
+        const changeCheck = await hasSourceFilesChanged(packageDir, cached.lastCommitHash);
+        if (changeCheck.changed) {
+            return {
+                needed: true,
+                reason: changeCheck.reason
+            };
+        }
+        return {
+            needed: false,
+            reason: 'No source file changes since last test run'
+        };
+    } catch (error) {
+        logger.debug(`Error checking if test is needed: ${error.message}`);
+        // Conservative: assume test is needed if we can't check
+        return {
+            needed: true,
+            reason: `Could not verify: ${error.message}`
+        };
+    }
+}
+/**
+ * Record that tests were run for this package
+ */ async function recordTestRun(packageDir) {
+    try {
+        const cache = await loadTestCache(packageDir);
+        const cacheKey = packageDir;
+        const commitHash = await getCurrentCommitHash(packageDir);
+        cache[cacheKey] = {
+            lastTestRun: Date.now(),
+            lastCommitHash: commitHash || 'unknown'
+        };
+        await saveTestCache(packageDir, cache);
+    } catch (error) {
+        logger.debug(`Failed to record test run: ${error.message}`);
+    }
+}
+/**
+ * Optimize a precommit command by skipping unnecessary steps
+ * Returns the optimized command and information about what was skipped
+ */ async function optimizePrecommitCommand(packageDir, originalCommand, options = {}) {
+    const { skipClean = true, skipTest = true } = options;
+    // Parse the original command to extract individual scripts
+    // Common patterns: "npm run precommit", "npm run clean && npm run build && npm run lint && npm run test"
+    const isPrecommitScript = originalCommand.includes('precommit') || originalCommand.includes('pre-commit');
+    let optimizedCommand = originalCommand;
+    const skipped = {
+        clean: false,
+        test: false
+    };
+    const reasons = {};
+    // If it's a precommit script, we need to check what it actually runs
+    // For now, we'll optimize the common pattern: clean && build && lint && test
+    if (isPrecommitScript || originalCommand.includes('clean')) {
+        if (skipClean) {
+            const cleanCheck = await isCleanNeeded(packageDir);
+            if (!cleanCheck.needed) {
+                // Remove clean from the command
+                optimizedCommand = optimizedCommand.replace(/npm\s+run\s+clean\s+&&\s*/g, '').replace(/npm\s+run\s+clean\s+/g, '').replace(/\s*&&\s*npm\s+run\s+clean/g, '').trim();
+                skipped.clean = true;
+                reasons.clean = cleanCheck.reason;
+            }
+        }
+    }
+    if (isPrecommitScript || originalCommand.includes('test')) {
+        if (skipTest) {
+            const testCheck = await isTestNeeded(packageDir);
+            if (!testCheck.needed) {
+                // Remove test from the command
+                optimizedCommand = optimizedCommand.replace(/\s*&&\s*npm\s+run\s+test\s*/g, '').replace(/\s*&&\s*npm\s+run\s+test$/g, '').replace(/npm\s+run\s+test\s+&&\s*/g, '').trim();
+                skipped.test = true;
+                reasons.test = testCheck.reason;
+            }
+        }
+    }
+    // Clean up any double && or trailing &&
+    optimizedCommand = optimizedCommand.replace(/\s*&&\s*&&/g, ' && ').replace(/&&\s*$/, '').trim();
+    return {
+        optimizedCommand,
+        skipped,
+        reasons
+    };
+}
+
+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