mirror of
https://github.com/expo/code-review-cli.git
synced 2026-11-13 20:28:06 -10:00
Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Philippe Loulidi
|
1547b9e370 | ||
|
Philippe Loulidi
|
bdd0b2c5ec | ||
|
Philippe Loulidi
|
f2f31522c8 | ||
|
Philippe Loulidi
|
ac2b4a2928 | ||
|
Philippe Loulidi
|
8b4780f473 | ||
|
Philippe Loulidi
|
e8feaa64e0 | ||
|
Philippe Loulidi
|
b737b8138d |
No files matched your search
@@ -35,22 +35,10 @@ the same kind of thing, so the codebase stays uniform and predictable.
|
||||
|
||||
## This repo's conventions
|
||||
|
||||
<!-- @ref glob:src/commands/*.ts — every command follows the shape described here -->
|
||||
<!-- @ref src/core/util.ts#errorMessage — the required error path -->
|
||||
<!-- @ref src/cli.ts — where a new command must be registered -->
|
||||
<!-- @ref src/config/schema.ts — one of the three places a config option lands -->
|
||||
<!-- @ref src/config/load.ts — the second -->
|
||||
<!-- @ref templates/config.jsonc — the third; a missing option here is a finding -->
|
||||
<!-- @ref templates/ — the scaffolding source that must stay in sync with src/ -->
|
||||
<!-- @ref src/ — the engine side of that sync -->
|
||||
<!-- @ref src/reporters/reporter.ts — the reporter interface siblings implement -->
|
||||
<!-- @ref src/sources/source.ts — the source interface siblings implement -->
|
||||
<!-- @ref src/__tests__/ — where a new module's bun test file belongs -->
|
||||
|
||||
- **New CLI commands** (`src/commands/*.ts`): a `USAGE` string, `-h`/`--help`
|
||||
handled first, errors written to stderr via `errorMessage(error)` from
|
||||
`src/core/util.ts`, and `process.exitCode = 2` on failure — never
|
||||
`process.exit()`. Registered in `src/cli.ts`.
|
||||
`core/util.ts`, and `process.exitCode = 2` on failure — never `process.exit()`.
|
||||
Registered in `src/cli.ts`.
|
||||
- **New config options** land in three places together: the zod schema
|
||||
(`src/config/schema.ts`), loading/defaults (`src/config/load.ts`), and the
|
||||
commented example in `templates/config.jsonc`. An option missing from the
|
||||
|
||||
@@ -19,10 +19,6 @@ issues in the changed code.
|
||||
|
||||
## This repo's footguns
|
||||
|
||||
<!-- @ref src/core/verify.ts#matchEvidence — where model claims become trusted -->
|
||||
<!-- @ref-ignore .js -->
|
||||
|
||||
|
||||
- **ESM specifiers**: TypeScript with NodeNext resolution — relative imports need
|
||||
the `.js` suffix. A missing suffix can type-check yet break the built CLI at
|
||||
runtime.
|
||||
|
||||
@@ -23,14 +23,6 @@ average severity.
|
||||
|
||||
## This repo's sensitive surfaces
|
||||
|
||||
<!-- @ref src/core/auth.ts#FORBIDDEN_TOKEN_ENVS — the deny-list this section is about -->
|
||||
<!-- @ref src/core/exec.ts — the single child-process seam (execFile, no shell) -->
|
||||
<!-- @ref src/core/prompts.ts#sanitizeUntrusted — the injection boundary named below -->
|
||||
<!-- @ref src/core/render.ts — writes the state markers a PR must not forge -->
|
||||
<!-- @ref templates/workflow.yml — scaffolded into every adopting repo -->
|
||||
<!-- @ref templates/config.jsonc — the tokenEnv guard must stay in sync with it -->
|
||||
<!-- @ref-ignore .runs/ -->
|
||||
|
||||
This CLI's core job is forwarding a model-provider credential and executing
|
||||
PR-controlled config, so these areas are critical surface:
|
||||
|
||||
@@ -58,8 +50,6 @@ PR-controlled config, so these areas are critical surface:
|
||||
guard step affect all downstream users, and the guard must stay in sync with
|
||||
`templates/config.jsonc`.
|
||||
|
||||
<!-- @ref glob:.github/workflows/** — the workflows this section judges -->
|
||||
|
||||
## CI / workflow supply-chain (changes under `.github/workflows/**`)
|
||||
|
||||
Treat any changed workflow as high-risk and reason about the *trigger*, not just
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
// Add or remove files to change the roster — no list needed here.
|
||||
// shared.md (prepended to every agent + coordinator) and coordinator.md are
|
||||
// reserved filenames. Per-agent overrides go in each file's YAML frontmatter,
|
||||
// e.g. `---\nmodel: anthropic/claude-opus-5\n---`.
|
||||
// e.g. `---\nmodel: anthropic/claude-opus-4-1\n---`.
|
||||
|
||||
"policy": {
|
||||
// Phase 1: keep signal high by surfacing only critical/warning.
|
||||
|
||||
@@ -11,8 +11,6 @@ These rules apply to every reviewer and are concatenated onto your role prompt.
|
||||
- **Do not judge the diff in isolation.** Before reporting, read the surrounding
|
||||
source with your file/read/grep tools and trace the relevant execution path.
|
||||
If you cannot substantiate a concrete failure or exploit path, do not report it.
|
||||
<!-- @ref AGENTS.md — the conventions reviewers must judge against -->
|
||||
<!-- @ref-ignore CLAUDE.md -->
|
||||
- Ground your judgment in the repo's own conventions (`AGENTS.md` / `CLAUDE.md`
|
||||
at the repo root, and any per-directory guidance) rather than generic
|
||||
best-practices.
|
||||
|
||||
@@ -17,13 +17,3 @@ jobs:
|
||||
|
||||
- name: Validate LLP references and metadata
|
||||
run: ./ref-check --verbose
|
||||
|
||||
- uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
|
||||
with:
|
||||
bun-version: latest
|
||||
|
||||
- run: bun install --frozen-lockfile
|
||||
|
||||
# The same grammar, applied to this repo's own review setup (see LLP 0012).
|
||||
- name: Validate review-setup refs
|
||||
run: bun run src/cli.ts ref-check
|
||||
@@ -33,10 +33,6 @@ verifies their findings, and posts one updating PR comment.
|
||||
don't silently "fix" either side.
|
||||
- `./ref-check` (`bun run llp:check`) validates refs and metadata; CI runs it
|
||||
on every push and PR.
|
||||
- `ecr ref-check` validates the SAME `@ref` grammar inside a repo's
|
||||
`.expo-code-review/` setup (see LLP 0012). The two checkers share the grammar:
|
||||
a change to target kinds, the `<placeholder>` rule, or the glob dialect must
|
||||
land in `./ref-check` and `src/core/config-refs.ts` together.
|
||||
|
||||
## Conventions
|
||||
|
||||
|
||||
@@ -70,9 +70,9 @@ excludes) — see [the mixed setup](#other-providers) below. Prefer
|
||||
# Review working-tree changes; prints here, posts nothing
|
||||
ecr review
|
||||
# Review a GitHub PR by number (preview only)
|
||||
ecr review --pr 123
|
||||
ecr review --pr 4057
|
||||
# …and post it as the PR comment
|
||||
ecr review --pr 123 --post
|
||||
ecr review --pr 4057 --post
|
||||
```
|
||||
|
||||
Options (most to least common):
|
||||
@@ -116,7 +116,6 @@ is a ready example to adapt.
|
||||
| `ecr ci` | Review the current GitHub PR and post/update a comment. For GitHub Actions. |
|
||||
| `ecr doctor [--list-scopes]` | Check environment, config, credentials, and (with a manifest) scopes. |
|
||||
| `ecr feedback [--repo <owner/repo>]` | Report which findings PR authors pushed back on, across history. See below. |
|
||||
| `ecr ref-check [--json]` | Fail when the review setup cites code that moved or vanished. See below. |
|
||||
|
||||
Extra flags for monorepos: `review`/`ci` `--config-dir <dir>` (load config from an
|
||||
alternate dir; also `ECR_CONFIG_DIR`), `ci --scopes a,b` (limit the fan-out to
|
||||
@@ -128,48 +127,6 @@ untrusted external context; see below).
|
||||
|
||||
---
|
||||
|
||||
## Keeping prompts true (`ecr ref-check`)
|
||||
|
||||
Good reviewer prompts cite real code: "the only session entry point is
|
||||
`server/src/session.ts`", "every webhook router must call `sanitizeSecrets`". Then the
|
||||
code moves and the prompt keeps citing a path that no longer exists — the reviewer
|
||||
reasons from a fiction, on every PR, with nothing to warn you.
|
||||
|
||||
`ecr ref-check` makes those citations checkable. Pin each one with a ref, in a comment
|
||||
of its own (`<!-- … -->` in Markdown, `//` in JSONC):
|
||||
|
||||
```md
|
||||
<!-- @ref server/src/session.ts#createSession — the only place a session is minted -->
|
||||
<!-- @ref server/src/entities/oauth/ — every provider lives here -->
|
||||
<!-- @ref glob:**/*WebhookRouter.ts — the routers this rule is about -->
|
||||
```
|
||||
|
||||
A target is a file, a `dir/`, `glob:<pattern>`, `file#symbol`, or `doc.md#heading` —
|
||||
never a line number, since a line number rots without any signal. Symbol anchors are
|
||||
checked by whole-word match, so code moving inside its file is fine and a rename is not.
|
||||
|
||||
The check is strict on purpose: a backticked token in `.expo-code-review/` that looks
|
||||
like a repo path **must** be a ref, because the stale citations are exactly the ones
|
||||
nobody thought to annotate. A token with no extension (`eas-build-worker/terraform`,
|
||||
`general-central/{module,production}`, `finops`) counts when it names something that
|
||||
exists — so those get pinned too, while `anthropic/claude-opus-5`, shaped the same way,
|
||||
stays prose. For a token that only looks like a path, say so once:
|
||||
`<!-- @ref-ignore knex.raw() -->`. It also checks what your config already declares —
|
||||
`enforceAgents` ids, scope `config` directories, scope path globs.
|
||||
|
||||
Refs are repo-root-relative, including in a scope's own setup dir. A scope prompt that
|
||||
cites `general-central/module` for `infrastructure/general-central/module` gets told the
|
||||
root-relative form to use.
|
||||
|
||||
Two run points:
|
||||
|
||||
- `ecr ref-check` exits 1 on any problem. Run it in CI or a pre-commit hook.
|
||||
- `ecr review` / `ecr ci` run it too, and never fail a PR's checks with it. The comment
|
||||
carries a **Review setup** note instead: refs that no longer resolve, plus cited code
|
||||
*this PR* changes, where the ref still resolves but the guidance may not.
|
||||
|
||||
---
|
||||
|
||||
## Monorepos (routing manifest)
|
||||
|
||||
A monorepo can route different subtrees to different reviewer rosters from a single
|
||||
@@ -184,9 +141,9 @@ your-monorepo/
|
||||
routing.jsonc # the manifest — infra-owned, ordered scope list + locked defaults
|
||||
config.jsonc # the default/root scope; the ONLY place auth/tokenEnv lives
|
||||
shared.md coordinator.md agents/
|
||||
apps/
|
||||
api/.expo-code-review/{config.jsonc(NO auth),coordinator.md,agents/} # api team
|
||||
web/.expo-code-review/{config.jsonc(NO auth),coordinator.md,agents/} # web team
|
||||
server/
|
||||
www/.expo-code-review/{config.jsonc(NO auth),coordinator.md,agents/} # www team
|
||||
website/.expo-code-review/{config.jsonc(NO auth),coordinator.md,agents/} # website team
|
||||
.github/workflows/expo-code-review.yml # unchanged shape: one workflow, one `ecr ci`
|
||||
```
|
||||
|
||||
@@ -203,21 +160,21 @@ your-monorepo/
|
||||
"comment": "single", // "single" = one aggregated comment (default) | "per-scope"
|
||||
// Ordered; the LAST matching scope wins per changed file (CODEOWNERS discipline).
|
||||
"scopes": [
|
||||
{ "name": "default", "paths": ["**/*"], "config": "." },
|
||||
{ "name": "apps-api", "paths": ["apps/api/**"], "config": "apps/api" },
|
||||
{ "name": "apps-web", "paths": ["apps/web/**"], "config": "apps/web" }
|
||||
{ "name": "default", "paths": ["**/*"], "config": "." },
|
||||
{ "name": "server-www", "paths": ["server/www/**"], "config": "server/www" },
|
||||
{ "name": "server-website", "paths": ["server/website/**"], "config": "server/website" }
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
```jsonc
|
||||
// apps/api/.expo-code-review/config.jsonc (the api team owns this)
|
||||
// server/www/.expo-code-review/config.jsonc (the www team owns this)
|
||||
{
|
||||
// NO "auth" block — locked centrally; a tokenEnv here is rejected by loader + CI guard.
|
||||
"model": "openai/gpt-5.5",
|
||||
"policy": { "includeSuggestions": false },
|
||||
"noise": { "additionalIgnores": ["apps/api/**/__generated__/**"] }
|
||||
// shared.md, coordinator.md, agents/*.md live beside this file — the api team's roster.
|
||||
"noise": { "additionalIgnores": ["server/www/**/__generated__/**"] }
|
||||
// shared.md, coordinator.md, agents/*.md live beside this file — the www team's roster.
|
||||
}
|
||||
```
|
||||
|
||||
@@ -291,7 +248,7 @@ your-monorepo/
|
||||
security warning and will be removed on a minor boundary.
|
||||
|
||||
Ownership is enforced with CODEOWNERS: `/.expo-code-review/routing.jsonc @your-infra`
|
||||
(the single authoritative router) and `/apps/api/.expo-code-review/ @your-api-team`
|
||||
(the single authoritative router) and `/server/www/.expo-code-review/ @your-www-team`
|
||||
(each team owns only its own scope dir). Rerouting globs is gated behind infra review.
|
||||
|
||||
---
|
||||
@@ -587,7 +544,7 @@ highest-value part — "repeat offenders": findings whose title recurred across
|
||||
PRs and drew a reply every single time.
|
||||
|
||||
```bash
|
||||
ecr feedback --repo your-org/your-repo --limit 100 --since 2026-06-01
|
||||
ecr feedback --repo expo/eas-cli --limit 100 --since 2026-06-01
|
||||
ecr feedback --as my-review-bot # if CI posts under a PAT/app identity
|
||||
ecr feedback --json # for scripting
|
||||
```
|
||||
|
||||
@@ -25,7 +25,7 @@ The IO and the logic are split on purpose. `walkUpstack` is a pure, exported fun
|
||||
|
||||
- **Same-repo, root included** — a child counts only when `head.repo.full_name` equals `owner/repo` [observed] ([github-pr.ts](../src/sources/github-pr.ts) `fetchOpenChildren` sets `sameRepo`). The REST pulls-list endpoint has no `isCrossRepository` field, so this comparison is the fork gate; a fork PR is dropped. The ROOT PR gets the same gate before the walk even starts: a fork PR's `headRefName` names a branch of the FORK, and using it as the pulls-list `base=` filter would match a same-named base-repo branch (a fork head called `main` would pull in every open PR targeting `main`), letting unrelated PRs into the manifest — so a cross-repo root (`isCrossRepository` from `gh pr view`) returns `null` outright [observed] ([github-pr.ts](../src/sources/github-pr.ts) `getStackContextAsync` cross-repo guard).
|
||||
- **Same-author** — when `requireSameAuthor` (default true), a child counts only when its `user.login` equals the current PR's author [observed] ([github-pr.ts](../src/sources/github-pr.ts) `walkUpstack` same-author filter; author from `fetchPrTrustAnchors`). This closes cross-author poisoning: a push-access colleague opening a child PR on the victim's branch cannot inject paths. Teams running genuine multi-author stacks set `requireSameAuthor: false` from the trusted base — an explicit, base-committed choice.
|
||||
- **Depth / width caps and a cycle guard** — `maxDepth` levels, `maxPrs` children per level, and a visited-branch `Set` so a branch cycle can't loop [observed] ([github-pr.ts](../src/sources/github-pr.ts) `walkUpstack`). Per child, file pages are fetched one by one and stop as soon as `maxFilesPerPr` is exceeded or a hard page ceiling is hit (never `--paginate` to the end of a huge child PR), setting `truncated` when either bound bites [observed] ([github-pr.ts](../src/sources/github-pr.ts) `collectChildFiles`, `MAX_CHILD_FILE_PAGES`; tests [stack-walk.test.ts](../src/__tests__/stack-walk.test.ts)).
|
||||
- **Depth / width caps and a cycle guard** — `maxDepth` levels, `maxPrs` children per level, and a visited-branch `Set` so a branch cycle can't loop [observed] ([github-pr.ts](../src/sources/github-pr.ts) `walkUpstack`). Per child, files are fetched with `--paginate` and capped at `maxFilesPerPr`, setting `truncated` when the cap bites [observed] ([github-pr.ts](../src/sources/github-pr.ts) `fetchChildFiles`).
|
||||
|
||||
`--method GET` on the pulls list is mandatory (else `gh` POSTs), and a per-element `--jq` yields NDJSON that stays valid when `gh` concatenates pages — unlike a bare `--paginate`, which concatenates JSON arrays into invalid JSON (the same trap the reporter's manual pagination avoids, [LLP 0008](./0008-sources-and-reporters.explainer.md)) [observed] ([github-pr.ts](../src/sources/github-pr.ts) `fetchOpenChildren`).
|
||||
|
||||
|
||||
@@ -279,21 +279,9 @@ model could be argued out of. `feedbackApplied` is the single function that
|
||||
decides whether a reply clears a finding, and it returns `false` unconditionally
|
||||
for `finding.severity === "critical"` and for any finding whose category is in
|
||||
`HARD_FLOOR_CATEGORIES` (`secrets`, `security`) — a constant the configured
|
||||
`protectedCategories` can only ADD to, never shrink, since that check runs
|
||||
independently of the floor [observed] ([adjudicate.ts](../src/core/adjudicate.ts)
|
||||
`HARD_FLOOR_CATEGORIES`, `hardFloored`, `feedbackApplied`). The floor is also the
|
||||
reason such a reply is never JUDGED: `hardFloored` is one function read by both
|
||||
`feedbackApplied` and `adjudicateFeedback`'s `toJudge` filter, so the two can never
|
||||
drift into a model call whose verdict the floor would then discard — a call that also
|
||||
consumed one of the `maxAdjudications` slots a clearable finding's reply could have
|
||||
used. The skip is deliberately NOT counted in `skipped`: that figure surfaces as "N
|
||||
left unjudged over the cap", and raising the cap would buy back no coverage here,
|
||||
so counting it would report a gap that does not exist. The config-tunable exclusions
|
||||
(`protectedCategories`, `dismiss`) are deliberately left IN the judged set — they can
|
||||
change, and `applied` is recomputed under the current config on every run, so a stored
|
||||
verdict there becomes useful the moment a repo widens its policy
|
||||
[observed] ([adjudicate.ts](../src/core/adjudicate.ts) `adjudicateFeedback`, the
|
||||
`!hardFloored(item.finding)` term of `toJudge`). Above those floors, dismissal is
|
||||
`protectedCategories` can only ADD to, never shrink, since both checks run
|
||||
independently [observed] ([adjudicate.ts](../src/core/adjudicate.ts)
|
||||
`HARD_FLOOR_CATEGORIES`, `feedbackApplied`). Above those floors, dismissal is
|
||||
gated by `dismiss` alone: `"never"` (the shipped default) short-circuits to
|
||||
`false` before any floor is even checked, so nothing clears a finding until a
|
||||
repo explicitly opts in. `mode` is deliberately a separate axis — it selects
|
||||
@@ -322,9 +310,9 @@ clears" rather than open [observed] ([responses.ts](../src/core/responses.ts)
|
||||
|
||||
Re-deriving it costs a `gh pr view`, and `mode: "annotate"` is the shipped
|
||||
default, so that call would otherwise land on EVERY report of every adopting
|
||||
repo — multiplied per scope in routed CI, which builds one reporter per scope
|
||||
comment plus one for the aggregate comment. Two things bound it, and neither weakens
|
||||
the fail-closed rule. The flag gates exactly one branch, so it is resolved only when that
|
||||
repo — multiplied per scope in routed CI, which builds a fresh reporter per
|
||||
scope plus one for the seam. Two things bound it, and neither weakens the fail-
|
||||
closed rule. The flag gates exactly one branch, so it is resolved only when that
|
||||
branch is reachable: `feedbackNeedsPrAuthor` returns true for
|
||||
`dismiss: "adjudicated"` and nothing else, and a skipped lookup reads the same
|
||||
as a failed one — `author: false`, clears nothing
|
||||
@@ -350,17 +338,6 @@ in-flight entry, while the entry is still what concurrent scopes join
|
||||
[observed] ([github.ts](../src/reporters/github.ts) `sharedPrAuthor`, the
|
||||
`forget` helper).
|
||||
|
||||
The other half of that cost is per instance and stays per instance: the paginated
|
||||
comment list (a 30s TTL cache) and the resolved bot login. So the rule in `ci.ts` is
|
||||
**one reporter per comment, not one per call site** — a scope's feedback seam reads the
|
||||
very comment that scope's review is posted to, so a second instance for the same tag
|
||||
re-fetches the identical list and re-resolves the login. `comment:'single'` mode shares
|
||||
`singleModeReporter` across every scope's seam and the aggregate post; per-scope mode
|
||||
memoizes one reporter per scope name and uses it for both that scope's seam and its
|
||||
`report()` [observed] ([ci.ts](../src/commands/ci.ts) `singleModeReporter`,
|
||||
`memoizeByScope`). The link context the report needs is inert for the seam
|
||||
(`matchAdjudicationItems` renders nothing), so one link-carrying reporter serves both.
|
||||
|
||||
`adjudicateFeedback` re-derives `applied` for **every** record on every call —
|
||||
including ones a model never touched this run (already-decided verdicts from a
|
||||
prior run are skipped to avoid re-spending the budget on the same words,
|
||||
|
||||
@@ -1,174 +0,0 @@
|
||||
# LLP 0012: Review-Setup Ref Integrity
|
||||
|
||||
**Type:** Explainer
|
||||
**Status:** Active
|
||||
**Systems:** Engine, CLI
|
||||
**Author:** Philippe Loulidi / Claude
|
||||
**Date:** 2026-08-03
|
||||
**Related:** [LLP 0006 Config Schema, Loading, and Routing](0006-config-schema-loading-routing.explainer.md), [LLP 0007 CLI Commands and CI](0007-cli-commands-and-ci.explainer.md), [LLP 0009 Adoption Templates and CI Workflows](0009-adoption-templates-and-ci-workflows.guide.md)
|
||||
|
||||
A repo's reviewer prompts are full of citations into its own code: "the only session
|
||||
entry point is `server/www/src/utils/session.ts`", "every webhook router must call
|
||||
`sanitizeSecretPatterns`". Those citations are load-bearing — they are how a prompt
|
||||
carries repo knowledge the model does not have — and nothing kept them true. Code
|
||||
moves, symbols get renamed, and the prompt keeps citing a path that no longer exists.
|
||||
The reviewer then reasons from a fiction, silently, on every PR.
|
||||
|
||||
`ecr ref-check` (`src/commands/ref-check.ts`, over `src/core/config-refs.ts`) closes
|
||||
that gap: every code citation in a `.expo-code-review/` setup must be a ref, and every
|
||||
ref must resolve against the checkout. It is deterministic — no model, no network —
|
||||
in the same family as `ecr verify-config` (see [LLP 0007][verify]).
|
||||
|
||||
Two measurements motivated the strict form. Swept against a real adopting monorepo
|
||||
(universe) the check found 165 citations, none of them annotated or verified by
|
||||
anything; swept against this repo's own setup it found 24 [observed]. Not one of those
|
||||
citations was checked before this existed.
|
||||
|
||||
## The `@ref` Grammar
|
||||
|
||||
One grammar, reused from the engine's own LLP annotations, so an author learns it once:
|
||||
|
||||
@ref <target> [relation] — why it matters
|
||||
|
||||
In markdown it lives in an HTML comment, in JSONC after `//`. Targets:
|
||||
|
||||
| Target | Resolves when |
|
||||
|---|---|
|
||||
| `path/to/file.ts` | the file exists |
|
||||
| `path/to/dir/` | the directory exists (trailing slash is required) |
|
||||
| `path/to/file.ts#symbolName` | the file exists and still contains that whole word |
|
||||
| `path/to/doc.md#heading` | the file exists and has that heading |
|
||||
| `glob:**/Handler.kt` | at least one file in the repo matches |
|
||||
| `https://…` | shape only, never fetched |
|
||||
|
||||
Refs are **always repo-root-relative**, including inside a scope's setup dir. A scope's
|
||||
prompts describe the same tree the reviewer sees in the diff, so a second base
|
||||
directory would only create ambiguity about which one a ref meant. Scoped prompts do
|
||||
naturally cite their own subtree (`general-central/module` for
|
||||
`infrastructure/general-central/module`), so that stays a broken ref — but the message
|
||||
resolves it against the scope root and names the root-relative form to use.
|
||||
|
||||
`glob:` exists for readability. A Kotlin path 90 characters deep gets abbreviated in
|
||||
prose (`.../config/MetricGroupCounter.kt`) and an abbreviation cannot be resolved, so
|
||||
the check suggests the suffix glob `glob:**/config/MetricGroupCounter.kt` — short in the
|
||||
prompt, still verified.
|
||||
|
||||
**Invariant:** a target is data, never a command. Resolution reads files inside the repo
|
||||
root only, via the same `pathInside` confinement the verifier uses ([LLP 0005][verify5]);
|
||||
absolute paths and `..` escapes are refused, not resolved.
|
||||
|
||||
## No Line Numbers, Symbol Anchors Instead
|
||||
|
||||
A ref may not pin a line. `src/auth.ts:42` is refused in an annotation *and* in prose,
|
||||
because a line number is the one form of citation that rots without any signal: insert
|
||||
a line above it and the ref still "resolves", now pointing at unrelated code. `#symbol`
|
||||
is the robust alternative — it survives the code moving inside its file, and breaks
|
||||
exactly when the thing cited is renamed or deleted, which is when a human should look.
|
||||
|
||||
For the same reason there is no content hash or pinned revision in the grammar. A digest
|
||||
would trip on every edit to the cited file, including edits that leave the prompt
|
||||
perfectly correct, and a check that cries wolf gets disabled. The drift signal lives on
|
||||
the review side instead (below).
|
||||
|
||||
## Unannotated Citations Are Broken Refs
|
||||
|
||||
Checking only what an author annotated would make the mechanism decorative: the stale
|
||||
citations are precisely the ones nobody thought about. So a backticked token in a setup
|
||||
file that *looks like* a repo path and is not a ref fails the check.
|
||||
|
||||
That rule needs a precise notion of "looks like a path", because prompts also backtick
|
||||
config keys, severities, commands and model ids. It comes in two tiers.
|
||||
|
||||
**Shape alone** (`isCodeCitation`): an allowlisted source extension, a trailing slash, or
|
||||
a wildcard tail inside a path — and never whitespace, `:`, `<`, `(` or quotes. So
|
||||
`session.ts`, `src/entities/oauth/` and `.github/workflows/**` are citations, while
|
||||
`ecr ci`, `label:<agent>`, `knex.raw()`, `critical` and a bare `.ts` are prose. Fenced
|
||||
code blocks are skipped whole: they are examples, not claims about the tree.
|
||||
|
||||
**Shape plus the filesystem** (`pathishCandidates`), for the citations shape cannot
|
||||
settle. A reviewer of this feature named the case: a Terraform prompt citing
|
||||
`eas-build-worker/terraform`, `general-central/{module,production}` and `finops`, with
|
||||
"this is very likely going to drift" [observed] — not one of those has an extension, and
|
||||
`anthropic/claude-opus-5` is shaped identically while naming no file. Syntax cannot tell
|
||||
them apart, so an extensionless token counts as a citation exactly when it *names
|
||||
something real*: probed against the repo root and the scope's own subtree, brace lists
|
||||
and wildcards cut back to their fixed prefix. Model ids resolve to nothing and stay prose.
|
||||
|
||||
The consequence is deliberate: an extensionless path that had already drifted before
|
||||
adoption is invisible (nothing distinguishes it from prose), while every one that is true
|
||||
today gets pinned and will be caught the moment it moves. This mechanism prevents future
|
||||
drift; it does not retroactively find old drift.
|
||||
|
||||
The escape hatch is explicit and per-token: `@ref-ignore knex.raw()` in a comment.
|
||||
Anything the heuristic misclassifies is one short line away from silence, which is why
|
||||
the rule can afford to be strict rather than advisory.
|
||||
|
||||
**Invariant:** the check never rewrites a prompt. It reports; a human decides whether the
|
||||
ref or the prompt was wrong. A stale citation often means the *guidance* is stale, not
|
||||
just the path.
|
||||
|
||||
## Structural Refs Need No Annotation
|
||||
|
||||
Some refs the config already declares, so they are checked without annotation:
|
||||
`enforceAgents` ids must exist as `agents/<id>.md` in the ROOT setup (that is where the
|
||||
loader resolves them, see [LLP 0006][routing]), every scope's `config` must point at a
|
||||
real `.expo-code-review/` directory inside the repo, and every scope glob must match at
|
||||
least one file — a scope whose paths match nothing ships prompts that review nothing.
|
||||
|
||||
## What Gets Scanned
|
||||
|
||||
Setup dirs are found by walking the tree, not by reading `routing.jsonc`: a scope dir the
|
||||
manifest forgot still ships prompts, and its stale refs are exactly what this exists to
|
||||
surface — the same reason `ecr verify-config` sweeps on disk instead of trusting the
|
||||
manifest ([LLP 0007][verify]). Inside a setup dir the scan covers prompts and configs
|
||||
(`.md`, `.json`, `.jsonc`, `.txt`) and skips dot entries, so `.runs/` artifacts are never
|
||||
scanned. Dot directories elsewhere are skipped too, which keeps `.claude/worktrees/`
|
||||
checkouts of the same repo from being swept as if they were scopes.
|
||||
|
||||
## Run Points: Command and Review
|
||||
|
||||
`ecr ref-check` exits 1 on any problem: that is the gate, for CI or a pre-commit hook.
|
||||
|
||||
The review path also runs it, and never fails a PR's checks with it — that invariant
|
||||
holds ([LLP 0002][pipeline]). Instead the review *advises*: broken refs in the setup
|
||||
become a note the reviewer comment carries, and `citedPathsTouchedBy` adds the drift
|
||||
signal a static check cannot give — "this PR changes code your reviewer prompts cite, so
|
||||
the guidance may need updating" — even when the ref still resolves. In CI the config
|
||||
comes from the trusted base ref while refs resolve against the PR head tree, so a PR that
|
||||
moves cited code is reported against the config that will actually review it.
|
||||
|
||||
## Two Checkers, One Grammar
|
||||
|
||||
The engine repo now has two ref checkers, and they scan overlapping files: `./ref-check`
|
||||
(the LLP corpus validator, which walks the whole tree) and `ecr ref-check` (setup dirs
|
||||
only). Running both surfaced two genuine conflicts, where one checker failed an
|
||||
annotation the other accepted [observed]:
|
||||
|
||||
- `glob:` targets were unknown to `./ref-check`, which read them as a literal path and
|
||||
reported "path not found".
|
||||
- Documenting the syntax broke both: a usage line containing the comment form with a
|
||||
`<target>` placeholder was collected as a real ref, and so were the README's fenced
|
||||
examples — the docs that teach refs were the first thing the checkers rejected.
|
||||
|
||||
All of it is fixed in the grammar rather than per-checker: `glob:` is understood by both,
|
||||
a target starting with `<` or a backtick is a documentation placeholder, and an annotation
|
||||
inside a fenced code block is an example that neither checker resolves.
|
||||
|
||||
Ownership stays split by target kind, not by file: an `LLP NNNN` target belongs to the
|
||||
design corpus and its own checker, so `ecr ref-check` neither resolves nor counts one —
|
||||
it owns exactly the refs that cite the reviewed repo's code. That split is why the
|
||||
templates can keep their engine annotations and still scaffold a repo that passes
|
||||
`ecr ref-check` on day one (asserted in `init-scaffold.test.ts`). An earlier attempt had
|
||||
`ecr init` strip those annotations while scaffolding; it mixed the two mechanisms and
|
||||
broke the "workflow templates land byte-identical" invariant [observed]. Parsing is what
|
||||
must be right: `LLP 0009#anchor` is one target containing a space, and taking the first
|
||||
whitespace-separated token left a bare `LLP` that read as a broken path.
|
||||
|
||||
**Invariant:** the grammar is shared. A change to target kinds, the placeholder rule, or
|
||||
the glob dialect must land in `./ref-check` and `src/core/config-refs.ts` together, or the
|
||||
same annotation will pass one checker and fail the other.
|
||||
|
||||
[verify]: 0007-cli-commands-and-ci.explainer.md#verify-config-the-config-guard
|
||||
[verify5]: 0005-verification-fingerprints-rendering.explainer.md#verifier-confinement-and-fail-open
|
||||
[routing]: 0006-config-schema-loading-routing.explainer.md#routing-manifest
|
||||
[pipeline]: 0002-review-engine-pipeline.explainer.md#pipeline-stages
|
||||
@@ -52,12 +52,6 @@ CODE_REF_RE = re.compile(re.escape(REF_MARK) + r"\s+(.+)")
|
||||
MD_REF_RE = re.compile(r"<!--\s*" + re.escape(REF_MARK) + r"\s+(.+?)-->", re.DOTALL)
|
||||
LLP_TARGET_RE = re.compile(r"^LLP\s+(\d{1,4})(?:#(\S+))?$")
|
||||
SHORTHAND_RE = re.compile(r"^[A-Z][A-Z0-9_]*(?:#\S+)?$")
|
||||
# Shared with `ecr ref-check`, which validates the SAME @ref grammar inside a repo's
|
||||
# .expo-code-review/ setup: `glob:<pattern>` targets a set of files, and a `<…>` target
|
||||
# documents the syntax rather than citing a file. Both checkers must agree on these or
|
||||
# the same annotation passes one and fails the other.
|
||||
GLOB_PREFIX = "glob:"
|
||||
PLACEHOLDER_RE = re.compile(r"^[<`]")
|
||||
URL_RE = re.compile(r"^https?://[^\s/]+\.[^\s/]+\S*$")
|
||||
HEADING_RE = re.compile(r"^(#{1,6})\s+(.+?)\s*$")
|
||||
LLP_FILE_RE = re.compile(r"^(\d{4})-[a-z0-9-]+\.([a-z0-9]+)\.md$")
|
||||
@@ -147,68 +141,17 @@ def parse_target(rest):
|
||||
token = rest.split()[0] if rest.split() else ""
|
||||
if token.startswith(("http://", "https://")):
|
||||
return "url", token, None
|
||||
if PLACEHOLDER_RE.match(token):
|
||||
return "placeholder", token, None
|
||||
if token.startswith(GLOB_PREFIX):
|
||||
return "glob", token[len(GLOB_PREFIX):], None
|
||||
if SHORTHAND_RE.match(token):
|
||||
return "shorthand", token, None
|
||||
path, _, anchor = token.partition("#")
|
||||
return "path", path, anchor or None
|
||||
|
||||
|
||||
def glob_to_regex(pattern):
|
||||
"""The mini-glob dialect shared with the CLI: `**` crosses `/`, `*` does not."""
|
||||
out, i = "", 0
|
||||
while i < len(pattern):
|
||||
ch = pattern[i]
|
||||
if ch == "*":
|
||||
if pattern[i + 1:i + 2] == "*":
|
||||
out += ".*"
|
||||
i += 1
|
||||
else:
|
||||
out += "[^/]*"
|
||||
elif ch in ".+^${}()|[]\\?":
|
||||
out += "\\" + ch
|
||||
else:
|
||||
out += ch
|
||||
i += 1
|
||||
return re.compile(f"^{out}$")
|
||||
|
||||
|
||||
def repo_files(root):
|
||||
"""Every file in the tree (SKIP_DIRS pruned), root-relative with / separators."""
|
||||
found = []
|
||||
for dirpath, dirnames, filenames in os.walk(root):
|
||||
dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
|
||||
for name in filenames:
|
||||
rel = os.path.relpath(os.path.join(dirpath, name), root)
|
||||
found.append(rel.replace(os.sep, "/"))
|
||||
return found
|
||||
|
||||
|
||||
def fenced_lines(text):
|
||||
"""1-based line numbers inside a fenced code block (the fence lines included)."""
|
||||
fenced, open_fence = set(), False
|
||||
for i, line in enumerate(text.splitlines(), 1):
|
||||
if line.lstrip().startswith("```"):
|
||||
fenced.add(i)
|
||||
open_fence = not open_fence
|
||||
elif open_fence:
|
||||
fenced.add(i)
|
||||
return fenced
|
||||
|
||||
|
||||
def collect_refs(path, text):
|
||||
refs = [] # (lineno, rest)
|
||||
if path.endswith(".md"):
|
||||
# An annotation inside a fence documents the grammar; resolving it would make
|
||||
# every doc that explains refs fail. Same rule in ecr's config-refs.ts.
|
||||
fenced = fenced_lines(text)
|
||||
for m in MD_REF_RE.finditer(text):
|
||||
lineno = text.count("\n", 0, m.start()) + 1
|
||||
if lineno in fenced:
|
||||
continue
|
||||
refs.append((lineno, m.group(1)))
|
||||
else:
|
||||
for i, line in enumerate(text.splitlines(), 1):
|
||||
@@ -262,7 +205,6 @@ def check(root):
|
||||
|
||||
# --- refs: scan the tree ---
|
||||
n_files = n_refs = 0
|
||||
all_files = repo_files(root)
|
||||
exempt = (os.path.join("llp", "tombstones"), os.path.join("llp", "reviews"))
|
||||
for dirpath, dirnames, filenames in os.walk(root):
|
||||
dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
|
||||
@@ -295,13 +237,6 @@ def check(root):
|
||||
elif kind == "url":
|
||||
if not URL_RE.match(target):
|
||||
rep.error(f"{where}: malformed URL target: {target}")
|
||||
elif kind == "placeholder":
|
||||
rep.info(f"{where}: documentation placeholder, not a citation: {target}")
|
||||
elif kind == "glob":
|
||||
if not target:
|
||||
rep.error(f"{where}: empty glob target")
|
||||
elif not any(glob_to_regex(target).match(f) for f in all_files):
|
||||
rep.error(f"{where}: broken ref: glob matches no file: {target}")
|
||||
elif kind == "shorthand":
|
||||
rep.info(f"{where}: unchecked shorthand: {target} (no mapping defined)")
|
||||
else: # path
|
||||
|
||||
@@ -185,17 +185,9 @@ test("feedbackApplied: an unclearedByHuman record never clears (a human restored
|
||||
|
||||
// ---- adjudicateFeedback: recompute without model calls ----
|
||||
|
||||
// A record every toJudge gate lets through (the PR author, cites the id, no prior
|
||||
// verdict, no `/undismiss` pin) paired with real reply text. Each test below then varies
|
||||
// exactly ONE thing, so the gate it names is the only reason nothing is judged — a
|
||||
// fixture excluded by a second gate would stay green with the named gate deleted.
|
||||
const eligibleRecord = (over: Partial<FeedbackRecord> = {}): FeedbackRecord =>
|
||||
record({ author: true, citedId: true, ...over });
|
||||
const REBUTTAL = "false positive, sanitizePath runs below";
|
||||
|
||||
test("adjudicateFeedback: mode:'off' makes no model calls and applies nothing", async () => {
|
||||
const items: AdjudicationItem[] = [
|
||||
{ finding: finding(), record: eligibleRecord(), replyText: REBUTTAL },
|
||||
{ finding: finding(), record: record({ maintainer: true }), replyText: "trust me" },
|
||||
];
|
||||
const out = await adjudicateFeedback(noHandle, items, config({ mode: "off" }));
|
||||
expect(out.adjudicated).toBe(0);
|
||||
@@ -204,36 +196,6 @@ test("adjudicateFeedback: mode:'off' makes no model calls and applies nothing",
|
||||
expect(out.records[0]!.applied).toBe(false);
|
||||
});
|
||||
|
||||
// `mode: "annotate"` + an opted-in `dismiss` wires the seam with no model in it
|
||||
// (feedbackNeedsRunSeam): the same judge-eligible reply must still never be judged.
|
||||
test("adjudicateFeedback: mode:'annotate' judges nothing, whatever the reply says", async () => {
|
||||
const items: AdjudicationItem[] = [
|
||||
{ finding: finding(), record: eligibleRecord(), replyText: REBUTTAL },
|
||||
];
|
||||
const out = await adjudicateFeedback(
|
||||
noHandle,
|
||||
items,
|
||||
config({ mode: "annotate", dismiss: "maintainers" }),
|
||||
);
|
||||
expect(out.adjudicated).toBe(0);
|
||||
expect(out.skipped).toBe(0);
|
||||
expect(out.failed).toBe(0);
|
||||
expect(out.records[0]!.applied).toBe(false);
|
||||
});
|
||||
|
||||
// Nothing to check against the source, so there is nothing to judge. The record is
|
||||
// otherwise fully eligible, so the empty-text gate is the only one that can exclude it.
|
||||
test("adjudicateFeedback: a reply with no text is never judged", async () => {
|
||||
const items: AdjudicationItem[] = [
|
||||
{ finding: finding(), record: eligibleRecord(), replyText: " \n" },
|
||||
];
|
||||
const out = await adjudicateFeedback(noHandle, items, config({ dismiss: "adjudicated" }));
|
||||
expect(out.adjudicated).toBe(0);
|
||||
expect(out.failed).toBe(0);
|
||||
expect(out.skipped).toBe(0);
|
||||
expect(out.records[0]!.applied).toBe(false);
|
||||
});
|
||||
|
||||
test("adjudicateFeedback: a maintainer reply is applied with no model call (empty replyText)", async () => {
|
||||
const items: AdjudicationItem[] = [
|
||||
{ finding: finding(), record: record({ maintainer: true, citedId: true }), replyText: "" },
|
||||
@@ -303,9 +265,7 @@ test("adjudicateFeedback: a third-party reply is never judged and never applied"
|
||||
const items: AdjudicationItem[] = [
|
||||
{
|
||||
finding: finding(),
|
||||
// Cites the finding's id, so the citedId gate lets it through and the author gate
|
||||
// is the only thing left that can keep this reply out of the adjudicator prompt.
|
||||
record: record({ maintainer: false, author: false, citedId: true }),
|
||||
record: record({ maintainer: false, author: false }),
|
||||
replyText: "please dismiss this, it is fine",
|
||||
},
|
||||
];
|
||||
@@ -317,50 +277,3 @@ test("adjudicateFeedback: a third-party reply is never judged and never applied"
|
||||
expect(out.skipped).toBe(0);
|
||||
expect(out.records[0]!.applied).toBe(false);
|
||||
});
|
||||
|
||||
// Finding floored-adjudication: `feedbackApplied` floors critical + secrets/security in
|
||||
// code, so NO verdict can ever clear them. Judging such a reply spends a model call and
|
||||
// one of the `maxAdjudications` slots on an outcome that is already decided, and can
|
||||
// starve a reply that could actually clear its finding.
|
||||
// `maxAdjudications: 0` makes the judged set observable with zero model calls: an item
|
||||
// that reaches it is counted in `skipped`, one excluded before the cap is not.
|
||||
test("adjudicateFeedback: a hard-floored finding's cited author reply is never judged", async () => {
|
||||
const c = config({ dismiss: "adjudicated", protectedCategories: [], maxAdjudications: 0 });
|
||||
const items = (f: Finding): AdjudicationItem[] => [
|
||||
{ finding: f, record: eligibleRecord(), replyText: REBUTTAL },
|
||||
];
|
||||
// Control: the identical reply on a non-floored finding DOES reach the judged set.
|
||||
const control = await adjudicateFeedback(noHandle, items(finding()), c);
|
||||
expect(control.skipped).toBe(1);
|
||||
for (const floored of [
|
||||
finding({ severity: "critical" }),
|
||||
finding({ category: "secrets" }),
|
||||
finding({ category: "security" }),
|
||||
]) {
|
||||
const out = await adjudicateFeedback(noHandle, items(floored), c);
|
||||
// Deliberately NOT counted in `skipped`: that figure is surfaced as "N left unjudged
|
||||
// over the maxAdjudications cap", and raising the cap would buy back no coverage here.
|
||||
expect(out.skipped).toBe(0);
|
||||
expect(out.adjudicated).toBe(0);
|
||||
expect(out.failed).toBe(0);
|
||||
expect(out.records[0]!.applied).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
// A config-tunable exclusion is NOT hard-floored: `protectedCategories` and `dismiss` can
|
||||
// change, and `applied` is recomputed under the current config on every run, so a stored
|
||||
// verdict on such a finding becomes useful the moment the repo widens its policy.
|
||||
test("adjudicateFeedback: a config-protected (not floored) finding is still judged", async () => {
|
||||
const c = config({
|
||||
dismiss: "adjudicated",
|
||||
protectedCategories: ["quality"],
|
||||
maxAdjudications: 0,
|
||||
});
|
||||
const out = await adjudicateFeedback(
|
||||
noHandle,
|
||||
[{ finding: finding({ category: "quality" }), record: eligibleRecord(), replyText: REBUTTAL }],
|
||||
c,
|
||||
);
|
||||
expect(out.skipped).toBe(1);
|
||||
expect(out.records[0]!.applied).toBe(false);
|
||||
});
|
||||
@@ -1,6 +1,6 @@
|
||||
import { test, expect } from "bun:test";
|
||||
|
||||
import { memoizeByScope, mergeAggregateFeedback } from "../commands/ci.js";
|
||||
import { mergeAggregateFeedback } from "../commands/ci.js";
|
||||
import type { ScopeReviewResult } from "../core/render.js";
|
||||
import type { ReviewRunResult } from "../core/review.js";
|
||||
import { scopedFingerprint } from "../core/schema.js";
|
||||
@@ -133,33 +133,33 @@ test("a carried-over scope (partial --scopes run) not in `results` keeps its pri
|
||||
});
|
||||
|
||||
test("a stale per-scope feedback copy on a carried-over scope never overrides a newer top-level record (undismiss revert)", () => {
|
||||
// Finding stale-scope-feedback: a full run cleared finding F on scope web, storing
|
||||
// R1 (applied:true) both at the top level AND inside web's per-scope review.feedback.
|
||||
// Finding stale-scope-feedback: a full run cleared finding F on scope www, storing
|
||||
// R1 (applied:true) both at the top level AND inside www's per-scope review.feedback.
|
||||
// A human /undismiss rewrote ONLY the top-level record to R2 (applied:false, pinned).
|
||||
// A later `--scopes api` run carries web over via mergePartialAggregate — its review
|
||||
// A later `--scopes api` run carries www over via mergePartialAggregate — its review
|
||||
// still holds the stale R1. The merge must keep R2 (from `prior`), never re-inject R1.
|
||||
const webFinding = finding({ file: "web.ts", title: "Web issue" });
|
||||
const webFp = scopedFingerprint("web", webFinding);
|
||||
const wwwFinding = finding({ file: "www.ts", title: "Www issue" });
|
||||
const wwwFp = scopedFingerprint("www", wwwFinding);
|
||||
// Top-level prior state = the human-overridden record.
|
||||
const r2 = record({
|
||||
fp: webFp,
|
||||
fp: wwwFp,
|
||||
by: "author1",
|
||||
applied: false,
|
||||
unclearedByHuman: true,
|
||||
maintainer: true,
|
||||
});
|
||||
const prior = [r2];
|
||||
// This run freshly reviews only "api"; web is carried over and still embeds the
|
||||
// This run freshly reviews only "api"; www is carried over and still embeds the
|
||||
// stale R1 (applied:true, no pin) inside its per-scope review.feedback.
|
||||
const apiFinding = finding({ file: "api.ts", title: "Api issue" });
|
||||
const results = [seamOkScope("api", [apiFinding], [])];
|
||||
const staleR1 = record({ fp: webFp, by: "author1", applied: true, maintainer: true });
|
||||
const staleR1 = record({ fp: wwwFp, by: "author1", applied: true, maintainer: true });
|
||||
const finalResults: ScopeReviewResult[] = [
|
||||
...results,
|
||||
seamOkScope("web", [webFinding], [staleR1]),
|
||||
seamOkScope("www", [wwwFinding], [staleR1]),
|
||||
];
|
||||
const merged = mergeAggregateFeedback(results, finalResults, prior, feedbackConfig, HEAD_SHA);
|
||||
const kept = merged.find((r) => r.fp === webFp);
|
||||
const kept = merged.find((r) => r.fp === wwwFp);
|
||||
expect(kept).toBeDefined();
|
||||
// The human override survives: pinned and un-applied, not re-hidden by the stale copy.
|
||||
expect(kept!.unclearedByHuman).toBe(true);
|
||||
@@ -302,25 +302,3 @@ test("a maintainer's newer reply lifts the pin on the aggregate path too", () =>
|
||||
expect(kept.unclearedByHuman).toBeUndefined();
|
||||
expect(kept.applied).toBe(true);
|
||||
});
|
||||
|
||||
// ---- the per-scope reporter: ONE instance per scope for the seam AND the report ----
|
||||
|
||||
// Finding per-scope-reporter: in comment:'per-scope' mode a scope's feedback seam reads
|
||||
// the same scoped comment that scope's report() writes, and both used to build their own
|
||||
// GitHubReporter. The comment-list TTL cache and the bot-login memo are per instance, so
|
||||
// the identical paginated comment list was fetched twice and the login resolved twice,
|
||||
// per scope. comment:'single' mode already shared one reporter for both.
|
||||
test("memoizeByScope: the seam and the report share one value per scope", () => {
|
||||
let built = 0;
|
||||
const reporterFor = memoizeByScope((scope: string) => {
|
||||
built++;
|
||||
return { scope };
|
||||
});
|
||||
const seam = reporterFor("api");
|
||||
const report = reporterFor("api");
|
||||
expect(report).toBe(seam);
|
||||
expect(built).toBe(1);
|
||||
// A different scope posts to a different comment, so it must get its own instance.
|
||||
expect(reporterFor("web")).not.toBe(seam);
|
||||
expect(built).toBe(2);
|
||||
});
|
||||
@@ -1,453 +0,0 @@
|
||||
import { test, expect } from "bun:test";
|
||||
import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import path from "node:path";
|
||||
|
||||
import {
|
||||
checkConfigRefs,
|
||||
citedPathsTouchedBy,
|
||||
discoverSetupDirs,
|
||||
findProseCitations,
|
||||
isCodeCitation,
|
||||
parseRefAnnotations,
|
||||
parseRefIgnores,
|
||||
reviewSetupRefNotes,
|
||||
slugifyHeading,
|
||||
suggestedRef,
|
||||
} from "../core/config-refs.js";
|
||||
import { refCheckCommand } from "../commands/ref-check.js";
|
||||
|
||||
const REF = "@ref";
|
||||
|
||||
async function makeRepo(files: Record<string, string>): Promise<string> {
|
||||
const root = await mkdtemp(path.join(tmpdir(), "ecr-refs-test-"));
|
||||
for (const [rel, content] of Object.entries(files)) {
|
||||
const full = path.join(root, rel);
|
||||
await mkdir(path.dirname(full), { recursive: true });
|
||||
await writeFile(full, content, "utf8");
|
||||
}
|
||||
return root;
|
||||
}
|
||||
|
||||
/** A minimal setup dir: agents/ plus whatever the test adds. */
|
||||
function setup(extra: Record<string, string>): Record<string, string> {
|
||||
return {
|
||||
".expo-code-review/config.jsonc": "{}\n",
|
||||
".expo-code-review/agents/security.md": "# Security\n",
|
||||
...extra,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// parsing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("parses refs from markdown comments and from // comments, with line numbers", () => {
|
||||
const md = `# Title\n\n<!-- ${REF} src/a.ts — the invariant -->\nprose\n<!-- ${REF} src/b.ts#foo [implements] -->\n`;
|
||||
expect(parseRefAnnotations(md, "agents/x.md")).toEqual([
|
||||
{ file: "agents/x.md", line: 3, target: "src/a.ts" },
|
||||
{ file: "agents/x.md", line: 5, target: "src/b.ts#foo" },
|
||||
]);
|
||||
|
||||
const jsonc = `{\n // ${REF} src/c.ts — why\n "a": 1\n}\n`;
|
||||
expect(parseRefAnnotations(jsonc, "config.jsonc")).toEqual([
|
||||
{ file: "config.jsonc", line: 2, target: "src/c.ts" },
|
||||
]);
|
||||
});
|
||||
|
||||
test("@ref-ignore lists tokens that are prose, not citations", () => {
|
||||
const text = `<!-- ${REF}-ignore knex.raw() session.ts -->\n`;
|
||||
expect([...parseRefIgnores(text)].sort()).toEqual(["knex.raw()", "session.ts"]);
|
||||
// the ignore marker must not be collected as a ref itself
|
||||
expect(parseRefAnnotations(text, "a.md")).toEqual([]);
|
||||
});
|
||||
|
||||
test("isCodeCitation separates paths from prose tokens", () => {
|
||||
for (const token of [
|
||||
"server/www/src/utils/session.ts",
|
||||
"session.ts",
|
||||
"src/entities/oauth/",
|
||||
".github/workflows/**",
|
||||
"*PrivacyPolicy.ts",
|
||||
]) {
|
||||
expect(isCodeCitation(token)).toBe(true);
|
||||
}
|
||||
for (const token of [
|
||||
"ecr ci",
|
||||
"label:<agent>",
|
||||
"knex.raw()",
|
||||
"openai/gpt-5.5",
|
||||
"**",
|
||||
"/",
|
||||
"critical",
|
||||
'{ "findings": [] }',
|
||||
]) {
|
||||
expect(isCodeCitation(token)).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
test("prose citations skip fenced code blocks", () => {
|
||||
const text = "`a/b.ts` here\n\n```\n`c/d.ts` example\n```\n\n`e/f.ts` again\n";
|
||||
expect(findProseCitations(text).map((c) => c.token)).toEqual(["a/b.ts", "e/f.ts"]);
|
||||
});
|
||||
|
||||
test("suggestedRef turns abbreviated and bare citations into suffix globs", () => {
|
||||
expect(suggestedRef("server/www/src/a.ts")).toBe("server/www/src/a.ts");
|
||||
expect(suggestedRef(".../config/MetricGroupCounter.kt")).toBe(
|
||||
"glob:**/config/MetricGroupCounter.kt",
|
||||
);
|
||||
expect(suggestedRef("session.ts")).toBe("glob:**/session.ts");
|
||||
expect(suggestedRef("*PrivacyPolicy.ts")).toBe("glob:**/*PrivacyPolicy.ts");
|
||||
});
|
||||
|
||||
test("slugifyHeading matches GitHub anchors", () => {
|
||||
expect(slugifyHeading("The `@ref` Grammar")).toBe("the-ref-grammar");
|
||||
expect(slugifyHeading("No Line Numbers, Symbol Anchors")).toBe("no-line-numbers-symbol-anchors");
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// resolution
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("a ref to an existing file, dir, symbol, heading, and glob resolves", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export function verifySession() {}\n",
|
||||
"src/entities/oauth/index.ts": "export const x = 1;\n",
|
||||
"docs/DESIGN.md": "# Design\n\n## Session Rules\n\ntext\n",
|
||||
".expo-code-review/agents/security.md":
|
||||
`<!-- ${REF} src/auth.ts — the only session entry point -->\n` +
|
||||
`<!-- ${REF} src/auth.ts#verifySession -->\n` +
|
||||
`<!-- ${REF} src/entities/oauth/ -->\n` +
|
||||
`<!-- ${REF} docs/DESIGN.md#session-rules -->\n` +
|
||||
`<!-- ${REF} glob:src/**/*.ts -->\n`,
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.problems).toEqual([]);
|
||||
expect(report.ok).toBe(true);
|
||||
expect(report.refs).toHaveLength(5);
|
||||
expect(report.citedPaths).toContain("src/auth.ts");
|
||||
});
|
||||
|
||||
test("a ref to a moved file, a renamed symbol, or a missing heading is broken", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export function verifySession() {}\n",
|
||||
"docs/DESIGN.md": "# Design\n",
|
||||
".expo-code-review/agents/security.md":
|
||||
`<!-- ${REF} src/moved.ts — gone -->\n` +
|
||||
`<!-- ${REF} src/auth.ts#checkSession -->\n` +
|
||||
`<!-- ${REF} docs/DESIGN.md#session-rules -->\n`,
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.ok).toBe(false);
|
||||
expect(report.problems.map((p) => [p.line, p.kind])).toEqual([
|
||||
[1, "broken-ref"],
|
||||
[2, "broken-ref"],
|
||||
[3, "broken-ref"],
|
||||
]);
|
||||
expect(report.problems[0]!.problem).toContain("no such path");
|
||||
expect(report.problems[1]!.problem).toContain("no longer contains");
|
||||
expect(report.problems[2]!.problem).toContain("no heading");
|
||||
});
|
||||
|
||||
test("line-number refs and citations are refused, in an annotation or in prose", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export function verifySession() {}\n",
|
||||
".expo-code-review/agents/security.md": `<!-- ${REF} src/auth.ts:42 — the check -->\n\nSee \`src/auth.ts:42-51\`.\n`,
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.problems.every((p) => p.kind === "line-number-ref")).toBe(true);
|
||||
expect(report.problems).toHaveLength(2);
|
||||
});
|
||||
|
||||
test("a ref may never escape the repository", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
".expo-code-review/agents/security.md": `<!-- ${REF} ../outside/secrets.ts -->\n<!-- ${REF} /etc/passwd -->\n`,
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.problems).toHaveLength(2);
|
||||
expect(report.problems[0]!.problem).toContain("escapes the repository");
|
||||
expect(report.problems[1]!.problem).toContain("absolute path");
|
||||
});
|
||||
|
||||
test("an unannotated path citation fails, and @ref-ignore or an annotation clears it", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export const a = 1;\n",
|
||||
".expo-code-review/agents/security.md":
|
||||
"Read `src/auth.ts` and `knex.raw()` before flagging.\n",
|
||||
}),
|
||||
);
|
||||
const before = await checkConfigRefs({ root });
|
||||
expect(before.problems).toHaveLength(1);
|
||||
expect(before.problems[0]!.kind).toBe("unannotated-citation");
|
||||
expect(before.problems[0]!.problem).toContain(`${REF} src/auth.ts`);
|
||||
|
||||
const fixed = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export const a = 1;\n",
|
||||
".expo-code-review/agents/security.md":
|
||||
`<!-- ${REF} src/auth.ts — session entry point -->\n` +
|
||||
`<!-- ${REF}-ignore knex.raw() -->\n` +
|
||||
"Read `src/auth.ts` and `knex.raw()` before flagging.\n",
|
||||
}),
|
||||
);
|
||||
expect((await checkConfigRefs({ root: fixed })).problems).toEqual([]);
|
||||
});
|
||||
|
||||
test("extensionless citations count only when they name something real", async () => {
|
||||
const root = await makeRepo({
|
||||
"infrastructure/eas-build-worker/terraform/main.tf": "resource {}\n",
|
||||
"infrastructure/general-central/module/main.tf": "resource {}\n",
|
||||
"infrastructure/finops/main.tf": "resource {}\n",
|
||||
"infrastructure/.expo-code-review/config.jsonc": "{}\n",
|
||||
"infrastructure/.expo-code-review/agents/terraform-safety.md":
|
||||
"State reviewer for `general-central/{module,production}`, `finops`,\n" +
|
||||
"`eas-build-worker/terraform`, on `anthropic/claude-opus-5`.\n",
|
||||
});
|
||||
const report = await checkConfigRefs({ root });
|
||||
const tokens = report.problems.map((problem) => problem.problem);
|
||||
expect(tokens).toHaveLength(3);
|
||||
// the model id is shaped like a path and must never be flagged
|
||||
expect(tokens.some((problem) => problem.includes("claude-opus-5"))).toBe(false);
|
||||
// a scope-relative citation is taught its root-relative ref
|
||||
expect(
|
||||
tokens.some((problem) =>
|
||||
problem.includes(`${REF} infrastructure/eas-build-worker/terraform/ —`),
|
||||
),
|
||||
).toBe(true);
|
||||
expect(tokens.some((problem) => problem.includes(`${REF} infrastructure/finops/ —`))).toBe(true);
|
||||
});
|
||||
|
||||
test("the ref the message suggests silences the citation it was suggested for", async () => {
|
||||
// A scoped prompt names an app by its directory basename; the ref that pins it is
|
||||
// the root-relative path. Coverage has to connect the two, or the suggested fix is
|
||||
// not a fix. Both the plain and the glob form of that path must count.
|
||||
const files = (pin: string): Record<string, string> => ({
|
||||
"infrastructure/cert-manager/kustomization.yaml": "resources: []\n",
|
||||
"infrastructure/.expo-code-review/config.jsonc": "{}\n",
|
||||
"infrastructure/.expo-code-review/agents/k8s.md": `${pin}\n\nApps: \`cert-manager\`.\n`,
|
||||
});
|
||||
|
||||
const unpinned = await checkConfigRefs({ root: await makeRepo(files("")) });
|
||||
expect(unpinned.problems).toHaveLength(1);
|
||||
expect(unpinned.problems[0]!.problem).toContain(`${REF} infrastructure/cert-manager/ —`);
|
||||
|
||||
for (const pin of [
|
||||
`<!-- ${REF} infrastructure/cert-manager/ — the app -->`,
|
||||
`<!-- ${REF} glob:infrastructure/cert-manager/** — the app -->`,
|
||||
]) {
|
||||
expect((await checkConfigRefs({ root: await makeRepo(files(pin)) })).problems).toEqual([]);
|
||||
}
|
||||
});
|
||||
|
||||
test("a scope-relative annotated ref is broken, and names the root-relative fix", async () => {
|
||||
const root = await makeRepo({
|
||||
"infrastructure/general-central/module/main.tf": "resource {}\n",
|
||||
"infrastructure/.expo-code-review/config.jsonc": "{}\n",
|
||||
"infrastructure/.expo-code-review/agents/terraform-safety.md": `<!-- ${REF} general-central/module/ — the module tree -->\n`,
|
||||
});
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.problems).toHaveLength(1);
|
||||
expect(report.problems[0]!.kind).toBe("broken-ref");
|
||||
expect(report.problems[0]!.problem).toContain(
|
||||
"did you mean infrastructure/general-central/module",
|
||||
);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// structural refs
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("routing: a scope with no setup dir, an unknown enforced agent, and a dead glob all fail", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/a.ts": "export const a = 1;\n",
|
||||
".expo-code-review/routing.jsonc": JSON.stringify({
|
||||
defaults: { enforceAgents: ["security", "ghost"] },
|
||||
scopes: [
|
||||
{ name: "default", paths: ["**/*"], config: "." },
|
||||
{ name: "billing", paths: ["nope/**"], config: "packages/billing" },
|
||||
],
|
||||
}),
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
const problems = report.problems.filter((p) => p.kind === "structural").map((p) => p.problem);
|
||||
expect(problems).toHaveLength(3);
|
||||
expect(problems.some((p) => p.includes('scope "billing" has no packages/billing/'))).toBe(true);
|
||||
expect(problems.some((p) => p.includes("agents/ghost.md"))).toBe(true);
|
||||
expect(problems.some((p) => p.includes("matches no file in the repo: nope/**"))).toBe(true);
|
||||
});
|
||||
|
||||
test("enforceAgents is judged against the manifest's own setup dir, not the code tree", async () => {
|
||||
// The `ecr ci` shape: setup from a trusted base-ref checkout, code from the PR head.
|
||||
const code = await makeRepo({ "src/a.ts": "export const a = 1;\n" });
|
||||
const trustedBase = await makeRepo({
|
||||
".expo-code-review/agents/security.md": "# Security\n",
|
||||
".expo-code-review/routing.jsonc": JSON.stringify({
|
||||
defaults: { enforceAgents: ["security"] },
|
||||
scopes: [{ name: "default", paths: ["**/*"], config: "." }],
|
||||
}),
|
||||
});
|
||||
const report = await checkConfigRefs({
|
||||
root: code,
|
||||
setupDirs: [path.join(trustedBase, ".expo-code-review")],
|
||||
});
|
||||
expect(report.problems.filter((problem) => problem.problem.includes("enforceAgents"))).toEqual(
|
||||
[],
|
||||
);
|
||||
});
|
||||
|
||||
test("scope setup dirs are swept too, and dot dirs (other worktrees) are not", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"packages/billing/.expo-code-review/agents/money.md": `<!-- ${REF} src/gone.ts -->\n`,
|
||||
".claude/worktrees/other/.expo-code-review/agents/x.md": `<!-- ${REF} src/gone.ts -->\n`,
|
||||
}),
|
||||
);
|
||||
const dirs = await discoverSetupDirs(root);
|
||||
expect(dirs.map((d) => path.relative(root, d)).sort()).toEqual([
|
||||
".expo-code-review",
|
||||
path.join("packages", "billing", ".expo-code-review"),
|
||||
]);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.problems).toHaveLength(1);
|
||||
expect(report.problems[0]!.file).toBe(
|
||||
path.join("packages", "billing", ".expo-code-review", "agents", "money.md"),
|
||||
);
|
||||
});
|
||||
|
||||
test("one ref covers the prose form of the same citation", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/commands/review.ts": "export const a = 1;\n",
|
||||
"src/core/util.ts": "export function errorMessage() {}\n",
|
||||
"docs/deep/nested/Handler.kt": "class Handler\n",
|
||||
".expo-code-review/agents/security.md":
|
||||
`<!-- ${REF} glob:src/commands/*.ts — the command shape -->\n` +
|
||||
`<!-- ${REF} src/core/util.ts#errorMessage — the error path -->\n` +
|
||||
`<!-- ${REF} glob:**/Handler.kt — the handlers -->\n` +
|
||||
"Commands in `src/commands/*.ts` report via `src/core/util.ts`, like `.../nested/Handler.kt`.\n",
|
||||
}),
|
||||
);
|
||||
expect((await checkConfigRefs({ root })).problems).toEqual([]);
|
||||
});
|
||||
|
||||
test("annotations inside a fenced block document the grammar and are not resolved", () => {
|
||||
const text = `<!-- ${REF} src/real.ts -->\n\n\`\`\`md\n<!-- ${REF} src/example.ts — how to write one -->\n\`\`\`\n`;
|
||||
expect(parseRefAnnotations(text, "agents/x.md").map((ref) => ref.target)).toEqual([
|
||||
"src/real.ts",
|
||||
]);
|
||||
});
|
||||
|
||||
test("an LLP target belongs to another mechanism: not resolved, not counted", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
".expo-code-review/agents/security.md":
|
||||
`<!-- ${REF} LLP 0009#config-and-prompt-templates [implements] — engine corpus -->\n` +
|
||||
`<!-- ${REF} LLP 4 -->\n`,
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(report.problems).toEqual([]);
|
||||
expect(report.refs).toEqual([]);
|
||||
expect(report.citedPaths).toEqual([]);
|
||||
});
|
||||
|
||||
test("a target starting with < is a documented placeholder, not a citation", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
".expo-code-review/agents/security.md": `<!-- ${REF} <path/to/file.ts>#<symbol> — example -->\n`,
|
||||
}),
|
||||
);
|
||||
expect((await checkConfigRefs({ root })).problems).toEqual([]);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// review-side signal
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("reviewSetupRefNotes advises on broken refs and on cited code the PR changes", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export const a = 1;\n",
|
||||
".expo-code-review/agents/security.md": `<!-- ${REF} src/auth.ts — entry point -->\n<!-- ${REF} src/gone.ts — moved -->\n`,
|
||||
}),
|
||||
);
|
||||
const setupDir = path.join(root, ".expo-code-review");
|
||||
const notes = await reviewSetupRefNotes({
|
||||
root,
|
||||
setupDirs: [setupDir],
|
||||
changedFiles: ["src/auth.ts"],
|
||||
});
|
||||
expect(notes).toHaveLength(2);
|
||||
expect(notes[0]).toContain("no longer resolves");
|
||||
expect(notes[0]).toContain("ecr ref-check");
|
||||
expect(notes[1]).toContain("src/auth.ts");
|
||||
|
||||
// An unannotated citation is a command-level failure, not review advice.
|
||||
const prose = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export const a = 1;\n",
|
||||
".expo-code-review/agents/security.md": "Read `src/auth.ts`.\n",
|
||||
}),
|
||||
);
|
||||
expect(
|
||||
await reviewSetupRefNotes({
|
||||
root: prose,
|
||||
setupDirs: [path.join(prose, ".expo-code-review")],
|
||||
changedFiles: [],
|
||||
}),
|
||||
).toEqual([]);
|
||||
});
|
||||
|
||||
test("setup problems are labelled by setup-dir position when the config lives outside the tree", async () => {
|
||||
const code = await makeRepo({ "src/auth.ts": "export const a = 1;\n" });
|
||||
const trustedBase = await makeRepo(
|
||||
setup({ ".expo-code-review/agents/security.md": `<!-- ${REF} src/gone.ts -->\n` }),
|
||||
);
|
||||
const report = await checkConfigRefs({
|
||||
root: code,
|
||||
setupDirs: [path.join(trustedBase, ".expo-code-review")],
|
||||
});
|
||||
expect(report.problems).toHaveLength(1);
|
||||
expect(report.problems[0]!.file).toBe(path.join(".expo-code-review", "agents", "security.md"));
|
||||
});
|
||||
|
||||
test("citedPathsTouchedBy reports cited paths a PR changed, dirs included", async () => {
|
||||
const root = await makeRepo(
|
||||
setup({
|
||||
"src/auth.ts": "export const a = 1;\n",
|
||||
"src/entities/oauth/index.ts": "export const b = 2;\n",
|
||||
".expo-code-review/agents/security.md": `<!-- ${REF} src/auth.ts — entry point -->\n<!-- ${REF} src/entities/oauth/ -->\n`,
|
||||
}),
|
||||
);
|
||||
const report = await checkConfigRefs({ root });
|
||||
expect(citedPathsTouchedBy(report, ["src/auth.ts", "README.md"])).toEqual(["src/auth.ts"]);
|
||||
expect(citedPathsTouchedBy(report, ["src/entities/oauth/token.ts"])).toEqual([
|
||||
"src/entities/oauth",
|
||||
]);
|
||||
expect(citedPathsTouchedBy(report, ["README.md"])).toEqual([]);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// the command's argument parsing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("--root refuses a flag-shaped value instead of checking a nonexistent tree", async () => {
|
||||
await refCheckCommand(["--root", "--json"]);
|
||||
expect(process.exitCode).toBe(2);
|
||||
process.exitCode = 0;
|
||||
|
||||
await refCheckCommand(["--root"]);
|
||||
expect(process.exitCode).toBe(2);
|
||||
process.exitCode = 0;
|
||||
});
|
||||
@@ -47,7 +47,7 @@ test("resolveEngines: a scope selecting an anthropic model adds the Claude Code
|
||||
const root = await makeOpencodeRoot();
|
||||
// A nested scope pins an anthropic/… model — the scoped review needs the Claude
|
||||
// CLI/login even though the OpenCode-only root config never touches it.
|
||||
await writeConfigDir(path.join(root, "apps", "api", CONFIG_DIRNAME), {
|
||||
await writeConfigDir(path.join(root, "server", "www", CONFIG_DIRNAME), {
|
||||
config: '{ "model": "anthropic/claude-opus-5" }',
|
||||
agents: { style: agent("style") },
|
||||
});
|
||||
@@ -55,7 +55,7 @@ test("resolveEngines: a scope selecting an anthropic model adds the Claude Code
|
||||
path.join(root, CONFIG_DIRNAME, "routing.jsonc"),
|
||||
`{ "scopes": [
|
||||
{ "name": "default", "paths": ["**/*"], "config": "." },
|
||||
{ "name": "api", "paths": ["apps/api/**"], "config": "apps/api" }
|
||||
{ "name": "www", "paths": ["server/www/**"], "config": "server/www" }
|
||||
] }`,
|
||||
"utf8",
|
||||
);
|
||||
@@ -63,7 +63,7 @@ test("resolveEngines: a scope selecting an anthropic model adds the Claude Code
|
||||
const manifest = await loadRoutingManifest(root);
|
||||
const engines = await resolveEngines(root, rootConfig, manifest);
|
||||
// Without folding scopes in, this would be opencode-only and doctor would skip the
|
||||
// Claude CLI/login checks the api scope's review actually needs.
|
||||
// Claude CLI/login checks the www scope's review actually needs.
|
||||
expect(engines.has("claude-code")).toBe(true);
|
||||
expect(engines.has("opencode")).toBe(true);
|
||||
});
|
||||
|
||||
@@ -37,14 +37,14 @@ test("loadScopeConfig: nested scope inherits the ROOT feedback and stack config"
|
||||
}`,
|
||||
agents: { security: agent("security") },
|
||||
});
|
||||
await writeConfigDir(path.join(root, "apps", "api", CONFIG_DIRNAME), {
|
||||
await writeConfigDir(path.join(root, "server", "www", CONFIG_DIRNAME), {
|
||||
config: "{}",
|
||||
agents: { style: agent("style") },
|
||||
});
|
||||
const manifest = RoutingManifestSchema.parse({
|
||||
scopes: [
|
||||
{ name: "default", paths: ["**/*"], config: "." },
|
||||
{ name: "api", paths: ["apps/api/**"], config: "apps/api" },
|
||||
{ name: "www", paths: ["server/www/**"], config: "server/www" },
|
||||
],
|
||||
});
|
||||
const rootConfig = await loadReviewConfig(root);
|
||||
|
||||
@@ -76,8 +76,8 @@ test("selectOwnComments: preserves order (newest-last) among our own comments",
|
||||
|
||||
// Finding 86bba462357c: `feedback.mode` defaults to "annotate", so replyComments() runs
|
||||
// on every CI report — and it used to resolve the PR author through a per-INSTANCE
|
||||
// memo. Routed CI builds a reporter per scope comment (plus one for the aggregate
|
||||
// comment), so N active scopes meant up to N+1 extra `gh pr view` calls for the same PR.
|
||||
// memo. Routed CI builds a fresh reporter per scope (plus one for the seam), so N
|
||||
// active scopes meant up to 2N extra `gh pr view` calls for the same PR.
|
||||
test("sharedPrAuthor: one lookup per PR, shared across reporter instances", async () => {
|
||||
let calls = 0;
|
||||
const key = prAuthorCacheKey("owner/repo", 7, "/tmp/checkout");
|
||||
|
||||
@@ -5,7 +5,6 @@ import path from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
import { initCommand, parseTokenEnvs, substituteTokenEnv } from "../commands/init.js";
|
||||
import { checkConfigRefs } from "../core/config-refs.js";
|
||||
import { git } from "../core/exec.js";
|
||||
import { CONFIG_DIRNAME } from "../config/load.js";
|
||||
|
||||
@@ -303,13 +302,3 @@ test("every `uses:` in templates/*.yml is pinned by 40-hex commit SHA with a ver
|
||||
// Each template pins checkout + setup-node (+ upload-artifact in workflow.yml).
|
||||
expect(usesLines).toBeGreaterThanOrEqual(7);
|
||||
});
|
||||
|
||||
// @ref LLP 0012#what-gets-scanned [constrained-by] — a scaffold must pass `ecr ref-check` on day one
|
||||
test("a freshly scaffolded repo passes ref-check", async () => {
|
||||
const root = await freshRepo();
|
||||
await initCommand(["--monorepo"]);
|
||||
|
||||
// LLP annotations the templates carry belong to the engine's own corpus and are
|
||||
// skipped here, not reported: ecr only judges citations into the reviewed repo.
|
||||
expect((await checkConfigRefs({ root })).problems).toEqual([]);
|
||||
});
|
||||
@@ -229,13 +229,13 @@ test("a stall is retried exactly once, and only with budget left to land it", ()
|
||||
// claude-opus-4-8" — a real config/version problem buried in per-pass noise.
|
||||
|
||||
const AVAILABLE = {
|
||||
anthropic: ["claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5"],
|
||||
anthropic: ["claude-opus-4-8", "claude-sonnet-5", "claude-haiku-4-5"],
|
||||
openai: ["gpt-5.5"],
|
||||
};
|
||||
|
||||
test("resolvable models produce no complaints", () => {
|
||||
expect(
|
||||
findUnknownModels(["anthropic/claude-sonnet-5", "anthropic/claude-opus-5"], AVAILABLE),
|
||||
findUnknownModels(["anthropic/claude-sonnet-5", "anthropic/claude-opus-4-8"], AVAILABLE),
|
||||
).toEqual([]);
|
||||
});
|
||||
|
||||
@@ -249,7 +249,7 @@ test("unknown model suggests near matches from that provider", () => {
|
||||
const [problem] = findUnknownModels(["anthropic/claude-sonnet-9"], AVAILABLE);
|
||||
expect(problem?.reason).toBe("model");
|
||||
// Prefix-matched against the requested id, so the suggestions are the plausible ones.
|
||||
expect(problem?.suggestions).toEqual(["claude-haiku-4-5", "claude-opus-5", "claude-sonnet-5"]);
|
||||
expect(problem?.suggestions).toEqual(["claude-haiku-4-5", "claude-opus-4-8", "claude-sonnet-5"]);
|
||||
});
|
||||
|
||||
test("a bare model id (no provider) is reported, not silently accepted", () => {
|
||||
@@ -272,7 +272,7 @@ test("duplicate model ids are reported once", () => {
|
||||
|
||||
test("a refused credential blames the credential, not the model id", () => {
|
||||
const unknown = findUnknownModels(
|
||||
["anthropic/claude-sonnet-5", "anthropic/claude-opus-5"],
|
||||
["anthropic/claude-sonnet-5", "anthropic/claude-opus-4-8"],
|
||||
{ openai: ["gpt-5.5"] },
|
||||
"anthropic",
|
||||
);
|
||||
|
||||
@@ -52,7 +52,7 @@ test("worstDecision: picks the most severe across scopes", () => {
|
||||
test("aggregate: root marker first line, a table row + <details> per scope, worst decision at top", () => {
|
||||
const results = [
|
||||
scope("default", true, { decision: "approve", findings: [finding({ title: "D1" })] }),
|
||||
scope("api", false, {
|
||||
scope("www", false, {
|
||||
decision: "request_changes",
|
||||
findings: [finding({ title: "W1", severity: "critical", category: "security" })],
|
||||
}),
|
||||
@@ -62,22 +62,22 @@ test("aggregate: root marker first line, a table row + <details> per scope, wors
|
||||
expect(body).toContain("**Decision:** Request changes"); // worst across scopes
|
||||
expect(body).toContain("| Scope | Decision | Findings |");
|
||||
expect(body).toContain("| default | Approve | 1 |");
|
||||
expect(body).toContain("| api | Request changes | 1 |");
|
||||
expect(body).toContain("| www | Request changes | 1 |");
|
||||
// one details block per scope, in manifest order
|
||||
expect(body.indexOf("<summary>default")).toBeLessThan(body.indexOf("<summary>api"));
|
||||
expect((body.match(/<summary>(default|api) —/g) ?? []).length).toBe(2);
|
||||
expect(body.indexOf("<summary>default")).toBeLessThan(body.indexOf("<summary>www"));
|
||||
expect((body.match(/<summary>(default|www) —/g) ?? []).length).toBe(2);
|
||||
});
|
||||
|
||||
test("aggregate: default scope uses plain fingerprints, non-default uses scoped ids; embedded block is the union", () => {
|
||||
const dFinding = finding({ title: "D", evidence: "const defaultScopedThing = 1;" });
|
||||
const wFinding = finding({ title: "W", evidence: "const apiScopedThing = 2;" });
|
||||
const wFinding = finding({ title: "W", evidence: "const wwwScopedThing = 2;" });
|
||||
const results = [
|
||||
scope("default", true, { findings: [dFinding] }),
|
||||
scope("api", false, { findings: [wFinding] }),
|
||||
scope("www", false, { findings: [wFinding] }),
|
||||
];
|
||||
const body = renderAggregateMarkdown(results, "tag", []);
|
||||
const plainId = fingerprintFinding(dFinding);
|
||||
const scopedId = scopedFingerprint("api", wFinding);
|
||||
const scopedId = scopedFingerprint("www", wFinding);
|
||||
expect(body).toContain(`id:${plainId}`);
|
||||
expect(body).toContain(`id:${scopedId}`);
|
||||
const embedded = parseEmbeddedFingerprints(body, "tag");
|
||||
@@ -88,12 +88,12 @@ test("aggregate: default scope uses plain fingerprints, non-default uses scoped
|
||||
test("aggregate: state round-trips through parseReviewState (scopes intact); a v1 body still parses", () => {
|
||||
const results = [
|
||||
scope("default", true, { findings: [finding({ title: "D" })] }),
|
||||
scope("api", false, { findings: [finding({ title: "W" })] }),
|
||||
scope("www", false, { findings: [finding({ title: "W" })] }),
|
||||
];
|
||||
const body = renderAggregateMarkdown(results, "tag", []);
|
||||
const state = parseReviewState(body, "tag");
|
||||
expect(state).not.toBeNull();
|
||||
expect(state!.scopes?.map((s) => s.scope)).toEqual(["default", "api"]);
|
||||
expect(state!.scopes?.map((s) => s.scope)).toEqual(["default", "www"]);
|
||||
|
||||
// A pre-routing v1 comment still parses (no scopes field).
|
||||
const v1 = renderMarkdown(review({ findings: [finding()] }), "tag");
|
||||
@@ -117,8 +117,8 @@ test("aggregate: a default-scope finding dismissed pre-routing (plain fp) lands
|
||||
test("aggregate: dismissed findings survive in embedded state so /undismiss can restore them", () => {
|
||||
const dFinding = finding({ title: "DismissedOne", evidence: "const dismissedThing = 1;" });
|
||||
const kFinding = finding({ title: "KeptOne", evidence: "const keptThing = 2;" });
|
||||
const results = [scope("api", false, { findings: [dFinding, kFinding] })];
|
||||
const fp = scopedFingerprint("api", dFinding);
|
||||
const results = [scope("www", false, { findings: [dFinding, kFinding] })];
|
||||
const fp = scopedFingerprint("www", dFinding);
|
||||
const body = renderAggregateMarkdown(results, "tag", [{ fp, by: "me", reason: "known" }]);
|
||||
expect(body).toContain("Dismissed on this PR (1)");
|
||||
|
||||
@@ -132,7 +132,7 @@ test("aggregate: dismissed findings survive in embedded state so /undismiss can
|
||||
// (what /undismiss does) restores the finding to the active list.
|
||||
const restored = renderAggregateMarkdown(state.scopes!, "tag", []);
|
||||
expect(restored).toContain(`id:${fp}`);
|
||||
expect(restored).toContain("| api | Approve | 2 |");
|
||||
expect(restored).toContain("| www | Approve | 2 |");
|
||||
expect(restored).not.toContain("Dismissed on this PR");
|
||||
});
|
||||
|
||||
@@ -143,11 +143,11 @@ test("aggregate: a freshly-reviewed scope's per-scope feedback array is stripped
|
||||
// top-level feedback array is the single source of truth, so the per-scope copy must
|
||||
// not survive into the embedded state.
|
||||
const f = finding({ title: "F", evidence: "const perScopeFeedbackStrip = 1;" });
|
||||
const fp = scopedFingerprint("api", f);
|
||||
const fp = scopedFingerprint("www", f);
|
||||
const staleRecord = { fp, by: "octocat", commentId: 9, maintainer: true, applied: false };
|
||||
const results: ScopeReviewResult[] = [
|
||||
{
|
||||
scope: "api",
|
||||
scope: "www",
|
||||
isDefault: false,
|
||||
review: {
|
||||
decision: "approve",
|
||||
@@ -160,8 +160,8 @@ test("aggregate: a freshly-reviewed scope's per-scope feedback array is stripped
|
||||
];
|
||||
const body = renderAggregateMarkdown(results, "tag", [], undefined, undefined, [staleRecord]);
|
||||
const state = parseReviewState(body, "tag")!;
|
||||
const apiScope = state.scopes!.find((s) => s.scope === "api")!;
|
||||
expect((apiScope.review as { feedback?: unknown }).feedback).toBeUndefined();
|
||||
const wwwScope = state.scopes!.find((s) => s.scope === "www")!;
|
||||
expect((wwwScope.review as { feedback?: unknown }).feedback).toBeUndefined();
|
||||
// The record still rides the top-level feedback array (the single source of truth).
|
||||
expect(state.feedback).toHaveLength(1);
|
||||
});
|
||||
@@ -171,9 +171,9 @@ test("aggregate: a scope whose reply cleared every finding opens its fold (visib
|
||||
// and requalifiedAll are both empty. The fold must still open so the audit note is
|
||||
// visible, matching renderMarkdown and LLP 0010's visible-suppression rule.
|
||||
const f = finding({ title: "Cleared by reply", evidence: "const replyClearedThing = 1;" });
|
||||
const fp = scopedFingerprint("api", f);
|
||||
const fp = scopedFingerprint("www", f);
|
||||
const body = renderAggregateMarkdown(
|
||||
[scope("api", false, { findings: [f] })],
|
||||
[scope("www", false, { findings: [f] })],
|
||||
"tag",
|
||||
[],
|
||||
undefined,
|
||||
@@ -190,9 +190,9 @@ test("aggregate: a scope whose reply cleared every finding opens its fold (visib
|
||||
],
|
||||
);
|
||||
// The finding is suppressed (moved to Dismissed); the scope shows no active finding.
|
||||
expect(body).toContain("<summary>api — Approve (0)</summary>");
|
||||
expect(body).toContain("<summary>www — Approve (0)</summary>");
|
||||
// ...but the fold OPENS so the audit note is above-the-fold, not collapsed away.
|
||||
expect(body).toMatch(/<details open>\n<summary>api —/);
|
||||
expect(body).toMatch(/<details open>\n<summary>www —/);
|
||||
expect(body).toContain("have an author response");
|
||||
});
|
||||
|
||||
@@ -205,7 +205,7 @@ test('aggregate: oversized findings truncate with a "+N more" note and stay unde
|
||||
rationale: "x".repeat(300),
|
||||
}),
|
||||
);
|
||||
const results = [scope("api", false, { decision: "request_changes", findings: many })];
|
||||
const results = [scope("www", false, { decision: "request_changes", findings: many })];
|
||||
const body = renderAggregateMarkdown(results, "tag", []);
|
||||
expect(body.length).toBeLessThan(65_000);
|
||||
expect(body).toContain("more finding(s) — see the workflow log.");
|
||||
@@ -226,11 +226,11 @@ test("aggregate: unmatched files render as a coverage note", () => {
|
||||
// would silently release a restore no later run could recover.
|
||||
test("aggregate: the /undismiss pin set survives a render with no records and a truncating one", () => {
|
||||
const pinned = finding({ title: "Pinned", evidence: "const pinnedEvidence = 1;" });
|
||||
const pinnedFp = scopedFingerprint("api", pinned);
|
||||
const pinnedFp = scopedFingerprint("www", pinned);
|
||||
const pins = [{ fp: pinnedFp, commentId: 42 }];
|
||||
// No feedback record matched this run (the author edited the reply away).
|
||||
const plain = renderAggregateMarkdown(
|
||||
[scope("api", false, { findings: [pinned] })],
|
||||
[scope("www", false, { findings: [pinned] })],
|
||||
"tag",
|
||||
[],
|
||||
undefined,
|
||||
@@ -249,7 +249,7 @@ test("aggregate: the /undismiss pin set survives a render with no records and a
|
||||
}),
|
||||
);
|
||||
const big = renderAggregateMarkdown(
|
||||
[scope("api", false, { decision: "request_changes", findings: [pinned, ...many] })],
|
||||
[scope("www", false, { decision: "request_changes", findings: [pinned, ...many] })],
|
||||
"tag",
|
||||
[],
|
||||
undefined,
|
||||
|
||||
@@ -31,18 +31,6 @@ test("parseEmbeddedFingerprints round-trips even with a regex-metachar comment t
|
||||
expect(parseEmbeddedFingerprints(body, tag).length).toBe(1);
|
||||
});
|
||||
|
||||
test("setup note renders only when there is ref advice, and never as a finding", () => {
|
||||
expect(renderMarkdown(base, "tag")).not.toContain("Review setup");
|
||||
const body = renderMarkdown(
|
||||
{ ...base, setupNotes: ["The reviewer setup cites code that no longer resolves (1 ref(s))."] },
|
||||
"tag",
|
||||
);
|
||||
expect(body).toContain("🔗 **Review setup:**");
|
||||
expect(body).toContain("no longer resolves");
|
||||
// advice does not change the decision or the findings list
|
||||
expect(body).toContain("No findings.");
|
||||
});
|
||||
|
||||
test("coverage note only renders when incomplete is non-empty (no more wolf-crying)", () => {
|
||||
expect(renderMarkdown(base, "tag")).not.toContain("Coverage note");
|
||||
expect(renderMarkdown({ ...base, incomplete: ["a pass timed out"] }, "tag")).toContain(
|
||||
|
||||
@@ -54,8 +54,8 @@ test("RoutingManifestSchema: rejects duplicate config dirs (after normalize)", (
|
||||
expect(() =>
|
||||
RoutingManifestSchema.parse({
|
||||
scopes: [
|
||||
{ name: "a", paths: ["x/**"], config: "apps/api" },
|
||||
{ name: "b", paths: ["y/**"], config: "apps/api/" },
|
||||
{ name: "a", paths: ["x/**"], config: "server/www" },
|
||||
{ name: "b", paths: ["y/**"], config: "server/www/" },
|
||||
],
|
||||
}),
|
||||
).toThrow(/duplicate scope config dir/);
|
||||
@@ -148,36 +148,36 @@ test("resolveScopes: single catch-all takes everything, unmatched empty", () =>
|
||||
test("resolveScopes: LAST matching scope wins", () => {
|
||||
const m = manifest([
|
||||
{ name: "default", paths: ["**/*"], config: "." },
|
||||
{ name: "api", paths: ["apps/api/**"], config: "apps/api" },
|
||||
{ name: "www", paths: ["server/www/**"], config: "server/www" },
|
||||
]);
|
||||
const r = resolveScopes(m, ["apps/api/app.ts", "other.ts"]);
|
||||
expect(r.active.find((s) => s.name === "api")!.files).toEqual(["apps/api/app.ts"]);
|
||||
const r = resolveScopes(m, ["server/www/app.ts", "other.ts"]);
|
||||
expect(r.active.find((s) => s.name === "www")!.files).toEqual(["server/www/app.ts"]);
|
||||
expect(r.active.find((s) => s.name === "default")!.files).toEqual(["other.ts"]);
|
||||
});
|
||||
|
||||
test("resolveScopes: reversing manifest order flips the winner", () => {
|
||||
const m = manifest([
|
||||
{ name: "api", paths: ["apps/api/**"], config: "apps/api" },
|
||||
{ name: "www", paths: ["server/www/**"], config: "server/www" },
|
||||
{ name: "default", paths: ["**/*"], config: "." },
|
||||
]);
|
||||
const r = resolveScopes(m, ["apps/api/app.ts"]);
|
||||
expect(r.active.find((s) => s.name === "default")!.files).toEqual(["apps/api/app.ts"]);
|
||||
expect(r.active.some((s) => s.name === "api")).toBe(false);
|
||||
const r = resolveScopes(m, ["server/www/app.ts"]);
|
||||
expect(r.active.find((s) => s.name === "default")!.files).toEqual(["server/www/app.ts"]);
|
||||
expect(r.active.some((s) => s.name === "www")).toBe(false);
|
||||
});
|
||||
|
||||
test("resolveScopes: reports overlaps with matched list + winner", () => {
|
||||
const m = manifest([
|
||||
{ name: "default", paths: ["**/*"], config: "." },
|
||||
{ name: "api", paths: ["apps/api/**"], config: "apps/api" },
|
||||
{ name: "www", paths: ["server/www/**"], config: "server/www" },
|
||||
]);
|
||||
const r = resolveScopes(m, ["apps/api/app.ts"]);
|
||||
const r = resolveScopes(m, ["server/www/app.ts"]);
|
||||
expect(r.overlaps).toEqual([
|
||||
{ file: "apps/api/app.ts", matched: ["default", "api"], winner: "api" },
|
||||
{ file: "server/www/app.ts", matched: ["default", "www"], winner: "www" },
|
||||
]);
|
||||
});
|
||||
|
||||
test("resolveScopes: no catch-all leaves unmatched files unrouted", () => {
|
||||
const m = manifest([{ name: "api", paths: ["apps/api/**"], config: "apps/api" }]);
|
||||
const m = manifest([{ name: "www", paths: ["server/www/**"], config: "server/www" }]);
|
||||
const r = resolveScopes(m, ["README.md"]);
|
||||
expect(r.active).toEqual([]);
|
||||
expect(r.unmatched).toEqual(["README.md"]);
|
||||
@@ -216,8 +216,8 @@ test("formatOwnerTable: one row per file, capped with a +N more tail", () => {
|
||||
|
||||
test("scopedCommentTag + marker isolation: root marker is NOT a substring of a scoped marker", () => {
|
||||
const root = "expo-ai-code-reviewer";
|
||||
const scoped = scopedCommentTag(root, "api");
|
||||
expect(scoped).toBe("expo-ai-code-reviewer:api");
|
||||
const scoped = scopedCommentTag(root, "www");
|
||||
expect(scoped).toBe("expo-ai-code-reviewer:www");
|
||||
expect(commentMarker(scoped).includes(commentMarker(root))).toBe(false);
|
||||
expect(commentMarker(root).includes(commentMarker(scoped))).toBe(false);
|
||||
});
|
||||
@@ -232,12 +232,12 @@ test("appendScopeEntry: inserts before the closing ] preserving comments", () =>
|
||||
]
|
||||
}`;
|
||||
const out = appendScopeEntry(raw, {
|
||||
name: "apps-api",
|
||||
paths: ["apps/api/**"],
|
||||
config: "apps/api",
|
||||
name: "server-www",
|
||||
paths: ["server/www/**"],
|
||||
config: "server/www",
|
||||
})!;
|
||||
expect(out).toContain("// keep me");
|
||||
expect(out).toContain('"name": "apps-api"');
|
||||
expect(out).toContain('"name": "server-www"');
|
||||
// Still valid JSON after stripping comments (comma inserted correctly).
|
||||
expect(() => RoutingManifestSchema.parse(JSON.parse(out.replace(/\/\/.*$/gm, "")))).not.toThrow();
|
||||
});
|
||||
@@ -249,9 +249,9 @@ test("appendScopeEntry: comma lands after the entry, not inside a trailing line
|
||||
]
|
||||
}`;
|
||||
const out = appendScopeEntry(raw, {
|
||||
name: "apps-api",
|
||||
paths: ["apps/api/**"],
|
||||
config: "apps/api",
|
||||
name: "server-www",
|
||||
paths: ["server/www/**"],
|
||||
config: "server/www",
|
||||
})!;
|
||||
expect(out).toContain('"config": "." }, // the default scope');
|
||||
// Still valid JSON after stripping comments (comma NOT swallowed by the comment).
|
||||
@@ -265,15 +265,15 @@ test("appendScopeEntry: handles a trailing comma plus block comment after the la
|
||||
{ "name": "default", "paths": ["**/*"], "config": "." }, /* keep */
|
||||
]
|
||||
}`;
|
||||
const out = appendScopeEntry(raw, { name: "api", paths: ["api/**"], config: "api" })!;
|
||||
const out = appendScopeEntry(raw, { name: "www", paths: ["www/**"], config: "www" })!;
|
||||
// No double comma; still parses after stripping both comment styles.
|
||||
const stripped = stripTrailingCommas(stripJsonComments(out));
|
||||
expect(() => RoutingManifestSchema.parse(JSON.parse(stripped))).not.toThrow();
|
||||
});
|
||||
|
||||
test("appendScopeEntry: idempotent on an already-present name", () => {
|
||||
const raw = `{ "scopes": [ { "name": "api", "paths": ["api/**"], "config": "api" } ] }`;
|
||||
expect(appendScopeEntry(raw, { name: "api", paths: ["api/**"], config: "api" })).toBe(raw);
|
||||
const raw = `{ "scopes": [ { "name": "www", "paths": ["www/**"], "config": "www" } ] }`;
|
||||
expect(appendScopeEntry(raw, { name: "www", paths: ["www/**"], config: "www" })).toBe(raw);
|
||||
});
|
||||
|
||||
test("appendScopeEntry: returns null when there is no scopes array", () => {
|
||||
@@ -303,8 +303,8 @@ test("scopedFingerprint: null scope === fingerprintFinding (BACKCOMPAT carry-ove
|
||||
test("scopedFingerprint: scoped ids are hex-only, same length, and differ per scope", () => {
|
||||
const f = finding();
|
||||
const plain = fingerprintFinding(f);
|
||||
const a = scopedFingerprint("api", f);
|
||||
const b = scopedFingerprint("web", f);
|
||||
const a = scopedFingerprint("www", f);
|
||||
const b = scopedFingerprint("website", f);
|
||||
expect(a).toMatch(/^[a-f0-9]+$/);
|
||||
expect(a.length).toBe(plain.length);
|
||||
expect(a).not.toBe(plain);
|
||||
|
||||
@@ -93,23 +93,23 @@ test("loadScopeConfig: config '.' reuses the root config, auth from loadAuthFrom
|
||||
|
||||
test("loadScopeConfig: nested scope reads its own roster/prompts; auth forced from root", async () => {
|
||||
const root = await makeRoot('{ "auth": { "mode": "oauth", "tokenEnv": "ROOT_TOKEN" } }');
|
||||
await writeConfigDir(path.join(root, "apps", "api", CONFIG_DIRNAME), {
|
||||
await writeConfigDir(path.join(root, "server", "www", CONFIG_DIRNAME), {
|
||||
// No auth here; scope-specific model + noise override the root.
|
||||
config:
|
||||
'{ "model": "anthropic/claude-opus-5", "noise": { "additionalIgnores": ["api/gen/**"] } }',
|
||||
'{ "model": "anthropic/claude-opus-4-1", "noise": { "additionalIgnores": ["www/gen/**"] } }',
|
||||
agents: { style: agent("style") },
|
||||
});
|
||||
const manifest = manifestOf({
|
||||
scopes: [
|
||||
{ name: "default", paths: ["**/*"], config: "." },
|
||||
{ name: "api", paths: ["apps/api/**"], config: "apps/api" },
|
||||
{ name: "www", paths: ["server/www/**"], config: "server/www" },
|
||||
],
|
||||
});
|
||||
const rootConfig = await loadReviewConfig(root);
|
||||
const scoped = await loadScopeConfig(root, manifest.scopes[1]!, manifest, rootConfig);
|
||||
expect(scoped.agents.some((a) => a.id === "style")).toBe(true);
|
||||
expect(scoped.noise.additionalIgnores).toEqual(["api/gen/**"]);
|
||||
expect(scoped.agents.find((a) => a.id === "style")!.model).toBe("anthropic/claude-opus-5");
|
||||
expect(scoped.noise.additionalIgnores).toEqual(["www/gen/**"]);
|
||||
expect(scoped.agents.find((a) => a.id === "style")!.model).toBe("anthropic/claude-opus-4-1");
|
||||
// auth is forced from the root even though the scope config declares none.
|
||||
expect(scoped.auth[0]?.tokenEnv).toBe("ROOT_TOKEN");
|
||||
});
|
||||
@@ -159,13 +159,13 @@ test("loadAuthFromRoot: manifest with defaults but no auth key keeps the root au
|
||||
|
||||
test("loadScopeConfig: enforceAgents injects the ROOT agent with alwaysRun", async () => {
|
||||
const root = await makeRoot();
|
||||
await writeConfigDir(path.join(root, "api", CONFIG_DIRNAME), {
|
||||
await writeConfigDir(path.join(root, "www", CONFIG_DIRNAME), {
|
||||
config: "{}",
|
||||
agents: { style: agent("style") }, // no security
|
||||
});
|
||||
const manifest = manifestOf({
|
||||
defaults: { enforceAgents: ["security"] },
|
||||
scopes: [{ name: "api", paths: ["api/**"], config: "api" }],
|
||||
scopes: [{ name: "www", paths: ["www/**"], config: "www" }],
|
||||
});
|
||||
const rootConfig = await loadReviewConfig(root);
|
||||
const scoped = await loadScopeConfig(root, manifest.scopes[0]!, manifest, rootConfig);
|
||||
@@ -177,14 +177,14 @@ test("loadScopeConfig: enforceAgents injects the ROOT agent with alwaysRun", asy
|
||||
|
||||
test("loadScopeConfig: a scope shadowing the enforced id gets the ROOT version (risk 11)", async () => {
|
||||
const root = await makeRoot();
|
||||
await writeConfigDir(path.join(root, "api", CONFIG_DIRNAME), {
|
||||
await writeConfigDir(path.join(root, "www", CONFIG_DIRNAME), {
|
||||
config: "{}",
|
||||
// The scope defines its OWN weaker security agent — must be overridden.
|
||||
agents: { security: agent("weak-security", ""), style: agent("style") },
|
||||
});
|
||||
const manifest = manifestOf({
|
||||
defaults: { enforceAgents: ["security"] },
|
||||
scopes: [{ name: "api", paths: ["api/**"], config: "api" }],
|
||||
scopes: [{ name: "www", paths: ["www/**"], config: "www" }],
|
||||
});
|
||||
const rootConfig = await loadReviewConfig(root);
|
||||
const scoped = await loadScopeConfig(root, manifest.scopes[0]!, manifest, rootConfig);
|
||||
@@ -231,20 +231,20 @@ test("config-dir override composes: root config + routing.jsonc from override, s
|
||||
path.join(root, "altroot", "routing.jsonc"),
|
||||
`{ "scopes": [
|
||||
{ "name": "default", "paths": ["**/*"], "config": "." },
|
||||
{ "name": "api", "paths": ["apps/api/**"], "config": "apps/api" }
|
||||
{ "name": "www", "paths": ["server/www/**"], "config": "server/www" }
|
||||
] }`,
|
||||
"utf8",
|
||||
);
|
||||
// The scope subtree lives at the REPO ROOT, not under the override dir.
|
||||
await writeConfigDir(path.join(root, "apps", "api", CONFIG_DIRNAME), {
|
||||
config: '{ "model": "anthropic/claude-opus-5" }',
|
||||
await writeConfigDir(path.join(root, "server", "www", CONFIG_DIRNAME), {
|
||||
config: '{ "model": "anthropic/claude-opus-4-1" }',
|
||||
agents: { style: agent("style") },
|
||||
});
|
||||
|
||||
// routing.jsonc is read from the override dir (the default tree's is absent).
|
||||
const manifest = await loadRoutingManifest(root, { configDir: "altroot" });
|
||||
expect(manifest).not.toBeNull();
|
||||
expect(manifest!.scopes.map((s) => s.name)).toEqual(["default", "api"]);
|
||||
expect(manifest!.scopes.map((s) => s.name)).toEqual(["default", "www"]);
|
||||
|
||||
// The root config artifacts follow the override.
|
||||
const rootConfig = await loadReviewConfig(root, { configDir: "altroot" });
|
||||
@@ -254,11 +254,11 @@ test("config-dir override composes: root config + routing.jsonc from override, s
|
||||
const def = await loadScopeConfig(root, manifest!.scopes[0]!, manifest!, rootConfig);
|
||||
expect(def.commentTag).toBe("alt-root-tag");
|
||||
|
||||
// The nested scope is still resolved from the repo root (apps/api), NOT the
|
||||
// The nested scope is still resolved from the repo root (server/www), NOT the
|
||||
// override dir — the override must not relocate the scopes themselves.
|
||||
const api = await loadScopeConfig(root, manifest!.scopes[1]!, manifest!, rootConfig);
|
||||
expect(api.agents.some((a) => a.id === "style")).toBe(true);
|
||||
expect(api.agents.find((a) => a.id === "style")!.model).toBe("anthropic/claude-opus-5");
|
||||
const www = await loadScopeConfig(root, manifest!.scopes[1]!, manifest!, rootConfig);
|
||||
expect(www.agents.some((a) => a.id === "style")).toBe(true);
|
||||
expect(www.agents.find((a) => a.id === "style")!.model).toBe("anthropic/claude-opus-4-1");
|
||||
});
|
||||
|
||||
test("loadReviewConfig: ECR_CONFIG_DIR loads from the alternate dir; unset → .expo-code-review (BACKCOMPAT)", async () => {
|
||||
|
||||
@@ -1,12 +1,6 @@
|
||||
import { test, expect } from "bun:test";
|
||||
|
||||
import {
|
||||
CHILD_FILES_PER_PAGE,
|
||||
MAX_CHILD_FILE_PAGES,
|
||||
collectChildFiles,
|
||||
parseChildFileNdjson,
|
||||
walkUpstack,
|
||||
} from "../sources/github-pr.js";
|
||||
import { parseChildFileNdjson, walkUpstack } from "../sources/github-pr.js";
|
||||
import type { StackChildFiles, StackChildPr } from "../sources/github-pr.js";
|
||||
import type { StackWalkOptions } from "../sources/source.js";
|
||||
|
||||
@@ -186,65 +180,3 @@ test("parseChildFileNdjson: blank lines and missing filenames are skipped", () =
|
||||
const stdout = `\n${JSON.stringify({ filename: "a.ts" })}\n\n${JSON.stringify({})}\n`;
|
||||
expect(parseChildFileNdjson(stdout)).toEqual(["a.ts"]);
|
||||
});
|
||||
|
||||
/** One NDJSON page of `count` filenames, offset so names are unique across pages. */
|
||||
function page(count: number, offset = 0): string {
|
||||
return Array.from({ length: count }, (_, i) =>
|
||||
JSON.stringify({ filename: `src/f${offset + i}.ts` }),
|
||||
).join("\n");
|
||||
}
|
||||
|
||||
test("collectChildFiles: stops paginating once maxFiles is exceeded", async () => {
|
||||
// 5 full pages exist, but with maxFiles=100 page 2 already proves truncation —
|
||||
// pages 3..5 must never be fetched.
|
||||
const calls: number[] = [];
|
||||
const result = await collectChildFiles(async (n) => {
|
||||
calls.push(n);
|
||||
return page(CHILD_FILES_PER_PAGE, (n - 1) * CHILD_FILES_PER_PAGE);
|
||||
}, 100);
|
||||
expect(calls).toEqual([1, 2]);
|
||||
expect(result.files.length).toBe(100);
|
||||
expect(result.truncated).toBe(true);
|
||||
});
|
||||
|
||||
test("collectChildFiles: reads to the end of a short list without truncation", async () => {
|
||||
const pages: Record<number, string> = { 1: page(CHILD_FILES_PER_PAGE), 2: page(40, 100) };
|
||||
const calls: number[] = [];
|
||||
const result = await collectChildFiles(async (n) => {
|
||||
calls.push(n);
|
||||
return pages[n] ?? "";
|
||||
}, 500);
|
||||
expect(calls).toEqual([1, 2]);
|
||||
expect(result.files.length).toBe(140);
|
||||
expect(result.truncated).toBe(false);
|
||||
});
|
||||
|
||||
test("collectChildFiles: never fetches past the hard page ceiling, and marks the subset", async () => {
|
||||
// Endless full pages with a huge maxFiles: the ceiling is the only stop, and the
|
||||
// result must still say truncated (the end of the list was never observed).
|
||||
const calls: number[] = [];
|
||||
const result = await collectChildFiles(async (n) => {
|
||||
calls.push(n);
|
||||
return page(CHILD_FILES_PER_PAGE, (n - 1) * CHILD_FILES_PER_PAGE);
|
||||
}, 1_000_000);
|
||||
expect(calls.length).toBe(MAX_CHILD_FILE_PAGES);
|
||||
expect(result.truncated).toBe(true);
|
||||
});
|
||||
|
||||
test("collectChildFiles: a dropped control-char name does not end pagination early", async () => {
|
||||
// Page 1 has 100 raw entries but one is dropped by the parser (99 kept). The
|
||||
// "last page?" decision must use the raw count, so page 2 is still fetched.
|
||||
const forged = JSON.stringify({ filename: "docs/a\nforged.ts" });
|
||||
const pages: Record<number, string> = {
|
||||
1: [page(CHILD_FILES_PER_PAGE - 1), forged].join("\n"),
|
||||
2: page(5, 200),
|
||||
};
|
||||
const calls: number[] = [];
|
||||
const result = await collectChildFiles(async (n) => {
|
||||
calls.push(n);
|
||||
return pages[n] ?? "";
|
||||
}, 500);
|
||||
expect(calls).toEqual([1, 2]);
|
||||
expect(result.files.length).toBe(104);
|
||||
expect(result.truncated).toBe(false);
|
||||
});
|
||||
@@ -43,7 +43,7 @@ test("refuses a scope config that declares auth", async () => {
|
||||
await put(root, `${CONFIG_DIRNAME}/config.jsonc`, `{ "auth": { "tokenEnv": "${EXPECTED}" } }`);
|
||||
await put(
|
||||
root,
|
||||
`apps/api/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`server/www/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`{ "model": "anthropic/claude-sonnet-5", "auth": { "mode": "api-key", "tokenEnv": "SNEAKY" } }`,
|
||||
);
|
||||
const result = await verifyConfig(root, { expected: EXPECTED });
|
||||
@@ -56,7 +56,7 @@ test("refuses a scope config that declares breakGlass", async () => {
|
||||
await put(root, `${CONFIG_DIRNAME}/config.jsonc`, `{ "auth": { "tokenEnv": "${EXPECTED}" } }`);
|
||||
await put(
|
||||
root,
|
||||
`apps/api/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`server/www/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`{ "model": "anthropic/claude-sonnet-5", "breakGlass": { "marker": "override-me" } }`,
|
||||
);
|
||||
const result = await verifyConfig(root, { expected: EXPECTED });
|
||||
@@ -69,7 +69,7 @@ test("refuses a scope config that declares commentTag", async () => {
|
||||
await put(root, `${CONFIG_DIRNAME}/config.jsonc`, `{ "auth": { "tokenEnv": "${EXPECTED}" } }`);
|
||||
await put(
|
||||
root,
|
||||
`apps/api/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`server/www/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`{ "model": "anthropic/claude-sonnet-5", "commentTag": "impostor-tag" }`,
|
||||
);
|
||||
const result = await verifyConfig(root, { expected: EXPECTED });
|
||||
@@ -156,7 +156,7 @@ test("refuses a tokenEnv declared only in a non-root file", async () => {
|
||||
await put(root, `${CONFIG_DIRNAME}/config.jsonc`, `{ "model": "anthropic/claude-sonnet-5" }`);
|
||||
await put(
|
||||
root,
|
||||
`apps/api/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`server/www/${CONFIG_DIRNAME}/config.jsonc`,
|
||||
`{ "auth": { "tokenEnv": "${EXPECTED}" } }`,
|
||||
);
|
||||
const result = await verifyConfig(root, { expected: EXPECTED });
|
||||
|
||||
@@ -5,7 +5,6 @@ import { dismissCommand } from "./commands/dismiss.js";
|
||||
import { doctorCommand } from "./commands/doctor.js";
|
||||
import { feedbackCommand } from "./commands/feedback.js";
|
||||
import { initCommand } from "./commands/init.js";
|
||||
import { refCheckCommand } from "./commands/ref-check.js";
|
||||
import { reviewCommand } from "./commands/review.js";
|
||||
import { setupAuthCommand } from "./commands/setup-auth.js";
|
||||
import { verifyConfigCommand } from "./commands/verify-config.js";
|
||||
@@ -22,7 +21,6 @@ Usage:
|
||||
ecr setup-auth [--yes] Walk through getting model credentials for local runs.
|
||||
ecr doctor [--list-scopes] Check environment, config, credentials, and scopes.
|
||||
ecr verify-config [--expected <env>] [--json] Refuse to run if a config could redirect the credential (CI guard).
|
||||
ecr ref-check [--root <dir>] [--json] Fail if the review setup cites code that moved or vanished.
|
||||
|
||||
Agents live in each repo under .expo-code-review/. This CLI is the engine.
|
||||
|
||||
@@ -72,9 +70,6 @@ async function main(): Promise<void> {
|
||||
case "verify-config":
|
||||
await verifyConfigCommand(rest);
|
||||
break;
|
||||
case "ref-check":
|
||||
await refCheckCommand(rest);
|
||||
break;
|
||||
default:
|
||||
process.stderr.write(`Unknown command: ${sub}\n\n${USAGE}`);
|
||||
process.exitCode = 2;
|
||||
|
||||
+4
-34
@@ -322,27 +322,6 @@ function adjudicationSeam(
|
||||
};
|
||||
}
|
||||
|
||||
// @ref LLP 0011#hard-floors-in-code [constrained-by] — one reporter per comment, so the
|
||||
// PR-author lookup and the paginated comment list are fetched once per scope, not twice
|
||||
/**
|
||||
* Memoize one value per scope name. Used for the per-scope GitHubReporter: a scope's
|
||||
* feedback seam reads the very comment that scope's report writes, and each reporter
|
||||
* instance holds its own comment-list TTL cache and bot-login memo, so a second instance
|
||||
* for the same comment tag re-fetches the identical paginated comment list and re-resolves
|
||||
* the login. Exported so that sharing is unit-testable.
|
||||
*/
|
||||
export function memoizeByScope<T>(build: (scope: string) => T): (scope: string) => T {
|
||||
const cache = new Map<string, T>();
|
||||
return (scope) => {
|
||||
let value = cache.get(scope);
|
||||
if (value === undefined) {
|
||||
value = build(scope);
|
||||
cache.set(scope, value);
|
||||
}
|
||||
return value;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* A freshly-reviewed scope's adjudicated feedback records, already keyed under the
|
||||
* scope-namespaced ids the aggregate comment renders (the single-mode seam builds them
|
||||
@@ -815,15 +794,6 @@ async function runRoutedCi(
|
||||
// the bot login once per scope for the identical comment.
|
||||
const singleModeReporter = mode === "single" ? reporterFor(rootTag, true) : undefined;
|
||||
|
||||
// Per-scope mode has the same property, one comment tag at a time: a scope's feedback
|
||||
// seam reads the very comment that scope's review is posted to, so both must use the
|
||||
// same instance or each scope re-fetches its comment list and re-resolves the bot
|
||||
// login. `withLink` is inert for the seam (matchAdjudicationItems renders nothing), so
|
||||
// one link-carrying reporter serves both uses.
|
||||
const scopeReporter = memoizeByScope((name: string) =>
|
||||
reporterFor(scopedCommentTag(rootTag, name), true),
|
||||
);
|
||||
|
||||
const results: ScopeReviewResult[] = [];
|
||||
for (const scope of active) {
|
||||
const scopeDef = manifest.scopes.find((entry) => entry.name === scope.name)!;
|
||||
@@ -852,7 +822,9 @@ async function runRoutedCi(
|
||||
const feedbackSeam = feedbackNeedsRunSeam(rootConfig.feedback)
|
||||
? adjudicationSeam(
|
||||
rootConfig,
|
||||
mode === "single" ? singleModeReporter! : scopeReporter(scope.name),
|
||||
mode === "single"
|
||||
? singleModeReporter!
|
||||
: reporterFor(scopedCommentTag(rootTag, scope.name)),
|
||||
mode === "single"
|
||||
? (finding) => scopedFingerprint(isDefault ? null : scope.name, finding)
|
||||
: undefined,
|
||||
@@ -942,9 +914,7 @@ async function runRoutedCi(
|
||||
if (scopesFilter && !scopesFilter.includes(scope.name)) {
|
||||
continue;
|
||||
}
|
||||
// The same instance the scope's feedback seam already used (its comment-list and
|
||||
// login caches are per-instance), so the report reuses that fetch.
|
||||
const reporter = scopeReporter(scope.name);
|
||||
const reporter = reporterFor(scopedCommentTag(rootTag, scope.name), true);
|
||||
const result = results.find((entry) => entry.scope === scope.name);
|
||||
if (result) {
|
||||
await reporter.report(result.review, (result.review as ReviewRunResult).feedback);
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
// @ref LLP 0012#run-points-command-and-review — the gating run point: exit 1 on any broken ref
|
||||
import path from "node:path";
|
||||
|
||||
import { checkConfigRefs } from "../core/config-refs.js";
|
||||
import type { RefProblem } from "../core/config-refs.js";
|
||||
import { repoRoot } from "../core/exec.js";
|
||||
import { errorMessage } from "../core/util.js";
|
||||
|
||||
const USAGE = `ecr ref-check — fail when the review setup cites code that moved or vanished
|
||||
|
||||
Usage:
|
||||
ecr ref-check [--root <dir>] [--json]
|
||||
|
||||
Sweeps every .expo-code-review/ directory in the repo (root and scopes) and checks
|
||||
that each code citation still resolves against this checkout:
|
||||
• \`@ref <target>\` annotations in prompts and configs. A target is a file, a
|
||||
directory (trailing slash), \`glob:<pattern>\`, a \`file#symbol\`, or a
|
||||
\`doc.md#heading\`. Never a line number — lines rot silently.
|
||||
• Unannotated citations: a backticked token that looks like a repo path must be a
|
||||
ref, so nothing cites code without being checked. Use \`@ref-ignore <token>\`
|
||||
for a token that is not a path.
|
||||
• Structural refs the config already declares: enforceAgents ids, scope config
|
||||
directories, and scope path globs.
|
||||
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.
|
||||
`;
|
||||
|
||||
const KIND_LABEL: Record<RefProblem["kind"], string> = {
|
||||
"broken-ref": "broken ref",
|
||||
"line-number-ref": "line-number ref",
|
||||
"unannotated-citation": "unannotated citation",
|
||||
structural: "structural ref",
|
||||
};
|
||||
|
||||
export async function refCheckCommand(argv: string[]): Promise<void> {
|
||||
if (argv.includes("-h") || argv.includes("--help")) {
|
||||
process.stdout.write(USAGE);
|
||||
return;
|
||||
}
|
||||
|
||||
let root: string | undefined;
|
||||
let json = false;
|
||||
for (let i = 0; i < argv.length; i++) {
|
||||
const arg = argv[i]!;
|
||||
if (arg === "--json") {
|
||||
json = true;
|
||||
} else if (arg === "--root") {
|
||||
root = argv[++i];
|
||||
// A flag-shaped value means the directory was forgotten: taking it would check
|
||||
// some nonexistent path and report "all resolve" while swallowing the real flag.
|
||||
if (!root || root.startsWith("-")) {
|
||||
process.stderr.write("ecr ref-check: --root needs a directory\n");
|
||||
process.exitCode = 2;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
process.stderr.write(`ecr ref-check: unknown argument ${arg}\n${USAGE}`);
|
||||
process.exitCode = 2;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const resolvedRoot = root ? path.resolve(root) : ((await repoRoot()) ?? process.cwd());
|
||||
const report = await checkConfigRefs({ root: resolvedRoot });
|
||||
|
||||
if (json) {
|
||||
process.stdout.write(`${JSON.stringify({ ok: report.ok, problems: report.problems })}\n`);
|
||||
} else if (report.ok) {
|
||||
process.stdout.write(
|
||||
`ref-check: ${report.refs.length} ref(s) across ${report.scannedFiles.length} setup file(s) — all resolve\n`,
|
||||
);
|
||||
} else {
|
||||
for (const problem of report.problems) {
|
||||
process.stderr.write(
|
||||
`${problem.file}:${problem.line}: ${KIND_LABEL[problem.kind]}: ${problem.problem}\n`,
|
||||
);
|
||||
}
|
||||
process.stderr.write(
|
||||
`\nref-check: ${report.problems.length} problem(s). Update the ref or the prompt that cites it.\n`,
|
||||
);
|
||||
}
|
||||
if (!report.ok) {
|
||||
process.exitCode = 1;
|
||||
}
|
||||
} catch (error) {
|
||||
process.stderr.write(`ecr ref-check: ${errorMessage(error)}\n`);
|
||||
process.exitCode = 2;
|
||||
}
|
||||
}
|
||||
+5
-18
@@ -24,17 +24,6 @@ const ADJUDICATE_TIMEOUT_MS = 3 * 60 * 1000;
|
||||
/** Categories no reply can ever clear, independent of the configured protected set. */
|
||||
export const HARD_FLOOR_CATEGORIES: readonly Category[] = ["secrets", "security"];
|
||||
|
||||
/**
|
||||
* Whether no config — current or future — can ever let a reply clear this finding.
|
||||
* `feedbackApplied`'s floor and `adjudicateFeedback`'s "don't spend a model call on it"
|
||||
* skip are the same question, so they read it from one place and cannot drift.
|
||||
* Deliberately NOT `config.protectedCategories`/`dismiss`: those are user-tunable, so a
|
||||
* stored verdict on such a finding becomes useful the moment the config changes.
|
||||
*/
|
||||
function hardFloored(finding: Finding): boolean {
|
||||
return finding.severity === "critical" || HARD_FLOOR_CATEGORIES.includes(finding.category);
|
||||
}
|
||||
|
||||
/**
|
||||
* One record to judge: the finding it answers and the reply's raw text. The reply text
|
||||
* is transient adjudicator input — it is built into the prompt and then discarded; it
|
||||
@@ -96,10 +85,13 @@ export function feedbackApplied(
|
||||
if (record.unclearedByHuman) {
|
||||
return false;
|
||||
}
|
||||
if (hardFloored(finding)) {
|
||||
if (finding.severity === "critical") {
|
||||
return false;
|
||||
}
|
||||
if (config.protectedCategories.includes(finding.category)) {
|
||||
if (
|
||||
HARD_FLOOR_CATEGORIES.includes(finding.category) ||
|
||||
config.protectedCategories.includes(finding.category)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
if (record.maintainer) {
|
||||
@@ -193,10 +185,6 @@ export async function adjudicateFeedback(
|
||||
// spend the budget on a rebuttal that changes no outcome. A reply that only quotes the
|
||||
// finding can never clear it either, and would otherwise starve a cited reply of the
|
||||
// cap. A finding a human already restored via `/undismiss` is likewise left unjudged.
|
||||
// A hard-floored finding is skipped for the same reason and is deliberately NOT counted
|
||||
// in `skipped` below: that figure means "reduced coverage, raise the cap", and a verdict
|
||||
// no config could ever act on is not coverage a higher cap would buy back.
|
||||
// @ref LLP 0011#hard-floors-in-code [constrained-by] — the code floor also means the model never judges a critical/secrets/security rebuttal: no verdict could move that outcome
|
||||
const toJudge =
|
||||
config.mode === "adjudicate"
|
||||
? items.filter(
|
||||
@@ -205,7 +193,6 @@ export async function adjudicateFeedback(
|
||||
item.record.author === true &&
|
||||
item.record.citedId === true &&
|
||||
!item.record.unclearedByHuman &&
|
||||
!hardFloored(item.finding) &&
|
||||
item.replyText.trim() !== "",
|
||||
)
|
||||
: [];
|
||||
|
||||
@@ -1,883 +0,0 @@
|
||||
// @ref LLP 0012#the-ref-grammar — one grammar for every code citation in a review setup
|
||||
// @ref LLP 0012#no-line-numbers-symbol-anchors-instead — targets are files, dirs, globs, symbols; never line numbers
|
||||
// @ref LLP 0012#unannotated-citations-are-broken-refs — a path-like backtick token that is not a ref fails the check
|
||||
import { readdir, readFile, stat } from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
|
||||
import { CONFIG_DIRNAME, stripJsonComments, stripTrailingCommas } from "../config/load.js";
|
||||
import { ROUTING_FILENAME } from "../config/routing.js";
|
||||
import { git, pathInside } from "./exec.js";
|
||||
import { matchesIgnore } from "./noise.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).
|
||||
*/
|
||||
const REF_MARK = "@" + "ref";
|
||||
const IGNORE_MARK = REF_MARK + "-ignore";
|
||||
|
||||
/** `@ref <target> [relation] — gloss` inside a `//`-style comment. */
|
||||
const LINE_REF_RE = new RegExp(String.raw`${REF_MARK}\s+(.+)`);
|
||||
/** `<!-- @ref <target> — gloss -->`, possibly spanning lines. */
|
||||
const MD_REF_RE = new RegExp(String.raw`<!--\s*${REF_MARK}\s+([\s\S]+?)-->`, "g");
|
||||
const IGNORE_RE = new RegExp(String.raw`${IGNORE_MARK}\s+(.+)`);
|
||||
|
||||
/** LLP-corpus targets (`LLP 0004#anchor`) belong to the engine repo, not an adopting one. */
|
||||
const LLP_TARGET_RE = /^LLP\s+\d{1,4}(?:#\S+)?$/;
|
||||
const URL_RE = /^https?:\/\/\S+$/;
|
||||
/** `<path>`, `<agent-id>`: documenting the grammar, not citing a file. */
|
||||
const PLACEHOLDER_RE = /^[<`]/;
|
||||
const GLOB_PREFIX = "glob:";
|
||||
|
||||
/** A citation that pins a line (`src/a.ts:42`, `src/a.ts:42-51`) — always refused. */
|
||||
const LINE_CITATION_RE = /^(.+?):(\d+)(?:-\d+)?$/;
|
||||
|
||||
/**
|
||||
* Extensions that make a backticked token a *code citation* rather than prose.
|
||||
* Deliberately an allowlist: `openai/gpt-5.5` and `label:<agent>` must not read as
|
||||
* paths, while `session.ts` and `.github/workflows/**` must.
|
||||
*/
|
||||
const CITATION_EXTENSIONS = new Set([
|
||||
".c",
|
||||
".cc",
|
||||
".cjs",
|
||||
".cpp",
|
||||
".cs",
|
||||
".css",
|
||||
".go",
|
||||
".graphql",
|
||||
".h",
|
||||
".hpp",
|
||||
".html",
|
||||
".java",
|
||||
".js",
|
||||
".json",
|
||||
".jsonc",
|
||||
".jsx",
|
||||
".kt",
|
||||
".lock",
|
||||
".md",
|
||||
".mjs",
|
||||
".mts",
|
||||
".php",
|
||||
".prisma",
|
||||
".proto",
|
||||
".py",
|
||||
".rb",
|
||||
".rs",
|
||||
".scss",
|
||||
".sh",
|
||||
".sql",
|
||||
".swift",
|
||||
".toml",
|
||||
".ts",
|
||||
".tsx",
|
||||
".txt",
|
||||
".vue",
|
||||
".yaml",
|
||||
".yml",
|
||||
".zsh",
|
||||
]);
|
||||
|
||||
/** Files inside a review-setup dir that are prompts or config (everything else is skipped). */
|
||||
const SCANNED_EXTENSIONS = new Set([".md", ".markdown", ".json", ".jsonc", ".txt"]);
|
||||
|
||||
export type RefProblemKind =
|
||||
| "broken-ref"
|
||||
| "line-number-ref"
|
||||
| "unannotated-citation"
|
||||
| "structural";
|
||||
|
||||
export interface RefProblem {
|
||||
/** Repo-relative file the problem was found in. */
|
||||
file: string;
|
||||
line: number;
|
||||
kind: RefProblemKind;
|
||||
/** One sentence, imperative where a fix is obvious. */
|
||||
problem: string;
|
||||
}
|
||||
|
||||
export interface ParsedRef {
|
||||
file: string;
|
||||
line: number;
|
||||
/** The target as written, gloss and relation stripped (`src/a.ts#foo`, `glob:**\/*.ts`). */
|
||||
target: string;
|
||||
}
|
||||
|
||||
export interface RefCheckReport {
|
||||
ok: boolean;
|
||||
problems: RefProblem[];
|
||||
/** Every resolvable ref found, so callers can tell when a PR touches cited code. */
|
||||
refs: ParsedRef[];
|
||||
/** Repo-relative review-setup files that were scanned. */
|
||||
scannedFiles: string[];
|
||||
/** Repo-relative paths (files and dirs) that some ref cites. */
|
||||
citedPaths: string[];
|
||||
}
|
||||
|
||||
interface RepoIndex {
|
||||
root: string;
|
||||
/** Tracked files, repo-relative with `/` separators. Empty when git is unavailable. */
|
||||
files: string[];
|
||||
}
|
||||
|
||||
function escapeRegExp(text: string): string {
|
||||
return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
|
||||
/** GitHub-style heading slug: lowercase, spaces to hyphens, drop other punctuation. */
|
||||
export function slugifyHeading(text: string): string {
|
||||
return [...text.replace(/`/g, "").trim().toLowerCase()]
|
||||
.map((ch) => (/[a-z0-9\-_]/.test(ch) ? ch : /\s/.test(ch) ? "-" : ""))
|
||||
.join("");
|
||||
}
|
||||
|
||||
/** Heading texts outside fenced code blocks. */
|
||||
function markdownHeadings(text: string): string[] {
|
||||
const headings: string[] = [];
|
||||
let fenced = false;
|
||||
for (const line of text.split(/\r?\n/)) {
|
||||
if (line.trimStart().startsWith("```")) {
|
||||
fenced = !fenced;
|
||||
continue;
|
||||
}
|
||||
const match = fenced ? null : /^#{1,6}\s+(.+?)\s*$/.exec(line);
|
||||
if (match) {
|
||||
headings.push(match[1]!);
|
||||
}
|
||||
}
|
||||
return headings;
|
||||
}
|
||||
|
||||
/** Strip the trailing `— gloss` and `[relation]` so only the target remains. */
|
||||
function refTarget(body: string): string {
|
||||
const withoutGloss = body.split(/\s+(?:[—–]|--)(?:\s+|$)/)[0]!.trim();
|
||||
const withoutRelation = withoutGloss.replace(/\s*\[[a-z-]+\]\s*$/, "").trim();
|
||||
// `LLP 0009#anchor` is ONE target that contains a space; taking the first
|
||||
// whitespace-separated token would leave a bare `LLP` and read as a broken path.
|
||||
const llp = /^LLP\s+\d{1,4}(?:#\S+)?/.exec(withoutRelation);
|
||||
return llp ? llp[0] : (withoutRelation.split(/\s+/)[0] ?? "");
|
||||
}
|
||||
|
||||
/** Line numbers (1-based) that sit inside a fenced code block. */
|
||||
function fencedLines(text: string): Set<number> {
|
||||
const fenced = new Set<number>();
|
||||
let open = false;
|
||||
text.split(/\r?\n/).forEach((line, index) => {
|
||||
if (line.trimStart().startsWith("```")) {
|
||||
fenced.add(index + 1); // the fence line itself is never a ref site
|
||||
open = !open;
|
||||
return;
|
||||
}
|
||||
if (open) {
|
||||
fenced.add(index + 1);
|
||||
}
|
||||
});
|
||||
return fenced;
|
||||
}
|
||||
|
||||
/**
|
||||
* Every `@ref` annotation in a setup file, markdown comments included. Fenced code
|
||||
* blocks are skipped: an annotation shown inside one is documenting the grammar, and
|
||||
* resolving it would make every doc that explains refs fail the check.
|
||||
*/
|
||||
export function parseRefAnnotations(text: string, file: string): ParsedRef[] {
|
||||
const refs: ParsedRef[] = [];
|
||||
if (file.endsWith(".md") || file.endsWith(".markdown")) {
|
||||
const fenced = fencedLines(text);
|
||||
for (const match of text.matchAll(MD_REF_RE)) {
|
||||
const line = text.slice(0, match.index).split("\n").length;
|
||||
if (fenced.has(line)) {
|
||||
continue;
|
||||
}
|
||||
refs.push({ file, line, target: refTarget(match[1]!) });
|
||||
}
|
||||
return refs;
|
||||
}
|
||||
text.split(/\r?\n/).forEach((lineText, index) => {
|
||||
const match = LINE_REF_RE.exec(lineText);
|
||||
if (match) {
|
||||
refs.push({ file, line: index + 1, target: refTarget(match[1]!) });
|
||||
}
|
||||
});
|
||||
return refs;
|
||||
}
|
||||
|
||||
/** Tokens an author declared as prose, not citations (`@ref-ignore knex.raw()`). */
|
||||
export function parseRefIgnores(text: string): Set<string> {
|
||||
const ignored = new Set<string>();
|
||||
for (const lineText of text.split(/\r?\n/)) {
|
||||
const match = IGNORE_RE.exec(lineText);
|
||||
if (!match) {
|
||||
continue;
|
||||
}
|
||||
for (const token of match[1]!.replace(/-->\s*$/, "").split(/[\s,]+/)) {
|
||||
const cleaned = token.replace(/^`|`$/g, "").trim();
|
||||
if (cleaned) {
|
||||
ignored.add(cleaned);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ignored;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does this backticked token cite code? True for `a/b/c.ts`, `session.ts`,
|
||||
* `src/entities/oauth/` and `.github/workflows/**`; false for `ecr ci`,
|
||||
* `label:<agent>`, `knex.raw()`, `openai/gpt-5.5` and bare `**`.
|
||||
*/
|
||||
export function isCodeCitation(token: string): boolean {
|
||||
if (!token || /[\s<>(){}"'|=,;]/.test(token) || token.length > 200) {
|
||||
return false;
|
||||
}
|
||||
const withoutLine = LINE_CITATION_RE.exec(token)?.[1] ?? token;
|
||||
if (withoutLine.includes(":")) {
|
||||
return false;
|
||||
}
|
||||
if (withoutLine.endsWith("/")) {
|
||||
return withoutLine.replace(/[/*]/g, "").length > 0;
|
||||
}
|
||||
const base = withoutLine.split("/").pop() ?? "";
|
||||
// A wildcard tail inside a path (`.github/workflows/**`) is a citation with no extension.
|
||||
if (base.includes("*") && withoutLine.includes("/")) {
|
||||
return withoutLine.replace(/[/*]/g, "").length > 0;
|
||||
}
|
||||
// A bare extension (`.ts`, `.js`) is prose about a suffix, not a file.
|
||||
if (CITATION_EXTENSIONS.has(base.toLowerCase())) {
|
||||
return false;
|
||||
}
|
||||
const dot = base.lastIndexOf(".");
|
||||
if (dot <= 0 && !base.startsWith(".")) {
|
||||
return false;
|
||||
}
|
||||
const extension = base.slice(base.lastIndexOf("."));
|
||||
return CITATION_EXTENSIONS.has(extension.toLowerCase()) && base.replace(/[*.]/g, "").length > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* The ref an unannotated citation should have become. Abbreviated paths (`.../a/B.kt`),
|
||||
* wildcards (`*Policy.ts`) and bare filenames (`session.ts`) become suffix globs, so a
|
||||
* prompt keeps its short readable form and still gets checked.
|
||||
*/
|
||||
export function suggestedRef(token: string): string {
|
||||
const trimmed = token.replace(/^\.\.\.\/?/, "").replace(/^\/+/, "");
|
||||
if (token.startsWith("...") || !trimmed.includes("/")) {
|
||||
return `${GLOB_PREFIX}**/${trimmed}`;
|
||||
}
|
||||
return trimmed.includes("*") ? `${GLOB_PREFIX}${trimmed}` : trimmed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Every form under which an annotated target can cover a prose citation, so one ref
|
||||
* silences the token it is about: `glob:src/commands/*.ts` covers `src/commands/*.ts`,
|
||||
* and `src/core/util.ts#errorMessage` covers `src/core/util.ts`.
|
||||
*/
|
||||
function coveringForms(target: string): string[] {
|
||||
const bare = target.startsWith(GLOB_PREFIX) ? target.slice(GLOB_PREFIX.length) : target;
|
||||
const withoutAnchor = splitAnchor(bare)[0];
|
||||
return [target, bare, withoutAnchor].flatMap((form) => [
|
||||
form,
|
||||
form.replace(/\/$/, ""),
|
||||
`${form}/`,
|
||||
]);
|
||||
}
|
||||
|
||||
/** The forms a prose citation could have been annotated as. */
|
||||
function citationForms(token: string): string[] {
|
||||
const suggested = suggestedRef(token);
|
||||
return [
|
||||
token,
|
||||
token.replace(/\/$/, ""),
|
||||
suggested,
|
||||
suggested.startsWith(GLOB_PREFIX) ? suggested.slice(GLOB_PREFIX.length) : suggested,
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Paths to test when a token has no extension to give it away — `eas-build-worker/terraform`,
|
||||
* `general-central/{module,production}`, a bare `finops`. These are only citations if they
|
||||
* actually resolve, since `anthropic/claude-opus-5` is shaped exactly the same and is not
|
||||
* a path. Returns the candidate paths to probe, or [] when the token cannot be one.
|
||||
*/
|
||||
export function pathishCandidates(token: string): string[] {
|
||||
if (!token || token.length > 200) {
|
||||
return [];
|
||||
}
|
||||
// Cut a brace list or wildcard tail off FIRST: the part before it is the path to
|
||||
// probe, and only that part has to look like one (`a/{b,c}` carries a comma).
|
||||
const cut = Math.min(
|
||||
...[token.indexOf("{"), token.indexOf("*")].filter((index) => index >= 0),
|
||||
token.length,
|
||||
);
|
||||
const prefix = token.slice(0, cut).replace(/\/$/, "");
|
||||
if (
|
||||
!prefix ||
|
||||
!/[a-zA-Z]/.test(prefix) ||
|
||||
/[\s<>()"'|=,;:]/.test(prefix) ||
|
||||
prefix.startsWith("-")
|
||||
) {
|
||||
return [];
|
||||
}
|
||||
return prefix === token ? [token] : [prefix];
|
||||
}
|
||||
|
||||
/** Backticked code citations, outside fenced code blocks, with their line numbers. */
|
||||
export function findProseCitations(text: string): Array<{ line: number; token: string }> {
|
||||
const found: Array<{ line: number; token: string }> = [];
|
||||
let fenced = false;
|
||||
text.split(/\r?\n/).forEach((lineText, index) => {
|
||||
if (lineText.trimStart().startsWith("```")) {
|
||||
fenced = !fenced;
|
||||
return;
|
||||
}
|
||||
if (fenced) {
|
||||
return;
|
||||
}
|
||||
for (const match of lineText.matchAll(/`([^`]+)`/g)) {
|
||||
found.push({ line: index + 1, token: match[1]! });
|
||||
}
|
||||
});
|
||||
return found;
|
||||
}
|
||||
|
||||
async function pathKind(absolute: string): Promise<"file" | "dir" | "missing"> {
|
||||
try {
|
||||
const stats = await stat(absolute);
|
||||
return stats.isDirectory() ? "dir" : "file";
|
||||
} catch {
|
||||
return "missing";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve one ref target against the repo. Returns the problem text, or null when
|
||||
* the ref holds. Refs are ALWAYS repo-root-relative — a scope's prompts cite the
|
||||
* same paths the reviewer sees in the diff, so there is no per-directory base.
|
||||
*/
|
||||
async function resolveTarget(
|
||||
target: string,
|
||||
index: RepoIndex,
|
||||
/** A scope's own subtree, used only to say "did you mean" on a scope-relative path. */
|
||||
scopeRoot?: string,
|
||||
): Promise<string | null> {
|
||||
if (!target) {
|
||||
return `empty ${REF_MARK} target`;
|
||||
}
|
||||
if (URL_RE.test(target) || LLP_TARGET_RE.test(target) || PLACEHOLDER_RE.test(target)) {
|
||||
// URLs are shape-only (never fetched); LLP numbers belong to the engine's own
|
||||
// corpus (`./ref-check`); `<placeholder>` targets are documentation of the syntax.
|
||||
return null;
|
||||
}
|
||||
if (target.startsWith(GLOB_PREFIX)) {
|
||||
const pattern = target.slice(GLOB_PREFIX.length);
|
||||
if (!pattern) {
|
||||
return `empty glob in ${REF_MARK} target`;
|
||||
}
|
||||
if (index.files.length === 0) {
|
||||
return null; // no file list to match against (not a git checkout) — uncheckable
|
||||
}
|
||||
return index.files.some((file) => matchesIgnore(file, pattern))
|
||||
? null
|
||||
: `glob matches no file in the repo: ${pattern}`;
|
||||
}
|
||||
const lineCitation = LINE_CITATION_RE.exec(target);
|
||||
if (lineCitation) {
|
||||
return `cites a line number (${target}); refs pin a file, dir, glob, or \`#symbol\` — line numbers rot silently`;
|
||||
}
|
||||
|
||||
const [rawPath, anchor] = splitAnchor(target);
|
||||
if (path.isAbsolute(rawPath) || rawPath.startsWith("~")) {
|
||||
return `absolute path (${rawPath}); refs are repo-root-relative`;
|
||||
}
|
||||
const absolute = path.resolve(index.root, rawPath);
|
||||
if (!pathInside(absolute, index.root)) {
|
||||
return `escapes the repository (${rawPath})`;
|
||||
}
|
||||
const kind = await pathKind(absolute);
|
||||
if (kind === "missing") {
|
||||
// A scope's prompts naturally say `general-central/module` for what is really
|
||||
// `infrastructure/general-central/module`. That is still a broken ref (one base, no
|
||||
// ambiguity), but the fix is named instead of left as a puzzle.
|
||||
const scoped = scopeRoot ? path.resolve(scopeRoot, rawPath) : null;
|
||||
if (scoped && pathInside(scoped, index.root) && (await pathKind(scoped)) !== "missing") {
|
||||
const suggestion = path.relative(index.root, scoped).split(path.sep).join("/");
|
||||
return `no such path in the repo: ${rawPath} — refs are repo-root-relative; did you mean ${suggestion}?`;
|
||||
}
|
||||
return `no such path in the repo: ${rawPath}`;
|
||||
}
|
||||
if (rawPath.endsWith("/") && kind !== "dir") {
|
||||
return `${rawPath} is a file, not a directory (drop the trailing slash)`;
|
||||
}
|
||||
if (!anchor) {
|
||||
return null;
|
||||
}
|
||||
if (kind === "dir") {
|
||||
return `${rawPath} is a directory, so \`#${anchor}\` cannot resolve`;
|
||||
}
|
||||
let content: string;
|
||||
try {
|
||||
content = await readFile(absolute, "utf8");
|
||||
} catch {
|
||||
return null; // unreadable (binary, permissions) — uncheckable, never a failure
|
||||
}
|
||||
if (rawPath.endsWith(".md") || rawPath.endsWith(".markdown")) {
|
||||
const slugs = new Set(markdownHeadings(content).map(slugifyHeading));
|
||||
return slugs.has(slugifyHeading(anchor)) ? null : `${rawPath} has no heading #${anchor}`;
|
||||
}
|
||||
return new RegExp(String.raw`\b${escapeRegExp(anchor)}\b`).test(content)
|
||||
? null
|
||||
: `${rawPath} no longer contains \`${anchor}\``;
|
||||
}
|
||||
|
||||
/**
|
||||
* How a setup file is named in a problem. Normally repo-relative, but in CI the setup
|
||||
* is materialized from the trusted base ref OUTSIDE the code tree, where a relative
|
||||
* path would read as `../../tmp/…`; there, name it by its position in the setup dir.
|
||||
*/
|
||||
function fileLabel(root: string, setupDir: string, file: string): string {
|
||||
const relative = path.relative(root, file);
|
||||
if (!relative.startsWith("..")) {
|
||||
return relative;
|
||||
}
|
||||
return path.join(CONFIG_DIRNAME, path.relative(setupDir, file));
|
||||
}
|
||||
|
||||
function splitAnchor(target: string): [string, string | undefined] {
|
||||
const hash = target.indexOf("#");
|
||||
return hash === -1 ? [target, undefined] : [target.slice(0, hash), target.slice(hash + 1)];
|
||||
}
|
||||
|
||||
/**
|
||||
* The repo's files, repo-relative with `/` separators — what `glob:` targets and scope
|
||||
* globs match against. `git ls-files` when possible (fast, and "tracked" is the right
|
||||
* notion for reviewable code), else a filesystem walk so the check still works in a
|
||||
* plain directory. Empty only for an unreadable root.
|
||||
*/
|
||||
async function listRepoFiles(root: string): Promise<string[]> {
|
||||
try {
|
||||
// Tracked AND untracked-but-not-ignored: a plain path ref resolves with `stat` and
|
||||
// therefore sees a file the moment it exists, so a glob must too — otherwise a
|
||||
// freshly scaffolded (uncommitted) tree reports globs as matching nothing.
|
||||
const tracked = (await git(["ls-files", "--cached", "--others", "--exclude-standard"], root))
|
||||
.split("\n")
|
||||
.map((line) => line.trim())
|
||||
.filter(Boolean);
|
||||
if (tracked.length > 0) {
|
||||
return tracked;
|
||||
}
|
||||
} catch {
|
||||
// not a git checkout — fall through to the walk
|
||||
}
|
||||
const found: string[] = [];
|
||||
async function walk(dir: string): Promise<void> {
|
||||
let entries;
|
||||
try {
|
||||
entries = await readdir(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
if (entry.name === "node_modules" || (entry.name.startsWith(".") && entry.isDirectory())) {
|
||||
continue;
|
||||
}
|
||||
const child = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) {
|
||||
await walk(child);
|
||||
} else if (entry.isFile()) {
|
||||
found.push(path.relative(root, child).split(path.sep).join("/"));
|
||||
}
|
||||
}
|
||||
}
|
||||
await walk(root);
|
||||
return found.sort();
|
||||
}
|
||||
|
||||
// @ref LLP 0012#what-gets-scanned [implements] — on-disk sweep of every setup dir, .runs/ excluded
|
||||
/**
|
||||
* Every review-setup directory in the repo, found by walking the tree (not the
|
||||
* routing manifest): a scope dir the manifest forgot still ships prompts to nobody,
|
||||
* and its stale refs are exactly what this check exists to surface.
|
||||
*/
|
||||
export async function discoverSetupDirs(root: string): Promise<string[]> {
|
||||
const found: string[] = [];
|
||||
async function walk(dir: string): Promise<void> {
|
||||
let entries;
|
||||
try {
|
||||
entries = await readdir(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
if (!entry.isDirectory()) {
|
||||
continue;
|
||||
}
|
||||
const child = path.join(dir, entry.name);
|
||||
if (entry.name === CONFIG_DIRNAME) {
|
||||
found.push(child);
|
||||
continue; // a setup dir never nests another
|
||||
}
|
||||
// Other dot dirs are skipped wholesale: `.claude/worktrees/` holds checkouts of
|
||||
// this same repo, whose setup dirs would otherwise be swept as if they were scopes.
|
||||
if (entry.name === "node_modules" || entry.name.startsWith(".")) {
|
||||
continue;
|
||||
}
|
||||
await walk(child);
|
||||
}
|
||||
}
|
||||
await walk(root);
|
||||
return found.sort();
|
||||
}
|
||||
|
||||
/** Prompt and config files inside a setup dir. Skips `.runs/` and other dot entries. */
|
||||
async function setupFiles(dir: string): Promise<string[]> {
|
||||
const found: string[] = [];
|
||||
async function walk(current: string): Promise<void> {
|
||||
let entries;
|
||||
try {
|
||||
entries = await readdir(current, { withFileTypes: true });
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
if (entry.name.startsWith(".")) {
|
||||
continue;
|
||||
}
|
||||
const child = path.join(current, entry.name);
|
||||
if (entry.isDirectory()) {
|
||||
await walk(child);
|
||||
} else if (SCANNED_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
|
||||
found.push(child);
|
||||
}
|
||||
}
|
||||
}
|
||||
await walk(dir);
|
||||
return found.sort();
|
||||
}
|
||||
|
||||
function parseJsonc(text: string): Record<string, unknown> | null {
|
||||
try {
|
||||
const value = JSON.parse(stripTrailingCommas(stripJsonComments(text))) as unknown;
|
||||
return value && typeof value === "object" && !Array.isArray(value)
|
||||
? (value as Record<string, unknown>)
|
||||
: null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function stringArray(value: unknown): string[] {
|
||||
return Array.isArray(value)
|
||||
? value.filter((item): item is string => typeof item === "string")
|
||||
: [];
|
||||
}
|
||||
|
||||
// @ref LLP 0012#structural-refs-need-no-annotation [implements] — ids and scope dirs are refs the config already declares
|
||||
/**
|
||||
* Refs the config declares structurally, so they are checked without an annotation:
|
||||
* every `enforceAgents` id must have a root `agents/<id>.md`, every scope must point
|
||||
* at a real setup dir, and every scope glob must match at least one tracked file (a
|
||||
* glob matching nothing means those prompts review nothing).
|
||||
*/
|
||||
async function checkRoutingManifest(
|
||||
file: string,
|
||||
index: RepoIndex,
|
||||
rootAgentIds: Set<string>,
|
||||
): Promise<RefProblem[]> {
|
||||
const problems: RefProblem[] = [];
|
||||
const relative = fileLabel(index.root, path.dirname(file), file);
|
||||
let parsed: Record<string, unknown> | null;
|
||||
try {
|
||||
parsed = parseJsonc(await readFile(file, "utf8"));
|
||||
} catch {
|
||||
return problems;
|
||||
}
|
||||
if (!parsed) {
|
||||
return [
|
||||
{ file: relative, line: 1, kind: "structural", problem: "could not be parsed as JSONC" },
|
||||
];
|
||||
}
|
||||
|
||||
const defaults = (parsed.defaults ?? {}) as Record<string, unknown>;
|
||||
const enforced = new Set(stringArray(defaults.enforceAgents));
|
||||
const scopes = Array.isArray(parsed.scopes) ? parsed.scopes : [];
|
||||
for (const scope of scopes) {
|
||||
if (!scope || typeof scope !== "object") {
|
||||
continue;
|
||||
}
|
||||
const entry = scope as Record<string, unknown>;
|
||||
const name = typeof entry.name === "string" ? entry.name : "(unnamed)";
|
||||
for (const id of stringArray(entry.enforceAgents)) {
|
||||
enforced.add(id);
|
||||
}
|
||||
const configDir = typeof entry.config === "string" ? entry.config : null;
|
||||
if (configDir) {
|
||||
const setupDir = path.resolve(index.root, configDir, CONFIG_DIRNAME);
|
||||
if (!pathInside(setupDir, index.root)) {
|
||||
problems.push({
|
||||
file: relative,
|
||||
line: 1,
|
||||
kind: "structural",
|
||||
problem: `scope "${name}" points outside the repository (config: ${configDir})`,
|
||||
});
|
||||
} else if ((await pathKind(setupDir)) !== "dir") {
|
||||
problems.push({
|
||||
file: relative,
|
||||
line: 1,
|
||||
kind: "structural",
|
||||
problem: `scope "${name}" has no ${configDir}/${CONFIG_DIRNAME}/ directory`,
|
||||
});
|
||||
}
|
||||
}
|
||||
if (index.files.length > 0) {
|
||||
for (const pattern of stringArray(entry.paths)) {
|
||||
const variants = [pattern, pattern.replace(/\*\*\//g, "")];
|
||||
if (
|
||||
!index.files.some((repoFile) => variants.some((v) => v && matchesIgnore(repoFile, v)))
|
||||
) {
|
||||
problems.push({
|
||||
file: relative,
|
||||
line: 1,
|
||||
kind: "structural",
|
||||
problem: `scope "${name}" glob matches no file in the repo: ${pattern}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const id of enforced) {
|
||||
if (!rootAgentIds.has(id)) {
|
||||
problems.push({
|
||||
file: relative,
|
||||
line: 1,
|
||||
kind: "structural",
|
||||
problem: `enforceAgents names "${id}", but the root setup has no agents/${id}.md`,
|
||||
});
|
||||
}
|
||||
}
|
||||
return problems;
|
||||
}
|
||||
|
||||
/** Agent ids in a setup dir (id = filename without `.md`, per the loader). */
|
||||
async function agentIds(setupDir: string): Promise<Set<string>> {
|
||||
try {
|
||||
const entries = await readdir(path.join(setupDir, "agents"));
|
||||
return new Set(entries.filter((name) => name.endsWith(".md")).map((name) => name.slice(0, -3)));
|
||||
} catch {
|
||||
return new Set();
|
||||
}
|
||||
}
|
||||
|
||||
export interface CheckConfigRefsOptions {
|
||||
/** Repo root. Refs resolve against this tree — in CI, the PR head checkout. */
|
||||
root: string;
|
||||
/** Restrict the sweep to these setup dirs (absolute). Default: every one in the repo. */
|
||||
setupDirs?: string[];
|
||||
}
|
||||
|
||||
// @ref LLP 0012#run-points-command-and-review [implements] — one pure-ish entry point both the command and the review call
|
||||
/**
|
||||
* Check every code citation in the repo's review setup. Deterministic, no model, no
|
||||
* network: refs either resolve against the tree or they do not.
|
||||
*/
|
||||
export async function checkConfigRefs(options: CheckConfigRefsOptions): Promise<RefCheckReport> {
|
||||
const root = path.resolve(options.root);
|
||||
const index: RepoIndex = { root, files: await listRepoFiles(root) };
|
||||
const dirs = options.setupDirs ?? (await discoverSetupDirs(root));
|
||||
|
||||
const problems: RefProblem[] = [];
|
||||
const refs: ParsedRef[] = [];
|
||||
const scannedFiles: string[] = [];
|
||||
const citedPaths = new Set<string>();
|
||||
|
||||
// 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<string, string | null>();
|
||||
/** The root-relative path an extensionless token names, or null if it names nothing. */
|
||||
const namedPath = async (token: string, scopeRoot: string): Promise<string | null> => {
|
||||
for (const candidate of pathishCandidates(token)) {
|
||||
for (const base of [root, scopeRoot]) {
|
||||
const absolute = path.resolve(base, candidate);
|
||||
let resolved = resolvable.get(absolute);
|
||||
if (resolved === undefined) {
|
||||
const kind = pathInside(absolute, root) ? await pathKind(absolute) : "missing";
|
||||
resolved =
|
||||
kind === "missing"
|
||||
? null
|
||||
: path.relative(root, absolute).split(path.sep).join("/") +
|
||||
(kind === "dir" ? "/" : "");
|
||||
resolvable.set(absolute, resolved);
|
||||
}
|
||||
if (resolved) {
|
||||
return resolved;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
|
||||
for (const dir of dirs) {
|
||||
const scopeRoot = path.dirname(dir);
|
||||
for (const file of await setupFiles(dir)) {
|
||||
const relative = fileLabel(root, dir, file);
|
||||
let text: string;
|
||||
try {
|
||||
text = await readFile(file, "utf8");
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
scannedFiles.push(relative);
|
||||
|
||||
const annotated = parseRefAnnotations(text, relative);
|
||||
const ignored = parseRefIgnores(text);
|
||||
const covered = new Set(annotated.flatMap((ref) => coveringForms(ref.target)));
|
||||
// A glob ref also covers any citation the glob itself matches, so a prompt can
|
||||
// cite `.../nested/Handler.kt` and pin it once with `glob:**/Handler.kt`.
|
||||
const coveringGlobs = annotated
|
||||
.filter((ref) => ref.target.startsWith(GLOB_PREFIX))
|
||||
.map((ref) => ref.target.slice(GLOB_PREFIX.length));
|
||||
|
||||
for (const ref of annotated) {
|
||||
const problem = await resolveTarget(ref.target, index, scopeRoot);
|
||||
if (problem) {
|
||||
problems.push({
|
||||
file: relative,
|
||||
line: ref.line,
|
||||
kind: problem.startsWith("cites a line number") ? "line-number-ref" : "broken-ref",
|
||||
problem,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
// An `LLP NNNN` target belongs to a different mechanism (a design corpus, owned
|
||||
// by that repo's own checker). ecr neither resolves nor counts it: the refs it
|
||||
// owns are the ones citing the reviewed code.
|
||||
if (LLP_TARGET_RE.test(ref.target)) {
|
||||
continue;
|
||||
}
|
||||
refs.push(ref);
|
||||
const cited = splitAnchor(ref.target)[0];
|
||||
if (cited && !cited.startsWith(GLOB_PREFIX) && !URL_RE.test(cited)) {
|
||||
citedPaths.add(cited.replace(/\/$/, ""));
|
||||
}
|
||||
}
|
||||
|
||||
for (const { line, token } of findProseCitations(text)) {
|
||||
// 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;
|
||||
}
|
||||
// Coverage must accept the path the token RESOLVED to, not just the token as
|
||||
// written: a prompt says `cert-manager` and the ref that pins it is
|
||||
// `infrastructure/cert-manager/`. Without this, the fix the message suggests
|
||||
// does not silence the citation it was suggested for.
|
||||
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;
|
||||
}
|
||||
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);
|
||||
problems.push({
|
||||
file: relative,
|
||||
line,
|
||||
kind: lineCitation ? "line-number-ref" : "unannotated-citation",
|
||||
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)`,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const routing = path.join(dir, ROUTING_FILENAME);
|
||||
if ((await pathKind(routing)) === "file") {
|
||||
// The roster comes from the dir that OWNS the manifest, never from `root`:
|
||||
// under `ecr ci` the setup is a trusted base-ref checkout while `root` is the PR
|
||||
// head tree, so reading `root/.expo-code-review/agents` would judge enforceAgents
|
||||
// against a different (or absent) roster than the one actually loaded.
|
||||
problems.push(...(await checkRoutingManifest(routing, index, await agentIds(dir))));
|
||||
}
|
||||
}
|
||||
|
||||
problems.sort(
|
||||
(a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.problem.localeCompare(b.problem),
|
||||
);
|
||||
return {
|
||||
ok: problems.length === 0,
|
||||
problems,
|
||||
refs,
|
||||
scannedFiles,
|
||||
citedPaths: [...citedPaths].sort(),
|
||||
};
|
||||
}
|
||||
|
||||
/** How many examples a review-side note names before saying "and N more". */
|
||||
const NOTE_EXAMPLES = 5;
|
||||
|
||||
function andMore(items: string[]): string {
|
||||
const shown = items.slice(0, NOTE_EXAMPLES).join(", ");
|
||||
const rest = items.length - NOTE_EXAMPLES;
|
||||
return rest > 0 ? `${shown}, and ${rest} more` : shown;
|
||||
}
|
||||
|
||||
// @ref LLP 0012#run-points-command-and-review [constrained-by] — advises, never fails the review
|
||||
/**
|
||||
* The advice a review gives about its own setup: refs that no longer resolve, and cited
|
||||
* code this PR changes (where the ref still resolves but the guidance may not). Returns
|
||||
* an empty array when the setup is clean, so a healthy run stays silent.
|
||||
*/
|
||||
export async function reviewSetupRefNotes(options: {
|
||||
root: string;
|
||||
setupDirs: string[];
|
||||
changedFiles: string[];
|
||||
}): Promise<string[]> {
|
||||
let report: RefCheckReport;
|
||||
try {
|
||||
report = await checkConfigRefs({ root: options.root, setupDirs: options.setupDirs });
|
||||
} catch {
|
||||
return []; // a check that cannot run must never degrade the review
|
||||
}
|
||||
const notes: string[] = [];
|
||||
const broken = report.problems.filter((problem) => problem.kind !== "unannotated-citation");
|
||||
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}`))}. ` +
|
||||
"Run `ecr ref-check` — the prompts may be reviewing against code that moved.",
|
||||
);
|
||||
}
|
||||
const touched = citedPathsTouchedBy(report, options.changedFiles);
|
||||
if (touched.length > 0) {
|
||||
notes.push(
|
||||
`This PR changes code the reviewer prompts cite (${andMore(touched)}). ` +
|
||||
"Check that the guidance quoting it is still correct.",
|
||||
);
|
||||
}
|
||||
return notes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Which of this PR's changed files are cited by a ref. The review uses this to say
|
||||
* "you moved code the reviewer prompts point at" even when the ref still resolves.
|
||||
*/
|
||||
export function citedPathsTouchedBy(report: RefCheckReport, changedFiles: string[]): string[] {
|
||||
const touched = new Set<string>();
|
||||
for (const changed of changedFiles) {
|
||||
for (const cited of report.citedPaths) {
|
||||
if (changed === cited || changed.startsWith(`${cited}/`)) {
|
||||
touched.add(cited);
|
||||
}
|
||||
}
|
||||
}
|
||||
return [...touched].sort();
|
||||
}
|
||||
@@ -238,7 +238,6 @@ export function renderMarkdown(
|
||||
);
|
||||
}
|
||||
|
||||
lines.push(...setupNote(review.setupNotes));
|
||||
lines.push(...requalificationAuditNote(requalified.map((entry) => entry.finding)));
|
||||
lines.push(...feedbackAuditNote([...feedbackByFp.values()]));
|
||||
|
||||
@@ -353,15 +352,6 @@ function renderFindingLines(
|
||||
return out;
|
||||
}
|
||||
|
||||
// @ref LLP 0012#run-points-command-and-review [implements] — setup advice renders outside the findings list, so it never blocks
|
||||
/** Advice about the reviewer's own setup (stale refs, cited code this PR moves). */
|
||||
function setupNote(notes: string[] = []): string[] {
|
||||
if (notes.length === 0) {
|
||||
return [];
|
||||
}
|
||||
return ["> 🔗 **Review setup:**", ...notes.map((note) => `> - ${stripStateMarkers(note)}`), ""];
|
||||
}
|
||||
|
||||
// @ref LLP 0010#rendering-in-all-three-paths [implements] — the visible audit count is mandatory: requalification's only effect on a real finding is moving it out of the blocking set, so it must never be silent
|
||||
/**
|
||||
* The visible one-line audit note in the OPEN body, naming the addressing PRs. This
|
||||
@@ -620,15 +610,6 @@ export function renderAggregateMarkdown(
|
||||
lines.push("");
|
||||
}
|
||||
|
||||
const setupLines = results.flatMap((result) =>
|
||||
(result.review.setupNotes ?? []).map(
|
||||
(note) => `> - [${stripStateMarkers(result.scope)}] ${stripStateMarkers(note)}`,
|
||||
),
|
||||
);
|
||||
if (setupLines.length > 0) {
|
||||
lines.push("> 🔗 **Review setup:**", ...setupLines, "");
|
||||
}
|
||||
|
||||
// Shown = the most-severe N kept findings per scope (N = limitPerScope). The
|
||||
// embedded state trims KEPT findings to the same set so a truncated comment
|
||||
// still fits GitHub's body limit (the hidden findings are noted, not silently
|
||||
|
||||
+1
-19
@@ -50,7 +50,6 @@ import { confirmStackRequalifications, patchConfirmer } from "./stack-confirm.js
|
||||
import { sortFindings } from "./render.js";
|
||||
import { appendStepSummary } from "./step-summary.js";
|
||||
import { errorMessage, sleep } from "./util.js";
|
||||
import { reviewSetupRefNotes } from "./config-refs.js";
|
||||
import { verifyFindings } from "./verify.js";
|
||||
import { applyInlineIgnores } from "./suppress.js";
|
||||
|
||||
@@ -298,20 +297,6 @@ export async function runReview(
|
||||
process.chdir(readRoot.dir);
|
||||
}
|
||||
|
||||
// Ref integrity of the setup that is about to review this PR. Resolved against the
|
||||
// tree the reviewers read (PR head when materialized), while the setup itself may
|
||||
// come from the trusted base ref — so a PR that moves cited code is reported against
|
||||
// the prompts that will actually judge it.
|
||||
// @ref LLP 0012#run-points-command-and-review [implements] — every review checks its own refs; advice only, never a gate
|
||||
const setupNotes = await reviewSetupRefNotes({
|
||||
root: readRoot?.dir ?? originalCwd,
|
||||
setupDirs: [config.configDir],
|
||||
changedFiles: kept.map((entry) => entry.path),
|
||||
});
|
||||
for (const note of setupNotes) {
|
||||
progress(` setup: ${note}`);
|
||||
}
|
||||
|
||||
const starting = [
|
||||
usesClaude ? "Claude Code engine" : null,
|
||||
usesOpencode ? "OpenCode server" : null,
|
||||
@@ -1182,10 +1167,7 @@ export async function runReview(
|
||||
summary: output.summary,
|
||||
});
|
||||
|
||||
// Engine-owned: overwrite whatever the coordinator may have emitted under this key,
|
||||
// so setup advice is always the checker's, never model text.
|
||||
const reviewed = { ...output, setupNotes };
|
||||
return feedbackRecords ? { ...reviewed, feedback: feedbackRecords } : reviewed;
|
||||
return feedbackRecords ? { ...output, feedback: feedbackRecords } : output;
|
||||
} catch (error) {
|
||||
await safeLog(logPath, {
|
||||
...baseRecord,
|
||||
|
||||
@@ -170,16 +170,6 @@ export const CoordinatorOutputSchema = z.object({
|
||||
* overrides the presentation instead).
|
||||
*/
|
||||
couldNotComplete: z.boolean().optional(),
|
||||
/**
|
||||
* Advice about the review's OWN setup: refs in `.expo-code-review/` that no longer
|
||||
* resolve, and cited code this PR changes. Engine-set (never the model, never a
|
||||
* finding) and never blocking — a stale prompt is a maintenance signal, not a defect
|
||||
* in the PR.
|
||||
*/
|
||||
// @ref LLP 0012#run-points-command-and-review [implements] — the review advises about stale refs instead of failing on them
|
||||
// Optional (like couldNotComplete) so every internal CoordinatorOutput literal stays
|
||||
// valid without restating an engine-owned field.
|
||||
setupNotes: z.array(z.string()).optional(),
|
||||
});
|
||||
export type CoordinatorOutput = z.infer<typeof CoordinatorOutputSchema>;
|
||||
|
||||
|
||||
@@ -78,12 +78,11 @@ const MAINTAINER_ASSOCIATIONS = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
|
||||
|
||||
/**
|
||||
* PR-author lookups shared across reporter INSTANCES, keyed by the exact PR they
|
||||
* describe. Routed CI builds one GitHubReporter per scope comment (plus one for the
|
||||
* aggregate comment), and every one of them would otherwise run its own `gh pr view` for
|
||||
* the SAME PR. The key carries the checkout, the repo and the PR number, so a lookup can
|
||||
* never leak across repos or PRs in one process (the `ecr feedback` crawl walks many
|
||||
* PRs). The in-flight promise is stored, not just the result, so concurrent scopes share
|
||||
* one call.
|
||||
* describe. Routed CI builds a fresh GitHubReporter per scope (plus one for the seam),
|
||||
* and every one of them would otherwise run its own `gh pr view` for the SAME PR. The
|
||||
* key carries the checkout, the repo and the PR number, so a lookup can never leak
|
||||
* across repos or PRs in one process (the `ecr feedback` crawl walks many PRs). The
|
||||
* in-flight promise is stored, not just the result, so concurrent scopes share one call.
|
||||
*/
|
||||
const prAuthorByPr = new Map<string, Promise<string | null>>();
|
||||
|
||||
|
||||
@@ -65,15 +65,6 @@ export class TerminalReporter implements Reporter {
|
||||
out.push("");
|
||||
}
|
||||
|
||||
const setupNotes = review.setupNotes ?? [];
|
||||
if (setupNotes.length > 0) {
|
||||
out.push(this.paint(BOLD, "🔗 Review setup:"));
|
||||
for (const note of setupNotes) {
|
||||
out.push(this.paint(DIM, ` - ${note}`));
|
||||
}
|
||||
out.push("");
|
||||
}
|
||||
|
||||
if (review.findings.length === 0) {
|
||||
out.push(this.paint(DIM, "No findings."), "");
|
||||
} else {
|
||||
|
||||
+25
-71
@@ -116,47 +116,6 @@ export function parseChildFileNdjson(stdout: string): string[] {
|
||||
.filter((name) => name.length > 0 && ![...name].some((char) => char.charCodeAt(0) < 0x20));
|
||||
}
|
||||
|
||||
/** Page size for the child-PR files endpoint (fetchAllComments convention). */
|
||||
export const CHILD_FILES_PER_PAGE = 100;
|
||||
|
||||
/**
|
||||
* Safety cap on pagination, same convention as the reporter's MAX_COMMENT_PAGES:
|
||||
* 30 pages = 3000 files bounds a pathological child PR; virtually every real
|
||||
* child PR exits far earlier via the maxFiles early stop below.
|
||||
*/
|
||||
export const MAX_CHILD_FILE_PAGES = 30;
|
||||
|
||||
/**
|
||||
* Collect a child PR's file pages, factored pure over an injected per-page fetcher
|
||||
* (same pattern as walkUpstack) so the stop conditions are testable without gh.
|
||||
* Stops at end-of-list, one entry past `maxFiles` (enough to know the list is
|
||||
* truncated — never paginates a huge child PR to the end just to throw the tail
|
||||
* away), or the hard page ceiling. Exported for tests.
|
||||
*/
|
||||
export async function collectChildFiles(
|
||||
fetchPage: (page: number) => Promise<string>,
|
||||
maxFiles: number,
|
||||
): Promise<StackChildFiles> {
|
||||
const files: string[] = [];
|
||||
let sawEnd = false;
|
||||
for (let page = 1; page <= MAX_CHILD_FILE_PAGES && !sawEnd; page++) {
|
||||
const stdout = await fetchPage(page);
|
||||
// "Last page?" is decided on the RAW line count (jq emits exactly one NDJSON
|
||||
// line per array element): parseChildFileNdjson drops control-char names, so
|
||||
// deciding on its output would mistake a page with a dropped entry for the
|
||||
// final page and silently skip the rest of the list.
|
||||
const rawCount = stdout.split("\n").filter((line) => line.trim()).length;
|
||||
files.push(...parseChildFileNdjson(stdout));
|
||||
sawEnd = rawCount < CHILD_FILES_PER_PAGE;
|
||||
if (files.length > maxFiles) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Hitting the page ceiling without seeing the end of the list still marks the
|
||||
// manifest as a subset — never claim completeness that wasn't observed.
|
||||
return { files: files.slice(0, maxFiles), truncated: files.length > maxFiles || !sawEnd };
|
||||
}
|
||||
|
||||
/**
|
||||
* Append gh as a git credential helper for a single command. The token comes from
|
||||
* GH_TOKEN via the credential-helper protocol — never argv, never `.git/config` —
|
||||
@@ -494,42 +453,37 @@ export class GitHubPRSource implements ReviewSource {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* A child PR's changed paths, capped at `maxFiles` with a truncated marker.
|
||||
* Pages are fetched one by one (not `--paginate`, which would walk a large
|
||||
* child PR's whole file list before the client-side cap applies) so pagination
|
||||
* stops as soon as the cap is exceeded, and never past MAX_CHILD_FILE_PAGES.
|
||||
*/
|
||||
/** A child PR's changed paths, capped at `maxFiles` with a truncated marker. */
|
||||
private async fetchChildFiles(
|
||||
gh: string,
|
||||
repo: string,
|
||||
prNumber: number,
|
||||
maxFiles: number,
|
||||
): Promise<StackChildFiles> {
|
||||
return collectChildFiles(async (page) => {
|
||||
const { stdout } = await run(
|
||||
gh,
|
||||
[
|
||||
"api",
|
||||
// --method GET is mandatory once a -f field is present (else gh POSTs).
|
||||
"--method",
|
||||
"GET",
|
||||
`repos/${repo}/pulls/${prNumber}/files`,
|
||||
"-f",
|
||||
`per_page=${CHILD_FILES_PER_PAGE}`,
|
||||
"-f",
|
||||
`page=${page}`,
|
||||
"--jq",
|
||||
// Objects, NOT raw strings (.[].filename): gh prints a raw string result
|
||||
// one value per line, so a git path containing a newline would split into
|
||||
// TWO manifest entries — one of them a forged membership the grounding
|
||||
// check would then accept. NDJSON keeps the newline escaped.
|
||||
".[] | {filename}",
|
||||
],
|
||||
{ cwd: this.options.cwd },
|
||||
);
|
||||
return stdout;
|
||||
}, maxFiles);
|
||||
const { stdout } = await run(
|
||||
gh,
|
||||
[
|
||||
"api",
|
||||
// --method GET is mandatory once a -f field is present (else gh POSTs).
|
||||
"--method",
|
||||
"GET",
|
||||
`repos/${repo}/pulls/${prNumber}/files`,
|
||||
// 100/page (fetchAllComments convention): a 3000-file child PR is ~30
|
||||
// round-trips instead of ~100 at the REST default of 30/page.
|
||||
"-f",
|
||||
"per_page=100",
|
||||
"--paginate",
|
||||
"--jq",
|
||||
// Objects, NOT raw strings (.[].filename): gh prints a raw string result
|
||||
// one value per line, so a git path containing a newline would split into
|
||||
// TWO manifest entries — one of them a forged membership the grounding
|
||||
// check would then accept. NDJSON keeps the newline escaped.
|
||||
".[] | {filename}",
|
||||
],
|
||||
{ cwd: this.options.cwd },
|
||||
);
|
||||
const all = parseChildFileNdjson(stdout);
|
||||
return { files: all.slice(0, maxFiles), truncated: all.length > maxFiles };
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -39,10 +39,7 @@ must support `--non-interactive` the way sibling commands do (a non-interactive
|
||||
path with no prompts, erroring clearly when a required value is missing), and it
|
||||
must expose flags to supply every prompted value so the command stays scriptable.
|
||||
|
||||
<!-- TODO: replace the example above with this repo's most important conventions.
|
||||
Pin each file, directory, or symbol you cite with a ref on its own line —
|
||||
@ref <path/to/file.ts>#<symbol> — why this matters
|
||||
so `ecr ref-check` fails when the cited code moves. Never a line number. -->
|
||||
<!-- TODO: replace the example above with this repo's most important conventions. -->
|
||||
|
||||
## What NOT to flag
|
||||
|
||||
|
||||
@@ -19,13 +19,7 @@ issues in the changed code.
|
||||
concrete trigger.
|
||||
|
||||
<!-- TODO: customize for this repo — add project-specific correctness rules,
|
||||
e.g. framework conventions, required flag handling, API compatibility.
|
||||
|
||||
Cite real code, and pin every citation with a ref so `ecr ref-check` fails when
|
||||
it moves. In a comment of its own, on one line:
|
||||
@ref <path/to/file.ts>#<symbol> — why this matters
|
||||
Targets: a file, a `<dir>/`, `glob:<pattern>`, `<file>#<symbol>`, `<doc>.md#<heading>`.
|
||||
Never a line number. Not a path? `@ref-ignore <token>`. -->
|
||||
e.g. framework conventions, required flag handling, API compatibility. -->
|
||||
|
||||
## What NOT to flag
|
||||
|
||||
|
||||
@@ -26,14 +26,7 @@ average severity.
|
||||
- Insecure file permissions, or writing secrets to world-readable paths.
|
||||
|
||||
<!-- TODO: customize for this repo — name the sensitive surfaces specific to this
|
||||
codebase (credential stores, tokens, arbitrary-command features, etc.).
|
||||
|
||||
Pin every path or symbol you cite with a ref, on a line of its own:
|
||||
@ref <path/to/file.ts>#<symbol> — why this matters
|
||||
`ecr ref-check` then fails when that code moves, so this prompt never sends a
|
||||
reviewer after a file that no longer exists. Never cite a line number. -->
|
||||
|
||||
<!-- @ref glob:.github/workflows/** — the workflows this section judges -->
|
||||
codebase (credential stores, tokens, arbitrary-command features, etc.). -->
|
||||
|
||||
## CI / workflow supply-chain (changes under `.github/workflows/**`)
|
||||
|
||||
|
||||
@@ -12,9 +12,6 @@ These rules apply to every reviewer and are concatenated onto your role prompt.
|
||||
- **Do not judge the diff in isolation.** Before reporting, read the surrounding
|
||||
source with your file/read/grep tools and trace the relevant execution path.
|
||||
If you cannot substantiate a concrete failure or exploit path, do not report it.
|
||||
<!-- Generic guidance, not a claim that either file exists. Once this repo has one,
|
||||
replace this with a real ref: @ref AGENTS.md — the conventions to judge against -->
|
||||
<!-- @ref-ignore AGENTS.md CLAUDE.md -->
|
||||
- Ground your judgment in the repo's own conventions (`AGENTS.md` / `CLAUDE.md`
|
||||
at the repo root, and any per-directory guidance) rather than generic
|
||||
best-practices.
|
||||
|
||||
Reference in new issue
Block a user