sfdx-git-delta 7.0.1 → 7.1.0

package/lib/adapter/GitAdapter.js

@@ -4,32 +4,64 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-import { spawn } from 'node:child_process';
+/*
+ * In-process git backend for sfdx-git-delta, backed by `@scolladon/tsgit`
+ * (zero-dependency, no `git` binary, no subprocess). Object-store reads,
+ * diffs, tree walks and blob content all go through the tsgit facade:
+ *
+ *   git rev-parse --verify <ref>        -> repo.revParse(ref)
+ *   git ls-tree --name-only -r <rev>    -> repo.primitives.flattenTree
+ *   git rev-list --max-parents=0 HEAD   -> repo.primitives.walkCommits
+ *   git cat-file --batch / blob         -> repo.primitives.readBlob / streamBlob
+ *   git diff --name-status -M -w        -> repo.diff({ recursive,
+ *                                            detectRenames, ignoreWhitespace })
+ *   git archive --format=tar            -> tree walk + streamBlob
+ *   git grep -l                         -> tree walk + readBlob + RegExp
+ *   git config core.*                   -> no-op (nothing to configure)
+ *
+ * Fidelity note: gitGrep matches with JS RegExp semantics, not POSIX basic
+ * regex. Callers are expected to pass metacharacter-free literals so the two
+ * semantics agree; the known pattern set is pinned by
+ * gitGrepPatternInventory.test.ts (new callers must extend that inventory).
+ */
+import { once } from 'node:events';
 import { createReadStream } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path/posix';
-import { createInterface } from 'node:readline';
-import { PassThrough } from 'node:stream';
+import { PassThrough, Readable } from 'node:stream';
+import { openRepository, toSimilarityPercent, } from '@scolladon/tsgit';
 import { TAB } from '../constant/cliConstants.js';
 import { UTF8_ENCODING } from '../constant/fsConstants.js';
-import { ADDITION, DELETION, HEAD, IGNORE_WHITESPACE_PARAMS, MODIFICATION, NUM_STAT_CHANGE_INFORMATION, RENAMED, } from '../constant/gitConstants.js';
+import { ADDITION, DELETION, HEAD, MODIFICATION, RENAMED, } from '../constant/gitConstants.js';
 import { pushAll } from '../utils/arrayUtils.js';
 import { getErrorMessage } from '../utils/errorUtils.js';
 import { 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';
-import { GitBatchCatFile } from './gitBatchCatFile.js';
+import { EscalateToStreamingSignal, SIZE_THRESHOLD, } from './gitBlobReader.js';
 import { TreeIndex } from './treeIndex.js';
-const LFS_MAGIC = Buffer.from('version https://git-lfs.github.com/spec/v1\n');
-const EOL = /\r?\n/;
+import { mapTsgitError } from './tsgitErrorMap.js';
 const ROOT_PATHS = new Set(['', '.', './']);
+// walkTree yields directories and gitlinks too; only blob-bearing modes
+// belong in the path -> blob id index (ls-tree -r parity).
+const BLOB_MODES = new Set(['100644', '100755', '120000']);
+const GITLINK_MODE = '160000';
+// Maps sgd's whitespace-ignoring diff request onto tsgit's data-mode
+// whitespace knobs: whitespace-only modifications drop out of the TreeDiff.
+const IGNORE_WHITESPACE_OPTIONS = {
+    ignoreWhitespace: 'all',
+    ignoreBlankLines: true,
+};
+// Streaming LFS-pointer detection for streamContent: the literal magic
+// prefix released LFS pointer files start with, and a generous upper
+// bound on pointer body size (real pointers are ~130 bytes; this guards
+// against a corrupt/oversized "pointer" masquerading as one).
+const LFS_MAGIC = Buffer.from('version https://git-lfs.github.com/spec/v1\n');
+const LFS_POINTER_CAP = 1024;
 export default class GitAdapter {
     config;
     static instances = new Map();
-    // Keyed by repo+to so spread copies of the same config (e.g. ioExecutor's
-    // per-revision {...config, to: rev}) share one adapter instead of spawning
-    // a fresh git cat-file subprocess per call.
     static keyFor(config) {
         return `${config.repo}\0${config.to}`;
     }
@@ -40,198 +72,98 @@ export default class GitAdapter {
         }
         return GitAdapter.instances.get(key);
     }
+    static async closeAll() {
+        for (const instance of GitAdapter.instances.values()) {
+            await instance.close();
+        }
+        GitAdapter.instances.clear();
+    }
     treeIndex;
-    batchCatFile = null;
-    // Live-only list of streaming subprocesses: children are appended when
-    // spawned and spliced on `close` so long-running invocations don't
-    // accumulate dead process references. Iterated at closeAll() teardown and
-    // kill()ed if still alive.
-    streamingChildren = [];
-    // Cap on stderr buffered per-subprocess: long-running git processes that
-    // emit progress to stderr would otherwise grow this without bound. The
-    // final error message truncates at this size.
-    static STDERR_BUFFER_CAP = 8 * 1024;
-    // Cap on LFS pointer buffering: real pointers are < 200 bytes; a crafted
-    // blob with the LFS magic prefix followed by gigabytes of content should
-    // not OOM the process before validation fails.
-    static LFS_POINTER_CAP = 1024;
-    spawnFn = spawn;
+    // Per revision: repo-relative path -> blob ObjectId. The tsgit counterpart
+    // of `git cat-file --batch` oid:path resolution.
+    blobIdIndex;
+    repoHandle = null;
     constructor(config) {
         this.config = config;
         this.treeIndex = new Map();
+        this.blobIdIndex = new Map();
     }
-    /**
-     * Testability seam: lets unit tests swap in a fake spawn for streaming
-     * subprocesses. Production always uses `child_process.spawn`.
-     */
-    setSpawnFn(spawnFn) {
-        this.spawnFn = spawnFn;
-    }
-    getBatchCatFile() {
-        if (!this.batchCatFile) {
-            this.batchCatFile = new GitBatchCatFile(this.config.repo, {
-                spawnFn: this.spawnFn,
-            });
+    getRepo() {
+        if (!this.repoHandle) {
+            this.repoHandle = openRepository({ cwd: this.config.repo });
         }
-        return this.batchCatFile;
+        return this.repoHandle;
     }
-    closeBatchProcess() {
-        this.batchCatFile?.close();
-        this.batchCatFile = null;
-        for (const child of this.streamingChildren) {
-            if (child.exitCode === null && !child.killed) {
-                child.kill();
-            }
+    async close() {
+        if (this.repoHandle) {
+            const repo = await this.repoHandle;
+            await repo.dispose();
+            this.repoHandle = null;
         }
-        this.streamingChildren.length = 0;
-    }
-    static closeAll() {
-        for (const instance of GitAdapter.instances.values()) {
-            instance.closeBatchProcess();
-        }
-        GitAdapter.instances.clear();
     }
     async configureRepository() {
-        await this._gitBuffered(['config', 'core.longpaths', 'true']);
-        await this._gitBuffered(['config', 'core.quotepath', 'off']);
+        // 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.
     }
     async parseRev(ref) {
-        return await this._gitBuffered(['rev-parse', '--verify', ref]);
+        try {
+            const repo = await this.getRepo();
+            return await repo.revParse(ref);
+        }
+        catch (error) {
+            throw mapTsgitError(error, ref);
+        }
     }
     async preBuildTreeIndex(revision, scopePaths) {
         if (this.treeIndex.has(revision)) {
             return;
         }
         try {
-            const args = ['ls-tree', '--name-only', '-r', revision];
-            if (scopePaths.length > 0) {
-                args.push('--', ...scopePaths);
-            }
+            const blobIds = await this.indexRevision(revision);
             const index = new TreeIndex();
-            for await (const line of this._spawnLines(args)) {
-                if (line)
-                    index.add(treatPathSep(line));
+            const scopes = scopePaths.filter(scope => !ROOT_PATHS.has(scope));
+            for (const path of blobIds.keys()) {
+                if (scopes.length === 0 || inScope(path, scopes)) {
+                    index.add(path);
+                }
             }
             this.treeIndex.set(revision, index);
         }
         catch (error) {
-            // Stryker disable next-line BlockStatement -- equivalent: catch body is observability-only; emptying the body skips the lazy log but tests assert that treeIndex is missing the revision (the swallowed throw is the contract)
-            Logger.debug(
-            // Stryker disable next-line StringLiteral,ArrowFunction -- equivalent: lazy log content is observability only; tests don't assert on the lazy log line
-            lazy `preBuildTreeIndex: scoped ls-tree for '${revision}' failed: ${() => getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Spawns `git <args>`, streams stdout through a readline interface, and
-     * yields one line at a time. Replaces the old "run command, split on EOL"
-     * pattern that accumulated a multi-MB string for megarepo diffs / tree
-     * listings before any downstream consumer ran.
-     *
-     * The spawned child is pushed into streamingChildren so closeAll()
-     * kills it if teardown happens mid-stream. stderr is drained to the
-     * debug log; a non-zero exit code rejects the iterator on next read.
-     */
-    async *_spawnLines(args) {
-        // Stryker disable ObjectLiteral,ArrayDeclaration,StringLiteral -- equivalent: spawn options are Node.js child_process internals; tests stub spawnFn and assert on yielded lines, not on the option object passed through to the spawn
-        const child = this.spawnFn('git', args, {
-            cwd: this.config.repo,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        // Stryker restore ObjectLiteral,ArrayDeclaration,StringLiteral
-        this._trackChild(child);
-        const stderrChunks = [];
-        let stderrLen = 0;
-        child.stderr.on('data', (chunk) => {
-            // Stryker disable next-line ConditionalExpression,EqualityOperator -- equivalent: stderr buffer cap guard; the test surface only checks the truncated error message at exit so >= vs > and the threshold flip are unobservable
-            if (stderrLen >= GitAdapter.STDERR_BUFFER_CAP)
-                return;
-            stderrChunks.push(chunk);
-            // Stryker disable next-line AssignmentOperator -- equivalent: same rationale — stderr cap accumulator; -= would underflow but no test feeds >cap stderr to observe
-            stderrLen += chunk.length;
-        });
-        const rl = createInterface({
-            input: child.stdout,
-            crlfDelay: Number.POSITIVE_INFINITY,
-        });
-        const exitPromise = new Promise((resolve, reject) => {
-            // Stryker disable next-line StringLiteral -- equivalent: 'error' and 'close' are EventEmitter event names; tests stub child.once with a fake EE that observes only the contract via the resolve/reject side-effect, not the literal name
-            child.once('error', reject);
-            child.once('close', resolve);
-        });
-        try {
-            for await (const line of rl) {
-                yield line;
-            }
-            const code = await exitPromise;
-            if (code !== 0 && code !== null) {
-                throw this._buildExitError(args, code, stderrChunks);
+            Logger.debug(lazy `preBuildTreeIndex: tree walk for '${revision}' failed: ${() => getErrorMessage(error)}`);
+        }
+    }
+    // Flattens the full tree at `revision` once and caches path -> blob oid.
+    // Shared by the tree index, blob reads, archive streaming and grep.
+    // flattenTree is the bulk traversal path (one call, no per-entry yields);
+    // it takes a tree oid, so the commit is peeled first.
+    async indexRevision(revision) {
+        const cached = this.blobIdIndex.get(revision);
+        if (cached) {
+            return cached;
+        }
+        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 blobIds = new Map();
+        for (const [path, entry] of entries) {
+            if (BLOB_MODES.has(entry.mode)) {
+                blobIds.set(treatPathSep(path), entry.id);
             }
         }
-        finally {
-            rl.close();
-            // Stryker disable next-line ConditionalExpression,LogicalOperator,EqualityOperator -- equivalent: this is a defensive cleanup gate; in unit tests the spawned child mock has already exited cleanly by the time the finally runs, so the guard's truth value is irrelevant — child.kill() on an already-exited child is a no-op
-            if (!child.killed && child.exitCode === null)
-                child.kill();
-        }
-    }
-    /**
-     * One-shot buffered git invocation. Spawns `git <args>`, drains stdout
-     * fully, and returns the trimmed UTF-8 string. Used by callers that
-     * need the complete output as a single string (revparse, raw-style
-     * commands, config writes) rather than a line-by-line stream.
-     *
-     * Mirrors _spawnLines' exit-code handling: non-zero exits throw with
-     * the stderr tail (capped at STDERR_BUFFER_CAP) in the message. Output
-     * is trimmed so callers receive the same shape they used to get from
-     * the legacy `simpleGit({ trimmed: true })` configuration.
-     */
-    async _gitBuffered(args) {
-        const child = this.spawnFn('git', args, {
-            cwd: this.config.repo,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        this._trackChild(child);
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        let stderrLen = 0;
-        child.stdout.on('data', (chunk) => {
-            stdoutChunks.push(chunk);
-        });
-        child.stderr.on('data', (chunk) => {
-            if (stderrLen >= GitAdapter.STDERR_BUFFER_CAP)
-                return;
-            stderrChunks.push(chunk);
-            stderrLen += chunk.length;
-        });
-        const code = await new Promise((resolve, reject) => {
-            child.once('error', reject);
-            child.once('close', resolve);
-        });
-        if (code !== 0 && code !== null) {
-            throw this._buildExitError(args, code, stderrChunks);
-        }
-        return Buffer.concat(stdoutChunks).toString('utf8').trim();
-    }
-    // Shared by _spawnLines and _gitBuffered: build the rejection thrown when
-    // git exits with a non-zero, non-null code. Captures the stderr tail
-    // (capped at STDERR_BUFFER_CAP) into the message for diagnostics.
-    _buildExitError(args, code, stderrChunks) {
-        // Stryker disable next-line MethodExpression -- equivalent: trim() strips trailing newlines from git stderr; tests synthesise stderr without trailing whitespace
-        const stderr = Buffer.concat(stderrChunks)
-            .subarray(0, GitAdapter.STDERR_BUFFER_CAP)
-            .toString('utf8')
-            .trim();
-        return new Error(`git ${args[0]} exited ${code}${stderr ? `: ${stderr}` : ''}`);
-    }
-    _trackChild(child) {
-        this.streamingChildren.push(child);
-        child.once('close', () => {
-            const idx = this.streamingChildren.indexOf(child);
-            // Stryker disable next-line ConditionalExpression,UnaryOperator -- equivalent: see v8 ignore — idx is always !== -1 because the just-pushed child is still in the array; the guard is a defensive safety net
-            /* v8 ignore next -- defensive: the close listener is once-only and bound to the tracked child; idx is always >= 0 here */
-            if (idx !== -1)
-                this.streamingChildren.splice(idx, 1);
-        });
+        this.blobIdIndex.set(revision, blobIds);
+        return blobIds;
     }
     pathExistsImpl(path, revision) {
         const index = this.treeIndex.get(revision);
@@ -245,197 +177,129 @@ export default class GitAdapter {
         return this.pathExistsImpl(path, revision);
     }
     async getFirstCommitRef() {
-        return await this._gitBuffered(['rev-list', '--max-parents=0', HEAD]);
-    }
-    async getBufferContent(forRef) {
-        let content = await this.getBatchCatFile().getContent(forRef.oid, forRef.path);
-        if (isLFS(content)) {
-            const lfsPath = getLFSObjectContentPath(content);
-            content = await readFile(join(this.config.repo, lfsPath));
+        try {
+            const repo = await this.getRepo();
+            const head = await repo.revParse(HEAD);
+            let firstCommit = head;
+            for await (const commit of repo.primitives.walkCommits({
+                from: [head],
+            })) {
+                if (commit.data.parents.length === 0) {
+                    firstCommit = commit.id;
+                    break;
+                }
+            }
+            return firstCommit;
+        }
+        catch (error) {
+            throw mapTsgitError(error, HEAD);
         }
-        return content;
     }
-    async getBufferContentOrEscalate(forRef) {
-        let content = await this.getBatchCatFile().getContentOrEscalate(forRef.oid, forRef.path);
-        if (isLFS(content)) {
-            const lfsPath = getLFSObjectContentPath(content);
-            content = await readFile(join(this.config.repo, lfsPath));
+    async resolveObjectId(forRef) {
+        const blobIds = await this.indexRevision(forRef.oid);
+        const blobId = blobIds.get(treatPathSep(forRef.path));
+        if (!blobId) {
+            throw new Error(`Path '${forRef.path}' not found at '${forRef.oid}'`);
         }
-        return content;
+        return blobId;
     }
-    /**
-     * Streams a directory from `revision` as `git archive --format=tar`
-     * entries. Yields `{ path, stream }` per file entry (directories are
-     * skipped). The tar subprocess is registered in streamingChildren so
-     * closeAll kills it on teardown.
-     *
-     * Callers MUST consume each entry's stream — even when skipping the
-     * entry — otherwise tar-stream back-pressures and halts parsing. For
-     * skip cases use `stream.resume()` to drain-and-discard.
-     */
-    async *streamArchive(path, revision) {
-        if (path.startsWith('-') || revision.startsWith('-')) {
-            throw new Error(`Refusing to spawn git archive for ${path}`);
-        }
-        const { extract } = await import('tar-stream');
-        const extractor = extract();
-        const child = this.spawnFn('git', ['archive', '--format=tar', revision, '--', path], { cwd: this.config.repo, stdio: ['ignore', 'pipe', 'pipe'] });
-        this._trackChild(child);
-        // Stryker disable next-line ArrowFunction -- equivalent: the arrow forwards the spawn error onto the tar-stream extractor; the unit tests assert the extractor's downstream destroy effect, not that the arrow is the literal forwarder
-        child.on('error', err => extractor.destroy(err));
-        // Stryker disable BlockStatement,StringLiteral,ArrowFunction -- equivalent: stderr listener is observability-only; tests assert the iterator yields/terminates, not on the lazy log line
-        child.stderr.on('data', (chunk) => {
-            Logger.debug(lazy `streamArchive stderr for ${path}@${revision}: ${() => chunk.toString()}`);
-        });
-        // Stryker restore BlockStatement,StringLiteral,ArrowFunction
-        child.stdout.pipe(extractor);
+    async readBlobBuffer(forRef) {
+        const repo = await this.getRepo();
+        const blobId = await this.resolveObjectId(forRef);
+        const blob = await repo.primitives.readBlob(blobId);
+        return Buffer.from(blob.content);
+    }
+    async getBufferContent(forRef) {
         try {
-            for await (const entry of extractor) {
-                if (entry.header.type !== 'file') {
-                    entry.resume();
-                    continue;
-                }
-                yield { path: entry.header.name, stream: entry };
+            let content = await this.readBlobBuffer(forRef);
+            if (isLFS(content)) {
+                const lfsPath = getLFSObjectContentPath(content);
+                content = await readFile(join(this.config.repo, lfsPath));
+            }
+            return content;
+        }
+        catch (error) {
+            throw mapTsgitError(error, forRef.oid);
+        }
+    }
+    // tsgit's Blob/BlobStream carry no size field, so the only way to know a
+    // blob is oversized is to accumulate streamBlob chunks and watch the
+    // running total: crossing SIZE_THRESHOLD escalates the caller onto the
+    // dedicated streamContent path instead of materializing further.
+    async getBufferContentOrEscalate(forRef) {
+        const repo = await this.getRepo();
+        const blobId = await this.resolveObjectId(forRef);
+        const blobStream = await repo.primitives.streamBlob(blobId);
+        const parts = [];
+        let length = 0;
+        for await (const chunk of blobStream) {
+            parts.push(chunk);
+            length += chunk.length;
+            if (length > SIZE_THRESHOLD) {
+                throw new EscalateToStreamingSignal(length, forRef);
             }
         }
-        finally {
-            // Stryker disable next-line BlockStatement -- equivalent: finally body is reached only when iteration completes/throws; the test surface drains the iterator cleanly so the conditional inside is a no-op (child already exited), and emptying the body skips the no-op kill
-            // Stryker disable next-line ConditionalExpression -- equivalent: defensive cleanup guard; tests stub child to exit cleanly before reaching this gate, so the kill is a no-op either way
-            if (!child.killed && child.exitCode === null)
-                child.kill();
+        let content = Buffer.concat(parts, length);
+        if (isLFS(content)) {
+            // 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 { size } = await stat(lfsFile);
+            if (size > SIZE_THRESHOLD) {
+                throw new EscalateToStreamingSignal(size, forRef);
+            }
+            content = await readFile(lfsFile);
         }
+        return content;
     }
-    /**
-     * Spawns a dedicated `git cat-file blob <oid>` subprocess and returns a
-     * Readable that peeks the first chunks for LFS pointer magic. On match,
-     * the spawned subprocess is killed and the Readable is fed from the
-     * resolved LFS object file. Otherwise bytes are forwarded as-is.
-     */
+    // Peeks the first LFS_MAGIC.length bytes off the pull-based streamBlob
+    // iterator: a match hands off to the resolved LFS object file, otherwise
+    // the peeked head and every remaining chunk are forwarded as-is. Backed
+    // by the async iterator's own pull semantics, so no pause/resume is
+    // needed to respect backpressure — only out.write()'s own signal.
     streamContent(forRef) {
         const out = new PassThrough();
-        // Defense in depth: `git cat-file blob <ref>` treats a ref starting
-        // with `-` as an option. Refs come from git diff output so this
-        // shouldn't happen in normal operation, but a malicious diff or a
-        // path with a leading dash would give git an option it respects.
-        // Fail fast with a clear error rather than trust the subprocess.
-        if (forRef.path.startsWith('-') || forRef.oid.startsWith('-')) {
-            process.nextTick(() => out.destroy(new Error(`Refusing to spawn git cat-file for ${forRef.path}`)));
-            return out;
-        }
-        const child = this.spawnFn('git', ['cat-file', 'blob', `${forRef.oid}:${forRef.path}`], { cwd: this.config.repo, stdio: ['ignore', 'pipe', 'pipe'] });
-        this._trackChild(child);
-        this._wireStreamContent(child, out, forRef);
+        this.pipeBlobContent(forRef, out).catch((error) => {
+            out.destroy(error instanceof Error ? error : new Error(getErrorMessage(error)));
+        });
         return out;
     }
-    _wireStreamContent(child, out, forRef) {
-        let peeked = [];
-        let peekedLen = 0;
-        let decided = false;
-        const forwardPeeked = () => {
-            const head = Buffer.concat(peeked, peekedLen);
-            // Stryker disable next-line ArrayDeclaration -- equivalent: the assignment resets the peek buffer; an injected initial element is overwritten on the next push and the head buffer is already concat'd above
-            peeked = [];
-            peekedLen = 0;
-            return head;
-        };
-        const onChunk = (chunk) => {
-            if (decided) {
-                // Stryker disable next-line BooleanLiteral -- equivalent: see v8 ignore — backpressure pause is rarely triggered in unit tests, and the drain listener resumes either way
-                /* v8 ignore next -- defensive: PassThrough rarely returns false here; backpressure handled at write time, drain listener resumes */
-                if (!out.write(chunk))
-                    child.stdout.pause();
-                return;
-            }
-            peeked.push(chunk);
-            peekedLen += chunk.length;
-            // Stryker disable next-line ConditionalExpression -- equivalent: the LFS_MAGIC.length threshold gates the peek-vs-decide flow; the test surface verifies LFS handoff via a chunk >= LFS_MAGIC bytes, so the < flip path is exercised but the false-branch only changes whether the next chunk runs through here vs adds another peek; downstream contract is unchanged
-            if (peekedLen < LFS_MAGIC.length)
-                return;
-            // Stryker disable next-line BooleanLiteral -- equivalent: `decided` is local state; the next event loop tick reads it as true regardless of the literal we set, because the function returns immediately after the magic check
-            decided = true;
-            const head = forwardPeeked();
-            if (head.subarray(0, LFS_MAGIC.length).equals(LFS_MAGIC)) {
-                this._handoffToLfs(child, out, head);
-                return;
-            }
-            // Stryker disable next-line BooleanLiteral -- equivalent: see v8 ignore — pause is rarely triggered in tests
-            /* v8 ignore next -- defensive: PassThrough rarely returns false here; backpressure handled at write time, drain listener resumes */
-            if (!out.write(head))
-                child.stdout.pause();
-        };
-        child.stdout.on('data', onChunk);
-        // Stryker disable next-line StringLiteral,ArrowFunction -- equivalent: 'drain' event name and the resume-on-drain callback are EventEmitter wiring; the test contract verifies that forwarded bytes land on `out`, not the literal event name
-        out.on('drain', () => child.stdout.resume());
-        child.stdout.on('end', () => {
-            // Stryker disable next-line LogicalOperator,ConditionalExpression,EqualityOperator -- equivalent: this is the flush gate for peeked bytes that never reached LFS_MAGIC.length; tests exercise the gate by feeding a sub-magic stream, so the && arm is covered, but the OR-mutated short-circuit produces the same downstream out.write() call
-            if (!decided && peekedLen > 0) {
-                out.write(forwardPeeked());
-            }
-            // Stryker disable next-line ConditionalExpression -- equivalent: see v8 ignore — second arm always true after flush
-            /* v8 ignore next -- defensive: forwardPeeked above zeroes peekedLen, so the second arm always evaluates true after a flush */
-            if (decided || peekedLen === 0)
-                out.end();
-        });
-        // Stryker disable BlockStatement,StringLiteral,ArrowFunction -- equivalent: stderr listener is observability-only; tests assert that the consumer sees the streamed content, not on the lazy log line
-        child.stderr.on('data', (chunk) => {
-            Logger.debug(lazy `streamContent stderr for ${forRef.path}: ${() => chunk.toString()}`);
-        });
-        // Stryker restore BlockStatement,StringLiteral,ArrowFunction
-        child.on('error', err => out.destroy(err));
-        child.on('close', code => {
-            // Intentional kills during LFS handoff close with a null/non-zero
-            // code; destroying `out` here would truncate the piped LFS stream
-            // the handoff just started.
-            // Stryker disable next-line ConditionalExpression -- equivalent: this 4-arm guard rejects only the (non-zero, non-null, non-killed, non-destroyed) corner; unit tests stub close with code=0 so the guard short-circuits regardless of mutation, leaving out destinations unaffected
-            if (code !== 0 && code !== null && !child.killed && !out.destroyed) {
-                out.destroy(new Error(`git cat-file blob exited ${code}`));
-            }
-        });
+    async pipeBlobContent(forRef, out) {
+        const repo = await this.getRepo();
+        const blobId = await this.resolveObjectId(forRef);
+        const blobStream = await repo.primitives.streamBlob(blobId);
+        const chunks = normalizeChunks(blobStream);
+        const { head, exhausted } = await peekHead(chunks);
+        if (isLfsPointer(head)) {
+            await this.pipeLfsObject(chunks, head, out);
+            return;
+        }
+        await forwardChunks(chunks, out, head, exhausted);
     }
-    _handoffToLfs(child, out, head) {
-        const pointerParts = [head];
-        let pointerLen = head.length;
-        let aborted = false;
-        // Replace both data and end listeners from _wireStreamContent: the
-        // original end listener calls out.end() when decided===true, which would
-        // close `out` before the LFS file stream begins piping into it and the
-        // consumer would receive an empty/truncated payload.
-        child.stdout.removeAllListeners('data');
-        child.stdout.removeAllListeners('end');
-        child.stdout.on('data', (c) => {
-            // Stryker disable next-line ConditionalExpression -- equivalent: re-entry guard for chunks arriving after abort triggered out.destroy(); tests don't fire a multi-chunk abort sequence so the false-flip is unobservable
-            if (aborted)
-                return;
-            pointerParts.push(c);
-            pointerLen += c.length;
-            // Stryker disable next-line ConditionalExpression -- equivalent: LFS pointer cap guard; unit tests fixture LFS pointers under the cap (real pointers are <200 bytes, cap is 1024), so the > flip path is unobservable
-            if (pointerLen > GitAdapter.LFS_POINTER_CAP) {
-                aborted = true;
-                out.destroy(new Error('LFS pointer exceeds expected size'));
-            }
-        });
-        child.stdout.on('end', () => {
-            if (aborted)
-                return;
-            try {
-                const pointer = Buffer.concat(pointerParts, pointerLen);
-                const lfsPath = getLFSObjectContentPath(pointer);
-                // Stryker disable next-line ConditionalExpression -- equivalent: this is a Readable.on('error') wiring that propagates ENOENT/permission errors during the LFS file read; unit tests fixture an existing LFS file so the error listener never fires
-                createReadStream(join(this.config.repo, lfsPath))
-                    .on('error', err => out.destroy(err))
-                    .pipe(out);
-            }
-            catch (err) {
-                /* v8 ignore next -- defensive: getLFSObjectContentPath / createReadStream throw Error instances in practice; the String() fallback exists for non-Error throws */
-                out.destroy(err instanceof Error ? err : new Error(String(err)));
-            }
-        });
-        // Stryker disable next-line ConditionalExpression -- equivalent: see v8 ignore — child is always alive here
-        /* v8 ignore next -- defensive: _handoffToLfs is reached after the first peek; the child is alive at this point */
-        if (!child.killed)
-            child.kill();
+    async pipeLfsObject(chunks, head, out) {
+        const pointer = await accumulatePointer(chunks, head);
+        const lfsPath = getLFSObjectContentPath(pointer);
+        createReadStream(join(this.config.repo, lfsPath))
+            .on('error', (error) => out.destroy(error))
+            .pipe(out);
+    }
+    async *streamArchive(path, revision) {
+        const repo = await this.getRepo();
+        const blobIds = await this.indexRevision(revision);
+        for (const [filePath, blobId] of blobIds) {
+            if (!inScope(filePath, [path]))
+                continue;
+            const blob = await repo.primitives.streamBlob(blobId);
+            yield {
+                path: filePath,
+                stream: Readable.from(blob, { objectMode: false }),
+            };
+        }
     }
     async getStringContent(forRef) {
+        // getBufferContent already maps raw tsgit errors — mapping exactly once
+        // keeps the released error shapes intact (no double-wrapped messages).
         const content = await this.getBufferContent(forRef);
         return content.toString(UTF8_ENCODING);
     }
@@ -445,7 +309,6 @@ export default class GitAdapter {
             return [];
         if (ROOT_PATHS.has(path))
             return index.allPaths();
-        // Stryker disable next-line ConditionalExpression -- equivalent: file-vs-dir fast path; flipping to false routes file paths through getFilesUnder which returns the same single-element array because the trie navigation lands on the file node
         if (index.has(path))
             return [path];
         return index.getFilesUnder(path);
@@ -468,147 +331,53 @@ export default class GitAdapter {
     }
     async gitGrep(pattern, path, revision = this.config.to) {
         try {
+            const repo = await this.getRepo();
             const paths = Array.isArray(path) ? path : [path];
-            const result = await this._gitBuffered([
-                'grep',
-                '-l',
-                pattern,
-                revision,
-                '--',
-                ...paths,
-            ]);
-            return result
-                .split(EOL)
-                .filter(line => line)
-                .map(line => treatPathSep(line.slice(line.indexOf(':') + 1)));
+            const blobIds = await this.indexRevision(revision);
+            const matcher = new RegExp(pattern);
+            const matchesPathspec = buildPathspecMatcher(paths);
+            const matches = [];
+            for (const [filePath, blobId] of blobIds) {
+                if (!matchesPathspec(filePath))
+                    continue;
+                const blob = await repo.primitives.readBlob(blobId);
+                if (matcher.test(Buffer.from(blob.content).toString(UTF8_ENCODING))) {
+                    matches.push(filePath);
+                }
+            }
+            return matches;
         }
         catch (error) {
-            // Stryker disable next-line StringLiteral,ArrowFunction -- equivalent: catch is observability-only; tests assert on the empty-array return, not the lazy log line
-            Logger.debug(
-            // Stryker disable next-line StringLiteral,ArrowFunction -- equivalent: lazy log content is observability only
-            lazy `gitGrep: grep for '${pattern}' in '${path}' at '${revision}' failed: ${() => getErrorMessage(error)}`);
+            Logger.debug(lazy `gitGrep: grep for '${pattern}' in '${path}' at '${revision}' failed: ${() => getErrorMessage(error)}`);
             return [];
         }
     }
-    // Fast path (no whitespace ignore): one `git diff --name-status` call.
-    // Rename detection (`-M` + `R` filter) is gated behind
-    // `config.changesManifest` so the default sgd pipeline emits the same
-    // A/M/D line shape as before this feature. When enabled, renames surface
-    // as `R<score>\tfrom\tto` lines that RepoGitDiff splits into synthetic
-    // A/D while recording the rename pair for ChangeSet.
-    //
-    // Whitespace path: three (or four, when rename detection is on) parallel
-    // `git diff --numstat` calls, one per --diff-filter. `--name-status` does
-    // NOT honor `--ignore-all-space` (git decides A/M/D from blob SHAs for
-    // that mode, so a whitespace-only change still appears as `M`). Only
-    // `--numstat` computes a real content diff under the whitespace flags,
-    // so files with 0/0 line changes drop out naturally. When rename
-    // detection is enabled the R call uses `-z` so it can sidestep numstat's
-    // brace/arrow rename-path encoding.
-    //
-    // The Promise.all fans out to 4 items with rename detection on. That's a
-    // localised exception to the CLAUDE.local.md ≤3 bounded-Promise.all
-    // guideline: the four `--diff-filter`s are the canonical per-kind split,
-    // so hiding R as an out-of-band sequential await just obscures the real
-    // symmetric fan-out without changing the resource footprint.
+    // One facade diff call carries the whole subprocess contract: `recursive`
+    // is `git diff -r`, `detectRenames` is `-M` (similarity-based, gated
+    // behind `config.changesManifest` like the subprocess `-M`), and the
+    // whitespace options drop whitespace-only modifications the way the
+    // subprocess numstat path does.
     async *streamDiffLines() {
-        const detectRenames = Boolean(this.config.changesManifest);
-        if (!this.config.ignoreWhitespace) {
-            const args = [
-                'diff',
-                '--name-status',
-                ...(detectRenames ? ['-M'] : ['--no-renames']),
-                `--diff-filter=${detectRenames ? 'AMDR' : 'AMD'}`,
-                this.config.from,
-                this.config.to,
-                '--',
-                ...this.config.source,
-            ];
-            for await (const line of this._spawnLines(args)) {
-                if (line)
-                    yield treatPathSep(line);
-            }
-            return;
-        }
-        // When rename detection is on, the A/M/D filters also run with -M so
-        // renamed files drop out (reclassified to R by git), and the dedicated
-        // R call is the single source of rename lines — no dedup needed.
-        // Without rename detection, A/M/D keep their pre-feature line shape via
-        // --no-renames.
-        const filters = detectRenames
-            ? [ADDITION, MODIFICATION, DELETION, RENAMED]
-            : [ADDITION, MODIFICATION, DELETION];
-        // Numstat path runs one git invocation per change-type; we still emit
-        // each batch as it lands so downstream filters can begin work before
-        // every filter has finished.
-        for (const changeType of filters) {
-            for (const line of await this._getNumstatLines(changeType, detectRenames)) {
-                yield line;
-            }
+        const { changes } = await this.requestDiff();
+        const scopes = this.config.source.filter(scope => !ROOT_PATHS.has(scope));
+        for (const change of changes) {
+            yield* toDiffLines(change, scopes);
         }
     }
-    // Per-filter numstat call. The R branch uses `-z` because numstat
-    // otherwise encodes rename paths in three format variants within the
-    // path column (`{a => b}`, `a/{b => c}/d`, or bare `old => new`). `-z`
-    // emits `N<TAB>M<TAB>\0<src>\0<dst>\0` for each rename, so we stride-3
-    // over the NUL-split tokens and synthesise `R<TAB><src><TAB><dst>`
-    // lines that RepoGitDiff._expandRenames already understands.
-    //
-    // A/M/D: streamed via _spawnLines + readline, per-line transform strips
-    // the leading `N\tM\t` counts and rewrites them to the status prefix.
-    // R (NUL-delimited): buffered via _gitBuffered because readline is
-    // newline-oriented and the whole-string split remains cheap for the
-    // rare rename set.
-    async _getNumstatLines(changeType, detectRenames) {
-        if (changeType === RENAMED) {
-            return this._getRenameLines();
-        }
-        const args = [
-            'diff',
-            '--numstat',
-            ...(detectRenames ? ['-M'] : ['--no-renames']),
-            ...IGNORE_WHITESPACE_PARAMS,
-            `--diff-filter=${changeType}`,
-            this.config.from,
-            this.config.to,
-            // Stryker disable next-line StringLiteral -- equivalent: '--' is the git path separator marker; tests stub _spawnLines so the args array is opaque past the call, and the contract enforced is that {from, to, ...source} land in the right slots
-            '--',
-            ...this.config.source,
-        ];
-        const lines = [];
-        for await (const line of this._spawnLines(args)) {
-            // Stryker disable next-line ConditionalExpression -- equivalent: see v8 ignore — _spawnLines is the line splitter; empty lines are unreachable in practice
-            /* v8 ignore next -- defensive: _spawnLines splits on EOL; trailing/empty lines from git numstat are filtered here */
-            if (!line)
-                continue;
-            lines.push(treatPathSep(line.replace(NUM_STAT_CHANGE_INFORMATION, `${changeType}\t`)));
-        }
-        return lines;
-    }
-    async _getRenameLines() {
-        const output = await this._gitBuffered([
-            'diff',
-            '--numstat',
-            '-M',
-            '-z',
-            ...IGNORE_WHITESPACE_PARAMS,
-            `--diff-filter=${RENAMED}`,
-            this.config.from,
-            this.config.to,
-            '--',
-            ...this.config.source,
-        ]);
-        const tokens = output.split('\0');
-        const lines = [];
-        // Stryker disable next-line EqualityOperator,ArithmeticOperator,AssignmentOperator -- equivalent: this is the stride-3 loop bound; <= vs < and i-2 vs i+2 only widen/narrow the iteration count by one trailing position whose tokens are undefined and rejected by the `!src || !dst` guard below; i-=3 produces an unbounded negative-index walk that reads tokens[-N] (undefined) and is also rejected by the same guard
-        for (let i = 0; i + 2 < tokens.length; i += 3) {
-            const src = tokens[i + 1];
-            const dst = tokens[i + 2];
-            if (!src || !dst)
-                continue;
-            lines.push(treatPathSep(`${RENAMED}${TAB}${src}${TAB}${dst}`));
+    async requestDiff() {
+        try {
+            const repo = await this.getRepo();
+            return await repo.diff({
+                from: this.config.from,
+                to: this.config.to,
+                recursive: true,
+                detectRenames: Boolean(this.config.changesManifest),
+                ...(this.config.ignoreWhitespace ? IGNORE_WHITESPACE_OPTIONS : {}),
+            });
+        }
+        catch (error) {
+            throw mapTsgitError(error, `${this.config.from}..${this.config.to}`);
         }
-        return lines;
     }
 }
 __decorate([
@@ -641,4 +410,126 @@ __decorate([
 __decorate([
     log
 ], GitAdapter.prototype, "streamDiffLines", null);
+// Normalizes streamBlob's result (a real BlobStream in production, plain
+// arrays of chunks in unit fakes) into a single stateful AsyncGenerator so
+// streamContent can peek a few chunks via next() and later hand the same
+// cursor to a for-await loop without losing its place.
+async function* normalizeChunks(source) {
+    yield* source;
+}
+const isLfsPointer = (head) => head.length >= LFS_MAGIC.length &&
+    head.subarray(0, LFS_MAGIC.length).equals(LFS_MAGIC);
+const peekHead = async (chunks) => {
+    const parts = [];
+    let length = 0;
+    while (length < LFS_MAGIC.length) {
+        const result = await chunks.next();
+        if (result.done) {
+            return { head: Buffer.concat(parts, length), exhausted: true };
+        }
+        parts.push(result.value);
+        length += result.value.length;
+    }
+    return { head: Buffer.concat(parts, length), exhausted: false };
+};
+const writeChunk = async (out, chunk) => {
+    if (!out.write(chunk)) {
+        await once(out, 'drain');
+    }
+};
+const forwardChunks = async (chunks, out, head, exhausted) => {
+    if (head.length > 0) {
+        await writeChunk(out, head);
+    }
+    if (!exhausted) {
+        for await (const chunk of chunks) {
+            await writeChunk(out, chunk);
+        }
+    }
+    out.end();
+};
+const assertWithinPointerCap = (length) => {
+    if (length > LFS_POINTER_CAP) {
+        throw new Error('LFS pointer exceeds expected size');
+    }
+};
+const accumulatePointer = async (chunks, head) => {
+    const parts = [head];
+    let length = head.length;
+    assertWithinPointerCap(length);
+    for await (const chunk of chunks) {
+        parts.push(chunk);
+        length += chunk.length;
+        assertWithinPointerCap(length);
+    }
+    return Buffer.concat(parts, length);
+};
+const inScope = (path, scopes) => scopes.some(scope => ROOT_PATHS.has(scope) || path === scope || path.startsWith(`${scope}/`));
+const keepSide = (mode, path, scopes) => mode !== GITLINK_MODE && (scopes.length === 0 || inScope(path, scopes));
+// git prints rename similarity as a zero-padded three-digit percent (R087).
+const similarityPercent = (similarity) => String(toSimilarityPercent(similarity.score)).padStart(3, '0');
+// The facade diff takes no pathspec, so `-- <source>` scoping is replicated
+// per side. Gitlink changes are skipped (submodule pointer moves are not
+// deployable metadata) and `type-change`/`copy` entries are dropped for
+// parity with the subprocess `--diff-filter=AMD(R)`. A rename with only one
+// side in scope degrades to that side's A/D line, matching what the
+// subprocess pathspec does to a broken rename pair.
+function* toDiffLines(change, scopes) {
+    switch (change.type) {
+        case 'add':
+            if (keepSide(change.newMode, change.newPath, scopes)) {
+                yield `${ADDITION}${TAB}${treatPathSep(change.newPath)}`;
+            }
+            break;
+        case 'delete':
+            if (keepSide(change.oldMode, change.oldPath, scopes)) {
+                yield `${DELETION}${TAB}${treatPathSep(change.oldPath)}`;
+            }
+            break;
+        case 'modify':
+            if (change.oldMode !== GITLINK_MODE &&
+                keepSide(change.newMode, change.path, scopes)) {
+                yield `${MODIFICATION}${TAB}${treatPathSep(change.path)}`;
+            }
+            break;
+        case 'rename': {
+            const oldKept = keepSide(change.oldMode, change.oldPath, scopes);
+            const newKept = keepSide(change.newMode, change.newPath, scopes);
+            if (oldKept && newKept) {
+                yield `${RENAMED}${similarityPercent(change.similarity)}${TAB}${treatPathSep(change.oldPath)}${TAB}${treatPathSep(change.newPath)}`;
+            }
+            else if (newKept) {
+                yield `${ADDITION}${TAB}${treatPathSep(change.newPath)}`;
+            }
+            else if (oldKept) {
+                yield `${DELETION}${TAB}${treatPathSep(change.oldPath)}`;
+            }
+            break;
+        }
+    }
+}
+const GLOB_CHARS = /[*?[]/;
+const REGEXP_SPECIALS = /[.+^${}()|\\\]]/g;
+// Git pathspec semantics: a literal pathspec matches by directory prefix; a
+// pathspec containing wildcards uses wildmatch where `*` also crosses `/`
+// (no `:(glob)` magic). Callers mix both shapes (e.g. flow translations use
+// `<source>/*.translation-meta.xml`).
+const buildPathspecMatcher = (specs) => {
+    // Git normalizes leading `./` (and the `.//*` shape produced by the
+    // default `./` source dir) away before matching; repo paths never carry
+    // either prefix.
+    const normalized = specs.map(spec => spec.replace(/^(\.\/)+/, '').replace(/^\/+/, ''));
+    const literals = normalized.filter(spec => !GLOB_CHARS.test(spec));
+    const globs = normalized
+        .filter(spec => GLOB_CHARS.test(spec))
+        .map(spec => {
+        const escaped = spec
+            .replace(REGEXP_SPECIALS, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${escaped}$`);
+    });
+    return (path) => (literals.length > 0 && inScope(path, literals)) ||
+        globs.some(glob => glob.test(path));
+};
 //# sourceMappingURL=GitAdapter.js.map