ai-changelog-generator-extension 0.4.0

package/src/commands/setupWizard.ts

@@ -0,0 +1,333 @@
+import * as vscode from 'vscode'
+import { ExtensionConfigurationManager } from '../services/ExtensionConfigurationManager'
+import { EnvFileService } from '../services/EnvFileService'
+import { StatusService } from '../services/StatusService'
+
+export async function setupWizard(
+  configManager: ExtensionConfigurationManager
+): Promise<boolean> {
+  const config = vscode.workspace.getConfiguration('aiChangelog')
+
+  StatusService.log('Setup wizard started')
+
+  // Welcome message
+  const proceed = await vscode.window.showInformationMessage(
+    '🎉 Welcome to AI Changelog Generator!\n\nThis wizard will help you configure your AI provider in 3 simple steps:\n\n1️⃣ Choose storage method\n2️⃣ Select AI provider\n3️⃣ Enter credentials\n\nReady to begin?',
+    { modal: true },
+    'Start Setup',
+    'Cancel'
+  )
+
+  if (proceed !== 'Start Setup') {
+    StatusService.log('Setup wizard cancelled by user')
+    return false
+  }
+
+  try {
+    // Step 1: Check for existing environment variables
+    const autoDetect = config.get<boolean>('autoDetectEnv', true)
+    if (autoDetect) {
+      const envVars = await EnvFileService.detectEnvironmentVariables()
+      if (Object.keys(envVars).length > 0) {
+        StatusService.log(`Found ${Object.keys(envVars).length} API keys in .env files`)
+
+        const useEnv = await vscode.window.showInformationMessage(
+          `🔍 Found API keys in .env file!\n\nDetected: ${Object.keys(envVars).join(', ')}\n\nWould you like to import these keys?`,
+          { modal: true },
+          'Import from .env',
+          'Configure Manually'
+        )
+
+        if (useEnv === 'Import from .env') {
+          StatusService.log('Importing keys from .env file...')
+
+          // Import keys from .env
+          for (const [key, value] of Object.entries(envVars)) {
+            const provider = EnvFileService.getProviderFromKey(key)
+            if (provider && value) {
+              await configManager.storeApiKey(provider, value)
+              StatusService.log(`✓ Imported ${key} for ${provider}`)
+            }
+          }
+
+          // Set storage mode to env
+          await config.update('storageMode', 'env', vscode.ConfigurationTarget.Workspace)
+
+          // Determine primary provider
+          const firstKey = Object.keys(envVars)[0]
+          const primaryProvider = EnvFileService.getProviderFromKey(firstKey)
+          if (primaryProvider) {
+            await config.update('provider', primaryProvider, vscode.ConfigurationTarget.Workspace)
+            StatusService.log(`Set primary provider to ${primaryProvider}`)
+          }
+
+          await config.update('setupCompleted', true, vscode.ConfigurationTarget.Workspace)
+
+          vscode.window.showInformationMessage(
+            '✅ Setup complete! API keys imported from .env file.',
+            'Test Connection'
+          ).then((action) => {
+            if (action === 'Test Connection') {
+              vscode.commands.executeCommand('ai-changelog.testConnection')
+            }
+          })
+
+          StatusService.log('Setup completed successfully (env import)')
+          return true
+        }
+      }
+    }
+
+    // Step 2: Choose storage mode
+    await vscode.window.showInformationMessage(
+      '📍 Step 1 of 3: Storage Method\n\nWhere should API keys be stored?',
+      { modal: false }
+    )
+
+    const storageMode = await vscode.window.showQuickPick(
+      [
+        {
+          label: '🔒 Secure Storage (Recommended)',
+          description: 'Store keys in VS Code secret storage',
+          value: 'secrets',
+        },
+        {
+          label: '📄 Environment File',
+          description: 'Store keys in .env.local file',
+          value: 'env',
+        },
+        {
+          label: '⚙️ Settings File',
+          description: 'Store in settings.json (not recommended - not secure)',
+          value: 'settings',
+        },
+      ],
+      {
+        placeHolder: 'Select where to store API keys',
+        ignoreFocusOut: true,
+      }
+    )
+
+    if (!storageMode) {
+      StatusService.log('Setup cancelled: No storage mode selected')
+      return false
+    }
+
+    await config.update('storageMode', storageMode.value, vscode.ConfigurationTarget.Workspace)
+    StatusService.log(`Storage mode set to: ${storageMode.value}`)
+
+    // Step 3: Choose provider
+    await vscode.window.showInformationMessage(
+      '📍 Step 2 of 3: AI Provider\n\nSelect your AI provider',
+      { modal: false }
+    )
+
+    const provider = await vscode.window.showQuickPick(
+      [
+        { label: 'OpenAI', description: 'GPT-4, GPT-4 Turbo, GPT-4o', value: 'openai' },
+        { label: 'Anthropic', description: 'Claude 3.5 Sonnet, Opus', value: 'anthropic' },
+        { label: 'Google', description: 'Gemini Pro, Gemini Ultra', value: 'google' },
+        { label: 'Azure OpenAI', description: 'Azure-hosted OpenAI models', value: 'azure' },
+        {
+          label: 'AWS Bedrock',
+          description: 'Claude via AWS Bedrock',
+          value: 'bedrock',
+        },
+        { label: 'Ollama', description: 'Local models via Ollama', value: 'ollama' },
+        { label: 'LM Studio', description: 'Local models via LM Studio', value: 'lmstudio' },
+      ],
+      {
+        placeHolder: 'Select your AI provider',
+        ignoreFocusOut: true,
+      }
+    )
+
+    if (!provider) {
+      StatusService.log('Setup cancelled: No provider selected')
+      return false
+    }
+
+    await config.update('provider', provider.value, vscode.ConfigurationTarget.Workspace)
+    StatusService.log(`Provider set to: ${provider.value}`)
+
+    // Step 4: Configure provider-specific settings
+    await vscode.window.showInformationMessage(
+      `📍 Step 3 of 3: Configure ${provider.label}\n\nAlmost there!`,
+      { modal: false }
+    )
+
+    // Handle local providers (Ollama, LM Studio)
+    if (provider.value === 'ollama') {
+      const host = await vscode.window.showInputBox({
+        prompt: 'Ollama API host',
+        value: 'http://localhost:11434',
+        placeHolder: 'http://localhost:11434',
+        ignoreFocusOut: true,
+      })
+
+      if (host) {
+        await config.update('ollamaHost', host, vscode.ConfigurationTarget.Workspace)
+      }
+
+      const model = await vscode.window.showInputBox({
+        prompt: 'Ollama model name',
+        value: 'mistral',
+        placeHolder: 'mistral',
+        ignoreFocusOut: true,
+      })
+
+      if (model) {
+        await config.update('model', model, vscode.ConfigurationTarget.Workspace)
+      }
+
+      await config.update('setupCompleted', true, vscode.ConfigurationTarget.Workspace)
+      StatusService.log('Setup completed successfully (Ollama)')
+
+      const testNow = await vscode.window.showInformationMessage(
+        '✅ Ollama configured successfully!\n\nWould you like to test the connection?',
+        'Test Now',
+        'Skip'
+      )
+
+      if (testNow === 'Test Now') {
+        vscode.commands.executeCommand('ai-changelog.testConnection')
+      }
+
+      return true
+    }
+
+    if (provider.value === 'lmstudio') {
+      const host = await vscode.window.showInputBox({
+        prompt: 'LM Studio API host',
+        value: 'http://localhost:1234',
+        placeHolder: 'http://localhost:1234',
+        ignoreFocusOut: true,
+      })
+
+      if (host) {
+        await config.update('lmStudioHost', host, vscode.ConfigurationTarget.Workspace)
+      }
+
+      await config.update('setupCompleted', true, vscode.ConfigurationTarget.Workspace)
+      StatusService.log('Setup completed successfully (LM Studio)')
+
+      const testNow = await vscode.window.showInformationMessage(
+        '✅ LM Studio configured successfully!\n\nWould you like to test the connection?',
+        'Test Now',
+        'Skip'
+      )
+
+      if (testNow === 'Test Now') {
+        vscode.commands.executeCommand('ai-changelog.testConnection')
+      }
+
+      return true
+    }
+
+    // Step 5: Get API key for cloud providers
+    const apiKey = await vscode.window.showInputBox({
+      prompt: `Enter your ${provider.label} API key`,
+      password: true,
+      placeHolder: 'sk-...',
+      ignoreFocusOut: true,
+      validateInput: (value) => {
+        if (!value || value.trim().length === 0) {
+          return 'API key is required'
+        }
+        if (value.length < 10) {
+          return 'API key seems too short. Please check it.'
+        }
+        return null
+      },
+    })
+
+    if (!apiKey) {
+      StatusService.log('Setup cancelled: No API key entered')
+      return false
+    }
+
+    StatusService.log(`API key entered for ${provider.value} (${apiKey.length} characters)`)
+
+    // Step 6: Save API key based on storage mode
+    try {
+      if (storageMode.value === 'env') {
+        const keyName = configManager['getKeyNameForProvider'](provider.value)
+        await EnvFileService.saveToEnvFile(keyName, apiKey)
+        StatusService.log(`✓ API key saved to .env file`)
+        vscode.window.showInformationMessage(`✅ API key saved to .env.local`)
+      } else if (storageMode.value === 'settings') {
+        // Save to workspace settings (not recommended)
+        const keyName = `${provider.value}ApiKey`
+        await config.update(keyName, apiKey, vscode.ConfigurationTarget.Workspace)
+        StatusService.log(`✓ API key saved to settings.json`)
+        vscode.window.showWarningMessage(
+          '⚠️ API key stored in settings.json. This is visible in your workspace settings and not recommended for security.'
+        )
+      } else {
+        // Default: secure storage
+        await configManager.storeApiKey(provider.value, apiKey)
+        StatusService.log(`✓ API key saved to secure storage`)
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error)
+      StatusService.log(`✗ Failed to save API key: ${errorMsg}`)
+      vscode.window.showErrorMessage(`Failed to save API key: ${errorMsg}`)
+      return false
+    }
+
+    // Azure-specific configuration
+    if (provider.value === 'azure') {
+      const endpoint = await vscode.window.showInputBox({
+        prompt: 'Azure OpenAI endpoint',
+        placeHolder: 'https://your-resource.openai.azure.com',
+        ignoreFocusOut: true,
+      })
+
+      if (endpoint) {
+        await config.update('azureEndpoint', endpoint, vscode.ConfigurationTarget.Workspace)
+      }
+
+      const deployment = await vscode.window.showInputBox({
+        prompt: 'Azure deployment name',
+        placeHolder: 'gpt-4',
+        ignoreFocusOut: true,
+      })
+
+      if (deployment) {
+        await config.update(
+          'azureDeploymentName',
+          deployment,
+          vscode.ConfigurationTarget.Workspace
+        )
+      }
+    }
+
+    // Mark setup as completed
+    await config.update('setupCompleted', true, vscode.ConfigurationTarget.Workspace)
+    StatusService.log('Setup marked as complete')
+
+    // Test connection
+    const testConnection = await vscode.window.showInformationMessage(
+      '✅ Configuration saved!\n\nWould you like to test the connection to verify everything works?',
+      { modal: true },
+      'Test Now',
+      'Skip'
+    )
+
+    if (testConnection === 'Test Now') {
+      StatusService.log('User requested connection test')
+      await vscode.commands.executeCommand('ai-changelog.testConnection')
+    } else {
+      vscode.window.showInformationMessage(
+        '🎉 Setup complete! You can test the connection anytime with "AI Changelog: Test Connection"'
+      )
+    }
+
+    return true
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error)
+    StatusService.log(`✗ Setup wizard failed: ${errorMsg}`)
+    vscode.window.showErrorMessage(`Setup failed: ${errorMsg}`)
+    return false
+  }
+}

package/src/commands/testConnection.ts

@@ -0,0 +1,93 @@
+import * as vscode from 'vscode'
+import { ExtensionConfigurationManager } from '../services/ExtensionConfigurationManager'
+import { StatusService } from '../services/StatusService'
+
+export async function testConnection(
+  configManager: ExtensionConfigurationManager
+): Promise<void> {
+  const provider = configManager.getCurrentProvider()
+
+  StatusService.log(`Testing connection to ${provider}...`, true)
+
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: `Testing ${provider} connection...`,
+      cancellable: false,
+    },
+    async (progress) => {
+      try {
+        progress.report({ increment: 30, message: 'Checking configuration...' })
+
+        // Ensure config manager is initialized to load env vars if needed
+        if (!configManager.isInitialized()) {
+          await configManager.initialize()
+        }
+
+        // Check if API key exists (for cloud providers)
+        if (provider !== 'ollama' && provider !== 'lmstudio') {
+          // Check in config manager (which includes env vars)
+          const keyName = configManager['getKeyNameForProvider'](provider)
+          const apiKey = configManager.get(keyName)
+
+          if (!apiKey || apiKey.trim().length === 0) {
+            throw new Error(`No API key configured for ${provider}. Storage mode: ${configManager.getStorageMode()}`)
+          }
+          StatusService.log(`✓ API key found for ${provider}`)
+        }
+
+        progress.report({ increment: 30, message: 'Initializing...' })
+
+        // Try to import and initialize the ApplicationService
+        const { ApplicationService } = await import(
+          '@entro314labs/ai-changelog-generator/src/application/services/application.service.js'
+        )
+
+        const workspaceFolders = vscode.workspace.workspaceFolders
+        if (!workspaceFolders) {
+          throw new Error('No workspace folder open')
+        }
+
+        const appService = new ApplicationService({
+          configManager: configManager,
+          cwd: workspaceFolders[0].uri.fsPath,
+        })
+
+        progress.report({ increment: 40, message: 'Testing AI provider...' })
+
+        // This will test if the provider can be initialized
+        // For a real test, we'd need to make a small API call
+        StatusService.log(`✓ ${provider} provider initialized successfully`)
+
+        vscode.window.showInformationMessage(
+          `✅ Connection to ${provider} successful!\n\nProvider is configured and ready to use.`,
+          'View Details'
+        ).then((action) => {
+          if (action === 'View Details') {
+            vscode.commands.executeCommand('ai-changelog.showStatus')
+          }
+        })
+
+        StatusService.log(`Connection test passed for ${provider}`)
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        StatusService.log(`✗ Connection test failed: ${errorMessage}`)
+
+        const action = await vscode.window.showErrorMessage(
+          `❌ Connection to ${provider} failed:\n\n${errorMessage}`,
+          'View Logs',
+          'Reconfigure',
+          'Check Status'
+        )
+
+        if (action === 'View Logs') {
+          vscode.commands.executeCommand('ai-changelog.showLogs')
+        } else if (action === 'Reconfigure') {
+          vscode.commands.executeCommand('ai-changelog.setup')
+        } else if (action === 'Check Status') {
+          vscode.commands.executeCommand('ai-changelog.showStatus')
+        }
+      }
+    }
+  )
+}

package/src/extension.ts

@@ -0,0 +1,264 @@
+import * as vscode from 'vscode'
+import { CommitSidebarProvider } from './views/CommitSidebarProvider'
+import { ReleaseSidebarProvider } from './views/ReleaseSidebarProvider'
+import { SettingsPanelProvider } from './views/SettingsPanelProvider'
+import { OnboardingPanelProvider } from './views/OnboardingPanelProvider'
+import { ExtensionConfigurationManager } from './services/ExtensionConfigurationManager'
+import { EnvFileService } from './services/EnvFileService'
+import { StatusService } from './services/StatusService'
+import { configureProviderCommand } from './commands/configureProvider'
+import { setupWizard } from './commands/setupWizard'
+import { testConnection } from './commands/testConnection'
+
+export async function activate(context: vscode.ExtensionContext) {
+  console.log('AI Changelog Generator extension is activating...')
+
+  try {
+    // Initialize StatusService first
+    StatusService.initialize(context)
+    StatusService.log('Extension activation started')
+
+    // Initialize configuration manager
+    const configManager = new ExtensionConfigurationManager(context.secrets)
+
+    // Check if setup is complete
+    const setupComplete = configManager.isSetupComplete()
+    StatusService.log(`Setup complete: ${setupComplete}`)
+
+    if (!setupComplete) {
+      // Update status bar
+      StatusService.updateStatus(configManager)
+
+      // Show onboarding panel
+      StatusService.log('Opening onboarding panel...')
+      OnboardingPanelProvider.createOrShow(context.extensionUri, configManager)
+    } else {
+      // Load configuration
+      await configManager.initialize()
+      StatusService.log('Configuration loaded successfully')
+
+      // Update status bar
+      StatusService.updateStatus(configManager)
+
+      // Auto-detect environment variables if enabled
+      const wsConfig = vscode.workspace.getConfiguration('aiChangelog')
+      const autoDetect = wsConfig.get<boolean>('autoDetectEnv', true)
+      const storageMode = configManager.getStorageMode()
+
+      if (autoDetect && storageMode !== 'env') {
+        const hasEnvVars = await EnvFileService.hasEnvVars()
+        if (hasEnvVars) {
+          StatusService.log('Env vars detected, asking user...')
+          const useEnv = await vscode.window.showInformationMessage(
+            '🔍 Detected API keys in .env files. Would you like to use them?',
+            'Use .env',
+            'Keep Current',
+            "Don't Ask Again"
+          )
+
+          if (useEnv === 'Use .env') {
+            StatusService.log('Switching to .env storage mode')
+            await wsConfig.update('storageMode', 'env', vscode.ConfigurationTarget.Workspace)
+            await configManager.initialize() // Reload with env vars
+            StatusService.updateStatus(configManager)
+            vscode.window.showInformationMessage('✅ Now using API keys from .env file')
+          } else if (useEnv === "Don't Ask Again") {
+            StatusService.log('User disabled auto-detect')
+            await wsConfig.update('autoDetectEnv', false, vscode.ConfigurationTarget.Workspace)
+          }
+        }
+      }
+    }
+
+    console.log('Configuration manager initialized')
+    StatusService.log('Registering commands...')
+
+    // Register Settings Panel Provider
+    const settingsProvider = new SettingsPanelProvider(context.extensionUri, configManager)
+    context.subscriptions.push(
+      vscode.window.registerWebviewViewProvider(
+        SettingsPanelProvider.viewType,
+        settingsProvider
+      )
+    )
+    StatusService.log('Settings panel provider registered')
+
+    // Register all commands
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.setup', async () => {
+        StatusService.log('Setup command invoked - opening onboarding panel')
+        OnboardingPanelProvider.createOrShow(context.extensionUri, configManager)
+      })
+    )
+
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.testConnection', async () => {
+        StatusService.log('Test connection command invoked')
+        await testConnection(configManager)
+      })
+    )
+
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.showStatus', async () => {
+        StatusService.log('Show status command invoked')
+        await StatusService.showStatusReport(configManager)
+      })
+    )
+
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.showLogs', () => {
+        StatusService.log('Show logs command invoked')
+        StatusService.showOutputChannel()
+      })
+    )
+
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.detectEnv', async () => {
+        StatusService.log('Detect env command invoked')
+        const envVars = await EnvFileService.detectEnvironmentVariables()
+        if (Object.keys(envVars).length === 0) {
+          vscode.window.showInformationMessage('No API keys found in .env files')
+          StatusService.log('No env vars found')
+        } else {
+          const keys = Object.keys(envVars).join(', ')
+          vscode.window.showInformationMessage(`Found keys: ${keys}`)
+          StatusService.log(`Found env vars: ${keys}`)
+        }
+      })
+    )
+
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.configure', () => {
+        StatusService.log('Configure provider command invoked')
+        configureProviderCommand(configManager)
+      })
+    )
+
+    // Listen for configuration changes and provide immediate feedback
+    context.subscriptions.push(
+      vscode.workspace.onDidChangeConfiguration(async (e) => {
+        if (e.affectsConfiguration('aiChangelog')) {
+          StatusService.log('Configuration changed, validating...')
+
+          // Reinitialize config manager
+          await configManager.initialize()
+
+          // Update status bar
+          StatusService.updateStatus(configManager)
+
+          // Validate provider changes
+          if (e.affectsConfiguration('aiChangelog.provider')) {
+            const provider = vscode.workspace.getConfiguration('aiChangelog').get<string>('provider')
+            StatusService.log(`Provider changed to: ${provider}`)
+
+            const hasKey = await configManager.hasApiKey(provider || 'openai')
+            if (!hasKey && provider !== 'ollama' && provider !== 'lmstudio') {
+              vscode.window.showWarningMessage(
+                `⚠️ Provider changed to ${provider} but no API key is configured.`,
+                'Open Settings'
+              ).then((action) => {
+                if (action === 'Open Settings') {
+                  vscode.commands.executeCommand('ai-changelog-settings-view.focus')
+                }
+              })
+            } else {
+              vscode.window.showInformationMessage(`✅ Provider set to ${provider}`)
+            }
+          }
+
+          // Validate storage mode changes
+          if (e.affectsConfiguration('aiChangelog.storageMode')) {
+            const mode = vscode.workspace.getConfiguration('aiChangelog').get<string>('storageMode')
+            StatusService.log(`Storage mode changed to: ${mode}`)
+
+            if (mode === 'env') {
+              const envVars = await EnvFileService.detectEnvironmentVariables()
+              if (Object.keys(envVars).length === 0) {
+                vscode.window.showWarningMessage(
+                  '⚠️ Storage mode set to .env but no .env file found. Create .env.local in workspace root.'
+                )
+              } else {
+                vscode.window.showInformationMessage(
+                  `✅ Found ${Object.keys(envVars).length} API key(s) in .env file`
+                )
+              }
+            } else {
+              vscode.window.showInformationMessage(`✅ Storage mode set to ${mode}`)
+            }
+          }
+
+          StatusService.log('Configuration validation complete')
+        }
+      })
+    )
+
+    // Register the Commit Sidebar Provider
+    const sidebarProvider = new CommitSidebarProvider(context.extensionUri, configManager)
+    context.subscriptions.push(
+      vscode.window.registerWebviewViewProvider('ai-changelog-commit-view', sidebarProvider)
+    )
+    StatusService.log('Commit sidebar provider registered')
+
+    // Register Release Provider
+    const releaseProvider = new ReleaseSidebarProvider(context.extensionUri, configManager)
+    context.subscriptions.push(
+      vscode.window.registerWebviewViewProvider('ai-changelog-release-view', releaseProvider)
+    )
+    StatusService.log('Release sidebar provider registered')
+
+    // Register Commands
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.generateCommit', async () => {
+        StatusService.log('Generate commit command invoked')
+        if (!configManager.isSetupComplete()) {
+          StatusService.log('Setup not complete, prompting user')
+          const runSetup = await vscode.window.showWarningMessage(
+            'AI Changelog Generator is not set up yet. Would you like to run the setup wizard?',
+            'Setup Now',
+            'Cancel'
+          )
+          if (runSetup === 'Setup Now') {
+            await vscode.commands.executeCommand('ai-changelog.setup')
+          }
+          return
+        }
+        await vscode.commands.executeCommand('ai-changelog-commit-view.focus')
+      })
+    )
+
+    context.subscriptions.push(
+      vscode.commands.registerCommand('ai-changelog.generateRelease', async () => {
+        StatusService.log('Generate release command invoked')
+        if (!configManager.isSetupComplete()) {
+          StatusService.log('Setup not complete, prompting user')
+          const runSetup = await vscode.window.showWarningMessage(
+            'AI Changelog Generator is not set up yet. Would you like to run the setup wizard?',
+            'Setup Now',
+            'Cancel'
+          )
+          if (runSetup === 'Setup Now') {
+            await vscode.commands.executeCommand('ai-changelog.setup')
+          }
+          return
+        }
+        await vscode.commands.executeCommand('ai-changelog-release-view.focus')
+      })
+    )
+
+    console.log('AI Changelog Generator extension is now active!')
+    StatusService.log('Extension activated successfully')
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.error('Failed to activate AI Changelog Generator extension:', errorMessage)
+    StatusService.log(`✗ Extension activation failed: ${errorMessage}`)
+    vscode.window.showErrorMessage(
+      `AI Changelog Generator failed to activate: ${errorMessage}`
+    )
+  }
+}
+
+export function deactivate() {
+  console.log('AI Changelog Generator extension is deactivating...')
+  StatusService.log('Extension deactivating')
+  StatusService.dispose()
+}