done-done-axi 0.6.15 → 0.6.16

package/dist/cli.js

@@ -281,7 +281,7 @@ each prints the files it changed and runs the journey once as a dirty-tree trial
   when the repo (the current folder) has none; repro is not n/a on a fix PR. evidence names files in the evidence folder (or absolute):
   each exists, is non-empty and is newer than the folder itself; no two are byte-identical; at least one has a hash no other PR used
   (hash store lint.hashes in ~/.done-done, or $DONE_DONE_HOME). "evidence: not proven: <cause>" passes. A PR with 1,000 or more added
-  non-generated lines fails (lockfiles, vendor/, dist/, LICENSE-type files, deletions and moved lines do not count); a bot PR passes.
+  non-generated lines fails; the whole PR is counted (every page of its file list, its compare diff), and a failed page or diff fails instead of counting part of it (lockfiles, vendor/, dist/, LICENSE-type files, deletions and moved lines do not count); a bot PR passes.
   A PR URL whose diff changes a src/ file and no journeys/ file prints WARN instead of PASS (still exit 0): run the journey and commit it before the PR opens.
   In .done-done.yaml, checks.upstream_catch_up: true also drops a fork's upstream catch-up lines, and checks.moved_from: true drops lines
   a "moved-from: <owner>/<repo>@<ref> <dst>=<src>" body line says came from a repo of the same owner; both are off by default.

package/dist/lint.js

@@ -61,6 +61,34 @@ function without(a, b) {
 }
 const total = (n) => [...n.values()].reduce((sum, c) => sum + c, 0);
 const stdout = (r) => (r.status === 0 ? r.stdout.trim() : '');
+const worst = (r) => r.stderr.trim().split('\n').pop()?.slice(0, 160) || '?';
+// `gh pr view --json files` stops at 100 files, so the whole list comes from the paginated pull-files endpoint instead.
+// GitHub stops that endpoint at 3000 files, so page 30 being full is already past what it will list.
+const MAX_PAGES = 30;
+function prFiles(run, nwo, num) {
+    const paths = [];
+    for (let page = 1; page <= MAX_PAGES; page++) {
+        const call = `repos/${nwo}/pulls/${num}/files?per_page=100&page=${page}`;
+        const r = run('api', call);
+        if (r.status)
+            return { why: `${call} failed: ${worst(r)}` };
+        let files;
+        try {
+            files = JSON.parse(r.stdout);
+        }
+        catch {
+            return { why: `${call} returned no file list` };
+        }
+        if (!Array.isArray(files))
+            return { why: `${call} returned no file list` };
+        for (const f of files)
+            if (f.path)
+                paths.push(f.path);
+        if (files.length < 100)
+            return { paths };
+    }
+    return { why: `${nwo}/pulls/${num}/files is still full on page ${MAX_PAGES}: more files than lint can count` };
+}
 // checks.upstream_catch_up: lines the fork's parent repo already shipped are not authored here, so subtract the upstream delta the PR
 // merges in (PR base ... the merge base with the parent's default branch). A plain fork PR merges no new upstream commit, so its delta
 // is empty. Any API failure keeps the full count.
@@ -107,9 +135,9 @@ export function lint(src, ev, dir, rules = {}, run = gh) {
         task = basename(dirname(resolve(src)));
     }
     else {
-        const r = run('pr', 'view', src, '--json', 'author,body,title,files,headRefOid,headRefName,baseRefOid');
+        const r = run('pr', 'view', src, '--json', 'author,body,title,headRefOid,headRefName,baseRefOid');
         if (r.status)
-            return log({ ok: false, why: `gh pr view failed: ${r.stderr.trim().split('\n').pop()?.slice(0, 160) || '?'}`, head });
+            return log({ ok: false, why: `gh pr view failed: ${worst(r)}`, head });
         const pr = JSON.parse(r.stdout);
         ({ body, title } = { body: pr.body ?? '', title: pr.title ?? '' });
         head = pr.headRefOid ?? '-';
@@ -118,26 +146,31 @@ export function lint(src, ev, dir, rules = {}, run = gh) {
         if (/^(app\/)?(dependabot|renovate)(\[bot\])?$/.test(author))
             return log({ ok: true, why: 'bot', head });
         const nwo = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\//.exec(src)?.[1];
-        const attrs = nwo && [head, pr.baseRefOid].map((ref) => ref && run('api', '-H', 'Accept: application/vnd.github.raw', `repos/${nwo}/contents/.gitattributes?ref=${ref}`)).find((a) => a && a.status === 0);
+        const num = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/.exec(src)?.[1];
+        if (!nwo || !num)
+            return log({ ok: false, why: `not a GitHub pull URL: ${src.slice(0, 120)}`, head });
+        const listed = prFiles(run, nwo, num);
+        if (!listed.paths)
+            return log({ ok: false, why: listed.why ?? 'the pull file list failed', head });
+        const paths = listed.paths;
+        const attrs = [head, pr.baseRefOid].map((ref) => ref && run('api', '-H', 'Accept: application/vnd.github.raw', `repos/${nwo}/contents/.gitattributes?ref=${ref}`)).find((a) => a && a.status === 0);
         if (attrs) {
             const byAttr = attrGenerated(attrs.stdout);
             isGenerated = (p) => byConfig(p) || byAttr(p);
         }
-        const paths = (pr.files ?? []).map((f) => f.path ?? '');
         if (paths.some((p) => p.startsWith('src/')) && !paths.some((p) => p.startsWith('journeys/')))
             warn = 'the diff changes src/ and no journeys/ file: run the journey, commit it, then open the PR';
-        let size = (pr.files ?? []).reduce((n, f) => n + (isGenerated(f.path ?? '') ? 0 : f.additions ?? 0), 0);
-        if (size >= SIZE_LIMIT) {
-            const d = run('pr', 'diff', src);
-            if (!d.status) {
-                let net = netLines(d.stdout, isGenerated);
-                if (nwo && rules.upstream_catch_up && total(net) >= SIZE_LIMIT)
-                    net = without(net, upstreamDelta(run, nwo, head, pr.baseRefOid ?? '', isGenerated));
-                if (nwo && rules.moved_from && total(net) >= SIZE_LIMIT)
-                    net = without(net, movedLines(run, nwo, body, (pr.files ?? []).map((f) => f.path ?? ''), isGenerated));
-                size = total(net);
-            }
-        }
+        // The PR's whole net comes from the compare diff (three dots: from the merge base), never from the per-file additions.
+        const cmp = `repos/${nwo}/compare/${pr.baseRefOid ?? ''}...${head}`;
+        const d = run('api', '-H', 'Accept: application/vnd.github.diff', cmp);
+        if (d.status)
+            return log({ ok: false, why: `${cmp} failed: ${worst(d)}`, head });
+        let net = netLines(d.stdout, isGenerated);
+        if (rules.upstream_catch_up && total(net) >= SIZE_LIMIT)
+            net = without(net, upstreamDelta(run, nwo, head, pr.baseRefOid ?? '', isGenerated));
+        if (rules.moved_from && total(net) >= SIZE_LIMIT)
+            net = without(net, movedLines(run, nwo, body, paths, isGenerated));
+        const size = total(net);
         if (size >= SIZE_LIMIT)
             return log({ ok: false, why: `${size} added non-generated lines (moved lines excluded): split it (limit ${SIZE_LIMIT})`, head });
     }

package/docs/reference.md

@@ -314,7 +314,7 @@ journeys:
 
 ### Lint check
 
-`done-done lint <PR URL | report file> <evidence folder>` is a deterministic gate on a worker's claim: no judge, no model, and the project config only switches on two optional size rules. It prints `PASS`, `WARN: <reason>` or `FAIL: <reason>` and exits 0 (PASS or WARN), 1, or 2 on a usage error. A PR URL is read with `gh pr view`; a file is read as the report.
+`done-done lint <PR URL | report file> <evidence folder>` is a deterministic gate on a worker's claim: no judge, no model, and the project config only switches on two optional size rules. It prints `PASS`, `WARN: <reason>` or `FAIL: <reason>` and exits 0 (PASS or WARN), 1, or 2 on a usage error. A PR URL is read with `gh pr view` and `gh api`; a file is read as the report.
 
 - The newest `## Checks` block needs `outcome:`, `repro:`, `proof:` and `evidence:`.
 - `proof:` names a command or path, and the repo's `done-done-verify-<app>` skill (a legacy `verify-<app>` skill is read too); it may say `no verify skill` only when `.agents/skills/` in the current folder holds none.
@@ -322,8 +322,8 @@ journeys:
 - `evidence: not proven: <cause>` passes.
 - A PR URL whose changed files include one under `src/` and none under `journeys/` prints `WARN` instead of `PASS` (exit 0; a `FAIL` still wins). It needs no config and never applies to a report file. The worker rule it backs: run the journey, commit it, then open the PR.
 - Otherwise each named file (relative to the evidence folder, or absolute) exists, is non-empty and is newer than the evidence folder itself; no two are byte-identical; and at least one has a hash no other PR used. Hashes are kept in `lint.hashes` and each run is appended to `lint.log`, both in `~/.done-done` (`$DONE_DONE_HOME`). A later lint of the same PR is not reuse.
-- A PR with 1,000 or more added non-generated lines fails. Lockfiles, `vendor/`, `dist/` and `LICENSE`-type files do not count, and neither do deletions or lines moved between files. A dependabot or renovate PR passes.
-- Two optional size rules, both off by default and switched on per repo in `.done-done.yaml` (read from the current folder; they apply to a PR URL, never a report file). With both off a big PR is counted exactly as above. Each runs only when the PR is still at 1,000 lines, and an API failure keeps the full count.
+- A PR with 1,000 or more added non-generated lines fails. The whole PR is counted: its file list comes from every page of `pulls/<number>/files` (100 a page, up to GitHub's 3,000-file ceiling) and its net lines from the compare diff from the merge base, so a PR of any size is counted whole. Lockfiles, `vendor/`, `dist/` and `LICENSE`-type files do not count, and neither do deletions or lines moved between files. A dependabot or renovate PR passes. A page of the file list or the compare diff that fails makes lint `FAIL` with that call, never a partial count.
+- Two optional size rules, both off by default and switched on per repo in `.done-done.yaml` (read from the current folder; they apply to a PR URL, never a report file). With both off a big PR is counted exactly as above. Each runs only when the PR is still at 1,000 lines.
   - `checks.upstream_catch_up: true`: in a fork, lines the parent repo already shipped are not authored here, so lint subtracts the changes between the PR's base and the merge base with the parent's default branch. A PR that merges in no new upstream commit loses nothing.
   - `checks.moved_from: true`: a line in the PR body `moved-from: <owner>/<repo>@<ref> <dst-prefix>=<src-prefix>` (more `dst=src` pairs may follow) cancels added lines that match, byte for byte after trimming, the file at the same path under `<src-prefix>` in that repo at `<ref>`. The source repo must have the PR's owner; authored lines still count.
   - `checks.generated_paths: ["gen/**", "*.snap"]`: globs for the repo's own generated files, counted as generated beside the built-in ones above, so they stay out of the size count. Default none, so results do not change. Like the two rules above it applies to a PR URL, never a report file.

package/docs/releasing.md

@@ -1,5 +1,5 @@
-# 0.6.15 patch release
+# 0.6.16 patch release
 
-This release carries the audited README to the npm page: the hero GIF opens on the finished screen, the four lower terminal pictures sit one per row at one width, and the journey and Firstmate commands wrap so no line is clipped in the README column.
+This release counts a PR whole, however many files it touches. `lint` reads every page of the PR's file list (GitHub gives `gh pr view` only the first 100 files) and takes its net lines from the compare diff, so a PR over 100 files no longer gets a line count from its first 100 — one 408-file PR was counted as 6,198 added lines when its real net was about 688. The moved-from exclusion, the generated-file rules and the `journeys/` warning now see the whole list, and a failed page or compare diff fails the lint with that call instead of keeping a partial count.
 
-Do not publish an unmerged candidate. The existing `release` workflow on main tests and publishes an unpublished package version using npm trusted publishing. After merge, confirm `npm view done-done-axi@0.6.15 version dist.integrity` and smoke-test a clean `npx` install with `done-done --version`. Do not run `npm publish` manually unless the workflow fails and the release is blocked; if so, stop and report.
+Do not publish an unmerged candidate. The existing `release` workflow on main tests and publishes an unpublished package version using npm trusted publishing. After merge, confirm `npm view done-done-axi@0.6.16 version dist.integrity` and smoke-test a clean `npx` install with `done-done --version`. Do not run `npm publish` manually unless the workflow fails and the release is blocked; if so, stop and report.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "done-done-axi",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "license": "Apache-2.0",
   "description": "Prove your app really works: done-done drives your app the way a user does, a fresh judge checks every capture, and the proof is tied to a commit.",
   "type": "module",