flagrm 0.3.0 → 0.4.1

package/dist/adapters/angular/index.js

@@ -1,7 +1,11 @@
 import fs from "node:fs";
+import path from "node:path";
 import { discoverInText } from "../../core/discover.js";
 import { FRONTEND_GLOBS } from "../../core/scan.js";
+import { detectTestRunner, runnerTestCommands } from "../../core/test-runner.js";
+import { componentScopeFiles } from "./component-files.js";
 import { discoverTypeScript } from "./discover.js";
+import { angularFlow } from "./flow.js";
 import { angularUnusedDiagnostics } from "./unused.js";
 /**
  * Discover candidate flag names: string literals passed to configured eval
@@ -25,10 +29,25 @@ export function discoverAngularFlags(ctx) {
     }
     return out;
 }
+/** The runner per project directory: projectCommands asks for the default commands many times per command. */
+const runners = new Map();
+function testRunner(root) {
+    let runner = runners.get(root);
+    if (!runner)
+        runners.set(root, (runner = detectTestRunner(root)));
+    return runner;
+}
 export const angularAdapter = {
     id: "angular",
     defaultGlobs: FRONTEND_GLOBS,
     discover: async (ctx) => discoverAngularFlags(ctx),
-    defaultCommands: () => ({ build: "npx ng build", test: "npx ng test --watch=false" }),
+    flow: (ctx, flags) => angularFlow(ctx, flags, ctx.project.methods),
+    scopeFiles: (_ctx, file) => componentScopeFiles(file),
+    // Like the .NET adapter: when the runner can write results without setup, the default test command does, under .flagrm/.
+    defaultCommands: (ctx) => {
+        const dir = path.join(ctx.config.root, ".flagrm", "test-results", ctx.name);
+        const tests = runnerTestCommands(testRunner(ctx.root), ctx.root, dir);
+        return { build: "npx ng build", ...(tests ?? { test: "npx ng test --watch=false" }) };
+    },
     unusedDiagnostics: (_ctx, input) => angularUnusedDiagnostics(input),
 };

package/dist/adapters/angular/inputs.js

@@ -0,0 +1,181 @@
+/**
+ * One hop of a flag's value into a child component: a parent's template
+ * binds a holder (`[express]="expressShipping()"`) on an element whose tag is
+ * another component's selector, and the child's input of that binding name
+ * holds the flag too. Templates are scanned lexically; components are parsed,
+ * never type-checked. The child's own bindings are not followed.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+const ELEMENT_SELECTOR = /^[a-z][\w-]*$/i;
+/** A start tag and its attributes; quoted values may contain `>`. */
+const START_TAG = /<([a-zA-Z][\w-]*)((?:\s+[^\s"'=<>/]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*\/?>/g;
+/** `[prop]="expr"` or `[prop]='expr'`; `[attr.x]`, `[class.x]`, `[style.x]` don't match. */
+const PROPERTY_BINDING = /\[([\w$]+)\]\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** `h`, `!h`, `h()` or `!h()`. */
+const HOLDER_READ = /^!?\s*([A-Za-z_$][\w$]*)(?:\s*\(\s*\))?$/;
+const SIGNAL_INPUT = /^(?:input|model)(?:\.required)?$/;
+/**
+ * The inputs of child components that parents' templates bind one of
+ * `holders` to. An input is `ambiguous` (suggested, never recorded) when its
+ * tag maps to several components, or when another binding passes it
+ * something else: a reusable component keeps that input after the removal.
+ */
+export function childInputs(files, holders) {
+    const all = components(files);
+    const bySelector = new Map();
+    for (const c of all)
+        for (const s of c.selectors)
+            bySelector.set(s, [...(bySelector.get(s) ?? []), c]);
+    const inputs = new Map();
+    for (const parent of all) {
+        const bound = new Map();
+        for (const h of holders) {
+            if (h.cls !== parent.cls || h.kind === "local" || h.ternary || h.ambiguous)
+                continue;
+            bound.set(h.name, (bound.get(h.name) ?? new Set()).add(h.flag));
+        }
+        const template = templateOf(parent)?.replace(/<!--[\s\S]*?-->/g, "");
+        if (!template)
+            continue;
+        for (const tag of template.matchAll(START_TAG)) {
+            const children = bySelector.get(tag[1].toLowerCase());
+            if (!children)
+                continue;
+            for (const binding of tag[2].matchAll(PROPERTY_BINDING)) {
+                const read = HOLDER_READ.exec((binding[2] ?? binding[3]).trim());
+                const flags = read ? bound.get(read[1]) : undefined;
+                for (const child of children) {
+                    const input = findInput(child, binding[1]);
+                    if (!input)
+                        continue;
+                    const key = `${child.file.file}\0${child.cls.pos}\0${input.name}`;
+                    const entry = inputs.get(key) ?? { child, input, shared: false, reads: [] };
+                    inputs.set(key, entry);
+                    entry.shared ||= children.length > 1;
+                    entry.reads.push(flags);
+                }
+            }
+        }
+    }
+    const out = [];
+    for (const { child, input, shared, reads } of inputs.values()) {
+        const flags = new Set(reads.flatMap((r) => [...(r ?? [])]));
+        for (const flag of flags) {
+            const ambiguous = shared || reads.some((r) => !r?.has(flag));
+            out.push({
+                flag,
+                name: input.name,
+                kind: "field",
+                file: child.file.file,
+                line: input.line,
+                cls: child.cls,
+                ...(ambiguous ? { ambiguous: true } : {}),
+            });
+        }
+    }
+    return out;
+}
+/** The `@Component` classes of `files`, with their selectors and template. */
+function components(files) {
+    const out = [];
+    for (const file of files) {
+        if (!file.text.includes("@Component"))
+            continue;
+        for (const statement of file.sf.statements) {
+            if (!ts.isClassDeclaration(statement))
+                continue;
+            for (const decorator of ts.getDecorators(statement) ?? []) {
+                const call = decorator.expression;
+                if (!ts.isCallExpression(call) || call.expression.getText(file.sf) !== "Component")
+                    continue;
+                const options = call.arguments[0];
+                if (!options || !ts.isObjectLiteralExpression(options))
+                    continue;
+                const info = { file, cls: statement, selectors: [] };
+                for (const prop of options.properties) {
+                    if (!ts.isPropertyAssignment(prop) || !ts.isStringLiteralLike(prop.initializer))
+                        continue;
+                    const key = prop.name.getText(file.sf);
+                    const value = prop.initializer.text;
+                    if (key === "selector") {
+                        info.selectors = value
+                            .split(",")
+                            .map((s) => s.trim())
+                            .filter((s) => ELEMENT_SELECTOR.test(s))
+                            .map((s) => s.toLowerCase());
+                    }
+                    else if (key === "template") {
+                        info.template = value;
+                    }
+                    else if (key === "templateUrl") {
+                        info.templateUrl = path.resolve(path.dirname(file.file), value);
+                    }
+                }
+                out.push(info);
+            }
+        }
+    }
+    return out;
+}
+function templateOf(c) {
+    if (c.template !== undefined)
+        return c.template;
+    if (!c.templateUrl)
+        return undefined;
+    try {
+        return fs.readFileSync(c.templateUrl, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The child's member whose binding name (its `alias`, else its own name) is `binding`. */
+function findInput(child, binding) {
+    const { sf } = child.file;
+    for (const member of child.cls.members) {
+        if (!(ts.isPropertyDeclaration(member) || ts.isSetAccessorDeclaration(member)) || !ts.isIdentifier(member.name)) {
+            continue;
+        }
+        const name = member.name.text;
+        const line = sf.getLineAndCharacterOfPosition(member.name.getStart(sf)).line + 1;
+        const decorator = (ts.getDecorators(member) ?? [])
+            .map((d) => d.expression)
+            .find((e) => ts.isCallExpression(e) && e.expression.getText(sf) === "Input");
+        if (decorator) {
+            if ((aliasOf(decorator.arguments, true) ?? name) === binding)
+                return { name, line };
+            continue;
+        }
+        const init = ts.isPropertyDeclaration(member) ? member.initializer : undefined;
+        if (init &&
+            ts.isCallExpression(init) &&
+            SIGNAL_INPUT.test(init.expression.getText(sf)) &&
+            (aliasOf(init.arguments, false) ?? name) === binding) {
+            return { name, line };
+        }
+    }
+    return undefined;
+}
+/**
+ * An input's alias: `{ alias: 'x' }` among the arguments, or (for `@Input`
+ * only, where a signal input's first argument is its initial value) `'x'`.
+ */
+function aliasOf(args, stringAlias) {
+    for (const arg of args) {
+        if (stringAlias && ts.isStringLiteralLike(arg))
+            return arg.text;
+        if (!ts.isObjectLiteralExpression(arg))
+            continue;
+        for (const p of arg.properties) {
+            if (ts.isPropertyAssignment(p) &&
+                ts.isIdentifier(p.name) &&
+                p.name.text === "alias" &&
+                ts.isStringLiteralLike(p.initializer)) {
+                return p.initializer.text;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/cli.js

@@ -4,20 +4,23 @@ import path from "node:path";
 import { Command } from "commander";
 import pc from "picocolors";
 import { realProbes } from "./adapters/dotnet/setup.js";
-import { acceptBaseline, addNames, assertNoEditsSinceBaseline, baselinePath, baselineSummary, discoverFlag, flagDir, mergeNames, parseAccept, runChecks, validateAgentNames, writeBaseline, } from "./core/baseline.js";
+import { acceptBaseline, addNames, assertNoEditsSinceBaseline, baselinePath, baselineSummary, discoverFlag, mergeNames, parseAccept, validateAgentNames, writeBaseline, } from "./core/baseline.js";
 import { changeFilter } from "./core/change-filter.js";
 import { loadConfig, parseTools, TOOL_IDS } from "./core/config.js";
 import { projectCommands } from "./core/config-snapshot.js";
 import { runDoctor } from "./core/doctor.js";
-import { gitState } from "./core/git.js";
+import { blobIds, gitState } from "./core/git.js";
 import { hookRoot, parseHookInput, stopDecision } from "./core/hook.js";
 import { initProject, installRoot, updateProject } from "./core/install.js";
 import { buildInventory } from "./core/inventory.js";
 import { verifyMarkdown } from "./core/markdown.js";
+import { assertOwnNames } from "./core/name-owner.js";
 import { packageVersion } from "./core/package.js";
 import { resolveProjects } from "./core/registry.js";
 import { printBaseline, printDoctor, printInventory, printScope, printSteps, printVerifyReport, } from "./core/report.js";
+import { baselineRuns } from "./core/run-cache.js";
 import { setupReport, writeScope } from "./core/scope.js";
+import { withScopeFiles } from "./core/scope-files.js";
 import { askTools, detectTools, savedTools, TOOL_LABELS } from "./core/tools.js";
 import { CHECK_IDS } from "./core/types.js";
 import { onPath, relativePath } from "./core/util.js";
@@ -63,21 +66,23 @@ function loadWorkspace(opts) {
 // --- baseline ------------------------------------------------------------------
 addCommonOptions(program
     .command("baseline <flag>")
-    .description("record the state before removing a flag: the git commit, each project's build and test results, and the " +
+    .description("record the state before removing a flag: the git commit, each project's build, test and lint results, and the " +
     "flag's names for the leftovers check; writes .flagrm/<flag>/baseline.json for verify. With --name on an " +
     "existing baseline, only adds names"))
-    .option("--no-checks", "record only the git state, without running build and test commands")
+    .option("--no-checks", "record only the git state, without running build, test and lint commands")
+    .option("--no-reuse", "run build, tests and lint even when a passing verify on the same tree and commands saved their results")
     .option("--name <name>", "add a name the flag is read through (repeatable)", collect, [])
     .option("--kind <kind>", "how --name entries are matched: alias (qualified constant) or wrapper (identifier, calls included); default alias, wrapper with --file")
-    .option("--file <path>", "check the --name entries only in this file (a local, parameter or field; implies --kind wrapper)")
+    .option("--file <path>", "check the --name entries only in these files and the files sharing their scope, such as a component's template " +
+    "(repeatable; a local, parameter or field; implies --kind wrapper)", collect, [])
     .option("--force", "start over: replace the baseline, only while the code is unedited since it")
     .option("--accept <what>", "acknowledge without starting over, also mid-removal: config (verify stops warning about changes to the flagrm " +
     "config so far), failures (the baseline's failing tests); comma-separated")
     .action(async (flag, opts) => {
     const { root, projects } = loadWorkspace(opts);
     if (opts.accept !== undefined) {
-        if (opts.force || opts.name.length || opts.file || opts.kind || !opts.checks) {
-            fail(new Error("--accept only records an acknowledgement; run it without --force, --name, --file, --kind and --no-checks."));
+        if (opts.force || opts.name.length || opts.file.length || opts.kind || !opts.checks || !opts.reuse) {
+            fail(new Error("--accept only records an acknowledgement; run it without --force, --name, --file, --kind, --no-checks and --no-reuse."));
         }
         let accepted;
         try {
@@ -93,26 +98,34 @@ addCommonOptions(program
         return;
     }
     // Only wrappers are matched per file: a name scoped with --file is a local, parameter or field.
-    const kind = opts.kind ?? (opts.file ? "wrapper" : "alias");
+    const kind = opts.kind ?? (opts.file.length ? "wrapper" : "alias");
     if (kind !== "alias" && kind !== "wrapper") {
         fail(new Error(`--kind must be alias or wrapper, not "${kind}".`));
     }
-    if (opts.file && opts.name.length === 0)
+    if (!opts.checks && !opts.reuse)
+        fail(new Error("--no-reuse has nothing to reuse with --no-checks."));
+    if (opts.file.length && opts.name.length === 0)
         fail(new Error("--file scopes --name entries; pass --name too."));
-    if (opts.file && kind !== "wrapper")
+    if (opts.file.length && kind !== "wrapper")
         fail(new Error("--file scopes wrapper names; drop --kind alias."));
-    const scope = opts.file && relativePath(root, path.resolve(opts.file));
-    if (scope?.startsWith(".."))
-        fail(new Error(`--file ${opts.file} is outside ${root}.`));
-    const added = opts.name.map((name) => ({
+    const scopes = [
+        ...new Set(opts.file.flatMap((file) => {
+            const rel = relativePath(root, path.resolve(file));
+            if (rel.startsWith(".."))
+                fail(new Error(`--file ${file} is outside ${root}.`));
+            return withScopeFiles(projects, root, rel);
+        })),
+    ];
+    const added = opts.name.flatMap((name) => (scopes.length ? scopes : [undefined]).map((file) => ({
         name,
         kind: kind,
         source: "agent",
-        ...(scope ? { file: scope } : {}),
-    }));
+        ...(file ? { file } : {}),
+    })));
     let result;
     try {
         validateAgentNames(projects, added);
+        await assertOwnNames(root, projects, flag, added);
         const exists = fs.existsSync(baselinePath(root, flag));
         if (exists && opts.force) {
             const testResults = projects.flatMap(({ adapter, ctx }) => projectCommands(adapter, ctx).testResults ?? []);
@@ -126,7 +139,9 @@ addCommonOptions(program
         }
         else {
             const git = gitState(root);
-            const checks = opts.checks ? await runChecks(projects, flagDir(root, flag)) : undefined;
+            if (git.dirtyFiles?.length)
+                git.dirtyHashes = blobIds(root, git.dirtyFiles);
+            const checks = opts.checks ? await baselineRuns(root, flag, projects, opts.reuse) : undefined;
             const { names, ...flow } = await discoverFlag(projects, flag);
             result = writeBaseline(root, flag, projects, git, checks, mergeNames(names, added), flow);
         }
@@ -144,18 +159,23 @@ addCommonOptions(program
 // --- verify ------------------------------------------------------------------
 addCommonOptions(program
     .command("verify <flag>")
-    .description("gate a flag removal against its baseline (`flagrm baseline <flag>`): build, tests and new unused code; " +
+    .description("gate a flag removal against its baseline (`flagrm baseline <flag>`): leftovers, new unused code, build, tests, lint and coverage; " +
     "writes .flagrm/<flag>/verify.json; exit 0 pass, 1 fail, 2 usage error"))
     .option("--skip <checks>", `comma-separated checks to skip (${CHECK_IDS.join(", ")})`)
     .option("--strict", "treat warnings as failures")
     .option("--md", "print a markdown overview (for the user or a PR) instead of text")
+    .option("--no-reuse", "run build, tests and lint even when a passing verify on the same tree and commands saved their results")
     .action(async (flag, opts) => {
     if (opts.md && opts.json)
         fail(new Error("--md and --json can't be combined."));
     const { root, projects } = loadWorkspace(opts);
     let result;
     try {
-        result = await verifyFlag(root, projects, flag, { skip: parseSkip(opts.skip), strict: opts.strict });
+        result = await verifyFlag(root, projects, flag, {
+            skip: parseSkip(opts.skip),
+            strict: opts.strict,
+            reuse: opts.reuse,
+        });
     }
     catch (err) {
         fail(err);
@@ -273,10 +293,10 @@ function printInstallRoot(root) {
 // --- doctor ------------------------------------------------------------------
 program
     .command("doctor")
-    .description("check that this repository is ready for flag removal: config, build/test commands, git, .gitignore, " +
+    .description("check that this repository is ready for flag removal: config, build/test/lint commands, git, .gitignore, " +
     "installed skills and Stop hook, abandoned baselines; exit 0 ok, 1 problems")
     .option("--config <path>", "path to a config file (default: the nearest flagrm.config.yaml up to the git repository root)")
-    .option("--run", "also run each build and test command")
+    .option("--run", "also run each build, test and lint command")
     .option("--json", "machine-readable JSON output")
     .action(async (opts) => {
     const report = await runDoctor(process.cwd(), { config: opts.config, run: opts.run });

package/dist/core/baseline.js

@@ -2,14 +2,16 @@ import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
 import { changeFilter } from "./change-filter.js";
 import { configSnapshot, projectCommands } from "./config-snapshot.js";
 import { environmentProblem } from "./environment.js";
 import { changedFilesSince } from "./git.js";
 import { buildInventory } from "./inventory.js";
+import { globAbsolute } from "./scan.js";
+import { withScopeFiles } from "./scope-files.js";
 import { JSON_SCHEMA_VERSION, READABLE_BASELINE_VERSIONS, } from "./types.js";
 import { readJson, relativePath } from "./util.js";
+import { parseTestLog } from "./verify/log-results.js";
 import { collectTestResults, shortTestNames } from "./verify/test-results.js";
 /**
  * `.flagrm/<flag>/` under the config root. A name that isn't safe as a directory
@@ -78,14 +80,22 @@ export function readBaseline(root, flag) {
         throw new UsageError(`${file} was written by schema version ${baseline.schemaVersion}; this flagrm expects ${JSON_SCHEMA_VERSION}. ` +
             `Re-run \`flagrm baseline ${flag} --force\` on the code as it was before the removal.`);
     }
+    const sha = baseline.git?.sha;
+    if (sha != null && !COMMIT_ID.test(sha)) {
+        throw new UsageError(`${file} has git.sha "${sha}", which is not a git commit id. ` +
+            `Re-run \`flagrm baseline ${flag} --force\` on the code as it was before the removal.`);
+    }
     return { baseline, file };
 }
+/** A full SHA-1 or SHA-256 commit id, as `git rev-parse HEAD` prints it. */
+const COMMIT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 /**
  * Run one shell command inside a project, streaming its output to `logFile`
  * (no buffer limit, stdout and stderr interleaved as printed). A command that
  * can't start, is killed or outlives the project's `timeout` fails with the
  * reason at the end of the log. A test run also reads the `testResults`
- * files (absolute path or glob) written during it.
+ * files (absolute path or glob) written during it, or without any, what its
+ * log says (`log-results.ts`).
  */
 export async function runCheck(ctx, check, command, logFile, claimed, testResults) {
     const started = Date.now();
@@ -110,12 +120,17 @@ export async function runCheck(ctx, check, command, logFile, claimed, testResult
         durationMs: Date.now() - started,
         log: logFile,
     };
+    if (reason)
+        run.interrupted = reason;
     if (run.exitCode !== 0) {
         const problem = environmentProblem(fs.readFileSync(logFile, "utf8"), ctx.root);
         if (problem)
             run.failure = { kind: "environment", message: problem };
     }
-    const results = check === "test" && testResults ? collectTestResults(testResults, started, claimed) : undefined;
+    let results = check === "test" && testResults ? collectTestResults(testResults, started, claimed) : undefined;
+    // No result files: the runner's log still names failing tests and prints counts.
+    if (check === "test" && !results)
+        results = parseTestLog(fs.readFileSync(logFile, "utf8"));
     if (results)
         run.results = results;
     return run;
@@ -189,11 +204,12 @@ export function incrementalBuildGap(adapter, build) {
     return "`dotnet build` without `--no-incremental` skips up-to-date projects and prints none of their warnings, so the dead-code check may report existing unused code as new: add `--no-incremental` to `build`";
 }
 /**
- * Build then test every project, each command resolved on its own (see
- * `projectCommands`): the configured one, none for `false`, else the
- * adapter's default (`dotnet build --no-incremental`, `npx ng test`, ...).
+ * Build, test, then lint every project, each command resolved on its own
+ * (see `projectCommands`): the configured one, none for `false`, else the
+ * adapter's default (`dotnet build --no-incremental`, `npx ng test`, ...;
+ * lint has none).
  */
-export async function runChecks(projects, logDir, only = ["build", "test"]) {
+export async function runChecks(projects, logDir, only = ["build", "test", "lint"]) {
     const runs = [];
     // Projects whose `testResults` patterns overlap must not count each other's result files.
     const claimed = new Map();
@@ -248,23 +264,26 @@ export async function discoverFlag(projects, flag) {
     const flow = entry?.flow ?? [];
     const names = mergeNames([{ name: flag, kind: "literal", source: "discovery" }], [
         ...(entry?.definitions ?? []).map((d) => ({ name: d.name, kind: "alias", source: "discovery" })),
-        ...flow.filter((n) => n.record).map((n) => flowName(projects, n)),
+        ...flow.filter((n) => n.record).flatMap((n) => flowNames(projects, n)),
     ]);
     const key = (n) => `${n.name}\0${n.file ?? ""}`;
     const recorded = new Set(names.map(key));
     const suggestedNames = flow
-        .filter((n) => !n.record && !recorded.has(key(flowName(projects, n))))
+        .filter((n) => !n.record && !recorded.has(key(flowNames(projects, n)[0])))
         .map(({ record: _record, ...name }) => name)
         .filter((n, i, all) => all.findIndex((m) => m.name === n.name && m.file === n.file) === i);
     return { names, suggestedNames, parameterizedTests: entry?.parameterizedTests ?? [] };
 }
-/** A flow name as a wrapper; a local, parameter or field only in its own file. */
-function flowName(projects, n) {
+/** A flow name as recorded: an alias everywhere; a wrapper, a local, parameter or field only in its own file. */
+function flowNames(projects, n) {
+    if (n.kind === "alias")
+        return [{ name: n.name, kind: "alias", source: "discovery" }];
     const name = { name: n.name, kind: "wrapper", source: "discovery" };
     const root = projects[0]?.ctx.config.root;
-    if (root && (n.kind === "local" || n.kind === "parameter" || n.kind === "field"))
-        name.file = relativePath(root, n.file);
-    return name;
+    if (root && (n.kind === "local" || n.kind === "parameter" || n.kind === "field")) {
+        return withScopeFiles(projects, root, relativePath(root, n.file)).map((file) => ({ ...name, file }));
+    }
+    return [name];
 }
 /** The names {@link discoverFlag} records. */
 export async function discoverNames(projects, flag) {
@@ -295,11 +314,13 @@ export function mergeNames(existing, added) {
  * when git can't tell (not a repository, or `sha` isn't in it).
  */
 export function editsSince(root, sha, testResults = [], ignore = changeFilter()) {
-    const results = new Set(testResults.flatMap((pattern) => fg
-        .sync(path.sep === "\\" ? pattern.replace(/\\/g, "/") : pattern, { absolute: true, dot: true })
-        .map((file) => relativePath(root, file))));
+    const results = matchingFiles(root, testResults);
     return changedFilesSince(root, sha, ignore)?.filter((rel) => !results.has(rel));
 }
+/** The files (relative to `root`) matching absolute paths or globs, such as `testResults` patterns. */
+export function matchingFiles(root, patterns) {
+    return new Set(patterns.flatMap((pattern) => globAbsolute(pattern).map((file) => relativePath(root, file))));
+}
 /**
  * `baseline --force` starts over only before the removal began: the working
  * tree must still match the baseline commit. Otherwise the new baseline would
@@ -373,30 +394,38 @@ export function validateAgentNames(projects, names) {
         }
     }
 }
-/**
- * Up to `max` distinct lines of a log that look like errors, so the reader sees
- * why a command failed without opening the log. Compiler warnings and summary
- * lines such as `0 Error(s)` are skipped: in a large build they bury the one
- * real error. When no line looks like an error, the last `max` lines instead.
- */
-export function errorExcerpt(log, max = 10) {
+/** A log's non-blank lines, trimmed, without ANSI colors or the `$ <command>` header; undefined when unreadable. */
+export function logLines(log) {
     if (!log)
-        return [];
+        return undefined;
     let text;
     try {
         text = fs.readFileSync(log, "utf8");
     }
     catch {
-        return [];
+        return undefined;
     }
-    const all = text
+    return (text
         .split(/\r?\n/)
         // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ANSI colors (ngc colors even when piped)
         .map((line) => line.replace(/\u001b\[[0-9;]*m/g, "").trim())
-        .filter((line) => line && !line.startsWith("$ "));
-    const lines = all
-        .filter((line) => /\berror\b|\bfailed\b|✗|×/i.test(line))
-        .filter((line) => !/:\s*warning\b/i.test(line) && !/^\d+ Error\(s\)$/i.test(line));
+        .filter((line) => line && !line.startsWith("$ ")));
+}
+/** A log line that reports an error: not a compiler warning, nor a summary such as `0 Error(s)`. */
+export function looksLikeError(line) {
+    return /\berror\b|\bfailed\b|✗|×/i.test(line) && !/:\s*warning\b/i.test(line) && !/^\d+ Error\(s\)$/i.test(line);
+}
+/**
+ * Up to `max` distinct lines of a log that look like errors, so the reader sees
+ * why a command failed without opening the log. Compiler warnings and summary
+ * lines such as `0 Error(s)` are skipped: in a large build they bury the one
+ * real error. When no line looks like an error, the last `max` lines instead.
+ */
+export function errorExcerpt(log, max = 10) {
+    const all = logLines(log);
+    if (!all)
+        return [];
+    const lines = all.filter(looksLikeError);
     // No line says error (e.g. "A compatible .NET SDK was not found"): the end of the log usually does.
     if (!lines.length)
         return all.slice(-max);

package/dist/core/change-filter.js

@@ -42,11 +42,12 @@ export function changeFilter(config) {
     };
 }
 /**
- * Matches `exclude` the way scanning's fast-glob `ignore` does: a pattern
+ * Matches `exclude` the way scanning's tinyglobby `ignore` does: a pattern
  * that matches a directory (`graphify-out`, `graphify-out/`) excludes
  * everything under it, so test the path and each of its parent directories.
+ * `covers` reads the same way.
  */
-function excludeMatcher(patterns) {
+export function excludeMatcher(patterns) {
     const isMatch = picomatch(patterns.map((p) => p.replace(/\/+$/, "")), { dot: true });
     return (rel) => {
         for (let end = rel.length; end > 0; end = rel.lastIndexOf("/", end - 1)) {

package/dist/core/config-snapshot.js

@@ -9,8 +9,8 @@ import path from "node:path";
 import YAML from "yaml";
 import { relativePath } from "./util.js";
 /**
- * A project's build/test commands, each resolved on its own: the configured
- * one, none for `false`, else the adapter's default. `testResults` defaults
+ * A project's build/test/lint commands, each resolved on its own: the
+ * configured one, none for `false`, else the adapter's default (lint has none). `testResults` defaults
  * only along with the default test command, whose output location it names.
  */
 export function projectCommands(adapter, ctx) {
@@ -27,6 +27,8 @@ export function projectCommands(adapter, ctx) {
             out.defaults.push(key);
         }
     }
+    if (typeof ctx.project.lint === "string")
+        out.lint = ctx.project.lint;
     if (ctx.project.testResults)
         out.testResults = ctx.project.testResults;
     else if (out.defaults.includes("test") && fallback.testResults) {
@@ -58,6 +60,8 @@ export function configSnapshot(projects) {
             entry.build = command(commands.build);
         if (commands.test)
             entry.test = command(commands.test);
+        if (commands.lint)
+            entry.lint = command(commands.lint);
         if (commands.testResults)
             entry.testResults = relativePath(root, commands.testResults);
         snapshot.projects.push(entry);
@@ -101,6 +105,7 @@ export function configChanges(before, now) {
         for (const [kind, check] of [
             ["build", "build"],
             ["test", "tests"],
+            ["lint", "lint"],
         ]) {
             const a = was?.[kind];
             const b = is?.[kind];
@@ -137,6 +142,23 @@ export function configChanges(before, now) {
     }
     return changes;
 }
+/**
+ * Whether the config file under `root` changed since `before` in what is
+ * scanned or ignored (`exclude`, globs, paths), not just in its commands.
+ * False when `before` recorded no config file.
+ */
+export function scanConfigChanged(before, root) {
+    if (!before?.file)
+        return false;
+    let text;
+    try {
+        text = fs.readFileSync(path.join(root, before.file.path), "utf8");
+    }
+    catch {
+        return true;
+    }
+    return withoutCommands(before.file.text) !== withoutCommands(text);
+}
 const quote = (text) => (text === undefined ? "(none)" : `\`${text}\``);
 function changedFiles(a, b) {
     const hashes = new Map(a.map((f) => [f.path, f.sha256]));
@@ -161,7 +183,8 @@ function withoutCommands(text) {
     const strip = (project) => {
         if (!project || typeof project !== "object")
             return project;
-        const { build: _b, test: _t, testResults: _r, timeout: _o, ...rest } = project;
+        // `covers` changes no command's result, and `coverage` always reads the current config.
+        const { build: _b, test: _t, lint: _l, testResults: _r, timeout: _o, covers: _c, ...rest } = project;
         return rest;
     };
     if (parsed && typeof parsed === "object") {