@codefast/cli 0.9.0 → 0.10.0

package/dist/audit/domain/markdown-links.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Extracts the two things a markdown cross-reference can get wrong: where it points and what it lands on.
+ */
+/**
+ * One `[text](target)` whose target is a path in this repository.
+ *
+ * @since 0.5.0
+ */
+type MarkdownLinkReference = {
+    readonly line: number;
+    /** The path as written, with any fragment stripped. Empty when the link is fragment-only. */
+    readonly targetPath: string;
+    /** The `#fragment`, without the hash, or `null`. */
+    readonly anchor: string | null;
+};
+/**
+ * The anchors a document offers, and the references it makes.
+ *
+ * @since 0.5.0
+ */
+export type MarkdownLinkScan = {
+    readonly references: ReadonlyArray<MarkdownLinkReference>;
+    readonly anchors: ReadonlySet<string>;
+};
+/**
+ * The anchor ids a rendered document exposes: explicit `<a id>` targets plus every heading's slug.
+ *
+ * @remarks Slugging matches GitHub's — lowercase, drop everything that is not a letter, number, space
+ * or hyphen, then hyphenate spaces. Duplicate headings get a `-1` suffix there; this returns the base
+ * only, so a link to the second copy reads as dangling rather than being silently accepted.
+ *
+ * @since 0.5.0
+ */
+export declare function collectMarkdownAnchors(content: string): Set<string>;
+/**
+ * Every repo-local link a document makes, with the anchors it offers.
+ *
+ * @remarks Fenced code is stripped first: a fence showing a link is an example, not a reference, and
+ * checking it would make the audit fail on documentation that is doing its job.
+ *
+ * @since 0.5.0
+ */
+export declare function scanMarkdownLinks(content: string): MarkdownLinkScan;
+export {};

package/dist/audit/domain/since-versions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Flags `@since` tags naming a version the owning package has not reached.
+ */
+/**
+ * One impossible `@since` stamp found in a file's comments.
+ *
+ * @since 0.8.0
+ */
+export interface SinceVersionFinding {
+    readonly line: number;
+    readonly raw: string;
+}
+/**
+ * Compares two SemVer strings by precedence — positive when `left` is greater,
+ * null when either side is not a SemVer version.
+ *
+ * @since 0.8.0
+ */
+export declare function compareVersionPrecedence(left: string, right: string): number | null;
+/**
+ * Scans a file's comments for `@since` tags stamped above the package's current
+ * version — a release that has not happened, so the stamp cannot be true.
+ *
+ * @since 0.8.0
+ */
+export declare function scanImpossibleSinceTags(content: string, packageVersion: string): Array<SinceVersionFinding>;

package/dist/audit/domain/tokenize.d.ts

@@ -0,0 +1,14 @@
+import type { RtlClassToken } from "#/audit/domain/types";
+/**
+ * Splits a class token into [variant, value, modifier], colon/slash-aware of
+ * brackets and parens (arbitrary values like data-[side=left] or calc(...)).
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function splitClassName(token: string): [string | null, string, string | null];
+/**
+ * Collects the parsed class tokens from every string literal in a file's content.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function collectTokens(content: string): Array<RtlClassToken>;

package/dist/audit/domain/tsdoc-syntax.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validates every doc block against the official TSDoc grammar, not a regex approximation.
+ */
+/**
+ * One grammar diagnostic from the TSDoc parser.
+ *
+ * @since 0.6.0
+ */
+export interface TsdocSyntaxFinding {
+    readonly line: number;
+    /** The parser's stable message id, e.g. `tsdoc-escape-right-brace` — the allowlist key. */
+    readonly raw: string;
+    readonly reason: string;
+}
+/**
+ * Every TSDoc grammar diagnostic in a file's doc blocks, in source order.
+ *
+ * @since 0.6.0
+ */
+export declare function scanTsdocSyntax(content: string): Array<TsdocSyntaxFinding>;

package/dist/audit/domain/types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * A class token parsed from a source string literal, split into variant, value, and modifier.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlClassToken = {
+    readonly raw: string;
+    readonly token: string;
+    readonly variant: string | null;
+    readonly value: string;
+    readonly modifier: string | null;
+    readonly line: number;
+};
+/**
+ * A physical class occurrence the RTL audit flags, with its suggested logical replacement.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlViolation = {
+    readonly line: number;
+    readonly raw: string;
+    readonly suggestion: string;
+};
+/**
+ * The RTL violations found in one file.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<RtlViolation>;
+};
+/**
+ * Outcome of one `audit rtl` run.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlAuditResult = {
+    readonly files: Array<RtlFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * An import-policy violation: a banned import form (namespace / default / named), or an implicit
+ * UMD-global type reference under a name nothing in the file imports.
+ *
+ * @since 0.10.0
+ */
+export type ImportPolicyViolation = {
+    readonly line: number;
+    /** The offending source text — the import statement or the qualified type name. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The import-policy violations found in one file.
+ *
+ * @since 0.10.0
+ */
+export type ImportPolicyFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<ImportPolicyViolation>;
+};
+/**
+ * Outcome of one `audit imports` run.
+ *
+ * @since 0.10.0
+ */
+export type ImportsAuditResult = {
+    readonly files: Array<ImportPolicyFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * A `token()`, `tag()` or module display name that breaks the display-name convention.
+ *
+ * @since 0.9.0
+ */
+export type DisplayNameViolation = {
+    readonly line: number;
+    /** The call as written, through its closing quote. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The display-name violations found in one file.
+ *
+ * @since 0.9.0
+ */
+export type DisplayNameFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<DisplayNameViolation>;
+};
+/**
+ * Outcome of one `audit display-names` run.
+ *
+ * @since 0.9.0
+ */
+export type DisplayNameAuditResult = {
+    readonly files: Array<DisplayNameFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * A broken link or anchor found by the link audit.
+ *
+ * @since 0.5.0
+ */
+export type LinkBreakage = {
+    readonly line: number;
+    /** The link target as written, fragment included. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The link breakages found in one markdown file.
+ *
+ * @since 0.5.0
+ */
+export type LinkFileBreakages = {
+    readonly relativePath: string;
+    readonly breakages: Array<LinkBreakage>;
+};
+/**
+ * Outcome of one `audit links` run.
+ *
+ * @since 0.5.0
+ */
+export type LinkAuditResult = {
+    readonly files: Array<LinkFileBreakages>;
+    readonly breakageCount: number;
+    readonly allowlistedCount: number;
+    readonly linkCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * A section divider that does not match the repo's one allowed form. Always `--fix`-able.
+ *
+ * @since 0.6.0
+ */
+export type DividerBreakage = {
+    readonly line: number;
+    /** The divider's opening line as written. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * @see DividerBreakage
+ *
+ * @since 0.6.0
+ */
+export type DividerFileBreakages = {
+    readonly relativePath: string;
+    readonly breakages: Array<DividerBreakage>;
+};
+/**
+ * Outcome of one `audit comments` run. `fixedCount` stays `0` unless `--fix` was passed.
+ *
+ * @since 0.6.0
+ */
+export type CommentAuditResult = {
+    readonly files: Array<DividerFileBreakages>;
+    readonly breakageCount: number;
+    readonly allowlistedCount: number;
+    readonly fixedCount: number;
+    readonly dividerCount: number;
+    readonly scannedFileCount: number;
+};

package/dist/audit/output.d.ts

@@ -0,0 +1,91 @@
+import type { CommentAuditResult, ImportsAuditResult, LinkAuditResult, RtlAuditResult, DisplayNameAuditResult } from "#/audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted violation remains.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function exitCodeForRtlAuditResult(result: RtlAuditResult): number;
+/**
+ * Human-readable RTL audit report (matches the former packages/ui script shape).
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function presentRtlAuditResult(result: RtlAuditResult): void;
+/**
+ * Machine-readable RTL audit summary for `--json`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function formatRtlAuditJsonOutput(result: RtlAuditResult, rootDir: string): string;
+/**
+ * Exit `1` when any non-allowlisted broken link remains.
+ *
+ * @since 0.5.0
+ */
+export declare function exitCodeForLinkAuditResult(result: LinkAuditResult): number;
+/**
+ * Human-readable link audit report.
+ *
+ * @since 0.5.0
+ */
+export declare function presentLinkAuditResult(result: LinkAuditResult): void;
+/**
+ * Machine-readable link audit summary for `--json`.
+ *
+ * @since 0.5.0
+ */
+export declare function formatLinkAuditJsonOutput(result: LinkAuditResult, rootDir: string): string;
+/**
+ * Exit `1` when any non-allowlisted import-policy violation remains.
+ *
+ * @since 0.10.0
+ */
+export declare function exitCodeForImportsAuditResult(result: ImportsAuditResult): number;
+/**
+ * Human-readable import-policy report.
+ *
+ * @since 0.10.0
+ */
+export declare function presentImportsAuditResult(result: ImportsAuditResult): void;
+/**
+ * Machine-readable import-policy summary for `--json`.
+ *
+ * @since 0.10.0
+ */
+export declare function formatImportsAuditJsonOutput(result: ImportsAuditResult, rootDir: string): string;
+/**
+ * Exit `1` when any non-allowlisted divider still breaks the convention.
+ *
+ * @since 0.6.0
+ */
+export declare function exitCodeForCommentAuditResult(result: CommentAuditResult): number;
+/**
+ * Human-readable comment-divider report.
+ *
+ * @since 0.6.0
+ */
+export declare function presentCommentAuditResult(result: CommentAuditResult): void;
+/**
+ * Machine-readable comment-divider summary for `--json`.
+ *
+ * @since 0.6.0
+ */
+export declare function formatCommentAuditJsonOutput(result: CommentAuditResult, rootDir: string): string;
+/**
+ * Exit `1` when any non-allowlisted display-name violation remains.
+ *
+ * @since 0.9.0
+ */
+export declare function exitCodeForDisplayNameAuditResult(result: DisplayNameAuditResult): number;
+/**
+ * Human-readable display-name report.
+ *
+ * @since 0.9.0
+ */
+export declare function presentDisplayNameAuditResult(result: DisplayNameAuditResult): void;
+/**
+ * Machine-readable display-name summary for `--json`.
+ *
+ * @since 0.9.0
+ */
+export declare function formatDisplayNameAuditJsonOutput(result: DisplayNameAuditResult, rootDir: string): string;

package/dist/audit/output.js

@@ -83,19 +83,19 @@ export function formatLinkAuditJsonOutput(result, rootDir) {
     });
 }
 /**
- * Exit `1` when any non-allowlisted React import-policy violation remains.
+ * Exit `1` when any non-allowlisted import-policy violation remains.
  *
- * @since 0.8.0
+ * @since 0.10.0
  */
-export function exitCodeForReactAuditResult(result) {
+export function exitCodeForImportsAuditResult(result) {
     return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
 }
 /**
- * Human-readable React import-policy report.
+ * Human-readable import-policy report.
  *
- * @since 0.8.0
+ * @since 0.10.0
  */
-export function presentReactAuditResult(result) {
+export function presentImportsAuditResult(result) {
     for (const file of result.files) {
         logger.out(`\n${file.relativePath}`);
         for (const { line, raw, reason } of file.violations) {
@@ -104,18 +104,18 @@ export function presentReactAuditResult(result) {
     }
     const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
     if (result.violationCount > 0) {
-        logger.out(`\n✖ ${result.violationCount} React import violation(s)${allowlistSuffix}`);
+        logger.out(`\n✖ ${result.violationCount} import-policy violation(s)${allowlistSuffix}`);
     }
     else {
-        logger.out(`✓ No namespace/default React imports or React.* UMD globals across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
+        logger.out(`✓ No import-policy violations across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
     }
 }
 /**
- * Machine-readable React import-policy summary for `--json`.
+ * Machine-readable import-policy summary for `--json`.
  *
- * @since 0.8.0
+ * @since 0.10.0
  */
-export function formatReactAuditJsonOutput(result, rootDir) {
+export function formatImportsAuditJsonOutput(result, rootDir) {
     return JSON.stringify({
         schemaVersion: 1,
         ok: result.violationCount === 0,

package/dist/audit/prepare.d.ts

@@ -0,0 +1,70 @@
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+/**
+ * Shared prelude for `audit rtl`: repo root and the canonicalized scan target with its allowlist.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlAuditCommandPrelude = {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+};
+/**
+ * Loads config and resolves the scan target for `audit rtl`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function prepareRtlAudit(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<RtlAuditCommandPrelude, AppError>>;
+/**
+ * Loads config and resolves the scan target for `audit links`.
+ *
+ * @remarks Defaults to the repo root rather than a configured path: a link audit that only covers one
+ * package cannot see the cross-package references that are the ones most likely to rot.
+ *
+ * @since 0.5.0
+ */
+export declare function prepareLinkAudit(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<RtlAuditCommandPrelude, AppError>>;
+/**
+ * Loads config and resolves the scan target for `audit imports`.
+ *
+ * @remarks Defaults to the repo root: the import policy is repo-wide, and generated or vendored
+ * trees are already excluded by the shared walk.
+ *
+ * @since 0.10.0
+ */
+export declare function prepareImportsAudit(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<RtlAuditCommandPrelude, AppError>>;
+/**
+ * Loads config and resolves the scan target for `audit comments`.
+ *
+ * @remarks Defaults to the repo root: a divider convention that only holds inside one package
+ * is not a convention.
+ *
+ * @since 0.6.0
+ */
+export declare function prepareCommentAudit(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<RtlAuditCommandPrelude, AppError>>;
+/**
+ * Loads config and resolves the scan target for `audit display-names`.
+ *
+ * @remarks Defaults to the repo root: a display name collides across packages, so the convention
+ * has to hold across them.
+ *
+ * @since 0.9.0
+ */
+export declare function prepareDisplayNameAudit(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<RtlAuditCommandPrelude, AppError>>;

package/dist/audit/prepare.js

@@ -2,7 +2,7 @@ import { resolveRepoRelativePath } from "#/audit/cli-schema";
 import { loadCodefastConfig } from "#/core/config";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
-import { findRepoRoot } from "#/core/workspace/resolver";
+import { resolveProjectRoot } from "#/core/workspace/resolver";
 /**
  * Loads config and resolves the scan target for `audit rtl`.
  *
@@ -12,7 +12,7 @@ export async function prepareRtlAudit(fs, args) {
     let rootDir;
     try {
         // Realpath so allowlist keys (`path.relative(rootDir, file)`) stay stable when cwd is a symlink.
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
     }
     catch (caughtError) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
@@ -50,7 +50,7 @@ export async function prepareRtlAudit(fs, args) {
 export async function prepareLinkAudit(fs, args) {
     let rootDir;
     try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
     }
     catch (caughtError) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
@@ -71,17 +71,17 @@ export async function prepareLinkAudit(fs, args) {
     });
 }
 /**
- * Loads config and resolves the scan target for `audit react`.
+ * Loads config and resolves the scan target for `audit imports`.
  *
  * @remarks Defaults to the repo root: the import policy is repo-wide, and generated or vendored
  * trees are already excluded by the shared walk.
  *
- * @since 0.8.0
+ * @since 0.10.0
  */
-export async function prepareReactAudit(fs, args) {
+export async function prepareImportsAudit(fs, args) {
     let rootDir;
     try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
     }
     catch (caughtError) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
@@ -90,7 +90,7 @@ export async function prepareReactAudit(fs, args) {
     if (!loadedOutcome.ok) {
         return loadedOutcome;
     }
-    const reactConfig = loadedOutcome.value.config.audit?.react ?? {};
+    const importsConfig = loadedOutcome.value.config.audit?.imports ?? {};
     const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
     if (!fs.existsSync(targetPath)) {
         return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
@@ -98,7 +98,7 @@ export async function prepareReactAudit(fs, args) {
     return ok({
         rootDir,
         targetPath: fs.canonicalPathSync(targetPath),
-        allowlist: reactConfig.allowlist ?? [],
+        allowlist: importsConfig.allowlist ?? [],
     });
 }
 /**
@@ -112,7 +112,7 @@ export async function prepareReactAudit(fs, args) {
 export async function prepareCommentAudit(fs, args) {
     let rootDir;
     try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
     }
     catch (caughtError) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
@@ -143,7 +143,7 @@ export async function prepareCommentAudit(fs, args) {
 export async function prepareDisplayNameAudit(fs, args) {
     let rootDir;
     try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
     }
     catch (caughtError) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));

package/dist/audit/run-comments.d.ts

@@ -0,0 +1,17 @@
+import type { CommentAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+/**
+ * Reports every comment off the repo's conventions: divider form (which `fix` rewrites), banned
+ * content — document pointers, JSDoc types, tag misuse — `{@link}` targets nothing declares, and
+ * every diagnostic the official TSDoc parser raises against a doc block's grammar.
+ *
+ * @since 0.6.0
+ */
+export declare function runCommentAudit(fs: FilesystemPort, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+    readonly fix: boolean;
+}): Result<CommentAuditResult, AppError>;

package/dist/audit/run-display-names.d.ts

@@ -0,0 +1,14 @@
+import type { DisplayNameAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+/**
+ * Scans a target path for `token()`, `tag()` and module display names that break the convention.
+ *
+ * @since 0.9.0
+ */
+export declare function runDisplayNameAudit(fs: FilesystemPort, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<DisplayNameAuditResult, AppError>;

package/dist/audit/run-imports.d.ts

@@ -0,0 +1,14 @@
+import type { ImportsAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+/**
+ * Scans a target path for import-policy violations, applying each rule only to files in its scope.
+ *
+ * @since 0.10.0
+ */
+export declare function runImportsAudit(fs: FilesystemPort, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<ImportsAuditResult, AppError>;

package/dist/audit/{run-react.js → run-imports.js}

@@ -1,25 +1,35 @@
 import path from "node:path";
-import { auditReactImportSource } from "#/audit/domain/react-imports";
+import { defaultImportPolicyRules } from "#/audit/domain/import-policy";
+import { auditImportPolicySource } from "#/audit/domain/import-policy";
 import { AppError, messageFrom } from "#/core/errors";
+import { createAnyGlobMatcher } from "#/core/glob";
 import { err, ok } from "#/core/result";
 import { walkTsxFiles } from "#/core/workspace/typescript-walk";
 /**
- * Scans a target path for React import-policy violations.
+ * Scans a target path for import-policy violations, applying each rule only to files in its scope.
  *
- * @since 0.8.0
+ * @since 0.10.0
  */
-export function runReactAudit(fs, args) {
+export function runImportsAudit(fs, args) {
     try {
         const allowlist = new Set(args.allowlist);
         const { rootDir, targetPath } = args;
+        const scopedRules = defaultImportPolicyRules.map((rule) => ({
+            rule,
+            isInScope: rule.scope ? createAnyGlobMatcher(rule.scope, { dot: true }) : () => true,
+        }));
         const filesToScan = collectScanPaths(fs, targetPath);
         const files = [];
         let violationCount = 0;
         let allowlistedCount = 0;
         for (const absolutePath of filesToScan) {
             const relativePath = toPosixPath(path.relative(rootDir, absolutePath));
+            const applicableRules = scopedRules.filter(({ isInScope }) => isInScope(relativePath)).map(({ rule }) => rule);
+            if (applicableRules.length === 0) {
+                continue;
+            }
             const content = fs.readFileSync(absolutePath, "utf8");
-            const remaining = auditReactImportSource(absolutePath, content).filter(({ raw }) => {
+            const remaining = auditImportPolicySource(absolutePath, content, applicableRules).filter(({ raw }) => {
                 const isAllowed = allowlist.has(raw) || allowlist.has(`${relativePath}:${raw}`);
                 if (isAllowed) {
                     allowlistedCount++;

package/dist/audit/run-links.d.ts

@@ -0,0 +1,14 @@
+import type { LinkAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+/**
+ * Reports markdown links that point at nothing — a missing path, or an anchor the target does not offer.
+ *
+ * @since 0.5.0
+ */
+export declare function runLinkAudit(fs: FilesystemPort, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<LinkAuditResult, AppError>;