@eldrforge/commands-git 0.1.0

package/dist/index.js

@@ -0,0 +1,2346 @@
+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 '@eldrforge/core';
+import { ValidationError, ExternalDependencyError, CommandError, createStorage, checkForFileDependencies as checkForFileDependencies$1, logFileDependencyWarning, logFileDependencySuggestions, FileOperationError } from '@eldrforge/shared';
+import { run, validateString, safeJsonParse, validatePackageJson, unstageAll, stageFiles, verifyStagedFiles, runSecure } from '@eldrforge/git-tools';
+import { getRecentClosedIssuesForCommit, handleIssueCreation, getReleaseNotesContent, getIssuesContent } from '@eldrforge/github-tools';
+import { runAgenticCommit, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createCommitPrompt, createReviewPrompt, createCompletion } from '@eldrforge/ai-service';
+import path from 'path';
+import fs from 'fs/promises';
+import os from 'os';
+import { spawn } from 'child_process';
+
+// 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
+        }
+    }
+};
+/**
+ * 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$2 = async (runConfig)=>{
+    var _ref, _runConfig_excludedPatterns;
+    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _aiConfig_commands_commit, _aiConfig_commands, _runConfig_commit7, _aiConfig_commands_commit1, _aiConfig_commands1, _runConfig_commit8, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14;
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+    // 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
+    const cached = await determineCachedState(runConfig);
+    // Validate sendit state early - now returns boolean instead of throwing
+    validateSenditState(runConfig, cached, isDryRun, logger);
+    let diffContent = '';
+    const maxDiffBytes = (_ref = (_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.maxDiffBytes) !== null && _ref !== void 0 ? _ref : 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();
+    // 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_commit15;
+            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_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.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_commit16;
+            // 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_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.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_commit17;
+                    if ((_runConfig_commit17 = runConfig.commit) === null || _runConfig_commit17 === void 0 ? void 0 : _runConfig_commit17.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_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.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_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.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_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.contextFiles, logger);
+    // Combine file context with existing context
+    const combinedContext = [
+        (_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.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_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.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
+    const agenticResult = await runAgenticCommit({
+        changedFiles,
+        diffContent,
+        userDirection,
+        logContext,
+        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,
+        maxIterations: ((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.maxAgenticIterations) || 10,
+        debug: runConfig.debug,
+        debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('commit')),
+        debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('commit')),
+        storage: aiStorageAdapter,
+        logger: aiLogger,
+        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
+    });
+    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_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.selfReflection) {
+        await generateSelfReflection(agenticResult, outputDirectory, storage, logger);
+    }
+    // Check for suggested splits
+    if (agenticResult.suggestedSplits.length > 1 && ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.allowCommitSplitting)) {
+        var _runConfig_commit18;
+        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_commit18 = runConfig.commit) === null || _runConfig_commit18 === void 0 ? void 0 : _runConfig_commit18.autoSplit) !== false; // Default to true
+        if (autoSplitEnabled) {
+            var _runConfig_commit19, _runConfig_commit20;
+            logger.info('\n🔄 Auto-split enabled - creating separate commits...\n');
+            const splitResult = await executeSplitCommits({
+                splits: agenticResult.suggestedSplits,
+                isDryRun,
+                interactive: !!(((_runConfig_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.interactive) && !((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.sendit)),
+                logger});
+            if (splitResult.success) {
+                var _runConfig_commit21;
+                // Push if requested (all commits)
+                if (((_runConfig_commit21 = runConfig.commit) === null || _runConfig_commit21 === void 0 ? void 0 : _runConfig_commit21.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_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.sendit) && hasActualChanges && cached;
+    if (willCreateCommit && !((_runConfig_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.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_commit22;
+                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_commit22 = runConfig.commit) === null || _runConfig_commit22 === void 0 ? void 0 : _runConfig_commit22.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_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.skipFileCheck) && willCreateCommit) {
+        logger.warn('⚠️  Skipping file: dependency check as requested');
+    }
+    // Handle interactive mode
+    if (((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.interactive) && !isDryRun) {
+        var _runConfig_commit23;
+        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_commit23 = runConfig.commit) === null || _runConfig_commit23 === void 0 ? void 0 : _runConfig_commit23.sendit;
+        const willActuallyCommit = senditEnabled && hasActualChanges && cached;
+        if (willActuallyCommit) {
+            var _runConfig_commit24;
+            const commitAction = ((_runConfig_commit24 = runConfig.commit) === null || _runConfig_commit24 === void 0 ? void 0 : _runConfig_commit24.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_commit25, _runConfig_commit26;
+                const validatedSummary = validateString(interactiveResult.finalMessage, 'commit summary');
+                const escapedSummary = shellescape([
+                    validatedSummary
+                ]);
+                const commitCommand = ((_runConfig_commit25 = runConfig.commit) === null || _runConfig_commit25 === void 0 ? void 0 : _runConfig_commit25.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_commit26 = runConfig.commit) === null || _runConfig_commit26 === void 0 ? void 0 : _runConfig_commit26.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_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.sendit) {
+        if (isDryRun) {
+            var _runConfig_commit27, _runConfig_commit28;
+            logger.info('Would commit with message: \n\n%s\n\n', summary);
+            const commitAction = ((_runConfig_commit27 = runConfig.commit) === null || _runConfig_commit27 === void 0 ? void 0 : _runConfig_commit27.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_commit28 = runConfig.commit) === null || _runConfig_commit28 === void 0 ? void 0 : _runConfig_commit28.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_commit29;
+            const commitAction = ((_runConfig_commit29 = runConfig.commit) === null || _runConfig_commit29 === void 0 ? void 0 : _runConfig_commit29.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_commit30, _runConfig_commit31;
+                const validatedSummary = validateString(summary, 'commit summary');
+                const escapedSummary = shellescape([
+                    validatedSummary
+                ]);
+                const commitCommand = ((_runConfig_commit30 = runConfig.commit) === null || _runConfig_commit30 === void 0 ? void 0 : _runConfig_commit30.amend) ? `git commit --amend -m ${escapedSummary}` : `git commit -m ${escapedSummary}`;
+                await run(commitCommand);
+                logger.info('Commit successful!');
+                // Push if requested
+                await pushCommit((_runConfig_commit31 = runConfig.commit) === null || _runConfig_commit31 === void 0 ? void 0 : _runConfig_commit31.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$3 = async (runConfig)=>{
+    try {
+        return await executeInternal$2(runConfig);
+    } catch (error) {
+        // Import getLogger for error handling
+        const { getLogger } = await import('@eldrforge/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;
+    }
+};
+
+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
+    };
+}
+
+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`);
+};
+
+/**
+ * Execute precommit checks: lint -> build -> test
+ * Skips clean step (clean should be run separately if needed)
+ * Uses optimization to skip steps when unchanged
+ */ const execute$2 = async (runConfig)=>{
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    const packageDir = process.cwd();
+    // Default command: lint -> build -> test (no clean)
+    const defaultCommand = 'npm run lint && npm run build && npm run test';
+    // Check if package.json has a precommit script
+    let commandToRun = defaultCommand;
+    try {
+        var _packageJson_scripts;
+        const fs = await import('fs/promises');
+        const packageJsonPath = path.join(packageDir, 'package.json');
+        const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(packageJsonContent);
+        // If there's a precommit script, check what it does
+        if ((_packageJson_scripts = packageJson.scripts) === null || _packageJson_scripts === void 0 ? void 0 : _packageJson_scripts.precommit) {
+            const precommitScript = packageJson.scripts.precommit;
+            // If it includes clean, we'll optimize it out
+            // Otherwise, use the precommit script directly
+            if (!precommitScript.includes('clean')) {
+                commandToRun = `npm run precommit`;
+            } else {
+                // Use default command (lint -> build -> test) if precommit includes clean
+                commandToRun = defaultCommand;
+            }
+        }
+    } catch (error) {
+        logger.debug(`Could not read package.json, using default command: ${error.message}`);
+    }
+    if (isDryRun) {
+        logger.info(`DRY RUN: Would execute: ${commandToRun}`);
+        return `DRY RUN: Would run precommit checks: ${commandToRun}`;
+    }
+    // Optimize the command (skip clean/test if unchanged)
+    let optimizedCommand = commandToRun;
+    let optimizationInfo = null;
+    try {
+        const optimization = await optimizePrecommitCommand(packageDir, commandToRun);
+        optimizedCommand = optimization.optimizedCommand;
+        optimizationInfo = {
+            skipped: optimization.skipped,
+            reasons: optimization.reasons
+        };
+        if (optimization.skipped.clean || optimization.skipped.test) {
+            const skippedParts = [];
+            if (optimization.skipped.clean) {
+                skippedParts.push(`clean (${optimization.reasons.clean})`);
+            }
+            if (optimization.skipped.test) {
+                skippedParts.push(`test (${optimization.reasons.test})`);
+            }
+            logger.info(`⚡ Optimized: Skipped ${skippedParts.join(', ')}`);
+            if (runConfig.verbose || runConfig.debug) {
+                logger.info(`   Original: ${commandToRun}`);
+                logger.info(`   Optimized: ${optimizedCommand}`);
+            }
+        }
+    } catch (error) {
+        logger.debug(`Precommit optimization failed: ${error.message}`);
+    }
+    // Execute the optimized command
+    const timer = PerformanceTimer.start(logger, 'Precommit checks');
+    try {
+        logger.info(`🔧 Running precommit checks: ${optimizedCommand}`);
+        await run(optimizedCommand, {
+            cwd: packageDir
+        });
+        const duration = timer.end('Precommit checks');
+        const seconds = (duration / 1000).toFixed(1);
+        logger.info(`✅ Precommit checks passed (${seconds}s)`);
+        // Record test run if tests were executed (not skipped)
+        if (optimizedCommand.includes('test') && (!optimizationInfo || !optimizationInfo.skipped.test)) {
+            try {
+                await recordTestRun(packageDir);
+            } catch (error) {
+                logger.debug(`Failed to record test run: ${error.message}`);
+            }
+        }
+        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$1 = 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$1 = async (runConfig)=>{
+    try {
+        await executeInternal$1(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 = 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 = async (runConfig)=>{
+    try {
+        return await executeInternal(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;
+    }
+};
+
+export { PerformanceTimer, batchReadPackageJsonFiles, checkForFileDependencies, execute$1 as clean, collectAllDependencies, execute$3 as commit, findAllPackageJsonFiles, findPackagesByScope, isCleanNeeded, isTestNeeded, optimizePrecommitCommand, execute$2 as precommit, recordTestRun, execute as review, scanDirectoryForPackages };
+//# sourceMappingURL=index.js.map