// A committed git tree as the closure walker's source of truth: the merge-base with origin/main,

// read without checking it out, so a ratchet compares against what actually landed.

import { execFileSync } from 'node:child_process';

import path from 'node:path';

import type { SourceTreeReader } from '../../src/__tests__/eager-import-closure.fixtures.ts';

import { isProductionSourceFile } from '../layering/tracked-sources.ts';

const WALKED_SOURCE = /^(?:src|packages\/[^/]+\/src)\/.*\.ts$/;

const WALKED_MANIFEST = /^packages\/[^/]+\/package\.json$/;

function git(repoRoot: string, args: readonly string[], input = ''): Buffer {

return execFileSync('git', [...args], {

cwd: repoRoot,

input,

maxBuffer: 256 * 1024 * 1024,

stdio: ['pipe', 'pipe', 'pipe'],

});

}

/** The commit a branch's closures ratchet against: `git merge-base origin/main HEAD`. */

export function mergeBaseWithMain(repoRoot: string): string {

try {

return git(repoRoot, ['merge-base', 'origin/main', 'HEAD']).toString('utf8').trim();

} catch (error) {

const stderr = (error as { stderr?: Buffer }).stderr?.toString('utf8').trim() ?? '';

throw new Error(

'The eager-closure ratchet needs origin/main to find its merge-base (git merge-base ' +

`origin/main HEAD failed: ${stderr}). Fetch origin/main; the gate does not skip.`,

{ cause: error },

);

}

}

/**

* The commit under measurement. Compared against `mergeBaseWithMain`, this answers whether the

* head carries work of its own: they are equal exactly when `main` already carries this commit --

* a push to `main`, or a branch that has not committed anything yet -- and then no entry is

* first-introduced, whatever the tree contains.

*/

export function headCommit(repoRoot: string): string {

return git(repoRoot, ['rev-parse', 'HEAD']).toString('utf8').trim();

}

/** Files renamed since `base`, current path -> path at `base`, so a rename is not a new entry. */

export function renamedSince(repoRoot: string, base: string): ReadonlyMap<string, string> {

const renamed = new Map<string, string>();

const status = git(repoRoot, ['diff', '--name-status', '-M', '--diff-filter=R', '-z', base]);

const fields = status.toString('utf8').split('\0');

for (let index = 0; index + 2 < fields.length; index += 3) {

const [from, to] = [fields[index + 1], fields[index + 2]];

if (from && to) renamed.set(to, from);

}

return renamed;

}

/**

* Production source paths tracked at `base` but gone from the working tree. Plain `git diff`

* already pairs renames by default, so this lists only the deletions that pairing did NOT

* absorb -- a moved-and-rewritten module the detector could not pair, which `renamedSince`

* answers by detection and therefore misses. The split tolerance reads these paths' content

* through `movedFromDeletedSource`: two or more statements shared with ONE deleted source is a

* move signal, so a verbatim transplant stays non-novel; one shared statement is tolerated as

* coincidence, and a statement-by-statement rewrite evades a textual match. This probe is the

* reinforcement -- containment is what structurally refuses a dropped-and-swapped base module

* (#3298 review). The default pairing is load-bearing:

* it keeps a split's re-homed hub OUT of this list (paired to its closest part), and passing

* `--no-renames` would put it here, making the split's own parts share two statements with

* "deleted source" and refusing the very extraction the tolerance exists for.

*/

export function deletedSourcesSince(repoRoot: string, base: string): string[] {

const status = git(repoRoot, ['diff', '--name-only', '--diff-filter=D', '-z', base]);

return status

.toString('utf8')

.split('\0')

.filter((file) => file !== '' && WALKED_SOURCE.test(file) && isProductionSourceFile(file));

}

/** A carried entry must have been a source the base closure walker could actually read. */

export function baseProductionPathOf(

repoRoot: string,

entryFile: string,

baseTree: SourceTreeReader,

renamedFrom: ReadonlyMap<string, string>,

): string | null {

const baseFile = renamedFrom.get(entryFile) ?? entryFile;

return WALKED_SOURCE.test(baseFile) &&

isProductionSourceFile(baseFile) &&

baseTree.isFile(path.resolve(repoRoot, baseFile))

? baseFile

: null;

}

/** Every path tracked at `treeish`, repo-root-relative, from ONE `git ls-tree`. */

function listCommittedTree(repoRoot: string, treeish: string): string[] {

const listing = git(repoRoot, ['ls-tree', '-r', '--name-only', '-z', treeish]).toString('utf8');

return listing.split('\0').filter(Boolean);

}

/**

* The sources this reader serves, split by kind: production TypeScript under `src/` and

* `packages/<pkg>/src/`, and workspace package manifests. One definition, so a consumer reading

* a committed tree cannot classify it differently from the walker.

*/

function committedSourceSet(tracked: readonly string[]): {

sources: string[];

manifests: string[];

} {

return {

sources: tracked.filter((file) => WALKED_SOURCE.test(file) && isProductionSourceFile(file)),

manifests: tracked.filter((file) => WALKED_MANIFEST.test(file)),

};

}

/** Contents of `files` at `treeish`, through ONE long-lived `git cat-file --batch`. */

function readCommittedBlobs(

repoRoot: string,

treeish: string,

files: readonly string[],

): Map<string, string> {

if (files.length === 0) return new Map();

const requests = files.map((file) => `${treeish}:${file}\n`).join('');

return parseCatFileBatch(git(repoRoot, ['cat-file', '--batch'], requests), files);

}

/**

* The same enumeration and blob read as `createCommittedSourceTree`, handed over as text: the

* production sources and workspace manifests committed at `treeish`. A whole-tree measurement

* (the layering ratchets) needs the corpus rather than a reader, and taking it from here is what

* keeps its file set identical to the closure walker's.

*/

// fallow-ignore-next-line unused-export -- consumed by scripts/layering, outside fallow's scope

export function readCommittedSources(

repoRoot: string,

treeish: string,

): { sources: Map<string, string>; manifests: Map<string, string> } {

const { sources, manifests } = committedSourceSet(listCommittedTree(repoRoot, treeish));

const blobs = readCommittedBlobs(repoRoot, treeish, [...sources, ...manifests]);

const only = (files: readonly string[]) =>

new Map(files.flatMap((file) => (blobs.has(file) ? [[file, blobs.get(file)!] as const] : [])));

return { sources: only(sources), manifests: only(manifests) };

}

/**

* `<sha> blob <size>\n<size bytes>\n` per hit and `<request> missing\n` per miss, in request

* order. Sizes are bytes, so this walks the raw buffer rather than a string offset.

*/

function parseCatFileBatch(output: Buffer, files: readonly string[]): Map<string, string> {

const contents = new Map<string, string>();

let offset = 0;

for (const file of files) {

const headerEnd = output.indexOf(0x0a, offset);

const blob = /^\S+ blob (\d+)$/.exec(output.toString('utf8', offset, headerEnd));

offset = headerEnd + 1;

if (!blob) continue;

const size = Number(blob[1]);

contents.set(file, output.toString('utf8', offset, offset + size));

offset += size + 1;

}

return contents;

}

/** Every ancestor directory of the tracked paths, so `exists` answers for directories too. */

function directoriesOf(files: ReadonlySet<string>): Set<string> {

const directories = new Set<string>();

for (const file of files) {

for (let dir = path.posix.dirname(file); dir !== '.'; dir = path.posix.dirname(dir)) {

if (directories.has(dir)) break;

directories.add(dir);

}

}

return directories;

}

/**

* The walker's view of `treeish`: tracked paths from one `git ls-tree`, and every source the

* walker can reach (production TypeScript under `src/` and `packages/<pkg>/src/`, package

* manifests) from ONE `git cat-file --batch` fed those paths up front -- two processes for the

* whole tree, never one per file. A read outside that set is a widening request, not a fallback.

*/

export function createCommittedSourceTree(repoRoot: string, treeish: string): SourceTreeReader {

const listing = listCommittedTree(repoRoot, treeish);

const tracked = new Set(listing);

const directories = directoriesOf(tracked);

const { sources, manifests } = committedSourceSet(listing);

const contents = readCommittedBlobs(repoRoot, treeish, [...sources, ...manifests]);

const relative = (file: string) => path.relative(repoRoot, file).split(path.sep).join('/');

return {

exists: (file) => tracked.has(relative(file)) || directories.has(relative(file)),

isFile: (file) => tracked.has(relative(file)),

readdir: (dir) => {

const prefix = `${relative(dir)}/`;

const names = new Set<string>();

for (const entry of [...tracked, ...directories]) {

if (entry.startsWith(prefix)) names.add(entry.slice(prefix.length).split('/')[0] ?? '');

}

names.delete('');

return [...names].sort();

},

readFile: (file) => {

const source = contents.get(relative(file));

if (source === undefined) {

throw new Error(`${relative(file)} is not a source the closure walker reads at ${treeish}`);

}

return source;

},

};

}