@grunnverk/kilde 0.1.0

package/src/application.ts

@@ -0,0 +1,246 @@
+// Load .env file if it exists, but NEVER override existing environment variables
+import { config as dotenvConfig } from 'dotenv';
+dotenvConfig({ override: false, debug: false });
+
+import { setLogger as setGitLogger } from '@grunnverk/git-tools';
+import { initializeTemplates } from '@grunnverk/ai-service';
+import { Config } from '@grunnverk/core';
+import { Command } from 'commander';
+
+// Import commands
+import * as CommandsGit from '@grunnverk/commands-git';
+import * as ReleaseCommand from './commands/release';
+
+import {
+    COMMAND_COMMIT,
+    COMMAND_RELEASE,
+    VERSION,
+    BUILD_HOSTNAME,
+    BUILD_TIMESTAMP,
+    KILDE_DEFAULTS,
+    PROGRAM_NAME
+} from './constants';
+import { getLogger, setLogLevel } from './logging';
+import { getEffectiveConfig } from './utils/config';
+
+/**
+ * Check Node.js version and exit with clear error message if version is too old.
+ */
+function checkNodeVersion(): void {
+    const requiredMajorVersion = 24;
+    const currentVersion = process.version;
+    const majorVersion = parseInt(currentVersion.slice(1).split('.')[0], 10);
+
+    if (majorVersion < requiredMajorVersion) {
+        // eslint-disable-next-line no-console
+        console.error(`\n❌ ERROR: Node.js version ${requiredMajorVersion}.0.0 or higher is required.`);
+        // eslint-disable-next-line no-console
+        console.error(`   Current version: ${currentVersion}`);
+        // eslint-disable-next-line no-console
+        console.error(`   Please upgrade your Node.js version to continue.\n`);
+        process.exit(1);
+    }
+}
+
+/**
+ * Get formatted version information including build metadata.
+ */
+export function getVersionInfo(): { version: string; buildHostname: string; buildTimestamp: string; formatted: string } {
+    return {
+        version: VERSION,
+        buildHostname: BUILD_HOSTNAME,
+        buildTimestamp: BUILD_TIMESTAMP,
+        formatted: `${VERSION}\nBuilt on: ${BUILD_HOSTNAME}\nBuild time: ${BUILD_TIMESTAMP}`
+    };
+}
+
+/**
+ * Parse command line arguments and merge with config
+ */
+async function parseArguments(): Promise<{ commandName: string; config: Config }> {
+    const program = new Command();
+
+    program
+        .name(PROGRAM_NAME)
+        .description('Universal Git Automation Tool - AI-powered commit and release messages')
+        .version(VERSION)
+        .option('-v, --verbose', 'Enable verbose logging')
+        .option('-d, --debug', 'Enable debug logging')
+        .option('--dry-run', 'Preview without making changes')
+        .option('--model <model>', 'AI model to use (default: gpt-4o-mini)')
+        .option('--reasoning <level>', 'OpenAI reasoning level: low, medium, high (default: low)');
+
+    // Commit command
+    program
+        .command('commit')
+        .description('Generate AI-powered commit message')
+        .option('--add', 'Stage all changes before committing')
+        .option('--cached', 'Only use staged changes')
+        .option('--sendit', 'Automatically commit with generated message')
+        .option('--interactive', 'Interactive mode for reviewing message')
+        .option('--amend', 'Amend the previous commit')
+        .option('--push [remote]', 'Push after committing (optionally specify remote)')
+        .option('--issue <number>', 'Reference issue number')
+        .option('--context <text>', 'Additional context for commit message')
+        .option('--context-files <files...>', 'Context files to include')
+        .action(async (options) => {
+            const config = await buildConfig('commit', options);
+            await executeCommand(COMMAND_COMMIT, config);
+        });
+
+    // Release command
+    program
+        .command('release')
+        .description('Generate release notes from git history')
+        .option('--from-tag <tag>', 'Start tag for release notes')
+        .option('--to-tag <tag>', 'End tag for release notes (default: HEAD)')
+        .option('--version <version>', 'Version number for release')
+        .option('--output <file>', 'Output file path')
+        .option('--interactive', 'Interactive mode for reviewing notes')
+        .option('--focus <text>', 'Focus area for release notes')
+        .option('--context <text>', 'Additional context for release notes')
+        .option('--context-files <files...>', 'Context files to include')
+        .action(async (options) => {
+            const config = await buildConfig('release', options);
+            await executeCommand(COMMAND_RELEASE, config);
+        });
+
+    program.parse();
+
+    // Return empty config if help or version was shown
+    return { commandName: '', config: KILDE_DEFAULTS };
+}
+
+/**
+ * Build final configuration from defaults, config file, and CLI arguments
+ */
+async function buildConfig(commandName: string, cliOptions: any): Promise<Config> {
+    // Load config from file
+    const fileConfig = await getEffectiveConfig();
+
+    // Start with defaults
+    const config: Config = { ...KILDE_DEFAULTS };
+
+    // Merge file config
+    Object.assign(config, fileConfig);
+
+    // Merge CLI global options
+    if (cliOptions.parent.verbose !== undefined) config.verbose = cliOptions.parent.verbose;
+    if (cliOptions.parent.debug !== undefined) config.debug = cliOptions.parent.debug;
+    if (cliOptions.parent.dryRun !== undefined) config.dryRun = cliOptions.parent.dryRun;
+    if (cliOptions.parent.model) config.model = cliOptions.parent.model;
+    if (cliOptions.parent.reasoning) config.openaiReasoning = cliOptions.parent.reasoning;
+
+    // Merge command-specific options
+    if (commandName === 'commit') {
+        config.commit = config.commit || {};
+        if (cliOptions.add !== undefined) config.commit.add = cliOptions.add;
+        if (cliOptions.cached !== undefined) config.commit.cached = cliOptions.cached;
+        if (cliOptions.sendit !== undefined) config.commit.sendit = cliOptions.sendit;
+        if (cliOptions.interactive !== undefined) config.commit.interactive = cliOptions.interactive;
+        if (cliOptions.amend !== undefined) config.commit.amend = cliOptions.amend;
+        if (cliOptions.push !== undefined) config.commit.push = cliOptions.push;
+        if (cliOptions.context) config.commit.context = cliOptions.context;
+        if (cliOptions.contextFiles) config.commit.contextFiles = cliOptions.contextFiles;
+    } else if (commandName === 'release') {
+        config.release = config.release || {};
+        if (cliOptions.fromTag) config.release.from = cliOptions.fromTag;
+        if (cliOptions.toTag) config.release.to = cliOptions.toTag;
+        if (cliOptions.interactive !== undefined) config.release.interactive = cliOptions.interactive;
+        if (cliOptions.focus) config.release.focus = cliOptions.focus;
+        if (cliOptions.context) config.release.context = cliOptions.context;
+        if (cliOptions.contextFiles) config.release.contextFiles = cliOptions.contextFiles;
+        // Add non-standard fields as any
+        if (cliOptions.version) (config.release as any).version = cliOptions.version;
+        if (cliOptions.output) (config.release as any).output = cliOptions.output;
+    }
+
+    // Return config (no validation needed - already built from defaults)
+    return config as unknown as Config;
+}
+
+/**
+ * Execute the specified command
+ */
+async function executeCommand(commandName: string, runConfig: Config): Promise<void> {
+    const logger = getLogger();
+
+    // Configure logging level
+    if (runConfig.verbose) {
+        setLogLevel('verbose');
+    }
+    if (runConfig.debug) {
+        setLogLevel('debug');
+    }
+
+    // Configure external packages to use our logger
+    setGitLogger(logger);
+
+    logger.info('APPLICATION_STARTING: Kilde application initializing | Version: %s | BuildHost: %s | BuildTime: %s | Status: starting',
+        VERSION, BUILD_HOSTNAME, BUILD_TIMESTAMP);
+
+    logger.debug(`Executing command: ${commandName}`);
+
+    let summary: string = '';
+
+    try {
+        if (commandName === COMMAND_COMMIT) {
+            summary = await CommandsGit.commit(runConfig);
+        } else if (commandName === COMMAND_RELEASE) {
+            const releaseSummary = await ReleaseCommand.execute(runConfig);
+            summary = `Release notes generated:\nTitle: ${releaseSummary.title}\n\n${releaseSummary.body}`;
+        } else {
+            throw new Error(`Unknown command: ${commandName}`);
+        }
+
+        if (summary) {
+            logger.info('COMMAND_COMPLETE: Command executed successfully | Status: success');
+            if (runConfig.verbose || runConfig.debug) {
+                logger.info('COMMAND_SUMMARY: %s', summary);
+            }
+        }
+
+    } catch (error: any) {
+        // Handle user cancellation gracefully
+        if (error.name === 'UserCancellationError' || error.message?.includes('cancelled')) {
+            logger.info('COMMAND_CANCELLED: Command cancelled by user | Status: cancelled');
+            return;
+        }
+
+        // Log and re-throw other errors
+        logger.error('COMMAND_FAILED: Command execution failed | Error: %s | Status: error', error.message);
+        throw error;
+    }
+}
+
+/**
+ * Configure early logging based on command line flags.
+ */
+export function configureEarlyLogging(): void {
+    const hasVerbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+    const hasDebug = process.argv.includes('--debug') || process.argv.includes('-d');
+
+    // Set log level based on early flag detection
+    if (hasDebug) {
+        setLogLevel('debug');
+    } else if (hasVerbose) {
+        setLogLevel('verbose');
+    }
+}
+
+/**
+ * Main application entry point
+ */
+export async function runApplication(): Promise<void> {
+    // Check Node.js version first
+    checkNodeVersion();
+
+    // Configure logging early
+    configureEarlyLogging();
+
+    // Initialize RiotPrompt templates for ai-service
+    initializeTemplates();
+
+    // Parse arguments and execute command
+    await parseArguments();
+}

package/src/commands/release.ts

@@ -0,0 +1,450 @@
+#!/usr/bin/env node
+/**
+ * Pure Git-Only Release Notes Generator
+ *
+ * This is a simplified version of the release command that works with pure git
+ * operations only - no GitHub API dependencies, making it work with any git host
+ * (GitHub, GitLab, Bitbucket, self-hosted, etc.)
+ */
+import 'dotenv/config';
+import type { ChatCompletionMessageParam } from 'openai/resources';
+import { getDefaultFromRef, getCurrentBranch } from '@grunnverk/git-tools';
+import { Formatter, Model } from '@riotprompt/riotprompt';
+import {
+    Config,
+    Log,
+    Diff,
+    DEFAULT_EXCLUDED_PATTERNS,
+    DEFAULT_TO_COMMIT_ALIAS,
+    DEFAULT_OUTPUT_DIRECTORY,
+    DEFAULT_MAX_DIFF_BYTES,
+    improveContentWithLLM,
+    toAIConfig,
+    createStorageAdapter,
+    createLoggerAdapter,
+    getDryRunLogger,
+    getOutputPath,
+    getTimestampedRequestFilename,
+    getTimestampedResponseFilename,
+    getTimestampedReleaseNotesFilename,
+    validateReleaseSummary,
+    ReleaseSummary,
+    filterContent,
+    type LLMImprovementConfig,
+} from '@grunnverk/core';
+import {
+    createCompletionWithRetry,
+    getUserChoice,
+    editContentInEditor,
+    getLLMFeedbackInEditor,
+    requireTTY,
+    STANDARD_CHOICES,
+    ReleaseContext,
+    runAgenticRelease,
+    generateReflectionReport,
+    createReleasePrompt,
+} from '@grunnverk/ai-service';
+import { createStorage } from '@grunnverk/shared';
+
+// Helper function to read context files
+async function readContextFiles(contextFiles: string[] | undefined, logger: any): Promise<string> {
+    if (!contextFiles || contextFiles.length === 0) {
+        return '';
+    }
+
+    const storage = createStorage();
+    const contextParts: string[] = [];
+
+    for (const filePath of contextFiles) {
+        try {
+            const content = await storage.readFile(filePath, 'utf8');
+            contextParts.push(`## Context from ${filePath}\n\n${content}\n`);
+            logger.debug(`Read context from file: ${filePath}`);
+        } catch (error: any) {
+            logger.warn(`Failed to read context file ${filePath}: ${error.message}`);
+        }
+    }
+
+    return contextParts.join('\n---\n\n');
+}
+
+// Helper function to edit release notes using editor
+async function editReleaseNotesInteractively(releaseSummary: ReleaseSummary): Promise<ReleaseSummary> {
+    const templateLines = [
+        '# Edit your release notes below. Lines starting with "#" will be ignored.',
+        '# The first line is the title, everything else is the body.',
+        '# Save and close the editor when you are done.'
+    ];
+
+    const content = `${releaseSummary.title}\n\n${releaseSummary.body}`;
+    const result = await editContentInEditor(content, templateLines, '.md');
+
+    const lines = result.content.split('\n');
+    const title = lines[0].trim();
+    const body = lines.slice(1).join('\n').trim();
+
+    return { title, body };
+}
+
+// Helper function to improve release notes using LLM
+async function improveReleaseNotesWithLLM(
+    releaseSummary: ReleaseSummary,
+    runConfig: Config,
+    promptConfig: any,
+    promptContext: any,
+    outputDirectory: string,
+    logContent: string,
+    diffContent: string
+): Promise<ReleaseSummary> {
+    // Get user feedback on what to improve using the editor
+    const releaseNotesContent = `${releaseSummary.title}\n\n${releaseSummary.body}`;
+    const userFeedback = await getLLMFeedbackInEditor('release notes', releaseNotesContent);
+
+    const improvementConfig: LLMImprovementConfig = {
+        contentType: 'release notes',
+        createImprovedPrompt: async (promptConfig, currentSummary, promptContext) => {
+            const improvementPromptContent = {
+                logContent: logContent,
+                diffContent: diffContent,
+                releaseFocus: `Please improve these release notes based on the user's feedback: "${userFeedback}".
+
+Current release notes:
+Title: "${currentSummary.title}"
+Body: "${currentSummary.body}"
+
+Please revise the release notes according to the user's feedback while maintaining accuracy and following good release note practices.`,
+            };
+            const promptResult = await createReleasePrompt(promptConfig, improvementPromptContent, promptContext);
+            // Format the prompt into a proper request with messages
+            const aiConfig = toAIConfig(runConfig);
+            const modelToUse = aiConfig.commands?.release?.model || aiConfig.model || 'gpt-4o-mini';
+            return Formatter.create({ logger: getDryRunLogger(false) }).formatPrompt(modelToUse as Model, promptResult.prompt);
+        },
+        callLLM: async (request, runConfig, outputDirectory) => {
+            const aiConfig = toAIConfig(runConfig);
+            const aiStorageAdapter = createStorageAdapter(outputDirectory);
+            const aiLogger = createLoggerAdapter(false);
+            const modelToUse = aiConfig.commands?.release?.model || aiConfig.model || 'gpt-4o-mini';
+            const openaiReasoning = aiConfig.commands?.release?.reasoning || aiConfig.reasoning;
+            return await createCompletionWithRetry(
+                request.messages as ChatCompletionMessageParam[],
+                {
+                    model: modelToUse,
+                    openaiReasoning,
+                    responseFormat: { type: 'json_object' },
+                    debug: runConfig.debug,
+                    debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('release-improve')),
+                    debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('release-improve')),
+                    storage: aiStorageAdapter,
+                    logger: aiLogger,
+                }
+            );
+        },
+        processResponse: (response: any) => {
+            return validateReleaseSummary(response);
+        }
+    };
+
+    return await improveContentWithLLM(
+        releaseSummary,
+        runConfig,
+        promptConfig,
+        promptContext,
+        outputDirectory,
+        improvementConfig
+    );
+}
+
+// Helper function to generate self-reflection output for release notes using observability module
+async function generateSelfReflection(
+    agenticResult: any,
+    outputDirectory: string,
+    storage: any,
+    logger: any
+): Promise<void> {
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const reflectionPath = getOutputPath(outputDirectory, `agentic-reflection-release-${timestamp}.md`);
+
+        // Use new observability reflection generator
+        const report = await generateReflectionReport({
+            iterations: agenticResult.iterations || 0,
+            toolCallsExecuted: agenticResult.toolCallsExecuted || 0,
+            maxIterations: agenticResult.maxIterations || 30,
+            toolMetrics: agenticResult.toolMetrics || [],
+            conversationHistory: agenticResult.conversationHistory || [],
+            releaseNotes: agenticResult.releaseNotes,
+            logger
+        });
+
+        // Save the report to output directory
+        await storage.writeFile(reflectionPath, report, 'utf8');
+
+        logger.info('');
+        logger.info('═'.repeat(80));
+        logger.info('📊 SELF-REFLECTION REPORT GENERATED');
+        logger.info('═'.repeat(80));
+        logger.info('');
+        logger.info('📁 Location: %s', reflectionPath);
+        logger.info('');
+        logger.info('📈 Report Summary:');
+        const iterations = agenticResult.iterations || 0;
+        const toolCalls = agenticResult.toolCallsExecuted || 0;
+        const uniqueTools = new Set((agenticResult.toolMetrics || []).map((m: any) => m.name)).size;
+        logger.info(`   • ${iterations} iterations completed`);
+        logger.info(`   • ${toolCalls} tool calls executed`);
+        logger.info(`   • ${uniqueTools} unique tools used`);
+        logger.info('');
+        logger.info('💡 Use this report to:');
+        logger.info('   • Understand which tools were most effective');
+        logger.info('   • Identify performance bottlenecks');
+        logger.info('   • Optimize tool selection and usage patterns');
+        logger.info('   • Improve agentic release notes generation');
+        logger.info('');
+        logger.info('═'.repeat(80));
+    } catch (error: any) {
+        logger.warn('Failed to generate self-reflection report: %s', error.message);
+    }
+}
+
+// Interactive feedback loop for release notes
+async function handleInteractiveReleaseFeedback(
+    releaseSummary: ReleaseSummary,
+    runConfig: Config,
+    promptConfig: any,
+    promptContext: any,
+    outputDirectory: string,
+    storage: any,
+    logContent: string,
+    diffContent: string
+): Promise<{ action: 'confirm' | 'skip', finalSummary: ReleaseSummary }> {
+    const logger = getDryRunLogger(false);
+    let currentSummary = releaseSummary;
+
+    while (true) {
+        // Display the current release notes
+        logger.info('\nRELEASE_NOTES_GENERATED: Generated release notes from AI | Title Length: ' + currentSummary.title.length + ' | Body Length: ' + currentSummary.body.length);
+        logger.info('─'.repeat(50));
+        logger.info('RELEASE_NOTES_TITLE: %s', currentSummary.title);
+        logger.info('');
+        logger.info('RELEASE_NOTES_BODY: Release notes content:');
+        logger.info(currentSummary.body);
+        logger.info('─'.repeat(50));
+
+        // Get user choice
+        const userChoice = await getUserChoice(
+            '\nWhat would you like to do with these release notes?',
+            [
+                STANDARD_CHOICES.CONFIRM,
+                STANDARD_CHOICES.EDIT,
+                STANDARD_CHOICES.SKIP,
+                STANDARD_CHOICES.IMPROVE
+            ],
+            {
+                nonTtyErrorSuggestions: ['Use --dry-run to see the generated content without interaction']
+            }
+        );
+
+        switch (userChoice) {
+            case 'c':
+                return { action: 'confirm', finalSummary: currentSummary };
+
+            case 'e':
+                try {
+                    currentSummary = await editReleaseNotesInteractively(currentSummary);
+                } catch (error: any) {
+                    logger.error(`RELEASE_NOTES_EDIT_FAILED: Unable to edit release notes | Error: ${error.message} | Impact: Using original notes`);
+                    // Continue the loop to show options again
+                }
+                break;
+
+            case 's':
+                return { action: 'skip', finalSummary: currentSummary };
+
+            case 'i':
+                try {
+                    currentSummary = await improveReleaseNotesWithLLM(
+                        currentSummary,
+                        runConfig,
+                        promptConfig,
+                        promptContext,
+                        outputDirectory,
+                        logContent,
+                        diffContent
+                    );
+                } catch (error: any) {
+                    logger.error(`RELEASE_NOTES_IMPROVE_FAILED: Unable to improve release notes | Error: ${error.message} | Impact: Using current version`);
+                    // Continue the loop to show options again
+                }
+                break;
+
+            default:
+                // This shouldn't happen, but continue the loop
+                break;
+        }
+    }
+}
+
+/**
+ * Execute release notes generation (pure git version)
+ *
+ * This implementation uses ONLY git operations - no GitHub API calls.
+ * Works with any git repository regardless of host or language.
+ */
+export const execute = async (runConfig: Config): Promise<ReleaseSummary> => {
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+
+    // Get current branch to help determine best tag comparison
+    const currentBranch = await getCurrentBranch();
+
+    // Resolve the from reference with fallback logic if not explicitly provided
+    const fromRef = runConfig.release?.from ?? await getDefaultFromRef(false, currentBranch);
+    const toRef = runConfig.release?.to ?? DEFAULT_TO_COMMIT_ALIAS;
+
+    logger.debug(`Using git references: from=${fromRef}, to=${toRef}`);
+
+    const log = await Log.create({
+        from: fromRef,
+        to: toRef,
+        limit: runConfig.release?.messageLimit
+    });
+    let logContent = '';
+
+    const maxDiffBytes = runConfig.release?.maxDiffBytes ?? DEFAULT_MAX_DIFF_BYTES;
+    const diff = await Diff.create({
+        from: fromRef,
+        to: toRef,
+        excludedPatterns: runConfig.excludedPatterns ?? DEFAULT_EXCLUDED_PATTERNS,
+        maxDiffBytes
+    });
+    let diffContent = '';
+
+    diffContent = await diff.get();
+    logContent = await log.get();
+
+    const promptConfig = {
+        overridePaths: runConfig.discoveredConfigDirs || [],
+        overrides: runConfig.overrides || false,
+    };
+
+    // Always ensure output directory exists for request/response files
+    const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    const storage = createStorage();
+    await storage.ensureDirectory(outputDirectory);
+
+    // Create adapters for ai-service
+    const aiConfig = toAIConfig(runConfig);
+    const aiStorageAdapter = createStorageAdapter(outputDirectory);
+    const aiLogger = createLoggerAdapter(isDryRun);
+
+    // Read context from files if provided
+    const contextFromFiles = await readContextFiles(runConfig.release?.contextFiles, logger);
+
+    // Combine file context with existing context
+    const combinedContext = [
+        runConfig.release?.context,
+        contextFromFiles
+    ].filter(Boolean).join('\n\n---\n\n');
+
+    // Run agentic release notes generation
+    // NOTE: No milestone/GitHub integration - pure git only
+    const agenticResult = await runAgenticRelease({
+        fromRef,
+        toRef,
+        logContent,
+        diffContent,
+        milestoneIssues: '', // Empty - no GitHub API integration
+        releaseFocus: runConfig.release?.focus,
+        userContext: combinedContext || undefined,
+        targetVersion: (runConfig.release as any)?.version,
+        model: aiConfig.commands?.release?.model || aiConfig.model || 'gpt-4o',
+        maxIterations: runConfig.release?.maxAgenticIterations || 30,
+        debug: runConfig.debug,
+        debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('release')),
+        debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('release')),
+        storage: aiStorageAdapter,
+        logger: aiLogger,
+        openaiReasoning: aiConfig.commands?.release?.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.release?.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: ReleaseSummary = {
+        title: titleFilterResult.filtered,
+        body: bodyFilterResult.filtered,
+    };
+
+    // Handle interactive mode
+    if (runConfig.release?.interactive && !isDryRun) {
+        requireTTY('Interactive mode requires a terminal. Use --dry-run instead.');
+
+        const interactivePromptContext: ReleaseContext = {
+            context: combinedContext || undefined,
+            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: any) {
+        logger.warn('RELEASE_SAVE_FAILED: Failed to save timestamped release notes | Error: %s | Impact: Notes not persisted to file', error.message);
+    }
+
+    // Save to specified output file if provided
+    const outputFile = (runConfig.release as any)?.output;
+    if (outputFile) {
+        try {
+            const releaseNotesContent = `# ${releaseSummary.title}\n\n${releaseSummary.body}`;
+            await storage.writeFile(outputFile, releaseNotesContent, 'utf-8');
+            logger.info(`Saved release notes to: ${outputFile}`);
+        } catch (error: any) {
+            logger.error(`Failed to save release notes to ${outputFile}: ${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;
+}