fix: respect the VS Code "git.path" setting

The extension always spawned "git" from PATH, so it failed with
"spawn git ENOENT" when git was not globally installed (e.g. portable
or MSYS2 installs configured via the built-in "git.path" setting).

- Add a central git-binary module holding the resolved git executable,
  used by every spawn site (git-service, repo-discovery, content-provider).
- Resolve the path on activation: the configured "git.path" (string or
  first existing array entry) takes precedence, falling back to the path
  the built-in git extension resolved, then to PATH.
- Re-resolve when "git.path" changes at runtime.

Fixes #18

Author: the0807

src/extension.ts

@@ -1,5 +1,7 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
+import { existsSync } from 'fs';
+import { setGitBinaryPath } from './git/git-binary';
 import { MainPanel } from './panels/MainPanel';
 import { GitContentProvider } from './services/git-content-provider';
 import { GitService } from './git/git-service';
@@ -12,6 +14,20 @@ import { WorktreesViewProvider } from './views/worktrees-view';
 import { StatusBarManager } from './views/status-bar';
 import { RepoDiscoveryService } from './services/repo-discovery';
 
+/**
+ * Resolve the `git.path` setting to an existing executable. The setting may be
+ * a single path or an array of candidates (VS Code uses the first that exists).
+ * Returns undefined when nothing is configured or none of the candidates exist.
+ */
+function resolveConfiguredGitPath(): string | undefined {
+  const cfg = vscode.workspace.getConfiguration('git').get<string | string[] | null>('path');
+  const candidates = Array.isArray(cfg) ? cfg : cfg ? [cfg] : [];
+  for (const c of candidates) {
+    if (c && existsSync(c)) return c;
+  }
+  return undefined;
+}
+
 export function activate(context: vscode.ExtensionContext) {
   // Status bar is always visible regardless of workspace state
   const statusBar = new StatusBarManager();
@@ -48,23 +64,45 @@ export function activate(context: vscode.ExtensionContext) {
   }
 
   let activeRepoPath = workspaceFolder.uri.fsPath;
+
+  // Resolve the git executable so the extension works when git is not on PATH
+  // (e.g. portable/MSYS2 installs configured via `git.path`). The configured
+  // path takes precedence; otherwise we fall back to the path the built-in git
+  // extension resolved (set below once its API is available), then to PATH. #18
+  let apiGitPath: string | undefined;
+  const applyGitPath = () => setGitBinaryPath(resolveConfiguredGitPath() ?? apiGitPath);
+  applyGitPath();
+
   let activeGitService = new GitService(activeRepoPath);
 
   // Inject VS Code's built-in git extension askpass env so authentication prompts work
   const builtinGit = vscode.extensions.getExtension('vscode.git');
   if (builtinGit) {
     const waitForGit = builtinGit.isActive ? Promise.resolve(builtinGit.exports) : Promise.resolve(builtinGit.activate());
-    waitForGit.then((ext: { getAPI(version: number): { git: { env?: Record<string, string> } } }) => {
+    waitForGit.then((ext: { getAPI(version: number): { git: { env?: Record<string, string>; path?: string } } }) => {
       try {
-        const env = ext.getAPI(1)?.git?.env;
-        if (env) {
-          activeGitService.setExtraEnv(env);
-          MainPanel.setExtraEnv(env);
+        const git = ext.getAPI(1)?.git;
+        if (git?.env) {
+          activeGitService.setExtraEnv(git.env);
+          MainPanel.setExtraEnv(git.env);
+        }
+        // The built-in extension's resolved path already honors `git.path`; adopt
+        // it as the fallback for when the user hasn't set a valid `git.path`.
+        if (typeof git?.path === 'string' && git.path) {
+          apiGitPath = git.path;
+          applyGitPath();
         }
       } catch { /* built-in git extension API unavailable */ }
     }).catch(() => {});
   }
 
+  // Re-resolve when the user changes `git.path` at runtime.
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeConfiguration(e => {
+      if (e.affectsConfiguration('git.path')) applyGitPath();
+    }),
+  );
+
   // --- Content Provider for diff URIs ---
   const contentProvider = new GitContentProvider();
   context.subscriptions.push(

src/git/__tests__/git-binary.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { getGitBinaryPath, setGitBinaryPath } from '../git-binary';
+
+describe('git-binary', () => {
+  afterEach(() => setGitBinaryPath('git')); // reset shared module state
+
+  it("defaults to 'git'", () => {
+    expect(getGitBinaryPath()).toBe('git');
+  });
+
+  it('stores an explicit path', () => {
+    setGitBinaryPath('/usr/local/bin/git');
+    expect(getGitBinaryPath()).toBe('/usr/local/bin/git');
+  });
+
+  it('keeps a Windows-style path verbatim', () => {
+    setGitBinaryPath('D:/app/msys64/mingw64/bin/git.exe');
+    expect(getGitBinaryPath()).toBe('D:/app/msys64/mingw64/bin/git.exe');
+  });
+
+  it.each([undefined, null, '', '   '])('resets to "git" for %p', (value) => {
+    setGitBinaryPath('/custom/git');
+    setGitBinaryPath(value as string | undefined | null);
+    expect(getGitBinaryPath()).toBe('git');
+  });
+});

src/git/git-binary.ts

@@ -0,0 +1,25 @@
+// Resolved path to the git executable used for every spawned git process.
+//
+// Defaults to `'git'` (looked up on PATH). When git is not on PATH — common on
+// Windows with portable/MSYS2 installs — the extension host resolves the
+// VS Code `git.path` setting (or the built-in git extension's resolved path)
+// during activation and stores it here so all spawn sites pick it up. See #18.
+//
+// This module is intentionally free of any `vscode` import so GitService and
+// the other git callers stay unit-testable. The vscode-aware resolution lives
+// in the extension entry point, which calls `setGitBinaryPath`.
+
+let gitBinaryPath = 'git';
+
+/** The git executable to spawn. */
+export function getGitBinaryPath(): string {
+  return gitBinaryPath;
+}
+
+/**
+ * Set the git executable path. A nullish or blank value resets to the default
+ * PATH lookup (`'git'`).
+ */
+export function setGitBinaryPath(p: string | undefined | null): void {
+  gitBinaryPath = p && p.trim() ? p : 'git';
+}

src/git/git-service.ts

@@ -4,6 +4,7 @@ import { writeFile, unlink } from 'fs/promises';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { bufferStream, BufferOverflowError } from '../utils/buffer-stream';
+import { getGitBinaryPath } from './git-binary';
 
 /** Default max bytes per stdout/stderr stream for a single git invocation.
  *  Picked to comfortably hold large log/diff output (e.g. `git log --all`
@@ -244,7 +245,7 @@ export class GitService {
     const maxBytes = options?.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
 
     return new Promise((resolve, reject) => {
-      const proc = spawn('git', args, {
+      const proc = spawn(getGitBinaryPath(), args, {
         cwd: this.repoPath,
         env: { ...process.env, ...this.extraEnv, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C', GIT_MERGE_AUTOEDIT: 'no', GIT_EDITOR: 'true', EDITOR: 'true' },
       });
@@ -694,7 +695,7 @@ export class GitService {
       ? ['merge-tree', '--write-tree', `--merge-base=${mergeBase}`, ours, theirs]
       : ['merge-tree', '--write-tree', ours, theirs];
     return new Promise((resolve) => {
-      const proc = spawn('git', args, {
+      const proc = spawn(getGitBinaryPath(), args, {
         cwd: this.repoPath,
         env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' },
       });
@@ -1176,7 +1177,7 @@ export class GitService {
       // that cmd.exe / sh expansion handles repo paths containing &, |, (, ),
       // ^, etc. safely without manual escaping.
       await new Promise<void>((resolve, reject) => {
-        const proc = spawn('git', ['rebase', '-i', base], {
+        const proc = spawn(getGitBinaryPath(), ['rebase', '-i', base], {
           cwd: this.repoPath,
           env: {
             ...process.env,
@@ -1854,7 +1855,7 @@ export class GitService {
     }
     const MAX_IMAGE_SIZE = 50 * 1024 * 1024; // 50MB limit
     return new Promise((resolve, reject) => {
-      const proc = spawn('git', ['show', `${ref}:${filePath}`], {
+      const proc = spawn(getGitBinaryPath(), ['show', `${ref}:${filePath}`], {
         cwd: this.repoPath,
         env: { ...process.env, ...this.extraEnv, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C', GIT_MERGE_AUTOEDIT: 'no', GIT_EDITOR: 'true', EDITOR: 'true' },
       });

src/services/git-content-provider.ts

@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import { spawn } from 'child_process';
+import { getGitBinaryPath } from '../git/git-binary';
 
 export class GitContentProvider implements vscode.TextDocumentContentProvider {
   private onDidChangeEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -21,7 +22,7 @@ export class GitContentProvider implements vscode.TextDocumentContentProvider {
     }
 
     return new Promise((resolve) => {
-      const proc = spawn('git', ['show', `${ref}:${filePath}`], {
+      const proc = spawn(getGitBinaryPath(), ['show', `${ref}:${filePath}`], {
         cwd: repoPath,
         env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' },
       });

src/services/repo-discovery.ts

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import { getGitBinaryPath } from '../git/git-binary';
 
 export type RepoType = 'root' | 'submodule' | 'nested';
 
@@ -214,7 +215,7 @@ export class RepoDiscoveryService {
 
   private static execGit(args: string[], cwd: string, timeoutMs = 15000): Promise<string> {
     return new Promise((resolve, reject) => {
-      const proc = spawn('git', args, {
+      const proc = spawn(getGitBinaryPath(), args, {
         cwd,
         env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' },
       });