@outfitter/tooling 0.3.3 → 0.3.5

package/dist/shared/@outfitter/tooling-amrbp7cm.js

@@ -0,0 +1,102 @@
+// @bun
+// packages/tooling/src/cli/check-boundary-invocations.ts
+import { relative, resolve } from "path";
+var ROOT_RUNS_PACKAGE_SRC = /\bbun(?:x)?\s+(?:run\s+)?(?:\.\.\/|\.\/)?packages\/[^/\s]+\/src\/\S+/;
+var CD_PACKAGE_THEN_RUNS_SRC = /\bcd\s+(?:\.\.\/|\.\/)?packages\/[^/\s]+\s*&&\s*bun(?:x)?\s+(?:run\s+)?(?:\.\.\/|\.\/)?src\/\S+/;
+function detectBoundaryViolation(location) {
+  if (ROOT_RUNS_PACKAGE_SRC.test(location.command)) {
+    return { ...location, rule: "root-runs-package-src" };
+  }
+  if (CD_PACKAGE_THEN_RUNS_SRC.test(location.command)) {
+    return { ...location, rule: "cd-package-then-runs-src" };
+  }
+  return null;
+}
+function findBoundaryViolations(entries) {
+  const violations = [];
+  for (const entry of entries) {
+    for (const [scriptName, command] of Object.entries(entry.scripts)) {
+      const violation = detectBoundaryViolation({
+        file: entry.file,
+        scriptName,
+        command
+      });
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  return violations.toSorted((a, b) => {
+    const fileCompare = a.file.localeCompare(b.file);
+    if (fileCompare !== 0) {
+      return fileCompare;
+    }
+    return a.scriptName.localeCompare(b.scriptName);
+  });
+}
+async function readScriptEntries(cwd, options = {}) {
+  const entries = [];
+  const rootPackagePath = resolve(cwd, "package.json");
+  const candidatePaths = [rootPackagePath];
+  if (options.appManifestRelativePaths) {
+    for (const file of options.appManifestRelativePaths) {
+      candidatePaths.push(resolve(cwd, file));
+    }
+  } else {
+    const appPackageGlob = new Bun.Glob("apps/*/package.json");
+    for (const match of appPackageGlob.scanSync({ cwd })) {
+      candidatePaths.push(resolve(cwd, match));
+    }
+  }
+  const readPackageJson = options.readPackageJson ?? (async (filePath) => await Bun.file(filePath).json());
+  for (const filePath of candidatePaths) {
+    const isRootManifest = filePath === rootPackagePath;
+    try {
+      const pkg = await readPackageJson(filePath);
+      if (!pkg.scripts) {
+        continue;
+      }
+      entries.push({
+        file: relative(cwd, filePath),
+        scripts: pkg.scripts
+      });
+    } catch (error) {
+      if (isRootManifest) {
+        const message = error instanceof Error ? error.message : "unknown parse error";
+        throw new Error(`Failed to read root package manifest (${filePath}): ${message}`);
+      }
+    }
+  }
+  return entries;
+}
+async function runCheckBoundaryInvocations() {
+  const cwd = process.cwd();
+  let entries;
+  try {
+    entries = await readScriptEntries(cwd);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown read failure";
+    process.stderr.write(`Boundary invocation check failed before evaluation: ${message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const violations = findBoundaryViolations(entries);
+  if (violations.length === 0) {
+    process.stdout.write(`No boundary invocation violations detected in root/apps scripts.
+`);
+    process.exitCode = 0;
+    return;
+  }
+  process.stderr.write(`Boundary invocation violations detected:
+
+`);
+  for (const violation of violations) {
+    process.stderr.write(`- ${violation.file}#${violation.scriptName}: ${violation.command}
+`);
+  }
+  process.stderr.write("\nUse canonical command surfaces (e.g. `outfitter repo ...` or package bins) instead of executing packages/*/src directly.\n");
+  process.exitCode = 1;
+}
+
+export { detectBoundaryViolation, findBoundaryViolations, readScriptEntries, runCheckBoundaryInvocations };

package/dist/shared/@outfitter/tooling-ayps7c4x.js

@@ -0,0 +1,58 @@
+// @bun
+// packages/tooling/src/cli/internal/exports-analysis.ts
+function entryToSubpath(entry) {
+  const stripped = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
+  if (stripped === "index") {
+    return ".";
+  }
+  if (stripped.endsWith("/index")) {
+    return `./${stripped.slice(0, -"/index".length)}`;
+  }
+  return `./${stripped}`;
+}
+function compareExports(input) {
+  const { name, actual, expected, path } = input;
+  const actualKeys = new Set(Object.keys(actual));
+  const expectedKeys = new Set(Object.keys(expected));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const key of expectedKeys) {
+    if (!actualKeys.has(key)) {
+      added.push(key);
+    }
+  }
+  for (const key of actualKeys) {
+    if (!expectedKeys.has(key)) {
+      removed.push(key);
+    }
+  }
+  for (const key of actualKeys) {
+    if (expectedKeys.has(key)) {
+      const actualValue = actual[key];
+      const expectedValue = expected[key];
+      if (JSON.stringify(actualValue) !== JSON.stringify(expectedValue)) {
+        changed.push({ key, expected: expectedValue, actual: actualValue });
+      }
+    }
+  }
+  added.sort();
+  removed.sort();
+  changed.sort((a, b) => a.key.localeCompare(b.key));
+  if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+    return { name, status: "ok" };
+  }
+  return {
+    name,
+    status: "drift",
+    drift: {
+      package: name,
+      path: path ?? "",
+      added,
+      removed,
+      changed
+    }
+  };
+}
+
+export { entryToSubpath, compareExports };

package/dist/shared/@outfitter/tooling-c8q6mj8z.js

@@ -0,0 +1,228 @@
+// @bun
+import {
+  analyzeSourceFile,
+  calculateCoverage
+} from "./tooling-5xxctk9b.js";
+
+// packages/tooling/src/cli/internal/pre-push-checks.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import ts from "typescript";
+function getCurrentBranch() {
+  const result = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+  return result.stdout.toString().trim();
+}
+function runGit(args) {
+  try {
+    const result = Bun.spawnSync(["git", ...args], { stderr: "ignore" });
+    if (result.exitCode !== 0) {
+      return { ok: false, lines: [] };
+    }
+    return {
+      ok: true,
+      lines: result.stdout.toString().split(`
+`).map((line) => line.trim()).filter(Boolean)
+    };
+  } catch {
+    return { ok: false, lines: [] };
+  }
+}
+function isRedPhaseBranch(branch) {
+  return branch.endsWith("-tests") || branch.endsWith("/tests") || branch.endsWith("_tests");
+}
+function isScaffoldBranch(branch) {
+  return branch.endsWith("-scaffold") || branch.endsWith("/scaffold") || branch.endsWith("_scaffold");
+}
+function isReleaseBranch(branch) {
+  return branch.startsWith("changeset-release/");
+}
+var TEST_PATH_PATTERNS = [
+  /(^|\/)__tests__\//,
+  /(^|\/)__snapshots__\//,
+  /\.(test|spec)\.[cm]?[jt]sx?$/,
+  /\.snap$/,
+  /(^|\/)(vitest|jest|bun)\.config\.[cm]?[jt]s$/,
+  /(^|\/)tsconfig\.test\.json$/,
+  /(^|\/)\.env\.test(\.|$)/
+];
+function isTestOnlyPath(path) {
+  const normalized = path.replaceAll("\\", "/");
+  return TEST_PATH_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function areFilesTestOnly(paths) {
+  return paths.length > 0 && paths.every((path) => isTestOnlyPath(path));
+}
+function canBypassRedPhaseByChangedFiles(changedFiles) {
+  return changedFiles.deterministic && areFilesTestOnly(changedFiles.files);
+}
+function hasPackageSourceChanges(changedFiles) {
+  const packageSrcPattern = /^packages\/[^/]+\/src\//;
+  return changedFiles.files.some((f) => packageSrcPattern.test(f));
+}
+function resolveBaseRef() {
+  const candidates = [
+    "origin/main",
+    "main",
+    "origin/trunk",
+    "trunk",
+    "origin/master",
+    "master"
+  ];
+  for (const candidate of candidates) {
+    const resolved = runGit(["rev-parse", "--verify", "--quiet", candidate]);
+    if (resolved.ok) {
+      return candidate;
+    }
+  }
+  return;
+}
+function changedFilesFromRange(range) {
+  const result = runGit(["diff", "--name-only", "--diff-filter=d", range]);
+  return {
+    ok: result.ok,
+    files: result.lines
+  };
+}
+function getChangedFilesForPush() {
+  const upstream = runGit([
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{upstream}"
+  ]);
+  if (upstream.ok && upstream.lines[0]) {
+    const rangeResult = changedFilesFromRange(`${upstream.lines[0]}...HEAD`);
+    if (rangeResult.ok) {
+      return {
+        files: rangeResult.files,
+        deterministic: true,
+        source: "upstream"
+      };
+    }
+  }
+  const baseRef = resolveBaseRef();
+  if (baseRef) {
+    const rangeResult = changedFilesFromRange(`${baseRef}...HEAD`);
+    if (rangeResult.ok) {
+      return {
+        files: rangeResult.files,
+        deterministic: true,
+        source: "baseRef"
+      };
+    }
+  }
+  return {
+    files: [],
+    deterministic: false,
+    source: "undetermined"
+  };
+}
+function hasRedPhaseBranchInContext(currentBranch) {
+  let branches = [];
+  try {
+    const gtResult = Bun.spawnSync(["gt", "ls"], { stderr: "pipe" });
+    if (gtResult.exitCode === 0) {
+      branches = gtResult.stdout.toString().split(`
+`).map((line) => line.replace(/^[\u2502\u251C\u2514\u2500\u25C9\u25EF ]*/g, "").replace(/ \(.*/, "")).filter(Boolean);
+    }
+  } catch {}
+  if (branches.length === 0) {
+    const gitResult = Bun.spawnSync([
+      "git",
+      "branch",
+      "--list",
+      "cli/*",
+      "types/*",
+      "contracts/*"
+    ]);
+    branches = gitResult.stdout.toString().split(`
+`).map((line) => line.replace(/^[* ]+/, "")).filter(Boolean);
+  }
+  for (const branch of branches) {
+    if (branch === currentBranch)
+      continue;
+    if (isRedPhaseBranch(branch))
+      return true;
+  }
+  return false;
+}
+function createVerificationPlan(scripts) {
+  if (scripts["verify:push"]) {
+    return { ok: true, scripts: ["verify:push"], source: "verify:push" };
+  }
+  if (scripts["verify:ci"]) {
+    return { ok: true, scripts: ["verify:ci"], source: "verify:ci" };
+  }
+  const requiredScripts = ["typecheck", "build", "test"];
+  const missingRequired = requiredScripts.filter((name) => !scripts[name]);
+  const checkOrLint = scripts["check"] ? "check" : scripts["lint"] ? "lint" : undefined;
+  if (!checkOrLint || missingRequired.length > 0) {
+    const missing = checkOrLint ? missingRequired : [...missingRequired, "check|lint"];
+    return {
+      ok: false,
+      error: `Missing required scripts for strict pre-push verification: ${missing.join(", ")}`
+    };
+  }
+  return {
+    ok: true,
+    scripts: ["typecheck", checkOrLint, "build", "test"],
+    source: "fallback"
+  };
+}
+function readPackageScripts(cwd = process.cwd()) {
+  const packageJsonPath = join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const scripts = parsed.scripts ?? {};
+    const normalized = {};
+    for (const [name, value] of Object.entries(scripts)) {
+      if (typeof value === "string") {
+        normalized[name] = value;
+      }
+    }
+    return normalized;
+  } catch {
+    return {};
+  }
+}
+function checkBunVersion(projectRoot = process.cwd()) {
+  const versionFile = join(projectRoot, ".bun-version");
+  if (!existsSync(versionFile)) {
+    return { matches: true };
+  }
+  const expected = readFileSync(versionFile, "utf-8").trim();
+  const actual = Bun.version;
+  if (expected === actual) {
+    return { matches: true };
+  }
+  return { matches: false, expected, actual };
+}
+async function printTsdocSummary(log) {
+  const glob = new Bun.Glob("packages/*/src/index.ts");
+  const cwd = process.cwd();
+  const allDeclarations = [];
+  for (const entry of glob.scanSync({ cwd })) {
+    const filePath = resolve(cwd, entry);
+    const content = await Bun.file(filePath).text();
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    allDeclarations.push(...analyzeSourceFile(sourceFile));
+  }
+  if (allDeclarations.length === 0)
+    return;
+  const coverage = calculateCoverage(allDeclarations);
+  const parts = [];
+  if (coverage.documented > 0)
+    parts.push(`${coverage.documented} documented`);
+  if (coverage.partial > 0)
+    parts.push(`${coverage.partial} partial`);
+  if (coverage.undocumented > 0)
+    parts.push(`${coverage.undocumented} undocumented`);
+  const BLUE = "\x1B[34m";
+  const RESET = "\x1B[0m";
+  log(`${BLUE}TSDoc${RESET}: ${coverage.percentage}% coverage (${parts.join(", ")} of ${coverage.total} total)`);
+}
+
+export { getCurrentBranch, runGit, isRedPhaseBranch, isScaffoldBranch, isReleaseBranch, isTestOnlyPath, areFilesTestOnly, canBypassRedPhaseByChangedFiles, hasPackageSourceChanges, getChangedFilesForPush, hasRedPhaseBranchInContext, createVerificationPlan, readPackageScripts, checkBunVersion, printTsdocSummary };

package/dist/shared/@outfitter/tooling-cb0b8wsx.d.ts

@@ -0,0 +1,57 @@
+/**
+* Pure analysis functions for comparing maps.
+*
+* Types and stateless comparison logic used by the check-exports command.
+* No filesystem access — all inputs are passed as arguments.
+*
+* @packageDocumentation
+*/
+/** A package.json map: keys are subpaths, values are conditions or strings */
+type ExportMap = Record<string, unknown>;
+/** Describes drift between expected and actual exports for a single package */
+interface ExportDrift {
+	readonly package: string;
+	readonly path: string;
+	readonly added: string[];
+	readonly removed: string[];
+	readonly changed: Array<{
+		readonly key: string;
+		readonly expected: unknown;
+		readonly actual: unknown;
+	}>;
+}
+/** Per-package comparison result */
+interface PackageResult {
+	readonly name: string;
+	readonly status: "ok" | "drift";
+	readonly drift?: ExportDrift;
+}
+/** Aggregated result across all checked packages */
+interface CheckResult {
+	readonly ok: boolean;
+	readonly packages: PackageResult[];
+}
+/** Input for comparing a single package's exports */
+interface CompareInput {
+	readonly name: string;
+	readonly actual: ExportMap;
+	readonly expected: ExportMap;
+	readonly path?: string;
+}
+/**
+* Convert a source entry file path to its subpath.
+*
+* @example
+* entryToSubpath("src/index.ts")       // "."
+* entryToSubpath("src/branded.ts")     // "./branded"
+* entryToSubpath("src/cli/index.ts")   // "./cli"
+* entryToSubpath("src/cli/check.ts")   // "./cli/check"
+*/
+declare function entryToSubpath(entry: string): string;
+/**
+* Compare actual vs expected exports for a single package.
+*
+* Returns a PackageResult with status "ok" or "drift" and detailed diff.
+*/
+declare function compareExports(input: CompareInput): PackageResult;
+export { ExportMap, ExportDrift, PackageResult, CheckResult, CompareInput, entryToSubpath, compareExports };

package/dist/shared/@outfitter/tooling-ctmgnap5.js

@@ -0,0 +1,19 @@
+// @bun
+// packages/tooling/src/version.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+var DEFAULT_VERSION = "0.0.0";
+function readPackageVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgPath = require2.resolve("@outfitter/tooling/package.json");
+    const packageJson = JSON.parse(readFileSync(pkgPath, "utf8"));
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {}
+  return DEFAULT_VERSION;
+}
+var VERSION = readPackageVersion();
+
+export { VERSION };

package/dist/shared/@outfitter/tooling-f8q38e9z.d.ts

@@ -0,0 +1,16 @@
+import { CheckTsDocOptions, TsDocCheckResult } from "./tooling-tj9p41vj.js";
+/** Resolve whether JSON output mode is active. */
+declare function resolveJsonMode(options?: CheckTsDocOptions): boolean;
+/**
+* Print a TSDoc coverage result in human-readable format.
+*
+* Renders a bar chart per package with summary statistics. Writes to stdout/stderr.
+*
+* @param result - The coverage result to print
+* @param options - Display options (strict mode, coverage threshold for warning)
+*/
+declare function printCheckTsdocHuman(result: TsDocCheckResult, options?: {
+	strict?: boolean | undefined;
+	minCoverage?: number | undefined;
+}): void;
+export { resolveJsonMode, printCheckTsdocHuman };

package/dist/shared/@outfitter/tooling-gcdvsqqp.js

@@ -0,0 +1,73 @@
+// @bun
+// packages/tooling/src/cli/check-clean-tree.ts
+function parseGitDiff(diffOutput) {
+  return diffOutput.split(`
+`).map((line) => line.trim()).filter(Boolean);
+}
+function parseUntrackedFiles(lsOutput) {
+  return lsOutput.split(`
+`).map((line) => line.trim()).filter(Boolean);
+}
+function isCleanTree(status) {
+  return status.modified.length === 0 && status.untracked.length === 0;
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  dim: "\x1B[2m"
+};
+async function runCheckCleanTree(options = {}) {
+  const pathArgs = options.paths ?? [];
+  const diffResult = Bun.spawnSync(["git", "diff", "HEAD", "--name-only", "--", ...pathArgs], { stderr: "pipe" });
+  if (diffResult.exitCode !== 0) {
+    process.stderr.write(`Failed to run git diff
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const modified = parseGitDiff(diffResult.stdout.toString());
+  const lsResult = Bun.spawnSync(["git", "ls-files", "--others", "--exclude-standard", "--", ...pathArgs], { stderr: "pipe" });
+  if (lsResult.exitCode !== 0) {
+    process.stderr.write(`Failed to run git ls-files
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const untracked = parseUntrackedFiles(lsResult.stdout.toString());
+  const clean = modified.length === 0 && untracked.length === 0;
+  const status = { clean, modified, untracked };
+  if (status.clean) {
+    process.stdout.write(`${COLORS.green}Working tree is clean.${COLORS.reset}
+`);
+    process.exitCode = 0;
+    return;
+  }
+  process.stderr.write(`${COLORS.red}Working tree is dirty after verification:${COLORS.reset}
+
+`);
+  if (modified.length > 0) {
+    process.stderr.write(`Modified files:
+`);
+    for (const file of modified) {
+      process.stderr.write(`  ${COLORS.dim}M${COLORS.reset} ${file}
+`);
+    }
+  }
+  if (untracked.length > 0) {
+    process.stderr.write(`Untracked files:
+`);
+    for (const file of untracked) {
+      process.stderr.write(`  ${COLORS.dim}?${COLORS.reset} ${file}
+`);
+    }
+  }
+  process.stderr.write(`
+This likely means a build step produced uncommitted changes.
+`);
+  process.stderr.write(`Commit these changes or add them to .gitignore.
+`);
+  process.exitCode = 1;
+}
+
+export { parseGitDiff, parseUntrackedFiles, isCleanTree, runCheckCleanTree };

package/dist/shared/@outfitter/tooling-h5dnevjw.js

@@ -0,0 +1,139 @@
+// @bun
+// packages/tooling/src/cli/check-home-paths.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { resolve } from "path";
+function formatLeakLineText(lineText) {
+  return lineText.trimEnd();
+}
+function writeLeakSummary(stderr, leaks) {
+  stderr.write(`Hardcoded home directory paths detected:
+`);
+  for (const leak of leaks) {
+    stderr.write(`  ${leak.filePath}:${leak.line}:${leak.column} ${formatLeakLineText(leak.lineText)}
+`);
+  }
+}
+function writeReplacementHint(stderr, leaks) {
+  const matchedText = leaks[0]?.matchedText;
+  if (!matchedText) {
+    return;
+  }
+  stderr.write(`
+Replace ${JSON.stringify(matchedText)} with a repo-relative or home-agnostic path before committing.
+`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildHomePathPattern(homePath) {
+  if (homePath.trim().length === 0) {
+    return;
+  }
+  const patternSource = homePath.split(/(\\+)/).map((segment) => segment.includes("\\") ? "\\\\+" : escapeRegExp(segment)).join("");
+  return new RegExp(`${patternSource}(?![\\w.-])`, "g");
+}
+function findHomePathLeaks(content, homePathOrPattern) {
+  let pattern;
+  if (homePathOrPattern instanceof RegExp) {
+    if (!homePathOrPattern.flags.includes("g")) {
+      throw new TypeError("findHomePathLeaks: RegExp must have the global (g) flag set");
+    }
+    pattern = homePathOrPattern;
+  } else {
+    pattern = buildHomePathPattern(homePathOrPattern);
+  }
+  if (!pattern) {
+    return [];
+  }
+  const leaks = [];
+  const lines = content.split(/\r?\n/);
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    for (const match of line.matchAll(pattern)) {
+      leaks.push({
+        line: index + 1,
+        column: (match.index ?? 0) + 1,
+        matchedText: match[0],
+        lineText: line
+      });
+    }
+  }
+  return leaks;
+}
+function scanFilesForHardcodedHomePaths(filePaths, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const homePath = options.homeDir ?? homedir();
+  const readFile = options.readFile ?? readFileSync;
+  const leaks = [];
+  const failures = [];
+  const pattern = buildHomePathPattern(homePath);
+  if (!pattern) {
+    return { leaks, failures };
+  }
+  for (const filePath of filePaths) {
+    const absolutePath = resolve(cwd, filePath);
+    let fileContent;
+    try {
+      fileContent = readFile(absolutePath, "utf-8");
+    } catch (error) {
+      const errno = error;
+      if (errno.code === "ENOENT") {
+        continue;
+      }
+      failures.push({
+        filePath,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    const fileLeaks = findHomePathLeaks(fileContent, pattern);
+    for (const leak of fileLeaks) {
+      leaks.push({
+        filePath,
+        ...leak
+      });
+    }
+  }
+  return { leaks, failures };
+}
+function runCheckHomePaths(paths, options = {}) {
+  const stderr = options.stderr ?? process.stderr;
+  const setExitCode = options.setExitCode ?? ((code) => {
+    process.exitCode = code;
+  });
+  const { failures, leaks } = scanFilesForHardcodedHomePaths(paths, options.scanOptions);
+  if (failures.length > 0) {
+    const unreadableTarget = failures.length === 1 ? "file" : "files";
+    stderr.write(`Unreadable ${unreadableTarget} while scanning for hardcoded home paths:
+`);
+    for (const failure of failures) {
+      stderr.write(`  ${failure.filePath}: ${failure.reason}
+`);
+    }
+    if (leaks.length > 0) {
+      stderr.write(`
+`);
+      writeLeakSummary(stderr, leaks);
+      writeReplacementHint(stderr, leaks);
+      stderr.write(`
+`);
+    } else {
+      stderr.write(`
+`);
+    }
+    stderr.write(`Fix file permissions or remove the unreadable ${unreadableTarget} before committing.
+`);
+    setExitCode(1);
+    return;
+  }
+  if (leaks.length === 0) {
+    setExitCode(0);
+    return;
+  }
+  writeLeakSummary(stderr, leaks);
+  writeReplacementHint(stderr, leaks);
+  setExitCode(1);
+}
+
+export { findHomePathLeaks, scanFilesForHardcodedHomePaths, runCheckHomePaths };