feat(git): Refactored path normalization logic

Added a new GitApi class to encapsulate interactions with the VSCode Git extension API, enhancing the retrieval of Git path and environment variables. Updated execBase to utilize the new GitApi for executing Git commands. Refactored path normalization logic in toSimplePath to handle Windows disk drive letters correctly.

Author: jackiotyu

src/core/bootstrap.ts

@@ -24,6 +24,7 @@ import { worktreeEventRegister } from '@/core/event/git';
 import { Config } from '@/core/config/setting';
 import { Commands, RefreshCacheType } from '@/constants';
 import { updateWorkspaceListCache, updateWorktreeCache, updateRecentItems } from '@/core/util/cache';
+import { gitApi } from '@/core/git/scmGit';
 
 const setupCacheEvents = (context: vscode.ExtensionContext) => {
     const updateWorktreeCacheHandler = updateWorktreeCacheEvent.event((repoPath) => {
@@ -96,6 +97,7 @@ const setupState = (context: vscode.ExtensionContext) => {
 
 const registerAllSubscriptions = (context: vscode.ExtensionContext) => {
     context.subscriptions.push(
+        gitApi,
         vscode.window.registerFileDecorationProvider(new WorktreeDecorator()),
         folderRoot,
         logger,

src/core/git/exec-base.ts

@@ -1,57 +1,22 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import * as vscode from 'vscode';
 import * as cp from 'child_process';
-import type { GitExtension, API as ScmGitApi } from '@/@types/vscode.git';
 import { Config } from '@/core/config/setting';
 import { withResolvers } from '@/core/util/promise';
 import logger from '@/core/log/logger';
 import treeKill from 'tree-kill';
+import { gitApi } from '@/core/git/scmGit';
 
 export interface ExecResult {
     stdout: string;
     stderr: string;
     code: number | null;
 }
 
-let scmGitApi: ScmGitApi | undefined;
-
-const getScmGitApiCore = async (): Promise<ScmGitApi | undefined> => {
-    try {
-        const extension = vscode.extensions.getExtension<GitExtension>('vscode.git');
-        if (!extension) return undefined;
-        const gitExtension = extension.isActive ? extension.exports : await extension.activate();
-        return gitExtension?.getAPI(1);
-    } catch {
-        return undefined;
-    }
-};
-
-/**
- * Get the Git executable path used by VSCode Git extension
- * VSCode Git extension uses git.path configuration, or automatically finds system Git if not set
- */
-const getGitPath = async (): Promise<string> => {
-    try {
-        // Ensure Git extension is activated (if needed)
-        if (!scmGitApi) {
-            scmGitApi = await getScmGitApiCore();
-        }
-        if (!scmGitApi) return 'git';
-        return scmGitApi.git.path;
-    } catch (error) {
-        logger.error(`Failed to get Git path: ${error}`);
-        // Fallback to default value on error
-        return 'git';
-    }
-};
-
-const getGitEnv = (): Record<string, string> => {
-    if (!scmGitApi) return {};
-    return (scmGitApi.git as any).env || {};
-};
-
 export const execBase = async (cwd: string, args?: string[], token?: vscode.CancellationToken): Promise<ExecResult> => {
-    const gitPath = await getGitPath();
+    await gitApi.getAPI();
+    const gitPath = gitApi.gitPath;
+    const gitEnv = gitApi.gitEnv;
 
     const { resolve, reject, promise } = withResolvers<ExecResult>();
 
@@ -70,7 +35,7 @@ export const execBase = async (cwd: string, args?: string[], token?: vscode.Canc
         cwd,
         env: {
             ...env,
-            ...getGitEnv(),
+            ...gitEnv,
             GCM_INTERACTIVE: 'NEVER',
             GCM_PRESERVE_CREDS: 'TRUE',
             LC_ALL: 'en_US.UTF-8',

src/core/git/scmGit.ts

@@ -0,0 +1,57 @@
+import * as vscode from 'vscode';
+import type { GitExtension, API as ScmGitApi } from '@/@types/vscode.git';
+import logger from '@/core/log/logger';
+
+class GitApi implements vscode.Disposable {
+    private _api: ScmGitApi | undefined;
+    private _gitPath: string = 'git';
+    private _gitEnv: Record<string, string> = {};
+    private _disposed: boolean = false;
+    constructor() {
+        this._api = undefined;
+    }
+
+    get gitPath(): string {
+        return this._gitPath;
+    }
+
+    get gitEnv(): Record<string, string> {
+        return this._gitEnv;
+    }
+
+    async getAPI(): Promise<ScmGitApi | undefined> {
+        try {
+            if (this._disposed) return undefined;
+            // Check if the API is already cached
+            if (this._api) return this._api;
+
+            const extension = vscode.extensions.getExtension<GitExtension>('vscode.git');
+            if (!extension) return undefined;
+            const gitExtension = extension.isActive ? extension.exports : await extension.activate();
+
+            // Cache the API and Git path/env
+            this.cacheAPI(gitExtension?.getAPI(1));
+
+            return this._api;
+        } catch (error) {
+            logger.error(`Failed to get SCM Git API: ${error}`);
+            this.cacheAPI(undefined);
+            return undefined;
+        }
+    }
+
+    private cacheAPI(api?: ScmGitApi): void {
+        this._api = api;
+        this._gitPath = api?.git.path || 'git';
+        this._gitEnv = (api?.git as any).env || {};
+    }
+
+    dispose(): void {
+        this._api = undefined;
+        this._disposed = true;
+    }
+}
+
+const gitApi = new GitApi();
+
+export { gitApi };

src/core/util/path.ts

@@ -1,8 +1,18 @@
 import path from 'path';
 
 function toSimplePath(path: string) {
-    const normalized = path.replace(/\\/g, '/');
-    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+    // Just handle the disk drive letter on Windows, keep other platforms unchanged
+    if (process.platform === 'win32') {
+        const normalized = path.replace(/\\/g, '/');
+        const diskPattern = /^[a-zA-Z]:/;
+        const match = normalized.match(diskPattern);
+        if (match) {
+            return match[0].toLowerCase() + normalized.slice(match[0].length);
+        } else {
+            return normalized;
+        }
+    }
+    return path;
 }
 
 function comparePath(path1: string = '', path2: string = '') {