@eldrforge/commands-git 0.1.5 → 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, getCurrentBranch, getGitStatusSummary } 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) {
@@ -552,10 +552,11 @@ const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
     return lines.join('\n');
 }
 const executeInternal$3 = async (runConfig)=>{
-    var _ref, _runConfig_excludedPatterns;
-    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _aiConfig_commands_commit, _aiConfig_commands, _runConfig_commit7, _aiConfig_commands_commit1, _aiConfig_commands1, _runConfig_commit8, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14;
+    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) {
@@ -568,11 +569,14 @@ const executeInternal$3 = 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,
@@ -580,15 +584,16 @@ const executeInternal$3 = 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');
@@ -620,10 +625,10 @@ const executeInternal$3 = 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 {
@@ -642,8 +647,8 @@ const executeInternal$3 = 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 {
@@ -654,7 +659,7 @@ const executeInternal$3 = 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();
@@ -689,7 +694,7 @@ const executeInternal$3 = 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);
     }
@@ -698,10 +703,10 @@ const executeInternal$3 = 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
@@ -711,7 +716,7 @@ const executeInternal$3 = 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
@@ -720,30 +725,31 @@ const executeInternal$3 = 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];
@@ -753,9 +759,9 @@ const executeInternal$3 = 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)
@@ -766,12 +772,12 @@ const executeInternal$3 = async (runConfig)=>{
             const splitResult = await executeSplitCommits({
                 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);
@@ -796,13 +802,13 @@ const executeInternal$3 = 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');
@@ -810,7 +816,7 @@ const executeInternal$3 = 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');
@@ -822,12 +828,12 @@ const executeInternal$3 = 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') {
@@ -837,23 +843,23 @@ const executeInternal$3 = 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);
@@ -876,32 +882,32 @@ const executeInternal$3 = 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);
@@ -939,419 +945,117 @@ const execute$4 = 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)) {
-                    continue;
-                }
-                // Skip dist files
-                if (file.startsWith('dist/')) {
+            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;
                 }
-                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`
-                        };
+                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}`);
                     }
-                } catch  {
-                    continue;
-                }
-            }
-            return {
-                needed: false,
-                reason: 'dist directory is up to date with source files'
-            };
-        } catch (error) {
-            // If git check fails, fall back to checking common source directories
-            logger.debug(`Git-based check failed, using fallback: ${error.message}`);
-            const sourceDirs = [
-                'src',
-                'tests'
-            ];
-            for (const dir of sourceDirs){
-                const dirPath = path.join(packageDir, dir);
-                try {
-                    const dirStats = await fs.stat(dirPath);
-                    if (dirStats.mtimeMs > distMtime) {
-                        return {
-                            needed: true,
-                            reason: `${dir} directory is newer than dist`
-                        };
-                    }
-                } catch  {
-                    continue;
-                }
-            }
-            // Conservative: if we can't verify, assume clean is needed
-            return {
-                needed: true,
-                reason: 'Could not verify dist freshness, cleaning to be safe'
-            };
-        }
-    } catch (error) {
-        logger.debug(`Error checking if clean is needed: ${error.message}`);
-        // Conservative: assume clean is needed if we can't check
-        return {
-            needed: true,
-            reason: `Could not verify: ${error.message}`
-        };
-    }
-}
-/**
- * Check if tests need to be run (source files changed since last test run)
- */ async function isTestNeeded(packageDir) {
-    try {
-        // Load test cache
-        const cache = await loadTestCache(packageDir);
-        const cacheKey = packageDir;
-        // Check if we have a cached test run for this package
-        const cached = cache[cacheKey];
-        if (!cached) {
-            return {
-                needed: true,
-                reason: 'No previous test run recorded'
-            };
-        }
-        // Check if source files have changed since last test run
-        const changeCheck = await hasSourceFilesChanged(packageDir, cached.lastCommitHash);
-        if (changeCheck.changed) {
-            return {
-                needed: true,
-                reason: changeCheck.reason
-            };
-        }
-        return {
-            needed: false,
-            reason: 'No source file changes since last test run'
-        };
-    } catch (error) {
-        logger.debug(`Error checking if test is needed: ${error.message}`);
-        // Conservative: assume test is needed if we can't check
-        return {
-            needed: true,
-            reason: `Could not verify: ${error.message}`
-        };
-    }
-}
-/**
- * Record that tests were run for this package
- */ async function recordTestRun(packageDir) {
-    try {
-        const cache = await loadTestCache(packageDir);
-        const cacheKey = packageDir;
-        const commitHash = await getCurrentCommitHash(packageDir);
-        cache[cacheKey] = {
-            lastTestRun: Date.now(),
-            lastCommitHash: commitHash || 'unknown'
-        };
-        await saveTestCache(packageDir, cache);
-    } catch (error) {
-        logger.debug(`Failed to record test run: ${error.message}`);
-    }
-}
-/**
- * Optimize a precommit command by skipping unnecessary steps
- * Returns the optimized command and information about what was skipped
- */ async function optimizePrecommitCommand(packageDir, originalCommand, options = {}) {
-    const { skipClean = true, skipTest = true } = options;
-    // Parse the original command to extract individual scripts
-    // Common patterns: "npm run precommit", "npm run clean && npm run build && npm run lint && npm run test"
-    const isPrecommitScript = originalCommand.includes('precommit') || originalCommand.includes('pre-commit');
-    let optimizedCommand = originalCommand;
-    const skipped = {
-        clean: false,
-        test: false
-    };
-    const reasons = {};
-    // If it's a precommit script, we need to check what it actually runs
-    // For now, we'll optimize the common pattern: clean && build && lint && test
-    if (isPrecommitScript || originalCommand.includes('clean')) {
-        if (skipClean) {
-            const cleanCheck = await isCleanNeeded(packageDir);
-            if (!cleanCheck.needed) {
-                // Remove clean from the command
-                optimizedCommand = optimizedCommand.replace(/npm\s+run\s+clean\s+&&\s*/g, '').replace(/npm\s+run\s+clean\s+/g, '').replace(/\s*&&\s*npm\s+run\s+clean/g, '').trim();
-                skipped.clean = true;
-                reasons.clean = cleanCheck.reason;
-            }
-        }
-    }
-    if (isPrecommitScript || originalCommand.includes('test')) {
-        if (skipTest) {
-            const testCheck = await isTestNeeded(packageDir);
-            if (!testCheck.needed) {
-                // Remove test from the command
-                optimizedCommand = optimizedCommand.replace(/\s*&&\s*npm\s+run\s+test\s*/g, '').replace(/\s*&&\s*npm\s+run\s+test$/g, '').replace(/npm\s+run\s+test\s+&&\s*/g, '').trim();
-                skipped.test = true;
-                reasons.test = testCheck.reason;
-            }
-        }
-    }
-    // Clean up any double && or trailing &&
-    optimizedCommand = optimizedCommand.replace(/\s*&&\s*&&/g, ' && ').replace(/&&\s*$/, '').trim();
-    return {
-        optimizedCommand,
-        skipped,
-        reasons
-    };
-}
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-// Performance timing helper
-class PerformanceTimer {
-    static start(logger, operation) {
-        logger.verbose(`⏱️  Starting: ${operation}`);
-        return new PerformanceTimer(logger);
-    }
-    end(operation) {
-        const duration = Date.now() - this.startTime;
-        this.logger.verbose(`⏱️  Completed: ${operation} (${duration}ms)`);
-        return duration;
-    }
-    constructor(logger){
-        _define_property(this, "startTime", void 0);
-        _define_property(this, "logger", void 0);
-        this.logger = logger;
-        this.startTime = Date.now();
-    }
-}
-const EXCLUDED_DIRECTORIES = [
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.git',
-    '.next',
-    '.nuxt',
-    'out',
-    'public',
-    'static',
-    'assets'
-];
-// Batch read multiple package.json files in parallel
-const batchReadPackageJsonFiles = async (packageJsonPaths, storage, rootDir)=>{
-    const logger = getLogger();
-    const timer = PerformanceTimer.start(logger, `Batch reading ${packageJsonPaths.length} package.json files`);
-    const readPromises = packageJsonPaths.map(async (packageJsonPath)=>{
-        try {
-            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
-            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
-            const packageJson = validatePackageJson(parsed, packageJsonPath, false);
-            const relativePath = path.relative(rootDir, path.dirname(packageJsonPath));
-            return {
-                path: packageJsonPath,
-                packageJson,
-                relativePath: relativePath || '.'
-            };
-        } catch (error) {
-            logger.debug(`Skipped invalid package.json at ${packageJsonPath}: ${error.message}`);
-            return null;
-        }
-    });
-    const results = await Promise.all(readPromises);
-    const validResults = results.filter((result)=>result !== null);
-    timer.end(`Successfully read ${validResults.length}/${packageJsonPaths.length} package.json files`);
-    return validResults;
-};
-// Optimized recursive package.json finder with parallel processing
-const findAllPackageJsonFiles = async (rootDir, storage)=>{
-    const logger = getLogger();
-    const timer = PerformanceTimer.start(logger, 'Optimized scanning for package.json files');
-    const scanForPaths = async (currentDir, depth = 0)=>{
-        // Prevent infinite recursion and overly deep scanning
-        if (depth > 5) {
-            return [];
-        }
-        try {
-            if (!await storage.exists(currentDir) || !await storage.isDirectory(currentDir)) {
-                return [];
-            }
-            const items = await storage.listFiles(currentDir);
-            const foundPaths = [];
-            // Check for package.json in current directory
-            if (items.includes('package.json')) {
-                const packageJsonPath = path.join(currentDir, 'package.json');
-                foundPaths.push(packageJsonPath);
-            }
-            // Process subdirectories in parallel
-            const subdirPromises = [];
-            for (const item of items){
-                if (EXCLUDED_DIRECTORIES.includes(item)) {
-                    continue;
-                }
-                const itemPath = path.join(currentDir, item);
-                subdirPromises.push((async ()=>{
-                    try {
-                        if (await storage.isDirectory(itemPath)) {
-                            return await scanForPaths(itemPath, depth + 1);
-                        }
-                    } catch (error) {
-                        logger.debug(`Skipped directory ${itemPath}: ${error.message}`);
-                    }
-                    return [];
-                })());
-            }
-            if (subdirPromises.length > 0) {
-                const subdirResults = await Promise.all(subdirPromises);
-                for (const subdirPaths of subdirResults){
-                    foundPaths.push(...subdirPaths);
+                    return [];
+                })());
+            }
+            if (subdirPromises.length > 0) {
+                const subdirResults = await Promise.all(subdirPromises);
+                for (const subdirPaths of subdirResults){
+                    foundPaths.push(...subdirPaths);
                 }
             }
             return foundPaths;
@@ -1540,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
+ * 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)=>{
-    const logger = getLogger();
+    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;
-    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
+    // Execute the precommit script
     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');
@@ -2963,5 +2670,307 @@ const AUTO_RESOLVABLE_PATTERNS = {
     }
 };
 
+const logger = getLogger();
+// Cache file to store test run timestamps per package
+const TEST_CACHE_FILE = '.kodrdriv-test-cache.json';
+/**
+ * Load test cache from disk
+ */ async function loadTestCache(packageDir) {
+    const cachePath = path.join(packageDir, TEST_CACHE_FILE);
+    try {
+        const content = await fs.readFile(cachePath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return {};
+    }
+}
+/**
+ * Save test cache to disk
+ */ async function saveTestCache(packageDir, cache) {
+    const cachePath = path.join(packageDir, TEST_CACHE_FILE);
+    try {
+        await fs.writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+    } catch (error) {
+        logger.debug(`Failed to save test cache: ${error.message}`);
+    }
+}
+/**
+ * Get the current git commit hash
+ */ async function getCurrentCommitHash(packageDir) {
+    try {
+        const { stdout } = await runSecure('git', [
+            'rev-parse',
+            'HEAD'
+        ], {
+            cwd: packageDir
+        });
+        return stdout.trim();
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Check if source files have changed since the last test run
+ */ async function hasSourceFilesChanged(packageDir, lastCommitHash) {
+    if (!lastCommitHash) {
+        return {
+            changed: true,
+            reason: 'No previous test run recorded'
+        };
+    }
+    try {
+        // Get current commit hash
+        const currentCommitHash = await getCurrentCommitHash(packageDir);
+        if (!currentCommitHash) {
+            return {
+                changed: true,
+                reason: 'Not in a git repository'
+            };
+        }
+        // If commit hash changed, files definitely changed
+        if (currentCommitHash !== lastCommitHash) {
+            return {
+                changed: true,
+                reason: `Commit hash changed: ${lastCommitHash.substring(0, 7)} -> ${currentCommitHash.substring(0, 7)}`
+            };
+        }
+        // Check if there are any uncommitted changes to source files
+        const { stdout } = await runSecure('git', [
+            'status',
+            '--porcelain'
+        ], {
+            cwd: packageDir
+        });
+        const changedFiles = stdout.split('\n').filter((line)=>line.trim()).map((line)=>line.substring(3).trim()).filter((file)=>{
+            // Only consider source files, not build artifacts or config files
+            const ext = path.extname(file);
+            return(// TypeScript/JavaScript source files
+            [
+                '.ts',
+                '.tsx',
+                '.js',
+                '.jsx'
+            ].includes(ext) || // Test files
+            file.includes('.test.') || file.includes('.spec.') || // Config files that affect build/test
+            [
+                'tsconfig.json',
+                'vite.config.ts',
+                'vitest.config.ts',
+                'package.json'
+            ].includes(path.basename(file)));
+        });
+        if (changedFiles.length > 0) {
+            return {
+                changed: true,
+                reason: `Uncommitted changes in: ${changedFiles.slice(0, 3).join(', ')}${changedFiles.length > 3 ? '...' : ''}`
+            };
+        }
+        return {
+            changed: false,
+            reason: 'No source file changes detected'
+        };
+    } catch (error) {
+        logger.debug(`Error checking for source file changes: ${error.message}`);
+        // Conservative: assume changed if we can't verify
+        return {
+            changed: true,
+            reason: `Could not verify changes: ${error.message}`
+        };
+    }
+}
+/**
+ * Check if dist directory needs to be cleaned (is outdated compared to source files)
+ */ async function isCleanNeeded(packageDir) {
+    const storage = createStorage();
+    const distPath = path.join(packageDir, 'dist');
+    try {
+        // Check if dist directory exists
+        const distExists = await storage.exists('dist');
+        if (!distExists) {
+            return {
+                needed: false,
+                reason: 'dist directory does not exist'
+            };
+        }
+        // Get dist directory modification time
+        const distStats = await fs.stat(distPath);
+        const distMtime = distStats.mtimeMs;
+        // Use git to find source files that are newer than dist
+        try {
+            // Get all tracked source files
+            const { stdout: trackedFiles } = await runSecure('git', [
+                'ls-files'
+            ], {
+                cwd: packageDir
+            });
+            const files = trackedFiles.split('\n').filter(Boolean);
+            // Check if any source files are newer than dist
+            for (const file of files){
+                const ext = path.extname(file);
+                if (![
+                    '.ts',
+                    '.tsx',
+                    '.js',
+                    '.jsx',
+                    '.json'
+                ].includes(ext)) {
+                    continue;
+                }
+                // Skip dist files
+                if (file.startsWith('dist/')) {
+                    continue;
+                }
+                try {
+                    const filePath = path.join(packageDir, file);
+                    const fileStats = await fs.stat(filePath);
+                    if (fileStats.mtimeMs > distMtime) {
+                        return {
+                            needed: true,
+                            reason: `${file} is newer than dist directory`
+                        };
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+            return {
+                needed: false,
+                reason: 'dist directory is up to date with source files'
+            };
+        } catch (error) {
+            // If git check fails, fall back to checking common source directories
+            logger.debug(`Git-based check failed, using fallback: ${error.message}`);
+            const sourceDirs = [
+                'src',
+                'tests'
+            ];
+            for (const dir of sourceDirs){
+                const dirPath = path.join(packageDir, dir);
+                try {
+                    const dirStats = await fs.stat(dirPath);
+                    if (dirStats.mtimeMs > distMtime) {
+                        return {
+                            needed: true,
+                            reason: `${dir} directory is newer than dist`
+                        };
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+            // Conservative: if we can't verify, assume clean is needed
+            return {
+                needed: true,
+                reason: 'Could not verify dist freshness, cleaning to be safe'
+            };
+        }
+    } catch (error) {
+        logger.debug(`Error checking if clean is needed: ${error.message}`);
+        // Conservative: assume clean is needed if we can't check
+        return {
+            needed: true,
+            reason: `Could not verify: ${error.message}`
+        };
+    }
+}
+/**
+ * Check if tests need to be run (source files changed since last test run)
+ */ async function isTestNeeded(packageDir) {
+    try {
+        // Load test cache
+        const cache = await loadTestCache(packageDir);
+        const cacheKey = packageDir;
+        // Check if we have a cached test run for this package
+        const cached = cache[cacheKey];
+        if (!cached) {
+            return {
+                needed: true,
+                reason: 'No previous test run recorded'
+            };
+        }
+        // Check if source files have changed since last test run
+        const changeCheck = await hasSourceFilesChanged(packageDir, cached.lastCommitHash);
+        if (changeCheck.changed) {
+            return {
+                needed: true,
+                reason: changeCheck.reason
+            };
+        }
+        return {
+            needed: false,
+            reason: 'No source file changes since last test run'
+        };
+    } catch (error) {
+        logger.debug(`Error checking if test is needed: ${error.message}`);
+        // Conservative: assume test is needed if we can't check
+        return {
+            needed: true,
+            reason: `Could not verify: ${error.message}`
+        };
+    }
+}
+/**
+ * Record that tests were run for this package
+ */ async function recordTestRun(packageDir) {
+    try {
+        const cache = await loadTestCache(packageDir);
+        const cacheKey = packageDir;
+        const commitHash = await getCurrentCommitHash(packageDir);
+        cache[cacheKey] = {
+            lastTestRun: Date.now(),
+            lastCommitHash: commitHash || 'unknown'
+        };
+        await saveTestCache(packageDir, cache);
+    } catch (error) {
+        logger.debug(`Failed to record test run: ${error.message}`);
+    }
+}
+/**
+ * Optimize a precommit command by skipping unnecessary steps
+ * Returns the optimized command and information about what was skipped
+ */ async function optimizePrecommitCommand(packageDir, originalCommand, options = {}) {
+    const { skipClean = true, skipTest = true } = options;
+    // Parse the original command to extract individual scripts
+    // Common patterns: "npm run precommit", "npm run clean && npm run build && npm run lint && npm run test"
+    const isPrecommitScript = originalCommand.includes('precommit') || originalCommand.includes('pre-commit');
+    let optimizedCommand = originalCommand;
+    const skipped = {
+        clean: false,
+        test: false
+    };
+    const reasons = {};
+    // If it's a precommit script, we need to check what it actually runs
+    // For now, we'll optimize the common pattern: clean && build && lint && test
+    if (isPrecommitScript || originalCommand.includes('clean')) {
+        if (skipClean) {
+            const cleanCheck = await isCleanNeeded(packageDir);
+            if (!cleanCheck.needed) {
+                // Remove clean from the command
+                optimizedCommand = optimizedCommand.replace(/npm\s+run\s+clean\s+&&\s*/g, '').replace(/npm\s+run\s+clean\s+/g, '').replace(/\s*&&\s*npm\s+run\s+clean/g, '').trim();
+                skipped.clean = true;
+                reasons.clean = cleanCheck.reason;
+            }
+        }
+    }
+    if (isPrecommitScript || originalCommand.includes('test')) {
+        if (skipTest) {
+            const testCheck = await isTestNeeded(packageDir);
+            if (!testCheck.needed) {
+                // Remove test from the command
+                optimizedCommand = optimizedCommand.replace(/\s*&&\s*npm\s+run\s+test\s*/g, '').replace(/\s*&&\s*npm\s+run\s+test$/g, '').replace(/npm\s+run\s+test\s+&&\s*/g, '').trim();
+                skipped.test = true;
+                reasons.test = testCheck.reason;
+            }
+        }
+    }
+    // Clean up any double && or trailing &&
+    optimizedCommand = optimizedCommand.replace(/\s*&&\s*&&/g, ' && ').replace(/&&\s*$/, '').trim();
+    return {
+        optimizedCommand,
+        skipped,
+        reasons
+    };
+}
+
 export { PerformanceTimer, batchReadPackageJsonFiles, checkForFileDependencies, execute$2 as clean, collectAllDependencies, execute$4 as commit, findAllPackageJsonFiles, findPackagesByScope, isCleanNeeded, isTestNeeded, optimizePrecommitCommand, execute$3 as precommit, execute as pull, recordTestRun, execute$1 as review, scanDirectoryForPackages };
 //# sourceMappingURL=index.js.map