@expo/code-review-cli 0.9.0 → 0.9.2

package/build/commands/ref-check.js

@@ -22,7 +22,7 @@ Exit 0 = every ref holds. Exit 1 = at least one is broken.
 
 Options:
   --root <dir>   Repository root to check (default: the current git repo).
-  --json         Emit {ok, problems:[{file, line, kind, problem}]} on stdout.
+  --json         Emit {ok, problems:[{file, line, kind, problem, target?}]} on stdout.
 `;
 const KIND_LABEL = {
     "broken-ref": "broken ref",

package/build/core/config-refs.js

@@ -7,6 +7,7 @@ import { CONFIG_DIRNAME, stripJsonComments, stripTrailingCommas } from "../confi
 import { ROUTING_FILENAME } from "../config/routing.js";
 import { git, pathInside } from "./exec.js";
 import { matchesIgnore } from "./noise.js";
+import { isAmbientRuntimeConfig } from "./scrub.js";
 /**
  * Built by concatenation so this module's own regexes and doc comments are not
  * themselves collected as refs by a scanner (the repo's `ref-check` does the same).
@@ -40,6 +41,7 @@ const CITATION_EXTENSIONS = new Set([
     ".css",
     ".go",
     ".graphql",
+    ".hcl",
     ".h",
     ".hpp",
     ".html",
@@ -63,6 +65,8 @@ const CITATION_EXTENSIONS = new Set([
     ".sh",
     ".sql",
     ".swift",
+    ".tf",
+    ".tfvars",
     ".toml",
     ".ts",
     ".tsx",
@@ -608,10 +612,11 @@ export async function checkConfigRefs(options) {
     // Does an extensionless token name something real? Cached: prompts repeat the same
     // paths, and each miss would otherwise cost a stat per occurrence.
     const resolvable = new Map();
-    /** The root-relative path an extensionless token names, or null if it names nothing. */
+    /** The root-relative path a token names, or null. Scope first: a scoped prompt
+     * citing `alerts/` means its own tree even when the root has one too. */
     const namedPath = async (token, scopeRoot) => {
         for (const candidate of pathishCandidates(token)) {
-            for (const base of [root, scopeRoot]) {
+            for (const base of [scopeRoot, root]) {
                 const absolute = path.resolve(base, candidate);
                 let resolved = resolvable.get(absolute);
                 if (resolved === undefined) {
@@ -630,6 +635,18 @@ export async function checkConfigRefs(options) {
         }
         return null;
     };
+    /** The glob a wildcard token names, rebased onto the scope when that is what
+     * matches, so the suggested `glob:` ref actually resolves. */
+    const namedGlob = (token, scopeRoot) => {
+        const scopeRel = path.relative(root, scopeRoot).split(path.sep).join("/");
+        const candidates = [...(scopeRel && scopeRel !== "." ? [`${scopeRel}/${token}`] : []), token];
+        for (const candidate of candidates) {
+            if (index.files.some((file) => matchesIgnore(file, candidate))) {
+                return candidate;
+            }
+        }
+        return null;
+    };
     for (const dir of dirs) {
         const scopeRoot = path.dirname(dir);
         for (const file of await setupFiles(dir)) {
@@ -658,6 +675,7 @@ export async function checkConfigRefs(options) {
                         line: ref.line,
                         kind: problem.startsWith("cites a line number") ? "line-number-ref" : "broken-ref",
                         problem,
+                        target: ref.target,
                     });
                     continue;
                 }
@@ -674,24 +692,28 @@ export async function checkConfigRefs(options) {
                 }
             }
             for (const { line, token } of findProseCitations(text)) {
-                const forms = citationForms(token);
+                const isWild = token.includes("*");
+                const named = isWild ? namedGlob(token, scopeRoot) : await namedPath(token, scopeRoot);
+                // Shape alone makes a citation; otherwise it must name something real, or
+                // `anthropic/claude-opus-5` would read as a path.
+                if (!isCodeCitation(token) && !named) {
+                    continue;
+                }
+                // Coverage accepts the resolved path too, else the only ref that silences a
+                // scope-relative citation is an over-broad `glob:**/<basename>`.
+                const forms = [...citationForms(token), ...(named ? coveringForms(named) : [])];
                 if (ignored.has(token) ||
                     forms.some((form) => covered.has(form)) ||
                     coveringGlobs.some((pattern) => forms.some((form) => matchesIgnore(form.replace(/^\.\.\.\//, ""), pattern)))) {
                     continue;
                 }
-                // Extension or wildcard tail ⇒ a citation on shape alone. Otherwise it only
-                // counts if it names something real: `eas-build-worker/terraform` and
-                // `general-central/{module,production}` are paths, `anthropic/claude-opus-5`
-                // is shaped identically and is not.
-                const named = isCodeCitation(token) ? null : await namedPath(token, scopeRoot);
-                if (!isCodeCitation(token) && !named) {
-                    continue;
-                }
                 const lineCitation = LINE_CITATION_RE.exec(token);
-                // For an extensionless token the suggestion is the path that actually resolved,
-                // which is also how a scope-relative citation learns its root-relative form.
-                const suggestion = named ?? suggestedRef(token);
+                // A wildcard token means the family; anything else gets the precise resolved path.
+                const suggestion = isWild
+                    ? named
+                        ? `${GLOB_PREFIX}${named}`
+                        : suggestedRef(token)
+                    : (named ?? suggestedRef(token));
                 problems.push({
                     file: relative,
                     line,
@@ -699,6 +721,7 @@ export async function checkConfigRefs(options) {
                     problem: lineCitation
                         ? `\`${token}\` pins a line number; cite the file or a \`#symbol\` instead, as \`${REF_MARK} ${suggestedRef(lineCitation[1])}\``
                         : `\`${token}\` cites code without a ref; add \`${REF_MARK} ${suggestion} — why it matters\` (or \`${IGNORE_MARK} ${token}\` if it is not a path)`,
+                    target: token,
                 });
             }
         }
@@ -720,6 +743,12 @@ export async function checkConfigRefs(options) {
         citedPaths: [...citedPaths].sort(),
     };
 }
+/** The file a target names, with any `glob:` prefix, `#anchor` or `:line` stripped. */
+function citedBasename(target) {
+    const withoutPrefix = target.startsWith(GLOB_PREFIX) ? target.slice(GLOB_PREFIX.length) : target;
+    const withoutLine = LINE_CITATION_RE.exec(withoutPrefix)?.[1] ?? withoutPrefix;
+    return path.basename(splitAnchor(withoutLine)[0]);
+}
 /** How many examples a review-side note names before saying "and N more". */
 const NOTE_EXAMPLES = 5;
 function andMore(items) {
@@ -742,7 +771,11 @@ export async function reviewSetupRefNotes(options) {
         return []; // a check that cannot run must never degrade the review
     }
     const notes = [];
-    const broken = report.problems.filter((problem) => problem.kind !== "unannotated-citation");
+    // The read root is scrubbed of ambient runtime config (AGENTS.md, CLAUDE.md, .env…),
+    // so a ref to one is missing by design here, not stale. The template itself cites
+    // AGENTS.md, which would make this note cry wolf on every PR.
+    const broken = report.problems.filter((problem) => problem.kind !== "unannotated-citation" &&
+        !(problem.target && isAmbientRuntimeConfig(citedBasename(problem.target))));
     if (broken.length > 0) {
         notes.push(`The reviewer setup cites code that no longer resolves (${broken.length} ref(s)): ` +
             `${andMore(broken.map((problem) => `${problem.file}:${problem.line}`))}. ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/code-review-cli",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Generic, config-driven AI code reviewer engine. Repos supply their agents via .expo-code-review/.",
   "license": "MIT",
   "repository": {