repo-dive 0.16.4 → 0.17.0

package/README.md

@@ -68,7 +68,7 @@ Collectors so far:
 - **commit-meta** — identities, dates, parents, subject and trailers (incl. AI co-authors)
 - **churn** — lines added/deleted per commit, by file extension
 - **file-types** — file count and bytes per extension at each commit's tree
-- **directives** — eslint-disable comments by rule (block disables tracked as gray areas) and `@ts-ignore`/`@ts-expect-error`/`@ts-nocheck`
+- **directives** — `eslint-disable` and `oxlint-disable` comments by linter and rule (block disables tracked as gray areas) and `@ts-ignore`/`@ts-expect-error`/`@ts-nocheck`
 - **dependencies** — resolved package totals from lockfiles, per package manager (pnpm, npm, yarn classic and yarn berry), plus direct/dev/optional dependencies and manifest counts read straight from `package.json` files; version-aware, monorepo-aware and extensible to more managers
 - **todo-comments** — TODO/FIXME/HACK/XXX counts
 - **languages** — lines and file count per language across a commit's source files (lockfiles, minified bundles and generated data excluded)

package/dist/cli.js

@@ -42805,7 +42805,7 @@ var runWith = (command, config) => {
 };
 var package_default = {
 	name: "repo-dive",
-	version: "0.16.4",
+	version: "0.17.0",
 	description: "Dive into a git repo's history: per-commit snapshots, an indexed metrics catalog and an interactive dashboard",
 	keywords: [
 		"git",
@@ -49682,6 +49682,36 @@ var scanTreeWithBlobCache = fnUntraced(function* ({ repoRoot, catalogPath, sha,
 });
 //#endregion
 //#region src/cli/shared/collectors/directives.ts
+/**
+* The linters whose suppression comments are counted, by comment prefix.
+* oxlint honours `eslint-*` comments too, so the prefix records how a comment
+* is spelled, not which tool reads it.
+*/
+var linters = ["eslint", "oxlint"];
+/**
+* Where each linter's counts sit in {@link DirectivesOutput}. Flat rather than
+* nested by linter, so outputs collected before oxlint was counted (eslint
+* keys only) still normalize.
+*/
+var outputKeys = {
+	eslint: {
+		nextLine: "eslintNextLine",
+		line: "eslintLine",
+		blocks: "eslintBlocks"
+	},
+	oxlint: {
+		nextLine: "oxlintNextLine",
+		line: "oxlintLine",
+		blocks: "oxlintBlocks"
+	}
+};
+var emptyBlockCounts = () => ({
+	count: 0,
+	closedCount: 0,
+	unboundedCount: 0,
+	coveredLines: 0,
+	byRule: {}
+});
 var emptyOutput = () => ({
 	eslintNextLine: {
 		count: 0,
@@ -49691,24 +49721,25 @@ var emptyOutput = () => ({
 		count: 0,
 		byRule: {}
 	},
-	eslintBlocks: {
+	eslintBlocks: emptyBlockCounts(),
+	oxlintNextLine: {
+		count: 0,
+		byRule: {}
+	},
+	oxlintLine: {
 		count: 0,
-		closedCount: 0,
-		unboundedCount: 0,
-		coveredLines: 0,
 		byRule: {}
 	},
+	oxlintBlocks: emptyBlockCounts(),
 	tsDirectives: {
 		ignore: 0,
 		expectError: 0,
 		nocheck: 0
 	}
 });
-/** Extracts rule names following a directive keyword, stopping at a comment terminator or `--`. */
-var parseRules = (content, keyword) => {
-	const keywordIndex = content.indexOf(keyword);
-	if (keywordIndex === -1) return [];
-	let rest = content.slice(keywordIndex + keyword.length);
+/** Extracts the rule names after a directive, stopping at a comment terminator or `--`. */
+var parseRules = (afterDirective) => {
+	let rest = afterDirective;
 	for (const terminator of [
 		"*/",
 		"-->",
@@ -49722,34 +49753,59 @@ var parseRules = (content, keyword) => {
 var addRules = (byRule, rules) => {
 	for (const rule of rules.length > 0 ? rules : ["(all)"]) byRule[rule] = (byRule[rule] ?? 0) + 1;
 };
-var quickPattern = /eslint-disable|eslint-enable|@ts-(?:ignore|expect-error|nocheck)/;
+var quickPattern = /(?:eslint|oxlint)-(?:disable|enable)|@ts-(?:ignore|expect-error|nocheck)/;
+/**
+* A lint directive and its kind. The first match on a line wins, so a comment
+* that mentions the other linter's directive in its rationale is still
+* attributed to the linter it opens with.
+*/
+var lintDirectivePattern = /(eslint|oxlint)-(disable-next-line|disable-line|disable|enable)/;
 /** Scans one file's content; results are cached per blob by the tree scanner. */
 var scanFileForDirectives = (content) => {
 	const output = emptyOutput();
 	if (!quickPattern.test(content)) return output;
-	let openBlock;
+	const openBlockLines = /* @__PURE__ */ new Map();
 	for (const [index, line] of content.split("\n").entries()) {
 		if (!quickPattern.test(line)) continue;
+		const lintDirective = lintDirectivePattern.exec(line);
 		if (line.includes("@ts-ignore")) output.tsDirectives.ignore += 1;
 		else if (line.includes("@ts-expect-error")) output.tsDirectives.expectError += 1;
 		else if (line.includes("@ts-nocheck")) output.tsDirectives.nocheck += 1;
-		else if (line.includes("eslint-disable-next-line")) {
-			output.eslintNextLine.count += 1;
-			addRules(output.eslintNextLine.byRule, parseRules(line, "eslint-disable-next-line"));
-		} else if (line.includes("eslint-disable-line")) {
-			output.eslintLine.count += 1;
-			addRules(output.eslintLine.byRule, parseRules(line, "eslint-disable-line"));
-		} else if (line.includes("eslint-disable")) {
-			output.eslintBlocks.count += 1;
-			addRules(output.eslintBlocks.byRule, parseRules(line, "eslint-disable"));
-			openBlock = { line: index };
-		} else if (openBlock && line.includes("eslint-enable")) {
-			output.eslintBlocks.closedCount += 1;
-			output.eslintBlocks.coveredLines += Math.max(0, index - openBlock.line - 1);
-			openBlock = void 0;
-		}
-	}
-	output.eslintBlocks.unboundedCount = output.eslintBlocks.count - output.eslintBlocks.closedCount;
+		else if (lintDirective !== null) {
+			const [directive, prefix, kind] = lintDirective;
+			const linter = prefix === "oxlint" ? "oxlint" : "eslint";
+			const keys = outputKeys[linter];
+			const rules = parseRules(line.slice(lintDirective.index + directive.length));
+			switch (kind) {
+				case "disable-next-line":
+					output[keys.nextLine].count += 1;
+					addRules(output[keys.nextLine].byRule, rules);
+					break;
+				case "disable-line":
+					output[keys.line].count += 1;
+					addRules(output[keys.line].byRule, rules);
+					break;
+				case "disable":
+					output[keys.blocks].count += 1;
+					addRules(output[keys.blocks].byRule, rules);
+					openBlockLines.set(linter, index);
+					break;
+				case "enable": {
+					const openBlockLine = openBlockLines.get(linter);
+					if (openBlockLine !== void 0) {
+						output[keys.blocks].closedCount += 1;
+						output[keys.blocks].coveredLines += Math.max(0, index - openBlockLine - 1);
+						openBlockLines.delete(linter);
+					}
+					break;
+				}
+			}
+		}
+	}
+	for (const linter of linters) {
+		const blocks = output[outputKeys[linter].blocks];
+		blocks.unboundedCount = blocks.count - blocks.closedCount;
+	}
 	return output;
 };
 var mergeRuleCounts = (target, source) => {
@@ -49759,18 +49815,21 @@ var mergeRuleCounts = (target, source) => {
 var mergeDirectives = (fileResults) => {
 	const merged = emptyOutput();
 	for (const result of fileResults) {
-		const nextLine = recordAt(result, "eslintNextLine");
-		merged.eslintNextLine.count += numberAt(nextLine, "count");
-		mergeRuleCounts(merged.eslintNextLine.byRule, nextLine["byRule"]);
-		const line = recordAt(result, "eslintLine");
-		merged.eslintLine.count += numberAt(line, "count");
-		mergeRuleCounts(merged.eslintLine.byRule, line["byRule"]);
-		const blocks = recordAt(result, "eslintBlocks");
-		merged.eslintBlocks.count += numberAt(blocks, "count");
-		merged.eslintBlocks.closedCount += numberAt(blocks, "closedCount");
-		merged.eslintBlocks.unboundedCount += numberAt(blocks, "unboundedCount");
-		merged.eslintBlocks.coveredLines += numberAt(blocks, "coveredLines");
-		mergeRuleCounts(merged.eslintBlocks.byRule, blocks["byRule"]);
+		for (const linter of linters) {
+			const keys = outputKeys[linter];
+			for (const key of [keys.nextLine, keys.line]) {
+				const counts = recordAt(result, key);
+				merged[key].count += numberAt(counts, "count");
+				mergeRuleCounts(merged[key].byRule, counts["byRule"]);
+			}
+			const blocks = recordAt(result, keys.blocks);
+			const mergedBlocks = merged[keys.blocks];
+			mergedBlocks.count += numberAt(blocks, "count");
+			mergedBlocks.closedCount += numberAt(blocks, "closedCount");
+			mergedBlocks.unboundedCount += numberAt(blocks, "unboundedCount");
+			mergedBlocks.coveredLines += numberAt(blocks, "coveredLines");
+			mergeRuleCounts(mergedBlocks.byRule, blocks["byRule"]);
+		}
 		const ts = recordAt(result, "tsDirectives");
 		merged.tsDirectives.ignore += numberAt(ts, "ignore");
 		merged.tsDirectives.expectError += numberAt(ts, "expectError");
@@ -49780,8 +49839,8 @@ var mergeDirectives = (fileResults) => {
 };
 var directivesCollector = {
 	name: "directives",
-	description: "ESLint suppression comments (by rule; block disables as gray areas) and @ts-ignore/@ts-expect-error/@ts-nocheck counts",
-	version: "1",
+	description: "ESLint and oxlint suppression comments (by linter and rule; block disables as gray areas) and @ts-ignore/@ts-expect-error/@ts-nocheck counts",
+	version: "2",
 	strategy: "tree",
 	defaultSampling: "all",
 	collect: ({ repoRoot, catalogPath, sha, cacheKey }) => scanTreeWithBlobCache({
@@ -49794,22 +49853,28 @@ var directivesCollector = {
 	}).pipe(map$6((files) => mergeDirectives(files.map((file) => file.result)))),
 	normalize: (raw) => {
 		const facts = [];
-		for (const [key, type] of [
-			["eslintNextLine", "next-line"],
-			["eslintLine", "line"],
-			["eslintBlocks", "block"]
-		]) for (const [rule, count] of Object.entries(recordAt(recordAt(raw, key), "byRule"))) if (typeof count === "number") facts.push({
-			metric: "directives.eslint",
-			value: count,
-			categories: {
-				type,
-				rule
-			}
-		});
-		facts.push({
-			metric: "directives.eslintBlockCoveredLines",
-			value: numberAt(recordAt(raw, "eslintBlocks"), "coveredLines")
-		});
+		for (const linter of linters) {
+			const keys = outputKeys[linter];
+			const kinds = [
+				[keys.nextLine, "next-line"],
+				[keys.line, "line"],
+				[keys.blocks, "block"]
+			];
+			for (const [key, type] of kinds) for (const [rule, count] of Object.entries(recordAt(recordAt(raw, key), "byRule"))) if (typeof count === "number") facts.push({
+				metric: "directives.lint",
+				value: count,
+				categories: {
+					linter,
+					type,
+					rule
+				}
+			});
+			facts.push({
+				metric: "directives.lintBlockCoveredLines",
+				value: numberAt(recordAt(raw, keys.blocks), "coveredLines"),
+				categories: { linter }
+			});
+		}
 		const ts = recordAt(raw, "tsDirectives");
 		for (const type of [
 			"ignore",
@@ -52054,15 +52119,17 @@ var sumMetric = (commit, metric, filter) => {
 	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;
 	return total;
 };
-var groupMetric = (commit, metric, categoryKey) => {
+/** Sums a metric's values by a key derived from each fact's categories. */
+var groupMetricBy = (commit, metric, keyOf) => {
 	const grouped = {};
 	for (const facts of commit.factsByCollector.values()) for (const fact of facts) {
 		if (fact.metric !== metric) continue;
-		const key = fact.categories?.[categoryKey] ?? "(unknown)";
+		const key = keyOf(fact.categories ?? {});
 		grouped[key] = (grouped[key] ?? 0) + fact.value;
 	}
 	return grouped;
 };
+var groupMetric = (commit, metric, categoryKey) => groupMetricBy(commit, metric, (categories) => categories[categoryKey] ?? "(unknown)");
 var hasMetric = (commit, metric) => commit.factsByCollector.values().some((facts) => facts.some((fact) => fact.metric === metric));
 /** Re-keys a numeric record, summing values whose new keys collide. */
 var sumByKey = (record, keyOf) => {
@@ -52127,15 +52194,6 @@ var buildDashboardData = (repoRoot, commits, config, remoteUrl, lineageOf) => {
 		};
 	};
 	const span = spanOf(commits);
-	const commitRows = commits.map((commit) => ({
-		sha: commit.sha.slice(0, 10),
-		date: commit.authoredAt,
-		author: commit.authorEmail,
-		kind: config.resolveContributor(commit.authorEmail, commit.authorName).kind,
-		ai: coAuthorsOf(commit).some((identity) => resolveCoAuthor(identity).resolved.kind === "ai"),
-		added: sumMetric(commit, "churn.added"),
-		deleted: sumMetric(commit, "churn.deleted")
-	}));
 	const languages = composeSeries((commit) => hasMetric(commit, "languages.lines"), (commit) => ({
 		sha: commit.sha.slice(0, 10),
 		date: commit.committedAt,
@@ -52149,15 +52207,18 @@ var buildDashboardData = (repoRoot, commits, config, remoteUrl, lineageOf) => {
 		totalBytes: sumMetric(commit, "files.bytes")
 	}));
 	const directives = composeSeries((commit) => hasMetric(commit, "directives.ts"), (commit) => {
-		const byType = groupMetric(commit, "directives.eslint", "type");
+		const lint = groupMetricBy(commit, "directives.lint", (categories) => `${categories["linter"]} ${categories["type"]}`);
 		const ts = groupMetric(commit, "directives.ts", "type");
 		return {
 			sha: commit.sha.slice(0, 10),
 			date: commit.committedAt,
-			eslintNextLine: byType["next-line"] ?? 0,
-			eslintLine: byType["line"] ?? 0,
-			eslintBlocks: byType["block"] ?? 0,
-			blockCoveredLines: sumMetric(commit, "directives.eslintBlockCoveredLines"),
+			eslintNextLine: lint["eslint next-line"] ?? 0,
+			eslintLine: lint["eslint line"] ?? 0,
+			eslintBlocks: lint["eslint block"] ?? 0,
+			oxlintNextLine: lint["oxlint next-line"] ?? 0,
+			oxlintLine: lint["oxlint line"] ?? 0,
+			oxlintBlocks: lint["oxlint block"] ?? 0,
+			blockCoveredLines: sumMetric(commit, "directives.lintBlockCoveredLines"),
 			tsIgnore: ts["ignore"] ?? 0,
 			tsExpectError: ts["expectError"] ?? 0,
 			tsNocheck: ts["nocheck"] ?? 0,
@@ -52177,8 +52238,8 @@ var buildDashboardData = (repoRoot, commits, config, remoteUrl, lineageOf) => {
 			byPackageManager: groupMetric(commit, "dependencies.resolved", "packageManager")
 		};
 	});
-	const latestWithDirectives = commits.findLast((commit) => hasMetric(commit, "directives.eslint"));
-	const topRules = latestWithDirectives ? Object.entries(groupMetric(latestWithDirectives, "directives.eslint", "rule")).toSorted(([, left], [, right]) => right - left).slice(0, 20).map(([rule, count]) => ({
+	const latestWithDirectives = commits.findLast((commit) => hasMetric(commit, "directives.lint"));
+	const topRules = latestWithDirectives ? Object.entries(groupMetric(latestWithDirectives, "directives.lint", "rule")).toSorted(([, left], [, right]) => right - left).slice(0, 20).map(([rule, count]) => ({
 		rule,
 		count
 	})) : [];
@@ -52243,7 +52304,7 @@ var buildDashboardData = (repoRoot, commits, config, remoteUrl, lineageOf) => {
 	const fileSurvival = survivalSeriesOf("survival.files");
 	const contributorMap = /* @__PURE__ */ new Map();
 	/**
-	* Fetches or creates a contributor's bucket.
+	* Fetches or creates a contributor's entry.
 	*
 	* Humans key off their canonical email alone, so an alias group folds every
 	* spelling of one person together. Bots and AI agents key off their name too:
@@ -52252,65 +52313,44 @@ var buildDashboardData = (repoRoot, commits, config, remoteUrl, lineageOf) => {
 	* identity worth telling apart. Giving such a group a `displayName` in the
 	* config merges them back into one.
 	*/
-	const bucketFor = (resolved, observedName) => {
+	const contributorFor = (resolved, observedName) => {
 		const name = nameOf(resolved, observedName);
 		const email = resolved.canonicalEmail.toLowerCase();
 		const key = resolved.kind === "human" ? email : `${name.toLowerCase()}\u{1F}${email}`;
-		const bucket = contributorMap.get(key) ?? {
+		const contributor = contributorMap.get(key) ?? {
+			index: contributorMap.size,
 			email: resolved.canonicalEmail,
 			name,
 			url: resolved.url,
-			kind: resolved.kind,
-			commits: 0,
-			added: 0,
-			deleted: 0,
-			assistedBy: {},
-			assisted: {}
+			kind: resolved.kind
 		};
-		bucket.name = name;
-		contributorMap.set(key, bucket);
-		return bucket;
+		contributor.name = name;
+		contributorMap.set(key, contributor);
+		return contributor;
 	};
-	for (const [index, commit] of commits.entries()) {
-		const row = commitRows[index];
-		if (!row) continue;
+	const commitRows = commits.map((commit) => {
 		const author = config.resolveContributor(commit.authorEmail, commit.authorName);
-		const authorBucket = bucketFor(author, commit.authorName);
-		authorBucket.commits += 1;
-		authorBucket.added += row.added;
-		authorBucket.deleted += row.deleted;
+		const contributor = contributorFor(author, commit.authorName).index;
+		const coAuthors = coAuthorsOf(commit).map(resolveCoAuthor);
 		const helpers = /* @__PURE__ */ new Set();
-		for (const identity of coAuthorsOf(commit)) {
-			const { name, resolved } = resolveCoAuthor(identity);
-			if (resolved.kind !== author.kind) helpers.add(bucketFor(resolved, name));
-		}
-		const helperKinds = /* @__PURE__ */ new Set();
-		for (const helper of helpers) {
-			helper.assisted[author.kind] = (helper.assisted[author.kind] ?? 0) + 1;
-			helperKinds.add(helper.kind);
-		}
-		for (const kind of helperKinds) authorBucket.assistedBy[kind] = (authorBucket.assistedBy[kind] ?? 0) + 1;
-	}
-	const sumCounts = (counts) => Object.values(counts).reduce((total, count) => total + count, 0);
-	/** Ranking weight: authoring and helping both count as taking part. */
-	const involvementOf = (bucket) => bucket.commits + sumCounts(bucket.assisted);
-	/** Emitted as absent rather than `{}` so the JSON stays lean. */
-	const countsOrUndefined = (counts) => Object.keys(counts).length === 0 ? void 0 : counts;
-	const perKindCap = config.maxInCharts * 2;
-	const keptPerKind = {
-		human: 0,
-		bot: 0,
-		ai: 0
-	};
-	const contributors = contributorMap.values().toArray().toSorted((left, right) => involvementOf(right) - involvementOf(left)).filter((bucket) => {
-		if (keptPerKind[bucket.kind] >= perKindCap) return false;
-		keptPerKind[bucket.kind] += 1;
-		return true;
-	}).map((bucket) => ({
-		...bucket,
-		assistedBy: countsOrUndefined(bucket.assistedBy),
-		assisted: countsOrUndefined(bucket.assisted)
-	}));
+		for (const { name, resolved } of coAuthors) if (resolved.kind !== author.kind) helpers.add(contributorFor(resolved, name).index);
+		return {
+			sha: commit.sha.slice(0, 10),
+			date: commit.authoredAt,
+			contributor,
+			kind: author.kind,
+			ai: coAuthors.some(({ resolved }) => resolved.kind === "ai"),
+			added: sumMetric(commit, "churn.added"),
+			deleted: sumMetric(commit, "churn.deleted"),
+			...helpers.size > 0 && { helpers: [...helpers] }
+		};
+	});
+	const contributors = contributorMap.values().map(({ email, name, url, kind }) => ({
+		email,
+		name,
+		url,
+		kind
+	})).toArray();
 	return {
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		config: {