@mergelight/cli 0.0.0-stage → 0.1.14

package/LICENSE.md

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Thomas Egelund
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,114 @@
-# Temporary Holding Version
+# Mergelight
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+AI code review that runs on the ChatGPT or Claude plan you already pay for. Mergelight reviews a GitHub pull request, tries to disprove every problem it finds before you see it, and tells you which ones are worth fixing.
+
+## Start here
+
+**Reviews on every pull request.** Set it up at [mergelight.dev/setup](https://mergelight.dev/setup). It runs in your own GitHub Actions, on your own plan. See the [GitHub Action guide](https://github.com/mergelightai/mergelight/blob/main/docs/github-action.md).
+
+**Findings in your coding agent.** One command adds the MCP server and the skill to Claude Code, Codex and Cursor:
+
+```bash
+npx @mergelight/cli init
+```
+
+Then ask your agent: "Handle the Mergelight findings on this PR." See [Mergelight in your coding agent](https://github.com/mergelightai/mergelight/blob/main/docs/agents.md).
+
+**One review from your terminal.** It uses your Codex login, or your Claude login with `--provider claude`.
+
+```bash
+npx @mergelight/cli review https://github.com/owner/repo/pull/123
+```
+
+## What a review says
+
+Every finding is one of four kinds:
+
+- 🔴 **Bug:** happens in normal use and breaks something that matters. Fix it before merging.
+- 🟠 **Minor bug:** happens in normal use, but the damage is small, like a wrong label or a missing translation.
+- 🟡 **Risk:** real, but needs specific conditions, like a race or an unusual account setup.
+- ⚪ **Hardening:** doesn't happen in real use. Extra safety, left alone by default.
+
+How likely a problem is and how bad it is are rated separately, so a small problem that really happens is a minor bug, not hardening. Style, nitpicks and "add a test" comments are never posted. Text users see is not style: wrong or missing labels, messages and translations are reported. Each finding says how it would actually happen, what breaks, what the smallest fix costs, and whether that fix is worth it.
+
+## Requirements
+
+- Node 20 or newer
+- [GitHub CLI](https://cli.github.com), logged in (`gh auth login`)
+- The [Codex CLI](https://github.com/openai/codex), logged in with your ChatGPT plan (`codex login`). It looks for the problems by default.
+- Or [Claude Code](https://claude.com/claude-code), logged in with your Claude plan. With only Claude Code installed, add `--provider claude` to every `review` command.
+- With both installed, Codex looks for problems and Claude checks them. `--provider claude` makes Claude do both.
+
+## Usage
+
+```bash
+npx @mergelight/cli review https://github.com/owner/repo/pull/123
+```
+
+Installed with `npm i -g @mergelight/cli`, the command is `mergelight`. From a clone of the repository: `npm install`, `npm run build`, then `node dist/cli.js` in place of `mergelight`.
+
+Other ways to name the pull request: `owner/repo#123`, or just `123` inside a clone of the repository.
+
+| Option | What it does |
+|---|---|
+| `--at <sha>` | Review an earlier commit of the PR |
+| `--json` | Print the review as JSON |
+| `--out <file>` | Also save the JSON review to a file |
+| `--provider <name>` | Who looks for problems: `codex` (default) or `claude` |
+| `--model <name>` | Model to use (default: your Codex config, or `opus` with Claude) |
+| `--effort <level>` | Reasoning effort: `low`, `medium` or `high` (default: `high`) |
+| `--verify-with <name>` | Who checks the findings: `claude` (default when Claude Code is installed) or `codex` |
+| `--verify-model <name>` | Model for the checker, like `claude-opus-5-5` (default for Claude: `opus`) |
+| `--keep` | Keep the temporary checkout |
+| `--post` | Post the review to the PR: inline findings, one summary comment and a **Mergelight** check. GitHub only lets Apps write checks, so a personal `gh` login gets the comments and no check. The [GitHub Action](https://github.com/mergelightai/mergelight/blob/main/docs/github-action.md) gets all three |
+| `--dry-run` | With `--post`, `post` or `approve`: print what would be posted and change nothing |
+| `--yellow-blocks` | With `--post` or `post`: a 🟡 check waits for an approval instead of being neutral |
+
+Two more commands, used by the GitHub Action:
+
+- `mergelight post review.json` posts a review saved with `--out`.
+- `mergelight approve owner/repo#123 --by login` turns a 🟡 "needs a human" check green after someone approves the PR. A 🔴 check stays red.
+
+`mergelight init` adds Mergelight to your coding agents, and `mergelight mcp` is the MCP server they start, so Claude Code, Codex or Cursor can read a PR's findings and mark them handled. `mergelight setup owner/repo` sets up the GitHub Action from a terminal.
+
+The exit code is `2` when the review finds a bug that blocks the merge, `1` on errors and `0` otherwise. With `--post` it is `0` unless the review fails, since the check carries the verdict. On a personal `gh` login, where GitHub doesn't allow checks, the summary comment carries it instead.
+
+## How it works
+
+1. Fetches the PR with `gh` into a small cached mirror in `~/.cache/mergelight` and checks out the commit under review in a temporary folder.
+2. Three hunters run in parallel, each a `codex exec` in a read-only sandbox, or Claude Code with file tools only, with one area to cover: access (who can see and do what), money and data, and behavior (does the change do what the PR says, everywhere it's used). A fourth covers CI and supply chain, and only runs when a PR touches workflows, container, deploy or dependency files. They're told to be thorough and to check the code before reporting.
+3. A sweep pass reads the changed files no hunter reported anything in, up to 36 files in runs of 12, so big PRs aren't only reviewed where the hunters happened to look. Tests and docs are skipped.
+4. A verifier tries to disprove every candidate. It runs on Claude Code with the latest Opus when Claude Code is installed, and on Codex otherwise. It merges candidates only when they share the same cause and the same fix, and rates the rest: class, how likely, how bad, what the fix costs, and whether to fix it, decide or leave it. Then it picks at most 3 a senior reviewer would hold the merge for.
+5. Only those top picks get their own comment. Everything else it would **fix** is listed under **also worth fixing** in the summary. **Decide** becomes a one-line **your call**, for real trade-offs. **Leave** is collapsed under hardening. With `--post`, later review rounds hand the verifier what earlier rounds found. It checks each one again, so a finding keeps its id and its one comment even if it's worded differently or points at other lines, and "no longer found" means it was checked, not just missed. It also sees what the team marked as fixed or won't fix: a fix gets checked like anything else, and a decision not to fix is respected unless a major bug still stands.
+
+On 32 real pull requests across two repositories, Opus's top picks came to about 2 comments per PR, and the team fixed 65% of the problems they describe. The team never saw these comments, but another bot had raised the same problem in 37 of the 63 cases. Among problems only Mergelight raised, the team fixed 38% of the top picks on its own and 14% of the other findings worth fixing, so the picks are a real signal, on a small sample. Posting everything the verifier would fix meant about 4.5 comments per PR with Opus and 6 with Codex.
+
+The light is red when a major bug must be fixed, yellow when anything else is worth fixing or needs a decision, and green otherwise.
+
+Plugins, MCP servers, hooks and web search are switched off for every Codex run, so code in a pull request can't reach your other tools. Claude Code runs with only Read, Grep and Glob, confined to the checkout, with plugins, hooks, MCP servers and skills off, and anything that would ask for permission is denied. Every Codex run uses high reasoning effort unless you pass `--effort`, whatever your Codex config says. It matters: in our eval, gpt-6.1-sol at its default low effort found about a third fewer real problems. A review takes about 2 to 15 minutes depending on the size of the PR, around 7 for a typical one.
+
+Nothing is sent to Mergelight. The review runs on your own Codex or Claude login, on your machine or in your own GitHub Actions.
+
+## Eval
+
+`eval/` compares Mergelight with CodeRabbit and Copilot on PRs they already reviewed, and with what the team did about each comment. Results are written to `~/.cache/mergelight/eval`, never to this repository.
+
+```bash
+node eval/collect.mjs owner/repo --since 2026-10-01   # comments other bots left, per PR
+node eval/run.mjs owner/repo --count 20               # Mergelight reviews the same commits
+node eval/judge.mjs owner/repo                        # Codex judges which comments the team fixed before merging
+node eval/score.mjs owner/repo                        # per reviewer: comments, comments fixed, fixed issues found
+node eval/replay.mjs owner/repo --from v2 --tag opus --with claude   # same candidates, another verifier
+```
+
+`compare.mjs` is a cruder, faster version of the judge. It only checks whether the commented lines changed, which misses fixes that land a few lines away.
+
+## License
+
+Mergelight is under the [Functional Source License](https://github.com/mergelightai/mergelight/blob/main/LICENSE.md) (FSL-1.1-MIT). In plain words:
+
+- You can use it, alone or in your company, and you can change it, fork it and share it.
+- You can't offer it, or something built from it, as a commercial product or service that takes its place.
+- Each version becomes MIT two years after it's released.
+
+Changes are welcome as pull requests. See [CONTRIBUTING.md](https://github.com/mergelightai/mergelight/blob/main/CONTRIBUTING.md).

package/dist/action-source.js

@@ -0,0 +1,107 @@
+import { lstatSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** A Node or Docker action's definition only names what it runs. */
+const RUNS_A_PROGRAM = /^[ \t]*using:[ \t]*["']?(?:node\d*|docker)\b/m;
+export function notRead(sources) {
+    return sources.flatMap((s) => {
+        if (!s.files.length)
+            return [{ uses: s.uses, why: "unreadable" }];
+        return RUNS_A_PROGRAM.test(s.files[0].text) ? [{ uses: s.uses, why: "program" }] : [];
+    });
+}
+/** The only places GitHub runs these from. */
+const WORKFLOW_FILE = /^\.github\/workflows\/[^/]+\.ya?ml$|^\.github\/actions\/(.+\/)?action\.ya?ml$/;
+const USES = /^[ \t]*(?:-[ \t]+)?uses:[ \t]*["']?([^"'\s#]+)/gm;
+const REMOTE = /^([\w.-]+)\/([\w.-]+)((?:\/[\w.-]+)*)@([\w./-]+)$/;
+/** Scripts a composite action runs from its own folder. */
+const OWN_SCRIPT = /(?:GITHUB_ACTION_PATH|github\.action_path)(?:\s*\}\}|\})?["']?\/([\w./-]+)/g;
+/** GitHub's own actions are widely read, and reading them would crowd out the rest. */
+const WELL_KNOWN = new Set(["actions", "github"]);
+/** The action running this review. A customer can't fix its code, so a finding about it would only be noise on their pull request. */
+const OURS = /^mergelightai\/mergelight(?:\/|@)/i;
+const MAX_ACTIONS = 6;
+const MAX_SCRIPTS = 6;
+const MAX_FILE = 30_000;
+/** All of it goes in the verifier's prompt, whose failure ends the review, so a pull request mustn't be able to overfill it. */
+const MAX_TOTAL = 90_000;
+/** The other people's actions and reusable workflows these changed files use, in the order they appear. */
+export function actionsUsedBy(dir, changedPaths) {
+    const used = new Set();
+    for (const path of changedPaths.filter((p) => WORKFLOW_FILE.test(p))) {
+        let text;
+        try {
+            // A pull request can make this a symlink to anywhere, and a regular file is all a workflow can be.
+            if (!lstatSync(join(dir, path)).isFile())
+                continue;
+            text = readFileSync(join(dir, path), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const [, uses] of text.matchAll(USES)) {
+            const remote = REMOTE.exec(uses);
+            if (remote && !WELL_KNOWN.has(remote[1].toLowerCase()) && !OURS.test(uses) && !uses.includes(".."))
+                used.add(uses);
+        }
+    }
+    return [...used];
+}
+/**
+ * Reads without a token, so public code is all this can reach. A pull request chooses these names,
+ * and must not be able to pull someone's private repository into a prompt with the reader's access.
+ */
+async function readFile(owner, repo, ref, path, fetchImpl) {
+    try {
+        const res = await fetchImpl(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path}`, { signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            return null;
+        const text = await res.text();
+        return text.length > MAX_FILE ? `${text.slice(0, MAX_FILE)}\n(cut off here, the file is longer)` : text;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetches each action's definition and the scripts it runs from its own folder. Anything that can't be
+ * read, or is past the limits, comes back with no files, so a review never fails over it and reviewers
+ * know what they didn't see.
+ */
+export async function fetchActionSources(uses, fetchImpl = fetch) {
+    const sources = await Promise.all(uses.map(async (use, i) => {
+        if (i >= MAX_ACTIONS)
+            return { uses: use, files: [] };
+        const [, owner, repo, sub, ref] = REMOTE.exec(use);
+        const folder = sub.replace(/^\//, "");
+        const prefix = folder && `${folder}/`;
+        const reusable = /\.ya?ml$/.test(folder);
+        let main = null;
+        for (const path of reusable ? [folder] : [`${prefix}action.yml`, `${prefix}action.yaml`]) {
+            const text = await readFile(owner, repo, ref, path, fetchImpl);
+            if (text !== null) {
+                main = { path, text };
+                break;
+            }
+        }
+        if (!main)
+            return { uses: use, files: [] };
+        const scripts = [...new Set([...main.text.matchAll(OWN_SCRIPT)].map((m) => m[1]))].filter((p) => !p.includes("..")).slice(0, MAX_SCRIPTS);
+        const read = await Promise.all(scripts.map(async (script) => {
+            const path = `${prefix}${script}`;
+            const text = await readFile(owner, repo, ref, path, fetchImpl);
+            return text === null ? null : { path, text };
+        }));
+        return { uses: use, files: [main, ...read.filter((f) => f !== null)] };
+    }));
+    let room = MAX_TOTAL;
+    return sources.map((source) => {
+        const files = source.files.filter((f) => {
+            if (f.text.length > room)
+                return false;
+            room -= f.text.length;
+            return true;
+        });
+        // Without its definition, the scripts left over say little.
+        return { ...source, files: files[0] === source.files[0] ? files : [] };
+    });
+}

package/dist/cli.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { currentRepo, fetchPullRequest, parsePrRef } from "./github.js";
+import { serve } from "./mcp/server.js";
+import { GitHub } from "./publish/api.js";
+import { approveCheck, checkLimitTitle, checkLoginTitle, failCheck, failSummary, previousFindings, publishReview, startCheck, startSummary } from "./publish/publish.js";
+import { LimitError, LoginError, loginFailureMessage } from "./providers/codex.js";
+import { limitNotice, loginNotice } from "./publish/markdown.js";
+import { renderTerminal } from "./render.js";
+import { reviewPullRequest } from "./review.js";
+import { askForApp, connect, githubConnect } from "./connect.js";
+import { init, realInitDeps } from "./init.js";
+import { realDeps, setup } from "./setup.js";
+const HELP = `Mergelight: AI code review on the plan you already pay for.
+
+Usage
+  mergelight review <pr> [options]       Review a pull request
+  mergelight post <review.json>          Post a saved review to its pull request
+  mergelight approve <pr> --by <login>   Turn a "needs a human" check green after approval
+  mergelight init                        Add Mergelight to your coding agents: Claude Code, Codex and Cursor
+  mergelight mcp                         Run the MCP server, so your coding agent can read findings
+  mergelight setup <owner/repo>          Set up the GitHub Action on a repository
+  mergelight connect <pr>                In the Action: connect ChatGPT from the pull request
+
+  <pr> is a pull request URL, owner/repo#123, or a number inside a clone.
+
+Options
+  --repo <owner/name>   Repository for a bare PR number
+  --at <sha>            Review this commit of the PR instead of the latest
+  --post                Post the review to the PR: summary comment, inline findings, check
+                        (the check needs a GitHub App, a personal gh login skips it)
+  --dry-run             With --post, post or approve: print what would be posted, change nothing
+  --yellow-blocks       With --post or post: a "needs a human" check waits for an approval
+  --json                Print the review as JSON
+  --out <file>          Also write the JSON review to a file
+  --provider <name>     Who hunts for problems: codex or claude (default: codex)
+  --model <name>        Model for the hunters (default: your Codex config, or opus on Claude)
+  --effort <level>      Reasoning effort: low, medium, high (default: high)
+  --verify-with <name>  Who checks the findings: claude or codex
+                        (default: claude when Claude Code is installed)
+  --verify-model <name> Model for the checker (default for claude: opus)
+  --keep                Keep the temporary checkout
+  --by <login>          Who approved, for approve
+  --base <branch>       For setup: add the workflows to this branch (default: the default branch)
+  --skip-branches <a,b> For setup: don't review pull requests from these branches
+  --relogin             For setup: log in to Codex again
+  --no-pin              For setup: follow @v0 and get each release by itself, instead of pinning to the latest
+  --yes                 For setup: don't stop to ask whether the app is installed
+  --no-save             For connect: there's nowhere to save a login, so ask for the app instead
+  -h, --help            Show this help
+
+Reviews run on your own logged-in Codex CLI, and Claude Code if you check with it.
+Nothing is sent to Mergelight.
+`;
+function progressPrinter() {
+    const tty = Boolean(process.stderr.isTTY);
+    const started = Date.now();
+    let last = "";
+    const draw = () => {
+        if (!tty || !last)
+            return;
+        const s = Math.round((Date.now() - started) / 1000);
+        const line = `${last} (${s}s)`;
+        process.stderr.write(`\r\x1b[2K${line.slice(0, (process.stderr.columns ?? 100) - 1)}`);
+    };
+    const ticker = tty ? setInterval(draw, 1000) : undefined;
+    return {
+        onProgress(message, transient) {
+            if (tty) {
+                last = message;
+                draw();
+            }
+            else if (!transient) {
+                process.stderr.write(`${message}\n`);
+            }
+        },
+        stop() {
+            if (ticker)
+                clearInterval(ticker);
+            if (tty)
+                process.stderr.write("\r\x1b[2K");
+        },
+    };
+}
+const log = (line) => process.stderr.write(`${line}\n`);
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            repo: { type: "string" },
+            at: { type: "string" },
+            post: { type: "boolean" },
+            "dry-run": { type: "boolean" },
+            "yellow-blocks": { type: "boolean" },
+            json: { type: "boolean" },
+            out: { type: "string" },
+            model: { type: "string" },
+            effort: { type: "string" },
+            "verify-with": { type: "string" },
+            provider: { type: "string" },
+            "verify-model": { type: "string" },
+            keep: { type: "boolean" },
+            by: { type: "string" },
+            base: { type: "string" },
+            "skip-branches": { type: "string" },
+            relogin: { type: "boolean" },
+            pin: { type: "boolean" },
+            "no-pin": { type: "boolean" },
+            yes: { type: "boolean" },
+            "no-save": { type: "boolean" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    const [command, target] = positionals;
+    if (values.help || !command) {
+        process.stdout.write(HELP);
+        return values.help ? 0 : 1;
+    }
+    if (command === "setup") {
+        if (!target || !/^[\w.-]+\/[\w.-]+$/.test(target)) {
+            log("mergelight: name the repository, like: mergelight setup owner/repo");
+            return 1;
+        }
+        try {
+            return await setup({
+                repo: target,
+                base: values.base,
+                skipBranches: values["skip-branches"]?.split(",").map((b) => b.trim()).filter(Boolean),
+                relogin: values.relogin,
+                pin: !values["no-pin"],
+                yes: values.yes,
+            }, realDeps());
+        }
+        catch (err) {
+            log(`mergelight: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+    }
+    if (command === "init") {
+        try {
+            return await init(realInitDeps());
+        }
+        catch (err) {
+            log(`mergelight: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+    }
+    if (command === "mcp") {
+        await serve();
+        return 0;
+    }
+    if (!["review", "post", "approve", "connect"].includes(command) || !target) {
+        process.stderr.write(HELP);
+        return 1;
+    }
+    const dryRun = Boolean(values["dry-run"]);
+    const provider = values.provider;
+    if (provider !== undefined && provider !== "codex" && provider !== "claude") {
+        log(`mergelight: --provider must be codex or claude, not "${provider}"`);
+        return 1;
+    }
+    const verifyWith = values["verify-with"];
+    if (verifyWith !== undefined && verifyWith !== "codex" && verifyWith !== "claude") {
+        log(`mergelight: --verify-with must be codex or claude, not "${verifyWith}"`);
+        return 1;
+    }
+    if (command === "post") {
+        const review = JSON.parse(readFileSync(target, "utf8"));
+        const result = await publishReview(review, { dryRun, log, yellowBlocks: values["yellow-blocks"] });
+        log(`Posted: ${result.inline} inline, ${result.outside} in the summary only, ${result.resolved} resolved. ${result.summaryUrl ?? ""}`);
+        return 0;
+    }
+    const ref = parsePrRef(target, values.repo ?? (await currentRepo()));
+    if (command === "connect") {
+        try {
+            const api = new GitHub(ref.owner, ref.repo, { log });
+            const { headSha } = await fetchPullRequest(ref);
+            if (values["no-save"]) {
+                await askForApp(api, ref.number, headSha);
+                log("Install the Mergelight AI app: without it there's nowhere to save the ChatGPT login.");
+                return 1;
+            }
+            return await connect(githubConnect(api, ref.number, headSha, log));
+        }
+        catch (err) {
+            log(`mergelight: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+    }
+    if (command === "approve") {
+        if (!values.by) {
+            log("approve needs --by <login>");
+            return 1;
+        }
+        log(await approveCheck(new GitHub(ref.owner, ref.repo, { dryRun, log }), ref.number, values.by));
+        return 0;
+    }
+    // review
+    const api = new GitHub(ref.owner, ref.repo, { dryRun, log });
+    let checkRunId = null;
+    let headSha = values.at ?? null;
+    if (values.post) {
+        headSha ??= (await fetchPullRequest(ref)).headSha;
+        checkRunId = await startCheck(api, headSha);
+        await startSummary(api, ref.number).catch((e) => log(`Couldn't post the summary yet: ${e.message}`));
+    }
+    const progress = progressPrinter();
+    try {
+        // The login step already found this login can't be refreshed, so don't send every reviewer to find out.
+        if (process.env.MERGELIGHT_LOGIN_LOST === "1")
+            throw new LoginError(loginFailureMessage(process.env.SECRET_NAME || undefined));
+        const review = await reviewPullRequest(ref, {
+            previous: values.post ? await previousFindings(api, ref.number) : undefined,
+            at: values.at,
+            provider,
+            model: values.model,
+            effort: values.effort,
+            verifyWith,
+            verifyModel: values["verify-model"],
+            keep: values.keep,
+            onProgress: progress.onProgress,
+        });
+        progress.stop();
+        const json = JSON.stringify(review, null, 2);
+        if (values.out)
+            writeFileSync(values.out, `${json}\n`);
+        process.stdout.write(values.json ? `${json}\n` : `${renderTerminal(review)}\n`);
+        if (values.post) {
+            const result = await publishReview(review, { dryRun, log, checkRunId, yellowBlocks: values["yellow-blocks"] });
+            log(`Posted: ${result.inline} inline, ${result.outside} in the summary only, ${result.resolved} resolved. ${result.summaryUrl ?? ""}`);
+            // The check carries the verdict; the job itself only fails on errors.
+            return 0;
+        }
+        return review.light === "red" ? 2 : 0;
+    }
+    catch (err) {
+        progress.stop();
+        const message = err instanceof Error ? err.message : String(err);
+        log(`mergelight: ${message}`);
+        if (values.post && headSha) {
+            const login = err instanceof LoginError ? err : null;
+            const limit = err instanceof LimitError ? err : null;
+            const title = limit ? checkLimitTitle(limit.plan) : login ? checkLoginTitle(login.plan) : undefined;
+            const notice = limit ? limitNotice(limit.plan, limit.resets) : login ? loginNotice(login.plan, message) : undefined;
+            await failCheck(api, checkRunId, headSha, message, log, title).catch((e) => log(`Couldn't update the check: ${e.message}`));
+            await failSummary(api, ref.number, notice).catch((e) => log(`Couldn't update the summary: ${e.message}`));
+        }
+        return 1;
+    }
+}
+main().then((code) => process.exit(code));