@entro314labs/ai-changelog-generator 3.0.5

package/src/application/orchestrators/changelog.orchestrator.js

@@ -0,0 +1,730 @@
+import { GitService } from '../../domains/git/git.service.js';
+import { AIAnalysisService } from '../../domains/ai/ai-analysis.service.js';
+import { ChangelogService } from '../../domains/changelog/changelog.service.js';
+import { AnalysisEngine } from '../../domains/analysis/analysis.engine.js';
+import { ProviderManagerService } from '../../infrastructure/providers/provider-manager.service.js';
+import { InteractiveWorkflowService } from '../../infrastructure/interactive/interactive-workflow.service.js';
+import colors from '../../shared/constants/colors.js';
+
+export class ChangelogOrchestrator {
+  constructor(configManager, options = {}) {
+    this.configManager = configManager;
+    this.options = options;
+    this.analysisMode = options.analysisMode || 'standard';
+    this.metrics = {
+      startTime: Date.now(),
+      commitsProcessed: 0,
+      apiCalls: 0,
+      errors: 0,
+      batchesProcessed: 0,
+      totalTokens: 0,
+      ruleBasedFallbacks: 0,
+      cacheHits: 0
+    };
+
+    this.initialized = false;
+    this.initializationPromise = null;
+
+    // Start initialization
+    this.initializationPromise = this.initializeServices();
+  }
+
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initializationPromise;
+    }
+  }
+
+  async initializeServices() {
+    try {
+      // Initialize AI provider
+      this.providerManager = new ProviderManagerService(this.configManager.getAll(), {
+        errorHandler: { logToConsole: true }
+      });
+      this.aiProvider = this.providerManager.getActiveProvider();
+
+      // Create lightweight implementations for missing dependencies
+      this.gitManager = await this.createGitManager();
+      this.tagger = await this.createTagger();
+      this.promptEngine = await this.createPromptEngine();
+
+      // Initialize domain services with proper dependencies
+      this.gitService = new GitService(this.gitManager, this.tagger);
+      this.aiAnalysisService = new AIAnalysisService(this.aiProvider, this.promptEngine, this.tagger, this.analysisMode);
+      this.analysisEngine = new AnalysisEngine(this.gitService, this.aiAnalysisService);
+      this.changelogService = new ChangelogService(this.gitService, this.aiAnalysisService, this.analysisEngine, this.configManager);
+      this.interactiveService = new InteractiveWorkflowService(this.gitService, this.aiAnalysisService, this.changelogService);
+
+      // Only log if not in MCP server mode
+      if (!process.env.MCP_SERVER_MODE) {
+        console.log(colors.successMessage('⚙️  Services initialized'));
+      }
+      this.initialized = true;
+
+    } catch (error) {
+      console.error(colors.errorMessage('Failed to initialize services:'), error.message);
+      throw error;
+    }
+  }
+
+  async createGitManager() {
+    const { execSync } = await import('child_process');
+
+    return {
+      isGitRepo: (() => {
+        try {
+          execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+          return true;
+        } catch {
+          return false;
+        }
+      })(),
+
+      execGit(command) {
+        try {
+          return execSync(command, { encoding: 'utf8', stdio: 'pipe' });
+        } catch (error) {
+          throw new Error(`Git command failed: ${error.message}`);
+        }
+      },
+
+      execGitSafe(command) {
+        try {
+          return execSync(command, { encoding: 'utf8', stdio: 'pipe' });
+        } catch {
+          return '';
+        }
+      },
+
+      execGitShow(command) {
+        try {
+          return execSync(command, { encoding: 'utf8', stdio: 'pipe' });
+        } catch (error) {
+          // console.warn(`Git command failed: ${command}`);
+          // console.warn(`Error: ${error.message}`);
+          return null;
+        }
+      },
+
+      validateCommitHash(hash) {
+        try {
+          execSync(`git cat-file -e ${hash}`, { stdio: 'ignore' });
+          return true;
+        } catch {
+          return false;
+        }
+      },
+
+      getAllBranches() {
+        try {
+          const output = execSync('git branch -a', { encoding: 'utf8' });
+          return output.split('\n').filter(Boolean).map(branch => branch.trim().replace(/^\*\s*/, ''));
+        } catch {
+          return [];
+        }
+      },
+
+      getUnmergedCommits() {
+        try {
+          const output = execSync('git log --oneline --no-merges HEAD ^origin/main', { encoding: 'utf8' });
+          return output.split('\n').filter(Boolean);
+        } catch {
+          return [];
+        }
+      },
+
+      getDanglingCommits() {
+        try {
+          const output = execSync('git fsck --no-reflog | grep "dangling commit"', { encoding: 'utf8' });
+          return output.split('\n').filter(Boolean);
+        } catch {
+          return [];
+        }
+      },
+
+      getUntrackedFiles() {
+        try {
+          const output = execSync('git ls-files --others --exclude-standard', { encoding: 'utf8' });
+          return output.split('\n').filter(Boolean);
+        } catch {
+          return [];
+        }
+      },
+
+      getRecentCommits(limit = 10) {
+        try {
+          const output = execSync(`git log --oneline -${limit}`, { encoding: 'utf8' });
+          return output.split('\n').filter(Boolean);
+        } catch {
+          return [];
+        }
+      },
+
+      getComprehensiveAnalysis() {
+        return {
+          totalCommits: this.getRecentCommits(1000).length,
+          branches: this.getAllBranches(),
+          untrackedFiles: this.getUntrackedFiles()
+        };
+      },
+
+      hasFile(filename) {
+        try {
+          execSync(`test -f ${filename}`, { stdio: 'ignore' });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+
+  async createTagger() {
+    const { analyzeSemanticChanges, analyzeFunctionalImpact } = await import('../../shared/utils/utils.js');
+
+    return {
+      analyzeCommit(commit) {
+        const semanticChanges = [];
+        const breakingChanges = [];
+        const categories = [];
+        const tags = [];
+
+        // Basic analysis based on commit message
+        const message = commit.message.toLowerCase();
+
+        if (message.includes('breaking') || message.includes('!:')) {
+          breakingChanges.push('Breaking change detected in commit message');
+          categories.push('breaking');
+          tags.push('breaking');
+        }
+
+        if (message.startsWith('feat')) {
+          categories.push('feature');
+          tags.push('feature');
+        } else if (message.startsWith('fix')) {
+          categories.push('fix');
+          tags.push('bugfix');
+        } else if (message.startsWith('docs')) {
+          categories.push('docs');
+          tags.push('documentation');
+        }
+
+        // Analyze files if available
+        if (commit.files && commit.files.length > 0) {
+          commit.files.forEach(file => {
+            const semantic = analyzeSemanticChanges('', file.path);
+            if (semantic.frameworks) {
+              semanticChanges.push(...semantic.frameworks);
+            }
+          });
+        }
+
+        // Determine importance
+        let importance = 'medium';
+        if (breakingChanges.length > 0 || commit.files?.length > 10) {
+          importance = 'high';
+        } else if (categories.includes('docs') || commit.files?.length < 3) {
+          importance = 'low';
+        }
+
+        return {
+          semanticChanges,
+          breakingChanges,
+          categories,
+          importance,
+          tags
+        };
+      }
+    };
+  }
+
+  async createPromptEngine() {
+    const { buildEnhancedPrompt } = await import('../../shared/utils/utils.js');
+
+    return {
+      systemPrompts: {
+        master: "You are an expert software analyst specializing in code change analysis and changelog generation.",
+        standard: "Provide clear, concise analysis focusing on the practical impact of changes.",
+        detailed: "Provide comprehensive technical analysis with detailed explanations and implications.",
+        enterprise: "Provide enterprise-grade analysis suitable for stakeholder communication and decision-making.",
+        changesAnalysis: "You are an expert at analyzing code changes and their business impact."
+      },
+
+      optimizeForProvider(prompt, providerName, capabilities = {}) {
+        // Simple optimization - could be enhanced based on provider capabilities
+        if (providerName?.toLowerCase().includes('claude')) {
+          return `Please analyze this carefully and provide structured output:\n\n${prompt}`;
+        } else if (providerName?.toLowerCase().includes('gpt')) {
+          return `${prompt}\n\nPlease respond in JSON format as requested.`;
+        }
+        return prompt;
+      },
+
+      buildRepositoryHealthPrompt(healthData, analysisMode) {
+        return `Analyze the health of this repository based on the following data:\n\n${JSON.stringify(healthData, null, 2)}\n\nProvide assessment and recommendations.`;
+      }
+    };
+  }
+
+  async generateChangelog(version, since) {
+    try {
+      await this.ensureInitialized();
+
+      this.metrics.startTime = Date.now();
+
+      console.log('\n' + colors.processingMessage('🚀 Starting changelog generation...'));
+
+      // Validate git repository
+      if (!this.gitManager.isGitRepo) {
+        throw new Error('Not a git repository');
+      }
+
+      // Generate changelog using the service
+      const result = await this.changelogService.generateChangelog(version, since);
+
+      if (!result) {
+        console.log(colors.warningMessage('No changelog generated'));
+        return null;
+      }
+
+      // Update metrics
+      this.updateMetrics(result);
+
+      // Display results
+      this.displayResults(result, version);
+
+      return result;
+
+    } catch (error) {
+      this.metrics.errors++;
+      console.error(colors.errorMessage('Changelog generation failed:'), error.message);
+      throw error;
+    }
+  }
+
+  async analyzeRepository(options = {}) {
+    try {
+      await this.ensureInitialized();
+
+      console.log(colors.processingMessage('🔍 Starting repository analysis...'));
+
+      const analysisType = options.type || 'changes';
+      const result = await this.analysisEngine.analyze(analysisType, options);
+
+      this.displayAnalysisResults(result, analysisType);
+
+      return result;
+
+    } catch (error) {
+      this.metrics.errors++;
+      console.error(colors.errorMessage('Repository analysis failed:'), error.message);
+      throw error;
+    }
+  }
+
+  async runInteractive() {
+    await this.ensureInitialized();
+
+    const { runInteractiveMode, selectSpecificCommits } = await import('../../shared/utils/utils.js');
+    const { confirm } = await import('@clack/prompts');
+
+    console.log(colors.processingMessage('🎮 Starting interactive mode...'));
+
+    let continueSession = true;
+
+    while (continueSession) {
+      try {
+        const result = await runInteractiveMode();
+
+        if (result.action === 'exit') {
+          console.log(colors.successMessage('👋 Goodbye!'));
+          break;
+        }
+
+        await this.handleInteractiveAction(result.action);
+
+        // Ask if user wants to continue
+        const continueChoice = await confirm({
+          message: 'Would you like to perform another action?',
+          initialValue: true
+        });
+
+        continueSession = continueChoice;
+
+      } catch (error) {
+        console.error(colors.errorMessage(`Interactive mode error: ${error.message}`));
+
+        const retryChoice = await confirm({
+          message: 'Would you like to try again?',
+          initialValue: true
+        });
+
+        continueSession = retryChoice;
+      }
+    }
+
+    return { interactive: true, status: 'completed' };
+  }
+
+  async handleInteractiveAction(action) {
+
+    switch (action) {
+      case 'changelog-recent':
+        await this.handleRecentChangelogGeneration();
+        break;
+
+      case 'changelog-specific':
+        await this.handleSpecificChangelogGeneration();
+        break;
+
+      case 'analyze-workdir':
+        await this.generateChangelogFromChanges();
+        break;
+
+      case 'analyze-repo':
+        await this.analyzeRepository({ type: 'comprehensive' });
+        break;
+
+      case 'commit-message':
+        await this.handleCommitMessageGeneration();
+        break;
+
+      case 'configure-providers':
+        await this.handleProviderConfiguration();
+        break;
+
+      case 'validate-config':
+        await this.validateConfiguration();
+        break;
+
+      default:
+        console.log(colors.warningMessage(`Unknown action: ${action}`));
+    }
+  }
+
+  async handleRecentChangelogGeneration() {
+    const { text } = await import('@clack/prompts');
+
+    const commitCountInput = await text({
+      message: 'How many recent commits to include?',
+      placeholder: '10',
+      validate: (value) => {
+        const num = parseInt(value);
+        if (isNaN(num) || num <= 0 || num > 100) {
+          return 'Please enter a number between 1 and 100';
+        }
+      }
+    });
+
+    const commitCount = parseInt(commitCountInput) || 10;
+
+    console.log(colors.processingMessage(`📝 Generating changelog for ${commitCount} recent commits...`));
+
+    const result = await this.generateChangelog({
+      version: `Recent-${commitCount}-commits`,
+      maxCommits: commitCount
+    });
+
+    if (result?.changelog) {
+      console.log(colors.successMessage('✅ Changelog generated successfully!'));
+    }
+  }
+
+  async handleSpecificChangelogGeneration() {
+    const { selectSpecificCommits } = await import('../../shared/utils/utils.js');
+
+    console.log(colors.infoMessage('📋 Select specific commits for changelog generation:'));
+
+    const selectedCommits = await selectSpecificCommits(30);
+
+    if (selectedCommits.length === 0) {
+      console.log(colors.warningMessage('No commits selected.'));
+      return;
+    }
+
+    console.log(colors.processingMessage(`📝 Generating changelog for ${selectedCommits.length} selected commits...`));
+
+    const result = await this.generateChangelogFromCommits(selectedCommits);
+
+    if (result?.changelog) {
+      console.log(colors.successMessage('✅ Changelog generated successfully!'));
+    }
+  }
+
+  async handleCommitMessageGeneration() {
+    console.log(colors.processingMessage('🤖 Analyzing current changes for commit message suggestions...'));
+
+    // Use shared utility for getting working directory changes
+    const { getWorkingDirectoryChanges } = await import('../../shared/utils/utils.js');
+    const changes = getWorkingDirectoryChanges();
+
+    if (!changes || changes.length === 0) {
+      console.log(colors.warningMessage('No uncommitted changes found.'));
+      return;
+    }
+
+    const analysis = await this.interactiveService.generateCommitSuggestion();
+
+    if (analysis.success && analysis.suggestions.length > 0) {
+      const { select } = await import('@clack/prompts');
+
+      const choices = [
+        ...analysis.suggestions.map((msg, index) => ({
+          value: msg,
+          label: `${index + 1}. ${msg}`
+        })),
+        {
+          value: 'CUSTOM',
+          label: '✏️  Write custom message'
+        }
+      ];
+
+      const selectedMessage = await select({
+        message: 'Choose a commit message:',
+        options: choices
+      });
+
+      if (selectedMessage === 'CUSTOM') {
+        const { text } = await import('@clack/prompts');
+
+        const customMessage = await text({
+          message: 'Enter your commit message:',
+          validate: (input) => {
+            if (!input || input.trim().length === 0) {
+              return 'Commit message cannot be empty';
+            }
+          }
+        });
+
+        console.log(colors.successMessage(`📝 Custom message: ${customMessage}`));
+      } else {
+        console.log(colors.successMessage(`📝 Selected: ${selectedMessage}`));
+      }
+    } else {
+      console.log(colors.warningMessage('Could not generate commit message suggestions.'));
+    }
+  }
+
+  async handleProviderConfiguration() {
+    const { select } = await import('@clack/prompts');
+
+    const availableProviders = this.providerManager.getAllProviders();
+
+    const choices = availableProviders.map(p => ({
+      value: p.name,
+      label: `${p.name} ${p.available ? '✅' : '⚠️ (needs configuration)'}`
+    }));
+
+    const selectedProvider = await select({
+      message: 'Select provider to configure:',
+      options: choices
+    });
+
+    console.log(colors.infoMessage(`🔧 Configuring ${selectedProvider}...`));
+    console.log(colors.infoMessage('Please edit your .env.local file to add the required API keys.'));
+    console.log(colors.highlight(`Example for ${selectedProvider.toUpperCase()}:`));
+
+    switch (selectedProvider) {
+      case 'openai':
+        console.log(colors.code('OPENAI_API_KEY=your_api_key_here'));
+        break;
+      case 'anthropic':
+        console.log(colors.code('ANTHROPIC_API_KEY=your_api_key_here'));
+        break;
+      case 'azure':
+        console.log(colors.code('AZURE_OPENAI_API_KEY=your_api_key_here'));
+        console.log(colors.code('AZURE_OPENAI_ENDPOINT=your_endpoint_here'));
+        break;
+      case 'google':
+        console.log(colors.code('GOOGLE_API_KEY=your_api_key_here'));
+        break;
+      default:
+        console.log(colors.code(`${selectedProvider.toUpperCase()}_API_KEY=your_api_key_here`));
+    }
+  }
+
+  async generateChangelogFromChanges(version) {
+    try {
+      await this.ensureInitialized();
+
+      console.log(colors.processingMessage('📝 Generating changelog from working directory changes...'));
+
+      const result = await this.changelogService.generateChangelogFromChanges(version);
+
+      if (result) {
+        console.log(colors.successMessage('✅ Working directory changelog generated'));
+        console.log(result.changelog);
+      }
+
+      return result;
+
+    } catch (error) {
+      this.metrics.errors++;
+      console.error(colors.errorMessage('Working directory changelog generation failed:'), error.message);
+      throw error;
+    }
+  }
+
+  updateMetrics(result) {
+    if (result.analyzedCommits) {
+      this.metrics.commitsProcessed += result.analyzedCommits.length;
+    }
+
+    // Get metrics from AI service
+    const aiMetrics = this.aiAnalysisService.getMetrics();
+    this.metrics.apiCalls += aiMetrics.apiCalls;
+    this.metrics.totalTokens += aiMetrics.totalTokens;
+    this.metrics.ruleBasedFallbacks += aiMetrics.ruleBasedFallbacks;
+  }
+
+  displayResults(result, version) {
+    const { changelog, insights, analyzedCommits } = result;
+
+    console.log('\n' + colors.successMessage('✅ Changelog Generation Complete'));
+
+    if (insights) {
+      // Create a clean insights summary
+      const insightLines = [
+        `${colors.label('Total commits')}: ${colors.number(insights.totalCommits)}`,
+        `${colors.label('Complexity')}: ${this.getComplexityColor(insights.complexity)(insights.complexity)}`,
+        `${colors.label('Risk level')}: ${this.getRiskColor(insights.riskLevel)(insights.riskLevel)}`
+      ];
+
+      if (insights.breaking) {
+        insightLines.push('');
+        insightLines.push(colors.warningMessage('⚠️  Contains breaking changes'));
+      }
+
+      if (Object.keys(insights.commitTypes).length > 0) {
+        insightLines.push('');
+        insightLines.push(colors.dim('Commit types:'));
+        Object.entries(insights.commitTypes).forEach(([type, count]) => {
+          insightLines.push(`  ${colors.commitType(type)}: ${colors.number(count)}`);
+        });
+      }
+
+      console.log(colors.box('📊 Release Insights', insightLines.join('\n')));
+    }
+
+    // Don't show changelog content in terminal - it's saved to file
+
+    this.displayMetrics();
+  }
+
+  getComplexityColor(complexity) {
+    const level = complexity?.toLowerCase();
+    switch (level) {
+      case 'low': return colors.success;
+      case 'medium': return colors.warning;
+      case 'high': return colors.error;
+      default: return colors.highlight;
+    }
+  }
+
+  getRiskColor(risk) {
+    const level = risk?.toLowerCase();
+    switch (level) {
+      case 'low': return colors.riskLow;
+      case 'medium': return colors.riskMedium;
+      case 'high': return colors.riskHigh;
+      case 'critical': return colors.riskCritical;
+      default: return colors.highlight;
+    }
+  }
+
+  displayAnalysisResults(result, type) {
+    console.log(colors.successMessage(`\n✅ ${type.charAt(0).toUpperCase() + type.slice(1)} Analysis Complete`));
+    console.log(colors.separator());
+
+    if (result.summary) {
+      console.log(colors.sectionHeader('📋 Summary'));
+      console.log(result.summary);
+      console.log('');
+    }
+
+    if (result.analysis) {
+      console.log(colors.sectionHeader('🔍 Analysis Details'));
+      if (typeof result.analysis === 'object') {
+        Object.entries(result.analysis).forEach(([key, value]) => {
+          if (typeof value === 'object') {
+            console.log(`${key}: ${JSON.stringify(value, null, 2)}`);
+          } else {
+            console.log(`${key}: ${colors.highlight(value)}`);
+          }
+        });
+      } else {
+        console.log(result.analysis);
+      }
+    }
+
+    this.displayMetrics();
+  }
+
+  displayMetrics() {
+    const duration = Date.now() - this.metrics.startTime;
+
+    const metricLines = [
+      `${colors.label('Duration')}: ${colors.number(this.formatDuration(duration))}`,
+      `${colors.label('Commits processed')}: ${colors.number(this.metrics.commitsProcessed)}`,
+      `${colors.label('API calls')}: ${colors.number(this.metrics.apiCalls)}`,
+      `${colors.label('Total tokens')}: ${colors.number(this.metrics.totalTokens.toLocaleString())}`
+    ];
+
+    if (this.metrics.ruleBasedFallbacks > 0) {
+      metricLines.push('');
+      metricLines.push(colors.warning(`⚠️  Rule-based fallbacks: ${this.metrics.ruleBasedFallbacks}`));
+    }
+
+    if (this.metrics.errors > 0) {
+      metricLines.push('');
+      metricLines.push(colors.error(`❌ Errors: ${this.metrics.errors}`));
+    }
+
+    console.log(colors.box('📈 Performance Metrics', metricLines.join('\n')));
+  }
+
+  formatDuration(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+  }
+
+  // Configuration methods
+  setAnalysisMode(mode) {
+    this.analysisMode = mode;
+    if (this.aiAnalysisService) {
+      this.aiAnalysisService.analysisMode = mode;
+    }
+  }
+
+  setModelOverride(model) {
+    if (this.aiAnalysisService) {
+      this.aiAnalysisService.setModelOverride(model);
+    }
+  }
+
+  // Metrics methods
+  getMetrics() {
+    return {
+      ...this.metrics,
+      aiMetrics: this.aiAnalysisService?.getMetrics() || {}
+    };
+  }
+
+  resetMetrics() {
+    this.metrics = {
+      startTime: Date.now(),
+      commitsProcessed: 0,
+      apiCalls: 0,
+      errors: 0,
+      batchesProcessed: 0,
+      totalTokens: 0,
+      ruleBasedFallbacks: 0,
+      cacheHits: 0
+    };
+
+    if (this.aiAnalysisService) {
+      this.aiAnalysisService.resetMetrics();
+    }
+  }
+}