ai-changelog-generator-extension 0.4.0

package/src/views/ReleaseSidebarProvider.ts

@@ -0,0 +1,370 @@
+import * as vscode from 'vscode'
+import { AIChangelogGenerator } from '@entro314labs/ai-changelog-generator'
+import { ExtensionConfigurationManager } from '../services/ExtensionConfigurationManager'
+import { StatusService } from '../services/StatusService'
+
+export class ReleaseSidebarProvider implements vscode.WebviewViewProvider {
+  _view?: vscode.WebviewView
+
+  constructor(
+    private readonly _extensionUri: vscode.Uri,
+    private readonly _configManager: ExtensionConfigurationManager
+  ) {}
+
+  public resolveWebviewView(
+    webviewView: vscode.WebviewView,
+    context: vscode.WebviewViewResolveContext,
+    _token: vscode.CancellationToken
+  ) {
+    this._view = webviewView
+
+    webviewView.webview.options = {
+      enableScripts: true,
+      localResourceRoots: [this._extensionUri],
+    }
+
+    webviewView.webview.html = this._getHtmlForWebview(webviewView.webview)
+
+    webviewView.webview.onDidReceiveMessage(async (data) => {
+      switch (data.type) {
+        case 'refresh':
+          await this.refresh()
+          break
+        case 'generate':
+          await this.generateChangelog()
+          break
+      }
+    })
+
+    // Initial refresh
+    setTimeout(() => this.refresh(), 1000)
+  }
+
+  public async refresh() {
+    if (!this._view) {
+      return
+    }
+
+    StatusService.log('[ReleaseView] Starting refresh...', true)
+
+    try {
+      const workspaceFolder = this.getWorkspaceFolder()
+      if (!workspaceFolder) {
+        StatusService.log('[ReleaseView] No workspace folder', true)
+        this._view.webview.postMessage({
+          type: 'error',
+          message: 'No workspace folder open. Please open a git repository.',
+        })
+        return
+      }
+
+      const rootPath = workspaceFolder.uri.fsPath
+      const configPath = require('path').join(rootPath, '.env.local')
+
+      StatusService.log(`[ReleaseView] Repository: ${rootPath}`, true)
+
+      // Use AI Changelog Generator to get repository info
+      StatusService.log('[ReleaseView] Creating generator...', true)
+      const generator = new AIChangelogGenerator({
+        repositoryPath: rootPath,
+        configPath: require('fs').existsSync(configPath) ? configPath : undefined,
+        silent: true,
+      })
+
+      // Get tags - analyze repository to see if it has tags
+      let tags: string[] = []
+      try {
+        StatusService.log('[ReleaseView] Analyzing for tags...', true)
+
+        // Add timeout to prevent hanging
+        const timeoutPromise = new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Analysis timeout after 15 seconds')), 15000)
+        )
+
+        const analysis: any = await Promise.race([
+          generator.analyzeRepository(),
+          timeoutPromise
+        ])
+
+        tags = analysis.tags || []
+        StatusService.log(`[ReleaseView] Found ${tags.length} tags`, true)
+      } catch (e: any) {
+        // No tags yet - that's okay
+        StatusService.log(`[ReleaseView] No tags: ${e.message}`, true)
+      }
+
+      StatusService.log(`[ReleaseView] Posting ${tags.length} tags`, true)
+      this._view.webview.postMessage({ type: 'update', tags })
+    } catch (error: any) {
+      StatusService.log(`[ReleaseView] ERROR: ${error.message}`, true)
+      console.error('Error refreshing release view:', error)
+      this._view.webview.postMessage({
+        type: 'error',
+        message: `Failed to refresh: ${error.message || 'Unknown error'}`,
+      })
+    }
+  }
+
+  /**
+   * Get the current workspace folder, handling multi-root workspaces
+   */
+  private getWorkspaceFolder(): vscode.WorkspaceFolder | undefined {
+    const workspaceFolders = vscode.workspace.workspaceFolders
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      return undefined
+    }
+
+    // If there's an active text editor, use its workspace folder
+    if (vscode.window.activeTextEditor) {
+      const activeFolder = vscode.workspace.getWorkspaceFolder(
+        vscode.window.activeTextEditor.document.uri
+      )
+      if (activeFolder) {
+        return activeFolder
+      }
+    }
+
+    // Default to first workspace folder
+    return workspaceFolders[0]
+  }
+
+  private async generateChangelog() {
+    const workspaceFolder = this.getWorkspaceFolder()
+    if (!workspaceFolder) {
+      vscode.window.showErrorMessage('No workspace folder open')
+      return
+    }
+    const rootPath = workspaceFolder.uri.fsPath
+
+    try {
+      // Ensure configuration is initialized
+      if (!this._configManager.isInitialized()) {
+        await this._configManager.initialize()
+      }
+
+      const configPath = require('path').join(rootPath, '.env.local')
+
+      // Create AI Changelog Generator
+      const generator = new AIChangelogGenerator({
+        repositoryPath: rootPath,
+        configPath: require('fs').existsSync(configPath) ? configPath : undefined,
+        silent: true,
+      })
+
+      // Analyze recent commits to suggest next version
+      StatusService.log('[ReleaseView] Analyzing commits for version suggestion...', true)
+      const recentCommits = await generator.analyzeRecentCommits(50)
+
+      // Calculate suggested version based on semantic versioning rules
+      const currentVersion = await this.getCurrentVersion(rootPath)
+      const suggestedVersion = this.calculateNextVersion(currentVersion, recentCommits)
+
+      StatusService.log(`[ReleaseView] Current: ${currentVersion}, Suggested: ${suggestedVersion}`, true)
+
+      const version = await vscode.window.showInputBox({
+        prompt: `Enter release version (suggested: ${suggestedVersion} based on commit analysis)`,
+        placeHolder: suggestedVersion,
+        value: suggestedVersion,
+        valueSelection: undefined,
+        validateInput: (value) => {
+          if (!value || value.trim() === '') {
+            return 'Version is required'
+          }
+          // Basic version format validation
+          if (!/^v?\d+\.\d+\.\d+/.test(value)) {
+            return 'Please use semantic versioning format (e.g., v1.0.1 or 1.0.1)'
+          }
+          return null
+        },
+      })
+
+      if (!version) return
+
+      await vscode.window.withProgress(
+        {
+          location: vscode.ProgressLocation.Notification,
+          title: `Generating Changelog for ${version}...`,
+          cancellable: false,
+        },
+        async () => {
+          // Generate changelog for the version
+          const result = await generator.generateChangelog(version)
+
+          vscode.window.showInformationMessage(
+            `✅ Changelog generated successfully for ${version}!`,
+            'Open File'
+          ).then((action) => {
+            if (action === 'Open File') {
+              // Open the generated changelog file
+              const changelogPath = require('path').join(rootPath, 'AI_CHANGELOG.md')
+              vscode.workspace.openTextDocument(changelogPath).then(doc => {
+                vscode.window.showTextDocument(doc)
+              })
+            }
+          })
+
+          // Refresh the view
+          setTimeout(() => this.refresh(), 500)
+        }
+      )
+    } catch (error: any) {
+      console.error('Changelog generation failed:', error)
+      vscode.window.showErrorMessage(
+        `Failed to generate changelog: ${error.message || 'Unknown error'}`
+      )
+    }
+  }
+
+  /**
+   * Get current version from git tags or package.json
+   */
+  private async getCurrentVersion(rootPath: string): Promise<string> {
+    try {
+      // Try to get latest git tag first
+      const { execSync } = require('child_process')
+      const latestTag = execSync('git describe --tags --abbrev=0', {
+        cwd: rootPath,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore']
+      }).trim()
+
+      if (latestTag) {
+        return latestTag
+      }
+    } catch (e) {
+      // No tags yet, try package.json
+    }
+
+    try {
+      const packageJsonPath = require('path').join(rootPath, 'package.json')
+      const fs = require('fs')
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+        if (packageJson.version) {
+          return packageJson.version.startsWith('v') ? packageJson.version : `v${packageJson.version}`
+        }
+      }
+    } catch (e) {
+      // No package.json
+    }
+
+    return 'v0.0.0'
+  }
+
+  /**
+   * Calculate next semantic version based on commit types
+   * - feat = minor bump (0.1.0 -> 0.2.0)
+   * - fix = patch bump (0.1.0 -> 0.1.1)
+   * - breaking = major bump (0.1.0 -> 1.0.0)
+   */
+  private calculateNextVersion(currentVersion: string, commits: any): string {
+    // Parse current version
+    const versionMatch = currentVersion.match(/v?(\d+)\.(\d+)\.(\d+)/)
+    if (!versionMatch) {
+      return 'v0.1.0'
+    }
+
+    let [, major, minor, patch] = versionMatch.map(Number)
+
+    // Analyze commits for version bump type
+    const hasBreaking = commits.some((c: any) =>
+      c.breaking ||
+      c.breakingChanges?.length > 0 ||
+      c.message?.includes('BREAKING CHANGE')
+    )
+
+    const hasFeat = commits.some((c: any) =>
+      c.type === 'feat' ||
+      c.message?.startsWith('feat:') ||
+      c.message?.startsWith('feat(')
+    )
+
+    const hasFix = commits.some((c: any) =>
+      c.type === 'fix' ||
+      c.message?.startsWith('fix:') ||
+      c.message?.startsWith('fix(')
+    )
+
+    StatusService.log(`[ReleaseView] Version analysis: breaking=${hasBreaking}, feat=${hasFeat}, fix=${hasFix}`, true)
+
+    if (hasBreaking) {
+      // Major version bump
+      major++
+      minor = 0
+      patch = 0
+    } else if (hasFeat) {
+      // Minor version bump
+      minor++
+      patch = 0
+    } else if (hasFix) {
+      // Patch version bump
+      patch++
+    } else {
+      // No significant changes, suggest patch bump
+      patch++
+    }
+
+    return `v${major}.${minor}.${patch}`
+  }
+
+  private _getHtmlForWebview(webview: vscode.Webview) {
+    return `<!DOCTYPE html>
+			<html lang="en">
+			<head>
+				<meta charset="UTF-8">
+				<meta name="viewport" content="width=device-width, initial-scale=1.0">
+				<title>Release Manager</title>
+                <style>
+                    body { font-family: var(--vscode-font-family); color: var(--vscode-foreground); padding: 10px; }
+                    .tag-item { display: flex; align-items: center; margin-bottom: 5px; padding: 5px; background: var(--vscode-list-hoverBackground); border-radius: 4px; }
+                    .tag-icon { margin-right: 10px; }
+                    .tag-name { flex: 1; font-weight: bold; }
+                    .button { background-color: var(--vscode-button-background); color: var(--vscode-button-foreground); border: none; padding: 8px 12px; cursor: pointer; width: 100%; margin-top: 10px; }
+                    .button:hover { background-color: var(--vscode-button-hoverBackground); }
+                    .error { color: var(--vscode-errorForeground); }
+                    h3 { margin-top: 0; }
+                </style>
+			</head>
+			<body>
+				<h3>Recent Tags</h3>
+				<div id="tag-list">Loading...</div>
+
+                <button class="button" onclick="handleGenerate()">Draft New Release</button>
+                <button class="button" onclick="handleRefresh()">Refresh System</button>
+
+                <script>
+                    const vscode = acquireVsCodeApi();
+
+                    window.addEventListener('message', event => {
+                        const message = event.data;
+                        const list = document.getElementById('tag-list');
+
+                        if (message.type === 'update') {
+                            if (message.tags.length === 0) {
+                                list.innerHTML = '<p>No tags found.</p>';
+                                return;
+                            }
+
+                            list.innerHTML = message.tags.map(t => \`
+                                <div class="tag-item">
+                                    <span class="tag-icon">🏷️</span>
+                                    <span class="tag-name">\${t}</span>
+                                </div>
+                            \`).join('');
+                        } else if (message.type === 'error') {
+                            list.innerHTML = \`<p class="error">\${message.message}</p>\`;
+                        }
+                    });
+
+                    function handleRefresh() {
+                        vscode.postMessage({ type: 'refresh' });
+                    }
+
+                    function handleGenerate() {
+                        vscode.postMessage({ type: 'generate' });
+                    }
+                </script>
+			</body>
+			</html>`
+  }
+}