@eldrforge/kodrdriv 1.2.125 → 1.2.127

package/dist/commands/release.js

@@ -5,7 +5,7 @@ import { DEFAULT_TO_COMMIT_ALIAS, DEFAULT_MAX_DIFF_BYTES, DEFAULT_EXCLUDED_PATTE
 import { getCurrentBranch, getDefaultFromRef, safeJsonParse } from '@eldrforge/git-tools';
 import { create } from '../content/log.js';
 import { create as create$1, truncateDiffByFiles } from '../content/diff.js';
-import { createReleasePrompt, createCompletionWithRetry, requireTTY, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor } from '@eldrforge/ai-service';
+import { runAgenticRelease, requireTTY, createReleasePrompt, createCompletionWithRetry, 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';
@@ -88,6 +88,189 @@ Please revise the release notes according to the user's feedback while maintaini
     };
     return await improveContentWithLLM(releaseSummary, runConfig, promptConfig, promptContext, outputDirectory, improvementConfig);
 }
+// Helper function to generate self-reflection output for release notes
+async function generateSelfReflection(agenticResult, outputDirectory, storage, logger) {
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const reflectionPath = getOutputPath(outputDirectory, `agentic-reflection-release-${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 Release Notes - 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 called during execution.*');
+            sections.push('');
+        } else {
+            sections.push('| Tool | Calls | Success Rate | Avg Duration | Total Time |');
+            sections.push('|------|-------|--------------|--------------|------------|');
+            const sortedTools = Array.from(toolStats.entries()).sort((a, b)=>b[1].total - a[1].total);
+            for (const [toolName, stats] of sortedTools){
+                const successRate = (stats.success / stats.total * 100).toFixed(1);
+                const avgDuration = (stats.totalDuration / stats.total).toFixed(0);
+                const totalTime = stats.totalDuration.toFixed(0);
+                sections.push(`| ${toolName} | ${stats.total} | ${successRate}% | ${avgDuration}ms | ${totalTime}ms |`);
+            }
+            sections.push('');
+        }
+        // Tool usage insights
+        sections.push('## Tool Usage Insights');
+        sections.push('');
+        if (toolStats.size > 0) {
+            const mostUsedTool = Array.from(toolStats.entries()).sort((a, b)=>b[1].total - a[1].total)[0];
+            sections.push(`- **Most Used Tool**: \`${mostUsedTool[0]}\` (${mostUsedTool[1].total} calls)`);
+            const slowestTool = Array.from(toolStats.entries()).sort((a, b)=>b[1].totalDuration / b[1].total - a[1].totalDuration / a[1].total)[0];
+            const slowestAvg = (slowestTool[1].totalDuration / slowestTool[1].total).toFixed(0);
+            sections.push(`- **Slowest Tool**: \`${slowestTool[0]}\` (${slowestAvg}ms average)`);
+            const failedTools = Array.from(toolStats.entries()).filter(([_, stats])=>stats.failures > 0);
+            if (failedTools.length > 0) {
+                sections.push(`- **Tools with Failures**: ${failedTools.length} tool(s) had at least one failure`);
+                for (const [toolName, stats] of failedTools){
+                    sections.push(`  - \`${toolName}\`: ${stats.failures}/${stats.total} calls failed`);
+                }
+            } else {
+                sections.push('- **Reliability**: All tool calls succeeded ✓');
+            }
+        }
+        sections.push('');
+        // Execution patterns
+        sections.push('## Execution Patterns');
+        sections.push('');
+        const iterationsPerToolCall = agenticResult.toolCallsExecuted > 0 ? (agenticResult.iterations / agenticResult.toolCallsExecuted).toFixed(2) : 'N/A';
+        sections.push(`- **Iterations per Tool Call**: ${iterationsPerToolCall}`);
+        const totalExecutionTime = Array.from(toolStats.values()).reduce((sum, stats)=>sum + stats.totalDuration, 0);
+        sections.push(`- **Total Tool Execution Time**: ${totalExecutionTime.toFixed(0)}ms`);
+        if (agenticResult.toolCallsExecuted > 0) {
+            const avgTimePerCall = (totalExecutionTime / agenticResult.toolCallsExecuted).toFixed(0);
+            sections.push(`- **Average Time per Tool Call**: ${avgTimePerCall}ms`);
+        }
+        sections.push('');
+        // Recommendations
+        sections.push('## Recommendations');
+        sections.push('');
+        const recommendations = [];
+        const failedTools = Array.from(toolStats.entries()).filter(([_, stats])=>stats.failures > 0);
+        if (failedTools.length > 0) {
+            recommendations.push('- **Tool Reliability**: Some tools failed during execution. Review error messages and consider improving error handling or tool implementation.');
+        }
+        const slowTools = Array.from(toolStats.entries()).filter(([_, stats])=>stats.totalDuration / stats.total > 1000);
+        if (slowTools.length > 0) {
+            recommendations.push('- **Performance**: Consider optimizing slow tools or caching results to improve execution speed.');
+        }
+        if (agenticResult.iterations >= (agenticResult.maxIterations || 30)) {
+            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 (agenticResult.toolCallsExecuted === 0) {
+            recommendations.push('- **No Tools Used**: The agent completed without calling any tools. This might indicate the initial prompt provided sufficient information, or the agent may benefit from more explicit guidance to use tools.');
+        }
+        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('');
+        // Add detailed execution timeline
+        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('');
+        }
+        // Add conversation history
+        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('');
+        // Add generated release notes
+        sections.push('## Generated Release Notes');
+        sections.push('');
+        sections.push('### Title');
+        sections.push('```');
+        sections.push(agenticResult.releaseNotes.title);
+        sections.push('```');
+        sections.push('');
+        sections.push('### Body');
+        sections.push('```markdown');
+        sections.push(agenticResult.releaseNotes.body);
+        sections.push('```');
+        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('   • Optimize tool selection and usage patterns');
+        logger.info('   • Improve agentic release notes generation');
+        logger.info('');
+        logger.info('═'.repeat(80));
+    } catch (error) {
+        logger.warn('Failed to generate self-reflection report: %s', error.message);
+    }
+}
 // Interactive feedback loop for release notes
 async function handleInteractiveReleaseFeedback(releaseSummary, runConfig, promptConfig, promptContext, outputDirectory, storage, logContent, diffContent) {
     const logger = getDryRunLogger(false);
@@ -143,7 +326,7 @@ async function handleInteractiveReleaseFeedback(releaseSummary, runConfig, promp
     }
 }
 const execute = async (runConfig)=>{
-    var _runConfig_release, _runConfig_release1, _runConfig_release2, _runConfig_release3, _runConfig_release4, _runConfig_release5, _runConfig_release6, _runConfig_release7, _runConfig_release8, _aiConfig_commands_release, _aiConfig_commands, _aiConfig_commands_release1, _aiConfig_commands1, _runConfig_release9;
+    var _runConfig_release, _runConfig_release1, _runConfig_release2, _runConfig_release3, _runConfig_release4, _runConfig_release5, _runConfig_release6, _runConfig_release7, _runConfig_release8, _runConfig_release9, _aiConfig_commands_release, _aiConfig_commands, _aiConfig_commands_release1, _aiConfig_commands1, _runConfig_release10;
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     // Get current branch to help determine best tag comparison
@@ -234,14 +417,87 @@ const execute = async (runConfig)=>{
     const aiConfig = toAIConfig(runConfig);
     const aiStorageAdapter = createStorageAdapter();
     const aiLogger = createLoggerAdapter(isDryRun);
+    // Always ensure output directory exists for request/response files
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = createStorage();
+    await storage.ensureDirectory(outputDirectory);
+    // Check if agentic mode is enabled
+    if ((_runConfig_release7 = runConfig.release) === null || _runConfig_release7 === void 0 ? void 0 : _runConfig_release7.agentic) {
+        var _runConfig_release11, _runConfig_release12, _aiConfig_commands_release2, _aiConfig_commands2, _runConfig_release13, _aiConfig_commands_release3, _aiConfig_commands3, _runConfig_release14, _runConfig_release15;
+        logger.info('🤖 Using agentic mode for release notes generation');
+        // Run agentic release notes generation
+        const agenticResult = await runAgenticRelease({
+            fromRef,
+            toRef,
+            logContent,
+            diffContent,
+            milestoneIssues: milestoneIssuesContent,
+            releaseFocus: (_runConfig_release11 = runConfig.release) === null || _runConfig_release11 === void 0 ? void 0 : _runConfig_release11.focus,
+            userContext: (_runConfig_release12 = runConfig.release) === null || _runConfig_release12 === void 0 ? void 0 : _runConfig_release12.context,
+            model: ((_aiConfig_commands2 = aiConfig.commands) === null || _aiConfig_commands2 === void 0 ? void 0 : (_aiConfig_commands_release2 = _aiConfig_commands2.release) === null || _aiConfig_commands_release2 === void 0 ? void 0 : _aiConfig_commands_release2.model) || aiConfig.model || 'gpt-4o',
+            maxIterations: ((_runConfig_release13 = runConfig.release) === null || _runConfig_release13 === void 0 ? void 0 : _runConfig_release13.maxAgenticIterations) || 30,
+            debug: runConfig.debug,
+            debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('release-agentic')),
+            debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('release-agentic')),
+            storage: aiStorageAdapter,
+            logger: aiLogger,
+            openaiReasoning: ((_aiConfig_commands3 = aiConfig.commands) === null || _aiConfig_commands3 === void 0 ? void 0 : (_aiConfig_commands_release3 = _aiConfig_commands3.release) === null || _aiConfig_commands_release3 === void 0 ? void 0 : _aiConfig_commands_release3.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_release14 = runConfig.release) === null || _runConfig_release14 === void 0 ? void 0 : _runConfig_release14.selfReflection) {
+            await generateSelfReflection(agenticResult, outputDirectory, storage, logger);
+        }
+        // Apply stop-context filtering to release notes
+        const titleFilterResult = filterContent(agenticResult.releaseNotes.title, runConfig.stopContext);
+        const bodyFilterResult = filterContent(agenticResult.releaseNotes.body, runConfig.stopContext);
+        let releaseSummary = {
+            title: titleFilterResult.filtered,
+            body: bodyFilterResult.filtered
+        };
+        // Handle interactive mode
+        if (((_runConfig_release15 = runConfig.release) === null || _runConfig_release15 === void 0 ? void 0 : _runConfig_release15.interactive) && !isDryRun) {
+            var _runConfig_release16;
+            requireTTY('Interactive mode requires a terminal. Use --dry-run instead.');
+            const interactivePromptContext = {
+                context: (_runConfig_release16 = runConfig.release) === null || _runConfig_release16 === void 0 ? void 0 : _runConfig_release16.context,
+                directories: runConfig.contextDirectories
+            };
+            const interactiveResult = await handleInteractiveReleaseFeedback(releaseSummary, runConfig, promptConfig, interactivePromptContext, outputDirectory, storage, logContent, diffContent);
+            if (interactiveResult.action === 'skip') {
+                logger.info('RELEASE_ABORTED: Release notes generation aborted by user | Reason: User choice | Status: cancelled');
+            } else {
+                logger.info('RELEASE_FINALIZED: Release notes finalized and accepted | Status: ready | Next: Create release or save');
+            }
+            releaseSummary = interactiveResult.finalSummary;
+        }
+        // Save timestamped copy of release notes to output directory
+        try {
+            const timestampedFilename = getTimestampedReleaseNotesFilename();
+            const outputPath = getOutputPath(outputDirectory, timestampedFilename);
+            // Format the release notes as markdown
+            const releaseNotesContent = `# ${releaseSummary.title}\n\n${releaseSummary.body}`;
+            await storage.writeFile(outputPath, releaseNotesContent, 'utf-8');
+            logger.debug('Saved timestamped release notes: %s', outputPath);
+        } catch (error) {
+            logger.warn('RELEASE_SAVE_FAILED: Failed to save timestamped release notes | Error: %s | Impact: Notes not persisted to file', error.message);
+        }
+        if (isDryRun) {
+            logger.info('RELEASE_SUMMARY_COMPLETE: Generated release summary successfully | Status: completed');
+            logger.info('RELEASE_SUMMARY_TITLE: %s', releaseSummary.title);
+            logger.info('RELEASE_SUMMARY_BODY: %s', releaseSummary.body);
+        }
+        return releaseSummary;
+    }
+    // Non-agentic mode: use traditional prompt-based approach
     const promptContent = {
         logContent,
         diffContent,
-        releaseFocus: (_runConfig_release7 = runConfig.release) === null || _runConfig_release7 === void 0 ? void 0 : _runConfig_release7.focus,
+        releaseFocus: (_runConfig_release8 = runConfig.release) === null || _runConfig_release8 === void 0 ? void 0 : _runConfig_release8.focus,
         milestoneIssues: milestoneIssuesContent
     };
     const promptContext = {
-        context: (_runConfig_release8 = runConfig.release) === null || _runConfig_release8 === void 0 ? void 0 : _runConfig_release8.context,
+        context: (_runConfig_release9 = runConfig.release) === null || _runConfig_release9 === void 0 ? void 0 : _runConfig_release9.context,
         directories: runConfig.contextDirectories
     };
     const promptResult = await createReleasePrompt(promptConfig, promptContent, promptContext);
@@ -249,10 +505,6 @@ const execute = async (runConfig)=>{
     const request = Formatter.create({
         logger
     }).formatPrompt(modelToUse, promptResult.prompt);
-    // Always ensure output directory exists for request/response files
-    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
-    const storage = createStorage();
-    await storage.ensureDirectory(outputDirectory);
     logger.debug('Release analysis: isLargeRelease=%s, maxTokens=%d', promptResult.isLargeRelease, promptResult.maxTokens);
     // Create retry callback that reduces diff size on token limit errors
     const createRetryCallback = (originalDiffContent, originalLogContent)=>async (attempt)=>{
@@ -304,7 +556,7 @@ const execute = async (runConfig)=>{
         body: bodyFilterResult.filtered
     };
     // Handle interactive mode
-    if (((_runConfig_release9 = runConfig.release) === null || _runConfig_release9 === void 0 ? void 0 : _runConfig_release9.interactive) && !isDryRun) {
+    if (((_runConfig_release10 = runConfig.release) === null || _runConfig_release10 === void 0 ? void 0 : _runConfig_release10.interactive) && !isDryRun) {
         requireTTY('Interactive mode requires a terminal. Use --dry-run instead.');
         const interactiveResult = await handleInteractiveReleaseFeedback(releaseSummary, runConfig, promptConfig, promptContext, outputDirectory, storage, logContent, diffContent);
         if (interactiveResult.action === 'skip') {