@lariocpt/flawless-react 0.0.0-stage → 0.3.1

package/src/runner/runTests.ts

@@ -0,0 +1,402 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, rmSync, symlinkSync } from "node:fs";
+import path from "node:path";
+import type { AffectedSpecs } from "../changed.ts";
+import { grepFor, grepForRoutes } from "../changed.ts";
+import { VITEST_CONFIG } from "../suiteScripts.ts";
+import type { TaskId } from "../types.ts";
+
+/** One suite invocation the runner will spawn, in order. */
+export interface PlannedRun {
+  id: string;
+  cmd: string[];
+}
+
+/**
+ * The command plan for a full generated-suite run — a PURE function (FR-019:
+ * the two shipped bugs in this module both lived in these branches, guarded
+ * only by comments; tests/runPlan.test.ts pins the matrix now).
+ *
+ * Standalone suites carry test:* scripts in their own package.json; Next.js
+ * mode runs the target project's flawless:* scripts. The browser suite needs
+ * BOTH unit-browser and perf-harness: its specs mount through perf-harness's
+ * host, so the script exists only when both were generated — asking for it
+ * otherwise invoked a script that had never been written. Standalone suites
+ * have no e2e script at all.
+ */
+/**
+ * What a suite-run phase actually DID.
+ *
+ * `ran` is the number of suites that were spawned, and it exists because
+ * `green` alone cannot tell "every suite passed" from "no suite ran" — both
+ * were `true`. Both runners returned that bare boolean and both said so out
+ * loud ("all generated/affected suites passed") over an EMPTY plan, which is
+ * the false pass this project exists to kill: FR-042 reached it through plain
+ * `--changed --tasks e2e`, FR-043 through `--run-tests` with an `--out` dir
+ * that happened to hold a package.json.
+ *
+ * The rule at every call site: check `ran === 0` BEFORE reading `green`.
+ */
+export interface SuiteRunOutcome {
+  /** Suites actually spawned. Zero means nothing ran — never report green. */
+  ran: number;
+  /** No spawned suite failed. Meaningless unless `ran > 0`. */
+  green: boolean;
+  /** Why nothing ran. Set exactly when `ran === 0`, for the caller to relay. */
+  reason?: string;
+}
+
+export function planGeneratedRuns(selectedTasks: TaskId[], standalone: boolean): PlannedRun[] {
+  const prefix = standalone ? "test" : "flawless";
+  const script = (name: string): string[] => ["bun", "run", `${prefix}:${name}`];
+  const runs: PlannedRun[] = [];
+  if (selectedTasks.includes("unit-browser")) runs.push({ id: "unit", cmd: script("unit") });
+  if (selectedTasks.includes("perf-harness")) runs.push({ id: "perf", cmd: script("perf") });
+  if (selectedTasks.includes("unit-browser") && selectedTasks.includes("perf-harness")) {
+    runs.push({ id: "browser", cmd: script("browser") });
+  }
+  if (!standalone && selectedTasks.includes("e2e")) {
+    runs.push({ id: "e2e", cmd: script("e2e") });
+  }
+  return runs;
+}
+
+/**
+ * Run the generated suites. Standalone mode (no nextRoot): the suite is its
+ * own package under outDir with test:* scripts. Next.js mode: the target
+ * project's package.json carries flawless:* scripts and owns node_modules,
+ * so everything runs with cwd = nextRoot.
+ */
+export async function runGeneratedTests(
+  outDir: string,
+  selectedTasks: TaskId[],
+  nextRoot?: string,
+  quiet = false,
+): Promise<SuiteRunOutcome> {
+  // Under --json/--ci stdout is contractually one JSON blob; in quiet mode
+  // everything the runner says — and the child suites' own stdout — goes to
+  // stderr so the blob stays parseable on exactly the red runs it exists for.
+  const say = sayInto(quiet);
+  const standalone = existsSync(path.join(path.resolve(outDir), "package.json"));
+  const cwd = standalone ? path.resolve(outDir) : (nextRoot ?? path.resolve(outDir));
+
+  if (!existsSync(path.join(cwd, "node_modules"))) {
+    say(`\n› bun install in ${cwd}\n`);
+    await spawn("bun", ["install"], cwd, quiet);
+  }
+
+  const wantsPlaywright =
+    selectedTasks.includes("perf-harness") ||
+    selectedTasks.includes("unit-browser") ||
+    selectedTasks.includes("e2e");
+  if (wantsPlaywright) {
+    await ensureChromium(cwd, quiet);
+  }
+
+  const scripts = planGeneratedRuns(selectedTasks, standalone);
+
+  // FR-043. Checked BEFORE anything is spawned, because the loop below cannot
+  // distinguish an empty plan from a plan that all passed — it reports both as
+  // "all generated suites passed".
+  //
+  // The previous comment here claimed this was unreachable through runCore.
+  // That was WRONG, and the correctness lens refuted it with a repro:
+  // `standalone` is `existsSync(outDir/package.json)`, NOT "outside Next.js
+  // mode". Point --out at any directory holding a package.json — a leftover
+  // standalone suite, a package root — and `standalone` is true inside Next.js
+  // mode, where planGeneratedRuns(["e2e"], true) plans nothing at all.
+  if (scripts.length === 0) {
+    const reason = `no generated suite matched the selected task(s): ${selectedTasks.join(", ")}`;
+    say(`\n${reason}\n`);
+    return { ran: 0, green: true, reason };
+  }
+
+  // The vitest plane is the one that pays for a second physical React (see
+  // healReactIdentity). Repair after any install has rewritten the tree.
+  if (standalone && scripts.some((s) => s.id === "unit")) {
+    const healed = healReactIdentity(path.resolve(outDir));
+    if (healed.length > 0) say(`\n› healed dual-React copies: ${healed.join(", ")}\n`);
+  }
+
+  const failed: string[] = [];
+  for (const s of scripts) {
+    say(`\n› ${s.cmd.join(" ")}\n`);
+    const ok = await spawn(s.cmd[0] as string, s.cmd.slice(1), cwd, quiet);
+    if (!ok) failed.push(s.id);
+  }
+
+  if (failed.length > 0) {
+    say(`\nfailed suites: ${failed.join(", ")}\n`);
+    return { ran: scripts.length, green: false };
+  }
+  say("\nall generated suites passed\n");
+  return { ran: scripts.length, green: true };
+}
+
+function sayInto(quiet: boolean): (s: string) => void {
+  return (s) => void (quiet ? process.stderr : process.stdout).write(s);
+}
+
+/**
+ * Collapse the suite's separate physical copies of react/react-dom onto the
+ * app's copy, in place, right before a vitest run.
+ *
+ * Every request-level pin (vitest aliases, deps.inline, the app-version
+ * dependency) has been tried, and pnpm's layout defeats them all: an
+ * internalised package's own require("react") resolves by plain node rules
+ * from its realpath under the SUITE's .pnpm root, so the renderer and the
+ * app's context libraries land on two physical copies — same version,
+ * separate hook dispatchers ("Cannot read properties of null (reading
+ * 'useContext')"). Only module IDENTITY fixes it, and identity is
+ * filesystem-level: node's require cache is keyed by realpath, so the suite
+ * tree must not CONTAIN a second react. The top-level entries and the
+ * @testing-library peer links under .pnpm are replaced with relative
+ * symlinks to the app's copy (absolute links would break a moved checkout).
+ *
+ * Best-effort by design: every failure is swallowed, a re-run after any
+ * `install` (which rewrites the links) heals again, and suites whose app
+ * has no installed react are left exactly as they were.
+ */
+export function healReactIdentity(suiteDir: string): string[] {
+  const suiteNm = path.join(suiteDir, "node_modules");
+  if (!existsSync(suiteNm)) return [];
+  let appNm: string | undefined;
+  let dir = path.dirname(suiteDir);
+  for (let hop = 0; hop < 8 && !appNm; hop++) {
+    const nm = path.join(dir, "node_modules");
+    if (existsSync(path.join(nm, "react"))) appNm = nm;
+    else {
+      const up = path.dirname(dir);
+      if (up === dir) break;
+      dir = up;
+    }
+  }
+  if (!appNm) return [];
+  const app = appNm;
+  const healed: string[] = [];
+  const versionOf = (dir: string): string | undefined => {
+    try {
+      return (
+        JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8")) as { version?: string }
+      ).version;
+    } catch {
+      return undefined;
+    }
+  };
+  const repair = (entry: string, name: string): void => {
+    const appCopy = path.join(app, name);
+    try {
+      // Only copies the suite ACTUALLY carries are replaced; a missing entry
+      // already resolves outward toward the app, and inventing links in a
+      // package-manager-managed tree invites that manager's corrections.
+      if (!existsSync(entry) || realpathSync(entry) === realpathSync(appCopy)) return;
+      // Never collapse copies that disagree on version: react-dom@N is only
+      // a renderer for react@N, and the suite's pair is internally
+      // consistent. Linking across versions turns a broken-but-rendering
+      // dual-React suite into a crashed renderer.
+      const from = versionOf(entry);
+      const to = versionOf(appCopy);
+      if (from && to && from !== to) return;
+      rmSync(entry, { recursive: true, force: true });
+      symlinkSync(path.relative(path.dirname(entry), appCopy), entry);
+      healed.push(path.relative(suiteDir, entry));
+    } catch {
+      /* permission or a busy tree: the suite runs on what it has */
+    }
+  };
+  for (const name of ["react", "react-dom"]) {
+    repair(path.join(suiteNm, name), name);
+    // pnpm's peer links are where the split actually bites: RTL renders
+    // through ITS react-dom peer, so replacing only the top level left the
+    // dual instance exactly where it was.
+    let pnpmDirs: string[];
+    try {
+      pnpmDirs = readdirSync(path.join(suiteNm, ".pnpm"));
+    } catch {
+      pnpmDirs = [];
+    }
+    for (const d of pnpmDirs) {
+      if (!d.startsWith("@testing-library")) continue;
+      const peer = path.join(suiteNm, ".pnpm", d, "node_modules", name);
+      if (existsSync(peer)) repair(peer, name);
+    }
+  }
+  return healed;
+}
+
+/**
+ * Best-effort chromium install so Playwright suites run hands-free. No
+ * --with-deps (it sudo-prompts on Linux and would hang unattended runs);
+ * bounded by a kill-timer; opt out with FLAWLESS_SKIP_BROWSER_INSTALL=1.
+ */
+const INSTALL_TIMEOUT_MS = 300_000;
+
+async function ensureChromium(cwd: string, quiet = false): Promise<void> {
+  if (process.env.FLAWLESS_SKIP_BROWSER_INSTALL === "1") return;
+  sayInto(quiet)(
+    "\n› bunx playwright install chromium (set FLAWLESS_SKIP_BROWSER_INSTALL=1 to skip)\n",
+  );
+  const proc = Bun.spawn(["bunx", "playwright", "install", "chromium"], {
+    cwd,
+    // fd 2: in quiet mode even the child's stdout belongs on stderr.
+    stdout: quiet ? 2 : "inherit",
+    stderr: "inherit",
+  });
+  const timer = setTimeout(() => proc.kill(), INSTALL_TIMEOUT_MS);
+  const code = await proc.exited;
+  clearTimeout(timer);
+  if (code !== 0) {
+    process.stderr.write(
+      "playwright browser install failed — if suites can't find a browser, run: bunx playwright install chromium --with-deps\n",
+    );
+  }
+}
+
+async function spawn(cmd: string, args: string[], cwd: string, quiet = false): Promise<boolean> {
+  const proc = Bun.spawn([cmd, ...args], {
+    cwd,
+    // fd 2: in quiet mode the child suite's stdout must not contaminate the
+    // parent's stdout (the --json blob is the only thing allowed there).
+    stdout: quiet ? 2 : "inherit",
+    stderr: "inherit",
+  });
+  const code = await proc.exited;
+  return code === 0;
+}
+
+/**
+ * Run only the suites that cover the changed components.
+ *
+ * Two different narrowing mechanisms, because the two runners offer different
+ * and better ones:
+ *
+ * - **vitest `--related`** walks the module graph, so it finds every spec that
+ *   imports a changed file without the tool having to reproduce its own spec
+ *   naming rules. It is also transitively correct for free.
+ * - **Playwright `--grep`** anchored on `\b(Name): `, because every emitted
+ *   title starts that way. Anchoring matters: a bare "Card" would also select
+ *   CardHeader, CardFooter and CardTitle.
+ *
+ * e2e is selected by whether a page's tree RENDERS a changed component — the
+ * relationship a path filter cannot see — and narrowed the same way, by
+ * grepping for the route templates its titles embed.
+ */
+/**
+ * The command plan for an affected-only run — pure, same discipline as
+ * planGeneratedRuns. Unit narrowing keys on changed FILES (vitest `related`
+ * walks the module graph from them), so it fires even when components+routes
+ * are empty — the case of a change confined to an unexported component, which
+ * has no spec name of its own but whose parent's spec DOES import it. An
+ * affected set that matches no branch plans nothing; runAffectedTests then
+ * reports why (nothing affected, or affected-but-unnarrowable).
+ */
+export function planAffectedRuns(
+  outDir: string,
+  selectedTasks: TaskId[],
+  affected: AffectedSpecs,
+  standalone: boolean,
+): PlannedRun[] {
+  // No blanket empty-set early return: the unit branch below keys on
+  // affected.changedFiles, not components/routes, so vitest `related` must
+  // still fire for a change confined to an UNEXPORTED component (no spec name
+  // of its own, so components is empty) — related walks the module graph from
+  // the file and reaches the parent's spec. An all-empty affected set still
+  // matches no branch and returns [] naturally; runAffectedTests then reports
+  // why. The old early return made --changed report "nothing affected" and
+  // exit 0 green for exactly that change.
+  const runs: PlannedRun[] = [];
+  const prefix = standalone ? "test" : "flawless";
+
+  if (selectedTasks.includes("unit-browser") && affected.changedFiles.length > 0) {
+    // `related` is a vitest SUBCOMMAND, not a flag, so it cannot be appended to
+    // the generated `vitest run` script — vitest exits with "Unknown option
+    // --related". Invoking vitest directly with the emitted config is the only
+    // way to reach it, and it is worth reaching: it walks the module graph, so
+    // it finds every spec that transitively imports a changed file without this
+    // tool having to reproduce its own spec-naming rules.
+    const configPath = path.join(path.resolve(outDir), VITEST_CONFIG);
+    runs.push({
+      id: "unit",
+      cmd: ["bunx", "vitest", "related", ...affected.changedFiles, "--run", "--config", configPath],
+    });
+  }
+  if (affected.components.length > 0) {
+    const grep = grepFor(affected.components);
+    if (selectedTasks.includes("perf-harness")) {
+      runs.push({ id: "perf", cmd: ["bun", "run", `${prefix}:perf`, "--", "--grep", grep] });
+    }
+    if (selectedTasks.includes("unit-browser") && selectedTasks.includes("perf-harness")) {
+      runs.push({ id: "browser", cmd: ["bun", "run", `${prefix}:browser`, "--", "--grep", grep] });
+    }
+  }
+  if (selectedTasks.includes("e2e") && affected.routes.length > 0) {
+    // Same narrowing as perf/browser: every emitted e2e title embeds its route
+    // template ("GET /things/[id] renders …"), so the affected routes select
+    // their specs by grep — the whole suite must not run for one route.
+    runs.push({
+      id: "e2e",
+      cmd: ["bun", "run", `${prefix}:e2e`, "--", "--grep", grepForRoutes(affected.routes)],
+    });
+  }
+  return runs;
+}
+
+export async function runAffectedTests(
+  outDir: string,
+  selectedTasks: TaskId[],
+  affected: AffectedSpecs,
+  nextRoot?: string,
+  quiet = false,
+): Promise<SuiteRunOutcome> {
+  const say = sayInto(quiet);
+  const standalone = existsSync(path.join(path.resolve(outDir), "package.json"));
+  const cwd = standalone ? path.resolve(outDir) : (nextRoot ?? path.resolve(outDir));
+
+  const runs = planAffectedRuns(outDir, selectedTasks, affected, standalone);
+  // FR-042. The old guard demanded runs.length === 0 AND both affected sets
+  // empty, so an empty plan WITH affected work fell through the loop below and
+  // announced "all affected suites passed" having spawned nothing. Two plain
+  // routes reached it: --changed --tasks e2e when the edited component sits on
+  // no page route, and --changed --tasks perf-harness when the only affected
+  // work is a route. The plan being empty is the whole condition — what made
+  // it empty only decides which sentence to say.
+  if (runs.length === 0) {
+    // withoutSpecs in the "nothing" test is load-bearing: a change confined to
+    // unexported components is NOT "nothing affected" — the file changed and
+    // is covered through a parent's spec. It is simply not reachable by a
+    // task set that narrows by spec name.
+    const nothingAffected =
+      affected.components.length === 0 &&
+      affected.routes.length === 0 &&
+      affected.withoutSpecs.length === 0;
+    let reason: string;
+    if (nothingAffected) {
+      reason = "changed: nothing affected — no specs to run";
+    } else if (affected.components.length === 0 && affected.routes.length === 0) {
+      reason = `changed: ${affected.withoutSpecs.length} unexported component(s) changed (covered through a parent's spec), but the selected task(s) (${selectedTasks.join(", ")}) narrow by spec name and cannot reach them — add unit-browser to run vitest \`related\``;
+    } else {
+      reason = `changed: ${affected.components.length} affected component(s) and ${affected.routes.length} affected route(s), but the selected task(s) (${selectedTasks.join(", ")}) plan no run for them`;
+    }
+    say(`\n${reason}\n`);
+    return { ran: 0, green: true, reason };
+  }
+
+  // Same repair as the full run: vitest is the plane that pays for two
+  // physical Reacts, and --changed runs it just as hard.
+  if (standalone && runs.some((r) => r.id === "unit")) {
+    const healed = healReactIdentity(path.resolve(outDir));
+    if (healed.length > 0) say(`\n› healed dual-React copies: ${healed.join(", ")}\n`);
+  }
+
+  const failed: string[] = [];
+  for (const r of runs) {
+    say(`\n› ${r.cmd.join(" ")}\n`);
+    const ok = await spawn(r.cmd[0] as string, r.cmd.slice(1), cwd, quiet);
+    if (!ok) failed.push(r.id);
+  }
+  if (failed.length > 0) {
+    say(`\nfailed suites: ${failed.join(", ")}\n`);
+    return { ran: runs.length, green: false };
+  }
+  say("\nall affected suites passed\n");
+  return { ran: runs.length, green: true };
+}

package/src/scaffold/adoptStyle.ts

@@ -0,0 +1,181 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Make generated files conform to the HOST project's formatter so flawless
+ * output never churns a target repo's lint/format state. Detection walks up
+ * from the project root: biome config → run the project's own biome;
+ * prettier config → run prettier; neither → leave files untouched.
+ * Failures are warnings, never task failures.
+ */
+
+export interface AdoptStyleResult {
+  formatter: "biome" | "prettier" | "none";
+  formatted: number;
+  warning?: string;
+}
+
+// .html is deliberately excluded: biome's HTML formatting is not stable enough
+// to churn the emitted host/index.html.
+const FORMATTABLE = /\.(tsx?|jsx?|mts|cts|mjs|cjs|jsonc?|css|md)$/;
+
+export async function adoptProjectStyle(
+  projectRoot: string,
+  writtenFiles: string[],
+): Promise<AdoptStyleResult> {
+  const files = writtenFiles.filter((f) => FORMATTABLE.test(f) && existsSync(f));
+  if (files.length === 0) return { formatter: "none", formatted: 0 };
+
+  const biomeDir = findUp(projectRoot, ["biome.json", "biome.jsonc"]);
+  if (biomeDir) {
+    const bin = resolveLocalBin(biomeDir.dir, "biome") ?? Bun.which("biome");
+    if (bin) {
+      const proc = Bun.spawn([bin, "check", "--write", "--no-errors-on-unmatched", ...files], {
+        cwd: biomeDir.dir,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const code = await proc.exited;
+      if (code === 0 || code === 1) {
+        // biome exits 1 when unfixable diagnostics remain — files are still formatted.
+        return { formatter: "biome", formatted: files.length };
+      }
+      const stderr = await new Response(proc.stderr).text();
+      return {
+        formatter: "biome",
+        formatted: 0,
+        warning: `biome check --write exited ${code}: ${stderr.slice(0, 300)}`,
+      };
+    }
+    return { formatter: "biome", formatted: 0, warning: "biome config found but no biome binary" };
+  }
+
+  const prettierDir = findUp(projectRoot, [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.yaml",
+    ".prettierrc.yml",
+    "prettier.config.js",
+    "prettier.config.cjs",
+  ]);
+  const hasPrettierConfig = prettierDir !== undefined || packageJsonHasPrettier(projectRoot);
+  if (hasPrettierConfig) {
+    const cwd = prettierDir?.dir ?? projectRoot;
+    const bin = resolveLocalBin(cwd, "prettier") ?? Bun.which("prettier");
+    const cmd = bin ? [bin] : ["bunx", "prettier"];
+    // Ignore files govern the repo's sweeps, not the tool's own conformance pass.
+    // prettier skips ignored files even when they are passed explicitly (proven on
+    // 3.0.3), so once a run appends `flawless/` to the repo's .prettierignore the
+    // format pass would silently stop formatting the suite it just wrote — and
+    // any pre-existing repo ignore covering an output directory already had that
+    // effect. An empty ignore path keeps the pass alive for exactly the files the
+    // tool passed; the repo's own ignore still owns the repo's own sweeps.
+    const ignoreOverride = path.join(os.tmpdir(), "flawless-empty.prettierignore");
+    writeFileSync(ignoreOverride, "");
+    const proc = Bun.spawn(
+      [...cmd, "--write", "--ignore-unknown", "--ignore-path", ignoreOverride, ...files],
+      {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+    const code = await proc.exited;
+    if (code === 0) return { formatter: "prettier", formatted: files.length };
+    const stderr = await new Response(proc.stderr).text();
+    // Syntax the repo's pinned prettier predates - `with { type: "json" }`
+    // import attributes need prettier 3.1, and the tool's specs use them.
+    // Those files are still valid TS the app's own toolchain accepts; the
+    // honest degrade is to skip THOSE and format the rest, not to abandon
+    // the whole pass. (Repo CI never sees any of them: the ignore files
+    // say so.)
+    // Normalize both sides: prettier reports paths relative to its cwd,
+    // while the caller's list may be absolute.
+    const unparseable = new Set<string>();
+    for (const m of stderr.matchAll(/^\[error\] (\S+):/gm)) {
+      if (m[1] !== undefined) unparseable.add(path.resolve(cwd, m[1]));
+    }
+    if (/SyntaxError/.test(stderr) && unparseable.size > 0 && unparseable.size < files.length) {
+      const rest = files.filter((f) => !unparseable.has(path.resolve(cwd, f)));
+      if (rest.length > 0) {
+        const retry = Bun.spawn(
+          [...cmd, "--write", "--ignore-unknown", "--ignore-path", ignoreOverride, ...rest],
+          { cwd, stdout: "pipe", stderr: "pipe" },
+        );
+        if ((await retry.exited) === 0) {
+          return {
+            formatter: "prettier",
+            formatted: rest.length,
+            warning: `prettier could not parse ${unparseable.size} generated file(s) - its version predates their syntax; the remaining ${rest.length} were formatted`,
+          };
+        }
+      }
+    }
+    if (/SyntaxError/.test(stderr)) {
+      return {
+        formatter: "prettier",
+        formatted: 0,
+        warning: `prettier could not parse the generated files (its version predates their syntax) - style pass skipped: ${stderr.slice(0, 160)}`,
+      };
+    }
+    return {
+      formatter: "prettier",
+      formatted: 0,
+      warning: `prettier --write exited ${code}: ${stderr.slice(0, 300)}`,
+    };
+  }
+
+  return { formatter: "none", formatted: 0 };
+}
+
+/** Detect a JSON file's indentation so merges preserve it (tabs beat spaces). */
+export function detectJsonIndent(source: string): string {
+  const m = source.match(/^(\t+|[ ]+)"/m);
+  if (!m?.[1]) return "  ";
+  return m[1].startsWith("\t") ? "\t" : " ".repeat(m[1].length);
+}
+
+/** Stringify preserving the original file's indentation and final newline. */
+export function stringifyLike(original: string, value: unknown): string {
+  const indent = detectJsonIndent(original);
+  const trailingNewline = original.endsWith("\n") ? "\n" : "";
+  return `${JSON.stringify(value, null, indent)}${trailingNewline}`;
+}
+
+function findUp(fromDir: string, names: string[]): { dir: string; file: string } | undefined {
+  let dir = path.resolve(fromDir);
+  for (;;) {
+    for (const name of names) {
+      const candidate = path.join(dir, name);
+      if (existsSync(candidate)) return { dir, file: candidate };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function resolveLocalBin(fromDir: string, name: string): string | undefined {
+  let dir = path.resolve(fromDir);
+  for (;;) {
+    const candidate = path.join(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function packageJsonHasPrettier(projectRoot: string): boolean {
+  const found = findUp(projectRoot, ["package.json"]);
+  if (!found) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(found.file, "utf8")) as Record<string, unknown>;
+    return pkg.prettier !== undefined;
+  } catch {
+    return false;
+  }
+}