repo-dive 0.13.0 → 0.14.0

package/dist/cli.js

@@ -42694,7 +42694,7 @@ var runWith = (command, config) => {
 };
 var package_default = {
 	name: "repo-dive",
-	version: "0.13.0",
+	version: "0.14.0",
 	description: "Dive into a git repo's history: per-commit snapshots, an indexed metrics catalog and an interactive dashboard",
 	keywords: [
 		"git",
@@ -42956,10 +42956,11 @@ var languageOfExtension = (extension) => languageByExtension[extension] ?? exten
 /**
 * Whether a collector describes the *state of the tree* at a commit rather than
 * facts about the commit itself. Such snapshots are only meaningful on the
-* first-parent chain: a commit that lives on a side branch — or that arrived
-* with a foreign history absorbed by an unrelated-histories merge — carries a
-* tree that was never the repository's state, so charting it puts a cliff into
-* every timeline.
+* mainline (the first-parent chain, extended backwards across founding
+* grafts — see `listMainlineShas`): a commit that lives on a side branch — or
+* that arrived with a foreign history absorbed mid-life by an
+* unrelated-histories merge — carries a tree that was never the repository's
+* state, so charting it puts a cliff into every timeline.
 */
 var describesTreeState = (collector) => collector.strategy !== "log";
 /** File extension used as a category key, e.g. ".ts"; files without one map to "(none)". */
@@ -50809,18 +50810,104 @@ var listCommits = (repoRoot) => runGit([
 	"log",
 	`--format=${gitLogFormat}`
 ]).pipe(succeedIfNoCommitsYet, map$7(parseGitLog));
+var chainLogFormat = [
+	"%H",
+	"%P",
+	"%cI"
+].join("%x1f");
 /**
-* Shas on HEAD's first-parent chain, i.e. the states the repository actually
-* passed through. See {@link describesTreeState} for why snapshot collectors
-* are restricted to them.
+* The first-parent chain of `tip` (HEAD when omitted), newest first. HEAD is
+* left implicit rather than passed: an explicit rev makes git fail an empty
+* repository with "unknown revision" instead of the "does not have any commits
+* yet" that {@link succeedIfNoCommitsYet} recovers from.
 */
-var listFirstParentShas = (repoRoot) => runGit([
+var listFirstParentChain = (repoRoot, tip) => runGit([
 	"-C",
 	repoRoot,
 	"log",
 	"--first-parent",
-	"--format=%H"
-]).pipe(succeedIfNoCommitsYet, map$7((stdout) => new Set(stdout.split("\n").filter(Boolean))));
+	`--format=${chainLogFormat}`,
+	...tip === void 0 ? [] : [tip]
+]).pipe(succeedIfNoCommitsYet, map$7((stdout) => stdout.split("\n").filter(Boolean).map((line) => {
+	const [hash = "", parents = "", committerDate = ""] = line.split(fieldSeparator);
+	return {
+		hash,
+		parentHashes: parents.split(" ").filter(Boolean),
+		committerDate
+	};
+})));
+/** No common ancestor means the two commits come from unrelated histories. */
+var haveUnrelatedHistories = (repoRoot, left, right) => runGit([
+	"-C",
+	repoRoot,
+	"merge-base",
+	left,
+	right
+], { okExitCodes: [1] }).pipe(map$7((stdout) => stdout.trim() === ""));
+/**
+* The first-parent chain that continues `chain` backwards in time across a
+* founding graft, or `[]` when there is none.
+*
+* A repository migration (monorepo assembly, host move, history rewrite)
+* leaves a recognizable signature: a fresh root commit followed immediately by
+* merges that absorb the project's previous histories. Both conditions below
+* are required, so ordinary absorptions stay excluded:
+*
+* - the merge sits in the founding window — the unbroken run of merges
+*   directly above the root, before the first ordinary commit. A foreign
+*   history vendored later in the repository's life does not qualify.
+* - the absorbed history ends before the root begins, so it occupies the
+*   stretch of timeline where the current chain has nothing to say. A side
+*   history that overlaps the chain (e.g. a plugin repository absorbed while
+*   mainline development continued) does not qualify.
+*
+* When several absorbed histories qualify (effect's monorepo assembly merged
+* eight), the timeline can only continue into one of them: the one reaching
+* back furthest wins.
+*/
+var findFoundingGraftChain = (repoRoot, chain, alreadyOnMainline) => gen(function* () {
+	const root = chain.at(-1);
+	if (root === void 0) return [];
+	const rootDate = Date.parse(root.committerDate);
+	const candidateTips = [];
+	for (let index = chain.length - 2; index >= 0; index -= 1) {
+		const entry = chain[index];
+		if (entry === void 0 || entry.parentHashes.length < 2) break;
+		candidateTips.push(...entry.parentHashes.slice(1));
+	}
+	let best = [];
+	let bestRootDate = Number.POSITIVE_INFINITY;
+	for (const tip of candidateTips) {
+		if (alreadyOnMainline.has(tip)) continue;
+		if (!(yield* haveUnrelatedHistories(repoRoot, root.hash, tip))) continue;
+		const candidate = yield* listFirstParentChain(repoRoot, tip);
+		const tipDate = Date.parse(candidate.at(0)?.committerDate ?? "");
+		const candidateRootDate = Date.parse(candidate.at(-1)?.committerDate ?? "");
+		if (Number.isNaN(tipDate) || Number.isNaN(candidateRootDate) || tipDate >= rootDate) continue;
+		if (candidateRootDate < bestRootDate) {
+			best = candidate;
+			bestRootDate = candidateRootDate;
+		}
+	}
+	return best;
+});
+/**
+* Shas on the mainline — the states the repository actually passed through.
+* That is HEAD's first-parent chain, extended backwards across founding grafts
+* (see {@link findFoundingGraftChain}): when a migration absorbed the
+* project's previous history behind a fresh root, the absorbed mainline is the
+* continuation of the timeline. See {@link describesTreeState} for why
+* snapshot collectors are restricted to the mainline.
+*/
+var listMainlineShas = (repoRoot) => gen(function* () {
+	const shas = /* @__PURE__ */ new Set();
+	let chain = yield* listFirstParentChain(repoRoot);
+	while (chain.length > 0) {
+		for (const entry of chain) shas.add(entry.hash);
+		chain = yield* findFoundingGraftChain(repoRoot, chain, shas);
+	}
+	return shas;
+});
 var summarizeCommits = (commits) => {
 	const authorEmails = new Set(commits.map((commit) => commit.authorEmail));
 	const dates = commits.flatMap((commit) => [commit.authorDate, commit.committerDate]).filter((date) => !Number.isNaN(Date.parse(date))).toSorted((left, right) => Date.parse(left) - Date.parse(right));
@@ -50900,10 +50987,10 @@ var runScan = ({ repoPath, collectorNames, maxCommits, sample, force = false })
 	const summary = summarizeCommits(commits);
 	const cacheKeys = new Map(collectors.map((collector) => [collector.name, collectorCacheKey(collector, config)]));
 	const cacheKeyOf = (collector) => cacheKeys.get(collector.name) ?? collectorCacheKey(collector, config);
-	const firstParentShas = yield* listFirstParentShas(repoRoot);
+	const mainlineShas = yield* listMainlineShas(repoRoot);
 	const plans = collectors.map((collector) => {
 		const policy = sampleOverride ?? collector.defaultSampling;
-		const candidates = describesTreeState(collector) ? selected.filter((commit) => firstParentShas.has(commit.hash)) : selected;
+		const candidates = describesTreeState(collector) ? selected.filter((commit) => mainlineShas.has(commit.hash)) : selected;
 		return {
 			collector,
 			policy,
@@ -51101,7 +51188,7 @@ var buildPlan = (repoRoot) => gen(function* () {
 		"rev-list",
 		"HEAD"
 	])).split("\n").filter(Boolean));
-	const firstParentShas = yield* listFirstParentShas(repoRoot);
+	const mainlineShas = yield* listMainlineShas(repoRoot);
 	const currentCacheKeys = new Map(builtInCollectors.map((collector) => [collector.name, collectorCacheKey(collector, config)]));
 	const snapshotCollectorNames = new Set(builtInCollectors.filter((collector) => describesTreeState(collector)).map((collector) => collector.name));
 	const unreachableShas = [];
@@ -51116,7 +51203,7 @@ var buildPlan = (repoRoot) => gen(function* () {
 		const collectorNames = yield* readdirIfExists(path.join(commitsPath, sha));
 		for (const collectorName of collectorNames) {
 			countsByCollector.set(collectorName, (countsByCollector.get(collectorName) ?? 0) + 1);
-			if (!firstParentShas.has(sha) && snapshotCollectorNames.has(collectorName)) offMainlineOutputs.push({
+			if (!mainlineShas.has(sha) && snapshotCollectorNames.has(collectorName)) offMainlineOutputs.push({
 				sha,
 				collectorName
 			});
@@ -51737,7 +51824,7 @@ var runIndex = ({ repoPath }) => gen(function* () {
 	const commitsPath = path.join(catalogPath, "commits");
 	const registry = new Map(builtInCollectors.map((collector) => [collector.name, collector]));
 	const gitCommits = yield* listCommits(repoRoot);
-	const firstParentShas = yield* listFirstParentShas(repoRoot);
+	const mainlineShas = yield* listMainlineShas(repoRoot);
 	const remoteUrl = yield* readRemoteUrl(repoRoot);
 	const catalogShas = new Set(yield* tryPromise(async () => {
 		try {
@@ -51750,7 +51837,7 @@ var runIndex = ({ repoPath }) => gen(function* () {
 	if (orderedCommits.length === 0) return yield* new NoCollectedCommitsError({ commitsPath });
 	const readOutcomes = yield* forEach$1(orderedCommits, (commit) => tryPromise(async () => {
 		const commitDir = path.join(commitsPath, commit.hash);
-		const onMainline = firstParentShas.has(commit.hash);
+		const onMainline = mainlineShas.has(commit.hash);
 		const factsByCollector = /* @__PURE__ */ new Map();
 		let unknownCollectorDirs = 0;
 		let offMainlineSnapshots = 0;
@@ -56767,7 +56854,7 @@ var exists = (filePath) => promise(() => access(filePath).then(() => true, () =>
 var runStatus = ({ repoPath }) => gen(function* () {
 	const repoRoot = yield* resolveRepoRoot(repoPath);
 	const commits = yield* listCommits(repoRoot);
-	const firstParentShas = yield* listFirstParentShas(repoRoot);
+	const mainlineShas = yield* listMainlineShas(repoRoot);
 	const config = yield* loadConfig(repoRoot);
 	const catalogPath = config.catalogPath;
 	if (!(yield* exists(path.join(catalogPath, "catalog.json")))) {
@@ -56789,7 +56876,7 @@ var runStatus = ({ repoPath }) => gen(function* () {
 		`Catalog: ${catalogPath}`
 	];
 	for (const collector of builtInCollectors) {
-		const target = sampleCommits(describesTreeState(collector) ? commits.filter((commit) => firstParentShas.has(commit.hash)) : commits, collector.defaultSampling);
+		const target = sampleCommits(describesTreeState(collector) ? commits.filter((commit) => mainlineShas.has(commit.hash)) : commits, collector.defaultSampling);
 		const cacheKey = collectorCacheKey(collector, config);
 		const collected = (yield* forEach$1(target, (commit) => isCollected(catalog, commit.hash, collector, cacheKey), { concurrency: 16 })).filter(Boolean).length;
 		lines.push(collector.defaultSampling === "all" ? `  ${collector.name}: ${collected}/${target.length} commits collected` : `  ${collector.name}: ${collected}/${target.length} commits collected (${samplingLabel(collector.defaultSampling)} sample of ${commits.length})`);