agentic-qe 3.15.9 → 3.15.10

package/dist/shared/git/git-analyzer.js

@@ -8,9 +8,9 @@
  * - Code age calculation
  * - Bug history from commit messages
  */
-import { execFileSync } from 'child_process';
 import * as path from 'path';
 import { assertSafeGitRef } from './ref-validation.js';
+import { GitTimeoutError, runGit } from './git-process.js';
 /**
  * Sanitize a string for safe use in git arguments
  * Removes shell metacharacters that could enable injection
@@ -19,13 +19,22 @@ function sanitizeGitArg(arg) {
     // Remove characters that could be used for command injection
     return arg.replace(/[;&|`$(){}[\]<>\\'"!\n\r]/g, '');
 }
+/** A git `%at` epoch-seconds line as a Date, or null when it is not one. */
+function timestampToDate(line) {
+    const timestamp = parseInt(line ?? '', 10);
+    return isNaN(timestamp) ? null : new Date(timestamp * 1000);
+}
 const DEFAULT_CONFIG = {
     repoRoot: process.cwd(),
     maxCommits: 100,
     bugKeywords: ['fix', 'bug', 'patch', 'issue', 'error', 'defect', 'problem'],
     enableCache: true,
     cacheTtl: 5 * 60 * 1000, // 5 minutes
+    gitTimeoutMs: 30 * 1000,
+    fileTimeoutMs: 60 * 1000,
 };
+/** Room for `git blame --line-porcelain` on large files (execFileSync allowed 1 MiB). */
+const GIT_MAX_BUFFER = 64 * 1024 * 1024;
 /**
  * Git Analyzer for defect prediction metrics
  */
@@ -33,6 +42,11 @@ export class GitAnalyzer {
     config;
     cache = new Map();
     isGitRepo = null;
+    /** After a rev-parse timeout, when to ask git again (until then: "timeout"). */
+    repoRetryAt = 0;
+    timedOutFiles = new Set();
+    /** Files inside withFileDeadline() and when their git time runs out. */
+    fileDeadlines = new Map();
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
@@ -40,19 +54,30 @@ export class GitAnalyzer {
      * Check if current directory is a git repository
      */
     async isGitRepository() {
-        if (this.isGitRepo !== null)
-            return this.isGitRepo;
+        return (await this.repoState()) === true;
+    }
+    /**
+     * True when git timed out while analysing `filePath` since the last call, so
+     * the analysis returned its "git unavailable" default rather than a result.
+     */
+    consumeTimeout(filePath) {
+        return this.timedOutFiles.delete(filePath);
+    }
+    /**
+     * Run `work`, during which every analysis of `filePath` also stops at one
+     * shared `fileTimeoutMs` deadline. One file's analyses then wait for git at
+     * most that long together, rather than `gitTimeoutMs` each (#1115).
+     */
+    async withFileDeadline(filePath, work) {
+        if (this.fileDeadlines.has(filePath))
+            return work();
+        this.fileDeadlines.set(filePath, Date.now() + this.config.fileTimeoutMs);
         try {
-            execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
-                cwd: this.config.repoRoot,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            this.isGitRepo = true;
+            return await work();
         }
-        catch {
-            this.isGitRepo = false;
+        finally {
+            this.fileDeadlines.delete(filePath);
         }
-        return this.isGitRepo;
     }
     /**
      * Get file change frequency (commits in last 90 days / 3)
@@ -63,28 +88,15 @@ export class GitAnalyzer {
         const cached = this.getFromCache(cacheKey);
         if (cached !== undefined)
             return cached;
-        if (!(await this.isGitRepository())) {
-            return 0.4; // Default when not in git repo
-        }
-        try {
-            const relativePath = this.getRelativePath(filePath);
+        return this.analyze(filePath, 0.4, async (git, relativePath) => {
             // Literal pathspecs preserve route filenames such as app/[id].tsx.
-            // execFileSync passes arguments directly without shell interpretation.
-            const output = execFileSync('git', [
-                '--literal-pathspecs', 'log', '--oneline', '--since=90 days ago', '--', relativePath
-            ], {
-                cwd: this.config.repoRoot,
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
+            // Arguments go to git directly, without shell interpretation.
+            const output = (await git.text(['--literal-pathspecs', 'log', '--oneline', '--since=90 days ago', '--', relativePath])).trim();
             const commits = output ? output.split('\n').length : 0;
             const frequency = Math.min(1, commits / 30); // Normalize: 30+ commits in 90 days = 1.0
             this.setCache(cacheKey, frequency);
             return frequency;
-        }
-        catch {
-            return 0.4; // Default on error
-        }
+        });
     }
     /**
      * Get developer experience score for a file based on git blame
@@ -95,42 +107,24 @@ export class GitAnalyzer {
         const cached = this.getFromCache(cacheKey);
         if (cached !== undefined)
             return cached;
-        if (!(await this.isGitRepository())) {
-            return 0.5; // Default when not in git repo
-        }
-        try {
-            const relativePath = this.getRelativePath(filePath);
-            // Get blame info using execFileSync with argument array
-            const blameOutput = execFileSync('git', [
-                '--literal-pathspecs', 'blame', '--line-porcelain', '--', relativePath
-            ], {
-                cwd: this.config.repoRoot,
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
+        return this.analyze(filePath, 0.5, async (git, relativePath) => {
+            const blameOutput = await git.text(['--literal-pathspecs', 'blame', '--line-porcelain', '--', relativePath]);
             // Parse blame output - count authors manually instead of piping through shell
             const authorCounts = new Map();
-            const lines = blameOutput.split('\n');
-            for (const line of lines) {
+            for (const line of blameOutput.split('\n')) {
                 if (line.startsWith('author ')) {
                     const author = line.substring(7).trim();
                     authorCounts.set(author, (authorCounts.get(author) || 0) + 1);
                 }
             }
             const totalLines = Array.from(authorCounts.values()).reduce((a, b) => a + b, 0);
-            const uniqueAuthors = authorCounts.size;
-            // Score based on code ownership concentration
-            // High concentration by few authors = more experience = lower risk
             if (totalLines === 0)
                 return 0.5;
             // More authors touching the file = higher risk (less concentrated ownership)
-            const riskScore = Math.min(1, uniqueAuthors / 10);
+            const riskScore = Math.min(1, authorCounts.size / 10);
             this.setCache(cacheKey, riskScore);
             return riskScore;
-        }
-        catch {
-            return 0.5; // Default on error
-        }
+        });
     }
     /**
      * Get code age - how old is the file
@@ -141,49 +135,16 @@ export class GitAnalyzer {
         const cached = this.getFromCache(cacheKey);
         if (cached !== undefined)
             return cached;
-        if (!(await this.isGitRepository())) {
-            return 0.4; // Default when not in git repo
-        }
-        try {
-            const relativePath = this.getRelativePath(filePath);
-            // Get first commit date using execFileSync with argument array
-            let firstCommitTimestamp = NaN;
-            try {
-                const firstCommitOutput = execFileSync('git', [
-                    '--literal-pathspecs', 'log', '--format=%at', '--follow', '--diff-filter=A', '--', relativePath
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
-                // Get last line (oldest commit)
-                const lines = firstCommitOutput.split('\n').filter(Boolean);
-                if (lines.length > 0) {
-                    firstCommitTimestamp = parseInt(lines[lines.length - 1], 10);
-                }
-            }
-            catch {
-                // File may not have been added yet
-            }
-            // Get last commit date using execFileSync with argument array
-            let lastCommitTimestamp = NaN;
-            try {
-                const lastCommitOutput = execFileSync('git', [
-                    '--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
-                lastCommitTimestamp = parseInt(lastCommitOutput, 10);
-            }
-            catch {
-                // File may not be in git
-            }
-            const now = Date.now() / 1000;
+        return this.analyze(filePath, 0.4, async (git, relativePath) => {
+            // First commit: the last line (oldest) of the commits that added the file
+            const added = await git.lines(['--literal-pathspecs', 'log', '--format=%at', '--follow', '--diff-filter=A', '--', relativePath]);
+            const firstCommitTimestamp = parseInt(added[added.length - 1] ?? '', 10);
+            const [lastLine] = await git.lines(['--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath]);
+            const lastCommitTimestamp = parseInt(lastLine ?? '', 10);
             if (isNaN(lastCommitTimestamp)) {
                 return 0.4; // File not in git
             }
+            const now = Date.now() / 1000;
             const daysSinceLastChange = (now - lastCommitTimestamp) / (60 * 60 * 24);
             const totalAgeDays = isNaN(firstCommitTimestamp)
                 ? daysSinceLastChange
@@ -200,10 +161,7 @@ export class GitAnalyzer {
             }
             this.setCache(cacheKey, riskScore);
             return riskScore;
-        }
-        catch {
-            return 0.4; // Default on error
-        }
+        });
     }
     /**
      * Get bug history - how many bug fix commits have touched this file
@@ -214,48 +172,12 @@ export class GitAnalyzer {
         const cached = this.getFromCache(cacheKey);
         if (cached !== undefined)
             return cached;
-        if (!(await this.isGitRepository())) {
-            return 0.2; // Default when not in git repo
-        }
-        try {
-            const relativePath = this.getRelativePath(filePath);
-            // Search for each keyword separately and count unique commits
-            // This avoids shell injection from keywords config
-            let bugCommits = 0;
-            const seenCommits = new Set();
-            for (const keyword of this.config.bugKeywords) {
-                const sanitizedKeyword = sanitizeGitArg(keyword);
-                try {
-                    const output = execFileSync('git', [
-                        '--literal-pathspecs', 'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
-                    ], {
-                        cwd: this.config.repoRoot,
-                        encoding: 'utf-8',
-                        stdio: ['pipe', 'pipe', 'pipe'],
-                    }).trim();
-                    if (output) {
-                        // Track unique commit hashes to avoid double-counting
-                        const lines = output.split('\n');
-                        for (const line of lines) {
-                            const hash = line.split(' ')[0];
-                            if (hash && !seenCommits.has(hash)) {
-                                seenCommits.add(hash);
-                                bugCommits++;
-                            }
-                        }
-                    }
-                }
-                catch {
-                    // Keyword search failed, continue with next
-                }
-            }
+        return this.analyze(filePath, 0.2, async (git, relativePath) => {
+            const bugCommits = await this.countBugFixCommits(git, relativePath);
             const riskScore = Math.min(1, bugCommits / 10); // Normalize: 10+ bug fixes = 1.0
             this.setCache(cacheKey, riskScore);
             return riskScore;
-        }
-        catch {
-            return 0.2; // Default on error
-        }
+        });
     }
     /**
      * Get comprehensive file history analysis
@@ -265,87 +187,15 @@ export class GitAnalyzer {
         const cached = this.getFromCache(cacheKey);
         if (cached)
             return cached;
-        if (!(await this.isGitRepository())) {
-            return this.getDefaultFileHistory(filePath);
-        }
-        try {
-            const relativePath = this.getRelativePath(filePath);
-            // Get commit count using execFileSync with argument array
-            let totalCommits = 0;
-            try {
-                const commitCountOutput = execFileSync('git', [
-                    '--literal-pathspecs', 'log', '--oneline', '--', relativePath
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
-                totalCommits = commitCountOutput ? commitCountOutput.split('\n').length : 0;
-            }
-            catch {
-                // File may not be in git
-            }
-            // Get unique authors - parse output manually instead of piping through sort/wc
-            let uniqueAuthors = 0;
-            try {
-                const authorsOutput = execFileSync('git', [
-                    '--literal-pathspecs', 'log', '--format=%ae', '--', relativePath
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
-                if (authorsOutput) {
-                    const authorSet = new Set(authorsOutput.split('\n').filter(Boolean));
-                    uniqueAuthors = authorSet.size;
-                }
-            }
-            catch {
-                // File may not be in git
-            }
-            // Get first commit date
-            let firstCommit = null;
-            try {
-                const firstCommitOutput = execFileSync('git', [
-                    '--literal-pathspecs', 'log', '--format=%at', '--follow', '--', relativePath
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
-                if (firstCommitOutput) {
-                    const lines = firstCommitOutput.split('\n').filter(Boolean);
-                    if (lines.length > 0) {
-                        const timestamp = parseInt(lines[lines.length - 1], 10);
-                        if (!isNaN(timestamp)) {
-                            firstCommit = new Date(timestamp * 1000);
-                        }
-                    }
-                }
-            }
-            catch {
-                // File may not be in git
-            }
-            // Get last commit date
-            let lastCommit = null;
-            try {
-                const lastCommitOutput = execFileSync('git', [
-                    '--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
-                if (lastCommitOutput) {
-                    const timestamp = parseInt(lastCommitOutput, 10);
-                    if (!isNaN(timestamp)) {
-                        lastCommit = new Date(timestamp * 1000);
-                    }
-                }
-            }
-            catch {
-                // File may not be in git
-            }
+        return this.analyze(filePath, this.getDefaultFileHistory(filePath), async (git, relativePath) => {
+            // Each query yields no lines when the file is not in git
+            const totalCommits = (await git.lines(['--literal-pathspecs', 'log', '--oneline', '--', relativePath])).length;
+            // Parse authors here instead of piping through sort/wc
+            const uniqueAuthors = new Set(await git.lines(['--literal-pathspecs', 'log', '--format=%ae', '--', relativePath])).size;
+            const followed = await git.lines(['--literal-pathspecs', 'log', '--format=%at', '--follow', '--', relativePath]);
+            const firstCommit = timestampToDate(followed[followed.length - 1]);
+            const [lastLine] = await git.lines(['--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath]);
+            const lastCommit = timestampToDate(lastLine);
             // Calculate change frequency (commits per month)
             let changeFrequency = 0;
             if (firstCommit && lastCommit && totalCommits > 0) {
@@ -356,34 +206,6 @@ export class GitAnalyzer {
             const isRecentlyModified = lastCommit
                 ? Date.now() - lastCommit.getTime() < 7 * 24 * 60 * 60 * 1000
                 : false;
-            // Count bug fix commits - search each keyword separately to avoid injection
-            let bugFixCommits = 0;
-            const seenBugCommits = new Set();
-            for (const keyword of this.config.bugKeywords) {
-                const sanitizedKeyword = sanitizeGitArg(keyword);
-                try {
-                    const bugFixOutput = execFileSync('git', [
-                        '--literal-pathspecs', 'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
-                    ], {
-                        cwd: this.config.repoRoot,
-                        encoding: 'utf-8',
-                        stdio: ['pipe', 'pipe', 'pipe'],
-                    }).trim();
-                    if (bugFixOutput) {
-                        const lines = bugFixOutput.split('\n');
-                        for (const line of lines) {
-                            const hash = line.split(' ')[0];
-                            if (hash && !seenBugCommits.has(hash)) {
-                                seenBugCommits.add(hash);
-                                bugFixCommits++;
-                            }
-                        }
-                    }
-                }
-                catch {
-                    // Keyword search failed, continue with next
-                }
-            }
             const history = {
                 filePath: relativePath,
                 totalCommits,
@@ -392,44 +214,25 @@ export class GitAnalyzer {
                 lastCommit,
                 changeFrequency,
                 isRecentlyModified,
-                bugFixCommits,
+                bugFixCommits: await this.countBugFixCommits(git, relativePath),
             };
             this.setCache(cacheKey, history);
             return history;
-        }
-        catch {
-            return this.getDefaultFileHistory(filePath);
-        }
+        });
     }
     /**
      * Get files changed since a specific date
      * @param since - Date to check changes from (default: 24 hours ago)
      * @returns Array of changed file paths relative to repo root
+     * @throws GitTimeoutError when git does not answer within `gitTimeoutMs`
      */
     async getChangedFiles(since) {
         if (!(await this.isGitRepository())) {
             return [];
         }
-        try {
-            const sinceDate = since || new Date(Date.now() - 24 * 60 * 60 * 1000);
-            const sinceStr = sinceDate.toISOString();
-            // Get files changed since the date using execFileSync with argument array
-            const output = execFileSync('git', [
-                'log', `--since=${sinceStr}`, '--name-only', '-z', '--format='
-            ], {
-                cwd: this.config.repoRoot,
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            if (!output)
-                return [];
-            // NUL records preserve whitespace, newlines and Git-quoted Unicode paths.
-            const files = output.split('\0').filter(Boolean);
-            return Array.from(new Set(files));
-        }
-        catch {
-            return [];
-        }
+        const sinceDate = since || new Date(Date.now() - 24 * 60 * 60 * 1000);
+        const files = await this.query().paths(['log', `--since=${sinceDate.toISOString()}`, '--name-only', '-z', '--format=']);
+        return Array.from(new Set(files));
     }
     /**
      * Get files changed in a specific commit
@@ -438,78 +241,115 @@ export class GitAnalyzer {
      * @throws Error when `commitHash` is option-shaped (starts with "-") or otherwise
      *   not a safe revision argument; git would otherwise parse it as an option
      *   (e.g. `--output=<path>` writes an arbitrary file). See issue #960.
+     * @throws GitTimeoutError when git does not answer within `gitTimeoutMs`
      */
     async getCommitFiles(commitHash = 'HEAD') {
-        // Validate before touching git: execFileSync has no shell, so stripping
+        // Validate before touching git: there is no shell, so stripping
         // metacharacters does not help, but a leading "-" is still parsed as an option.
         assertSafeGitRef(commitHash, 'commit hash');
         if (!(await this.isGitRepository())) {
             return [];
         }
-        try {
-            const output = execFileSync('git', [
-                'diff-tree', '--root', '--no-commit-id', '--name-only', '-z', '-r', commitHash
-            ], {
-                cwd: this.config.repoRoot,
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            if (!output)
-                return [];
-            return output.split('\0').filter(Boolean);
-        }
-        catch {
-            return [];
-        }
+        return this.query().paths(['diff-tree', '--root', '--no-commit-id', '--name-only', '-z', '-r', commitHash]);
     }
     /**
      * Get files with uncommitted changes (staged + unstaged)
      * @returns Array of modified file paths relative to repo root
+     * @throws GitTimeoutError when git does not answer within `gitTimeoutMs`
      */
     async getUncommittedFiles() {
         if (!(await this.isGitRepository())) {
             return [];
         }
+        // `diff HEAD` fails before the first commit; `--cached` still lists staged files.
+        const git = this.query();
+        const unstaged = await git.paths(['diff', '--name-only', '-z', 'HEAD']);
+        const staged = await git.paths(['diff', '--name-only', '-z', '--cached']);
+        return Array.from(new Set([...unstaged, ...staged]));
+    }
+    /**
+     * Count commits whose message matches any bug keyword, in one `git log`
+     * (repeated --grep patterns are OR-ed). Keywords are sanitized arguments and
+     * never reach a shell.
+     */
+    async countBugFixCommits(git, relativePath) {
+        if (this.config.bugKeywords.length === 0)
+            return 0;
+        const greps = this.config.bugKeywords.flatMap((keyword) => ['--grep', sanitizeGitArg(keyword)]);
+        const lines = await git.lines(['--literal-pathspecs', 'log', '--oneline', '-i', ...greps, '--', relativePath]);
+        return new Set(lines.map((line) => line.split(' ')[0]).filter(Boolean)).size;
+    }
+    /**
+     * Run one file's analysis with every git call sharing one `gitTimeoutMs`
+     * deadline (#1115). When git is unavailable or times out, the analysis
+     * returns its default, which callers treat as "no git data", and a timeout
+     * is recorded for consumeTimeout(). A timeout never yields a measured 0.
+     */
+    async analyze(filePath, fallback, work) {
+        const repo = await this.repoState();
+        if (repo !== true) {
+            if (repo === 'timeout')
+                this.timedOutFiles.add(filePath);
+            return fallback;
+        }
         try {
-            const files = [];
-            // Get unstaged changes using execFileSync with argument array
-            try {
-                const unstagedOutput = execFileSync('git', [
-                    'diff', '--name-only', '-z', 'HEAD'
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
-                if (unstagedOutput) {
-                    files.push(...unstagedOutput.split('\0').filter(Boolean));
-                }
-            }
-            catch {
-                // May fail if no HEAD commit exists
+            return await work(this.query(this.fileDeadlines.get(filePath)), this.getRelativePath(filePath));
+        }
+        catch (error) {
+            if (error instanceof GitTimeoutError)
+                this.timedOutFiles.add(filePath);
+            return fallback;
+        }
+    }
+    /**
+     * Whether the repo root is a git work tree. A timeout is not an answer: it
+     * is remembered for `cacheTtl` so a hung git is not waited on for every
+     * file, and then git is asked again.
+     */
+    async repoState() {
+        if (this.isGitRepo !== null)
+            return this.isGitRepo;
+        if (Date.now() < this.repoRetryAt)
+            return 'timeout';
+        try {
+            await this.query().text(['rev-parse', '--is-inside-work-tree']);
+            this.isGitRepo = true;
+        }
+        catch (error) {
+            if (error instanceof GitTimeoutError) {
+                this.repoRetryAt = Date.now() + this.config.cacheTtl;
+                return 'timeout';
             }
-            // Get staged changes using execFileSync with argument array
+            this.isGitRepo = false;
+        }
+        return this.isGitRepo;
+    }
+    /**
+     * Git queries in the repo root that share a deadline of `gitTimeoutMs` from
+     * now, or `fileDeadline` when that comes first. Git runs asynchronously in its own process group, so a slow or hung
+     * git (a network filesystem, a credential prompt) neither blocks the MCP
+     * server's event loop nor outlives its deadline (#1115).
+     */
+    query(fileDeadline = Infinity) {
+        const deadline = Math.min(Date.now() + this.config.gitTimeoutMs, fileDeadline);
+        const text = (args) => runGit(args, {
+            cwd: this.config.repoRoot, timeout: deadline - Date.now(), maxBuffer: GIT_MAX_BUFFER,
+        });
+        const orNothing = async (args, separator) => {
             try {
-                const stagedOutput = execFileSync('git', [
-                    'diff', '--name-only', '-z', '--cached'
-                ], {
-                    cwd: this.config.repoRoot,
-                    encoding: 'utf-8',
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
-                if (stagedOutput) {
-                    files.push(...stagedOutput.split('\0').filter(Boolean));
-                }
+                return (await text(args)).split(separator);
             }
-            catch {
-                // May fail if no commits exist
+            catch (error) {
+                if (error instanceof GitTimeoutError)
+                    throw error;
+                return [];
             }
-            // Deduplicate
-            return Array.from(new Set(files));
-        }
-        catch {
-            return [];
-        }
+        };
+        return {
+            text,
+            lines: async (args) => (await orNothing(args, '\n')).map((line) => line.trim()).filter(Boolean),
+            paths: async (args) => (await orNothing(args, '\0')).filter(Boolean),
+        };
     }
     /**
      * Get relative path from repo root

package/dist/shared/git/git-process.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Run git without blocking the event loop (#1115).
+ *
+ * Git runs in its own process group, so a timeout stops it together with any
+ * wrapper, credential helper or fsmonitor child it started.
+ */
+/** Git did not finish before its deadline; its result is unknown, not empty. */
+export declare class GitTimeoutError extends Error {
+    constructor(args: readonly string[], timeoutMs: number);
+}
+export interface RunGitOptions {
+    cwd: string;
+    /** Milliseconds before the git process group is stopped. */
+    timeout: number;
+    maxBuffer?: number;
+}
+/**
+ * Resolve with git's stdout. Rejects with GitTimeoutError when the deadline
+ * passes, and with a plain Error when git cannot start or exits non-zero.
+ */
+export declare function runGit(args: readonly string[], options: RunGitOptions): Promise<string>;
+//# sourceMappingURL=git-process.d.ts.map