sfdx-git-delta 7.2.0 → 7.4.0

package/README.md

@@ -26,6 +26,9 @@
 > [!WARNING]
 > **Potentially breaking changes in v6**: Check out the [v6 migration guide](docs/migrating-to-v6.0.0.md) to see how you could be impacted by some changes in the new major `v6` version of the plugin, and how to migrate to this version.
 
+> [!WARNING]
+> **Breaking change for programmatic consumers**: `Config.mergeBase` is now a required field. Add `mergeBase: false` to your config to preserve today's behavior. See the [merge-base migration guide](docs/migrating-config-merge-base.md) for details.
+
 <!-- TABLE OF CONTENTS -->
 <details>
   <summary>Table of Contents</summary>
@@ -119,7 +122,7 @@ It's also important to implement a way to switch back to full deployment in case
 
 ### Prerequisites
 
-No `git` binary is required: the plugin reads the repository's git object store in-process.
+No `git` binary is required: the plugin reads the repository's git object store in-process, including `--ref-format=reftable` and `--object-format=sha256` repositories (the latter isn't hosted by GitHub or GitLab today, so you're unlikely to run into one).
 
 **Node v22 or above is required**.
 To check if Salesforce CLI runs under a supported node version for SGD, run `sf --version`. You should see a node version of v22 or above to use SGD.
@@ -149,7 +152,7 @@ Generate incremental package manifest and source content
 
 ```
 USAGE
-  $ sf sgd source delta -f <value> [--json] [--flags-dir <value>] [-t <value>] [-d] [-o <value>] [-r <value>] [-s
+  $ sf sgd source delta -f <value> [--json] [--flags-dir <value>] [-t <value>] [-b] [-d] [-o <value>] [-r <value>] [-s
     <value>...] [-i <value>] [-D <value>] [-n <value>] [-N <value>] [-M <value>] [-c <value>] [-W] [-a <value>]
 
 FLAGS
@@ -159,6 +162,8 @@ FLAGS
   -W, --ignore-whitespace                     ignore git diff whitespace (space, tab, eol) changes
   -a, --api-version=<value>                   salesforce metadata API version, default to sfdx-project.json
                                               "sourceApiVersion" attribute or latest version
+  -b, --merge-base                            diff from the merge base of --from and --to instead of --from itself (git
+                                              three-dot semantics)
   -c, --changes-manifest=<value>              path to a JSON file grouping changed components by kind (add, modify,
                                               delete, rename); setting this flag also enables git rename detection
   -d, --generate-delta                        generate delta files in [--output-dir] folder
@@ -184,6 +189,8 @@ EXAMPLES
   $ sf sgd source delta --from "origin/development" --output-dir incremental
   - Build incremental manifest and source from the development branch
   $ sf sgd source delta --from "origin/development" --generate-delta --output-dir incremental
+  - Build incremental manifest from where the current branch diverged from main
+  $ sf sgd source delta --from "main" --merge-base --output-dir incremental
 
 FLAG DESCRIPTIONS
   -a, --api-version=<value>
@@ -207,7 +214,7 @@ FLAG DESCRIPTIONS
     `--source-dir force-app` does not match `nested/force-app/...`.
 ```
 
-_See code: [src/commands/sgd/source/delta.ts](https://github.com/scolladon/sfdx-git-delta/blob/v7.2.0/src/commands/sgd/source/delta.ts)_
+_See code: [src/commands/sgd/source/delta.ts](https://github.com/scolladon/sfdx-git-delta/blob/v7.4.0/src/commands/sgd/source/delta.ts)_
 <!-- commandsstop -->
 
 ### Windows users
@@ -230,6 +237,9 @@ In CI/CD pipelines, for most of the CI/CD providers, the checkout operation fetc
 You need to fetch all the needed commits as the plugin needs access to the branch being compared.
 Example for Github action checkout [here](https://github.com/actions/checkout#fetch-all-history-for-all-tags-and-branches).
 If you use `-n` (`--include-file`) with metadata contained inside files you will need to have the full repo locally for the command to fully work.
+With `--merge-base [-b]`, a shallow clone is an even sharper trap: `--from` and `--to` can each resolve to a valid commit while their histories still don't connect within the fetched depth, so SGD reports "no merge base found" even though the refs themselves are fine. Fetch enough history for the two branches to actually share an ancestor, not just enough for each ref to resolve.
+
+GitHub Actions' `pull_request` trigger checks out a synthetic merge commit whose parent already **is** the base branch tip, so `merge-base(HEAD, main)` resolves to `main`'s tip and `--merge-base` silently becomes a no-op (`--from main --merge-base` behaves like `--from main`). If you need true divergence semantics in that context, target the PR head commit directly — `--to <head sha>` (from the `pull_request` event payload) — or check out `ref: <head sha>` instead of the default merge ref.
 
 In CI/CD pipelines, branches are not checked out locally when the repository is cloned, so you must specify the remote prefix.
 If you do not specify the remote in CI context, the git pointer check will raise an error (as the branch is not created locally).
@@ -282,12 +292,14 @@ sf sgd source delta --to develop --from main --output-dir .
 ```
 
 - **Comparing branches (from a common ancestor)**
-  To compare the `develop` branch since its common ancestor with the `main` branch (i.e. ignoring the changes performed in the `main` branch after `develop` creation):
+  To compare the `develop` branch since its common ancestor with the `main` branch (i.e. ignoring the changes performed in the `main` branch after `develop` creation), use `--merge-base [-b]`:
 
 ```sh
-sf sgd source delta --to develop --from $(git merge-base develop main) --output-dir .
+sf sgd source delta --to develop --from main --merge-base --output-dir .
 ```
 
+This is equivalent to `git diff main...develop` (three-dot, common-ancestor semantics). Unlike the `$(git merge-base ...)` shell form, `--merge-base` resolves inside `--repo-dir` and needs no shell — the shell form always resolves in the current directory regardless of `--repo-dir`.
+
 ## Walkthrough
 
 Consider the following scenario:
@@ -609,6 +621,7 @@ import sgd from 'sfdx-git-delta'
 const work = await sgd({
   to: '', // commit sha to where the diff is done. [default : "HEAD"]
   from: '', // (required) commit sha from where the diff is done. [default : git rev-list --max-parents=0 HEAD]
+  mergeBase: false, // (required) resolve `from` to the merge base of `from`/`to` first. [default : false]
   output: '', // source package specific output. [default : "./output"]
   apiVersion: '', // salesforce API version. [default : latest]
   repo: '', // git repository location. [default : "."]

package/lib/adapter/GitAdapter.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'node:stream';
-import { type ObjectId, type Repository } from '@scolladon/tsgit';
+import { type Commit, type ObjectId, type Repository } from '@scolladon/tsgit';
 import type { Config } from '../types/config.js';
 import type { FileGitRef } from '../types/git.js';
 import type { Pathspec } from '../utils/pathspec.js';
@@ -9,24 +9,36 @@ export type DiffScopeVerdict = {
     changesSeen: number;
     linesYielded: number;
 };
+export type DiffSpec = Readonly<{
+    from: string;
+    to: string;
+    detectRenames: boolean;
+    ignoreWhitespace: boolean;
+}>;
+export type DiffRequest = Readonly<{
+    spec: DiffSpec;
+    verdict: DiffScopeVerdict;
+    scopes: readonly Pathspec[];
+}>;
 export default class GitAdapter implements GitBlobReader {
-    protected readonly config: Config;
+    private readonly key;
+    private readonly repoPath;
     private static instances;
     private static keyFor;
     static getInstance(config: Config): GitAdapter;
     static closeAll(): Promise<void>;
-    protected readonly treeIndex: Map<string, TreeIndex>;
     protected readonly blobIdIndex: Map<string, Map<string, ObjectId>>;
     private repoHandle;
     private constructor();
+    get repositoryKey(): string;
+    private mapError;
     protected getRepo(): Promise<Repository>;
     close(): Promise<void>;
-    configureRepository(): Promise<void>;
     parseRev(ref: string): Promise<string>;
-    preBuildTreeIndex(revision: string, scopePaths: string[]): Promise<void>;
+    buildTreeIndex(revision: string, scopePaths: readonly string[]): Promise<TreeIndex | undefined>;
+    protected peelToCommit(oid: ObjectId, label: string): Promise<Commit>;
     protected indexRevision(revision: string): Promise<Map<string, ObjectId>>;
-    protected pathExistsImpl(path: string, revision: string): boolean;
-    pathExists(path: string, revision?: string): Promise<boolean>;
+    getMergeBase(from: string, to: string): Promise<string | undefined>;
     getFirstCommitRef(): Promise<string>;
     protected resolveObjectId(forRef: FileGitRef): Promise<ObjectId>;
     protected readBlobBuffer(forRef: FileGitRef): Promise<Buffer>;
@@ -40,13 +52,10 @@ export default class GitAdapter implements GitBlobReader {
         stream: Readable;
     }>;
     getStringContent(forRef: FileGitRef): Promise<string>;
-    protected getFilesPathCached(path: string, revision: string): string[];
-    getFilesPath(paths: string | string[], revision?: string): Promise<string[]>;
-    listDirAtRevision(dir: string, revision: string): Promise<string[]>;
-    grepUnderPaths(pattern: string, path: string | string[], revision?: string): Promise<string[]>;
-    grepMatchingPathspecs(pattern: string, path: string | string[], revision?: string): Promise<string[]>;
+    grepUnderPaths(pattern: string, path: string | string[], revision: string): Promise<string[]>;
+    grepMatchingPathspecs(pattern: string, path: string | string[], revision: string): Promise<string[]>;
     private grepBlobs;
-    streamDiffLines(verdict: DiffScopeVerdict, scopes: readonly Pathspec[]): AsyncGenerator<string>;
+    streamDiffLines(request: DiffRequest): AsyncGenerator<string>;
     getUnmatchedSourceScopes(verdict: DiffScopeVerdict, scopes: readonly Pathspec[]): readonly string[];
     private requestDiff;
 }

package/lib/adapter/GitAdapter.js

@@ -20,7 +20,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
  *                                          (grepBlobs, shared by
  *                                          grepUnderPaths and
  *                                          grepMatchingPathspecs)
- *   git config core.*                   -> no-op (nothing to configure)
+ *   git merge-base <from> <to>          -> repo.primitives.mergeBase
  *
  * Fidelity note: grepBlobs matches content with JS RegExp semantics, not
  * POSIX basic regex. Callers are expected to pass metacharacter-free
@@ -35,14 +35,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { once } from 'node:events';
 import { createReadStream } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
-import { join } from 'node:path/posix';
+import { join, resolve } from 'node:path';
 import { PassThrough, Readable } from 'node:stream';
 import { openRepository, } from '@scolladon/tsgit';
 import { UTF8_ENCODING } from '../constant/fsConstants.js';
 import { HEAD } from '../constant/gitConstants.js';
-import { pushAll } from '../utils/arrayUtils.js';
 import { getErrorMessage } from '../utils/errorUtils.js';
-import { treatPathSep } from '../utils/fsUtils.js';
+import { sanitizePath, treatPathSep } from '../utils/fsUtils.js';
 import { getLFSObjectContentPath, isLFS } from '../utils/gitLfsHelper.js';
 import { log } from '../utils/LoggingDecorator.js';
 import { Logger, lazy } from '../utils/LoggingService.js';
@@ -66,15 +65,33 @@ const IGNORE_WHITESPACE_OPTIONS = {
 const LFS_MAGIC = Buffer.from('version https://git-lfs.github.com/spec/v1\n');
 const LFS_POINTER_CAP = 1024;
 export default class GitAdapter {
-    config;
+    key;
+    repoPath;
     static instances = new Map();
-    static keyFor(config) {
-        return `${config.repo}\0${config.to}`;
+    // Normalises the pool key the same way ConfigValidator eventually
+    // normalises config.repo (fsUtils#sanitizePath), so two configs that
+    // differ only by an unnormalised repo path (e.g. `./repo` vs `repo`)
+    // still resolve to one instance. ConfigValidator pools an adapter on the
+    // raw config.repo before _sanitizeConfig runs, so without this a single
+    // `--repo-dir ./repo` invocation would still allocate two instances.
+    // Takes the already-resolved (platform-form) path rather than resolving
+    // again, so the key and the repository path it is derived from can never
+    // drift onto two different resolutions of the same config.repo.
+    static keyFor(resolvedRepo) {
+        return sanitizePath(resolvedRepo);
     }
     static getInstance(config) {
-        const key = GitAdapter.keyFor(config);
+        // Resolved to an absolute path first: tsgit's openRepository validates
+        // `cwd` eagerly and refuses anything relative outright, which sgd's own
+        // CLI default ('./') would otherwise be. This platform-form value is
+        // threaded straight through to repository reads (see getRepo and the
+        // LFS reads below); the pool key instead takes its posix-sanitized
+        // form, since sanitizePath's separator normalisation — safe for an
+        // identity key — would corrupt a win32 UNC root if reads used it too.
+        const resolvedRepo = resolve(config.repo);
+        const key = GitAdapter.keyFor(resolvedRepo);
         if (!GitAdapter.instances.has(key)) {
-            GitAdapter.instances.set(key, new GitAdapter(config));
+            GitAdapter.instances.set(key, new GitAdapter(key, resolvedRepo));
         }
         return GitAdapter.instances.get(key);
     }
@@ -84,33 +101,73 @@ export default class GitAdapter {
         }
         GitAdapter.instances.clear();
     }
-    treeIndex;
     // Per revision: repo-relative path -> blob ObjectId. The tsgit counterpart
-    // of `git cat-file --batch` oid:path resolution.
+    // of `git cat-file --batch` oid:path resolution. Deterministic per
+    // revision and safe to share across every run against this repository —
+    // unlike the tree index (see buildTreeIndex), nothing here varies by
+    // caller-supplied scope.
     blobIdIndex;
     repoHandle = null;
-    constructor(config) {
-        this.config = config;
-        this.treeIndex = new Map();
+    // `key` identifies the repository — the pool map key and every
+    // user-facing message (mapTsgitError, the debug log below) render it, so
+    // a repository that fails the same way twice always reads identically.
+    // `repoPath` is the platform-native path actually opened and read from
+    // (openRepository's cwd, the LFS reads) — never sanitized, since
+    // sanitizePath's posix-only normalisation would corrupt a win32 UNC root.
+    constructor(key, repoPath) {
+        this.key = key;
+        this.repoPath = repoPath;
         this.blobIdIndex = new Map();
     }
+    // Read by ConfigValidator to render `error.PathIsNotGit` from the exact
+    // same absolute value this adapter renders its own repository-refusal
+    // messages from (see mapError below), so the two collapse to one sentence
+    // through validateConfig's `new Set(errors)` dedupe instead of reporting
+    // the same missing repository twice in different forms.
+    get repositoryKey() {
+        return this.key;
+    }
+    // Binds the repository argument every mapTsgitError call site needs so a
+    // transposition between it and the adjacent `context: string` argument
+    // can no longer compile — mapTsgitError itself stays a pure 3-argument
+    // function for its own unit surface.
+    mapError(error, context) {
+        return mapTsgitError(error, context, this.key);
+    }
     getRepo() {
         if (!this.repoHandle) {
-            this.repoHandle = openRepository({ cwd: this.config.repo });
+            // sgd only ever reads a repository (revParse, diff, tree walks,
+            // blobs) and never runs a verb that fires a hook or a merge driver,
+            // so both execution surfaces are switched off outright. The
+            // ownership gate is opted out of for the same reason: it would
+            // refuse the container-mounted checkouts README.md documents as
+            // supported, and tsgit cannot see the `safe.directory` those users
+            // already configured for git itself.
+            this.repoHandle = openRepository({
+                cwd: this.repoPath,
+                trust: 'always',
+                hooks: false,
+                command: false,
+            });
         }
         return this.repoHandle;
     }
     async close() {
-        if (this.repoHandle) {
-            const repo = await this.repoHandle;
+        if (!this.repoHandle)
+            return;
+        const handle = this.repoHandle;
+        // A failed open is cached like any other handle, so awaiting it here
+        // would rethrow the raw engine error out of main.ts's finally and
+        // replace the mapped error the caller already reported. There is
+        // nothing to dispose when the open never produced a repository.
+        this.repoHandle = null;
+        try {
+            const repo = await handle;
             await repo.dispose();
-            this.repoHandle = null;
         }
-    }
-    async configureRepository() {
-        // core.longpaths / core.quotepath exist to fix `git` CLI output and
-        // Windows path handling in subprocesses. tsgit reads the object store
-        // directly: nothing to configure.
+        catch (error) {
+            Logger.debug(lazy `GitAdapter.close: releasing '${this.key}' failed: ${() => getErrorMessage(error)}`);
+        }
     }
     async parseRev(ref) {
         try {
@@ -118,27 +175,48 @@ export default class GitAdapter {
             return await repo.revParse(ref);
         }
         catch (error) {
-            throw mapTsgitError(error, ref);
+            throw this.mapError(error, ref);
         }
     }
-    async preBuildTreeIndex(revision, scopePaths) {
-        if (this.treeIndex.has(revision)) {
-            return;
-        }
+    // Builds and RETURNS a tree index for (revision, scopePaths) instead of
+    // caching it: the caller (main.ts) owns the result and threads it to
+    // every reader, so a builder/reader scope mismatch becomes structurally
+    // impossible rather than a silently-missed cache key. On failure this
+    // degrades exactly like the old preBuildTreeIndex did — debug-log and
+    // return undefined, leaving the caller with no index for that revision
+    // (readers treat "no index" as an empty read, never a throw).
+    async buildTreeIndex(revision, scopePaths) {
         try {
             const blobIds = await this.indexRevision(revision);
             const index = new TreeIndex();
-            const scopes = scopePaths.filter(scope => !ROOT_PATHS.has(scope));
+            const scopes = scopePaths.filter(path => !ROOT_PATHS.has(path));
             for (const path of blobIds.keys()) {
                 if (scopes.length === 0 || inScope(path, scopes)) {
                     index.add(path);
                 }
             }
-            this.treeIndex.set(revision, index);
+            return index;
         }
         catch (error) {
-            Logger.debug(lazy `preBuildTreeIndex: tree walk for '${revision}' failed: ${() => getErrorMessage(error)}`);
+            Logger.debug(lazy `buildTreeIndex: tree walk for '${revision}' failed: ${() => getErrorMessage(error)}`);
+            return undefined;
+        }
+    }
+    // revParse returns the tag OBJECT oid for annotated tags (no auto-peel),
+    // so follow the tag chain down to the tagged commit — matching
+    // `git ls-tree -r <tag>` / `git merge-base` peeling semantics. `label`
+    // identifies the original ref/oid for the error message (it can differ
+    // from `oid` itself, e.g. a revision string vs. its resolved object id).
+    async peelToCommit(oid, label) {
+        const repo = await this.getRepo();
+        let target = await repo.primitives.readObject(oid);
+        while (target.type === 'tag') {
+            target = await repo.primitives.readObject(target.data.object);
+        }
+        if (target.type !== 'commit') {
+            throw new Error(`'${label}' does not resolve to a commit`);
         }
+        return target;
     }
     // Flattens the full tree at `revision` once and caches path -> blob oid.
     // Shared by the tree index, blob reads, archive streaming and grep.
@@ -151,17 +229,8 @@ export default class GitAdapter {
         }
         const repo = await this.getRepo();
         const revisionId = await repo.revParse(revision);
-        // revParse returns the tag OBJECT oid for annotated tags (no auto-peel),
-        // so follow the tag chain down to the tagged commit before reading its
-        // tree — matching `git ls-tree -r <tag>` semantics.
-        let target = await repo.primitives.readObject(revisionId);
-        while (target.type === 'tag') {
-            target = await repo.primitives.readObject(target.data.object);
-        }
-        if (target.type !== 'commit') {
-            throw new Error(`'${revision}' does not resolve to a commit`);
-        }
-        const { entries } = await repo.primitives.flattenTree(target.data.tree);
+        const commit = await this.peelToCommit(revisionId, revision);
+        const { entries } = await repo.primitives.flattenTree(commit.data.tree);
         const blobIds = new Map();
         for (const [path, entry] of entries) {
             if (BLOB_MODES.has(entry.mode)) {
@@ -171,16 +240,39 @@ export default class GitAdapter {
         this.blobIdIndex.set(revision, blobIds);
         return blobIds;
     }
-    pathExistsImpl(path, revision) {
-        const index = this.treeIndex.get(revision);
-        if (!index)
-            return false;
-        if (ROOT_PATHS.has(path))
-            return index.size > 0;
-        return index.hasPath(path);
-    }
-    async pathExists(path, revision = this.config.to) {
-        return this.pathExistsImpl(path, revision);
+    // Equivalent to `git merge-base <from> <to>`, resolved in-process via
+    // tsgit — no local git binary needed. `from`/`to` are resolved through
+    // revParse the same way indexRevision does, so this method is total over
+    // any revision string (ref, short SHA, `HEAD~2`, …) rather than encoding
+    // an "already an ObjectId" precondition in a comment. tsgit's `[]` result
+    // (no common ancestor / unrelated histories) is a legitimate git answer,
+    // not an exception — surfacing it as a user-facing error is the caller's
+    // job (ConfigValidator), not this adapter's.
+    async getMergeBase(from, to) {
+        try {
+            const repo = await this.getRepo();
+            const [fromId, toId] = await Promise.all([
+                repo.revParse(from),
+                repo.revParse(to),
+            ]);
+            const [fromCommit, toCommit] = await Promise.all([
+                this.peelToCommit(fromId, from),
+                this.peelToCommit(toId, to),
+            ]);
+            // Criss-cross histories can legitimately have several common
+            // ancestors; tsgit's mergeBase primitive returns all of them. Taking
+            // only the first matches `git merge-base`'s own default (without
+            // --all, which returns just one candidate), so this is a deliberate
+            // choice, not an oversight.
+            const [base] = await repo.primitives.mergeBase([
+                fromCommit.id,
+                toCommit.id,
+            ]);
+            return base;
+        }
+        catch (error) {
+            throw this.mapError(error, `${from}...${to}`);
+        }
     }
     async getFirstCommitRef() {
         try {
@@ -198,7 +290,7 @@ export default class GitAdapter {
             return firstCommit;
         }
         catch (error) {
-            throw mapTsgitError(error, HEAD);
+            throw this.mapError(error, HEAD);
         }
     }
     async resolveObjectId(forRef) {
@@ -220,12 +312,12 @@ export default class GitAdapter {
             let content = await this.readBlobBuffer(forRef);
             if (isLFS(content)) {
                 const lfsPath = getLFSObjectContentPath(content);
-                content = await readFile(join(this.config.repo, lfsPath));
+                content = await readFile(join(this.repoPath, lfsPath));
             }
             return content;
         }
         catch (error) {
-            throw mapTsgitError(error, forRef.oid);
+            throw this.mapError(error, forRef.oid);
         }
     }
     // tsgit's Blob/BlobStream carry no size field, so the only way to know a
@@ -250,7 +342,7 @@ export default class GitAdapter {
             // The pointer itself is tiny, so the accumulated-length guard above
             // never fires for LFS-backed files — size the resolved object instead
             // and escalate oversized ones onto the streaming path.
-            const lfsFile = join(this.config.repo, getLFSObjectContentPath(content));
+            const lfsFile = join(this.repoPath, getLFSObjectContentPath(content));
             const { size } = await stat(lfsFile);
             if (size > SIZE_THRESHOLD) {
                 throw new EscalateToStreamingSignal(size, forRef);
@@ -286,7 +378,7 @@ export default class GitAdapter {
     async pipeLfsObject(chunks, head, out) {
         const pointer = await accumulatePointer(chunks, head);
         const lfsPath = getLFSObjectContentPath(pointer);
-        createReadStream(join(this.config.repo, lfsPath))
+        createReadStream(join(this.repoPath, lfsPath))
             .on('error', (error) => out.destroy(error))
             .pipe(out);
     }
@@ -309,44 +401,18 @@ export default class GitAdapter {
         const content = await this.getBufferContent(forRef);
         return content.toString(UTF8_ENCODING);
     }
-    getFilesPathCached(path, revision) {
-        const index = this.treeIndex.get(revision);
-        if (!index)
-            return [];
-        if (ROOT_PATHS.has(path))
-            return index.allPaths();
-        if (index.has(path))
-            return [path];
-        return index.getFilesUnder(path);
-    }
-    async getFilesPath(paths, revision = this.config.to) {
-        if (typeof paths === 'string') {
-            return this.getFilesPathCached(paths, revision);
-        }
-        const result = [];
-        for (const path of paths) {
-            pushAll(result, this.getFilesPathCached(path, revision));
-        }
-        return result;
-    }
-    async listDirAtRevision(dir, revision) {
-        const index = this.treeIndex.get(revision);
-        if (!index)
-            return [];
-        return index.listChildren(dir);
-    }
     // Concrete-path surface: `path` comes straight off the repository (a git
     // diff path run through treatPathSep, or MetadataElement.basePath) and is
     // matched by literal directory prefix — never as a wildmatch pathspec, so
     // a metacharacter incidentally present in a real path (e.g. an object
     // folder named `Custom[1]__c`) can never be misread as a glob.
-    async grepUnderPaths(pattern, path, revision = this.config.to) {
+    async grepUnderPaths(pattern, path, revision) {
         return this.grepBlobs(pattern, path, revision, buildLiteralMatcher);
     }
     // Pattern surface: `path` is an sgd-constructed pathspec (e.g.
     // `<source>/*.translation-meta.xml`) and is matched with git pathspec
     // wildmatch semantics (literal + glob).
-    async grepMatchingPathspecs(pattern, path, revision = this.config.to) {
+    async grepMatchingPathspecs(pattern, path, revision) {
         return this.grepBlobs(pattern, path, revision, buildPathspecMatcher);
     }
     async grepBlobs(pattern, path, revision, buildMatcher) {
@@ -377,8 +443,9 @@ export default class GitAdapter {
     // behind `config.changesManifest` like the subprocess `-M`), and the
     // whitespace options drop whitespace-only modifications the way the
     // subprocess numstat path does.
-    async *streamDiffLines(verdict, scopes) {
-        const { changes } = await this.requestDiff();
+    async *streamDiffLines(request) {
+        const { spec, verdict, scopes } = request;
+        const { changes } = await this.requestDiff(spec);
         // git unions pathspecs (`-- . src` matches everything), so a root scope
         // must not be filtered out here even when non-root scopes are also
         // configured — the full, unfiltered source list is what `inScope`
@@ -401,52 +468,44 @@ export default class GitAdapter {
         if (hasRootScope(scopes))
             return [];
         const unmatchable = nonRootScopes(scopes);
+        // Stryker disable next-line ConditionalExpression,EqualityOperator -- equivalent: `.length` is never negative so `>= 0` is a tautology, and forcing this operand true only changes the ternary when unmatchable.length === 0 — in which case `unmatchable` is itself [], deep-equal to the `: []` branch it would take instead
         return unmatchable.length > 0 &&
             verdict.changesSeen > 0 &&
             verdict.linesYielded === 0
             ? unmatchable
             : [];
     }
-    async requestDiff() {
+    async requestDiff(spec) {
         try {
             const repo = await this.getRepo();
             return await repo.diff({
-                from: this.config.from,
-                to: this.config.to,
+                from: spec.from,
+                to: spec.to,
                 recursive: true,
-                detectRenames: Boolean(this.config.changesManifest),
-                ...(this.config.ignoreWhitespace ? IGNORE_WHITESPACE_OPTIONS : {}),
+                detectRenames: spec.detectRenames,
+                ...(spec.ignoreWhitespace ? IGNORE_WHITESPACE_OPTIONS : {}),
             });
         }
         catch (error) {
-            throw mapTsgitError(error, `${this.config.from}..${this.config.to}`);
+            throw this.mapError(error, `${spec.from}..${spec.to}`);
         }
     }
 }
-__decorate([
-    log
-], GitAdapter.prototype, "configureRepository", null);
 __decorate([
     log
 ], GitAdapter.prototype, "parseRev", null);
 __decorate([
     log
-], GitAdapter.prototype, "preBuildTreeIndex", null);
+], GitAdapter.prototype, "buildTreeIndex", null);
 __decorate([
     log
-], GitAdapter.prototype, "pathExists", null);
+], GitAdapter.prototype, "getMergeBase", null);
 __decorate([
     log
 ], GitAdapter.prototype, "getFirstCommitRef", null);
 __decorate([
     log
 ], GitAdapter.prototype, "getStringContent", null);
-__decorate([
-    log
-], GitAdapter.prototype, "getFilesPath", null);
-__decorate([
-    log
-], GitAdapter.prototype, "listDirAtRevision", null);
 __decorate([
     log
 ], GitAdapter.prototype, "grepUnderPaths", null);
@@ -463,14 +522,18 @@ __decorate([
 async function* normalizeChunks(source) {
     yield* source;
 }
-const isLfsPointer = (head) => head.length >= LFS_MAGIC.length &&
+const isLfsPointer = (head) => 
+// Stryker disable next-line ConditionalExpression -- equivalent: the length guard is redundant. Buffer#subarray clamps rather than throwing when the end index exceeds the buffer, and Buffer#equals is false for operands of differing length, so the comparison alone already returns false for any head shorter than the magic
+head.length >= LFS_MAGIC.length &&
     head.subarray(0, LFS_MAGIC.length).equals(LFS_MAGIC);
 const peekHead = async (chunks) => {
     const parts = [];
     let length = 0;
+    // Stryker disable next-line EqualityOperator -- equivalent: `<=` only shifts where the peek stops versus what the caller's remaining-chunk iteration picks up; the same total bytes reach forwardChunks/accumulatePointer either way, so the streamed output is byte-identical
     while (length < LFS_MAGIC.length) {
         const result = await chunks.next();
         if (result.done) {
+            // Stryker disable next-line BooleanLiteral -- equivalent: `exhausted` only gates whether forwardChunks re-enters a `for await` over the generator, and per the async-generator protocol a generator that has returned done keeps returning done — so re-entering when already exhausted is a guaranteed zero-iteration no-op
             return { head: Buffer.concat(parts, length), exhausted: true };
         }
         parts.push(result.value);
@@ -484,9 +547,11 @@ const writeChunk = async (out, chunk) => {
     }
 };
 const forwardChunks = async (chunks, out, head, exhausted) => {
+    // Stryker disable next-line ConditionalExpression,EqualityOperator -- equivalent: writing a zero-length Buffer to a PassThrough is a no-op (no 'data' event, readableLength/writableLength unchanged, write() returns true), so calling writeChunk unconditionally when head is empty is indistinguishable from skipping it
     if (head.length > 0) {
         await writeChunk(out, head);
     }
+    // Stryker disable next-line ConditionalExpression -- equivalent: same reasoning as the `exhausted: true` return in peekHead — entering this loop on an already-exhausted generator iterates zero times
     if (!exhausted) {
         for await (const chunk of chunks) {
             await writeChunk(out, chunk);