@juangadm/pre-post 1.0.0 → 1.2.0

package/README.md

@@ -1,9 +1,35 @@
 # pre-post
 
 Before/after screenshots for pull requests. One command detects the routes your branch
-changed, captures them on production ("Pre") and on your dev server ("Post"), pixel-diffs
-them, uploads the images to GitHub, and posts a single comment on the PR that a reviewer
-can judge at a glance.
+changed, captures each one before and after, uploads the images to GitHub, and puts them at
+the top of the PR description where a reviewer can judge them at a glance.
+
+It works out both sides itself, cheapest option first:
+
+| | Pre (the baseline) | Post (this branch) |
+|---|---|---|
+| 1 | `--before` | `--after` |
+| 2 | `before` in `.pre-post.json` | the preview deployment for this commit |
+| 3 | the production deployment for the base commit | a local dev server |
+| 4 | whatever is on production now | |
+| 5 | the base commit, served locally | |
+
+Rows 2 to 4 need no dev environment at all, which is the point: a preview deployment and a
+production URL are enough for anyone who can open the PR. Deployments come from the GitHub
+Deployments API, so Vercel, Cloudflare Pages, Netlify and Render all work with no extra
+token and nothing to configure; a host that records only a commit status is read from the
+deployment bot's own PR comment instead. Row 4 covers repositories that do not deploy every
+push to their default branch, so nothing is deployed at the fork point — it prints which
+commit Pre actually came from rather than implying the base.
+
+pre-post never guesses a baseline. If no deployment can be found it says so and tells you
+the one flag that fixes it, because a baseline that is quietly the wrong site reads as 100%
+changed on every route and looks exactly like a real result.
+
+The last baseline needs no network at all: it checks the base commit into a throwaway
+worktree and boots its dev script. That keeps pre-post working inside a sandboxed agent
+container, a CI job, or behind an egress allowlist — and it compares against exactly what
+the branch forked from, rendered in the same browser as the Post side.
 
 > Originally forked from [before-and-after](https://github.com/vercel-labs/before-and-after) by James Clements / Vercel Labs.
 
@@ -19,34 +45,62 @@ Capturing 8 screenshots (2 route(s) × 2 viewport(s)) ...
   same     / @ mobile (0.00%, 1990ms)
   same     / @ desktop (0.00%, 2211ms)
 Publishing 10 image(s) to acme/web@pre-post-assets ...
-Updated PR comment: https://github.com/acme/web/pull/42#issuecomment-1
+Updated PR description: https://github.com/acme/web/pull/42
 pre-post · PR #42 · 2 route(s) · 2 viewport(s) · 6.8s
   /         desktop  no change
   /         mobile   no change
   /pricing  desktop  0.64% changed
   /pricing  mobile   1.4% changed
-Comment: https://github.com/acme/web/pull/42#issuecomment-1
+Comment: https://github.com/acme/web/pull/42
 ```
 
 ## How it works
 
-1. **Routes.** Diffs the branch against the merge base with `main`, then follows the import
+1. **Routes.** Diffs the branch against the merge base with `main` — fetching that branch
+   first when the checkout does not have it, which is the normal shape in CI and in the
+   web/sandbox editors. When no shared history can be established it stops with one
+   sentence rather than reporting an empty diff, and `--base <ref>` names the commit
+   directly. Then it follows the import
    graph: a change to `components/ui/button.tsx` marks every page that imports it. Next.js
    App Router and Pages Router, Vite apps (React Router, file-based `src/pages`), and a
    generic fallback. Monorepos are handled by picking the app that owns the changed files.
-2. **Capture.** Playwright + Chromium headless shell. Fixed clock, reduced motion,
-   animations finished, caret hidden, fonts and images settled, layout stable across frames,
-   lazy content primed. 2x device scale, full page (capped at 2400 CSS px), desktop + mobile.
+2. **Capture.** Playwright + Chromium headless shell. The page's own clock is held
+   still while it loads and then run forward by a fixed budget, so a page that animates
+   on a timer is photographed at the same frame on both sides however fast each host
+   answered. Reduced motion, animations finished, caret hidden, fonts and images settled,
+   layout stable, lazy content primed. 2x device scale, full page (capped at 2400 CSS
+   px), desktop (add mobile with `-r`).
    All routes and viewports run concurrently.
 3. **Diff.** Pure-JS pixel comparison in worker threads. Reports the percentage changed,
-   the bounding box, a red-highlight image, and a tight crop of the changed region.
-4. **Publish.** Images go to a `pre-post-assets` branch in the same repository via the GitHub
+   the bounding box, and a tight crop of the changed region. A route counts as changed when
+   the painted difference covers at least `minChangedArea` CSS pixels² (default 100, roughly
+   a third of a 16px icon) or at least `threshold` of the canvas — the first rule is what
+   decides on a page, the second on a small image.
+4. **Layout shift.** A padding change near the top of a page moves everything below it, and
+   pixel diffing counts every moved pixel as changed: a change a designer would call
+   "slightly roomier" reads as most of the page repainted, and the crop is suppressed just
+   when it would be most useful. So the two sides are checked for a single vertical offset
+   first — how far the content moved, and from which row. When one is found, Pre is re-spaced
+   into Post's layout and the two are compared there: the crop comes from that pair, and the
+   comment says `Content shifted down 48px` instead of quoting a percentage. Rows Post gained
+   are left as background rather than skipped, so content inserted above the shift — the
+   banner that caused it — still reads as new rather than as nothing. The offset is only
+   accepted when it accounts for most of the difference across the rows both sides share.
+   The raw numbers are left alone: a move is a visual change, and reporting less of one would
+   hide it. Reflow, where content moves both across and down, has no single offset to find,
+   so it is reported the way it always was.
+5. **Publish.** Images go to a `pre-post-assets` branch in the same repository via the GitHub
    API, as one commit per run. Nothing is committed to the PR branch, no CI is triggered,
-   and the blob URLs render on private repos. `pre-post prune` removes images for PRs
-   closed more than 90 days ago.
-5. **Comment.** One sticky comment per PR, updated in place on every run. Changed routes show
-   a Pre/Post crop with the full page and diff collapsed underneath; unchanged routes fold
-   into a single line.
+   and the blob URLs render on private repos — a screenshot is visible to exactly whoever
+   can see the repository. `pre-post prune` removes images for PRs closed more than 90 days
+   ago, but note that it commits a deletion rather than rewriting history: the older commits
+   still hold the blobs, so a link handed out earlier keeps working. Treat anything captured
+   as permanent, and think twice before pointing pre-post at a preview holding real data.
+6. **Describe.** The images go in a delimited block at the top of the PR description,
+   replaced in place on every run and leaving your own text untouched. Changed routes show
+   a Pre/Post crop with the full page collapsed underneath; unchanged routes fold into a
+   single line. If the PR cannot be edited — a fork, a read-only token — it falls back to
+   one sticky comment.
 
 ## Install
 
@@ -66,7 +120,8 @@ Then say `/pre-post` after making UI changes.
 
 ```bash
 pre-post pr                                  # everything, on the current branch's PR
-pre-post pr --before https://acme.com        # first run in a repo (saved to .pre-post.json)
+pre-post pr --before https://acme.com        # pin the baseline (saved to .pre-post.json)
+pre-post pr --no-local-baseline              # never build the base commit locally
 pre-post pr --routes /pricing,/docs          # explicit routes
 pre-post pr --viewports desktop,1440x900     # custom viewports
 pre-post pr --dry-run                        # capture + diff locally, post nothing
@@ -83,6 +138,24 @@ pre-post doctor                              # browser, token, dev server, confi
 When something needs a human, the CLI exits with code 3 and one sentence saying what to do
 (log in, start the dev server, pass `--before`). Re-running picks up where it left off.
 
+Exit codes, so a script or an agent can branch on them:
+
+| code | meaning |
+|---|---|
+| 0 | done; for `doctor`, `pre-post pr` can run |
+| 1 | the run failed — every capture errored, or an unexpected error; for `doctor`, a required check failed |
+| 2 | the arguments could not be parsed |
+| 3 | something needs a human; the message says what |
+
+`doctor` marks a check **FAIL** only when `pre-post pr` has no way to proceed without it —
+the browser, a GitHub token, and being inside a git repository. Everything else prints as
+**note**: no dev server running, or no `--before` saved, narrows *which* strategy a run
+picks rather than stopping it, so those never change the exit code.
+
+Results go into a delimited block at the top of the PR description, which re-runs replace in
+place, leaving your own text untouched. If the PR cannot be edited — a fork, a read-only
+token — it falls back to a single sticky comment.
+
 ## Configuration
 
 Optional `.pre-post.json` in the repo root:
@@ -92,12 +165,12 @@ Optional `.pre-post.json` in the repo root:
   "before": "https://acme.com",
   "routes": ["/"],
   "samples": { "/blog/[slug]": "/blog/hello-world" },
-  "viewports": ["desktop", "mobile"],
+  "viewports": ["desktop"],
   "fullPage": true,
   "maxHeight": 2400,
   "scale": 2,
   "threshold": 0.001,
-  "minChangedPixels": 40,
+  "minChangedArea": 100,
   "maxRoutes": 6,
   "ignore": ["apps/docs"],
   "headers": {},
@@ -110,7 +183,7 @@ Environment:
 | Variable | Purpose |
 |---|---|
 | `GH_TOKEN` / `GITHUB_TOKEN` | GitHub token (default: `gh auth token`) |
-| `VERCEL_AUTOMATION_BYPASS_SECRET` | Bypass Vercel Deployment Protection on the production URL |
+| `VERCEL_AUTOMATION_BYPASS_SECRET` | Bypass Vercel Deployment Protection on preview and production URLs |
 | `PRE_POST_CONCURRENCY` | Parallel pages (default 6) |
 | `PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH` | Use a specific Chromium binary |
 | `GH_REPO` | `owner/repo` when the remote URL cannot be parsed |
@@ -130,6 +203,12 @@ pnpm test:unit
 TEST_BROWSER=true pnpm test        # needs a Chromium; npx playwright-core install chromium-headless-shell
 ```
 
+pnpm and npm cannot share a `node_modules`. pnpm builds a symlinked tree that npm
+cannot read, so `npm install` over it fails with `Cannot read properties of null
+(reading 'edgesOut')`, which names none of that. Run `rm -rf node_modules
+site/node_modules` before switching either way. npm also installs the CLI only —
+`site/` is a pnpm workspace member, so use pnpm to work on the site.
+
 ## License
 
 MIT

package/dist/baseline.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Serve the PR's base commit locally, as the "Pre" side.
+ *
+ * This is the baseline that always works: it needs no deployment, no
+ * production URL and no network, so it is what keeps pre-post usable inside a
+ * sandbox — a cloud agent container, a CI job, or any box behind an egress
+ * allowlist. It is also the most honest comparison available, because both
+ * sides then render in the same environment with the same fonts and the same
+ * browser, leaving the diff as the only variable.
+ *
+ * The cost is time: a checkout, an install and a dev-server boot. So callers
+ * reach for it after a reachable deployment, not before one.
+ */
+import { NeedsHumanError } from './errors.js';
+export interface LocalBaseline {
+    url: string;
+    /** Stop the dev server and delete the worktree. Safe to call twice. */
+    stop: () => Promise<void>;
+}
+interface PackageManager {
+    bin: string;
+    install: string[];
+    /** Build `run <script>` argv, appending extra args the way this manager wants. */
+    run: (script: string, args: string[]) => string[];
+    /**
+     * A second install to try, and the failure that earns it — or undefined when
+     * this manager has no looser mode.
+     *
+     * Both halves together, because apart they drift: a predicate matching npm's
+     * `ERESOLVE` sitting at module scope would be applied to whichever managers
+     * happened to have a retry argv, which is right today only because npm is
+     * the only one that does.
+     *
+     * Only npm needs one. npm 7+ treats a peer range as a hard constraint and
+     * aborts the whole install over a single lagging package; pnpm, yarn and bun
+     * warn and carry on. A React 19 app with one dependency whose peer range
+     * still says <=18 is an ordinary, temporary state of a real repository — and
+     * it took the local baseline, the fallback that is supposed to always work,
+     * down with it.
+     */
+    retry?: {
+        argv: string[];
+        when: (output: string) => boolean;
+    };
+}
+/**
+ * Which package manager this tree *declares*, from its `packageManager` field
+ * or its lockfile. Defaults to npm.
+ *
+ * The field wins over the lockfile because it is the deliberate statement: a
+ * repository mid-migration can carry two lockfiles, but it names one manager.
+ */
+export declare function detectPackageManager(dir: string, repoRoot?: string): PackageManager;
+/**
+ * Is `bin` runnable here?
+ *
+ * A PATH scan rather than a `--version` subprocess: this answers before every
+ * local baseline, and spawning a process to learn that a process cannot be
+ * spawned is the wrong shape.
+ */
+export declare function onPath(bin: string, env?: NodeJS.ProcessEnv): boolean;
+export interface ManagerChoice {
+    /** The manager to run, or null when neither it nor npm is installed here. */
+    pm: PackageManager | null;
+    /** What the repository declares. Differs from `pm` when we fell back. */
+    declared: PackageManager;
+}
+/**
+ * The manager to actually run: what the repository declares, if it is installed.
+ *
+ * Declaring pnpm does not put pnpm on PATH. On a real machine it was not there,
+ * and the local baseline — the fallback that exists for when nothing is
+ * deployed — died on `pnpm install` with no hint that the missing piece was
+ * pnpm itself. The same shell could still build the CLI, so the tool ran while
+ * its last resort could not.
+ *
+ * npm ships with Node, so it is the fallback with the best odds of being
+ * present. It will not honour a pnpm or yarn lockfile, so the baseline it
+ * installs can drift from the locked versions — worth saying out loud, and
+ * still far better than no baseline at all.
+ */
+export declare function resolvePackageManager(dir: string, repoRoot?: string, has?: (bin: string) => boolean): ManagerChoice;
+/**
+ * The directory to actually serve.
+ *
+ * The app root is detected from the files a branch changed, which answers
+ * "which routes moved" — not "which package can be served". A PR touching only
+ * the CLI resolves to the repo root, which has no dev script even though the
+ * site next door does. So prefer the detected directory and otherwise take the
+ * nearest package that can start a server.
+ */
+export declare function servableDir(treeRoot: string, appPrefix?: string): {
+    dir: string;
+    script: string;
+} | null;
+/**
+ * Copy the working checkout's local env files into a throwaway worktree.
+ *
+ * .env files are gitignored, so a fresh worktree of the base commit has none.
+ * An app that needs one to boot then either never starts or serves an error
+ * page — and an error page diffed against the real branch reports a wall of
+ * changes the PR never made, which is worse than reporting no baseline at all.
+ *
+ * Only ever writes inside `to`, and returns names, never values: these files
+ * are exactly the ones that hold secrets.
+ */
+export declare function copyEnvFiles(from: string, to: string, appPrefix?: string): string[];
+/** An OS-assigned free port. */
+export declare function freePort(): Promise<number>;
+/**
+ * How a package manager's install ended, and what it said.
+ *
+ * The output is kept because it is the only thing that can answer "why". The
+ * old path discarded it (`stdio: 'ignore'`) and told the reader to run the
+ * install themselves in their checkout — advice that could not reproduce the
+ * failure, because the install had run in a throwaway worktree that was
+ * already deleted by the time they read it.
+ */
+export interface InstallAttempt {
+    argv: string[];
+    ok: boolean;
+    /** The tail of the manager's own stdout+stderr. */
+    output: string;
+}
+export interface InstallResult {
+    ok: boolean;
+    /** In order. Length 2 when a first failure earned a retry. */
+    attempts: InstallAttempt[];
+}
+export type InstallRunner = (bin: string, argv: string[], cwd: string, timeoutMs: number) => InstallAttempt;
+/**
+ * Does this look like npm refusing to resolve a peer range?
+ *
+ * Matched on npm's own error code rather than on prose, so it does not depend
+ * on the wording of a given npm release. The second pattern is the same
+ * failure as reported by older npm, which does not always print the code.
+ */
+export declare function isPeerConflict(output: string): boolean;
+/**
+ * Install this app's dependencies, retrying once past a peer-dependency wall.
+ *
+ * The retry is deliberately narrow: only on the specific failure that a looser
+ * resolver would not have had, and only for a manager that has a looser mode.
+ * A baseline installed with `--legacy-peer-deps` is not a perfect reproduction
+ * of the branch's own install — but the alternative is no baseline at all, and
+ * the comparison this tool exists to make is between two renders of the same
+ * app, not between two dependency trees.
+ */
+export declare function installDeps(pm: PackageManager, cwd: string, timeoutMs: number, run?: InstallRunner): InstallResult;
+/**
+ * The install failed and nothing else can rescue this run.
+ *
+ * Its own error rather than a quiet null, for the reason docs/portability.md
+ * §1 gives about base resolution: a run that compared nothing must not exit
+ * clean. A null here fell through to "no baseline", and on a repository with a
+ * configured production URL it fell through to comparing against that instead
+ * — a different answer to a different question, published as if it were this
+ * one.
+ */
+/**
+ * What a reader has to do about a failed install, in one sentence.
+ *
+ * One sentence because that is what `NeedsHumanError` is for (AGENTS.md): the
+ * CLI prints the whole message for exit 3, so pasting a screen of package
+ * manager output here would bury the instruction inside it. The output is
+ * still the thing that answers "why", so it goes to the log instead — above
+ * this line, where it reads as diagnostics rather than as the remedy.
+ *
+ * The command names the caller's own directory, never the worktree: by the
+ * time anyone reads this, cleanup has deleted the worktree, so telling them to
+ * run it there would be an instruction they cannot follow.
+ */
+export declare function installFailureHint(where: string, ranIn: string): string;
+export declare class BaselineInstallError extends NeedsHumanError {
+    readonly result: InstallResult;
+    constructor(result: InstallResult, where: string, ranIn: string);
+}
+export interface BaselineOptions {
+    repoRoot: string;
+    /** Commit to serve. Omit to serve the working tree as it stands. */
+    sha?: string;
+    /** Directory holding the app's package.json, relative to the repo root. */
+    appPrefix?: string;
+    /** Budget for install + boot. */
+    timeoutMs?: number;
+    /** Injectable for tests; defaults to a real PATH scan. */
+    pathHas?: (bin: string) => boolean;
+    log?: (msg: string) => void;
+}
+/**
+ * Check out `sha` into a throwaway worktree, install, and start its dev server.
+ *
+ * Returns null when this repo cannot be served this way (no dev script, no
+ * install, server never came up). Callers treat that as "try the next option",
+ * so every failure path cleans up after itself and stays quiet.
+ */
+export declare function serveBaseCommit(opts: BaselineOptions): Promise<LocalBaseline | null>;
+/**
+ * Boot this repository's dev server without one already running.
+ *
+ * The working tree is what the author is looking at, uncommitted edits and all,
+ * so it is the honest "Post" when nothing is deployed. Serving it needs no
+ * worktree and usually no install, which is why it is cheaper than the base
+ * side it gets paired with.
+ */
+export declare function serveWorkingTree(opts: Omit<BaselineOptions, 'sha'>): Promise<LocalBaseline | null>;
+export {};
+//# sourceMappingURL=baseline.d.ts.map

package/dist/baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.d.ts","sourceRoot":"","sources":["../src/baseline.ts"],"names":[],"mappings":"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"}