repo-dive 0.18.0 → 0.18.1

package/dist/cli.js

@@ -44237,7 +44237,7 @@ var runWith = (command, config) => {
 };
 var package_default = {
 	name: "repo-dive",
-	version: "0.18.0",
+	version: "0.18.1",
 	description: "Dive into a git repo's history: per-commit snapshots, an indexed metrics catalog and an interactive dashboard",
 	keywords: [
 		"git",
@@ -44395,7 +44395,7 @@ var captureStream = (stream) => stream.pipe(decodeText$1(), mkString);
 * the invocation explicit.
 */
 var runCommand = fnUntraced(function* (command, args, options) {
-	const handle = yield* make$33(command, [...args], { stdin: "ignore" });
+	const handle = yield* make$33(command, [...args], { stdin: options?.input === void 0 ? "ignore" : make$38(new TextEncoder().encode(options.input)) });
 	const { stdout, stderr, exitCode } = yield* all({
 		stdout: captureStream(handle.stdout),
 		stderr: captureStream(handle.stderr),
@@ -53596,6 +53596,135 @@ var inferAliases = (resolveContributor, authors) => {
 	return (email, name) => resolveContributor(anchorEmailByKey.get(keyOf(email)) ?? email, name);
 };
 //#endregion
+//#region src/cli/shared/indexing/parse-identity.ts
+/**
+* Splits a `Co-authored-by:` trailer into its parts:
+* `"Claude Fable 5 <noreply@anthropic.com>"` → name + email.
+*
+* Keeping the email (rather than the display name alone) is what lets a
+* co-author resolve through the very same `resolveContributor` an author goes
+* through — so alias groups, `displayName`/`url` overrides and kind derivation
+* apply identically whether a person wrote a commit or helped with one.
+*/
+var parseIdentity = (identity) => {
+	const open = identity.indexOf("<");
+	const close = identity.lastIndexOf(">");
+	if (open === -1 || close < open) return {
+		name: identity.trim(),
+		email: ""
+	};
+	return {
+		name: identity.slice(0, open).trim(),
+		email: identity.slice(open + 1, close).trim()
+	};
+};
+//#endregion
+//#region src/cli/shared/indexing/read-mailmap.ts
+var CheckMailmapOutputError = class extends TaggedError$1("CheckMailmapOutputError") {
+	get message() {
+		return `git check-mailmap answered ${this.contactCount} contacts with ${this.lineCount} lines`;
+	}
+};
+/**
+* The line `git check-mailmap` looks an identity up by: `Name <email>`, or
+* `<email>` alone, which matches the `.mailmap` entries that don't name the
+* old identity. `undefined` for what it can't look up: no email (a bare
+* `Co-authored-by: Some Name`), an email with a `>` in it, which git cuts
+* short there, or a line break, which would split one contact in two.
+*/
+var contactOf = (name, email) => {
+	if (email === "" || /[>\n]/.test(email) || name.includes("\n")) return;
+	return name === "" ? `<${email}>` : `${name} <${email}>`;
+};
+/**
+* Looks up the identities `facts` name in the repository's current `.mailmap`
+* and returns a function that rewrites a fact through it, or `undefined` when
+* the `.mailmap` changes none of them.
+*
+* Collectors record authors under `author` as a bare email and co-authors
+* under `coAuthor` as the trailer's `Name <email>`, which is looked up by name
+* too, the way `git shortlog --group=trailer:co-authored-by` does. Neither is
+* mapped when collected — file survival reads the raw `%ae`, trailers are
+* kept verbatim — except line survival, which `git blame` maps through the
+* `.mailmap` of the day. Mapping them all again here, through the `.mailmap`
+* that `listCommits` reads commit authors through, brings entries added since
+* a snapshot was collected to every chart without a re-scan.
+*
+* Only additions reach back that way: line survival collected under an entry
+* keeps the address `git blame` mapped it to, so an entry removed or changed
+* since takes a re-scan to undo there. That address is looked up once more as
+* well, which only moves it if the `.mailmap` maps it in turn — a chain git
+* itself never follows.
+*/
+var readMailmap = fn("readMailmap")(function* (repoRoot, facts) {
+	const authors = /* @__PURE__ */ new Set();
+	const coAuthors = /* @__PURE__ */ new Set();
+	for (const fact of facts) {
+		const author = fact.categories?.["author"];
+		const coAuthor = fact.categories?.["coAuthor"];
+		if (author !== void 0) authors.add(author);
+		else if (coAuthor !== void 0) coAuthors.add(coAuthor);
+	}
+	const lookups = [];
+	for (const value of authors) {
+		const contact = contactOf("", value);
+		if (contact !== void 0) lookups.push({
+			key: "author",
+			value,
+			contact
+		});
+	}
+	for (const value of coAuthors) {
+		const { name, email } = parseIdentity(value);
+		const contact = contactOf(name, email);
+		if (contact !== void 0) lookups.push({
+			key: "coAuthor",
+			value,
+			contact
+		});
+	}
+	if (lookups.length === 0) return;
+	const answers = (yield* runGit([
+		"-C",
+		repoRoot,
+		"check-mailmap",
+		"--stdin"
+	], { input: lookups.map(({ contact }) => `${contact}\n`).join("") })).split("\n");
+	if (answers.length !== lookups.length + 1) return yield* new CheckMailmapOutputError({
+		contactCount: lookups.length,
+		lineCount: answers.length - 1
+	});
+	/** Category value → what replaces it, for the values the `.mailmap` changes. */
+	const replacements = {
+		author: /* @__PURE__ */ new Map(),
+		coAuthor: /* @__PURE__ */ new Map()
+	};
+	for (const [index, { key, value, contact }] of lookups.entries()) {
+		const answer = answers[index] ?? contact;
+		if (key === "coAuthor") {
+			if (answer !== contact) replacements.coAuthor.set(value, answer);
+			continue;
+		}
+		const { email } = parseIdentity(answer);
+		if (email !== value) replacements.author.set(value, email);
+	}
+	if (replacements.author.size === 0 && replacements.coAuthor.size === 0) return;
+	return (fact) => {
+		for (const key of ["author", "coAuthor"]) {
+			const value = fact.categories?.[key];
+			const replacement = value === void 0 ? void 0 : replacements[key].get(value);
+			if (replacement !== void 0) return {
+				...fact,
+				categories: {
+					...fact.categories,
+					[key]: replacement
+				}
+			};
+		}
+		return fact;
+	};
+});
+//#endregion
 //#region src/cli/shared/indexing/remote.ts
 /**
 * Turns whatever `remote.origin.url` holds into a URL a browser can open, or
@@ -53653,27 +53782,6 @@ var kindGroupLabels = {
 	bot: "Bots",
 	ai: "AI agents"
 };
-/**
-* Splits a `Co-authored-by:` trailer into its parts:
-* `"Claude Fable 5 <noreply@anthropic.com>"` → name + email.
-*
-* Keeping the email (rather than the display name alone) is what lets a
-* co-author resolve through the very same `resolveContributor` an author goes
-* through — so alias groups, `displayName`/`url` overrides and kind derivation
-* apply identically whether a person wrote a commit or helped with one.
-*/
-var parseIdentity = (identity) => {
-	const open = identity.indexOf("<");
-	const close = identity.lastIndexOf(">");
-	if (open === -1 || close < open) return {
-		name: identity.trim(),
-		email: ""
-	};
-	return {
-		name: identity.slice(0, open).trim(),
-		email: identity.slice(open + 1, close).trim()
-	};
-};
 var sumMetric = (commit, metric, filter) => {
 	let total = 0;
 	for (const facts of commit.factsByCollector.values()) for (const fact of facts) if (fact.metric === metric && (filter === void 0 || filter(fact.categories ?? {}))) total += fact.value;
@@ -53878,8 +53986,8 @@ var buildDashboardData = (repoRoot, commits, config, remoteUrl, lineageOf) => {
 	* config merges them back into one.
 	*/
 	const contributorFor = (resolved, observedName) => {
-		const name = nameOf(resolved, observedName);
 		const email = resolved.canonicalEmail.toLowerCase();
+		const name = (resolved.kind === "human" ? nameByCanonicalEmail.get(email) : void 0) ?? nameOf(resolved, observedName);
 		const key = resolved.kind === "human" ? email : `${name.toLowerCase()}\u{1F}${email}`;
 		const contributor = contributorMap.get(key) ?? {
 			index: contributorMap.size,
@@ -54052,7 +54160,11 @@ var runIndex = fn("runIndex")(function* ({ repoPath }) {
 			incompleteOutputs
 		};
 	}), { concurrency: 16 });
-	const commitFacts = readOutcomes.map((outcome) => outcome.facts);
+	const remapIdentities = yield* readMailmap(repoRoot, readOutcomes.values().flatMap(({ facts }) => facts.factsByCollector.values().flatMap((collectorFacts) => collectorFacts.values())));
+	const commitFacts = readOutcomes.map(({ facts }) => remapIdentities === void 0 ? facts : {
+		...facts,
+		factsByCollector: new Map(facts.factsByCollector.entries().map(([collector, collectorFacts]) => [collector, collectorFacts.map(remapIdentities)]))
+	});
 	const unknownCollectorDirs = readOutcomes.reduce((total, outcome) => total + outcome.unknownCollectorDirs, 0);
 	const offMainlineSnapshots = readOutcomes.reduce((total, outcome) => total + outcome.offMainlineSnapshots, 0);
 	const incompleteOutputs = readOutcomes.reduce((total, outcome) => total + outcome.incompleteOutputs, 0);