flagrm 0.3.0 → 0.4.0

package/dist/core/scope-files.js

@@ -0,0 +1,14 @@
+/**
+ * A file-scoped name (a local, parameter or field) is also used in the files
+ * that share its file's scope, such as an Angular component's template. The
+ * adapter whose project contains the file says which (`Adapter.scopeFiles`).
+ */
+import path from "node:path";
+import { relativePath } from "./util.js";
+/** `rel` (relative to the config `root`) followed by the files sharing its scope, relative too, each once. */
+export function withScopeFiles(projects, root, rel) {
+    const file = path.resolve(root, rel);
+    const owner = projects.find(({ ctx }) => !path.relative(ctx.root, file).startsWith(".."));
+    const more = owner?.adapter.scopeFiles?.(owner.ctx, file) ?? [];
+    return [...new Set([rel, ...more.map((f) => relativePath(root, f))])];
+}

package/dist/core/test-runner.js

@@ -0,0 +1,136 @@
+/**
+ * Which JavaScript test runner a project uses, read from `angular.json`'s
+ * test builder, config files and `package.json`, so the Angular adapter can
+ * default to a test command that writes machine-readable results, and
+ * doctor can say how to get them. Reads only; anything unreadable is `unknown`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { readJson, relativePath } from "./util.js";
+/** The test target of the first `angular.json` project that has one. */
+function angularTestTarget(root) {
+    const json = readJson(path.join(root, "angular.json"));
+    for (const project of Object.values(json?.projects ?? {})) {
+        const test = (project?.architect ?? project?.targets)?.test;
+        if (test?.builder)
+            return test;
+    }
+    return undefined;
+}
+function dependencies(root) {
+    const pkg = readJson(path.join(root, "package.json"));
+    return new Set([...Object.keys(pkg?.dependencies ?? {}), ...Object.keys(pkg?.devDependencies ?? {})]);
+}
+const hasFile = (root, pattern) => fg.sync(pattern, { cwd: root, deep: 1 }).length > 0;
+function karma(root, options) {
+    const conf = path.resolve(root, typeof options.karmaConfig === "string" ? options.karmaConfig : "karma.conf.js");
+    let text;
+    try {
+        text = fs.readFileSync(conf, "utf8");
+    }
+    catch {
+        return { kind: "karma" };
+    }
+    const outputDir = /junitReporter\s*:\s*\{[^}]*?\boutputDir\s*:\s*(['"`])([^'"`]+)\1/.exec(text)?.[2];
+    // Without a `plugins` key Karma loads every installed karma-* package.
+    const loaded = text.includes("karma-junit-reporter") ||
+        (!/\bplugins\s*:/.test(text) && dependencies(root).has("karma-junit-reporter"));
+    return loaded && outputDir
+        ? { kind: "karma", junit: { outputDir: path.resolve(path.dirname(conf), outputDir) } }
+        : { kind: "karma" };
+}
+export function detectTestRunner(root) {
+    const target = angularTestTarget(root);
+    const builder = target?.builder ?? "";
+    const options = target?.options ?? {};
+    if (builder === "@angular/build:unit-test")
+        return options.runner === "karma" ? karma(root, options) : { kind: "vitest-ng" };
+    if (builder.endsWith(":karma"))
+        return karma(root, options);
+    if (builder.startsWith("@angular-builders/jest"))
+        return { kind: "jest", viaNg: true };
+    if (hasFile(root, "jest.config.{js,ts,mjs,cjs,json}"))
+        return { kind: "jest", viaNg: false };
+    if (hasFile(root, "vitest.config.{js,ts,mjs,cjs,mts}"))
+        return { kind: "vitest" };
+    const deps = dependencies(root);
+    if (deps.has("jest"))
+        return { kind: "jest", viaNg: false };
+    if (deps.has("vitest"))
+        return { kind: "vitest" };
+    if (hasFile(root, "karma.conf.{js,cjs,ts}"))
+        return karma(root, {});
+    return { kind: "unknown" };
+}
+/** The flags that make each runner write results to `file` (quoted, relative to the project). */
+function resultFlags(runner, file) {
+    switch (runner.kind) {
+        case "vitest-ng":
+            // The unit-test builder's --output-file applies to the first reporter only.
+            return `--reporters=junit --output-file="${file("junit.xml")}"`;
+        case "jest":
+            return runner.viaNg ? undefined : `--json --outputFile="${file("jest.json")}"`;
+        case "vitest":
+            return `--reporter=default --reporter=junit --outputFile.junit="${file("junit.xml")}"`;
+        default:
+            return undefined;
+    }
+}
+const RESULT_FILE = {
+    "vitest-ng": "junit.xml",
+    jest: "jest.json",
+    vitest: "junit.xml",
+};
+/**
+ * A test command for the runner that writes results into `resultsDir`, and
+ * where to read them. Undefined when the runner can't without a setup change
+ * (Karma without a JUnit reporter, Jest through an Angular builder, unknown).
+ */
+export function runnerTestCommands(runner, projectRoot, resultsDir) {
+    if (runner.kind === "karma") {
+        return runner.junit
+            ? {
+                test: "npx ng test --watch=false --reporters=progress --reporters=junit",
+                testResults: path.join(runner.junit.outputDir, "**", "*.xml"),
+            }
+            : undefined;
+    }
+    const flags = resultFlags(runner, (name) => relativePath(projectRoot, path.join(resultsDir, name)));
+    const name = RESULT_FILE[runner.kind];
+    if (!flags || !name)
+        return undefined;
+    const base = runner.kind === "vitest-ng"
+        ? "npx ng test --watch=false"
+        : runner.kind === "jest"
+            ? "npx jest --ci"
+            : "npx vitest run";
+    return { test: `${base} ${flags}`, testResults: path.join(resultsDir, name) };
+}
+/**
+ * How to get test results for a project whose test command has none: one
+ * line for doctor and init. `dirFromProject` is a results directory relative
+ * to the project (for the command), `dirFromConfig` the same relative to the
+ * config file (for `testResults`). `adapterDefault`: the adapter's default
+ * test command writes results for this runner (Angular), so removing `test` is a fix too.
+ * `configRoot`: the config file's directory, for a results directory karma.conf.js names.
+ */
+export function testResultsHint(runner, dirFromProject, dirFromConfig, adapterDefault, configRoot) {
+    const flags = resultFlags(runner, (name) => `${dirFromProject}/${name}`);
+    const name = RESULT_FILE[runner.kind];
+    const fallback = adapterDefault ? " (or remove `test` to use the adapter default)" : "";
+    if (flags && name) {
+        return `add \`${flags}\` to the test command and set testResults: ${dirFromConfig}/${name}${fallback}`;
+    }
+    if (runner.kind === "karma" && runner.junit) {
+        const results = `./${relativePath(configRoot, runner.junit.outputDir)}/**/*.xml`;
+        return `add \`--reporters=progress --reporters=junit\` to the test command and set testResults: ${results}${fallback}`;
+    }
+    if (runner.kind === "karma") {
+        return "npm i -D karma-junit-reporter, add require('karma-junit-reporter') to plugins and junitReporter: { outputDir: 'test-results' } to karma.conf.js; the angular adapter's default test command then writes JUnit";
+    }
+    if (runner.kind === "jest") {
+        return `add \`--json --outputFile="${dirFromProject}/jest.json"\` to the test command if @angular-builders/jest passes them on, and set testResults: ${dirFromConfig}/jest.json`;
+    }
+    return "make the test runner write JUnit XML, TRX or Jest JSON and point testResults at the file";
+}

package/dist/core/types.js

@@ -18,11 +18,16 @@
  *   counts and at most 20 short failed test names (`failedTests`), no
  *   `config`. `baseline.json` itself is unchanged, so version 6 files are
  *   still read.
+ * - 8: `lint` runs (`check: "lint"`) and the `lint` and `coverage` checks;
+ *   `baseline.json` gains the config's `lint` commands and `git.dirtyHashes`.
+ *   Both are optional, so version 6 and 7 files are still read.
  */
-export const JSON_SCHEMA_VERSION = 7;
-/** `baseline.json` versions this flagrm reads: 7 only added optional fields to 6. */
-export const READABLE_BASELINE_VERSIONS = [6, 7];
+export const JSON_SCHEMA_VERSION = 8;
+/** `baseline.json` versions this flagrm reads: 7 and 8 only added optional fields to 6. */
+export const READABLE_BASELINE_VERSIONS = [6, 7, 8];
 // ---------------------------------------------------------------------------
 // verify
 // ---------------------------------------------------------------------------
-export const CHECK_IDS = ["leftovers", "dead-code", "build", "tests"];
+export const CHECK_IDS = ["leftovers", "dead-code", "build", "tests", "lint", "coverage"];
+/** The check that judges each kind of command run. */
+export const RUN_CHECK_ID = { build: "build", test: "tests", lint: "lint" };

package/dist/core/verify/commands.js

@@ -4,16 +4,21 @@
  * tests of the OFF path is part of removing a flag, losing any other test is not.
  * A changed test file none of whose tests ran is a warning too: the test
  * command doesn't cover it, so verify didn't check the edit.
+ *
+ * The `lint` check: a failing lint command fails. One that already failed at
+ * the baseline (lint debt) only warns, unless its log has error lines the
+ * baseline's didn't.
  */
 import fs from "node:fs";
 import path from "node:path";
-import { errorExcerpt, templateCheckGap } from "../baseline.js";
+import { errorExcerpt, logLines, looksLikeError, templateCheckGap } from "../baseline.js";
 import { projectCommands } from "../config-snapshot.js";
 import { escapeRegExp, isTestPath } from "../scan.js";
+import { RUN_CHECK_ID, } from "../types.js";
 import { relativePath } from "../util.js";
 import { checkResult, configFindings, plural, skippedResult } from "./context.js";
-import { classifyRemovedTests } from "./removed-tests.js";
-import { diffTestNames, shortTestNames, splitFailures } from "./test-results.js";
+import { classifyRemovedTests, declaredTestDiff } from "./removed-tests.js";
+import { diffTestNames, hasTestNames, shortTestNames, splitFailures } from "./test-results.js";
 function failedRunFindings(run) {
     const findings = [
         {
@@ -35,8 +40,9 @@ function setupFinding(run) {
     return { severity: "info", message: `setup problem: ${run.failure?.message}`, project: run.project };
 }
 /** No command to run: skipped, unless the baseline had one, which is worth a warning. */
-function noCommandResult(v, id) {
-    const summary = `no ${id === "build" ? "build" : "test"} command configured`;
+function noCommandResult(v, kind) {
+    const id = RUN_CHECK_ID[kind];
+    const summary = `no ${kind} command configured`;
     const findings = configFindings(v, id);
     return findings.length ? checkResult(id, summary, findings) : skippedResult(id, summary);
 }
@@ -63,15 +69,104 @@ export function buildCheck(v) {
         : `${runs.map((r) => r.project).join(", ")} built successfully`;
     return checkResult("build", summary, findings);
 }
+export function lintCheck(v) {
+    const runs = v.runs.filter((r) => r.check === "lint");
+    if (runs.length === 0)
+        return noCommandResult(v, "lint");
+    const findings = [];
+    let failed = 0;
+    let known = 0;
+    for (const run of runs) {
+        if (run.exitCode === 0)
+            continue;
+        const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "lint");
+        // A setup problem, or a run cut short, is no lint debt: it fails even when the baseline failed too.
+        if (run.failure || run.interrupted || !before || before.exitCode === 0 || before.failure || before.interrupted) {
+            failed++;
+            findings.push(...failedRunFindings(run));
+            if (!before) {
+                findings.push({
+                    severity: "info",
+                    message: "the baseline has no lint run to compare with (lint configured after it, or baseline --no-checks), so every lint error fails: show the user",
+                    project: run.project,
+                });
+            }
+            continue;
+        }
+        const debt = knownLintFindings(before, run);
+        if (debt.some((f) => f.severity === "fail"))
+            failed++;
+        else
+            known++;
+        findings.push(...debt);
+    }
+    findings.push(...configFindings(v, "lint"));
+    const summary = failed
+        ? `${plural(failed, "lint run")} failed`
+        : known
+            ? `${plural(known, "lint run fails", "lint runs fail")} as at the baseline`
+            : `${runs.map((r) => r.project).join(", ")} linted cleanly`;
+    return checkResult("lint", summary, findings);
+}
+/**
+ * A lint run that failed at the baseline too: compared line by line with the
+ * baseline's log. Numbers are masked first, so an old error whose line moved
+ * (`40:5` → `30:5`) or a changed problem count isn't new. Lines are counted,
+ * not just compared: ESLint prints an error without its file, so a second
+ * identical one is still new. A new line that looks like an error fails; other
+ * new lines only warn. At most 20 are listed, errors first.
+ */
+function knownLintFindings(before, run) {
+    const was = logLines(before.log);
+    if (!was) {
+        return [
+            {
+                severity: "warn",
+                message: `lint already failed at the baseline; its log wasn't found, so new errors can't be told (log: ${run.log})`,
+                project: run.project,
+                file: run.log,
+            },
+        ];
+    }
+    const mask = (line) => line.replace(/\d+/g, "#");
+    const seen = new Map();
+    for (const line of was)
+        seen.set(mask(line), (seen.get(mask(line)) ?? 0) + 1);
+    const added = (logLines(run.log) ?? []).filter((line) => {
+        const left = seen.get(mask(line)) ?? 0;
+        seen.set(mask(line), left - 1);
+        return left <= 0;
+    });
+    const errors = added.filter(looksLikeError);
+    const listed = [...errors, ...added.filter((line) => !looksLikeError(line))].slice(0, 20);
+    const head = errors.length
+        ? {
+            severity: "fail",
+            message: `lint already failed at the baseline, but ${plural(errors.length, "error line is", "error lines are")} new: fix ${errors.length === 1 ? "it" : "them"} (log: ${run.log})`,
+            project: run.project,
+            file: run.log,
+        }
+        : {
+            severity: "warn",
+            message: `lint already failed at the baseline: ${added.length ? `${plural(added.length, "new line")} in the log, none an error` : "no new lines in the log"} (log: ${run.log})`,
+            project: run.project,
+            file: run.log,
+        };
+    return [
+        head,
+        ...listed.map((line) => ({ severity: "info", message: `new: ${line}`, project: run.project })),
+    ];
+}
 export function compareTests(v) {
     const out = [];
     for (const run of v.runs.filter((r) => r.check === "test")) {
         const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "test")?.results;
         const after = run.results;
+        const counted = (r) => (r && (r.total > 0 || hasTestNames(r)) ? r.total : undefined);
         const comparison = {
             project: run.project,
-            before: before?.total,
-            after: after?.total,
+            before: counted(before),
+            after: counted(after),
             removed: [],
             added: [],
             deleted: [],
@@ -88,16 +183,40 @@ export function compareTests(v) {
             comparison.newFailures = shortTestNames(failures.new);
             comparison.knownFailures = shortTestNames(failures.known);
         }
-        if (before && after) {
+        const projectRoot = v.projects.find(({ ctx }) => ctx.name === run.project)?.ctx.root;
+        const removedCtx = {
+            root: v.root,
+            sha: v.baseline.git.sha,
+            changedFiles: projectRoot
+                ? (v.changedFiles ?? []).filter((rel) => !path.relative(projectRoot, path.join(v.root, rel)).startsWith(".."))
+                : v.changedFiles,
+            names: v.baseline.names,
+            testConfigChanged: v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project),
+        };
+        if (hasTestNames(before) && hasTestNames(after)) {
             const { removed, added } = diffTestNames(before.names, after.names);
             Object.assign(comparison, { removed, added });
-            Object.assign(comparison, classifyRemovedTests(removed, added, after.names, {
-                root: v.root,
-                sha: v.baseline.git.sha,
-                changedFiles: v.changedFiles,
-                names: v.baseline.names,
-                testConfigChanged: v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project),
-            }));
+            Object.assign(comparison, classifyRemovedTests(removed, added, after.names, removedCtx));
+        }
+        else {
+            // No names from result files on both sides: the test files' declarations show what the diff deleted or renamed.
+            const declared = declaredTestDiff(removedCtx);
+            const { renamed } = classifyRemovedTests(declared.removed, declared.added, declared.now, removedCtx, declared.files);
+            const from = new Set(renamed.map((r) => r.from));
+            Object.assign(comparison, {
+                removed: declared.removed,
+                added: declared.added,
+                renamed,
+                deleted: declared.removed.filter((name) => !from.has(name)),
+            });
+            if (comparison.before !== undefined && comparison.after !== undefined) {
+                const gap = comparison.before - comparison.after - comparison.deleted.length + (declared.added.length - renamed.length);
+                if (gap > 0) {
+                    comparison.missing = gap;
+                    if (declared.rows)
+                        comparison.missingMayBeRows = true;
+                }
+            }
         }
         out.push(comparison);
     }
@@ -106,13 +225,19 @@ export function compareTests(v) {
 /**
  * For a test run that exited non-zero: its failed tests split into the ones
  * that already failed at the baseline and new ones. Undefined when that can't
- * be told (no result files now or at the baseline, or none of them failed, so
+ * be told (no results now or at the baseline, from different sources, or none of them failed, so
  * the command broke some other way).
  */
 function splitBaselineFailures(v, run) {
     const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "test")?.results;
     if (!before || !run.results?.failed)
         return undefined;
+    // Counts without all their names (a log may not name every failing test) can't be split.
+    if (run.results.failedNames.length < run.results.failed || before.failedNames.length < before.failed)
+        return undefined;
+    // Names from a log and from result files aren't spelled alike, so they can't be matched.
+    if ((before.source ?? "files") !== (run.results.source ?? "files"))
+        return undefined;
     return splitFailures(before.failedNames, run.results.failedNames);
 }
 /**
@@ -125,7 +250,10 @@ function failedTestFindings(run, failures, accepted = false) {
         .slice(0, 20)
         .map((name) => ({ severity: "info", message: `${prefix}: ${name}`, project: run.project }));
     if (!failures) {
-        return [...failedRunFindings(run).slice(0, 1), ...list(run.results?.failedNames ?? [], "failed")];
+        const names = run.results?.failedNames ?? [];
+        const [head, ...excerpt] = failedRunFindings(run);
+        // Without failing test names, the log's error lines are all there is to go on; the caller adds a setup problem.
+        return [head, ...(names.length || run.failure ? [] : excerpt), ...list(names, "failed")];
     }
     if (failures.new.length === 0) {
         return [
@@ -160,7 +288,7 @@ function failedTestFindings(run, failures, accepted = false) {
 export function testsCheck(v, comparisons) {
     const runs = v.runs.filter((r) => r.check === "test");
     if (runs.length === 0)
-        return noCommandResult(v, "tests");
+        return noCommandResult(v, "test");
     const findings = configFindings(v, "tests");
     let failed = 0;
     let known = 0;
@@ -178,14 +306,14 @@ export function testsCheck(v, comparisons) {
         const ctx = entry?.ctx;
         const testResults = entry && projectCommands(entry.adapter, entry.ctx).testResults;
         const comparison = comparisons.find((c) => c.project === run.project);
-        if (testResults && !run.results) {
+        if (testResults && !hasTestNames(run.results)) {
             findings.push({
                 severity: "warn",
-                message: `no test results found at ${testResults}, so the test count was not compared`,
+                message: `no test results found at ${testResults}, so tests were not compared by name${run.results ? " (failing tests and counts read from the log)" : ""}`,
                 project: run.project,
             });
         }
-        else if (run.results && comparison?.before === undefined) {
+        else if (hasTestNames(run.results) && comparison?.before === undefined) {
             findings.push({
                 severity: "info",
                 message: "the baseline has no test results to compare with (run `flagrm baseline` before the removal)",
@@ -203,7 +331,16 @@ export function testsCheck(v, comparisons) {
                 findings.push({ severity: "info", message: `no longer runs: ${name}`, project: run.project });
             }
         }
-        if (run.results && ctx) {
+        const missing = comparison?.missing ?? 0;
+        if (missing > 0 && comparison) {
+            const configChanged = v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project);
+            findings.push({
+                severity: configChanged || comparison.missingMayBeRows ? "info" : "warn",
+                message: `${plural(missing, "more test stopped running", "more tests stopped running")} than the diff deletes (${comparison.before} → ${comparison.after}, ${comparison.deleted.length} deleted): account for ${missing === 1 ? "it" : "them"} in the PR${comparison.missingMayBeRows ? " (data rows and .each cases count separately, so this may be them)" : ""}`,
+                project: run.project,
+            });
+        }
+        if (hasTestNames(run.results) && ctx) {
             for (const file of changedTestFiles(v, ctx.root)) {
                 if (testFileRan(file, ctx.root, run.results.names))
                     continue;
@@ -226,6 +363,7 @@ export function testsCheck(v, comparisons) {
             c.renamed.length && `${c.renamed.length} renamed`,
             c.excludedByConfig.length && `${c.excludedByConfig.length} excluded by config`,
             c.unexplained.length && `${c.unexplained.length} unexplained`,
+            c.missing && `${c.missing} unaccounted for`,
         ].filter(Boolean);
         return `${c.project} ${c.before} → ${c.after}${why.length ? `: ${why.join(", ")}` : ""}`;
     });

package/dist/core/verify/coverage.js

@@ -0,0 +1,92 @@
+/**
+ * The `coverage` check: a file the removal changed that no build, test or
+ * lint command checks is a warning. A project covers a file inside its path
+ * when it ran a command in this verify (or has one `--skip` left out) and one
+ * of its `covers` globs (relative to its path; default: everything) matches
+ * the file. A file that was already dirty at the baseline and hasn't changed
+ * since is no edit of the removal. Outside every project, deleted files and
+ * documentation have nothing for a command to check.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { excludeMatcher } from "../change-filter.js";
+import { projectCommands } from "../config-snapshot.js";
+import { blobIds } from "../git.js";
+import { RUN_CHECK_ID } from "../types.js";
+import { relativePath } from "../util.js";
+import { checkResult, plural, skippedResult } from "./context.js";
+/** More uncovered files than this are counted per top-level directory instead. */
+const MAX_FILES = 20;
+const UNCHECKED = "no build, test or lint command checks";
+const DOCS = /\.(?:md|mdx|markdown|txt|rst|adoc)$/i;
+export function coverageCheck(v) {
+    if (!v.changedFiles)
+        return skippedResult("coverage", "no baseline commit to diff against");
+    const skipped = Object.keys(RUN_CHECK_ID).filter((kind) => v.skip?.has(RUN_CHECK_ID[kind]));
+    if (skipped.length === 3)
+        return skippedResult("coverage", "build, tests and lint skipped (--skip), so no command ran");
+    const ran = new Set(v.runs.map((r) => r.project));
+    const projects = v.projects.map(({ adapter, ctx }) => {
+        const covers = ctx.project.covers;
+        const commands = projectCommands(adapter, ctx);
+        return {
+            name: ctx.name,
+            root: ctx.root,
+            // A command --skip left out would have checked the file: no reason to warn about the config.
+            ran: ran.has(ctx.name) || skipped.some((kind) => commands[kind]),
+            covers: covers ? excludeMatcher(covers.map(coversGlob)) : () => true,
+        };
+    });
+    const uncovered = [];
+    for (const file of removalFiles(v, v.changedFiles)) {
+        const containing = projects
+            .map((p) => ({ ...p, rel: relativePath(p.root, path.join(v.root, file)) }))
+            .filter((p) => p.rel !== ".." && !p.rel.startsWith("../") && !path.isAbsolute(p.rel));
+        if (containing.some((p) => p.ran && p.covers(p.rel)))
+            continue;
+        // Outside every project, documentation and deleted files have nothing for a command to check.
+        if (containing.length === 0 && (DOCS.test(file) || !fs.existsSync(path.join(v.root, file))))
+            continue;
+        const innermost = containing.sort((a, b) => b.root.length - a.root.length)[0];
+        uncovered.push({ file, project: innermost?.name });
+    }
+    if (uncovered.length === 0)
+        return checkResult("coverage", "every changed file is built, tested or linted", []);
+    const findings = uncovered.length > MAX_FILES
+        ? byDirectory(uncovered)
+        : uncovered.map(({ file, project }) => ({
+            severity: "warn",
+            message: `${file}: ${UNCHECKED} it`,
+            ...(project ? { project } : {}),
+        }));
+    return checkResult("coverage", `${plural(uncovered.length, "changed file")} no command checks`, findings);
+}
+/** The changed files without the ones dirty at the baseline and unchanged since (all of them, for a baseline without their hashes). */
+function removalFiles(v, changed) {
+    const { dirtyFiles = [], dirtyHashes } = v.baseline.git ?? {};
+    const dirty = new Set(dirtyFiles);
+    const candidates = changed.filter((rel) => dirty.has(rel));
+    if (candidates.length === 0)
+        return changed;
+    if (!dirtyHashes)
+        return changed.filter((rel) => !dirty.has(rel));
+    const now = blobIds(v.root, candidates);
+    return changed.filter((rel) => !dirty.has(rel) || !(rel in dirtyHashes) || now[rel] !== dirtyHashes[rel]);
+}
+/** A `covers` entry as a glob: `./src/**` is how the rest of the config writes paths, and `./` or `.` is everything. */
+function coversGlob(glob) {
+    const rel = glob.replace(/^\.\//, "").replace(/\/+$/, "");
+    return rel === "" || rel === "." ? "**" : rel;
+}
+/** One warning per top-level directory (`.` for files in the root) with its count. */
+function byDirectory(uncovered) {
+    const counts = new Map();
+    for (const { file } of uncovered) {
+        const slash = file.indexOf("/");
+        const dir = slash === -1 ? "." : `${file.slice(0, slash)}/`;
+        counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    return [...counts]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([dir, n]) => ({ severity: "warn", message: `${dir}: ${plural(n, "changed file")} ${UNCHECKED}` }));
+}

package/dist/core/verify/index.js

@@ -9,9 +9,11 @@ import { flagDir, readBaseline, runChecks, verifyPath } from "../baseline.js";
 import { changeFilter, changeFilterAt } from "../change-filter.js";
 import { configChanges as configChangesSince, configSnapshot } from "../config-snapshot.js";
 import { changedFilesSince, gitState, treeFingerprint } from "../git.js";
-import { CHECK_IDS, JSON_SCHEMA_VERSION, } from "../types.js";
-import { buildCheck, compareTests, testsCheck } from "./commands.js";
+import { dropRuns, findRuns, plannedRuns, reuseRuns, runsKey, saveRuns } from "../run-cache.js";
+import { CHECK_IDS, JSON_SCHEMA_VERSION, RUN_CHECK_ID, } from "../types.js";
+import { buildCheck, compareTests, lintCheck, testsCheck } from "./commands.js";
 import { skippedResult } from "./context.js";
+import { coverageCheck } from "./coverage.js";
 import { deadCodeCheck } from "./dead-code.js";
 import { leftoversCheck } from "./leftovers.js";
 export async function verifyFlag(root, projects, flag, options = {}) {
@@ -23,8 +25,12 @@ export async function verifyFlag(root, projects, flag, options = {}) {
     // flagrm's setup files and `exclude`d paths (the config's and --exclude) aren't part of the removal.
     const ignore = changeFilter(projects[0]?.ctx.config);
     const changedFiles = baseline.git.sha ? changedFilesSince(root, baseline.git.sha, ignore) : undefined;
-    const only = [...(skip.has("build") ? [] : ["build"]), ...(skip.has("tests") ? [] : ["test"])];
-    const runs = only.length ? await runChecks(projects, path.join(flagDir(root, flag), "verify"), only) : [];
+    const only = ["build", "test", "lint"].filter((check) => !skip.has(RUN_CHECK_ID[check]));
+    // Before the commands: the key is the tree they run on.
+    const key = only.length ? runsKey(root, projects) : undefined;
+    const found = key && options.reuse !== false ? findRuns(root, projects, key, plannedRuns(projects, only)) : undefined;
+    const logDir = path.join(flagDir(root, flag), "verify");
+    const runs = found ? reuseRuns(found, logDir) : only.length ? await runChecks(projects, logDir, only) : [];
     // The fingerprint, though, is the tree the Stop hook will see next, so take it
     // after the commands: a test report they write outside .gitignore is part of it.
     // The Stop hook compares it with its own, so take it exactly as the hook does: from the config file
@@ -33,12 +39,24 @@ export async function verifyFlag(root, projects, flag, options = {}) {
     const now = configSnapshot(projects);
     const configChanges = configChangesSince(baseline.acceptedConfig ?? baseline.config, now);
     const originalConfigChanges = baseline.acceptedConfig ? configChangesSince(baseline.config, now) : configChanges;
-    const v = { root, flag, projects, baseline, changedFiles, runs, configChanges, originalConfigChanges };
+    const v = {
+        root,
+        flag,
+        projects,
+        baseline,
+        changedFiles,
+        runs,
+        skip,
+        configChanges,
+        originalConfigChanges,
+    };
     const tests = compareTests(v);
     const run = {
         "dead-code": () => deadCodeCheck(v),
         build: () => buildCheck(v),
         tests: () => testsCheck(v, tests),
+        lint: () => lintCheck(v),
+        coverage: () => coverageCheck(v),
     };
     const checks = [];
     for (const id of CHECK_IDS) {
@@ -64,6 +82,15 @@ export async function verifyFlag(root, projects, flag, options = {}) {
         runs: runs.map(countsOnly),
         tests,
     };
+    // Only a full pass is worth reusing: a failure may be flaky or a stopped service.
+    if (key && report.status === "pass" && report.skipped.length === 0)
+        saveRuns(root, flag, projects, key, runs);
+    // A fresh run that fails on this tree outweighs a saved pass for it (`--no-reuse` after a machine change).
+    else if (key &&
+        !found &&
+        checks.some((c) => (c.id === "build" || c.id === "tests" || c.id === "lint") && c.status === "fail")) {
+        dropRuns(root, key);
+    }
     const file = verifyPath(root, flag);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`, "utf8");