@entro314labs/ai-changelog-generator 3.0.5 → 3.2.0

package/src/application/services/application.service.js

@@ -1,201 +1,205 @@
-import { ChangelogOrchestrator } from '../orchestrators/changelog.orchestrator.js';
-import { ConfigurationManager } from '../../infrastructure/config/configuration.manager.js';
-import colors from '../../shared/constants/colors.js';
+import process from 'node:process'
+
+import { ConfigurationManager } from '../../infrastructure/config/configuration.manager.js'
+import colors from '../../shared/constants/colors.js'
+import { ChangelogOrchestrator } from '../orchestrators/changelog.orchestrator.js'
 
 export class ApplicationService {
   constructor(options = {}) {
-    this.options = options;
-    this.configManager = new ConfigurationManager();
-    this.orchestrator = new ChangelogOrchestrator(this.configManager, options);
-    this.initialized = false;
-    
+    this.options = options
+    this.configManager = new ConfigurationManager()
+    this.orchestrator = new ChangelogOrchestrator(this.configManager, options)
+    this.initialized = false
+
     // Apply options
     if (options.noColor || process.env.NO_COLOR) {
-      colors.disable();
+      colors.disable()
     }
-    
+
     // Wait for orchestrator to initialize
-    this.initializeAsync();
+    this.initializeAsync()
   }
-  
+
   async initializeAsync() {
     try {
       // Wait for orchestrator services to be ready
-      await this.orchestrator.ensureInitialized();
-      this.initialized = true;
+      await this.orchestrator.ensureInitialized()
+      this.initialized = true
     } catch (error) {
-      console.error(colors.errorMessage('Application service initialization failed:'), error.message);
+      console.error(
+        colors.errorMessage('Application service initialization failed:'),
+        error.message
+      )
     }
   }
-  
+
   async ensureInitialized() {
     if (!this.initialized) {
-      await this.initializeAsync();
+      await this.initializeAsync()
     }
   }
 
   async generateChangelog(options = {}) {
     try {
-      const { version, since } = options;
-      return await this.orchestrator.generateChangelog(version, since);
+      const { version, since } = options
+      return await this.orchestrator.generateChangelog(version, since)
     } catch (error) {
-      console.error(colors.errorMessage('Application service error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Application service error:'), error.message)
+      throw error
     }
   }
 
   async analyzeRepository(options = {}) {
     try {
-      return await this.orchestrator.analyzeRepository(options);
+      return await this.orchestrator.analyzeRepository(options)
     } catch (error) {
-      console.error(colors.errorMessage('Repository analysis error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Repository analysis error:'), error.message)
+      throw error
     }
   }
 
   async analyzeCurrentChanges() {
     try {
-      await this.ensureInitialized();
-      return await this.orchestrator.analyzeRepository({ type: 'changes' });
+      await this.ensureInitialized()
+      return await this.orchestrator.analyzeRepository({ type: 'changes' })
     } catch (error) {
-      console.error(colors.errorMessage('Changes analysis error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Changes analysis error:'), error.message)
+      throw error
     }
   }
 
   async analyzeRecentCommits(limit = 10) {
     try {
-      return await this.orchestrator.analyzeRepository({ 
-        type: 'commits', 
-        limit 
-      });
+      return await this.orchestrator.analyzeRepository({
+        type: 'commits',
+        limit,
+      })
     } catch (error) {
-      console.error(colors.errorMessage('Commits analysis error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Commits analysis error:'), error.message)
+      throw error
     }
   }
 
   async assessHealth(options = {}) {
     try {
-      return await this.orchestrator.analyzeRepository({ 
+      return await this.orchestrator.analyzeRepository({
         type: 'health',
-        ...options 
-      });
+        ...options,
+      })
     } catch (error) {
-      console.error(colors.errorMessage('Health assessment error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Health assessment error:'), error.message)
+      throw error
     }
   }
 
   async generateChangelogFromChanges(version) {
     try {
-      return await this.orchestrator.generateChangelogFromChanges(version);
+      return await this.orchestrator.generateChangelogFromChanges(version)
     } catch (error) {
-      console.error(colors.errorMessage('Working directory changelog error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Working directory changelog error:'), error.message)
+      throw error
     }
   }
 
   async runInteractive() {
     try {
-      return await this.orchestrator.runInteractive();
+      return await this.orchestrator.runInteractive()
     } catch (error) {
-      console.error(colors.errorMessage('Interactive mode error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Interactive mode error:'), error.message)
+      throw error
     }
   }
 
   // Configuration delegation
   setAnalysisMode(mode) {
-    this.orchestrator.setAnalysisMode(mode);
+    this.orchestrator.setAnalysisMode(mode)
   }
 
   setModelOverride(model) {
-    this.orchestrator.setModelOverride(model);
+    this.orchestrator.setModelOverride(model)
   }
 
   // Metrics delegation
   getMetrics() {
-    return this.orchestrator.getMetrics();
+    return this.orchestrator.getMetrics()
   }
 
   resetMetrics() {
-    this.orchestrator.resetMetrics();
+    this.orchestrator.resetMetrics()
   }
 
   // Provider management
   async listProviders() {
     try {
-      return await this.orchestrator.providerManager.listProviders();
+      return await this.orchestrator.providerManager.listProviders()
     } catch (error) {
-      console.error(colors.errorMessage('Provider listing error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Provider listing error:'), error.message)
+      throw error
     }
   }
 
-  async switchProvider(providerName) {
+  switchProvider(providerName) {
     try {
-      const result = this.orchestrator.providerManager.switchProvider(providerName);
+      const result = this.orchestrator.providerManager.switchProvider(providerName)
       if (result.success) {
         // Reinitialize services with new provider
-        this.orchestrator.initializeServices();
-        console.log(colors.successMessage(`✅ Switched to provider: ${providerName}`));
+        this.orchestrator.initializeServices()
+        console.log(colors.successMessage(`✅ Switched to provider: ${providerName}`))
       }
-      return result;
+      return result
     } catch (error) {
-      console.error(colors.errorMessage('Provider switch error:'), error.message);
-      return { success: false, error: error.message };
+      console.error(colors.errorMessage('Provider switch error:'), error.message)
+      return { success: false, error: error.message }
     }
   }
 
   // Validation methods
-  async validateConfiguration() {
+  validateConfiguration() {
     try {
       // Basic validation
-      const config = this.configManager.getAll();
-      const issues = [];
-      
-      if (!config.GIT_PATH && !process.cwd()) {
-        issues.push('No git path configured');
+      const config = this.configManager.getAll()
+      const issues = []
+
+      if (!(config.GIT_PATH || process.cwd())) {
+        issues.push('No git path configured')
       }
-      
+
       // Validate AI provider if available
       if (this.orchestrator.aiProvider) {
-        const isAvailable = this.orchestrator.aiProvider.isAvailable();
+        const isAvailable = this.orchestrator.aiProvider.isAvailable()
         if (!isAvailable) {
-          issues.push('AI provider not properly configured');
+          issues.push('AI provider not properly configured')
         }
       }
-      
+
       return {
         valid: issues.length === 0,
         issues,
-        recommendations: this.generateRecommendations(issues)
-      };
-      
+        recommendations: this.generateRecommendations(issues),
+      }
     } catch (error) {
-      console.error(colors.errorMessage('Configuration validation error:'), error.message);
+      console.error(colors.errorMessage('Configuration validation error:'), error.message)
       return {
         valid: false,
         issues: [error.message],
-        recommendations: []
-      };
+        recommendations: [],
+      }
     }
   }
 
   generateRecommendations(issues) {
-    const recommendations = [];
-    
-    issues.forEach(issue => {
+    const recommendations = []
+
+    issues.forEach((issue) => {
       if (issue.includes('git path')) {
-        recommendations.push('Set GIT_PATH environment variable or run from git repository');
+        recommendations.push('Set GIT_PATH environment variable or run from git repository')
       }
       if (issue.includes('AI provider')) {
-        recommendations.push('Configure AI provider credentials in .env.local file');
+        recommendations.push('Configure AI provider credentials in .env.local file')
       }
-    });
-    
-    return recommendations;
+    })
+
+    return recommendations
   }
 
   // Health check
@@ -204,98 +208,116 @@ export class ApplicationService {
       const health = {
         status: 'healthy',
         checks: {},
-        timestamp: new Date().toISOString()
-      };
-      
+        timestamp: new Date().toISOString(),
+      }
+
       // Git check
       try {
         health.checks.git = {
           status: this.orchestrator.gitManager.isGitRepo ? 'ok' : 'error',
-          message: this.orchestrator.gitManager.isGitRepo ? 'Git repository detected' : 'Not a git repository'
-        };
+          message: this.orchestrator.gitManager.isGitRepo
+            ? 'Git repository detected'
+            : 'Not a git repository',
+        }
       } catch (error) {
-        health.checks.git = { status: 'error', message: error.message };
+        health.checks.git = { status: 'error', message: error.message }
       }
-      
+
       // AI provider check
       try {
         health.checks.ai = {
           status: this.orchestrator.aiProvider?.isAvailable() ? 'ok' : 'warning',
-          message: this.orchestrator.aiProvider?.isAvailable() ? 'AI provider available' : 'AI provider not configured'
-        };
+          message: this.orchestrator.aiProvider?.isAvailable()
+            ? 'AI provider available'
+            : 'AI provider not configured',
+        }
       } catch (error) {
-        health.checks.ai = { status: 'error', message: error.message };
+        health.checks.ai = { status: 'error', message: error.message }
       }
-      
+
       // Configuration check
       try {
-        const configValidation = await this.validateConfiguration();
+        const configValidation = await this.validateConfiguration()
         health.checks.config = {
           status: configValidation.valid ? 'ok' : 'warning',
-          message: configValidation.valid ? 'Configuration valid' : `${configValidation.issues.length} issues found`
-        };
+          message: configValidation.valid
+            ? 'Configuration valid'
+            : `${configValidation.issues.length} issues found`,
+        }
       } catch (error) {
-        health.checks.config = { status: 'error', message: error.message };
+        health.checks.config = { status: 'error', message: error.message }
       }
-      
+
       // Overall status
-      const hasErrors = Object.values(health.checks).some(check => check.status === 'error');
-      const hasWarnings = Object.values(health.checks).some(check => check.status === 'warning');
-      
+      const hasErrors = Object.values(health.checks).some((check) => check.status === 'error')
+      const hasWarnings = Object.values(health.checks).some((check) => check.status === 'warning')
+
       if (hasErrors) {
-        health.status = 'unhealthy';
+        health.status = 'unhealthy'
       } else if (hasWarnings) {
-        health.status = 'degraded';
+        health.status = 'degraded'
       }
-      
-      return health;
-      
+
+      return health
     } catch (error) {
       return {
         status: 'unhealthy',
         error: error.message,
-        timestamp: new Date().toISOString()
-      };
+        timestamp: new Date().toISOString(),
+      }
     }
   }
 
   // Commit message generation
   async generateCommitMessage() {
     try {
-      await this.ensureInitialized();
-      return await this.orchestrator.interactiveService.generateCommitSuggestion();
+      await this.ensureInitialized()
+      return await this.orchestrator.interactiveService.generateCommitSuggestion()
     } catch (error) {
-      console.error(colors.errorMessage('Commit message generation error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Commit message generation error:'), error.message)
+      throw error
     }
   }
 
   // Provider validation methods
   async validateProvider(providerName) {
     try {
-      return await this.orchestrator.providerManager.testProvider(providerName);
+      return await this.orchestrator.providerManager.testProvider(providerName)
     } catch (error) {
-      console.error(colors.errorMessage('Provider validation error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Provider validation error:'), error.message)
+      throw error
     }
   }
 
   async validateAllProviders() {
     try {
-      return await this.orchestrator.providerManager.validateAll();
+      return await this.orchestrator.providerManager.validateAll()
     } catch (error) {
-      console.error(colors.errorMessage('All providers validation error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('All providers validation error:'), error.message)
+      throw error
     }
   }
 
   // Additional helper methods
   async generateChangelogFromCommits(commitHashes) {
     try {
-      return await this.orchestrator.interactiveService.generateChangelogForCommits(commitHashes);
+      return await this.orchestrator.interactiveService.generateChangelogForCommits(commitHashes)
+    } catch (error) {
+      console.error(colors.errorMessage('Changelog from commits error:'), error.message)
+      throw error
+    }
+  }
+
+  // Interactive commit workflow
+  async executeCommitWorkflow(options = {}) {
+    try {
+      await this.ensureInitialized()
+
+      // Delegate to orchestrator for the commit workflow
+      return await this.orchestrator.executeCommitWorkflow(options)
     } catch (error) {
-      console.error(colors.errorMessage('Changelog from commits error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Commit workflow error:'), error.message)
+      throw error
     }
   }
-}
+}

package/src/cli.js

@@ -5,10 +5,14 @@
  * Provides command-line interface for changelog generation functionality
  */
 
-import yargs from 'yargs/yargs';
-import { hideBin } from 'yargs/helpers';
-import { AIChangelogGenerator } from './ai-changelog-generator.js';
-import colors from './shared/constants/colors.js';
+import process from 'node:process'
+
+import { hideBin } from 'yargs/helpers'
+import yargs from 'yargs/yargs'
+
+import { AIChangelogGenerator } from './ai-changelog-generator.js'
+import colors from './shared/constants/colors.js'
+import { EnhancedConsole, SimpleSpinner } from './shared/utils/cli-ui.js'
 
 async function runCLI() {
   const argv = await yargs(hideBin(process.argv))
@@ -17,141 +21,156 @@ async function runCLI() {
     .option('tag', {
       alias: ['v', 'version'],
       type: 'string',
-      description: 'Version tag for changelog'
+      description: 'Version tag for changelog',
     })
     .option('since', {
       alias: 's',
       type: 'string',
-      description: 'Generate changelog since commit/tag'
+      description: 'Generate changelog since commit/tag',
     })
     .option('detailed', {
       type: 'boolean',
-      description: 'Generate detailed technical analysis'
+      description: 'Generate detailed technical analysis',
     })
     .option('enterprise', {
       type: 'boolean',
-      description: 'Generate enterprise-ready documentation'
+      description: 'Generate enterprise-ready documentation',
     })
     .option('interactive', {
       alias: 'i',
       type: 'boolean',
-      description: 'Run in interactive mode'
+      description: 'Run in interactive mode',
     })
     .option('analyze', {
       type: 'boolean',
-      description: 'Analyze current working directory changes'
+      description: 'Analyze current working directory changes',
     })
     .option('health', {
       type: 'boolean',
-      description: 'Assess repository health'
+      description: 'Assess repository health',
     })
     .option('branches', {
       type: 'boolean',
-      description: 'Analyze all branches'
+      description: 'Analyze all branches',
     })
     .option('comprehensive', {
       type: 'boolean',
-      description: 'Comprehensive repository analysis'
+      description: 'Comprehensive repository analysis',
     })
     .option('model', {
       type: 'string',
-      description: 'Override AI model selection'
+      description: 'Override AI model selection',
     })
     .option('no-attribution', {
       type: 'boolean',
-      description: 'Disable attribution footer'
+      description: 'Disable attribution footer',
     })
     .option('validate', {
       type: 'boolean',
-      description: 'Validate configuration'
+      description: 'Validate configuration',
     })
     .help()
     .alias('help', 'h')
-    .parse();
+    .parse()
 
   try {
     const generator = new AIChangelogGenerator({
       analysisMode: argv.detailed ? 'detailed' : argv.enterprise ? 'enterprise' : 'standard',
       modelOverride: argv.model,
-      includeAttribution: !argv.noAttribution
-    });
+      includeAttribution: !argv.noAttribution,
+    })
 
     if (argv.model) {
-      generator.setModelOverride(argv.model);
+      generator.setModelOverride(argv.model)
     }
 
     if (argv.detailed) {
-      generator.setAnalysisMode('detailed');
+      generator.setAnalysisMode('detailed')
     } else if (argv.enterprise) {
-      generator.setAnalysisMode('enterprise');
+      generator.setAnalysisMode('enterprise')
     }
 
     if (argv.validate) {
-      console.log(colors.infoMessage('🔧 Validating configuration...'));
-      await generator.validateConfiguration();
-      console.log(colors.successMessage('✅ Configuration is valid'));
-      return;
+      console.log(colors.infoMessage('🔧 Validating configuration...'))
+      await generator.validateConfiguration()
+      console.log(colors.successMessage('✅ Configuration is valid'))
+      return
     }
 
     if (argv.interactive) {
-      console.log(colors.infoMessage('🎮 Starting interactive mode...'));
-      await generator.runInteractive();
-      return;
+      console.log(colors.infoMessage('🎮 Starting interactive mode...'))
+      await generator.runInteractive()
+      return
     }
 
     if (argv.health) {
-      console.log(colors.infoMessage('🏥 Assessing repository health...'));
-      await generator.assessRepositoryHealth();
-      return;
+      const healthSpinner = new SimpleSpinner('Assessing repository health...')
+      healthSpinner.start()
+      await generator.assessRepositoryHealth()
+      healthSpinner.succeed('Repository health assessment complete')
+      return
     }
 
     if (argv.analyze) {
-      console.log(colors.infoMessage('🔍 Analyzing current changes...'));
-      await generator.analyzeCurrentChanges();
-      return;
+      const analyzeSpinner = new SimpleSpinner('Analyzing current changes...')
+      analyzeSpinner.start()
+      await generator.analyzeCurrentChanges()
+      analyzeSpinner.succeed('Current changes analysis complete')
+      return
     }
 
     if (argv.branches) {
-      console.log(colors.infoMessage('🌿 Analyzing branches...'));
-      await generator.analyzeRepository({ type: 'branches' });
-      return;
+      const branchSpinner = new SimpleSpinner('Analyzing branches...')
+      branchSpinner.start()
+      await generator.analyzeRepository({ type: 'branches' })
+      branchSpinner.succeed('Branch analysis complete')
+      return
     }
 
     if (argv.comprehensive) {
-      console.log(colors.infoMessage('📊 Running comprehensive analysis...'));
-      await generator.analyzeRepository({ type: 'comprehensive' });
-      return;
+      const compSpinner = new SimpleSpinner('Running comprehensive analysis...')
+      compSpinner.start()
+      await generator.analyzeRepository({ type: 'comprehensive' })
+      compSpinner.succeed('Comprehensive analysis complete')
+      return
     }
 
     // Default: Generate changelog
-    console.log(colors.infoMessage('📝 Generating changelog...'));
-    const result = await generator.generateChangelog(argv.tag || argv.version, argv.since);
-    
+    const changelogSpinner = new SimpleSpinner('Generating changelog...')
+    changelogSpinner.start()
+    const result = await generator.generateChangelog(argv.tag || argv.version, argv.since)
+
     if (result) {
-      console.log(colors.successMessage('✅ Changelog generated successfully!'));
-      
+      changelogSpinner.succeed('Changelog generated successfully!')
+
       // Show metrics
-      const metrics = generator.getMetrics();
-      console.log(colors.infoMessage(`📊 Processed ${metrics.commitsProcessed} commits in ${formatDuration(Date.now() - metrics.startTime)}`));
+      const metrics = generator.getMetrics()
+      EnhancedConsole.metrics(
+        `Processed ${metrics.commitsProcessed} commits in ${formatDuration(Date.now() - metrics.startTime)}`
+      )
+    } else {
+      changelogSpinner.fail('Failed to generate changelog')
     }
-
   } catch (error) {
-    console.error(colors.errorMessage('❌ Error:'), error.message);
+    EnhancedConsole.error(`Error: ${error.message}`)
     if (process.env.DEBUG) {
-      console.error(error.stack);
+      EnhancedConsole.error(error.stack)
     }
-    process.exit(1);
+    process.exit(1)
   }
 }
 
 function formatDuration(ms) {
-  const seconds = Math.round(ms / 1000);
-  return seconds > 0 ? `${seconds}s` : `${ms}ms`;
+  const seconds = Math.round(ms / 1000)
+  return seconds > 0 ? `${seconds}s` : `${ms}ms`
 }
 
-export { runCLI };
+export { runCLI }
 
 // If this file is run directly, execute CLI
 if (import.meta.url === `file://${process.argv[1]}`) {
-  runCLI();
-}
+  runCLI().catch((error) => {
+    console.error('CLI Error:', error.message)
+    process.exit(1)
+  })
+}