@eldrforge/commands-git 0.1.4 → 1.0.0

package/dist/index.js

@@ -3,13 +3,13 @@ import 'dotenv/config';
 import shellescape from 'shell-escape';
 import { getDryRunLogger, DEFAULT_MAX_DIFF_BYTES, DEFAULT_EXCLUDED_PATTERNS, Diff, Files, Log, DEFAULT_OUTPUT_DIRECTORY, sanitizeDirection, toAIConfig, createStorageAdapter, createLoggerAdapter, getOutputPath, getTimestampedResponseFilename, getTimestampedRequestFilename, filterContent, getTimestampedCommitFilename, improveContentWithLLM, getLogger, getTimestampedReviewNotesFilename, getTimestampedReviewFilename } from '@eldrforge/core';
 import { ValidationError, ExternalDependencyError, CommandError, createStorage, checkForFileDependencies as checkForFileDependencies$1, logFileDependencyWarning, logFileDependencySuggestions, FileOperationError } from '@eldrforge/shared';
-import { run, validateString, safeJsonParse, validatePackageJson, unstageAll, stageFiles, verifyStagedFiles, runSecure } from '@eldrforge/git-tools';
+import { run, validateString, safeJsonParse, validatePackageJson, unstageAll, stageFiles, verifyStagedFiles, getCurrentBranch, runSecure, getGitStatusSummary } from '@eldrforge/git-tools';
 import { getRecentClosedIssuesForCommit, handleIssueCreation, getReleaseNotesContent, getIssuesContent } from '@eldrforge/github-tools';
 import { runAgenticCommit, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createCommitPrompt, createReviewPrompt, createCompletion } from '@eldrforge/ai-service';
 import path from 'path';
-import fs from 'fs/promises';
 import os from 'os';
 import { spawn } from 'child_process';
+import fs from 'fs/promises';
 
 // Helper function to read context files
 async function readContextFiles(contextFiles, logger) {
@@ -311,6 +311,41 @@ const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
         }
     }
 };
+/**
+ * Deduplicate files across splits - each file can only be in one split
+ * Later splits lose files that were already claimed by earlier splits
+ * Returns filtered splits with empty splits removed
+ */ function deduplicateSplits(splits, logger) {
+    const claimedFiles = new Set();
+    const result = [];
+    for (const split of splits){
+        // Find files in this split that haven't been claimed yet
+        const uniqueFiles = [];
+        const duplicates = [];
+        for (const file of split.files){
+            if (claimedFiles.has(file)) {
+                duplicates.push(file);
+            } else {
+                uniqueFiles.push(file);
+                claimedFiles.add(file);
+            }
+        }
+        // Log if duplicates were found
+        if (duplicates.length > 0) {
+            logger.warn(`Removing duplicate files from split "${split.message.split('\n')[0]}": ${duplicates.join(', ')}`);
+        }
+        // Only include split if it has files
+        if (uniqueFiles.length > 0) {
+            result.push({
+                ...split,
+                files: uniqueFiles
+            });
+        } else {
+            logger.warn(`Skipping empty split after deduplication: "${split.message.split('\n')[0]}"`);
+        }
+    }
+    return result;
+}
 /**
  * Interactive review of a single split before committing
  */ async function reviewSplitInteractively(split, index, total, logger) {
@@ -516,11 +551,12 @@ const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
     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 executeInternal$3 = async (runConfig)=>{
+    var _ref, _ref1, _runConfig_excludedPatterns;
+    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7, _aiConfig_commands_commit, _aiConfig_commands, _aiConfig_commands_commit1, _aiConfig_commands1, _aiConfig_commands_commit2, _aiConfig_commands2, _runConfig_commit8, _aiConfig_commands_commit3, _aiConfig_commands3, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14, _runConfig_commit15;
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
+    logger.info('COMMIT_START: Starting commit message generation | Mode: %s', isDryRun ? 'dry-run' : 'live');
     // Track if user explicitly chose to skip in interactive mode
     let userSkippedCommit = false;
     if ((_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.add) {
@@ -533,11 +569,14 @@ const executeInternal$2 = async (runConfig)=>{
         }
     }
     // Determine cached state with single, clear logic
+    logger.info('COMMIT_CHECK_STAGED: Checking for staged changes | Action: Analyzing git status');
     const cached = await determineCachedState(runConfig);
+    logger.info('COMMIT_STAGED_STATUS: Staged changes detected: %s | Cached: %s', cached ? 'yes' : 'no', cached);
     // Validate sendit state early - now returns boolean instead of throwing
     validateSenditState(runConfig, cached, isDryRun, logger);
+    logger.info('COMMIT_GENERATE_DIFF: Generating diff content | Max bytes: %d', (_ref = (_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.maxDiffBytes) !== null && _ref !== void 0 ? _ref : DEFAULT_MAX_DIFF_BYTES);
     let diffContent = '';
-    const maxDiffBytes = (_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 maxDiffBytes = (_ref1 = (_runConfig_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.maxDiffBytes) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_MAX_DIFF_BYTES;
     const options = {
         cached,
         excludedPatterns: (_runConfig_excludedPatterns = runConfig.excludedPatterns) !== null && _runConfig_excludedPatterns !== void 0 ? _runConfig_excludedPatterns : DEFAULT_EXCLUDED_PATTERNS,
@@ -545,15 +584,16 @@ const executeInternal$2 = async (runConfig)=>{
     };
     const diff = await Diff.create(options);
     diffContent = await diff.get();
+    logger.info('COMMIT_DIFF_GENERATED: Diff content generated | Size: %d bytes | Has changes: %s', diffContent.length, diffContent.trim().length > 0 ? 'yes' : 'no');
     // Check if there are actually any changes in the diff
     let hasActualChanges = diffContent.trim().length > 0;
     // If no changes found with current patterns, check for critical excluded files
     if (!hasActualChanges) {
         const criticalChanges = await Diff.hasCriticalExcludedChanges();
         if (criticalChanges.hasChanges) {
-            var _runConfig_commit15;
+            var _runConfig_commit16;
             logger.info('CRITICAL_FILES_DETECTED: No changes with exclusion patterns, but critical files modified | Files: %s | Action: May need to include critical files', criticalChanges.files.join(', '));
-            if (((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.sendit) && !isDryRun) {
+            if (((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.sendit) && !isDryRun) {
                 var _runConfig_excludedPatterns1;
                 // In sendit mode, automatically include critical files
                 logger.info('SENDIT_INCLUDING_CRITICAL: SendIt mode including critical files in diff | Purpose: Ensure all important changes are captured');
@@ -585,10 +625,10 @@ const executeInternal$2 = async (runConfig)=>{
                 }
             }
         } else {
-            var _runConfig_commit16;
+            var _runConfig_commit17;
             // No changes at all - try fallback to file content for new repositories
             logger.info('NO_CHANGES_DETECTED: No changes found in working directory | Status: clean | Action: Nothing to commit');
-            if (((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.sendit) && !isDryRun) {
+            if (((_runConfig_commit17 = runConfig.commit) === null || _runConfig_commit17 === void 0 ? void 0 : _runConfig_commit17.sendit) && !isDryRun) {
                 logger.warn('No changes detected to commit. Skipping commit operation.');
                 return 'No changes to commit.';
             } else {
@@ -607,8 +647,8 @@ const executeInternal$2 = async (runConfig)=>{
                     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) {
+                    var _runConfig_commit18;
+                    if ((_runConfig_commit18 = runConfig.commit) === null || _runConfig_commit18 === void 0 ? void 0 : _runConfig_commit18.sendit) {
                         logger.info('COMMIT_SKIPPED: Skipping commit operation | Reason: No changes detected | Action: None');
                         return 'No changes to commit.';
                     } else {
@@ -619,7 +659,7 @@ const executeInternal$2 = async (runConfig)=>{
         }
     }
     const logOptions = {
-        limit: (_runConfig_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.messageLimit
+        limit: (_runConfig_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.messageLimit
     };
     const log = await Log.create(logOptions);
     const logContext = await log.get();
@@ -654,7 +694,7 @@ const executeInternal$2 = async (runConfig)=>{
         overridePaths: runConfig.discoveredConfigDirs || [],
         overrides: runConfig.overrides || false
     };
-    const userDirection = sanitizeDirection((_runConfig_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.direction);
+    const userDirection = sanitizeDirection((_runConfig_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.direction);
     if (userDirection) {
         logger.debug('Using user direction: %s', userDirection);
     }
@@ -663,10 +703,10 @@ const executeInternal$2 = async (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);
+    const contextFromFiles = await readContextFiles((_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.contextFiles, logger);
     // Combine file context with existing context
     const combinedContext = [
-        (_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.context,
+        (_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.context,
         contextFromFiles
     ].filter(Boolean).join('\n\n---\n\n');
     // Define promptContext for use in interactive improvements
@@ -676,7 +716,7 @@ const executeInternal$2 = async (runConfig)=>{
         directories: runConfig.contextDirectories
     };
     // Announce self-reflection if enabled
-    if ((_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.selfReflection) {
+    if ((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.selfReflection) {
         logger.info('📊 Self-reflection enabled - detailed analysis will be generated');
     }
     // Get list of changed files
@@ -685,30 +725,31 @@ const executeInternal$2 = async (runConfig)=>{
     const changedFiles = changedFilesOutput.split('\n').filter((f)=>f.trim().length > 0);
     logger.debug('Changed files for analysis: %d files', changedFiles.length);
     // Run agentic commit generation
+    logger.info('COMMIT_AI_GENERATION: Starting AI-powered commit message generation | Model: %s | Reasoning: %s | Files: %d', ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_commit = _aiConfig_commands.commit) === null || _aiConfig_commands_commit === void 0 ? void 0 : _aiConfig_commands_commit.model) || aiConfig.model || 'gpt-4o-mini', ((_aiConfig_commands1 = aiConfig.commands) === null || _aiConfig_commands1 === void 0 ? void 0 : (_aiConfig_commands_commit1 = _aiConfig_commands1.commit) === null || _aiConfig_commands_commit1 === void 0 ? void 0 : _aiConfig_commands_commit1.reasoning) || aiConfig.reasoning || 'low', changedFiles.length);
     const agenticResult = await runAgenticCommit({
         changedFiles,
         diffContent,
         userDirection,
         logContext,
-        model: ((_aiConfig_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,
+        model: ((_aiConfig_commands2 = aiConfig.commands) === null || _aiConfig_commands2 === void 0 ? void 0 : (_aiConfig_commands_commit2 = _aiConfig_commands2.commit) === null || _aiConfig_commands_commit2 === void 0 ? void 0 : _aiConfig_commands_commit2.model) || aiConfig.model,
+        maxIterations: ((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.maxAgenticIterations) || 10,
         debug: runConfig.debug,
         debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('commit')),
         debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('commit')),
         storage: aiStorageAdapter,
         logger: aiLogger,
-        openaiReasoning: ((_aiConfig_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
+        openaiReasoning: ((_aiConfig_commands3 = aiConfig.commands) === null || _aiConfig_commands3 === void 0 ? void 0 : (_aiConfig_commands_commit3 = _aiConfig_commands3.commit) === null || _aiConfig_commands_commit3 === void 0 ? void 0 : _aiConfig_commands_commit3.reasoning) || aiConfig.reasoning
     });
     const iterations = agenticResult.iterations || 0;
     const toolCalls = agenticResult.toolCallsExecuted || 0;
     logger.info(`🔍 Analysis complete: ${iterations} iterations, ${toolCalls} tool calls`);
     // Generate self-reflection output if enabled
-    if ((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.selfReflection) {
+    if ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.selfReflection) {
         await generateSelfReflection(agenticResult, outputDirectory, storage, logger);
     }
     // Check for suggested splits
-    if (agenticResult.suggestedSplits.length > 1 && ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.allowCommitSplitting)) {
-        var _runConfig_commit18;
+    if (agenticResult.suggestedSplits.length > 1 && ((_runConfig_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.allowCommitSplitting)) {
+        var _runConfig_commit19;
         logger.info('\n📋 AI suggests splitting this into %d commits:', agenticResult.suggestedSplits.length);
         for(let i = 0; i < agenticResult.suggestedSplits.length; i++){
             const split = agenticResult.suggestedSplits[i];
@@ -718,19 +759,25 @@ const executeInternal$2 = async (runConfig)=>{
             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
+        const autoSplitEnabled = ((_runConfig_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.autoSplit) !== false; // Default to true
         if (autoSplitEnabled) {
-            var _runConfig_commit19, _runConfig_commit20;
+            var _runConfig_commit20, _runConfig_commit21;
             logger.info('\n🔄 Auto-split enabled - creating separate commits...\n');
+            // Deduplicate files across splits to prevent staging errors
+            // (AI sometimes suggests the same file in multiple splits)
+            const deduplicatedSplits = deduplicateSplits(agenticResult.suggestedSplits, logger);
+            if (deduplicatedSplits.length === 0) {
+                throw new CommandError('All splits were empty after deduplication - no files to commit', 'SPLIT_EMPTY', false);
+            }
             const splitResult = await executeSplitCommits({
-                splits: agenticResult.suggestedSplits,
+                splits: deduplicatedSplits,
                 isDryRun,
-                interactive: !!(((_runConfig_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.interactive) && !((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.sendit)),
+                interactive: !!(((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.interactive) && !((_runConfig_commit21 = runConfig.commit) === null || _runConfig_commit21 === void 0 ? void 0 : _runConfig_commit21.sendit)),
                 logger});
             if (splitResult.success) {
-                var _runConfig_commit21;
+                var _runConfig_commit22;
                 // Push if requested (all commits)
-                if (((_runConfig_commit21 = runConfig.commit) === null || _runConfig_commit21 === void 0 ? void 0 : _runConfig_commit21.push) && !isDryRun) {
+                if (((_runConfig_commit22 = runConfig.commit) === null || _runConfig_commit22 === void 0 ? void 0 : _runConfig_commit22.push) && !isDryRun) {
                     await pushCommit(runConfig.commit.push, logger, isDryRun);
                 }
                 return formatSplitCommitSummary(splitResult);
@@ -755,13 +802,13 @@ const executeInternal$2 = async (runConfig)=>{
     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) {
+    const willCreateCommit = ((_runConfig_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.sendit) && hasActualChanges && cached;
+    if (willCreateCommit && !((_runConfig_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.skipFileCheck) && !isDryRun) {
         logger.debug('Checking for file: dependencies before commit operation...');
         try {
             const fileDependencyIssues = await checkForFileDependencies$1(storage, process.cwd());
             if (fileDependencyIssues.length > 0) {
-                var _runConfig_commit22;
+                var _runConfig_commit23;
                 logger.error('🚫 COMMIT BLOCKED: Found file: dependencies that should not be committed!');
                 logger.error('');
                 logFileDependencyWarning(fileDependencyIssues, 'commit');
@@ -769,7 +816,7 @@ const executeInternal$2 = async (runConfig)=>{
                 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) {
+                if ((_runConfig_commit23 = runConfig.commit) === null || _runConfig_commit23 === void 0 ? void 0 : _runConfig_commit23.sendit) {
                     logger.error('To bypass this check, use: kodrdriv commit --skip-file-check --sendit');
                 } else {
                     logger.error('To bypass this check, add skipFileCheck: true to your commit configuration');
@@ -781,12 +828,12 @@ const executeInternal$2 = async (runConfig)=>{
             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) {
+    } else if (((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.skipFileCheck) && willCreateCommit) {
         logger.warn('⚠️  Skipping file: dependency check as requested');
     }
     // Handle interactive mode
-    if (((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.interactive) && !isDryRun) {
-        var _runConfig_commit23;
+    if (((_runConfig_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.interactive) && !isDryRun) {
+        var _runConfig_commit24;
         requireTTY('Interactive mode requires a terminal. Use --sendit or --dry-run instead.');
         const interactiveResult = await handleInteractiveCommitFeedback(summary, runConfig, promptConfig, promptContext, outputDirectory, storage, diffContent, hasActualChanges, cached);
         if (interactiveResult.action === 'skip') {
@@ -796,23 +843,23 @@ const executeInternal$2 = async (runConfig)=>{
             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 senditEnabled = (_runConfig_commit24 = runConfig.commit) === null || _runConfig_commit24 === void 0 ? void 0 : _runConfig_commit24.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';
+            var _runConfig_commit25;
+            const commitAction = ((_runConfig_commit25 = runConfig.commit) === null || _runConfig_commit25 === void 0 ? void 0 : _runConfig_commit25.amend) ? 'amending last commit' : 'committing';
             logger.info('SENDIT_EXECUTING: SendIt enabled, executing commit action | Action: %s | Message Length: %d | Final Message: \n\n%s\n\n', commitAction.charAt(0).toUpperCase() + commitAction.slice(1), interactiveResult.finalMessage.length, interactiveResult.finalMessage);
             try {
-                var _runConfig_commit25, _runConfig_commit26;
+                var _runConfig_commit26, _runConfig_commit27;
                 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}`;
+                const commitCommand = ((_runConfig_commit26 = runConfig.commit) === null || _runConfig_commit26 === void 0 ? void 0 : _runConfig_commit26.amend) ? `git commit --amend -m ${escapedSummary}` : `git commit -m ${escapedSummary}`;
                 await run(commitCommand);
                 logger.info('COMMIT_SUCCESS: Commit operation completed successfully | Status: committed | Action: Changes saved to repository');
                 // Push if requested
-                await pushCommit((_runConfig_commit26 = runConfig.commit) === null || _runConfig_commit26 === void 0 ? void 0 : _runConfig_commit26.push, logger, isDryRun);
+                await pushCommit((_runConfig_commit27 = runConfig.commit) === null || _runConfig_commit27 === void 0 ? void 0 : _runConfig_commit27.push, logger, isDryRun);
             } catch (error) {
                 logger.error('Failed to commit:', error);
                 throw new ExternalDependencyError('Failed to create commit', 'git', error);
@@ -835,32 +882,32 @@ const executeInternal$2 = async (runConfig)=>{
         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 ((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.sendit) {
         if (isDryRun) {
-            var _runConfig_commit27, _runConfig_commit28;
+            var _runConfig_commit28, _runConfig_commit29;
             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>';
+            const commitAction = ((_runConfig_commit28 = runConfig.commit) === null || _runConfig_commit28 === void 0 ? void 0 : _runConfig_commit28.amend) ? 'git commit --amend -m <generated-message>' : 'git commit -m <generated-message>';
             logger.info('Would execute: %s', commitAction);
             // Show push command in dry run if requested
-            if ((_runConfig_commit28 = runConfig.commit) === null || _runConfig_commit28 === void 0 ? void 0 : _runConfig_commit28.push) {
+            if ((_runConfig_commit29 = runConfig.commit) === null || _runConfig_commit29 === void 0 ? void 0 : _runConfig_commit29.push) {
                 const remote = typeof runConfig.commit.push === 'string' ? runConfig.commit.push : 'origin';
                 logger.info('Would push to %s with: git push %s', remote, remote);
             }
         } else if (hasActualChanges && cached) {
-            var _runConfig_commit29;
-            const commitAction = ((_runConfig_commit29 = runConfig.commit) === null || _runConfig_commit29 === void 0 ? void 0 : _runConfig_commit29.amend) ? 'amending commit' : 'committing';
+            var _runConfig_commit30;
+            const commitAction = ((_runConfig_commit30 = runConfig.commit) === null || _runConfig_commit30 === void 0 ? void 0 : _runConfig_commit30.amend) ? 'amending commit' : 'committing';
             logger.info('SendIt mode enabled. %s with message: \n\n%s\n\n', commitAction.charAt(0).toUpperCase() + commitAction.slice(1), summary);
             try {
-                var _runConfig_commit30, _runConfig_commit31;
+                var _runConfig_commit31, _runConfig_commit32;
                 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}`;
+                const commitCommand = ((_runConfig_commit31 = runConfig.commit) === null || _runConfig_commit31 === void 0 ? void 0 : _runConfig_commit31.amend) ? `git commit --amend -m ${escapedSummary}` : `git commit -m ${escapedSummary}`;
                 await run(commitCommand);
                 logger.info('Commit successful!');
                 // Push if requested
-                await pushCommit((_runConfig_commit31 = runConfig.commit) === null || _runConfig_commit31 === void 0 ? void 0 : _runConfig_commit31.push, logger, isDryRun);
+                await pushCommit((_runConfig_commit32 = runConfig.commit) === null || _runConfig_commit32 === void 0 ? void 0 : _runConfig_commit32.push, logger, isDryRun);
             } catch (error) {
                 logger.error('Failed to commit:', error);
                 throw new ExternalDependencyError('Failed to create commit', 'git', error);
@@ -876,9 +923,9 @@ const executeInternal$2 = async (runConfig)=>{
     }
     return summary;
 };
-const execute$3 = async (runConfig)=>{
+const execute$4 = async (runConfig)=>{
     try {
-        return await executeInternal$2(runConfig);
+        return await executeInternal$3(runConfig);
     } catch (error) {
         // Import getLogger for error handling
         const { getLogger } = await import('@eldrforge/core');
@@ -898,547 +945,245 @@ const execute$3 = async (runConfig)=>{
     }
 };
 
-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
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-        return stdout.trim();
-    } catch  {
-        return null;
+    } else {
+        obj[key] = value;
     }
+    return obj;
 }
-/**
- * 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'
-        };
+// Performance timing helper
+class PerformanceTimer {
+    static start(logger, operation) {
+        logger.verbose(`⏱️  Starting: ${operation}`);
+        return new PerformanceTimer(logger);
     }
-    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}`
-        };
+    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();
     }
 }
-/**
- * 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) {
+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 {
-                needed: false,
-                reason: 'dist directory does not exist'
+                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 [];
         }
-        // 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)) {
+            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;
                 }
-                // 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;
+                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 {
-                needed: false,
-                reason: 'dist directory is up to date with source files'
-            };
+            return foundPaths;
         } 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);
+            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 {
-                    const dirStats = await fs.stat(dirPath);
-                    if (dirStats.mtimeMs > distMtime) {
-                        return {
-                            needed: true,
-                            reason: `${dir} directory is newer than dist`
-                        };
+                    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  {
-                    continue;
+                } 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}`);
                 }
             }
-            // Conservative: if we can't verify, assume clean is needed
-            return {
-                needed: true,
-                reason: 'Could not verify dist freshness, cleaning to be safe'
-            };
         }
+        processTimer.end(`Processed ${items.length} directories in ${batches.length} batches`);
+        logger.verbose(`Found ${packageMap.size} packages in ${items.length} subdirectories`);
     } 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}`
-        };
+        logger.warn(`PERFORMANCE_DIR_READ_FAILED: Unable to read directory | Directory: ${absoluteRootDir} | Error: ${error}`);
     }
-}
-/**
- * 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
-            };
+    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 {
-            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'
+            scope,
+            packages: matchingPackages
         };
-        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;
-            }
+    });
+    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);
         }
     }
-    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}`);
+    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`);
@@ -1499,87 +1244,90 @@ const checkForFileDependencies = (packageJsonFiles)=>{
 };
 
 /**
- * Execute precommit checks: lint -> build -> test
- * Skips clean step (clean should be run separately if needed)
- * Uses optimization to skip steps when unchanged
- */ const execute$2 = async (runConfig)=>{
-    const logger = getLogger();
+ * Check if running in MCP server mode
+ */ const isMcpMode = ()=>process.env.KODRDRIV_MCP_SERVER === 'true';
+/**
+ * Get an MCP-aware logger that suppresses info/warn/debug output in MCP mode.
+ * Errors are always logged since they indicate problems that need attention.
+ */ const getMcpAwareLogger = ()=>{
+    const coreLogger = getLogger();
+    if (!isMcpMode()) {
+        // In normal mode, just return the core logger
+        return coreLogger;
+    }
+    // In MCP mode, wrap the logger to suppress non-error output
+    return {
+        info: (_message, ..._args)=>{},
+        warn: (_message, ..._args)=>{},
+        debug: (_message, ..._args)=>{},
+        verbose: (_message, ..._args)=>{},
+        silly: (_message, ..._args)=>{},
+        // Always log errors - they indicate real problems
+        error: (message, ...args)=>coreLogger.error(message, ...args)
+    };
+};
+
+/**
+ * Execute precommit checks by running the package's precommit script.
+ * Expects the package to have a "precommit" script in package.json.
+ */ const execute$3 = async (runConfig)=>{
+    var _runConfig_precommit, _packageJson_scripts;
+    const logger = getMcpAwareLogger();
     const isDryRun = runConfig.dryRun || false;
     const packageDir = process.cwd();
-    // 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;
+    const shouldFix = ((_runConfig_precommit = runConfig.precommit) === null || _runConfig_precommit === void 0 ? void 0 : _runConfig_precommit.fix) || false;
+    // Verify precommit script exists
+    const fs = await import('fs/promises');
+    const packageJsonPath = path.join(packageDir, 'package.json');
+    let packageName = packageDir;
+    let packageJson;
     try {
-        var _packageJson_scripts;
-        const fs = await import('fs/promises');
-        const packageJsonPath = path.join(packageDir, 'package.json');
+        var _packageJson_scripts1;
         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;
-            }
+        packageJson = JSON.parse(packageJsonContent);
+        packageName = packageJson.name || packageDir;
+        if (!((_packageJson_scripts1 = packageJson.scripts) === null || _packageJson_scripts1 === void 0 ? void 0 : _packageJson_scripts1.precommit)) {
+            throw new Error(`Package "${packageName}" is missing a "precommit" script in package.json`);
         }
     } catch (error) {
-        logger.debug(`Could not read package.json, using default command: ${error.message}`);
+        if (error.code === 'ENOENT') {
+            throw new Error(`No package.json found at ${packageJsonPath}`);
+        }
+        throw error;
+    }
+    // If --fix is enabled, try to run lint --fix before precommit
+    if (shouldFix && ((_packageJson_scripts = packageJson.scripts) === null || _packageJson_scripts === void 0 ? void 0 : _packageJson_scripts.lint)) {
+        const lintFixCommand = 'npm run lint -- --fix';
+        if (isDryRun) {
+            logger.info(`DRY RUN: Would execute: ${lintFixCommand}`);
+        } else {
+            try {
+                logger.info(`🔧 Running lint --fix before precommit checks: ${lintFixCommand}`);
+                await run(lintFixCommand, {
+                    cwd: packageDir
+                });
+                logger.info(`✅ Lint fixes applied`);
+            } catch (error) {
+                // Log warning but continue with precommit - lint --fix may fail on some issues
+                logger.warn(`⚠️  Lint --fix had issues (continuing with precommit): ${error.message}`);
+            }
+        }
     }
+    const commandToRun = 'npm run precommit';
     if (isDryRun) {
         logger.info(`DRY RUN: Would execute: ${commandToRun}`);
         return `DRY RUN: Would run precommit checks: ${commandToRun}`;
     }
-    // Optimize the command (skip clean/test if unchanged)
-    let optimizedCommand = commandToRun;
-    let optimizationInfo = null;
+    // Execute the precommit script
+    const timer = PerformanceTimer.start(logger, 'Precommit checks');
     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, {
+        logger.info(`🔧 Running precommit checks: ${commandToRun}`);
+        await run(commandToRun, {
             cwd: packageDir
         });
         const duration = timer.end('Precommit checks');
         const seconds = (duration / 1000).toFixed(1);
         logger.info(`✅ Precommit checks passed (${seconds}s)`);
-        // 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');
@@ -1588,7 +1336,7 @@ const checkForFileDependencies = (packageJsonFiles)=>{
     }
 };
 
-const executeInternal$1 = async (runConfig)=>{
+const executeInternal$2 = async (runConfig)=>{
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     const storage = createStorage();
@@ -1612,9 +1360,9 @@ const executeInternal$1 = async (runConfig)=>{
         throw new FileOperationError('Failed to remove output directory', outputDirectory, error);
     }
 };
-const execute$1 = async (runConfig)=>{
+const execute$2 = async (runConfig)=>{
     try {
-        await executeInternal$1(runConfig);
+        await executeInternal$2(runConfig);
     } catch (error) {
         const logger = getLogger();
         if (error instanceof FileOperationError) {
@@ -2083,7 +1831,7 @@ const processSingleReview = async (reviewNote, runConfig, outputDirectory)=>{
     }
     return analysisResult;
 };
-const executeInternal = async (runConfig)=>{
+const executeInternal$1 = async (runConfig)=>{
     var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review4, _runConfig_review5, _runConfig_review6, _runConfig_review7, _runConfig_review8, _runConfig_review9, _runConfig_review10, _runConfig_review11, _runConfig_review12, _runConfig_review13, _runConfig_review14, _runConfig_review15, _runConfig_review16, _runConfig_review17, _runConfig_review18;
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
@@ -2204,143 +1952,1025 @@ const executeInternal = async (runConfig)=>{
                 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);
+            logger.error(`Failed to capture review note via editor: ${error.message}`);
+            throw error;
+        } finally{
+            // Always clean up the temp file
+            if (tmpFilePath) {
+                await cleanupTempFile(tmpFilePath);
+            }
+        }
+        reviewFiles = [
+            'editor input'
+        ];
+    }
+    if (!reviewNote || !reviewNote.trim()) {
+        throw new ValidationError('No review note provided or captured');
+    }
+    logger.info('📝 Starting review analysis...');
+    logger.debug('Review note: %s', reviewNote);
+    logger.debug('Review note length: %d characters', reviewNote.length);
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = createStorage();
+    await storage.ensureDirectory(outputDirectory);
+    // Save timestamped copy of review notes to output directory
+    try {
+        const reviewNotesFilename = getTimestampedReviewNotesFilename();
+        const reviewNotesPath = getOutputPath(outputDirectory, reviewNotesFilename);
+        const reviewNotesContent = `# Review Notes\n\n${reviewNote}\n\n`;
+        await safeWriteFile(reviewNotesPath, reviewNotesContent);
+        logger.debug('Saved timestamped review notes: %s', reviewNotesPath);
+    } catch (error) {
+        logger.warn('Failed to save review notes: %s', error.message);
+    }
+    // Phase 1: File selection (only for directory mode)
+    let selectedFiles;
+    if ((_runConfig_review16 = runConfig.review) === null || _runConfig_review16 === void 0 ? void 0 : _runConfig_review16.directory) {
+        var _runConfig_review26;
+        selectedFiles = await selectFilesForProcessing(reviewFiles, ((_runConfig_review26 = runConfig.review) === null || _runConfig_review26 === void 0 ? void 0 : _runConfig_review26.sendit) || false);
+    } else {
+        // For single note mode, just use the note directly
+        selectedFiles = [
+            'single note'
+        ];
+    }
+    // Phase 2: Process selected files in order
+    logger.info(`\n📝 Starting analysis phase...`);
+    const results = [];
+    const processedFiles = [];
+    if ((_runConfig_review17 = runConfig.review) === null || _runConfig_review17 === void 0 ? void 0 : _runConfig_review17.directory) {
+        // Directory mode: process each selected file
+        for(let i = 0; i < selectedFiles.length; i++){
+            const filePath = selectedFiles[i];
+            try {
+                logger.info(`📝 Processing file ${i + 1}/${selectedFiles.length}: ${filePath}`);
+                const fileNote = await readReviewNoteFromFile(filePath);
+                const fileResult = await processSingleReview(fileNote, runConfig, outputDirectory);
+                results.push(fileResult);
+                processedFiles.push(filePath);
+            } catch (error) {
+                // Check if this is a critical error that should be propagated
+                if (error.message.includes('Too many context gathering errors')) {
+                    throw error; // Propagate critical context errors
+                }
+                logger.warn(`Failed to process file ${filePath}: ${error.message}`);
+            // Continue with other files for non-critical errors
+            }
+        }
+    } else {
+        // Single note mode: process the note directly
+        try {
+            logger.info(`📝 Processing single review note`);
+            const fileResult = await processSingleReview(reviewNote, runConfig, outputDirectory);
+            results.push(fileResult);
+            processedFiles.push('single note');
+        } catch (error) {
+            logger.warn(`Failed to process review note: ${error.message}`);
+            throw error; // Re-throw for single note mode since there's only one item
+        }
+    }
+    if (results.length === 0) {
+        throw new ValidationError('No files were processed successfully');
+    }
+    // Combine results if we processed multiple files
+    let analysisResult;
+    if (results.length === 1) {
+        analysisResult = results[0];
+    } else {
+        logger.info(`✅ Successfully processed ${results.length} review files`);
+        // Create a combined summary
+        const totalIssues = results.reduce((sum, result)=>sum + result.totalIssues, 0);
+        const allIssues = results.flatMap((result)=>result.issues || []);
+        analysisResult = {
+            summary: `Combined analysis of ${results.length} review files. Total issues found: ${totalIssues}`,
+            totalIssues,
+            issues: allIssues
+        };
+        // Save combined results
+        try {
+            const combinedFilename = getTimestampedReviewFilename();
+            const combinedPath = getOutputPath(outputDirectory, combinedFilename);
+            const combinedContent = `# Combined Review Analysis Result\n\n` + `## Summary\n${analysisResult.summary}\n\n` + `## Total Issues Found\n${totalIssues}\n\n` + `## Files Processed\n${processedFiles.join('\n')}\n\n` + `## Issues\n\n${JSON.stringify(allIssues, null, 2)}\n\n` + `---\n\n*Combined analysis completed at ${new Date().toISOString()}*`;
+            await safeWriteFile(combinedPath, combinedContent);
+            logger.debug('Saved combined review analysis: %s', combinedPath);
+        } catch (error) {
+            logger.warn('Failed to save combined review analysis: %s', error.message);
+        }
+    }
+    // Handle GitHub issue creation using the issues module
+    const senditMode = ((_runConfig_review18 = runConfig.review) === null || _runConfig_review18 === void 0 ? void 0 : _runConfig_review18.sendit) || false;
+    return await handleIssueCreation(analysisResult, senditMode);
+};
+const execute$1 = async (runConfig)=>{
+    try {
+        return await executeInternal$1(runConfig);
+    } catch (error) {
+        const logger = getLogger();
+        if (error instanceof ValidationError) {
+            logger.error(`review failed: ${error.message}`);
+            throw error;
+        }
+        if (error instanceof FileOperationError) {
+            logger.error(`review failed: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            throw error;
+        }
+        if (error instanceof CommandError) {
+            logger.error(`review failed: ${error.message}`);
+            if (error.cause && typeof error.cause === 'object' && 'message' in error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            throw error;
+        }
+        // Unexpected errors
+        logger.error(`review encountered unexpected error: ${error.message}`);
+        throw error;
+    }
+};
+
+// Patterns for files that can be auto-resolved
+const AUTO_RESOLVABLE_PATTERNS = {
+    // Package lock files - just regenerate
+    packageLock: /^package-lock\.json$/,
+    yarnLock: /^yarn\.lock$/,
+    pnpmLock: /^pnpm-lock\.yaml$/,
+    // Generated files - take theirs and regenerate
+    dist: /^dist\//,
+    coverage: /^coverage\//,
+    nodeModules: /^node_modules\//,
+    // Build artifacts
+    buildOutput: /\.(js\.map|d\.ts)$/
+};
+/**
+ * Check if a file can be auto-resolved
+ */ function canAutoResolve(filename) {
+    if (AUTO_RESOLVABLE_PATTERNS.packageLock.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'regenerate-lock'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.yarnLock.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'regenerate-lock'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.pnpmLock.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'regenerate-lock'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.dist.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs-regenerate'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.coverage.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.nodeModules.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs'
+        };
+    }
+    if (AUTO_RESOLVABLE_PATTERNS.buildOutput.test(filename)) {
+        return {
+            canResolve: true,
+            strategy: 'take-theirs-regenerate'
+        };
+    }
+    return {
+        canResolve: false,
+        strategy: 'manual'
+    };
+}
+/**
+ * Check if this is a package.json version conflict that can be auto-resolved
+ */ async function tryResolvePackageJsonConflict(filepath, logger) {
+    const storage = createStorage();
+    try {
+        const content = await storage.readFile(filepath, 'utf-8');
+        // Check if this is actually a conflict file
+        if (!content.includes('<<<<<<<') || !content.includes('>>>>>>>')) {
+            return {
+                resolved: false,
+                error: 'Not a conflict file'
+            };
+        }
+        // Try to parse ours and theirs versions
+        const oursMatch = content.match(/<<<<<<< .*?\n([\s\S]*?)=======\n/);
+        const theirsMatch = content.match(/=======\n([\s\S]*?)>>>>>>> /);
+        if (!oursMatch || !theirsMatch) {
+            return {
+                resolved: false,
+                error: 'Cannot parse conflict markers'
+            };
+        }
+        // For package.json, if only version differs, take the higher version
+        // This is a simplified heuristic - real conflicts may need more logic
+        const oursPart = oursMatch[1];
+        const theirsPart = theirsMatch[1];
+        // Check if this is just a version conflict
+        const versionPattern = /"version":\s*"([^"]+)"/;
+        const oursVersion = oursPart.match(versionPattern);
+        const theirsVersion = theirsPart.match(versionPattern);
+        if (oursVersion && theirsVersion) {
+            // Both have versions - take higher one
+            const semver = await import('semver');
+            const higher = semver.gt(oursVersion[1].replace(/-.*$/, ''), theirsVersion[1].replace(/-.*$/, '')) ? oursVersion[1] : theirsVersion[1];
+            // Replace the conflicted version with the higher one
+            let resolvedContent = content;
+            // Simple approach: take theirs but use higher version
+            // Remove conflict markers and use theirs as base
+            resolvedContent = content.replace(/<<<<<<< .*?\n[\s\S]*?=======\n([\s\S]*?)>>>>>>> .*?\n/g, '$1');
+            // Update version to higher one
+            resolvedContent = resolvedContent.replace(/"version":\s*"[^"]+"/, `"version": "${higher}"`);
+            await storage.writeFile(filepath, resolvedContent, 'utf-8');
+            logger.info(`PULL_RESOLVED_VERSION: Auto-resolved version conflict | File: ${filepath} | Version: ${higher}`);
+            return {
+                resolved: true
+            };
+        }
+        return {
+            resolved: false,
+            error: 'Complex conflict - not just version'
+        };
+    } catch (error) {
+        return {
+            resolved: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Resolve a single conflict file
+ */ async function resolveConflict(filepath, strategy, logger, isDryRun) {
+    if (isDryRun) {
+        logger.info(`PULL_RESOLVE_DRY_RUN: Would resolve conflict | File: ${filepath} | Strategy: ${strategy}`);
+        return {
+            file: filepath,
+            resolved: true,
+            strategy
+        };
+    }
+    try {
+        switch(strategy){
+            case 'regenerate-lock':
+                {
+                    // Accept theirs and regenerate
+                    await runSecure('git', [
+                        'checkout',
+                        '--theirs',
+                        filepath
+                    ]);
+                    await runSecure('git', [
+                        'add',
+                        filepath
+                    ]);
+                    logger.info(`PULL_CONFLICT_RESOLVED: Accepted remote lock file | File: ${filepath} | Strategy: ${strategy} | Note: Will regenerate after pull`);
+                    return {
+                        file: filepath,
+                        resolved: true,
+                        strategy
+                    };
+                }
+            case 'take-theirs':
+            case 'take-theirs-regenerate':
+                {
+                    await runSecure('git', [
+                        'checkout',
+                        '--theirs',
+                        filepath
+                    ]);
+                    await runSecure('git', [
+                        'add',
+                        filepath
+                    ]);
+                    logger.info(`PULL_CONFLICT_RESOLVED: Accepted remote version | File: ${filepath} | Strategy: ${strategy}`);
+                    return {
+                        file: filepath,
+                        resolved: true,
+                        strategy
+                    };
+                }
+            case 'version-bump':
+                {
+                    const result = await tryResolvePackageJsonConflict(filepath, logger);
+                    if (result.resolved) {
+                        await runSecure('git', [
+                            'add',
+                            filepath
+                        ]);
+                        return {
+                            file: filepath,
+                            resolved: true,
+                            strategy
+                        };
+                    }
+                    return {
+                        file: filepath,
+                        resolved: false,
+                        strategy,
+                        error: result.error
+                    };
+                }
+            default:
+                return {
+                    file: filepath,
+                    resolved: false,
+                    strategy,
+                    error: 'Unknown resolution strategy'
+                };
+        }
+    } catch (error) {
+        return {
+            file: filepath,
+            resolved: false,
+            strategy,
+            error: error.message
+        };
+    }
+}
+/**
+ * Get list of conflicted files
+ */ async function getConflictedFiles() {
+    try {
+        const { stdout } = await runSecure('git', [
+            'diff',
+            '--name-only',
+            '--diff-filter=U'
+        ]);
+        return stdout.trim().split('\n').filter((f)=>f.trim());
+    } catch  {
+        return [];
+    }
+}
+/**
+ * Try to auto-resolve all conflicts
+ */ async function autoResolveConflicts(logger, isDryRun) {
+    const conflictedFiles = await getConflictedFiles();
+    const resolved = [];
+    const manual = [];
+    for (const file of conflictedFiles){
+        const { canResolve, strategy } = canAutoResolve(file);
+        // Special handling for package.json
+        if (file === 'package.json' || file.endsWith('/package.json')) {
+            const result = await resolveConflict(file, 'version-bump', logger, isDryRun);
+            if (result.resolved) {
+                resolved.push(file);
+            } else {
+                manual.push(file);
+            }
+            continue;
+        }
+        if (canResolve) {
+            const result = await resolveConflict(file, strategy, logger, isDryRun);
+            if (result.resolved) {
+                resolved.push(file);
+            } else {
+                manual.push(file);
+            }
+        } else {
+            manual.push(file);
+        }
+    }
+    return {
+        resolved,
+        manual
+    };
+}
+/**
+ * Stash local changes if any
+ */ async function stashIfNeeded(logger, isDryRun) {
+    const status = await getGitStatusSummary();
+    if (status.hasUncommittedChanges || status.hasUnstagedFiles) {
+        const changeCount = status.uncommittedCount + status.unstagedCount;
+        logger.info(`PULL_STASHING: Stashing ${changeCount} local changes before pull | Staged: ${status.uncommittedCount} | Unstaged: ${status.unstagedCount}`);
+        if (!isDryRun) {
+            await runSecure('git', [
+                'stash',
+                'push',
+                '-m',
+                `kodrdriv-pull-auto-stash-${Date.now()}`
+            ]);
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Apply stash if we created one
+ */ async function applyStashIfNeeded(didStash, logger, isDryRun) {
+    if (!didStash) return false;
+    logger.info('PULL_STASH_POP: Restoring stashed changes');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'stash',
+                'pop'
+            ]);
+            return true;
+        } catch (error) {
+            logger.warn(`PULL_STASH_CONFLICT: Stash pop had conflicts | Error: ${error.message} | Action: Stash preserved, manual intervention needed`);
+            // Don't fail - user can manually resolve stash conflicts
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Regenerate lock files after pull
+ */ async function regenerateLockFiles(resolvedFiles, logger, isDryRun) {
+    const needsRegenerate = resolvedFiles.some((f)=>f === 'package-lock.json' || f.endsWith('/package-lock.json'));
+    if (needsRegenerate) {
+        logger.info('PULL_REGENERATE_LOCK: Regenerating package-lock.json');
+        if (!isDryRun) {
+            try {
+                await run('npm install');
+                logger.info('PULL_REGENERATE_SUCCESS: Lock file regenerated successfully');
+            } catch (error) {
+                logger.warn(`PULL_REGENERATE_FAILED: Failed to regenerate lock file | Error: ${error.message}`);
+            }
+        }
+    }
+}
+/**
+ * Main pull execution
+ */ async function executePull(remote, branch, logger, isDryRun) {
+    const currentBranch = await getCurrentBranch();
+    const targetBranch = branch || currentBranch;
+    logger.info(`PULL_STARTING: Pulling changes | Remote: ${remote} | Branch: ${targetBranch} | Current: ${currentBranch}`);
+    // Step 1: Stash any local changes
+    const didStash = await stashIfNeeded(logger, isDryRun);
+    // Step 2: Fetch first to see what's coming
+    logger.info(`PULL_FETCH: Fetching from ${remote}`);
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'fetch',
+                remote,
+                targetBranch
+            ]);
+        } catch (error) {
+            logger.error(`PULL_FETCH_FAILED: Failed to fetch | Error: ${error.message}`);
+            if (didStash) await applyStashIfNeeded(true, logger, isDryRun);
+            return {
+                success: false,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'failed',
+                message: `Fetch failed: ${error.message}`
+            };
+        }
+    }
+    // Step 3: Try fast-forward first
+    logger.info('PULL_STRATEGY: Attempting fast-forward merge');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'merge',
+                '--ff-only',
+                `${remote}/${targetBranch}`
+            ]);
+            await applyStashIfNeeded(didStash, logger, isDryRun);
+            logger.info('PULL_SUCCESS: Fast-forward merge successful');
+            return {
+                success: true,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'fast-forward',
+                message: 'Fast-forward merge successful'
+            };
+        } catch  {
+            logger.info('PULL_FF_FAILED: Fast-forward not possible, trying rebase');
+        }
+    }
+    // Step 4: Try rebase
+    logger.info('PULL_STRATEGY: Attempting rebase');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'rebase',
+                `${remote}/${targetBranch}`
+            ]);
+            await applyStashIfNeeded(didStash, logger, isDryRun);
+            logger.info('PULL_SUCCESS: Rebase successful');
+            return {
+                success: true,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'rebase',
+                message: 'Rebase successful'
+            };
+        } catch  {
+            // Check if rebase is in progress with conflicts
+            const conflictedFiles = await getConflictedFiles();
+            if (conflictedFiles.length > 0) {
+                logger.info(`PULL_CONFLICTS: Rebase has ${conflictedFiles.length} conflicts, attempting auto-resolution`);
+                // Step 5: Try to auto-resolve conflicts
+                const { resolved, manual } = await autoResolveConflicts(logger, isDryRun);
+                if (manual.length === 0) {
+                    // All conflicts resolved, continue rebase
+                    logger.info('PULL_ALL_RESOLVED: All conflicts auto-resolved, continuing rebase');
+                    try {
+                        await runSecure('git', [
+                            'rebase',
+                            '--continue'
+                        ]);
+                        await regenerateLockFiles(resolved, logger, isDryRun);
+                        await applyStashIfNeeded(didStash, logger, isDryRun);
+                        return {
+                            success: true,
+                            hadConflicts: true,
+                            autoResolved: resolved,
+                            manualRequired: [],
+                            stashApplied: didStash,
+                            strategy: 'rebase',
+                            message: `Rebase successful with ${resolved.length} auto-resolved conflicts`
+                        };
+                    } catch (continueError) {
+                        logger.warn(`PULL_CONTINUE_FAILED: Rebase continue failed | Error: ${continueError.message}`);
+                    }
+                } else {
+                    // Some conflicts need manual resolution
+                    logger.warn(`PULL_MANUAL_REQUIRED: ${manual.length} conflicts require manual resolution`);
+                    logger.warn('PULL_MANUAL_FILES: Files needing manual resolution:');
+                    manual.forEach((f)=>logger.warn(`  - ${f}`));
+                    logger.info('PULL_HINT: After resolving conflicts manually, run: git rebase --continue');
+                    // Keep rebase in progress so user can finish
+                    return {
+                        success: false,
+                        hadConflicts: true,
+                        autoResolved: resolved,
+                        manualRequired: manual,
+                        stashApplied: false,
+                        strategy: 'rebase',
+                        message: `Rebase paused: ${manual.length} files need manual conflict resolution`
+                    };
+                }
+            } else {
+                // Rebase failed for other reason, abort and try merge
+                logger.info('PULL_REBASE_ABORT: Rebase failed, aborting and trying merge');
+                try {
+                    await runSecure('git', [
+                        'rebase',
+                        '--abort'
+                    ]);
+                } catch  {
+                // Ignore abort errors
+                }
+            }
+        }
+    }
+    // Step 6: Fall back to regular merge
+    logger.info('PULL_STRATEGY: Attempting merge');
+    if (!isDryRun) {
+        try {
+            await runSecure('git', [
+                'merge',
+                `${remote}/${targetBranch}`
+            ]);
+            await applyStashIfNeeded(didStash, logger, isDryRun);
+            logger.info('PULL_SUCCESS: Merge successful');
+            return {
+                success: true,
+                hadConflicts: false,
+                autoResolved: [],
+                manualRequired: [],
+                stashApplied: didStash,
+                strategy: 'merge',
+                message: 'Merge successful'
+            };
+        } catch  {
+            // Check for merge conflicts
+            const conflictedFiles = await getConflictedFiles();
+            if (conflictedFiles.length > 0) {
+                logger.info(`PULL_CONFLICTS: Merge has ${conflictedFiles.length} conflicts, attempting auto-resolution`);
+                const { resolved, manual } = await autoResolveConflicts(logger, isDryRun);
+                if (manual.length === 0) {
+                    // All conflicts resolved, commit the merge
+                    logger.info('PULL_ALL_RESOLVED: All conflicts auto-resolved, completing merge');
+                    try {
+                        await runSecure('git', [
+                            'commit',
+                            '-m',
+                            `Merge ${remote}/${targetBranch} (auto-resolved by kodrdriv)`
+                        ]);
+                        await regenerateLockFiles(resolved, logger, isDryRun);
+                        await applyStashIfNeeded(didStash, logger, isDryRun);
+                        return {
+                            success: true,
+                            hadConflicts: true,
+                            autoResolved: resolved,
+                            manualRequired: [],
+                            stashApplied: didStash,
+                            strategy: 'merge',
+                            message: `Merge successful with ${resolved.length} auto-resolved conflicts`
+                        };
+                    } catch (commitError) {
+                        logger.error(`PULL_COMMIT_FAILED: Merge commit failed | Error: ${commitError.message}`);
+                    }
+                } else {
+                    logger.warn(`PULL_MANUAL_REQUIRED: ${manual.length} conflicts require manual resolution`);
+                    manual.forEach((f)=>logger.warn(`  - ${f}`));
+                    logger.info('PULL_HINT: After resolving conflicts manually, run: git commit');
+                    return {
+                        success: false,
+                        hadConflicts: true,
+                        autoResolved: resolved,
+                        manualRequired: manual,
+                        stashApplied: false,
+                        strategy: 'merge',
+                        message: `Merge paused: ${manual.length} files need manual conflict resolution`
+                    };
+                }
+            }
+        }
+    }
+    // If we got here, something went wrong
+    if (didStash) {
+        logger.warn('PULL_STASH_PRESERVED: Local changes still stashed, use "git stash pop" to restore');
+    }
+    return {
+        success: false,
+        hadConflicts: false,
+        autoResolved: [],
+        manualRequired: [],
+        stashApplied: false,
+        strategy: 'failed',
+        message: 'Pull failed - unable to merge or rebase'
+    };
+}
+/**
+ * Internal execution
+ */ const executeInternal = async (runConfig)=>{
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+    // Get pull configuration
+    const pullConfig = runConfig.pull || {};
+    const remote = pullConfig.remote || 'origin';
+    const branch = pullConfig.branch;
+    // Execute pull
+    const result = await executePull(remote, branch, logger, isDryRun);
+    // Format output
+    const lines = [];
+    lines.push('');
+    lines.push('═'.repeat(60));
+    lines.push(result.success ? '✅ PULL COMPLETE' : '⚠️  PULL NEEDS ATTENTION');
+    lines.push('═'.repeat(60));
+    lines.push('');
+    lines.push(`Strategy: ${result.strategy}`);
+    lines.push(`Message: ${result.message}`);
+    if (result.hadConflicts) {
+        lines.push('');
+        lines.push(`Conflicts detected: ${result.autoResolved.length + result.manualRequired.length}`);
+        if (result.autoResolved.length > 0) {
+            lines.push(`✓ Auto-resolved: ${result.autoResolved.length}`);
+            result.autoResolved.forEach((f)=>lines.push(`   - ${f}`));
+        }
+        if (result.manualRequired.length > 0) {
+            lines.push(`✗ Manual resolution needed: ${result.manualRequired.length}`);
+            result.manualRequired.forEach((f)=>lines.push(`   - ${f}`));
+        }
+    }
+    if (result.stashApplied) {
+        lines.push('');
+        lines.push('ℹ️  Local changes have been restored from stash');
+    }
+    lines.push('');
+    lines.push('═'.repeat(60));
+    const output = lines.join('\n');
+    logger.info(output);
+    return output;
+};
+/**
+ * Execute pull command
+ */ const execute = async (runConfig)=>{
+    try {
+        return await executeInternal(runConfig);
+    } catch (error) {
+        const logger = getLogger();
+        logger.error(`PULL_COMMAND_FAILED: Pull command failed | Error: ${error.message}`);
+        throw error;
+    }
+};
+
+const logger = getLogger();
+// Cache file to store test run timestamps per package
+const TEST_CACHE_FILE = '.kodrdriv-test-cache.json';
+/**
+ * Load test cache from disk
+ */ async function loadTestCache(packageDir) {
+    const cachePath = path.join(packageDir, TEST_CACHE_FILE);
+    try {
+        const content = await fs.readFile(cachePath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return {};
+    }
+}
+/**
+ * Save test cache to disk
+ */ async function saveTestCache(packageDir, cache) {
+    const cachePath = path.join(packageDir, TEST_CACHE_FILE);
+    try {
+        await fs.writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+    } catch (error) {
+        logger.debug(`Failed to save test cache: ${error.message}`);
+    }
+}
+/**
+ * Get the current git commit hash
+ */ async function getCurrentCommitHash(packageDir) {
+    try {
+        const { stdout } = await runSecure('git', [
+            'rev-parse',
+            'HEAD'
+        ], {
+            cwd: packageDir
+        });
+        return stdout.trim();
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Check if source files have changed since the last test run
+ */ async function hasSourceFilesChanged(packageDir, lastCommitHash) {
+    if (!lastCommitHash) {
+        return {
+            changed: true,
+            reason: 'No previous test run recorded'
+        };
+    }
+    try {
+        // Get current commit hash
+        const currentCommitHash = await getCurrentCommitHash(packageDir);
+        if (!currentCommitHash) {
+            return {
+                changed: true,
+                reason: 'Not in a git repository'
+            };
+        }
+        // If commit hash changed, files definitely changed
+        if (currentCommitHash !== lastCommitHash) {
+            return {
+                changed: true,
+                reason: `Commit hash changed: ${lastCommitHash.substring(0, 7)} -> ${currentCommitHash.substring(0, 7)}`
+            };
+        }
+        // Check if there are any uncommitted changes to source files
+        const { stdout } = await runSecure('git', [
+            'status',
+            '--porcelain'
+        ], {
+            cwd: packageDir
+        });
+        const changedFiles = stdout.split('\n').filter((line)=>line.trim()).map((line)=>line.substring(3).trim()).filter((file)=>{
+            // Only consider source files, not build artifacts or config files
+            const ext = path.extname(file);
+            return(// TypeScript/JavaScript source files
+            [
+                '.ts',
+                '.tsx',
+                '.js',
+                '.jsx'
+            ].includes(ext) || // Test files
+            file.includes('.test.') || file.includes('.spec.') || // Config files that affect build/test
+            [
+                'tsconfig.json',
+                'vite.config.ts',
+                'vitest.config.ts',
+                'package.json'
+            ].includes(path.basename(file)));
+        });
+        if (changedFiles.length > 0) {
+            return {
+                changed: true,
+                reason: `Uncommitted changes in: ${changedFiles.slice(0, 3).join(', ')}${changedFiles.length > 3 ? '...' : ''}`
+            };
+        }
+        return {
+            changed: false,
+            reason: 'No source file changes detected'
+        };
+    } catch (error) {
+        logger.debug(`Error checking for source file changes: ${error.message}`);
+        // Conservative: assume changed if we can't verify
+        return {
+            changed: true,
+            reason: `Could not verify changes: ${error.message}`
+        };
+    }
+}
+/**
+ * Check if dist directory needs to be cleaned (is outdated compared to source files)
+ */ async function isCleanNeeded(packageDir) {
+    const storage = createStorage();
+    const distPath = path.join(packageDir, 'dist');
+    try {
+        // Check if dist directory exists
+        const distExists = await storage.exists('dist');
+        if (!distExists) {
+            return {
+                needed: false,
+                reason: 'dist directory does not exist'
+            };
+        }
+        // Get dist directory modification time
+        const distStats = await fs.stat(distPath);
+        const distMtime = distStats.mtimeMs;
+        // Use git to find source files that are newer than dist
+        try {
+            // Get all tracked source files
+            const { stdout: trackedFiles } = await runSecure('git', [
+                'ls-files'
+            ], {
+                cwd: packageDir
+            });
+            const files = trackedFiles.split('\n').filter(Boolean);
+            // Check if any source files are newer than dist
+            for (const file of files){
+                const ext = path.extname(file);
+                if (![
+                    '.ts',
+                    '.tsx',
+                    '.js',
+                    '.jsx',
+                    '.json'
+                ].includes(ext)) {
+                    continue;
+                }
+                // Skip dist files
+                if (file.startsWith('dist/')) {
+                    continue;
+                }
+                try {
+                    const filePath = path.join(packageDir, file);
+                    const fileStats = await fs.stat(filePath);
+                    if (fileStats.mtimeMs > distMtime) {
+                        return {
+                            needed: true,
+                            reason: `${file} is newer than dist directory`
+                        };
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+            return {
+                needed: false,
+                reason: 'dist directory is up to date with source files'
+            };
+        } catch (error) {
+            // If git check fails, fall back to checking common source directories
+            logger.debug(`Git-based check failed, using fallback: ${error.message}`);
+            const sourceDirs = [
+                'src',
+                'tests'
+            ];
+            for (const dir of sourceDirs){
+                const dirPath = path.join(packageDir, dir);
+                try {
+                    const dirStats = await fs.stat(dirPath);
+                    if (dirStats.mtimeMs > distMtime) {
+                        return {
+                            needed: true,
+                            reason: `${dir} directory is newer than dist`
+                        };
+                    }
+                } catch  {
+                    continue;
+                }
             }
+            // Conservative: if we can't verify, assume clean is needed
+            return {
+                needed: true,
+                reason: 'Could not verify dist freshness, cleaning to be safe'
+            };
         }
-        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'
-        ];
+        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}`
+        };
     }
-    // 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
-            }
+}
+/**
+ * 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'
+            };
         }
-    } 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
+        // 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
+            };
         }
-    }
-    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
+        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}`
         };
-        // 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)=>{
+}
+/**
+ * Record that tests were run for this package
+ */ async function recordTestRun(packageDir) {
     try {
-        return await executeInternal(runConfig);
+        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) {
-        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}`);
+        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;
             }
-            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}`);
+    }
+    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;
             }
-            throw error;
         }
-        // Unexpected errors
-        logger.error(`review encountered unexpected error: ${error.message}`);
-        throw error;
     }
-};
+    // Clean up any double && or trailing &&
+    optimizedCommand = optimizedCommand.replace(/\s*&&\s*&&/g, ' && ').replace(/&&\s*$/, '').trim();
+    return {
+        optimizedCommand,
+        skipped,
+        reasons
+    };
+}
 
-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 };
+export { PerformanceTimer, batchReadPackageJsonFiles, checkForFileDependencies, execute$2 as clean, collectAllDependencies, execute$4 as commit, findAllPackageJsonFiles, findPackagesByScope, isCleanNeeded, isTestNeeded, optimizePrecommitCommand, execute$3 as precommit, execute as pull, recordTestRun, execute$1 as review, scanDirectoryForPackages };
 //# sourceMappingURL=index.js.map