@eldrforge/kodrdriv 1.2.123 → 1.2.125

package/dist/commands/commit.js

@@ -10,15 +10,202 @@ import { ValidationError, ExternalDependencyError, CommandError } from '../error
 import { getDryRunLogger } from '../logging.js';
 import { run, validateString, safeJsonParse, validatePackageJson } from '@eldrforge/git-tools';
 import { sanitizeDirection } from '../util/validation.js';
+import { filterContent } from '../util/stopContext.js';
 import { getOutputPath, getTimestampedResponseFilename, getTimestampedRequestFilename, getTimestampedCommitFilename } from '../util/general.js';
 import { createStorage, stringifyJSON, checkForFileDependencies, logFileDependencyWarning, logFileDependencySuggestions } from '@eldrforge/shared';
 import { getRecentClosedIssuesForCommit } from '@eldrforge/github-tools';
-import { createCommitPrompt, createCompletionWithRetry, requireTTY, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor } from '@eldrforge/ai-service';
+import { runAgenticCommit, createCommitPrompt, createCompletionWithRetry, requireTTY, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor } from '@eldrforge/ai-service';
 import { improveContentWithLLM } from '../util/interactive.js';
 import { toAIConfig } from '../util/aiAdapter.js';
 import { createStorageAdapter } from '../util/storageAdapter.js';
 import { createLoggerAdapter } from '../util/loggerAdapter.js';
 
+// Helper function to generate self-reflection output
+async function generateSelfReflection(agenticResult, outputDirectory, storage, logger) {
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const reflectionPath = getOutputPath(outputDirectory, `agentic-reflection-${timestamp}.md`);
+        // Calculate tool effectiveness metrics
+        const toolMetrics = agenticResult.toolMetrics || [];
+        const toolStats = new Map();
+        for (const metric of toolMetrics){
+            if (!toolStats.has(metric.name)) {
+                toolStats.set(metric.name, {
+                    total: 0,
+                    success: 0,
+                    failures: 0,
+                    totalDuration: 0
+                });
+            }
+            const stats = toolStats.get(metric.name);
+            stats.total++;
+            stats.totalDuration += metric.duration;
+            if (metric.success) {
+                stats.success++;
+            } else {
+                stats.failures++;
+            }
+        }
+        // Build reflection document
+        const sections = [];
+        sections.push('# Agentic Commit - Self-Reflection Report');
+        sections.push('');
+        sections.push(`Generated: ${new Date().toISOString()}`);
+        sections.push('');
+        sections.push('## Execution Summary');
+        sections.push('');
+        sections.push(`- **Iterations**: ${agenticResult.iterations}`);
+        sections.push(`- **Tool Calls**: ${agenticResult.toolCallsExecuted}`);
+        sections.push(`- **Unique Tools Used**: ${toolStats.size}`);
+        sections.push('');
+        sections.push('## Tool Effectiveness Analysis');
+        sections.push('');
+        if (toolStats.size === 0) {
+            sections.push('*No tools were executed during this run.*');
+        } else {
+            sections.push('| Tool | Calls | Success | Failures | Success Rate | Avg Duration |');
+            sections.push('|------|-------|---------|----------|--------------|--------------|');
+            for (const [toolName, stats] of Array.from(toolStats.entries()).sort((a, b)=>b[1].total - a[1].total)){
+                const successRate = (stats.success / stats.total * 100).toFixed(1);
+                const avgDuration = (stats.totalDuration / stats.total).toFixed(0);
+                sections.push(`| ${toolName} | ${stats.total} | ${stats.success} | ${stats.failures} | ${successRate}% | ${avgDuration}ms |`);
+            }
+            sections.push('');
+            sections.push('### Tool Performance Insights');
+            sections.push('');
+            // Identify problematic tools
+            const failedTools = Array.from(toolStats.entries()).filter(([_, stats])=>stats.failures > 0);
+            if (failedTools.length > 0) {
+                sections.push('**Tools with Failures:**');
+                for (const [toolName, stats] of failedTools){
+                    const failureRate = (stats.failures / stats.total * 100).toFixed(1);
+                    sections.push(`- ${toolName}: ${stats.failures}/${stats.total} failures (${failureRate}%)`);
+                }
+                sections.push('');
+            }
+            // Identify slow tools
+            const slowTools = Array.from(toolStats.entries()).filter(([_, stats])=>stats.totalDuration / stats.total > 1000).sort((a, b)=>b[1].totalDuration / b[1].total - a[1].totalDuration / a[1].total);
+            if (slowTools.length > 0) {
+                sections.push('**Slow Tools (>1s average):**');
+                for (const [toolName, stats] of slowTools){
+                    const avgDuration = (stats.totalDuration / stats.total / 1000).toFixed(2);
+                    sections.push(`- ${toolName}: ${avgDuration}s average`);
+                }
+                sections.push('');
+            }
+            // Identify most useful tools
+            sections.push('**Most Frequently Used:**');
+            const topTools = Array.from(toolStats.entries()).slice(0, 3);
+            for (const [toolName, stats] of topTools){
+                sections.push(`- ${toolName}: ${stats.total} calls`);
+            }
+            sections.push('');
+        }
+        sections.push('## Detailed Execution Timeline');
+        sections.push('');
+        if (toolMetrics.length === 0) {
+            sections.push('*No tool execution timeline available.*');
+        } else {
+            sections.push('| Time | Iteration | Tool | Result | Duration |');
+            sections.push('|------|-----------|------|--------|----------|');
+            for (const metric of toolMetrics){
+                const time = new Date(metric.timestamp).toLocaleTimeString();
+                const result = metric.success ? '✅ Success' : `❌ ${metric.error || 'Failed'}`;
+                sections.push(`| ${time} | ${metric.iteration} | ${metric.name} | ${result} | ${metric.duration}ms |`);
+            }
+            sections.push('');
+        }
+        sections.push('## Conversation History');
+        sections.push('');
+        sections.push('<details>');
+        sections.push('<summary>Click to expand full agentic interaction</summary>');
+        sections.push('');
+        sections.push('```json');
+        sections.push(JSON.stringify(agenticResult.conversationHistory, null, 2));
+        sections.push('```');
+        sections.push('');
+        sections.push('</details>');
+        sections.push('');
+        sections.push('## Generated Commit Message');
+        sections.push('');
+        sections.push('```');
+        sections.push(agenticResult.commitMessage);
+        sections.push('```');
+        sections.push('');
+        if (agenticResult.suggestedSplits && agenticResult.suggestedSplits.length > 1) {
+            sections.push('## Suggested Commit Splits');
+            sections.push('');
+            for(let i = 0; i < agenticResult.suggestedSplits.length; i++){
+                const split = agenticResult.suggestedSplits[i];
+                sections.push(`### Split ${i + 1}`);
+                sections.push('');
+                sections.push(`**Files**: ${split.files.join(', ')}`);
+                sections.push('');
+                sections.push(`**Rationale**: ${split.rationale}`);
+                sections.push('');
+                sections.push(`**Message**:`);
+                sections.push('```');
+                sections.push(split.message);
+                sections.push('```');
+                sections.push('');
+            }
+        }
+        sections.push('## Recommendations for Improvement');
+        sections.push('');
+        // Generate recommendations based on metrics
+        const recommendations = [];
+        // Recalculate failed tools for recommendations
+        const toolsWithFailures = Array.from(toolStats.entries()).filter(([_, stats])=>stats.failures > 0);
+        if (toolsWithFailures.length > 0) {
+            recommendations.push('- **Tool Failures**: Investigate and fix tools that are failing. This may indicate issues with error handling or tool implementation.');
+        }
+        // Recalculate slow tools for recommendations
+        const slowToolsForRecs = Array.from(toolStats.entries()).filter(([_, stats])=>stats.totalDuration / stats.total > 1000);
+        if (slowToolsForRecs.length > 0) {
+            recommendations.push('- **Performance**: Consider optimizing slow tools or caching results to improve execution speed.');
+        }
+        if (agenticResult.iterations >= (agenticResult.maxIterations || 10)) {
+            recommendations.push('- **Max Iterations Reached**: The agent reached maximum iterations. Consider increasing the limit or improving tool efficiency to allow the agent to complete naturally.');
+        }
+        const underutilizedTools = Array.from(toolStats.entries()).filter(([_, stats])=>stats.total === 1);
+        if (underutilizedTools.length > 3) {
+            recommendations.push('- **Underutilized Tools**: Many tools were called only once. Consider whether all tools are necessary or if the agent needs better guidance on when to use them.');
+        }
+        if (recommendations.length === 0) {
+            sections.push('*No specific recommendations at this time. Execution appears optimal.*');
+        } else {
+            for (const rec of recommendations){
+                sections.push(rec);
+            }
+        }
+        sections.push('');
+        // Write the reflection file
+        const reflectionContent = sections.join('\n');
+        await storage.writeFile(reflectionPath, reflectionContent, 'utf-8');
+        logger.info('');
+        logger.info('═'.repeat(80));
+        logger.info('📊 SELF-REFLECTION REPORT GENERATED');
+        logger.info('═'.repeat(80));
+        logger.info('');
+        logger.info('📁 Location: %s', reflectionPath);
+        logger.info('');
+        logger.info('📈 Report Summary:');
+        logger.info('   • %d iterations completed', agenticResult.iterations);
+        logger.info('   • %d tool calls executed', agenticResult.toolCallsExecuted);
+        logger.info('   • %d unique tools used', toolStats.size);
+        logger.info('');
+        logger.info('💡 Use this report to:');
+        logger.info('   • Understand which tools were most effective');
+        logger.info('   • Identify performance bottlenecks');
+        logger.info('   • Review the complete agentic conversation');
+        logger.info('   • Improve tool implementation based on metrics');
+        logger.info('');
+        logger.info('═'.repeat(80));
+    } catch (error) {
+        logger.warn('Failed to generate self-reflection output: %s', error.message);
+        logger.debug('Self-reflection error details:', error);
+    }
+}
 // Helper function to get current version from package.json
 async function getCurrentVersion(storage) {
     try {
@@ -257,7 +444,7 @@ const saveCommitMessage = async (outputDirectory, summary, storage, logger)=>{
     }
 };
 const executeInternal = async (runConfig)=>{
-    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _aiConfig_commands_commit, _aiConfig_commands, _aiConfig_commands_commit1, _aiConfig_commands1, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7, _runConfig_commit8, _runConfig_commit9;
+    var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7, _runConfig_commit8, _runConfig_commit9, _runConfig_commit10;
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     // Track if user explicitly chose to skip in interactive mode
@@ -293,9 +480,9 @@ const executeInternal = async (runConfig)=>{
     if (!hasActualChanges) {
         const criticalChanges = await hasCriticalExcludedChanges();
         if (criticalChanges.hasChanges) {
-            var _runConfig_commit10;
+            var _runConfig_commit11;
             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_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.sendit) && !isDryRun) {
+            if (((_runConfig_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.sendit) && !isDryRun) {
                 // 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');
                 var _runConfig_excludedPatterns1;
@@ -327,10 +514,10 @@ const executeInternal = async (runConfig)=>{
                 }
             }
         } else {
-            var _runConfig_commit11;
+            var _runConfig_commit12;
             // 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_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.sendit) && !isDryRun) {
+            if (((_runConfig_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.sendit) && !isDryRun) {
                 logger.warn('No changes detected to commit. Skipping commit operation.');
                 return 'No changes to commit.';
             } else {
@@ -350,8 +537,8 @@ const executeInternal = async (runConfig)=>{
                     isUsingFileContent = true;
                     hasActualChanges = true; // We have content to work with
                 } else {
-                    var _runConfig_commit12;
-                    if ((_runConfig_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.sendit) {
+                    var _runConfig_commit13;
+                    if ((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.sendit) {
                         logger.info('COMMIT_SKIPPED: Skipping commit operation | Reason: No changes detected | Action: None');
                         return 'No changes to commit.';
                     } else {
@@ -405,6 +592,7 @@ const executeInternal = async (runConfig)=>{
     const aiConfig = toAIConfig(runConfig);
     const aiStorageAdapter = createStorageAdapter();
     const aiLogger = createLoggerAdapter(isDryRun);
+    // Define promptContext for use in both agentic and traditional modes
     const promptContent = {
         diffContent,
         userDirection,
@@ -416,65 +604,122 @@ const executeInternal = async (runConfig)=>{
         context: (_runConfig_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.context,
         directories: runConfig.contextDirectories
     };
-    const prompt = await createCommitPrompt(promptConfig, promptContent, promptContext);
-    // Get the appropriate model for the commit command
-    const modelToUse = ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_commit = _aiConfig_commands.commit) === null || _aiConfig_commands_commit === void 0 ? void 0 : _aiConfig_commands_commit.model) || aiConfig.model || 'gpt-4o-mini';
-    // Use consistent model for debug (fix hardcoded model)
-    if (runConfig.debug) {
-        const formattedPrompt = Formatter.create({
+    let rawSummary;
+    // Check if agentic mode is enabled
+    if ((_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.agentic) {
+        var _runConfig_commit14, _aiConfig_commands_commit, _aiConfig_commands, _runConfig_commit15, _aiConfig_commands_commit1, _aiConfig_commands1, _runConfig_commit16, _runConfig_commit17;
+        logger.info('🤖 Using agentic mode for commit message generation');
+        // Announce self-reflection if enabled
+        if ((_runConfig_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.selfReflection) {
+            logger.info('📊 Self-reflection enabled - detailed analysis will be generated');
+        }
+        // Get list of changed files
+        const changedFilesResult = await run(`git diff --name-only ${cached ? '--cached' : ''}`);
+        const changedFilesOutput = typeof changedFilesResult === 'string' ? changedFilesResult : changedFilesResult.stdout;
+        const changedFiles = changedFilesOutput.split('\n').filter((f)=>f.trim().length > 0);
+        logger.debug('Changed files for agentic analysis: %d files', changedFiles.length);
+        // Run agentic commit generation
+        const agenticResult = await runAgenticCommit({
+            changedFiles,
+            diffContent,
+            userDirection,
+            logContext,
+            model: ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_commit = _aiConfig_commands.commit) === null || _aiConfig_commands_commit === void 0 ? void 0 : _aiConfig_commands_commit.model) || aiConfig.model,
+            maxIterations: ((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.maxAgenticIterations) || 10,
+            debug: runConfig.debug,
+            debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('commit-agentic')),
+            debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('commit-agentic')),
+            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
+        });
+        logger.info('🔍 Agentic analysis complete: %d iterations, %d tool calls', agenticResult.iterations, agenticResult.toolCallsExecuted);
+        // Generate self-reflection output if enabled
+        if ((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.selfReflection) {
+            await generateSelfReflection(agenticResult, outputDirectory, storage, logger);
+        }
+        // Check for suggested splits
+        if (agenticResult.suggestedSplits.length > 1 && ((_runConfig_commit17 = runConfig.commit) === null || _runConfig_commit17 === void 0 ? void 0 : _runConfig_commit17.allowCommitSplitting)) {
+            logger.info('\n📋 Agent suggests splitting this into %d commits:', agenticResult.suggestedSplits.length);
+            for(let i = 0; i < agenticResult.suggestedSplits.length; i++){
+                const split = agenticResult.suggestedSplits[i];
+                logger.info('\nCommit %d (%d files):', i + 1, split.files.length);
+                logger.info('  Files: %s', split.files.join(', '));
+                logger.info('  Rationale: %s', split.rationale);
+                logger.info('  Message: %s', split.message);
+            }
+            logger.info('\n⚠️  Commit splitting is not yet automated. Please stage and commit files separately.');
+            logger.info('Using combined message for now...\n');
+        } else if (agenticResult.suggestedSplits.length > 1) {
+            logger.debug('Agent suggested %d splits but commit splitting is not enabled', agenticResult.suggestedSplits.length);
+        }
+        rawSummary = agenticResult.commitMessage;
+    } else {
+        var _aiConfig_commands_commit2, _aiConfig_commands2, _aiConfig_commands_commit3, _aiConfig_commands3;
+        // Traditional single-shot approach
+        const prompt = await createCommitPrompt(promptConfig, promptContent, promptContext);
+        // Get the appropriate model for the commit command
+        const modelToUse = ((_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 || 'gpt-4o-mini';
+        // Use consistent model for debug (fix hardcoded model)
+        if (runConfig.debug) {
+            const formattedPrompt = Formatter.create({
+                logger
+            }).formatPrompt(modelToUse, prompt);
+            logger.silly('Formatted Prompt: %s', stringifyJSON(formattedPrompt));
+        }
+        const request = Formatter.create({
             logger
         }).formatPrompt(modelToUse, prompt);
-        logger.silly('Formatted Prompt: %s', stringifyJSON(formattedPrompt));
-    }
-    const request = Formatter.create({
-        logger
-    }).formatPrompt(modelToUse, prompt);
-    // Create retry callback that reduces diff size on token limit errors
-    const createRetryCallback = (originalDiffContent)=>async (attempt)=>{
-            var _runConfig_commit;
-            logger.info('COMMIT_RETRY: Retrying with reduced diff size | Attempt: %d | Strategy: Truncate diff | Reason: Previous attempt failed', attempt);
-            // Progressively reduce the diff size on retries
-            const reductionFactor = Math.pow(0.5, attempt - 1); // 50% reduction per retry
-            const reducedMaxDiffBytes = Math.max(512, Math.floor(maxDiffBytes * reductionFactor));
-            logger.debug('Reducing maxDiffBytes from %d to %d for retry', maxDiffBytes, reducedMaxDiffBytes);
-            // Re-truncate the diff with smaller limits
-            const reducedDiffContent = originalDiffContent.length > reducedMaxDiffBytes ? truncateDiffByFiles(originalDiffContent, reducedMaxDiffBytes) : originalDiffContent;
-            // Rebuild the prompt with the reduced diff
-            const reducedPromptContent = {
-                diffContent: reducedDiffContent,
-                userDirection
-            };
-            const reducedPromptContext = {
-                logContext,
-                context: (_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.context,
-                directories: runConfig.contextDirectories
+        // Create retry callback that reduces diff size on token limit errors
+        const createRetryCallback = (originalDiffContent)=>async (attempt)=>{
+                var _runConfig_commit;
+                logger.info('COMMIT_RETRY: Retrying with reduced diff size | Attempt: %d | Strategy: Truncate diff | Reason: Previous attempt failed', attempt);
+                // Progressively reduce the diff size on retries
+                const reductionFactor = Math.pow(0.5, attempt - 1); // 50% reduction per retry
+                const reducedMaxDiffBytes = Math.max(512, Math.floor(maxDiffBytes * reductionFactor));
+                logger.debug('Reducing maxDiffBytes from %d to %d for retry', maxDiffBytes, reducedMaxDiffBytes);
+                // Re-truncate the diff with smaller limits
+                const reducedDiffContent = originalDiffContent.length > reducedMaxDiffBytes ? truncateDiffByFiles(originalDiffContent, reducedMaxDiffBytes) : originalDiffContent;
+                // Rebuild the prompt with the reduced diff
+                const reducedPromptContent = {
+                    diffContent: reducedDiffContent,
+                    userDirection
+                };
+                const reducedPromptContext = {
+                    logContext,
+                    context: (_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.context,
+                    directories: runConfig.contextDirectories
+                };
+                const retryPrompt = await createCommitPrompt(promptConfig, reducedPromptContent, reducedPromptContext);
+                const retryRequest = Formatter.create({
+                    logger
+                }).formatPrompt(modelToUse, retryPrompt);
+                return retryRequest.messages;
             };
-            const retryPrompt = await createCommitPrompt(promptConfig, reducedPromptContent, reducedPromptContext);
-            const retryRequest = Formatter.create({
-                logger
-            }).formatPrompt(modelToUse, retryPrompt);
-            return retryRequest.messages;
-        };
-    const summary = await createCompletionWithRetry(request.messages, {
-        model: modelToUse,
-        openaiReasoning: ((_aiConfig_commands1 = aiConfig.commands) === null || _aiConfig_commands1 === void 0 ? void 0 : (_aiConfig_commands_commit1 = _aiConfig_commands1.commit) === null || _aiConfig_commands_commit1 === void 0 ? void 0 : _aiConfig_commands_commit1.reasoning) || aiConfig.reasoning,
-        debug: runConfig.debug,
-        debugRequestFile: getOutputPath(runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY, getTimestampedRequestFilename('commit')),
-        debugResponseFile: getOutputPath(runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY, getTimestampedResponseFilename('commit')),
-        storage: aiStorageAdapter,
-        logger: aiLogger
-    }, createRetryCallback(diffContent));
+        rawSummary = await createCompletionWithRetry(request.messages, {
+            model: modelToUse,
+            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,
+            debug: runConfig.debug,
+            debugRequestFile: getOutputPath(runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY, getTimestampedRequestFilename('commit')),
+            debugResponseFile: getOutputPath(runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY, getTimestampedResponseFilename('commit')),
+            storage: aiStorageAdapter,
+            logger: aiLogger
+        }, createRetryCallback(diffContent));
+    }
+    // Apply stop-context filtering to commit message
+    const filterResult = filterContent(rawSummary, runConfig.stopContext);
+    const summary = filterResult.filtered;
     // Save timestamped copy of commit message with better error handling
     await saveCommitMessage(outputDirectory, summary, storage, logger);
     // 🛡️ Universal Safety Check: Run before ANY commit operation
     // This protects both direct commits (--sendit) and automated commits (publish, etc.)
-    const willCreateCommit = ((_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.sendit) && hasActualChanges && cached;
-    if (willCreateCommit && !((_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.skipFileCheck) && !isDryRun) {
+    const willCreateCommit = ((_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.sendit) && hasActualChanges && cached;
+    if (willCreateCommit && !((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.skipFileCheck) && !isDryRun) {
         logger.debug('Checking for file: dependencies before commit operation...');
         try {
             const fileDependencyIssues = await checkForFileDependencies(storage, process.cwd());
             if (fileDependencyIssues.length > 0) {
-                var _runConfig_commit13;
+                var _runConfig_commit18;
                 logger.error('🚫 COMMIT BLOCKED: Found file: dependencies that should not be committed!');
                 logger.error('');
                 logFileDependencyWarning(fileDependencyIssues, 'commit');
@@ -482,7 +727,7 @@ const executeInternal = async (runConfig)=>{
                 logger.error('Generated commit message was:');
                 logger.error('%s', summary);
                 logger.error('');
-                if ((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.sendit) {
+                if ((_runConfig_commit18 = runConfig.commit) === null || _runConfig_commit18 === void 0 ? void 0 : _runConfig_commit18.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');
@@ -494,12 +739,12 @@ const executeInternal = async (runConfig)=>{
             logger.warn('Warning: Could not check for file: dependencies: %s', error.message);
             logger.warn('Proceeding with commit...');
         }
-    } else if (((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.skipFileCheck) && willCreateCommit) {
+    } else if (((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.skipFileCheck) && willCreateCommit) {
         logger.warn('⚠️  Skipping file: dependency check as requested');
     }
     // Handle interactive mode
-    if (((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.interactive) && !isDryRun) {
-        var _runConfig_commit14;
+    if (((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.interactive) && !isDryRun) {
+        var _runConfig_commit19;
         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') {
@@ -509,23 +754,23 @@ const executeInternal = async (runConfig)=>{
             return interactiveResult.finalMessage;
         }
         // User chose to commit - check if sendit is enabled to determine what action to take
-        const senditEnabled = (_runConfig_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.sendit;
+        const senditEnabled = (_runConfig_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.sendit;
         const willActuallyCommit = senditEnabled && hasActualChanges && cached;
         if (willActuallyCommit) {
-            var _runConfig_commit15;
-            const commitAction = ((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.amend) ? 'amending last commit' : 'committing';
+            var _runConfig_commit20;
+            const commitAction = ((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.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_commit16, _runConfig_commit17;
+                var _runConfig_commit21, _runConfig_commit22;
                 const validatedSummary = validateString(interactiveResult.finalMessage, 'commit summary');
                 const escapedSummary = shellescape([
                     validatedSummary
                 ]);
-                const commitCommand = ((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.amend) ? `git commit --amend -m ${escapedSummary}` : `git commit -m ${escapedSummary}`;
+                const commitCommand = ((_runConfig_commit21 = runConfig.commit) === null || _runConfig_commit21 === void 0 ? void 0 : _runConfig_commit21.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_commit17 = runConfig.commit) === null || _runConfig_commit17 === void 0 ? void 0 : _runConfig_commit17.push, logger, isDryRun);
+                await pushCommit((_runConfig_commit22 = runConfig.commit) === null || _runConfig_commit22 === void 0 ? void 0 : _runConfig_commit22.push, logger, isDryRun);
             } catch (error) {
                 logger.error('Failed to commit:', error);
                 throw new ExternalDependencyError('Failed to create commit', 'git', error);
@@ -548,32 +793,32 @@ const executeInternal = async (runConfig)=>{
         logger.debug('Skipping sendit logic because user chose to skip in interactive mode');
         return summary;
     }
-    if ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.sendit) {
+    if ((_runConfig_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.sendit) {
         if (isDryRun) {
-            var _runConfig_commit18, _runConfig_commit19;
+            var _runConfig_commit23, _runConfig_commit24;
             logger.info('Would commit with message: \n\n%s\n\n', summary);
-            const commitAction = ((_runConfig_commit18 = runConfig.commit) === null || _runConfig_commit18 === void 0 ? void 0 : _runConfig_commit18.amend) ? 'git commit --amend -m <generated-message>' : 'git commit -m <generated-message>';
+            const commitAction = ((_runConfig_commit23 = runConfig.commit) === null || _runConfig_commit23 === void 0 ? void 0 : _runConfig_commit23.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_commit19 = runConfig.commit) === null || _runConfig_commit19 === void 0 ? void 0 : _runConfig_commit19.push) {
+            if ((_runConfig_commit24 = runConfig.commit) === null || _runConfig_commit24 === void 0 ? void 0 : _runConfig_commit24.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_commit20;
-            const commitAction = ((_runConfig_commit20 = runConfig.commit) === null || _runConfig_commit20 === void 0 ? void 0 : _runConfig_commit20.amend) ? 'amending commit' : 'committing';
+            var _runConfig_commit25;
+            const commitAction = ((_runConfig_commit25 = runConfig.commit) === null || _runConfig_commit25 === void 0 ? void 0 : _runConfig_commit25.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_commit21, _runConfig_commit22;
+                var _runConfig_commit26, _runConfig_commit27;
                 const validatedSummary = validateString(summary, 'commit summary');
                 const escapedSummary = shellescape([
                     validatedSummary
                 ]);
-                const commitCommand = ((_runConfig_commit21 = runConfig.commit) === null || _runConfig_commit21 === void 0 ? void 0 : _runConfig_commit21.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 successful!');
                 // Push if requested
-                await pushCommit((_runConfig_commit22 = runConfig.commit) === null || _runConfig_commit22 === void 0 ? void 0 : _runConfig_commit22.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);