@gitkraken/core-gitlens 0.1.0

package/dist/git-cli/providers/commits.js

@@ -0,0 +1,1151 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { GitCommit, GitCommitIdentity } from '../../git/models/commit.js';
+import { GitFileChange } from '../../git/models/fileChange.js';
+import { createUncommittedChangesCommit } from '../../git/utils/commit.utils.js';
+import { isRevisionRange, isSha, isUncommitted, isUncommittedStaged } from '../../git/utils/revision.utils.js';
+import { parseSearchQueryGitCommand } from '../../git/utils/search.utils.js';
+import { isUserMatch } from '../../git/utils/user.utils.js';
+import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
+import { debug, trace } from '../../utils/decorators/log.js';
+import { createDisposable } from '../../utils/disposable.js';
+import { filterMap, findLast, first, join, last, some } from '../../utils/iterable.js';
+import { getScopedLogger } from '../../utils/logger.scoped.js';
+import { isFolderGlob, normalizePath, splitPath, stripFolderGlob } from '../../utils/path.js';
+import { maybeStopWatch } from '../../utils/stopwatch.js';
+import { escapeRegex } from '../../utils/string.js';
+import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
+import { gitConfigsLog, gitConfigsLogWithFiles, GitErrors } from '../exec/git.js';
+import { getCommitsLogParser, getShaAndFilesAndStatsLogParser, getShaLogParser } from '../parsers/logParser.js';
+import { getReflogParser, parseGitRefLog } from '../parsers/reflogParser.js';
+import { parseSignatureOutput, signatureFormat } from '../parsers/signatureParser.js';
+import { createCommitFileset } from './commitFilesetUtils.js';
+import { convertStashesToStdin } from './stash.js';
+const emptyPromise = Promise.resolve(undefined);
+const reflogCommands = ['merge', 'pull'];
+export class CommitsGitSubProvider {
+    context;
+    git;
+    cache;
+    provider;
+    constructor(context, git, cache, provider) {
+        this.context = context;
+        this.git = git;
+        this.cache = cache;
+        this.provider = provider;
+    }
+    async createUnreachableCommitFromTree(repoPath, tree, parent, message, cancellation) {
+        const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'commit-tree', tree, '-p', parent, '-m', message);
+        return result.stdout.trim();
+    }
+    async getCommit(repoPath, rev, cancellation) {
+        if (isUncommitted(rev, true)) {
+            return createUncommittedChangesCommit(repoPath, rev, new Date(), await this.provider.config.getCurrentUser(repoPath));
+        }
+        const log = await this.getLogCore(repoPath, rev, { limit: 1 }, cancellation);
+        if (log == null)
+            return undefined;
+        return log.commits.get(rev) ?? first(log.commits.values());
+    }
+    async getCommitCount(repoPath, rev, cancellation) {
+        const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'rev-list', '--count', rev, '--');
+        if (result.cancelled || cancellation?.aborted) {
+            throw new CancellationError();
+        }
+        const data = result.stdout.trim();
+        if (!data)
+            return undefined;
+        const count = parseInt(data, 10);
+        return isNaN(count) ? undefined : count;
+    }
+    async getCommitFiles(repoPath, rev, cancellation) {
+        const parser = getShaAndFilesAndStatsLogParser();
+        const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...parser.arguments, '-n1', rev && !isUncommittedStaged(rev) ? rev : undefined, '--');
+        const repoUri = fileUri(normalizePath(repoPath));
+        const files = first(parser.parse(result.stdout))?.files.map(f => new GitFileChange(repoPath, f.path, f.status, joinUriPath(repoUri, normalizePath(f.path)), f.originalPath, f.originalPath != null ? joinUriPath(repoUri, normalizePath(f.originalPath)) : undefined, undefined, { additions: f.additions, deletions: f.deletions, changes: 0 }, undefined, undefined, f.mode, f.oid ? { oid: f.oid, previousOid: f.previousOid } : undefined));
+        return files ?? [];
+    }
+    async getCommitForFile(repoPath, pathOrUri, rev, options, cancellation) {
+        const scope = getScopedLogger();
+        const [relativePath, root] = splitPath(toFsPath(pathOrUri), repoPath);
+        try {
+            const log = await this.getLogForPath(root, relativePath, rev, { limit: 1 }, cancellation);
+            if (log == null)
+                return undefined;
+            let commit;
+            if (rev) {
+                commit = log.commits.get(rev);
+                if (commit == null && !options?.firstIfNotFound) {
+                    // If the ref isn't a valid sha we will never find it, so let it fall through so we return the first
+                    if (isSha(rev) || isUncommitted(rev))
+                        return undefined;
+                }
+            }
+            return commit ?? first(log.commits.values());
+        }
+        catch (ex) {
+            scope?.error(ex);
+            if (isCancellationError(ex))
+                throw ex;
+            return undefined;
+        }
+    }
+    getCommitReachability(repoPath, rev, cancellation) {
+        if (repoPath == null || isUncommitted(rev))
+            return Promise.resolve(undefined);
+        const scope = getScopedLogger();
+        const getCore = async (cacheable) => {
+            try {
+                // Use for-each-ref with %(HEAD) to mark current branch with *
+                const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'for-each-ref', '--contains', rev, '--format=%(HEAD)%(refname)', '--sort=-version:refname', '--sort=-committerdate', '--sort=-HEAD', 'refs/heads/', 'refs/remotes/', 'refs/tags/');
+                if (cancellation?.aborted)
+                    throw new CancellationError();
+                const refs = [];
+                // Parse branches from refs/heads/ and refs/remotes/
+                if (result?.stdout) {
+                    const lines = result.stdout.split('\n');
+                    for (let line of lines) {
+                        line = line.trim();
+                        if (!line)
+                            continue;
+                        // %(HEAD) outputs '*' for current branch, ' ' for others
+                        const isCurrent = line.startsWith('*');
+                        const refname = isCurrent ? line.substring(1) : line; // Skip the HEAD marker
+                        // Skip HEADs
+                        if (refname.endsWith('/HEAD'))
+                            continue;
+                        if (refname.startsWith('refs/heads/')) {
+                            // Remove 'refs/heads/'
+                            const name = refname.substring(11);
+                            refs.push({
+                                refType: 'branch',
+                                name: name,
+                                remote: false,
+                                current: isCurrent,
+                            });
+                        }
+                        else if (refname.startsWith('refs/remotes/')) {
+                            // Remove 'refs/remotes/'
+                            refs.push({ refType: 'branch', name: refname.substring(13), remote: true });
+                        }
+                        else if (refname.startsWith('refs/tags/')) {
+                            // Remove 'refs/tags/'
+                            refs.push({ refType: 'tag', name: refname.substring(10) });
+                        }
+                    }
+                }
+                // Sort to move tags to the end, preserving order within each type
+                refs.sort((a, b) => (a.refType !== b.refType ? (a.refType === 'tag' ? 1 : -1) : 0));
+                return { refs: refs };
+            }
+            catch (ex) {
+                cacheable?.invalidate();
+                debugger;
+                if (isCancellationError(ex))
+                    throw ex;
+                scope?.error(ex);
+                return undefined;
+            }
+        };
+        return this.cache.reachability.getOrCreate(repoPath, rev, getCore);
+    }
+    async getIncomingActivity(repoPath, options, cancellation) {
+        const scope = getScopedLogger();
+        const cfg = this.context.config;
+        const parser = getReflogParser();
+        const args = ['--walk-reflogs', ...parser.arguments, '--date=iso8601'];
+        const ordering = options?.ordering ?? cfg?.commits.ordering;
+        if (ordering) {
+            args.push(`--${ordering}-order`);
+        }
+        if (options?.all) {
+            args.push('--all');
+        }
+        // Pass a much larger limit to reflog, because we aggregate the data and we won't know how many lines we'll need
+        const limit = (options?.limit ?? cfg?.commits.maxItems ?? 0) * 100;
+        if (limit) {
+            args.push(`-n${limit}`);
+        }
+        if (options?.skip) {
+            args.push(`--skip=${options.skip}`);
+        }
+        try {
+            const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...args);
+            const reflog = parseGitRefLog(parser, result.stdout, repoPath, reflogCommands, limit, limit * 100);
+            if (reflog?.hasMore) {
+                reflog.more = this.getReflogMoreFn(reflog, options);
+            }
+            return reflog;
+        }
+        catch (ex) {
+            scope?.error(ex);
+            if (isCancellationError(ex))
+                throw ex;
+            return undefined;
+        }
+    }
+    getReflogMoreFn(reflog, options) {
+        return async (limit) => {
+            limit = limit ?? 0;
+            const moreLog = await this.getIncomingActivity(reflog.repoPath, {
+                ...options,
+                limit: limit,
+                skip: reflog.total,
+            });
+            if (moreLog == null) {
+                // If we can't find any more, assume we have everything
+                return { ...reflog, hasMore: false, more: undefined };
+            }
+            const mergedLog = {
+                repoPath: reflog.repoPath,
+                records: [...reflog.records, ...moreLog.records],
+                count: reflog.count + moreLog.count,
+                total: reflog.total + moreLog.total,
+                limit: (reflog.limit ?? 0) + limit,
+                hasMore: moreLog.hasMore,
+            };
+            if (mergedLog.hasMore) {
+                mergedLog.more = this.getReflogMoreFn(mergedLog, options);
+            }
+            return mergedLog;
+        };
+    }
+    getInitialCommitSha(repoPath, cancellation) {
+        // Initial commit SHA is shared across all worktrees
+        return this.cache.getInitialCommitSha(repoPath, async (commonPath) => {
+            try {
+                const result = await this.git.exec({ cwd: commonPath, cancellation: cancellation, errors: 'ignore' }, 'rev-list', `--max-parents=0`, 'HEAD', '--');
+                if (result.cancelled || cancellation?.aborted) {
+                    throw new CancellationError();
+                }
+                return result.stdout.trim().split('\n')?.[0];
+            }
+            catch (ex) {
+                if (isCancellationError(ex))
+                    throw ex;
+                return undefined;
+            }
+        });
+    }
+    async getLeftRightCommitCount(repoPath, range, options, cancellation) {
+        const authors = options?.authors?.length
+            ? options.authors.map(a => `--author=^${escapeRegex(a.name ?? '')} <${escapeRegex(a.email ?? '')}>$`)
+            : [];
+        const run = async () => {
+            const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'rev-list', '--left-right', '--count', ...authors, options?.excludeMerges ? '--no-merges' : undefined, range, '--');
+            if (result.cancelled || cancellation?.aborted) {
+                throw new CancellationError();
+            }
+            if (!result.stdout)
+                return undefined;
+            const parts = result.stdout.split('\t');
+            if (parts.length !== 2)
+                return undefined;
+            const [left, right] = parts;
+            const counts = {
+                left: parseInt(left, 10),
+                right: parseInt(right, 10),
+            };
+            if (isNaN(counts.left) || isNaN(counts.right))
+                return undefined;
+            return counts;
+        };
+        // Author-filtered calls are one-off (e.g. "who made these commits") with low re-hit
+        // rate; skip the cache to protect its capacity for the hot no-author merge-target path.
+        if (authors.length > 0)
+            return run();
+        // Cache key: range + excludeMerges. RepositoryChange events affecting branches/remotes
+        // invalidate this cache via clearCaches('branches').
+        const cacheKey = `${range}\x1f${options?.excludeMerges ? 'no-merges' : ''}`;
+        return this.cache.getLeftRightCommitCount(repoPath, cacheKey, run);
+    }
+    async getLog(repoPath, rev, options, cancellation) {
+        return this.getLogCore(repoPath, rev, options, cancellation);
+    }
+    async getLogCore(repoPath, rev, options, cancellation, additionalArgs) {
+        const scope = getScopedLogger();
+        try {
+            const currentUserPromise = this.provider.config.getCurrentUser(repoPath);
+            const cfg = this.context.config;
+            const limit = options?.limit ?? cfg?.commits.maxItems ?? 0;
+            const isSingleCommit = limit === 1;
+            const cfgIncludeFiles = options?.includeFiles ?? cfg?.commits.includeFileDetails ?? true;
+            const includeFiles = cfgIncludeFiles || isSingleCommit || Boolean(options?.path?.pathspec);
+            const parser = getCommitsLogParser(includeFiles, Boolean(options?.path?.pathspec && options?.path?.range));
+            const args = ['log', ...parser.arguments];
+            const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
+            args.push(`-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`, '--use-mailmap');
+            if (options?.all) {
+                args.push('--all');
+                if (options?.path?.pathspec) {
+                    args.push('--single-worktree');
+                }
+            }
+            const merges = options?.merges ?? true;
+            if (merges) {
+                // If we are are asking for a specific ref, ensure we return the merge commit files
+                if (isSingleCommit) {
+                    args.push('-m');
+                }
+                args.push(merges === 'first-parent' ? '--first-parent' : '--no-min-parents');
+            }
+            else {
+                args.push('--no-merges');
+            }
+            const ordering = options?.ordering ?? cfg?.commits.ordering;
+            if (ordering) {
+                args.push(`--${ordering}-order`);
+            }
+            if (options?.authors?.length) {
+                args.push(...options.authors.map(a => `--author=^${escapeRegex(a.name ?? '')} <${escapeRegex(a.email ?? '')}>$`));
+            }
+            let overrideHasMore;
+            if (options?.since) {
+                overrideHasMore = true;
+                args.push(`--since="${options.since}"`);
+            }
+            if (options?.until) {
+                overrideHasMore = true;
+                args.push(`--until="${options.until}"`);
+            }
+            if (additionalArgs?.length) {
+                args.push(...additionalArgs);
+            }
+            if (limit > 0) {
+                overrideHasMore = isSingleCommit ? false : undefined;
+                // Add 1 to the limit so we can check if there are more commits
+                args.push(`-n${isSingleCommit ? 1 : limit + 1}`);
+            }
+            let stashes;
+            let stdin;
+            if (!isSingleCommit) {
+                if (options?.stashes) {
+                    // There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
+                    ({ stdin, stashes } = convertStashesToStdin(typeof options.stashes === 'boolean'
+                        ? await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation)
+                        : options.stashes));
+                    if (stashes.size) {
+                        rev ??= 'HEAD';
+                    }
+                }
+                if (stdin) {
+                    args.push('--stdin');
+                }
+            }
+            if (rev && !isUncommittedStaged(rev)) {
+                args.push(rev);
+            }
+            let pathspec;
+            let pathspecRange;
+            if (options?.path?.pathspec) {
+                pathspec = options.path.pathspec;
+                const { filters, range, renames } = options.path;
+                if (filters?.length) {
+                    args.push(`--diff-filter=${filters.join('')}`);
+                }
+                if (range != null) {
+                    // Git doesn't allow rename detection (`--follow`) if a range is used
+                    const [start, end] = getGitStartEnd(range);
+                    pathspecRange = `${start},${end}`;
+                    args.push(`-L ${pathspecRange}:${pathspec}`, '--');
+                }
+                else {
+                    if (renames !== false) {
+                        args.push('--follow');
+                    }
+                    args.push('--', pathspec);
+                }
+            }
+            else {
+                args.push('--');
+            }
+            const currentUser = await currentUserPromise.catch(() => undefined);
+            if (cancellation?.aborted)
+                throw new CancellationError();
+            const cmdOpts = {
+                cwd: repoPath,
+                cancellation: cancellation,
+                configs: gitConfigsLogWithFiles,
+                stdin: stdin,
+            };
+            let { commits, count, countStashChildCommits } = await parseCommits(parser, isSingleCommit ? this.git.exec(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args), repoPath, pathspec, limit, stashes, currentUser);
+            // If we didn't find any history from the working tree, check to see if the file was renamed
+            if (rev == null && pathspec && !commits.size) {
+                const status = await this.provider.status?.getStatusForFile?.(repoPath, pathspec, undefined, cancellation);
+                if (status?.originalPath != null) {
+                    pathspec = status.originalPath;
+                    if (pathspecRange) {
+                        const index = args.findIndex(a => a.startsWith('-L '));
+                        args.splice(index, 1, `-L ${pathspecRange}:${pathspec}`);
+                    }
+                    else {
+                        args.splice(args.length - 1, 1, pathspec);
+                    }
+                    ({ commits, count, countStashChildCommits } = await parseCommits(parser, isSingleCommit ? this.git.exec(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args), repoPath, pathspec, limit, stashes, currentUser));
+                }
+            }
+            const log = {
+                repoPath: repoPath,
+                commits: commits,
+                sha: isRevisionRange(rev) ? undefined : rev,
+                count: commits.size,
+                limit: limit,
+                hasMore: overrideHasMore ?? count - countStashChildCommits > commits.size,
+            };
+            if (!isSingleCommit) {
+                log.query = (limit) => this.getLogCore(repoPath, rev, { ...options, limit: limit }, undefined, additionalArgs);
+                if (log.hasMore) {
+                    log.more = this.getLogCoreMoreFn(log, rev, options);
+                }
+            }
+            return log;
+        }
+        catch (ex) {
+            if (isCancellationError(ex))
+                throw ex;
+            // Check if this is a "bad object" error due to a submodule's internal SHA
+            const pathspec = options?.path?.pathspec;
+            if (rev && pathspec && ex instanceof Error && GitErrors.badObject.test(ex.message)) {
+                const tree = await this.provider.revision.getTreeEntryForRevision(repoPath, pathspec, 'HEAD');
+                if (tree?.type === 'commit') {
+                    // It's a submodule - retry without the rev and without rename tracking
+                    return this.getLogCore(repoPath, undefined, { ...options, path: { ...options.path, pathspec: pathspec, renames: false } }, cancellation, additionalArgs);
+                }
+            }
+            scope?.error(ex);
+            debugger;
+            return undefined;
+        }
+    }
+    getLogCoreMoreFn(log, rev, options) {
+        return async (limit) => {
+            const moreUntil = limit != null && typeof limit === 'object' ? limit.until : undefined;
+            let moreLimit = typeof limit === 'number' ? limit : undefined;
+            if (moreUntil && some(log.commits.values(), c => c.ref === moreUntil)) {
+                return log;
+            }
+            moreLimit = moreLimit ?? 0;
+            // If the log is for a range, then just get everything prior + more
+            if (isRevisionRange(log.sha)) {
+                const moreLog = await this.getLogCore(log.repoPath, rev, {
+                    ...options,
+                    limit: moreLimit === 0 ? 0 : (options?.limit ?? 0) + moreLimit,
+                });
+                // If we can't find any more, assume we have everything
+                if (moreLog == null)
+                    return { ...log, hasMore: false, more: undefined };
+                return moreLog;
+            }
+            // Stashes are not part of the normal commit history, so we need to find the last non-stash commit for the cursor
+            const lastCommit = findLast(log.commits.values(), c => !GitCommit.isStash(c)) ?? last(log.commits.values());
+            const sha = lastCommit?.ref;
+            // Check to make sure the filename hasn't changed and if it has use the previous
+            const lastCommitFile = lastCommit?.anyFiles?.[0];
+            if (options?.path?.pathspec && lastCommitFile != null) {
+                const path = lastCommitFile.originalPath ?? lastCommitFile.path;
+                if (path !== options.path.pathspec) {
+                    options = { ...options, path: { ...options.path, pathspec: path } };
+                }
+            }
+            // If we were asked for all refs, use the last commit timestamp (plus a second) as a cursor
+            let timestamp;
+            if (options?.all) {
+                const date = lastCommit?.committer.date;
+                // Git only allows 1-second precision, so round up to the nearest second
+                timestamp = date != null ? Math.ceil(date.getTime() / 1000) + 1 : undefined;
+            }
+            let moreLogCount;
+            let queryLimit = moreUntil == null ? moreLimit : 0;
+            do {
+                const moreLog = await this.getLogCore(log.repoPath, timestamp ? rev : moreUntil == null ? `${sha}^` : `${moreUntil}^..${sha}^`, {
+                    ...options,
+                    limit: queryLimit,
+                    ...(timestamp ? { until: timestamp } : undefined),
+                }, undefined, timestamp ? ['--boundary'] : undefined);
+                // If we can't find any more, assume we have everything
+                if (moreLog == null)
+                    return { ...log, hasMore: false, more: undefined };
+                const currentCount = log.commits.size;
+                const commits = new Map([...log.commits, ...moreLog.commits]);
+                if (currentCount === commits.size && queryLimit !== 0) {
+                    // If we didn't find any new commits, we must have them all so return that we have everything
+                    if (moreLogCount === moreLog.commits.size) {
+                        return { ...log, hasMore: false, more: undefined };
+                    }
+                    moreLogCount = moreLog.commits.size;
+                    queryLimit = queryLimit * 2;
+                    continue;
+                }
+                if (timestamp != null && sha != null && !moreLog.commits.has(sha)) {
+                    debugger;
+                }
+                const mergedLog = {
+                    repoPath: log.repoPath,
+                    commits: commits,
+                    sha: log.sha,
+                    count: commits.size,
+                    limit: moreUntil == null ? (log.limit ?? 0) + moreLimit : undefined,
+                    hasMore: moreUntil == null ? moreLog.hasMore : true,
+                    // The oldest commit SHA of the previous page — the graph webview compares this
+                    // against its last displayed row to determine the merge point for appending new rows
+                    startingCursor: sha,
+                    endingCursor: moreLog.endingCursor,
+                    pagedCommits: () => {
+                        // Remove any duplicates
+                        for (const sha of log.commits.keys()) {
+                            moreLog.commits.delete(sha);
+                        }
+                        return moreLog.commits;
+                    },
+                    // eslint-disable-next-line no-loop-func
+                    query: (limit) => this.getLogCore(log.repoPath, rev, { ...options, limit: limit }),
+                };
+                if (mergedLog.hasMore) {
+                    mergedLog.more = this.getLogCoreMoreFn(mergedLog, rev, options);
+                }
+                return mergedLog;
+            } while (true);
+        };
+    }
+    async getLogForPath(repoPath, pathOrUri, rev, options, cancellation) {
+        if (repoPath == null)
+            return undefined;
+        const scope = getScopedLogger();
+        let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+        if (repoPath != null && repoPath === relativePath) {
+            throw new Error(`Path cannot match the repository path; path=${relativePath}`);
+        }
+        const cfg = this.context.config;
+        options = {
+            ...options,
+            all: options?.all ?? cfg?.fileHistory?.showAllBranches,
+            limit: options?.limit ?? cfg?.commits.maxItems ?? 0,
+            merges: options?.merges ?? cfg?.fileHistory?.showMergeCommits,
+            ordering: options?.ordering ?? cfg?.commits.ordering ?? undefined,
+            renames: options?.renames ?? cfg?.fileHistory?.followRenames,
+            similarityThreshold: options?.similarityThreshold ?? cfg?.commits.similarityThreshold,
+        };
+        if (isFolderGlob(relativePath)) {
+            relativePath = stripFolderGlob(relativePath);
+            options.isFolder = true;
+        }
+        else if (options.isFolder == null) {
+            const tree = await this.provider.revision.getTreeEntryForRevision(repoPath, relativePath, rev || 'HEAD');
+            if (cancellation?.aborted)
+                throw new CancellationError();
+            if (tree?.type === 'commit') {
+                // It's a submodule — line ranges and rename tracking don't apply, and the rev may reference
+                // the submodule's internal SHA which isn't valid in the parent repo
+                options.range = undefined;
+                options.renames = false;
+                // rev = undefined;
+            }
+            else {
+                options.isFolder = tree?.type === 'tree';
+            }
+        }
+        // Build cache key — only for non-folder, non-filtered queries
+        let cacheKey;
+        if (!options.isFolder &&
+            options.authors == null &&
+            options.cursor == null &&
+            options.filters == null &&
+            options.range == null &&
+            options.since == null &&
+            options.until == null) {
+            let suffix = 'log';
+            if (rev != null) {
+                suffix += `:${rev}`;
+            }
+            if (options.all) {
+                suffix += ':all';
+            }
+            if (options.limit) {
+                suffix += `:n${options.limit}`;
+            }
+            if (options.merges) {
+                suffix += `:merges=${options.merges}`;
+            }
+            if (options.ordering) {
+                suffix += `:ordering=${options.ordering}`;
+            }
+            if (options.renames) {
+                suffix += ':follow';
+            }
+            cacheKey = `${normalizePath(relativePath)}:${suffix}`;
+        }
+        if (cacheKey != null) {
+            // Check for exact cache hit
+            const cached = this.cache.fileLog.get(repoPath, cacheKey);
+            if (cached != null) {
+                scope?.trace(`Cache hit: '${cacheKey}'`);
+                return cached;
+            }
+            // Subset optimization: if requesting partial log, check if whole-file log is cached
+            if (rev != null || (options.limit != null && options.limit !== 0)) {
+                const baseKey = `${normalizePath(relativePath)}:log${options.renames ? ':follow' : ''}`;
+                const baseLog = this.cache.fileLog.get(repoPath, baseKey);
+                if (baseLog != null) {
+                    if (rev == null) {
+                        scope?.trace(`Cache hit: ~'${cacheKey}'`);
+                        return baseLog;
+                    }
+                    scope?.trace(`Cache ?: '${cacheKey}'`);
+                    const log = await baseLog;
+                    if (log != null && !log.hasMore && log.commits.has(rev)) {
+                        scope?.trace(`Cache hit: '${cacheKey}'`);
+                        // Create a copy of the log starting at the requested commit
+                        let skip = true;
+                        let i = 0;
+                        const limit = options.limit;
+                        const commits = new Map(filterMap(log.commits.entries(), ([sha, c]) => {
+                            if (skip) {
+                                if (sha !== rev)
+                                    return undefined;
+                                skip = false;
+                            }
+                            i++;
+                            if (limit != null && i > limit) {
+                                return undefined;
+                            }
+                            return [sha, c];
+                        }));
+                        const optsCopy = { ...options };
+                        return {
+                            ...log,
+                            limit: optsCopy.limit,
+                            count: commits.size,
+                            commits: commits,
+                            query: (limit) => this.getLogForPath(repoPath, pathOrUri, rev, {
+                                ...optsCopy,
+                                limit: limit,
+                            }),
+                        };
+                    }
+                }
+            }
+            scope?.trace(`Cache miss: '${cacheKey}'`);
+            return this.cache.fileLog.getOrCreate(repoPath, cacheKey, (_cacheable, signal) => this.getLogForPathCore(repoPath, relativePath, rev, options, signal), { cancellation: cancellation });
+        }
+        return this.getLogForPathCore(repoPath, relativePath, rev, options, cancellation);
+    }
+    async getLogForPathCore(repoPath, path, rev, options, cancellation) {
+        const scope = getScopedLogger();
+        const tracked = await this.provider.isTrackedWithDetails(path, repoPath, rev);
+        if (cancellation?.aborted)
+            throw new CancellationError();
+        if (tracked == null) {
+            scope?.debug(`Skipping log; '${path}' is not tracked`);
+            return emptyPromise;
+        }
+        const relativePath = tracked.path;
+        const root = repoPath;
+        const log = await this.getLogCore(root, rev, {
+            all: options.all,
+            authors: options.authors,
+            cursor: options.cursor,
+            limit: options.limit,
+            merges: options.merges,
+            ordering: options.ordering,
+            since: options.since,
+            until: options.until,
+            path: {
+                pathspec: relativePath,
+                filters: options.filters,
+                range: options.range,
+                renames: options.renames,
+            },
+        }, cancellation);
+        return log;
+    }
+    async getLogShas(repoPath, rev, options, cancellation) {
+        const scope = getScopedLogger();
+        const cfg = this.context.config;
+        options ??= {};
+        options.limit ??= cfg?.commits.maxItems ?? 0;
+        options.ordering ??= cfg?.commits.ordering ?? undefined;
+        options.similarityThreshold ??= cfg?.commits.similarityThreshold;
+        options.merges ??= true;
+        const getCore = async () => {
+            try {
+                const parser = getShaLogParser();
+                const args = [...parser.arguments];
+                if (options.all) {
+                    args.push(`--all`);
+                }
+                if (options.ordering) {
+                    args.push(`--${options.ordering}-order`);
+                }
+                if (options.limit) {
+                    args.push(`-n${options.limit}`);
+                }
+                if (options.since) {
+                    args.push(`--since="${options.since}"`);
+                }
+                if (options.merges) {
+                    args.push(options.merges === 'first-parent' ? '--first-parent' : '--no-min-parents');
+                }
+                else {
+                    args.push('--no-merges');
+                }
+                if (options.reverse) {
+                    args.push('--reverse');
+                }
+                if (options.authors?.length) {
+                    if (!args.includes('--use-mailmap')) {
+                        args.push('--use-mailmap');
+                    }
+                    args.push(...options.authors.map(a => `--author=^${escapeRegex(a.name ?? '')} <${escapeRegex(a.email ?? '')}>$`));
+                }
+                const pathspec = options.pathOrUri != null ? this.provider.getRelativePath(options.pathOrUri, repoPath) : undefined;
+                if (pathspec) {
+                    const similarityThreshold = options.similarityThreshold;
+                    args.push(`-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`);
+                }
+                if (rev && !isUncommittedStaged(rev)) {
+                    args.push(rev);
+                }
+                args.push('--');
+                if (pathspec) {
+                    args.push(pathspec);
+                }
+                const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...args);
+                return [...parser.parse(result.stdout)];
+            }
+            catch (ex) {
+                scope?.error(ex);
+                if (isCancellationError(ex))
+                    throw ex;
+                debugger;
+                return [];
+            }
+        };
+        // Cache simple queries (no pathspec, no authors) as these are on hot paths (e.g. getting unpublished commits)
+        const cacheable = !options.pathOrUri && !options.authors?.length && !options.reverse && !options.all;
+        if (cacheable) {
+            return this.cache.logShas.getOrCreate(repoPath, `${rev ?? ''}:${options.ordering ?? ''}:${options.limit}:${options.merges}:${options.since ?? ''}`, () => getCore());
+        }
+        return getCore();
+    }
+    async getOldestUnpushedShaForPath(repoPath, pathOrUri, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+            const parser = getShaLogParser();
+            const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...parser.arguments, '--follow', '--reverse', '@{u}..', '--', relativePath);
+            return first(parser.parse(result.stdout));
+        }
+        catch (ex) {
+            scope?.error(ex);
+            if (isCancellationError(ex))
+                throw ex;
+            debugger;
+            return undefined;
+        }
+    }
+    async hasCommitBeenPushed(repoPath, rev, cancellation) {
+        if (repoPath == null)
+            return false;
+        return this.isAncestorOf(repoPath, rev, '@{u}', cancellation);
+    }
+    async isAncestorOf(repoPath, rev1, rev2, cancellation) {
+        if (repoPath == null)
+            return false;
+        const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'merge-base', '--is-ancestor', rev1, rev2);
+        return result.exitCode === 0;
+    }
+    async searchCommits(repoPath, search, options, cancellation) {
+        const scope = getScopedLogger();
+        search = { matchAll: false, matchCase: false, matchRegex: true, matchWholeWord: false, ...search };
+        // Pre-process natural language search queries via the host-provided hook
+        if (search.naturalLanguage &&
+            (typeof search.naturalLanguage !== 'object' || !search.naturalLanguage.processedQuery)) {
+            search = (await this.context.searchQuery?.preprocessQuery?.(search, options?.source)) ?? search;
+        }
+        try {
+            const cfg = this.context.config;
+            const currentUser = await this.provider.config.getCurrentUser(repoPath);
+            if (cancellation?.aborted)
+                throw new CancellationError();
+            const parser = getCommitsLogParser(true);
+            const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
+            const args = [
+                'log',
+                ...parser.arguments,
+                `-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`,
+                '--use-mailmap',
+            ];
+            const { args: searchArgs, files, shas, filters } = parseSearchQueryGitCommand(search, currentUser);
+            let stashes;
+            let stdin;
+            if (shas?.size) {
+                stdin = join(shas, '\n');
+                args.push('--no-walk');
+            }
+            else if (!filters.refs) {
+                // Don't include stashes when using ref: filter, as they would add unrelated commits
+                // There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
+                ({ stdin, stashes } = convertStashesToStdin(await this.provider.stash?.getStash(repoPath, undefined, cancellation)));
+            }
+            if (stdin) {
+                args.push('--stdin');
+            }
+            const limit = options?.limit ?? cfg?.search?.maxItems ?? 0;
+            if (limit && !shas?.size) {
+                args.push(`-n${limit + 1}`);
+            }
+            const ordering = options?.ordering ?? cfg?.commits.ordering;
+            if (ordering) {
+                args.push(`--${ordering}-order`);
+            }
+            if (options?.skip) {
+                args.push(`--skip=${options.skip}`);
+            }
+            // Add the search args, but skip any shas (as they are already included in the stdin)
+            for (const arg of searchArgs) {
+                if (shas?.has(arg) || args.includes(arg))
+                    continue;
+                args.push(arg);
+            }
+            const pathspec = files?.join(' ');
+            const { commits, count, countStashChildCommits } = await parseCommits(parser, this.git.stream({
+                cwd: repoPath,
+                cancellation: cancellation,
+                configs: ['-C', repoPath, ...gitConfigsLog],
+                stdin: stdin,
+            }, ...args, '--', ...files), repoPath, pathspec, limit, stashes, currentUser, filters);
+            const log = {
+                repoPath: repoPath,
+                commits: commits,
+                sha: undefined,
+                searchFilters: filters,
+                count: commits.size,
+                limit: limit,
+                hasMore: count - countStashChildCommits > commits.size,
+                query: (limit) => this.searchCommits(repoPath, search, { ...options, limit: limit }).then(r => r.log),
+            };
+            if (log.hasMore) {
+                const searchCommitsCore = (log) => {
+                    return async (limit) => {
+                        limit = limit ?? 0;
+                        const moreLog = (await this.searchCommits(log.repoPath, search, {
+                            ...options,
+                            limit: limit,
+                            skip: log.count,
+                        })).log;
+                        // If we can't find any more, assume we have everything
+                        if (moreLog == null)
+                            return { ...log, hasMore: false, more: undefined };
+                        const commits = new Map([...log.commits, ...moreLog.commits]);
+                        const mergedLog = {
+                            repoPath: log.repoPath,
+                            commits: commits,
+                            sha: log.sha,
+                            searchFilters: filters,
+                            count: commits.size,
+                            limit: (log.limit ?? 0) + limit,
+                            hasMore: moreLog.hasMore,
+                            query: (limit) => this.searchCommits(log.repoPath, search, { ...options, limit: limit }).then(r => r.log),
+                        };
+                        if (mergedLog.hasMore) {
+                            mergedLog.more = searchCommitsCore(mergedLog);
+                        }
+                        return mergedLog;
+                    };
+                };
+                log.more = searchCommitsCore(log);
+            }
+            return { search: search, log: log };
+        }
+        catch (ex) {
+            scope?.error(ex);
+            if (isCancellationError(ex))
+                throw ex;
+            return { search: search, log: undefined };
+        }
+    }
+    async getCommitSignature(repoPath, sha) {
+        const scope = getScopedLogger();
+        try {
+            const result = await this.git.exec({
+                cwd: repoPath,
+                errors: 'ignore',
+                caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+                configs: gitConfigsLog,
+            }, 'log', `--format=${signatureFormat}`, '-1', sha);
+            if (!result.stdout)
+                return undefined;
+            return parseSignatureOutput(result.stdout);
+        }
+        catch (ex) {
+            scope?.error(ex);
+            return undefined;
+        }
+    }
+    async isCommitSigned(repoPath, sha) {
+        const scope = getScopedLogger();
+        try {
+            const result = await this.git.exec({
+                cwd: repoPath,
+                errors: 'ignore',
+                caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+            }, 'cat-file', 'commit', sha);
+            return /^gpgsig(-sha256)? /m.test(result.stdout);
+        }
+        catch (ex) {
+            scope?.error(ex);
+            return false;
+        }
+    }
+}
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "createUnreachableCommitFromTree", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getCommit", null);
+__decorate([
+    debug({ exit: true })
+], CommitsGitSubProvider.prototype, "getCommitCount", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getCommitFiles", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getCommitForFile", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getCommitReachability", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getIncomingActivity", null);
+__decorate([
+    debug({ exit: true })
+], CommitsGitSubProvider.prototype, "getInitialCommitSha", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getLeftRightCommitCount", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getLog", null);
+__decorate([
+    trace({ args: (repoPath, rev) => ({ repoPath: repoPath, rev: rev }), exit: true })
+], CommitsGitSubProvider.prototype, "getLogCore", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getLogForPath", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getLogShas", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getOldestUnpushedShaForPath", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "hasCommitBeenPushed", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "isAncestorOf", null);
+__decorate([
+    debug({
+        args: (repoPath, s) => ({
+            repoPath: repoPath,
+            search: `[${s.matchAll ? 'A' : ''}${s.matchCase ? 'C' : ''}${s.matchRegex ? 'R' : ''}${s.matchWholeWord ? 'W' : ''}]: ${s.query.length > 500 ? `${s.query.substring(0, 500)}...` : s.query}`,
+        }),
+    })
+], CommitsGitSubProvider.prototype, "searchCommits", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "getCommitSignature", null);
+__decorate([
+    debug()
+], CommitsGitSubProvider.prototype, "isCommitSigned", null);
+function toCommit(c, repoPath, pathspec, currentUser) {
+    const message = c.message.trim();
+    const index = message.indexOf('\n');
+    const isCurrentAuthor = isUserMatch(currentUser, c.author, c.authorEmail) || undefined;
+    const isCurrentCommitter = isUserMatch(currentUser, c.committer, c.committerEmail) || undefined;
+    return new GitCommit(repoPath, c.sha, new GitCommitIdentity(c.author, c.authorEmail, new Date(Number(c.authorDate) * 1000), undefined, isCurrentAuthor), new GitCommitIdentity(c.committer, c.committerEmail, new Date(Number(c.committerDate) * 1000), undefined, isCurrentCommitter), index !== -1 ? message.substring(0, index) : message, c.parents?.split(' ') ?? [], message, createCommitFileset(c, repoPath, pathspec), c.stats, undefined, c.tips?.split(' '));
+}
+function getGitStartEnd(range) {
+    // Library DiffRange is always 1-based, startLine <= endLine
+    return [range.startLine, range.endLine];
+}
+async function parseCommits(parser, resultOrStream, repoPath, pathspec, limit, stashes, currentUser, searchFilters) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        let count = 0;
+        let countStashChildCommits = 0;
+        const commits = new Map();
+        const tipsOnly = searchFilters?.type === 'tip';
+        if (resultOrStream instanceof Promise) {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const scope = getScopedLogger();
+                const result = await resultOrStream;
+                const sw = __addDisposableResource(env_2, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
+                if (stashes?.size) {
+                    const allowFilteredFiles = searchFilters?.files ?? false;
+                    const stashesOnly = searchFilters?.type === 'stash';
+                    for (const c of parser.parse(result.stdout)) {
+                        if (stashesOnly && !stashes?.has(c.sha))
+                            continue;
+                        if (tipsOnly && !c.tips)
+                            continue;
+                        count++;
+                        if (limit && count > limit)
+                            break;
+                        const stash = stashes?.get(c.sha);
+                        if (stash != null) {
+                            if (commits.has(stash.sha)) {
+                                countStashChildCommits++;
+                            }
+                            else if (allowFilteredFiles) {
+                                commits.set(stash.sha, stash.with({
+                                    fileset: {
+                                        ...createCommitFileset(c, repoPath, pathspec),
+                                        // Add the full stash files back into the fileset
+                                        files: stash.fileset?.files,
+                                    },
+                                }));
+                            }
+                            else {
+                                commits.set(stash.sha, stash);
+                            }
+                            continue;
+                        }
+                        commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+                    }
+                }
+                else {
+                    for (const c of parser.parse(result.stdout)) {
+                        if (tipsOnly && !c.tips)
+                            continue;
+                        count++;
+                        if (limit && count > limit)
+                            break;
+                        commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+                    }
+                }
+                sw?.stop({ suffix: ` created ${count} commits` });
+                return { commits: commits, count: count, countStashChildCommits: countStashChildCommits };
+            }
+            catch (e_1) {
+                env_2.error = e_1;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        }
+        const _streamDisposer = __addDisposableResource(env_1, createDisposable(() => void resultOrStream.return?.(undefined)), false);
+        if (stashes?.size) {
+            const allowFilteredFiles = searchFilters?.files ?? false;
+            const stashesOnly = searchFilters?.type === 'stash';
+            for await (const c of parser.parseAsync(resultOrStream)) {
+                if (stashesOnly && !stashes?.has(c.sha))
+                    continue;
+                if (tipsOnly && !c.tips)
+                    continue;
+                count++;
+                if (limit && count > limit)
+                    break;
+                const stash = stashes?.get(c.sha);
+                if (stash != null) {
+                    if (commits.has(stash.sha)) {
+                        countStashChildCommits++;
+                    }
+                    else if (allowFilteredFiles) {
+                        commits.set(stash.sha, stash.with({
+                            fileset: {
+                                ...createCommitFileset(c, repoPath, pathspec),
+                                // Add the full stash files back into the fileset
+                                files: stash.fileset?.files,
+                            },
+                        }));
+                    }
+                    else {
+                        commits.set(stash.sha, stash);
+                    }
+                    continue;
+                }
+                commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+            }
+        }
+        else {
+            for await (const c of parser.parseAsync(resultOrStream)) {
+                if (tipsOnly && !c.tips)
+                    continue;
+                count++;
+                if (limit && count > limit)
+                    break;
+                commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+            }
+        }
+        return { commits: commits, count: count, countStashChildCommits: countStashChildCommits };
+    }
+    catch (e_2) {
+        env_1.error = e_2;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+//# sourceMappingURL=commits.js.map