@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/pr-6CYMM2XU.js

@@ -0,0 +1,707 @@
+import {
+  packageManagerOf
+} from "./chunk-SGP5JX6I.js";
+import {
+  PROSE_FILE,
+  analyzeImpact,
+  defaultIsTestFile,
+  deriveVerdict,
+  invalidatesAllTests,
+  isJavaScriptTestFile,
+  packageRootOf,
+  verdictText
+} from "./chunk-KCEGA56S.js";
+import {
+  computeAffectedFiles,
+  importersOfUnindexed
+} from "./chunk-IFFZ46YS.js";
+import "./chunk-GDSZFIHM.js";
+import {
+  classificationLabel
+} from "./chunk-CXNXZLDG.js";
+import "./chunk-DMDAJPFJ.js";
+import "./chunk-3E5LBU3O.js";
+import {
+  changeBaseDeps,
+  resolvePullRequestBase
+} from "./chunk-H5C4SE73.js";
+import "./chunk-X3VVGTEV.js";
+import "./chunk-NFFXYYM6.js";
+import {
+  classifyFileAgainstRef
+} from "./chunk-YII4TAKS.js";
+import {
+  assertBaseRef
+} from "./chunk-MAK3HG46.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-EISTWXDW.js";
+import {
+  listChangedFilesSinceMergeBase
+} from "./chunk-RSIOYQOQ.js";
+import {
+  isStarReexportKey
+} from "./chunk-DSQDMFQ6.js";
+import {
+  GitRefError
+} from "./chunk-ACTY42RE.js";
+
+// src/cli/commands/pr.ts
+import { writeFile } from "fs/promises";
+import path2 from "path";
+
+// src/core/pr/check.ts
+var DEFAULT_PR_BASE_REF = "main";
+var TS_FILE = /\.tsx?$/;
+async function listBranchChanges(cwd, baseRef) {
+  await assertBaseRef(cwd, baseRef);
+  const changed = await listChangedFilesSinceMergeBase(cwd, baseRef);
+  if (changed === null) {
+    throw new GitRefError(`"${baseRef}" has no merge base with HEAD`);
+  }
+  return changed;
+}
+async function runPrCheck(cwd, options = {}) {
+  const baseRef = options.changedFiles === void 0 ? await resolvePullRequestBase(options.base, changeBaseDeps(cwd)) : options.base ?? DEFAULT_PR_BASE_REF;
+  const changed = options.changedFiles ?? await listBranchChanges(cwd, baseRef);
+  const tsFiles = changed.filter((file) => TS_FILE.test(file));
+  const files = [];
+  for (const relPath of tsFiles) {
+    files.push(await classifyFileAgainstRef(cwd, relPath, baseRef));
+  }
+  return {
+    baseRef,
+    changedFiles: changed,
+    tsFilesChanged: tsFiles.length,
+    files,
+    verdict: deriveVerdict(files.map((file) => file.classification))
+  };
+}
+
+// src/core/plan/plan.ts
+import path from "path";
+
+// src/core/graph/import-paths.ts
+function importersOf(graph, file) {
+  return graph.imports.has(file) ? graph.dependents.get(file) ?? [] : importersOfUnindexed(graph, file);
+}
+function pathsToward(graph, targets) {
+  const next = /* @__PURE__ */ new Map();
+  let frontier = [...new Set(targets)].sort();
+  for (const target of frontier) next.set(target, null);
+  while (frontier.length > 0) {
+    const reached = [];
+    for (const file of frontier) {
+      for (const importer of [...importersOf(graph, file)].sort()) {
+        if (next.has(importer)) continue;
+        next.set(importer, file);
+        reached.push(importer);
+      }
+    }
+    frontier = reached;
+  }
+  return (from) => {
+    if (!next.has(from)) return null;
+    const chain = [from];
+    let hop = next.get(from);
+    while (hop !== null && hop !== void 0) {
+      chain.push(hop);
+      hop = next.get(hop);
+    }
+    return chain;
+  };
+}
+
+// src/core/plan/checks.ts
+var KINDS = [
+  ["typecheck", /^(?:type-?check|check-?types|tsc|types)$/],
+  ["build", /^build$/],
+  ["lint", /^lint$/],
+  ["e2e", /^(?:e2e|test[:-]e2e|e2e[:-]test)$/]
+];
+var ORDER = {
+  typecheck: 0,
+  build: 1,
+  lint: 2,
+  e2e: 3
+};
+function commandFor(pkg, script, style) {
+  const manager = style.packageManager ?? "npm";
+  if (pkg.dir === "" || pkg.name === void 0) {
+    const prefix = pkg.dir === "" ? "" : `cd ${pkg.dir} && `;
+    return `${prefix}${manager} run ${script}`;
+  }
+  if (style.taskRunner === "turborepo") {
+    return `turbo run ${script} --filter=${pkg.name}`;
+  }
+  if (style.taskRunner === "nx") return `nx run ${pkg.name}:${script}`;
+  if (manager === "pnpm") return `pnpm --filter ${pkg.name} run ${script}`;
+  if (manager === "yarn") return `yarn workspace ${pkg.name} run ${script}`;
+  if (manager === "bun") return `bun run --filter ${pkg.name} ${script}`;
+  return `npm run ${script} --workspace ${pkg.name}`;
+}
+var FANS_OUT = /\b(?:turbo|nx|lerna)\b|\s(?:-r|--recursive|--filter|--workspaces|-ws)\b|\bworkspaces\s+foreach\b/;
+function planChecks(packages, style, options = {}) {
+  const covered = /* @__PURE__ */ new Set();
+  const checks = [];
+  for (const pkg of packages) {
+    for (const script of Object.keys(pkg.scripts).sort()) {
+      const kind = KINDS.find(([, pattern]) => pattern.test(script))?.[0];
+      if (kind === void 0) continue;
+      if (options.everyPackage === true && pkg.dir === "" && FANS_OUT.test(` ${pkg.scripts[script] ?? ""}`)) {
+        covered.add(kind);
+      }
+      checks.push({
+        kind,
+        package: pkg.name ?? pkg.dir,
+        dir: pkg.dir,
+        script,
+        command: commandFor(pkg, script, style)
+      });
+    }
+  }
+  return checks.filter((check) => check.dir === "" || !covered.has(check.kind)).sort(
+    (a, b) => ORDER[a.kind] - ORDER[b.kind] || a.dir.localeCompare(b.dir) || a.script.localeCompare(b.script)
+  );
+}
+
+// src/core/plan/plan.ts
+var RISK_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2,
+  unrated: 3,
+  none: 4
+};
+var HOUSEKEEPING_FILE = /(?:^|\/)(?:\.github|\.vscode|\.husky)\/|(?:^|\/)(?:\.gitignore|\.gitattributes|\.editorconfig|LICENSE[^/]*)$/;
+function nearest(file, candidates) {
+  let best;
+  for (const candidate of candidates) {
+    const inside = candidate.dir === "" || file.startsWith(`${candidate.dir}/`);
+    if (inside && (best === void 0 || candidate.dir.length > best.dir.length)) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+var END_TO_END_FILE = /\.spec\.[cm]?[jt]sx?$|(?:^|\/)e2e\//;
+function runnerOf(file, roots) {
+  const unit = nearest(
+    file,
+    roots.filter((root) => root.runner !== "playwright")
+  );
+  const browser = nearest(
+    file,
+    roots.filter((root) => root.runner === "playwright")
+  );
+  if (browser === void 0 || !END_TO_END_FILE.test(file)) return unit;
+  return unit === void 0 || browser.dir.length >= unit.dir.length ? browser : unit;
+}
+function scriptFor(pkg, runner, file) {
+  const names = Object.keys(pkg.scripts).sort();
+  if (runner === "unknown") return names.includes("test") ? "test" : void 0;
+  const invoking = names.filter(
+    (name) => new RegExp(`\\b${runner}\\b`).test(pkg.scripts[name] ?? "")
+  );
+  const kind = /\.(integration|e2e)\./.exec(file)?.[1];
+  const byKind = kind === void 0 ? void 0 : invoking.find(
+    (name) => `${name} ${pkg.scripts[name] ?? ""}`.includes(kind)
+  );
+  if (byKind !== void 0) return byKind;
+  if (invoking.includes("test")) return "test";
+  if (invoking.length === 1) return invoking[0];
+  return runner !== "playwright" && invoking.length === 0 && names.includes("test") ? "test" : void 0;
+}
+function reachOf(file, graph) {
+  const seeds = graph.imports.has(file) ? /* @__PURE__ */ new Set([file]) : importersOfUnindexed(graph, file);
+  const reach = computeAffectedFiles(seeds, graph);
+  reach.delete(file);
+  return reach;
+}
+function riskOf(change, unverified, isTest) {
+  if (change.classification === "non-impacting") {
+    return { risk: "none", reason: "comments or formatting only" };
+  }
+  if (PROSE_FILE.test(change.filePath)) {
+    return { risk: "none", reason: "documentation" };
+  }
+  if (invalidatesAllTests(change.filePath)) {
+    return {
+      risk: "medium",
+      reason: "configuration every test and build runs under"
+    };
+  }
+  if (HOUSEKEEPING_FILE.test(change.filePath)) {
+    return {
+      risk: "unrated",
+      reason: "repository housekeeping, which no test can reach"
+    };
+  }
+  if (unverified) return { risk: "high", reason: "no test reaches it" };
+  if (isTest) {
+    return { risk: "low", reason: "a changed test, which the plan runs" };
+  }
+  if (change.additive) {
+    return { risk: "low", reason: "only adds exports, and tests reach it" };
+  }
+  if (change.classification === "breaking" && change.crossesInto.length > 0) {
+    return {
+      risk: "high",
+      reason: "its exports changed, and other packages import it"
+    };
+  }
+  if (change.classification === "breaking") {
+    return { risk: "medium", reason: "its exports changed" };
+  }
+  if (change.classification === "unanalyzed") {
+    return { risk: "medium", reason: "not a file variant can read" };
+  }
+  if (change.crossesInto.length > 0) {
+    return {
+      risk: "medium",
+      reason: "implementation changed, and other packages import it"
+    };
+  }
+  return { risk: "low", reason: "implementation only, and tests reach it" };
+}
+function assemblePlan(inputs) {
+  const { radius, tests, graph } = inputs;
+  const packageDirs = inputs.packages.map((pkg) => pkg.dir);
+  const nameOf = new Map(
+    inputs.packages.map((pkg) => [pkg.dir, pkg.name ?? pkg.dir])
+  );
+  const isTest = (file) => graph.imports.has(file) && defaultIsTestFile(file);
+  const unselected = new Set(tests.unselectedTests);
+  const unverifiedFiles = /* @__PURE__ */ new Set();
+  const changes = radius.changed.map((impact) => {
+    const reach = reachOf(impact.filePath, graph);
+    const home = packageRootOf(impact.filePath, packageDirs);
+    const crossesInto = /* @__PURE__ */ new Set();
+    let reaching = isTest(impact.filePath) ? 1 : 0;
+    for (const file of reach) {
+      if (isTest(file)) reaching++;
+      const dir = packageRootOf(file, packageDirs);
+      if (dir !== home) crossesInto.add(nameOf.get(dir) ?? dir);
+    }
+    const facts = {
+      filePath: impact.filePath,
+      classification: impact.classification,
+      symbols: impact.impactedSymbols.filter(
+        (name) => !isStarReexportKey(name)
+      ),
+      additive: impact.classification === "breaking" && impact.impactedSymbols.length === 0 && impact.ungated !== true,
+      dependents: reach.size,
+      crossesInto: [...crossesInto].sort(),
+      tests: reaching
+    };
+    const deleted = impact.classification !== "unanalyzed" && !graph.imports.has(impact.filePath);
+    const unverified = unselected.has(impact.filePath) || reaching === 0 && !deleted;
+    const scored = riskOf(facts, unverified, isTest(impact.filePath));
+    if (scored.risk === "high" && unverified) {
+      unverifiedFiles.add(impact.filePath);
+    }
+    return { ...facts, ...scored };
+  });
+  const rank = (change) => change.risk === "none" ? 3 : change.risk === "unrated" ? 2 : invalidatesAllTests(change.filePath) ? 1 : 0;
+  changes.sort(
+    (a, b) => rank(a) - rank(b) || RISK_ORDER[a.risk] - RISK_ORDER[b.risk] || a.filePath.localeCompare(b.filePath)
+  );
+  const seeds = radius.changed.filter((impact) => impact.classification !== "non-impacting").map((impact) => impact.filePath);
+  const chainFrom = pathsToward(graph, seeds);
+  const why = {};
+  const runs = /* @__PURE__ */ new Map();
+  for (const test of tests.affectedTests) {
+    const chain = chainFrom(test);
+    if (chain !== null) why[test] = chain;
+    const root = runnerOf(test, inputs.runnerRoots);
+    const owner = nearest(test, inputs.packages);
+    const script = owner === void 0 ? void 0 : scriptFor(owner, root?.runner ?? "unknown", test);
+    const run = {
+      runner: root?.runner ?? "unknown",
+      dir: root?.dir ?? "",
+      files: [],
+      ...owner !== void 0 && script !== void 0 && {
+        command: commandFor(owner, script, inputs.style)
+      }
+    };
+    const key = `${run.runner}\0${run.dir}\0${run.command ?? ""}`;
+    const existing = runs.get(key) ?? run;
+    existing.files.push(test);
+    runs.set(key, existing);
+  }
+  const widened = [];
+  for (const impact of radius.changed) {
+    if (invalidatesAllTests(impact.filePath)) {
+      widened.push(
+        `${impact.filePath} changed: every test and every package's checks are in the plan, because it configures all of them`
+      );
+    } else if (impact.ungated === true || impact.impactedSymbols.some(isStarReexportKey)) {
+      widened.push(
+        `${impact.filePath}: every file importing it is affected, whichever names it takes, because the file does not parse or re-exports with \`export *\``
+      );
+    }
+  }
+  const affectedDirs = new Set(
+    radius.affectedFiles.map((file) => packageRootOf(file, packageDirs))
+  );
+  const checked = inputs.packages.filter(
+    (pkg) => tests.selectAll || affectedDirs.has(pkg.dir)
+  );
+  const notVerified = radius.changed.filter((impact) => unverifiedFiles.has(impact.filePath)).map((impact) => {
+    const direct = graph.imports.has(impact.filePath) ? graph.dependents.get(impact.filePath) ?? [] : importersOfUnindexed(graph, impact.filePath);
+    return {
+      filePath: impact.filePath,
+      symbols: impact.impactedSymbols.filter(
+        (name) => !isStarReexportKey(name)
+      ),
+      usedBy: [...direct].sort(),
+      reason: isJavaScriptTestFile(impact.filePath) ? "a changed test in JavaScript, which variant does not index: run it yourself" : "no test reaches it: it is untested, or used in a way variant cannot follow"
+    };
+  });
+  return {
+    baseRef: inputs.baseRef,
+    baseLabel: inputs.baseLabel,
+    changes,
+    tests: {
+      selected: tests.affectedTests.length,
+      total: tests.totalTests,
+      all: tests.selectAll,
+      runs: [...runs.values()].sort(
+        (a, b) => a.dir.localeCompare(b.dir) || a.runner.localeCompare(b.runner)
+      ),
+      why
+    },
+    checks: planChecks(checked, inputs.style, {
+      everyPackage: tests.selectAll
+    }),
+    widened,
+    notVerified,
+    resolution: tests.resolution,
+    notes: [...radius.notes, ...tests.notes],
+    repositoryNotes: [...radius.repositoryNotes, ...tests.repositoryNotes]
+  };
+}
+var RUNNER_CONFIGS = [
+  // `vitest.integration.config.ts` is as much a Vitest config as the default.
+  [/^vitest(?:\.[\w-]+)?\.(?:config|workspace|projects)\./, "vitest"],
+  [/^jest(?:\.[\w-]+)?\.config\./, "jest"],
+  [/^playwright(?:\.[\w-]+)?\.config\./, "playwright"]
+];
+async function findRunnerRoots(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const found = await fg(
+    [
+      "**/vitest*.{config,workspace,projects}.*",
+      "**/jest*.config.*",
+      "**/playwright*.config.*"
+    ],
+    {
+      cwd,
+      onlyFiles: true,
+      ignore: ["**/node_modules/**", "**/dist/**", ".git/**", ".variant/**"]
+    }
+  );
+  const roots = [];
+  for (const file of found.map((entry) => entry.replace(/\\/g, "/")).sort()) {
+    const name = path.posix.basename(file);
+    const runner = RUNNER_CONFIGS.find(([pattern]) => pattern.test(name))?.[1];
+    if (runner === void 0) continue;
+    const dir = path.posix.dirname(file);
+    roots.push({ dir: dir === "." ? "" : dir, runner });
+  }
+  return roots;
+}
+var RUNNER_PACKAGES = [
+  ["vitest", "vitest"],
+  ["jest", "jest"],
+  ["@playwright/test", "playwright"]
+];
+function runnersDeclared(dir, manifest) {
+  const declared = { ...manifest.dependencies, ...manifest.devDependencies };
+  return RUNNER_PACKAGES.filter(([name]) => name in declared).map(
+    ([, runner]) => ({ dir, runner })
+  );
+}
+async function taskRunnerOf(cwd) {
+  const { access } = await import("fs/promises");
+  const exists = (file) => access(path.join(cwd, file)).then(
+    () => true,
+    () => false
+  );
+  if (await exists("turbo.json")) return "turborepo";
+  return await exists("nx.json") ? "nx" : null;
+}
+async function readRootPackage(cwd) {
+  const { readFile } = await import("fs/promises");
+  try {
+    const manifest = JSON.parse(
+      await readFile(path.join(cwd, "package.json"), "utf8")
+    );
+    return {
+      scripts: {
+        name: manifest.name,
+        dir: "",
+        scripts: manifest.scripts ?? {}
+      },
+      runners: runnersDeclared("", manifest)
+    };
+  } catch {
+    return null;
+  }
+}
+async function buildVerificationPlan(cwd, options = {}) {
+  const [{ base, result, packageGraph }, runnerRoots, root, manager, runner] = await Promise.all([
+    analyzeImpact(cwd, options),
+    findRunnerRoots(cwd),
+    readRootPackage(cwd),
+    packageManagerOf(cwd),
+    taskRunnerOf(cwd)
+  ]);
+  const style = { packageManager: manager, taskRunner: runner };
+  const packages = root === null ? [] : [root.scripts];
+  const declared = [...root?.runners ?? []];
+  for (const pkg of packageGraph?.packages ?? []) {
+    const dir = path.relative(cwd, pkg.dir).replace(/\\/g, "/");
+    if (dir === "") continue;
+    packages.push({
+      name: pkg.manifest.name,
+      dir,
+      scripts: pkg.manifest.scripts ?? {}
+    });
+    declared.push(...runnersDeclared(dir, pkg.manifest));
+  }
+  return assemblePlan({
+    baseRef: base.ref,
+    baseLabel: base.label,
+    radius: result.radius,
+    tests: result.tests,
+    graph: result.graph,
+    packages,
+    runnerRoots: [...runnerRoots, ...declared],
+    style
+  });
+}
+
+// src/core/pr/report.ts
+async function buildPrReport(cwd, options = {}) {
+  const check = await runPrCheck(cwd, options);
+  const plan = await buildVerificationPlan(cwd, {
+    base: check.baseRef,
+    changedFiles: check.changedFiles
+  });
+  return { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), check, plan };
+}
+function formatPrReportJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+var MAX_ROWS = 25;
+var MAX_INLINE = 5;
+var count = (value, noun) => `${value} ${noun}${value === 1 ? "" : "s"}`;
+var code = (text) => `\`${text}\``;
+function inline(items) {
+  const shown = items.slice(0, MAX_INLINE).map(code).join(", ");
+  return items.length > MAX_INLINE ? `${shown} and ${items.length - MAX_INLINE} more` : shown;
+}
+function capped(rows, noun) {
+  if (rows.length <= MAX_ROWS) return [...rows];
+  return [
+    ...rows.slice(0, MAX_ROWS),
+    `_\u2026and ${count(rows.length - MAX_ROWS, noun)} more, in the JSON report._`
+  ];
+}
+var RUNNER_NAME = {
+  vitest: "Vitest",
+  jest: "Jest",
+  playwright: "Playwright",
+  unknown: "Tests"
+};
+function changeRows(plan) {
+  return plan.changes.map((change) => {
+    const kind = change.additive ? "new exports" : change.classification;
+    const what = change.symbols.length > 0 ? `${kind}: ${inline(change.symbols)}` : kind;
+    const reach = [count(change.dependents, "file")];
+    if (change.crossesInto.length > 0) {
+      reach.push(`into ${inline(change.crossesInto)}`);
+    }
+    reach.push(count(change.tests, "test file"));
+    const reached = change.dependents === 0 && change.tests === 0 && change.risk !== "high" ? "\u2014" : reach.join(", ");
+    return `| **${change.risk}** | ${code(change.filePath)} | ${what} | ${reached} | ${change.reason} |`;
+  });
+}
+function testLines(plan) {
+  const { tests } = plan;
+  if (tests.total === 0) {
+    return ["**Tests:** variant found no TypeScript test files here.", ""];
+  }
+  const lines2 = [
+    tests.all ? `**Tests:** all ${count(tests.total, "test file")}.` : `**Tests:** ${tests.selected} of ${count(tests.total, "test file")}.`,
+    ""
+  ];
+  for (const run of tests.runs) {
+    const where = run.dir === "" ? "" : ` in ${code(run.dir)}`;
+    const how = run.command === void 0 ? "" : `, run by ${code(run.command)}`;
+    lines2.push(
+      `- ${RUNNER_NAME[run.runner]}${where}: ${count(run.files.length, "file")}${how}`
+    );
+  }
+  if (tests.runs.some((run) => run.runner === "jest")) {
+    lines2.push(
+      "",
+      "variant has no Jest adapter yet, so Jest runs are not compared with this plan."
+    );
+  }
+  if (tests.runs.length > 0) lines2.push("");
+  const chains = Object.values(tests.why);
+  if (chains.length > 0) {
+    lines2.push(
+      "<details><summary>Why these tests</summary>",
+      "",
+      "Each line is the import chain from a test to a file this change touches.",
+      "",
+      ...capped(
+        chains.map(
+          (chain) => chain.length === 1 ? `- ${code(chain[0] ?? "")} is itself changed` : `- ${chain.map(code).join(" \u2192 ")}`
+        ),
+        "test"
+      ),
+      "",
+      "</details>",
+      ""
+    );
+  }
+  return lines2;
+}
+function formatPrReportMarkdown(report) {
+  const { plan } = report;
+  const lines2 = [
+    "## Variant PR Report",
+    "",
+    `${count(plan.changes.length, "changed file")} against ${code(plan.baseRef)}.`,
+    ""
+  ];
+  if (plan.changes.length === 0) {
+    lines2.push("_Nothing changed against the base._", "");
+    return lines2.join("\n");
+  }
+  lines2.push(
+    "### What changed",
+    "",
+    "| Risk | File | Change | Reached by | Why |",
+    "|------|------|--------|------------|-----|",
+    ...capped(changeRows(plan), "file"),
+    "",
+    "### What to verify",
+    "",
+    ...testLines(plan)
+  );
+  if (plan.checks.length > 0) {
+    lines2.push(
+      "**Checks** in the packages this change affects:",
+      "",
+      ...capped(
+        plan.checks.map((check) => `- ${check.kind}: ${code(check.command)}`),
+        "check"
+      ),
+      ""
+    );
+  }
+  if (plan.widened.length > 0) {
+    lines2.push(
+      "**Wider than the import graph:**",
+      "",
+      ...plan.widened.map((reason) => `- ${reason}`),
+      ""
+    );
+  }
+  lines2.push("### Not verified", "");
+  if (plan.notVerified.length === 0) {
+    lines2.push(
+      plan.tests.total === 0 ? "_With no test files found, nothing here is verified by a test._" : `_Every changed source file is reached by at least one test in the plan.${plan.changes.some(
+        (change) => change.tests === 0 && change.risk !== "none"
+      ) ? " Configuration and housekeeping files are not counted: no test imports them." : ""}_`,
+      ""
+    );
+  } else {
+    lines2.push(
+      ...capped(
+        plan.notVerified.map((entry) => {
+          const names = entry.symbols.length > 0 ? ` (${inline(entry.symbols)})` : "";
+          const users = entry.usedBy.length > 0 ? ` Imported by ${inline(entry.usedBy)}.` : " Nothing variant indexes imports it.";
+          return `- ${code(entry.filePath)}${names}: ${entry.reason}.${users}`;
+        }),
+        "file"
+      ),
+      ""
+    );
+  }
+  lines2.push(
+    `<sub>Graph resolution: ${plan.resolution}. It says how much of this change variant could follow, not how safe the change is. Reaching a file is not the same as testing what changed in it.</sub>`,
+    ""
+  );
+  if (plan.notes.length > 0) {
+    lines2.push(
+      "<details><summary>Notes</summary>",
+      "",
+      ...plan.notes.map((note) => `- ${note}`),
+      "",
+      "</details>",
+      ""
+    );
+  }
+  return lines2.join("\n");
+}
+
+// src/cli/render/pr.ts
+function symbolSummary(symbols) {
+  const changes = [];
+  if (symbols.added.length > 0) changes.push(`+${symbols.added.length} added`);
+  if (symbols.removed.length > 0) {
+    changes.push(`-${symbols.removed.length} removed`);
+  }
+  if (symbols.changed.length > 0) {
+    changes.push(`~${symbols.changed.length} changed`);
+  }
+  return changes.length > 0 ? `  (${changes.join(", ")})` : "";
+}
+function renderPrCheck(result, printer = getPrinter()) {
+  lines(
+    printer,
+    "",
+    `Base ref: ${result.baseRef}`,
+    `Changed .ts files: ${result.tsFilesChanged}`
+  );
+  if (result.files.length > 0) {
+    lines(printer, "", "File classifications:");
+    for (const file of result.files) {
+      lines(
+        printer,
+        `  ${classificationLabel(file.classification)}  ${file.filePath}${symbolSummary(file.exportedSymbols)}`
+      );
+    }
+  }
+  lines(printer, "", `Verdict: ${verdictText(result.verdict)}`);
+}
+
+// src/cli/commands/pr.ts
+async function registerPrCheckAction(opts) {
+  renderPrCheck(await runPrCheck(process.cwd(), opts));
+}
+async function registerPrReportAction(opts) {
+  const cwd = process.cwd();
+  const report = await buildPrReport(cwd, opts);
+  const content = opts.markdown ? formatPrReportMarkdown(report) : formatPrReportJson(report);
+  if (opts.output === void 0) {
+    lines(getPrinter(), content);
+    return;
+  }
+  await writeFile(path2.resolve(cwd, opts.output), content, "utf8");
+  const kind = opts.markdown ? "Markdown report" : "Report";
+  lines(getPrinter(), `${kind} written to ${opts.output}`);
+}
+export {
+  registerPrCheckAction,
+  registerPrReportAction
+};