feat: open file diff

Author: zhangmo8

src/channel/constant.ts renamed to src/constant.ts

@@ -62,4 +62,15 @@ export class GitService {
       throw error
     }
   }
+
+  async getParentCommit(commitHash: string): Promise<string | null> {
+    try {
+      const result = await this.git.raw(['rev-parse', `${commitHash}^`])
+      return result.trim()
+    }
+    catch (error) {
+      console.error('Failed to get parent commit:', error)
+      return null
+    }
+  }
 }

src/git/index.ts

@@ -12,6 +12,10 @@ export interface Commit extends ListLogLine {
     additions: number
     deletions: number
   }
+  files?: Array<{
+    path: string
+    status: string
+  }>
 }
 
 export interface CommitStats {

src/git/types.ts

@@ -1,30 +1,72 @@
 import * as vscode from 'vscode'
 
 import { GitPanelViewProvider } from './views/webview'
-import { GitChangesProvider } from './views/diff'
-import { GitService } from './git'
-import { DiffViewService } from './views/diff/DiffViewService'
+import { DiffProvider } from './views/diff'
 
+import { GitService } from './git'
+import { StorageService } from './storage'
 import { logger } from './utils'
 
 export function activate(context: vscode.ExtensionContext) {
   logger.info('Git Panel Activated')
 
+  const storageService = StorageService.initialize(context)
+  storageService.clearCommits()
+
   const gitService = new GitService()
-  const diffViewService = DiffViewService.initialize(gitService)
 
-  const provider = new GitPanelViewProvider(vscode.Uri.file(__dirname), context, gitService)
+  const provider = new GitPanelViewProvider(vscode.Uri.file(__dirname), gitService)
   vscode.window.registerWebviewViewProvider(GitPanelViewProvider.viewType, provider)
 
-  const gitChangesProvider = GitChangesProvider.getInstance()
+  const diffProvider = DiffProvider.getInstance()
   vscode.window.createTreeView('git-panel.changes', {
-    treeDataProvider: gitChangesProvider,
+    treeDataProvider: diffProvider,
     showCollapseAll: true,
   })
 
-  context.subscriptions.push({
-    dispose: () => {
-      diffViewService.dispose()
-    },
+  // Register openDiff command
+  context.subscriptions.push(
+    vscode.commands.registerCommand('vscGitPanel.openDiff', async (fileInfo: { path: string, status: string }) => {
+      const commit = diffProvider.getSelectedCommitHash()
+      if (!commit) {
+        return
+      }
+
+      const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri
+      if (!workspaceRoot) {
+        return
+      }
+
+      const uri = vscode.Uri.joinPath(workspaceRoot, fileInfo.path)
+      const title = `${fileInfo.path} (${commit})`
+
+      // For modified files, show diff between current commit and its parent
+      if (fileInfo.status === 'M') {
+        const parentCommit = await gitService.getParentCommit(commit)
+        if (parentCommit) {
+          const leftUri = toGitUri(uri, parentCommit, fileInfo)
+          const rightUri = toGitUri(uri, commit, fileInfo)
+          await vscode.commands.executeCommand('vscode.diff', leftUri, rightUri, title)
+          return
+        }
+      }
+
+      // For added files, show the entire file content
+      if (fileInfo.status === 'A') {
+        const gitUri = toGitUri(uri, commit, fileInfo)
+        await vscode.commands.executeCommand('vscode.open', gitUri)
+      }
+    }),
+  )
+}
+
+// Helper function to create Git URIs
+function toGitUri(uri: vscode.Uri, ref: string, fileInfo: { path: string }): vscode.Uri {
+  return uri.with({
+    scheme: 'git',
+    query: JSON.stringify({
+      path: fileInfo.path,
+      ref,
+    }),
   })
 }

src/index.ts

@@ -1,17 +1,49 @@
-import type { ListLogLine } from 'simple-git'
 import type * as vscode from 'vscode'
+import type { Commit } from '@/git/types'
 
 export class StorageService {
   private static readonly COMMITS_KEY = 'git-panel.commits'
+  private static instance: StorageService
+  private context: vscode.ExtensionContext
 
-  constructor(private context: vscode.ExtensionContext) {}
+  private constructor(context: vscode.ExtensionContext) {
+    this.context = context
+  }
+
+  static initialize(context: vscode.ExtensionContext): StorageService {
+    if (!StorageService.instance) {
+      StorageService.instance = new StorageService(context)
+    }
+    return StorageService.instance
+  }
+
+  static getInstance(): StorageService {
+    if (!StorageService.instance) {
+      throw new Error('StorageService must be initialized with context first')
+    }
+    return StorageService.instance
+  }
 
-  saveCommits(commits: ListLogLine[]) {
+  saveCommits(commits: Commit[]) {
     this.context.globalState.update(StorageService.COMMITS_KEY, commits)
   }
 
-  getCommits(): ListLogLine[] {
-    return this.context.globalState.get<ListLogLine[]>(StorageService.COMMITS_KEY) || []
+  updateCommitFiles(commitHash: string, files: Array<{ status: string, path: string }>) {
+    const commits = this.getCommits()
+    const commit = commits.find(c => c.hash === commitHash)
+    if (commit) {
+      commit.files = files
+      this.saveCommits(commits)
+    }
+  }
+
+  getCommits(): Commit[] {
+    return this.context.globalState.get<Commit[]>(StorageService.COMMITS_KEY) || []
+  }
+
+  getCommit(hash: string): Commit | undefined {
+    const commits = this.getCommits()
+    return commits.find(commit => commit.hash === hash)
   }
 
   clearCommits() {

src/storage.ts

@@ -1,27 +1,30 @@
 import * as vscode from 'vscode'
-import { GitService } from '../../git'
-import { CommitNode } from './CommitNode'
+import { CommitNode } from './entity/CommitNode'
 import { FileTreeProvider } from './FileTreeProvider'
 import type { CommitDetails } from './types'
+import { StorageService } from '@/storage'
+import { GitService } from '@/git'
 
-export class GitChangesProvider implements vscode.TreeDataProvider<CommitNode> {
+export class DiffProvider implements vscode.TreeDataProvider<CommitNode> {
   private _onDidChangeTreeData: vscode.EventEmitter<CommitNode | undefined | null | void> = new vscode.EventEmitter<CommitNode | undefined | null | void>()
   readonly onDidChangeTreeData: vscode.Event<CommitNode | undefined | null | void> = this._onDidChangeTreeData.event
   private gitService: GitService
+  private storageService: StorageService
   private fileTreeProvider: FileTreeProvider
   private selectedCommitHash?: string
-  private static instance: GitChangesProvider
+  private static instance: DiffProvider
 
   private constructor() {
     this.gitService = new GitService()
-    this.fileTreeProvider = new FileTreeProvider(this.gitService)
+    this.storageService = StorageService.getInstance()
+    this.fileTreeProvider = new FileTreeProvider(this.gitService, this.storageService)
   }
 
-  static getInstance(): GitChangesProvider {
-    if (!GitChangesProvider.instance) {
-      GitChangesProvider.instance = new GitChangesProvider()
+  static getInstance(): DiffProvider {
+    if (!DiffProvider.instance) {
+      DiffProvider.instance = new DiffProvider()
     }
-    return GitChangesProvider.instance
+    return DiffProvider.instance
   }
 
   refresh(commitHash?: string): void {
@@ -35,19 +38,33 @@ export class GitChangesProvider implements vscode.TreeDataProvider<CommitNode> {
 
   private async getCommitByHash(hash?: string): Promise<CommitDetails | null> {
     try {
-      const history = await this.gitService.getHistory()
-      if (history.all.length === 0) {
-        return null
+      if (!hash) {
+        throw new Error('Commit hash is required')
       }
 
-      const commit = history.all.find(c => c.hash === hash) || history.all[0]
-      return {
-        hash: commit.hash,
-        authorName: commit.author_name,
-        authorEmail: commit.author_email,
-        date: commit.date,
-        stats: commit.stats,
+      // First try to get from cache
+      let commit = this.storageService.getCommit(hash)
+
+      if (!commit) {
+        // Only fetch all commits if not found in cache
+        const history = await this.gitService.getHistory()
+        const historyCommit = history.all.find(c => c.hash === hash)
+        if (!historyCommit) {
+          return null
+        }
+
+        commit = {
+          hash: historyCommit.hash,
+          authorName: historyCommit.author_name,
+          authorEmail: historyCommit.author_email,
+          date: historyCommit.date,
+          message: historyCommit.message,
+          body: historyCommit.body,
+          stats: historyCommit.stats,
+        }
       }
+
+      return commit
     }
     catch (error) {
       console.error('Error getting commit details:', error)
@@ -56,17 +73,15 @@ export class GitChangesProvider implements vscode.TreeDataProvider<CommitNode> {
   }
 
   async getChildren(element?: CommitNode): Promise<CommitNode[]> {
-    if (!element) {
+    if (!element && this.selectedCommitHash) {
       const commitDetails = await this.getCommitByHash(this.selectedCommitHash)
 
       if (!commitDetails) {
         return []
       }
 
-      // Refresh the file tree provider with current commit hash
       this.fileTreeProvider.refresh(commitDetails.hash)
 
-      // Get changed files from FileTreeProvider
       const changedFiles = await this.fileTreeProvider.getChildren()
 
       return [
@@ -97,10 +112,12 @@ export class GitChangesProvider implements vscode.TreeDataProvider<CommitNode> {
         ),
       ]
     }
-    else if (element.children) {
-      return element.children as CommitNode[]
-    }
 
-    return []
+    return element?.children as CommitNode[] || []
+  }
+
+  // Getter for selectedCommitHash
+  public getSelectedCommitHash(): string | undefined {
+    return this.selectedCommitHash
   }
 }