@codefast/cli 0.8.0 → 0.9.0

package/dist/audit/command.js

@@ -1,10 +1,11 @@
 import process from "node:process";
 import { Command } from "commander";
-import { commentAuditRunRequestSchema, linkAuditRunRequestSchema, reactAuditRunRequestSchema, rtlAuditRunRequestSchema, } from "#/audit/cli-schema";
-import { exitCodeForCommentAuditResult, exitCodeForLinkAuditResult, exitCodeForReactAuditResult, exitCodeForRtlAuditResult, formatCommentAuditJsonOutput, formatLinkAuditJsonOutput, formatReactAuditJsonOutput, formatRtlAuditJsonOutput, presentCommentAuditResult, presentLinkAuditResult, presentReactAuditResult, presentRtlAuditResult, } from "#/audit/output";
-import { prepareCommentAudit, prepareLinkAudit, prepareReactAudit, prepareRtlAudit } from "#/audit/prepare";
+import { commentAuditRunRequestSchema, linkAuditRunRequestSchema, reactAuditRunRequestSchema, rtlAuditRunRequestSchema, displayNameAuditRunRequestSchema, } from "#/audit/cli-schema";
+import { exitCodeForCommentAuditResult, exitCodeForLinkAuditResult, exitCodeForReactAuditResult, exitCodeForRtlAuditResult, exitCodeForDisplayNameAuditResult, formatCommentAuditJsonOutput, formatLinkAuditJsonOutput, formatReactAuditJsonOutput, formatRtlAuditJsonOutput, formatDisplayNameAuditJsonOutput, presentCommentAuditResult, presentLinkAuditResult, presentReactAuditResult, presentRtlAuditResult, presentDisplayNameAuditResult, } from "#/audit/output";
+import { prepareCommentAudit, prepareLinkAudit, prepareReactAudit, prepareRtlAudit, prepareDisplayNameAudit, } from "#/audit/prepare";
 import { runRtlAudit } from "#/audit/run";
 import { runCommentAudit } from "#/audit/run-comments";
+import { runDisplayNameAudit } from "#/audit/run-display-names";
 import { runLinkAudit } from "#/audit/run-links";
 import { runReactAudit } from "#/audit/run-react";
 import { readOptionalPositionalArg } from "#/core/cli/positional";
@@ -137,6 +138,45 @@ export function createAuditCommand() {
         }
         process.exitCode = exitCodeForReactAuditResult(outcome.value);
     });
+    cmd
+        .command("display-names")
+        .description("Report token(), tag() and module display names that break the <namespace>:<Name> convention")
+        .argument("[target]", "Directory or file to scan (default: the repo root)")
+        .option("--json", "Print one JSON summary on stdout", false)
+        .action(async (target, opts) => {
+        const prelude = await prepareDisplayNameAudit(nodeFilesystem, {
+            currentWorkingDirectory: process.cwd(),
+            rawTarget: readOptionalPositionalArg(target),
+        });
+        if (!consumeCliAppError(prelude)) {
+            return;
+        }
+        const { rootDir, targetPath, allowlist } = prelude.value;
+        const parsed = parseWithSchema(displayNameAuditRunRequestSchema, {
+            rootDir,
+            targetPath,
+            allowlist,
+            json: !!opts.json,
+        });
+        if (!consumeCliAppError(parsed)) {
+            return;
+        }
+        const outcome = runDisplayNameAudit(nodeFilesystem, {
+            rootDir: parsed.value.rootDir,
+            targetPath: parsed.value.targetPath,
+            allowlist: parsed.value.allowlist ?? [],
+        });
+        if (!consumeCliAppError(outcome)) {
+            return;
+        }
+        if (parsed.value.json) {
+            logger.out(formatDisplayNameAuditJsonOutput(outcome.value, rootDir));
+        }
+        else {
+            presentDisplayNameAuditResult(outcome.value);
+        }
+        process.exitCode = exitCodeForDisplayNameAuditResult(outcome.value);
+    });
     cmd
         .command("comments")
         .description("Report section dividers that are not in the repo's one allowed form")
@@ -180,5 +220,4 @@ export function createAuditCommand() {
         process.exitCode = exitCodeForCommentAuditResult(outcome.value);
     });
     return cmd;
-}
-//# sourceMappingURL=command.js.map
+}

package/dist/audit/domain/audit-file.js

@@ -7,7 +7,7 @@ import { collectTokens } from "#/audit/domain/tokenize";
  *
  * @since 0.5.0-canary.6
  */
-export function hasRtlCompanion(fileTokens, expectedValue) {
+function hasRtlCompanion(fileTokens, expectedValue) {
     return fileTokens.some(({ variant, value }) => {
         if (!variant) {
             return false;
@@ -97,5 +97,4 @@ export function auditFileContent(content) {
         }
     }
     return violations;
-}
-//# sourceMappingURL=audit-file.js.map
+}

package/dist/audit/domain/comment-content.js

@@ -174,5 +174,4 @@ function compareParams(parameterListText, documented) {
         }
     }
     return missing;
-}
-//# sourceMappingURL=comment-content.js.map
+}

package/dist/audit/domain/comment-dividers.js

@@ -11,12 +11,31 @@ const RULE_GLYPH = "─";
 const LEAD_GLYPHS = "──";
 /** Every glyph a divider has historically been drawn with, so legacy forms are recognised too. */
 const RULE_CHARACTER_CLASS = String.raw `[-=─_*~#]`;
-const ruleOnlyLinePattern = new RegExp(String.raw `^(?<indent>[ \t]*)(?:\/\/|\/\*|\*)[ \t]*${RULE_CHARACTER_CLASS}{4,}[ \t]*(?:\*\/)?[ \t]*$`);
-const titledLinePattern = new RegExp(String.raw `^(?<indent>[ \t]*)(?:\/\/|\/\*)[ \t]*${RULE_CHARACTER_CLASS}{2,}[ \t]+(?<title>.*?)[ \t]+${RULE_CHARACTER_CLASS}{2,}[ \t]*(?:\*\/)?[ \t]*$`);
-const commentLinePattern = /^[ \t]*(?:\/\/|\/\*|\*)/;
-const bareRuleClosePattern = new RegExp(String.raw `^[ \t]*${RULE_CHARACTER_CLASS}{4,}[ \t]*\*\/[ \t]*$`);
+// The comment lead each syntax opens a divider with — `#` for ignore files, slash forms for code.
+const commentLeadByLanguage = {
+    css: String.raw `\/\/|\/\*|\*`,
+    ignore: String.raw `#`,
+    js: String.raw `\/\/|\/\*|\*`,
+};
+// One compiled pattern set per language — the comment lead is the only part that varies.
+const patternsByLanguage = new Map();
+function patternsFor(language) {
+    const cached = patternsByLanguage.get(language);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const lead = commentLeadByLanguage[language];
+    const built = {
+        ruleOnly: new RegExp(String.raw `^(?<indent>[ \t]*)(?:${lead})[ \t]*${RULE_CHARACTER_CLASS}{4,}[ \t]*(?:\*\/)?[ \t]*$`),
+        titled: new RegExp(String.raw `^(?<indent>[ \t]*)(?:${lead})[ \t]*${RULE_CHARACTER_CLASS}{2,}[ \t]+(?<title>.*?)[ \t]+${RULE_CHARACTER_CLASS}{2,}[ \t]*(?:\*\/)?[ \t]*$`),
+        commentLine: new RegExp(String.raw `^[ \t]*(?:${lead})`),
+        bareRuleClose: new RegExp(String.raw `^[ \t]*${RULE_CHARACTER_CLASS}{4,}[ \t]*\*\/[ \t]*$`),
+        commentPrefix: new RegExp(String.raw `^[ \t]*(?:${lead})[ \t]?`),
+    };
+    patternsByLanguage.set(language, built);
+    return built;
+}
 const rulesOnlyPattern = new RegExp(String.raw `^(?:${RULE_CHARACTER_CLASS}|[ \t])*$`);
-const commentPrefixPattern = /^[ \t]*(?:\/\/|\/\*|\*)[ \t]?/;
 const commentSuffixPattern = /[ \t]*\*\/[ \t]*$/;
 /** A banner spanning more lines than this is prose that happens to start with a rule, not a divider. */
 const MAX_BANNER_SPAN = 16;
@@ -36,7 +55,8 @@ export function renderDivider(indent, title, language) {
         const head = `${indent}/* ${LEAD_GLYPHS} ${title} `;
         return `${head}${RULE_GLYPH.repeat(Math.max(2, DIVIDER_COLUMN - head.length - 3))} */`;
     }
-    const head = `${indent}// ${LEAD_GLYPHS} ${title} `;
+    const prefix = language === "ignore" ? "#" : "//";
+    const head = `${indent}${prefix} ${LEAD_GLYPHS} ${title} `;
     return `${head}${RULE_GLYPH.repeat(Math.max(2, DIVIDER_COLUMN - head.length))}`;
 }
 /**
@@ -80,7 +100,8 @@ export function applyCommentDividerFixes(content, language) {
 }
 function readRegionAt(lines, index, language) {
     const line = lines[index];
-    const titled = titledLinePattern.exec(line);
+    const patterns = patternsFor(language);
+    const titled = patterns.titled.exec(line);
     const title = titled?.groups?.title?.trim();
     if (titled !== null && title !== undefined && title.length > 0 && !rulesOnlyPattern.test(title)) {
         const indent = titled.groups?.indent ?? "";
@@ -94,26 +115,29 @@ function readRegionAt(lines, index, language) {
             defect: line === canonical ? null : usesCanonicalGlyphs(line) ? "bad-width" : "legacy-form",
         };
     }
-    const ruleOnly = ruleOnlyLinePattern.exec(line);
+    const ruleOnly = patterns.ruleOnly.exec(line);
     if (ruleOnly === null) {
         return null;
     }
-    return readBannerAt(lines, index, ruleOnly.groups?.indent ?? "");
+    return readBannerAt(lines, index, ruleOnly.groups?.indent ?? "", language);
 }
-function readBannerAt(lines, index, indent) {
+function readBannerAt(lines, index, indent, language) {
     const line = lines[index];
+    const patterns = patternsFor(language);
     // An unterminated `/*` opens a block whose body needs no per-line marker, so the run ends at `*/`.
     const insideBlock = line.trimStart().startsWith("/*") && !line.includes("*/");
     const body = [];
     let cursor = index + 1;
-    while (cursor < lines.length && cursor - index <= MAX_BANNER_SPAN && !isBannerClose(lines[cursor], insideBlock)) {
-        if (!insideBlock && !commentLinePattern.test(lines[cursor])) {
+    while (cursor < lines.length &&
+        cursor - index <= MAX_BANNER_SPAN &&
+        !isBannerClose(lines[cursor], insideBlock, language)) {
+        if (!insideBlock && !patterns.commentLine.test(lines[cursor])) {
             break;
         }
-        body.push(stripCommentPrefix(lines[cursor]));
+        body.push(stripCommentPrefix(lines[cursor], language));
         cursor++;
     }
-    const closed = cursor < lines.length && cursor - index <= MAX_BANNER_SPAN && isBannerClose(lines[cursor], insideBlock);
+    const closed = cursor < lines.length && cursor - index <= MAX_BANNER_SPAN && isBannerClose(lines[cursor], insideBlock, language);
     const meaningful = body.filter((entry) => entry.length > 0);
     // A frame around prose is a doc block, and an unclosed rule is prose formatting inside one.
     if (!closed || meaningful.length !== 1 || !looksLikeTitle(meaningful[0])) {
@@ -131,16 +155,19 @@ function readBannerAt(lines, index, indent) {
 function looksLikeTitle(text) {
     return text.length <= MAX_TITLE_LENGTH && !text.endsWith(".");
 }
-function isBannerClose(line, insideBlock) {
-    if (ruleOnlyLinePattern.test(line)) {
+function isBannerClose(line, insideBlock, language) {
+    const patterns = patternsFor(language);
+    if (patterns.ruleOnly.test(line)) {
         return true;
     }
-    return insideBlock && bareRuleClosePattern.test(line);
+    return insideBlock && patterns.bareRuleClose.test(line);
 }
 function usesCanonicalGlyphs(line) {
-    return line.trimStart().startsWith(`// ${LEAD_GLYPHS} `) || line.trimStart().startsWith(`/* ${LEAD_GLYPHS} `);
-}
-function stripCommentPrefix(line) {
-    return line.replace(commentPrefixPattern, "").replace(commentSuffixPattern, "").trim();
+    const trimmed = line.trimStart();
+    return (trimmed.startsWith(`// ${LEAD_GLYPHS} `) ||
+        trimmed.startsWith(`/* ${LEAD_GLYPHS} `) ||
+        trimmed.startsWith(`# ${LEAD_GLYPHS} `));
 }
-//# sourceMappingURL=comment-dividers.js.map
+function stripCommentPrefix(line, language) {
+    return line.replace(patternsFor(language).commentPrefix, "").replace(commentSuffixPattern, "").trim();
+}

package/dist/audit/domain/display-names.js

@@ -0,0 +1,71 @@
+/** The owner: a kebab-case package, app or feature slug, or a scoped package name. */
+const NAMESPACE = /^(?:@[a-z0-9-]+\/)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** A token or module stands for a type or a unit of composition. */
+const PASCAL_CASE = /^[A-Z][A-Za-z0-9]*$/;
+/** A tag key stands for an attribute a request selects on, so it reads like a property. */
+const CAMEL_CASE = /^[a-z][A-Za-z0-9]*$/;
+/**
+ * A bare `token(…)` / `tag(…)` call, or a module factory call, whose first argument is a string literal.
+ *
+ * @remarks Generic arguments are skipped up to four levels of nesting, which is deeper than any
+ * declaration in the repo. Template literals are not matched: an interpolated name has no fixed
+ * text to check. The closing parenthesis is kept when the name is the only argument, so the
+ * reported text reads as the call was written.
+ */
+const DISPLAY_NAME_CALL = /(?<![\w$.])(?:(token|tag)\s*(?:<(?:[^<>]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)*>)?|((?:Sync|Async)?Module)\s*\.\s*create(?:Async)?)\s*\(\s*(["'])((?:(?!\3)[^\\\n]|\\.)*)\3(\s*\))?/g;
+const KIND_LABEL = {
+    token: "token display name",
+    tag: "tag key",
+    module: "module name",
+};
+/**
+ * Scans one source or markdown text for `token()`, `tag()` and module display names that break the convention.
+ *
+ * @remarks Runs on markdown as well as TypeScript because a doc sample is what a reader copies:
+ * a convention the docs break is not one the docs teach.
+ *
+ * @since 0.9.0
+ */
+export function auditDisplayNames(sourceText) {
+    const violations = [];
+    for (const match of sourceText.matchAll(DISPLAY_NAME_CALL)) {
+        const kind = match[1] === undefined ? "module" : match[1];
+        const reason = reasonFor(kind, match[4]);
+        if (reason === null) {
+            continue;
+        }
+        violations.push({ line: lineOfOffset(sourceText, match.index), raw: match[0], reason });
+    }
+    return violations;
+}
+/** Why a display name breaks the convention, or `null` when it holds. */
+function reasonFor(kind, name) {
+    const segments = name.split(":");
+    const label = KIND_LABEL[kind];
+    if (segments.length < 2) {
+        return `${label} '${name}' has no namespace — write '<namespace>:${name}'`;
+    }
+    const local = segments.at(-1);
+    for (const namespace of segments.slice(0, -1)) {
+        if (!NAMESPACE.test(namespace)) {
+            return `namespace '${namespace}' in '${name}' is not kebab-case (or a scoped package name)`;
+        }
+    }
+    if (kind === "tag") {
+        return CAMEL_CASE.test(local)
+            ? null
+            : `${label} '${local}' in '${name}' is not camelCase — a tag key names an attribute`;
+    }
+    return PASCAL_CASE.test(local)
+        ? null
+        : `${label} '${local}' in '${name}' is not PascalCase — a ${kind} stands for a ${kind === "token" ? "type" : "unit of composition"}`;
+}
+function lineOfOffset(sourceText, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index++) {
+        if (sourceText.charCodeAt(index) === 10) {
+            line++;
+        }
+    }
+    return line;
+}

package/dist/audit/domain/link-references.js

@@ -60,5 +60,4 @@ export function countHeadMentions(contents, heads) {
         }
     }
     return counts;
-}
-//# sourceMappingURL=link-references.js.map
+}

package/dist/audit/domain/mappings.js

@@ -101,5 +101,4 @@ export const SLIDE_PREFIXES = [
     "slide-in-from-right",
     "slide-out-to-left",
     "slide-out-to-right",
-];
-//# sourceMappingURL=mappings.js.map
+];

package/dist/audit/domain/markdown-links.js

@@ -72,5 +72,4 @@ function lineNumberAt(content, index) {
         }
     }
     return line;
-}
-//# sourceMappingURL=markdown-links.js.map
+}

package/dist/audit/domain/react-imports.js

@@ -88,5 +88,4 @@ function lineOfOffset(sourceText, offset) {
 function firstLineOf(text) {
     const newlineIndex = text.indexOf("\n");
     return newlineIndex === -1 ? text : text.slice(0, newlineIndex);
-}
-//# sourceMappingURL=react-imports.js.map
+}

package/dist/audit/domain/since-versions.js

@@ -82,5 +82,4 @@ export function scanImpossibleSinceTags(content, packageVersion) {
         }
     }
     return findings;
-}
-//# sourceMappingURL=since-versions.js.map
+}

package/dist/audit/domain/tokenize.js

@@ -52,7 +52,7 @@ export function splitClassName(token) {
  *
  * @since 0.5.0-canary.6
  */
-export function* stringLiterals(content) {
+function* stringLiterals(content) {
     const pattern = /"([^"\n]*)"|'([^'\n]*)'|`([^`]*)`/g;
     for (const match of content.matchAll(pattern)) {
         const text = match[1] ?? match[2] ?? match[3] ?? "";
@@ -81,5 +81,4 @@ export function collectTokens(content) {
         }
     }
     return tokens;
-}
-//# sourceMappingURL=tokenize.js.map
+}

package/dist/audit/domain/tsdoc-syntax.js

@@ -29,5 +29,4 @@ export function scanTsdocSyntax(content) {
         }
     }
     return findings;
-}
-//# sourceMappingURL=tsdoc-syntax.js.map
+}

package/dist/audit/domain/types.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=types.js.map
+export {};

package/dist/audit/output.js

@@ -170,4 +170,44 @@ export function formatCommentAuditJsonOutput(result, rootDir) {
 function truncate(raw) {
     return raw.length <= 60 ? raw : `${raw.slice(0, 57)}…`;
 }
-//# sourceMappingURL=output.js.map
+/**
+ * Exit `1` when any non-allowlisted display-name violation remains.
+ *
+ * @since 0.9.0
+ */
+export function exitCodeForDisplayNameAuditResult(result) {
+    return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Human-readable display-name report.
+ *
+ * @since 0.9.0
+ */
+export function presentDisplayNameAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, reason } of file.violations) {
+            logger.out(`  ${line}: ${raw} → ${reason}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.violationCount > 0) {
+        logger.out(`\n✖ ${result.violationCount} display name(s) off the convention${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ Every token, tag and module display name follows <namespace>:<Name> across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
+    }
+}
+/**
+ * Machine-readable display-name summary for `--json`.
+ *
+ * @since 0.9.0
+ */
+export function formatDisplayNameAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.violationCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}

package/dist/audit/prepare.js

@@ -132,4 +132,34 @@ export async function prepareCommentAudit(fs, args) {
         allowlist: commentsConfig.allowlist ?? [],
     });
 }
-//# sourceMappingURL=prepare.js.map
+/**
+ * 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 async function prepareDisplayNameAudit(fs, args) {
+    let rootDir;
+    try {
+        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
+    if (!loadedOutcome.ok) {
+        return loadedOutcome;
+    }
+    const displayNamesConfig = loadedOutcome.value.config.audit?.displayNames ?? {};
+    const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
+    if (!fs.existsSync(targetPath)) {
+        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
+    }
+    return ok({
+        rootDir,
+        targetPath: fs.canonicalPathSync(targetPath),
+        allowlist: displayNamesConfig.allowlist ?? [],
+    });
+}

package/dist/audit/run-comments.js

@@ -68,30 +68,34 @@ export function runCommentAudit(fs, args) {
                 }
                 breakages.push({ line: region.startLine, raw: region.raw, reason: reasonByDefect[region.defect] });
             }
-            for (const finding of scanCommentContent(content, language)) {
-                if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
-                    allowlistedCount++;
-                    continue;
-                }
-                breakages.push({ line: finding.line, raw: finding.raw, reason: reasonByDefect[finding.defect] });
-            }
-            const packageVersion = nearestVersion(fs, absolutePath, versionByDirectory);
-            if (packageVersion !== null) {
-                for (const finding of scanImpossibleSinceTags(content, packageVersion)) {
+            // The content rules — banned fragments, `@since`, TSDoc grammar — govern doc comments in
+            // code; an ignore file carries only the divider convention.
+            if (language !== "ignore") {
+                for (const finding of scanCommentContent(content, language)) {
                     if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
                         allowlistedCount++;
                         continue;
                     }
-                    breakages.push({ line: finding.line, raw: finding.raw, reason: reasonByDefect["since-impossible"] });
+                    breakages.push({ line: finding.line, raw: finding.raw, reason: reasonByDefect[finding.defect] });
                 }
-            }
-            if (language === "js") {
-                for (const finding of scanTsdocSyntax(content)) {
-                    if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
-                        allowlistedCount++;
-                        continue;
+                const packageVersion = nearestVersion(fs, absolutePath, versionByDirectory);
+                if (packageVersion !== null) {
+                    for (const finding of scanImpossibleSinceTags(content, packageVersion)) {
+                        if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
+                            allowlistedCount++;
+                            continue;
+                        }
+                        breakages.push({ line: finding.line, raw: finding.raw, reason: reasonByDefect["since-impossible"] });
+                    }
+                }
+                if (language === "js") {
+                    for (const finding of scanTsdocSyntax(content)) {
+                        if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
+                            allowlistedCount++;
+                            continue;
+                        }
+                        breakages.push({ line: finding.line, raw: finding.raw, reason: finding.reason });
                     }
-                    breakages.push({ line: finding.line, raw: finding.raw, reason: finding.reason });
                 }
             }
             if (breakages.length > 0) {
@@ -186,5 +190,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run-comments.js.map
+}

package/dist/audit/run-display-names.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+import { auditDisplayNames } from "#/audit/domain/display-names";
+import { AppError, messageFrom } from "#/core/errors";
+import { err, ok } from "#/core/result";
+import { walkMarkdownFiles } from "#/core/workspace/markdown-walk";
+import { walkTsxFiles } from "#/core/workspace/typescript-walk";
+/**
+ * Trees the convention does not reach: a test or benchmark token is scoped by its file and never
+ * meets another author's, and a changelog quotes names as they were.
+ */
+const SKIPPED_SEGMENTS = new Set(["tests", "benchmarks", ".changeset"]);
+const SKIPPED_BASENAMES = new Set(["CHANGELOG.md"]);
+/**
+ * Scans a target path for `token()`, `tag()` and module display names that break the convention.
+ *
+ * @since 0.9.0
+ */
+export function runDisplayNameAudit(fs, args) {
+    try {
+        const allowlist = new Set(args.allowlist);
+        const { rootDir, targetPath } = args;
+        const filesToScan = collectScanPaths(fs, rootDir, targetPath);
+        const files = [];
+        let violationCount = 0;
+        let allowlistedCount = 0;
+        for (const absolutePath of filesToScan) {
+            const relativePath = toPosixPath(path.relative(rootDir, absolutePath));
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const remaining = auditDisplayNames(content).filter(({ raw }) => {
+                const isAllowed = allowlist.has(raw) || allowlist.has(`${relativePath}:${raw}`);
+                if (isAllowed) {
+                    allowlistedCount++;
+                }
+                return !isAllowed;
+            });
+            if (remaining.length === 0) {
+                continue;
+            }
+            violationCount += remaining.length;
+            files.push({ relativePath, violations: remaining });
+        }
+        return ok({ files, violationCount, allowlistedCount, scannedFileCount: filesToScan.length });
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+}
+function collectScanPaths(fs, rootDir, targetPath) {
+    const stats = fs.statSync(targetPath);
+    const candidates = stats.isFile()
+        ? [targetPath]
+        : [...walkTsxFiles(targetPath, fs), ...walkMarkdownFiles(targetPath, fs)];
+    return candidates.filter((absolutePath) => {
+        const relative = path.relative(rootDir, absolutePath).split(path.sep);
+        return !relative.some((segment) => SKIPPED_SEGMENTS.has(segment)) && !SKIPPED_BASENAMES.has(relative.at(-1));
+    });
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join("/");
+}

package/dist/audit/run-links.js

@@ -88,5 +88,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run-links.js.map
+}

package/dist/audit/run-react.js

@@ -52,5 +52,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run-react.js.map
+}

package/dist/audit/run.js

@@ -53,5 +53,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run.js.map
+}

package/dist/bin.js

@@ -2,5 +2,4 @@
 import process from "node:process";
 import { runCli } from "#/cli";
 const code = await runCli(process.argv);
-process.exit(code);
-//# sourceMappingURL=bin.js.map
+process.exit(code);

package/dist/cli.js

@@ -6,6 +6,7 @@ import { Command } from "commander";
 import { createArrangeCommand } from "#/arrange/command";
 import { createAuditCommand } from "#/audit/command";
 import { createMirrorCommand } from "#/mirror/command";
+import { createPackSlimCommand } from "#/pack-slim/command";
 import { createTagCommand } from "#/tag/command";
 function readVersion() {
     try {
@@ -39,9 +40,9 @@ export async function runCli(argv) {
     program.addCommand(createArrangeCommand());
     program.addCommand(createAuditCommand());
     program.addCommand(createMirrorCommand());
+    program.addCommand(createPackSlimCommand());
     program.addCommand(createTagCommand());
     await program.parseAsync(argv, { from: "node" });
     const code = process.exitCode ?? 0;
     return typeof code === "number" ? code : Number(code) || 0;
-}
-//# sourceMappingURL=cli.js.map
+}

package/dist/core/cli/format-error.js

@@ -17,5 +17,4 @@ export function formatAppError(error) {
             return `Unhandled error code: ${String(exhaustive)}`;
         }
     }
-}
-//# sourceMappingURL=format-error.js.map
+}

package/dist/core/cli/global-options.js

@@ -6,5 +6,4 @@ import { z } from "zod";
  */
 export const globalCliCommanderOptionsSchema = z.object({
     color: z.boolean().optional(),
-});
-//# sourceMappingURL=global-options.js.map
+});

package/dist/core/cli/positional.js

@@ -5,5 +5,4 @@
  */
 export function readOptionalPositionalArg(candidate) {
     return typeof candidate === "string" ? candidate : undefined;
-}
-//# sourceMappingURL=positional.js.map
+}