ai-changelog-generator-extension 0.4.0

package/src/services/EnvFileService.ts

@@ -0,0 +1,172 @@
+import * as vscode from 'vscode'
+import * as fs from 'fs'
+import * as path from 'path'
+
+export interface DetectedEnvVars {
+  [key: string]: string
+}
+
+export class EnvFileService {
+  /**
+   * Detect .env files in workspace and parse compatible API keys
+   */
+  static async detectEnvironmentVariables(): Promise<DetectedEnvVars> {
+    const workspaceFolders = vscode.workspace.workspaceFolders
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      return {}
+    }
+
+    const rootPath = workspaceFolders[0].uri.fsPath
+    const config = vscode.workspace.getConfiguration('aiChangelog')
+    const envFilePath = config.get<string>('envFilePath', '.env.local')
+
+    // Try multiple .env file locations
+    const envFiles = [
+      path.join(rootPath, envFilePath),
+      path.join(rootPath, '.env.local'),
+      path.join(rootPath, '.env'),
+    ]
+
+    let detectedVars: DetectedEnvVars = {}
+
+    for (const envFile of envFiles) {
+      if (fs.existsSync(envFile)) {
+        try {
+          const content = fs.readFileSync(envFile, 'utf8')
+          const vars = this.parseEnvFile(content)
+          detectedVars = { ...detectedVars, ...vars }
+        } catch (error) {
+          console.error(`Failed to read ${envFile}:`, error)
+        }
+      }
+    }
+
+    return detectedVars
+  }
+
+  /**
+   * Parse .env file content and extract AI provider keys
+   */
+  private static parseEnvFile(content: string): DetectedEnvVars {
+    const lines = content.split('\n')
+    const vars: DetectedEnvVars = {}
+
+    // Known API key and config patterns
+    const keyPatterns = [
+      'AI_PROVIDER',
+      'OPENAI_API_KEY',
+      'ANTHROPIC_API_KEY',
+      'GOOGLE_API_KEY',
+      'AZURE_OPENAI_KEY',
+      'AZURE_OPENAI_API_KEY',
+      'AZURE_OPENAI_ENDPOINT',
+      'AZURE_OPENAI_DEPLOYMENT_NAME',
+      'AZURE_OPENAI_API_VERSION',
+      'AZURE_OPENAI_USE_V1_API',
+      'AZURE_USE_AD_AUTH',
+      'AWS_ACCESS_KEY_ID',
+      'AWS_SECRET_ACCESS_KEY',
+      'HUGGINGFACE_API_KEY',
+      'OLLAMA_HOST',
+      'OLLAMA_MODEL',
+      'LMSTUDIO_BASE_URL',
+      'VERTEX_PROJECT_ID',
+      'VERTEX_LOCATION',
+      'GOOGLE_APPLICATION_CREDENTIALS',
+    ]
+
+    for (const line of lines) {
+      const trimmed = line.trim()
+
+      // Skip comments and empty lines
+      if (trimmed.startsWith('#') || !trimmed || !trimmed.includes('=')) {
+        continue
+      }
+
+      const [key, ...valueParts] = trimmed.split('=')
+      const value = valueParts.join('=').trim()
+
+      // Remove quotes
+      const cleanValue = value.replace(/^["']|["']$/g, '')
+
+      // Check if this is a known API key
+      if (keyPatterns.includes(key.trim())) {
+        vars[key.trim()] = cleanValue
+      }
+    }
+
+    return vars
+  }
+
+  /**
+   * Save API key to .env file
+   */
+  static async saveToEnvFile(key: string, value: string): Promise<void> {
+    const workspaceFolders = vscode.workspace.workspaceFolders
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      throw new Error('No workspace folder open')
+    }
+
+    const rootPath = workspaceFolders[0].uri.fsPath
+    const config = vscode.workspace.getConfiguration('aiChangelog')
+    const envFilePath = config.get<string>('envFilePath', '.env.local')
+    const envFile = path.join(rootPath, envFilePath)
+
+    let content = ''
+    let keyExists = false
+
+    // Read existing content
+    if (fs.existsSync(envFile)) {
+      content = fs.readFileSync(envFile, 'utf8')
+      const lines = content.split('\n')
+      const updatedLines: string[] = []
+
+      for (const line of lines) {
+        if (line.trim().startsWith(`${key}=`)) {
+          updatedLines.push(`${key}="${value}"`)
+          keyExists = true
+        } else {
+          updatedLines.push(line)
+        }
+      }
+
+      content = updatedLines.join('\n')
+    }
+
+    // Add key if it doesn't exist
+    if (!keyExists) {
+      if (content && !content.endsWith('\n')) {
+        content += '\n'
+      }
+      content += `${key}="${value}"\n`
+    }
+
+    // Write to file
+    fs.writeFileSync(envFile, content, 'utf8')
+  }
+
+  /**
+   * Check if any environment variables are detected
+   */
+  static async hasEnvVars(): Promise<boolean> {
+    const vars = await this.detectEnvironmentVariables()
+    return Object.keys(vars).length > 0
+  }
+
+  /**
+   * Get provider name from key name
+   */
+  static getProviderFromKey(key: string): string | null {
+    const keyMap: Record<string, string> = {
+      OPENAI_API_KEY: 'openai',
+      ANTHROPIC_API_KEY: 'anthropic',
+      GOOGLE_API_KEY: 'google',
+      AZURE_OPENAI_KEY: 'azure',
+      AZURE_OPENAI_API_KEY: 'azure',
+      AWS_ACCESS_KEY_ID: 'bedrock',
+      HUGGINGFACE_API_KEY: 'huggingface',
+    }
+
+    return keyMap[key] || null
+  }
+}

package/src/services/ExtensionConfigurationManager.ts

@@ -0,0 +1,224 @@
+import * as vscode from 'vscode'
+import { EnvFileService } from './EnvFileService'
+
+export class ExtensionConfigurationManager {
+  private secretStorage: vscode.SecretStorage
+  private initialized = false
+  private config: Record<string, any> = {}
+
+  constructor(secretStorage: vscode.SecretStorage) {
+    this.secretStorage = secretStorage
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return
+
+    // Load base config
+    this.loadConfig()
+
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    const storageMode = wsConfig.get<string>('storageMode', 'secrets')
+
+    if (storageMode === 'env') {
+      await this.loadFromEnvFile()
+    } else if (storageMode === 'settings') {
+      this.loadFromSettings()
+    } else {
+      await this.loadFromSecrets()
+    }
+
+    this.initialized = true
+  }
+
+  private async loadFromSecrets(): Promise<void> {
+    const providers = ['openai', 'anthropic', 'google', 'azure', 'bedrock', 'huggingface']
+
+    for (const provider of providers) {
+      const apiKey = await this.getApiKey(provider)
+      if (apiKey) {
+        const keyName = this.getKeyNameForProvider(provider)
+        this.config[keyName] = apiKey
+      }
+    }
+  }
+
+  private async loadFromEnvFile(): Promise<void> {
+    const envVars = await EnvFileService.detectEnvironmentVariables()
+
+    // Load all env vars into config
+    for (const [key, value] of Object.entries(envVars)) {
+      this.config[key] = value
+    }
+
+    // Also set AI_PROVIDER from env
+    if (!this.config.AI_PROVIDER && envVars.AI_PROVIDER) {
+      this.config.AI_PROVIDER = envVars.AI_PROVIDER
+    }
+  }
+
+  private loadFromSettings(): void {
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    const providers = ['openai', 'anthropic', 'google', 'azure', 'bedrock', 'huggingface']
+
+    for (const provider of providers) {
+      const keyName = `${provider}ApiKey`
+      const apiKey = wsConfig.get<string>(keyName)
+      if (apiKey) {
+        const configKeyName = this.getKeyNameForProvider(provider)
+        this.config[configKeyName] = apiKey
+      }
+    }
+  }
+
+  private getKeyNameForProvider(provider: string): string {
+    const keyMap: Record<string, string> = {
+      openai: 'OPENAI_API_KEY',
+      anthropic: 'ANTHROPIC_API_KEY',
+      google: 'GOOGLE_API_KEY',
+      azure: 'AZURE_OPENAI_KEY',
+      bedrock: 'AWS_ACCESS_KEY_ID',
+      huggingface: 'HUGGINGFACE_API_KEY',
+    }
+    return keyMap[provider] || `${provider.toUpperCase()}_API_KEY`
+  }
+
+  loadConfig() {
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+
+    // Base configuration with defaults
+    this.config = {
+      AI_PROVIDER: wsConfig.get<string>('provider', 'openai'),
+      DEFAULT_ANALYSIS_MODE: wsConfig.get<string>('analysisMode', 'standard'),
+      OUTPUT_FORMAT: wsConfig.get<string>('outputFormat', 'markdown'),
+      INCLUDE_ATTRIBUTION: wsConfig.get<boolean>('includeAttribution', true),
+      RATE_LIMIT_DELAY: wsConfig.get<number>('rateLimitDelay', 1000),
+      MAX_RETRIES: wsConfig.get<number>('maxRetries', 3),
+    }
+
+    // Model override
+    const model = wsConfig.get<string>('model')
+    if (model) {
+      this.config.OPENAI_MODEL = model
+    }
+
+    // Ollama config
+    this.config.OLLAMA_HOST = wsConfig.get<string>('ollamaHost', 'http://localhost:11434')
+    this.config.OLLAMA_MODEL = wsConfig.get<string>('ollamaModel', 'llama3')
+
+    // Azure config
+    const azureEndpoint = wsConfig.get<string>('azureEndpoint')
+    const azureDeployment = wsConfig.get<string>('azureDeploymentName')
+    const azureVersion = wsConfig.get<string>('azureApiVersion')
+
+    if (azureEndpoint) this.config.AZURE_OPENAI_ENDPOINT = azureEndpoint
+    if (azureDeployment) this.config.AZURE_OPENAI_DEPLOYMENT_NAME = azureDeployment
+    if (azureVersion) this.config.AZURE_OPENAI_API_VERSION = azureVersion
+
+    // Vertex AI config
+    const vertexProject = wsConfig.get<string>('vertexProjectId')
+    const vertexLocation = wsConfig.get<string>('vertexLocation')
+
+    if (vertexProject) this.config.VERTEX_PROJECT_ID = vertexProject
+    if (vertexLocation) this.config.VERTEX_LOCATION = vertexLocation
+
+    // LM Studio config
+    const lmstudioUrl = wsConfig.get<string>('lmstudioBaseUrl')
+    if (lmstudioUrl) this.config.LMSTUDIO_BASE_URL = lmstudioUrl
+  }
+
+  async getApiKey(provider: string): Promise<string | undefined> {
+    const keyMap: Record<string, string> = {
+      openai: 'OPENAI_API_KEY',
+      anthropic: 'ANTHROPIC_API_KEY',
+      google: 'GOOGLE_API_KEY',
+      azure: 'AZURE_OPENAI_KEY',
+      bedrock: 'AWS_ACCESS_KEY_ID',
+      huggingface: 'HUGGINGFACE_API_KEY',
+    }
+
+    const secretKey = keyMap[provider]
+    if (secretKey) {
+      return await this.secretStorage.get(secretKey)
+    }
+    return undefined
+  }
+
+  async storeApiKey(provider: string, key: string): Promise<void> {
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    const storageMode = wsConfig.get<string>('storageMode', 'secrets')
+    const secretKey = this.getKeyNameForProvider(provider)
+
+    if (storageMode === 'env') {
+      await EnvFileService.saveToEnvFile(secretKey, key)
+    } else if (storageMode === 'settings') {
+      const keyName = `${provider}ApiKey`
+      await wsConfig.update(keyName, key, vscode.ConfigurationTarget.Workspace)
+    } else {
+      await this.secretStorage.store(secretKey, key)
+    }
+
+    this.config[secretKey] = key
+  }
+
+  get(key: string): any {
+    return this.config[key]
+  }
+
+  set(key: string, value: any) {
+    this.config[key] = value
+  }
+
+  getAll(): Record<string, any> {
+    return { ...this.config }
+  }
+
+  isSetupComplete(): boolean {
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    return wsConfig.get<boolean>('setupCompleted', false)
+  }
+
+  isInitialized(): boolean {
+    return this.initialized
+  }
+
+  getCurrentProvider(): string {
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    return wsConfig.get<string>('provider') || this.config.AI_PROVIDER || 'openai'
+  }
+
+  getStorageMode(): string {
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    return wsConfig.get<string>('storageMode', 'secrets')
+  }
+
+  async hasApiKey(provider: string): Promise<boolean> {
+    const keyName = this.getKeyNameForProvider(provider)
+
+    // Check in memory first
+    if (this.config[keyName]) {
+      return true
+    }
+
+    // Check based on storage mode
+    const storageMode = this.getStorageMode()
+
+    if (storageMode === 'secrets') {
+      const key = await this.secretStorage.get(keyName)
+      return !!key
+    } else if (storageMode === 'env') {
+      const envVars = await EnvFileService.detectEnvironmentVariables()
+      return !!envVars[keyName]
+    } else if (storageMode === 'settings') {
+      const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+      const settingsKey = `${provider}ApiKey`
+      const key = wsConfig.get<string>(settingsKey)
+      return !!key
+    }
+
+    return false
+  }
+
+  get context() {
+    return { secrets: this.secretStorage }
+  }
+}

package/src/services/StatusService.ts

@@ -0,0 +1,211 @@
+import * as vscode from 'vscode'
+import { ExtensionConfigurationManager } from '../services/ExtensionConfigurationManager'
+import { EnvFileService } from '../services/EnvFileService'
+
+export interface SetupStatus {
+  isComplete: boolean
+  provider?: string
+  storageMode?: string
+  hasApiKey: boolean
+  errors: string[]
+}
+
+export class StatusService {
+  private static statusBarItem: vscode.StatusBarItem | null = null
+  private static outputChannel: vscode.OutputChannel | null = null
+
+  static initialize(context: vscode.ExtensionContext) {
+    this.statusBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      100
+    )
+    this.statusBarItem.command = 'ai-changelog.showStatus'
+    context.subscriptions.push(this.statusBarItem)
+
+    this.outputChannel = vscode.window.createOutputChannel('AI Changelog')
+    context.subscriptions.push(this.outputChannel)
+  }
+
+  static async updateStatus(configManager: ExtensionConfigurationManager) {
+    if (!this.statusBarItem) return
+
+    const status = await this.getStatus(configManager)
+
+    if (!status.isComplete) {
+      this.statusBarItem.text = '$(warning) AI Changelog: Setup Required'
+      this.statusBarItem.tooltip = 'Click to run setup wizard'
+      this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+        'statusBarItem.warningBackground'
+      )
+    } else if (!status.hasApiKey) {
+      this.statusBarItem.text = `$(error) AI Changelog: No API Key`
+      this.statusBarItem.tooltip = `Provider: ${status.provider}\nNo API key configured`
+      this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+        'statusBarItem.errorBackground'
+      )
+    } else if (status.errors.length > 0) {
+      this.statusBarItem.text = `$(alert) AI Changelog: ${status.provider}`
+      this.statusBarItem.tooltip = `Issues:\n${status.errors.join('\n')}`
+      this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+        'statusBarItem.warningBackground'
+      )
+    } else {
+      this.statusBarItem.text = `$(check) AI Changelog: ${status.provider}`
+      this.statusBarItem.tooltip = `Ready to generate\nProvider: ${status.provider}\nStorage: ${status.storageMode}`
+      this.statusBarItem.backgroundColor = undefined
+    }
+
+    this.statusBarItem.show()
+  }
+
+  static async getStatus(
+    configManager: ExtensionConfigurationManager
+  ): Promise<SetupStatus> {
+    const status: SetupStatus = {
+      isComplete: configManager.isSetupComplete(),
+      provider: configManager.getCurrentProvider(),
+      storageMode: configManager.getStorageMode(),
+      hasApiKey: false,
+      errors: [],
+    }
+
+    if (status.isComplete) {
+      // Check if API key exists
+      const provider = status.provider || 'openai'
+
+      if (provider === 'ollama' || provider === 'lmstudio') {
+        status.hasApiKey = true // Local models don't need API keys
+      } else {
+        // Ensure config is initialized to load env vars
+        if (!configManager.isInitialized()) {
+          await configManager.initialize()
+        }
+
+        // Check for API key in loaded config (includes env vars)
+        const keyName = configManager['getKeyNameForProvider'](provider)
+        const apiKey = configManager.get(keyName)
+
+        status.hasApiKey = !!apiKey && apiKey.length > 0
+
+        if (!status.hasApiKey) {
+          status.errors.push(`No API key found for ${provider}`)
+        }
+      }
+
+      // Check environment file if using env storage
+      if (status.storageMode === 'env') {
+        const hasEnv = await EnvFileService.hasEnvVars()
+        if (!hasEnv) {
+          status.errors.push('Storage mode is "env" but no .env file found')
+        }
+      }
+    }
+
+    return status
+  }
+
+  static log(message: string, show: boolean = false) {
+    if (this.outputChannel) {
+      const timestamp = new Date().toLocaleTimeString()
+      this.outputChannel.appendLine(`[${timestamp}] ${message}`)
+      if (show) {
+        this.outputChannel.show()
+      }
+    }
+  }
+
+  static async showStatusReport(configManager: ExtensionConfigurationManager) {
+    const status = await this.getStatus(configManager)
+
+    const lines: string[] = [
+      '# AI Changelog Generator - Configuration Status',
+      '',
+      '## Setup Status',
+      `- Setup Complete: ${status.isComplete ? '✅ Yes' : '❌ No'}`,
+      `- AI Provider: ${status.provider || 'Not configured'}`,
+      `- Storage Mode: ${status.storageMode || 'Not configured'}`,
+      `- Has API Key: ${status.hasApiKey ? '✅ Yes' : '❌ No'}`,
+      '',
+    ]
+
+    if (status.errors.length > 0) {
+      lines.push('## ⚠️ Issues Found')
+      status.errors.forEach((error) => lines.push(`- ${error}`))
+      lines.push('')
+    }
+
+    // Get detailed config
+    const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+    lines.push('## Current Settings')
+    lines.push(`- Provider: ${wsConfig.get('provider')}`)
+    lines.push(`- Model: ${wsConfig.get('model')}`)
+    lines.push(`- Temperature: ${wsConfig.get('temperature')}`)
+    lines.push(`- Storage Mode: ${wsConfig.get('storageMode')}`)
+    lines.push(`- Env File Path: ${wsConfig.get('envFilePath')}`)
+    lines.push(`- Auto Detect Env: ${wsConfig.get('autoDetectEnv')}`)
+    lines.push(`- Analysis Mode: ${wsConfig.get('analysisMode')}`)
+    lines.push('')
+
+    // Provider-specific settings
+    if (status.provider === 'ollama') {
+      lines.push('## Ollama Settings')
+      lines.push(`- Host: ${wsConfig.get('ollamaHost')}`)
+      lines.push(`- Model: ${wsConfig.get('ollamaModel')}`)
+      lines.push('')
+    } else if (status.provider === 'azure') {
+      lines.push('## Azure Settings')
+      lines.push(`- Endpoint: ${wsConfig.get('azureEndpoint') || 'Not set'}`)
+      lines.push(
+        `- Deployment: ${wsConfig.get('azureDeploymentName') || 'Not set'}`
+      )
+      lines.push(`- API Version: ${wsConfig.get('azureApiVersion')}`)
+      lines.push('')
+    } else if (status.provider === 'lmstudio') {
+      lines.push('## LM Studio Settings')
+      lines.push(`- Base URL: ${wsConfig.get('lmstudioBaseUrl')}`)
+      lines.push('')
+    }
+
+    // Environment file detection
+    if (wsConfig.get('autoDetectEnv')) {
+      const envVars = await EnvFileService.detectEnvironmentVariables()
+      if (Object.keys(envVars).length > 0) {
+        lines.push('## 🔍 Detected Environment Variables')
+        Object.keys(envVars).forEach((key) => {
+          lines.push(`- ${key}: ✅ Found`)
+        })
+        lines.push('')
+      }
+    }
+
+    // Recommendations
+    lines.push('## 💡 Recommendations')
+    if (!status.isComplete) {
+      lines.push('- Run the setup wizard: `AI Changelog: Setup Wizard`')
+    } else if (!status.hasApiKey) {
+      lines.push(
+        `- Configure API key for ${status.provider}: \`AI Changelog: Configure AI Provider\``
+      )
+    } else if (status.storageMode === 'settings') {
+      lines.push(
+        '- Consider using secure storage instead of settings.json for better security'
+      )
+    }
+
+    // Open in new document
+    const doc = await vscode.workspace.openTextDocument({
+      content: lines.join('\n'),
+      language: 'markdown',
+    })
+    await vscode.window.showTextDocument(doc)
+  }
+
+  static dispose() {
+    this.statusBarItem?.dispose()
+    this.outputChannel?.dispose()
+  }
+
+  static showOutputChannel() {
+    this.outputChannel?.show()
+  }
+}

package/src/types/core.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Type definitions for core ai-changelog-generator modules
+ * These allow TypeScript to understand imports from the workspace dependency
+ */
+
+declare module '@entro314labs/ai-changelog-generator/src/domains/git/git-manager.js' {
+  export class GitManager {
+    constructor(options: { cwd: string })
+    execGitSafe(command: string): string
+    execGit(command: string): string
+    getRepoRoot(): string
+    getCurrentBranch(): string
+    getTags(): string[]
+    getCommits(count?: number): any[]
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/domains/git/git.service.js' {
+  export class GitService {
+    constructor(gitManager: any, tagger: any)
+    analyzeWorkingDirectoryFileChange(status: string, filePath: string): Promise<any>
+    getWorkingDirectoryChanges(): Promise<any[]>
+    getCommitsBetweenTags(fromTag: string, toTag?: string): Promise<any[]>
+    analyzeCommit(commitHash: string): Promise<any>
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/domains/git/commit-tagger.js' {
+  export class CommitTagger {
+    constructor()
+    categorizeCommit(analysis: any): any
+    determineImportance(analysis: any): string
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/application/services/application.service.js' {
+  export class ApplicationService {
+    constructor(options: { configManager: any; cwd: string })
+    generateCommitMessage(): Promise<{
+      success: boolean
+      suggestions?: string[]
+      error?: string
+    }>
+    generateChangelogFromChanges(version: string): Promise<{
+      success: boolean
+      changelog?: string
+      error?: string
+    }>
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/infrastructure/config/configuration.manager.js' {
+  export class ConfigurationManager {
+    constructor()
+    config: Record<string, any>
+    loadConfig(): Record<string, any>
+    getAll(): Record<string, any>
+    get(key: string): any
+    set(key: string, value: any): void
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/application/orchestrators/changelog.orchestrator.js' {
+  export class ChangelogOrchestrator {
+    constructor(options: any)
+    generateChangelog(options?: any): Promise<any>
+    analyzeChanges(): Promise<any>
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/domains/ai/ai-analysis.service.js' {
+  export class AIAnalysisService {
+    constructor(aiProvider: any, promptEngine: any, tagger: any, analysisMode: string)
+    analyzeCommit(commit: any): Promise<any>
+    analyzeFileChange(analysis: any): Promise<any>
+  }
+}
+
+declare module '@entro314labs/ai-changelog-generator/src/infrastructure/providers/provider-manager.service.js' {
+  export class ProviderManagerService {
+    constructor(config: any)
+    getProvider(): any
+    isProviderAvailable(providerName: string): boolean
+  }
+}