@entro314labs/ai-changelog-generator 3.1.1 → 3.2.1

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,111 +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;
+      console.error(colors.errorMessage('Changelog from commits error:'), error.message)
+      throw error
     }
   }
 
   // Interactive commit workflow
   async executeCommitWorkflow(options = {}) {
     try {
-      await this.ensureInitialized();
-      
+      await this.ensureInitialized()
+
       // Delegate to orchestrator for the commit workflow
-      return await this.orchestrator.executeCommitWorkflow(options);
+      return await this.orchestrator.executeCommitWorkflow(options)
     } catch (error) {
-      console.error(colors.errorMessage('Commit workflow error:'), error.message);
-      throw error;
+      console.error(colors.errorMessage('Commit workflow error:'), error.message)
+      throw error
     }
   }
-}
+}