@outfitter/tooling 0.3.3 → 0.3.5

package/dist/cli/index.js

@@ -1,1229 +1,62 @@
 #!/usr/bin/env bun
+// @bun
+import {
+  runCheckCleanTree
+} from "../shared/@outfitter/tooling-gcdvsqqp.js";
+import {
+  runCheckHomePaths
+} from "../shared/@outfitter/tooling-h5dnevjw.js";
+import {
+  runInit
+} from "../shared/@outfitter/tooling-9ram55dd.js";
+import {
+  runPrePush
+} from "../shared/@outfitter/tooling-2vv5y3s4.js";
+import"../shared/@outfitter/tooling-c8q6mj8z.js";
+import {
+  runFix
+} from "../shared/@outfitter/tooling-1hez6j9d.js";
+import {
+  runCheckBoundaryInvocations
+} from "../shared/@outfitter/tooling-amrbp7cm.js";
 import {
-  VERSION,
-  analyzeSourceFile,
-  calculateCoverage,
   runCheckTsdoc
-} from "../shared/chunk-cmde0fwx.js";
+} from "../shared/@outfitter/tooling-a59br34g.js";
+import"../shared/@outfitter/tooling-7437rmy6.js";
+import"../shared/@outfitter/tooling-5ynz680q.js";
+import"../shared/@outfitter/tooling-5xxctk9b.js";
+import {
+  runCheckExports
+} from "../shared/@outfitter/tooling-0zjz8eg9.js";
+import"../shared/@outfitter/tooling-a6q3zh7t.js";
+import"../shared/@outfitter/tooling-ayps7c4x.js";
+import {
+  runCheck
+} from "../shared/@outfitter/tooling-a4bfx4be.js";
+import {
+  runCheckBunupRegistry
+} from "../shared/@outfitter/tooling-wwm97f47.js";
+import {
+  runUpgradeBun
+} from "../shared/@outfitter/tooling-pq47jv6t.js";
+import"../shared/@outfitter/tooling-mkynjra9.js";
+import {
+  VERSION
+} from "../shared/@outfitter/tooling-ctmgnap5.js";
+import {
+  runCheckChangeset
+} from "../shared/@outfitter/tooling-mq2xvz96.js";
+import {
+  runCheckMarkdownLinks
+} from "../shared/@outfitter/tooling-ja1zg5yc.js";
 import {
   __require
-} from "../shared/chunk-3s189drz.js";
+} from "../shared/@outfitter/tooling-jnrs9rqd.js";
 
-// src/cli/index.ts
+// packages/tooling/src/cli/index.ts
 import { exitWithError } from "@outfitter/cli";
 import { createCLI } from "@outfitter/cli/command";
 import { Command } from "commander";
-
-// src/cli/check.ts
-function buildCheckCommand(options) {
-  const cmd = ["ultracite", "check"];
-  if (options.paths && options.paths.length > 0) {
-    cmd.push(...options.paths);
-  }
-  return cmd;
-}
-async function runCheck(paths = []) {
-  const cmd = buildCheckCommand({ paths });
-  process.stdout.write(`Running: bun x ${cmd.join(" ")}
-`);
-  const proc = Bun.spawn(["bun", "x", ...cmd], {
-    stdio: ["inherit", "inherit", "inherit"]
-  });
-  const exitCode = await proc.exited;
-  process.exit(exitCode);
-}
-
-// src/cli/check-boundary-invocations.ts
-import { relative, resolve } from "node: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.sort((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.exit(1);
-  }
-  const violations = findBoundaryViolations(entries);
-  if (violations.length === 0) {
-    process.stdout.write(`No boundary invocation violations detected in root/apps scripts.
-`);
-    process.exit(0);
-  }
-  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.exit(1);
-}
-
-// src/cli/check-bunup-registry.ts
-import { resolve as resolve2 } from "node:path";
-function extractBunupFilterName(script) {
-  const match = script.match(/bunup\s+--filter\s+(\S+)/);
-  return match?.[1] ?? null;
-}
-function findUnregisteredPackages(packagesWithFilter, registeredNames) {
-  const registered = new Set(registeredNames);
-  const missing = packagesWithFilter.filter((name) => !registered.has(name)).sort();
-  return {
-    ok: missing.length === 0,
-    missing
-  };
-}
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m"
-};
-async function runCheckBunupRegistry() {
-  const cwd = process.cwd();
-  const configPath = resolve2(cwd, "bunup.config.ts");
-  let registeredNames;
-  try {
-    const configModule = await import(configPath);
-    const rawConfig = configModule.default;
-    if (!Array.isArray(rawConfig)) {
-      process.stderr.write(`bunup.config.ts must export a workspace array
-`);
-      process.exit(1);
-    }
-    registeredNames = rawConfig.map((entry) => entry.name);
-  } catch {
-    process.stderr.write(`Could not load bunup.config.ts from ${cwd}
-`);
-    process.exit(1);
-  }
-  const packagesWithFilter = [];
-  const glob = new Bun.Glob("{packages,apps}/*/package.json");
-  for (const match of glob.scanSync({ cwd })) {
-    const pkgPath = resolve2(cwd, match);
-    try {
-      const pkg = await Bun.file(pkgPath).json();
-      const buildScript = pkg.scripts?.["build"];
-      if (!buildScript)
-        continue;
-      const filterName = extractBunupFilterName(buildScript);
-      if (filterName) {
-        packagesWithFilter.push(filterName);
-      }
-    } catch {}
-  }
-  const result = findUnregisteredPackages(packagesWithFilter, registeredNames);
-  if (result.ok) {
-    process.stdout.write(`${COLORS.green}All ${packagesWithFilter.length} packages with bunup --filter are registered in bunup.config.ts.${COLORS.reset}
-`);
-    process.exit(0);
-  }
-  process.stderr.write(`${COLORS.red}${result.missing.length} package(s) have bunup --filter build scripts but are not registered in bunup.config.ts:${COLORS.reset}
-
-`);
-  for (const name of result.missing) {
-    process.stderr.write(`  ${COLORS.yellow}${name}${COLORS.reset}  ${COLORS.dim}(missing from workspace array)${COLORS.reset}
-`);
-  }
-  process.stderr.write(`
-Add the missing entries to ${COLORS.blue}bunup.config.ts${COLORS.reset} defineWorkspace array.
-`);
-  process.stderr.write(`Without registration, ${COLORS.dim}bunup --filter <name>${COLORS.reset} silently exits with no output.
-`);
-  process.exit(1);
-}
-
-// src/cli/check-changeset.ts
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-function getChangedPackagePaths(files) {
-  const packageNames = new Set;
-  const pattern = /^packages\/([^/]+)\/src\//;
-  for (const file of files) {
-    const match = pattern.exec(file);
-    if (match?.[1]) {
-      packageNames.add(match[1]);
-    }
-  }
-  return [...packageNames].sort();
-}
-function getChangedChangesetFiles(files) {
-  const pattern = /^\.changeset\/([^/]+\.md)$/;
-  const results = [];
-  for (const file of files) {
-    const match = pattern.exec(file);
-    if (match?.[1] && match[1] !== "README.md") {
-      results.push(match[1]);
-    }
-  }
-  return results.sort();
-}
-function checkChangesetRequired(changedPackages, changesetFiles) {
-  if (changedPackages.length === 0) {
-    return { ok: true, missingFor: [] };
-  }
-  if (changesetFiles.length > 0) {
-    return { ok: true, missingFor: [] };
-  }
-  return { ok: false, missingFor: changedPackages };
-}
-function parseIgnoredPackagesFromChangesetConfig(jsonContent) {
-  try {
-    const parsed = JSON.parse(jsonContent);
-    if (!Array.isArray(parsed.ignore)) {
-      return [];
-    }
-    return parsed.ignore.filter((entry) => typeof entry === "string");
-  } catch {
-    return [];
-  }
-}
-function parseChangesetFrontmatterPackageNames(markdownContent) {
-  const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdownContent);
-  if (!frontmatterMatch?.[1]) {
-    return [];
-  }
-  const packages = new Set;
-  for (const line of frontmatterMatch[1].split(/\r?\n/)) {
-    const trimmed = line.trim();
-    const match = /^(["']?)(@[^"':\s]+\/[^"':\s]+)\1\s*:/.exec(trimmed);
-    if (match?.[2]) {
-      packages.add(match[2]);
-    }
-  }
-  return [...packages].sort();
-}
-function findIgnoredPackageReferences(input) {
-  if (input.ignoredPackages.length === 0 || input.changesetFiles.length === 0) {
-    return [];
-  }
-  const ignored = new Set(input.ignoredPackages);
-  const results = [];
-  for (const file of input.changesetFiles) {
-    const content = input.readChangesetFile(file);
-    const referencedPackages = parseChangesetFrontmatterPackageNames(content);
-    const invalidReferences = referencedPackages.filter((pkg) => ignored.has(pkg));
-    if (invalidReferences.length > 0) {
-      results.push({ file, packages: invalidReferences.sort() });
-    }
-  }
-  return results.sort((a, b) => a.file.localeCompare(b.file));
-}
-function loadIgnoredPackages(cwd) {
-  const configPath = join(cwd, ".changeset", "config.json");
-  if (!existsSync(configPath)) {
-    return [];
-  }
-  try {
-    return parseIgnoredPackagesFromChangesetConfig(readFileSync(configPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function getIgnoredReferencesForChangedChangesets(cwd, changesetFiles) {
-  const ignoredPackages = loadIgnoredPackages(cwd);
-  return findIgnoredPackageReferences({
-    changesetFiles,
-    ignoredPackages,
-    readChangesetFile: (filename) => {
-      try {
-        return readFileSync(join(cwd, ".changeset", filename), "utf-8");
-      } catch {
-        return "";
-      }
-    }
-  });
-}
-var COLORS2 = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m"
-};
-async function runCheckChangeset(options = {}) {
-  if (options.skip || process.env["NO_CHANGESET"] === "1") {
-    process.stdout.write(`${COLORS2.dim}check-changeset skipped (NO_CHANGESET=1)${COLORS2.reset}
-`);
-    process.exit(0);
-  }
-  if (process.env["GITHUB_EVENT_NAME"] === "push") {
-    process.stdout.write(`${COLORS2.dim}check-changeset skipped (push event)${COLORS2.reset}
-`);
-    process.exit(0);
-  }
-  const cwd = process.cwd();
-  let changedFiles;
-  try {
-    const proc = Bun.spawnSync(["git", "diff", "--name-only", "origin/main...HEAD"], { cwd });
-    if (proc.exitCode !== 0) {
-      process.exit(0);
-    }
-    changedFiles = proc.stdout.toString().trim().split(`
-`).filter((line) => line.length > 0);
-  } catch {
-    process.exit(0);
-  }
-  const changedPackages = getChangedPackagePaths(changedFiles);
-  if (changedPackages.length === 0) {
-    process.stdout.write(`${COLORS2.green}No package source changes detected.${COLORS2.reset}
-`);
-    process.exit(0);
-  }
-  const changesetFiles = getChangedChangesetFiles(changedFiles);
-  const check = checkChangesetRequired(changedPackages, changesetFiles);
-  if (!check.ok) {
-    process.stderr.write(`${COLORS2.yellow}No changeset found.${COLORS2.reset} ` + "Consider adding one with `bun run changeset` for a custom changelog entry.\n\n");
-    process.stderr.write(`Packages with source changes:
-
-`);
-    for (const pkg of check.missingFor) {
-      process.stderr.write(`  ${COLORS2.yellow}@outfitter/${pkg}${COLORS2.reset}
-`);
-    }
-    process.stderr.write(`
-Run ${COLORS2.blue}bun run changeset${COLORS2.reset} for a custom changelog entry, ` + `or add ${COLORS2.blue}release:none${COLORS2.reset} to skip.
-`);
-  }
-  const ignoredReferences = getIgnoredReferencesForChangedChangesets(cwd, changesetFiles);
-  if (ignoredReferences.length > 0) {
-    process.stderr.write(`${COLORS2.red}Invalid changeset package reference(s).${COLORS2.reset}
-
-`);
-    process.stderr.write(`Changesets must not reference packages listed in .changeset/config.json ignore:
-
-`);
-    for (const reference of ignoredReferences) {
-      process.stderr.write(`  ${COLORS2.yellow}${reference.file}${COLORS2.reset}
-`);
-      for (const pkg of reference.packages) {
-        process.stderr.write(`    - ${pkg}
-`);
-      }
-    }
-    process.stderr.write(`
-Update the affected changeset files to remove ignored packages before merging.
-`);
-    process.exit(1);
-  }
-  process.stdout.write(`${COLORS2.green}Changeset found for ${changedPackages.length} changed package(s).${COLORS2.reset}
-`);
-  process.exit(0);
-}
-
-// 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);
-}
-var COLORS3 = {
-  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.exit(1);
-  }
-  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.exit(1);
-  }
-  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(`${COLORS3.green}Working tree is clean.${COLORS3.reset}
-`);
-    process.exit(0);
-  }
-  process.stderr.write(`${COLORS3.red}Working tree is dirty after verification:${COLORS3.reset}
-
-`);
-  if (modified.length > 0) {
-    process.stderr.write(`Modified files:
-`);
-    for (const file of modified) {
-      process.stderr.write(`  ${COLORS3.dim}M${COLORS3.reset} ${file}
-`);
-    }
-  }
-  if (untracked.length > 0) {
-    process.stderr.write(`Untracked files:
-`);
-    for (const file of untracked) {
-      process.stderr.write(`  ${COLORS3.dim}?${COLORS3.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.exit(1);
-}
-
-// src/cli/check-exports.ts
-import { resolve as resolve3 } from "node:path";
-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
-    }
-  };
-}
-function matchesExclude(subpath, excludes) {
-  return excludes.some((pattern) => new Bun.Glob(pattern).match(subpath));
-}
-var CLI_EXCLUSION_PATTERNS = [
-  "**/cli.ts",
-  "**/cli/index.ts",
-  "**/bin.ts",
-  "**/bin/index.ts"
-];
-function isCliEntrypoint(entry) {
-  return CLI_EXCLUSION_PATTERNS.some((pattern) => new Bun.Glob(pattern).match(entry));
-}
-function buildExportValue(entry) {
-  const distPath = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
-  return {
-    import: {
-      types: `./dist/${distPath}.d.ts`,
-      default: `./dist/${distPath}.js`
-    }
-  };
-}
-function discoverEntries(packageRoot) {
-  const glob = new Bun.Glob("src/**/*.ts");
-  const entries = [];
-  for (const match of glob.scanSync({ cwd: packageRoot, dot: false })) {
-    if (match.includes("__tests__") || match.endsWith(".test.ts")) {
-      continue;
-    }
-    entries.push(match);
-  }
-  return entries.sort();
-}
-function addConfigFileExports(expected, pkg) {
-  const CONFIG_RE = /\.(json|jsonc|yml|yaml|toml)$/;
-  const configFiles = (pkg.files ?? []).filter((file) => CONFIG_RE.test(file) && file !== "package.json");
-  for (const file of configFiles) {
-    expected[`./${file}`] = `./${file}`;
-    let base = file.replace(CONFIG_RE, "");
-    const match = base.match(/^(.+)\.preset(?:\.(.+))?$/);
-    if (match?.[1]) {
-      base = match[2] ? `${match[1]}-${match[2]}` : match[1];
-    }
-    if (base !== file) {
-      expected[`./${base}`] = `./${file}`;
-    }
-  }
-}
-function computeExpectedExports(packageRoot, workspace, pkg) {
-  const entries = discoverEntries(packageRoot);
-  const exportsConfig = typeof workspace.config?.exports === "object" ? workspace.config.exports : undefined;
-  const excludes = exportsConfig?.exclude ?? [];
-  const customExports = exportsConfig?.customExports ?? {};
-  const expected = {};
-  const subpathEntries = new Map;
-  for (const entry of entries) {
-    if (isCliEntrypoint(entry))
-      continue;
-    const subpath = entryToSubpath(entry);
-    if (matchesExclude(subpath, excludes))
-      continue;
-    const existing = subpathEntries.get(subpath);
-    if (existing) {
-      if (!existing.endsWith("/index.ts") && entry.endsWith("/index.ts")) {
-        continue;
-      }
-    }
-    subpathEntries.set(subpath, entry);
-  }
-  for (const [subpath, entry] of subpathEntries) {
-    expected[subpath] = buildExportValue(entry);
-  }
-  for (const [key, value] of Object.entries(customExports)) {
-    expected[`./${key.replace(/^\.\//, "")}`] = value;
-  }
-  addConfigFileExports(expected, pkg);
-  expected["./package.json"] = "./package.json";
-  return expected;
-}
-var COLORS4 = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m"
-};
-function resolveJsonMode(options = {}) {
-  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
-}
-async function runCheckExports(options = {}) {
-  const cwd = process.cwd();
-  const configPath = resolve3(cwd, "bunup.config.ts");
-  let workspaces;
-  try {
-    const configModule = await import(configPath);
-    const rawConfig = configModule.default;
-    if (!Array.isArray(rawConfig)) {
-      process.stderr.write(`bunup.config.ts must export a workspace array
-`);
-      process.exit(1);
-    }
-    workspaces = rawConfig;
-  } catch {
-    process.stderr.write(`Could not load bunup.config.ts from ${cwd}
-`);
-    process.exit(1);
-  }
-  const results = [];
-  for (const workspace of workspaces) {
-    const packageRoot = resolve3(cwd, workspace.root);
-    const pkgPath = resolve3(packageRoot, "package.json");
-    let pkg;
-    try {
-      pkg = await Bun.file(pkgPath).json();
-    } catch {
-      results.push({ name: workspace.name, status: "ok" });
-      continue;
-    }
-    const actual = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
-    const expected = computeExpectedExports(packageRoot, workspace, pkg);
-    results.push(compareExports({
-      name: workspace.name,
-      actual,
-      expected,
-      path: workspace.root
-    }));
-  }
-  const checkResult = {
-    ok: results.every((r) => r.status === "ok"),
-    packages: results
-  };
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(checkResult, null, 2)}
-`);
-  } else {
-    const drifted = results.filter((r) => r.status === "drift");
-    if (drifted.length === 0) {
-      process.stdout.write(`${COLORS4.green}All ${results.length} packages have exports in sync.${COLORS4.reset}
-`);
-    } else {
-      process.stderr.write(`${COLORS4.red}Export drift detected in ${drifted.length} package(s):${COLORS4.reset}
-
-`);
-      for (const result of drifted) {
-        const drift = result.drift;
-        if (!drift)
-          continue;
-        process.stderr.write(`  ${COLORS4.yellow}${result.name}${COLORS4.reset} ${COLORS4.dim}(${drift.path})${COLORS4.reset}
-`);
-        for (const key of drift.added) {
-          process.stderr.write(`    ${COLORS4.green}+ ${key}${COLORS4.reset}  ${COLORS4.dim}(missing from package.json)${COLORS4.reset}
-`);
-        }
-        for (const key of drift.removed) {
-          process.stderr.write(`    ${COLORS4.red}- ${key}${COLORS4.reset}  ${COLORS4.dim}(not in source)${COLORS4.reset}
-`);
-        }
-        for (const entry of drift.changed) {
-          process.stderr.write(`    ${COLORS4.yellow}~ ${entry.key}${COLORS4.reset}  ${COLORS4.dim}(value mismatch)${COLORS4.reset}
-`);
-        }
-        process.stderr.write(`
-`);
-      }
-      process.stderr.write(`Run ${COLORS4.blue}bun run build${COLORS4.reset} to regenerate exports.
-`);
-    }
-  }
-  process.exit(checkResult.ok ? 0 : 1);
-}
-
-// src/cli/fix.ts
-function buildFixCommand(options) {
-  const cmd = ["ultracite", "fix"];
-  if (options.paths && options.paths.length > 0) {
-    cmd.push(...options.paths);
-  }
-  return cmd;
-}
-async function runFix(paths = []) {
-  const cmd = buildFixCommand({ paths });
-  process.stdout.write(`Running: bun x ${cmd.join(" ")}
-`);
-  const proc = Bun.spawn(["bun", "x", ...cmd], {
-    stdio: ["inherit", "inherit", "inherit"]
-  });
-  const exitCode = await proc.exited;
-  process.exit(exitCode);
-}
-
-// src/cli/init.ts
-var FRAMEWORK_DETECTORS = {
-  react: ["react", "react-dom"],
-  next: ["next"],
-  vue: ["vue"],
-  nuxt: ["nuxt"],
-  svelte: ["svelte"],
-  angular: ["@angular/core"],
-  solid: ["solid-js"],
-  astro: ["astro"],
-  remix: ["@remix-run/react"],
-  qwik: ["@builder.io/qwik"]
-};
-function detectFrameworks(pkg) {
-  const allDeps = {
-    ...pkg.dependencies,
-    ...pkg.devDependencies
-  };
-  const detected = [];
-  for (const [framework, packages] of Object.entries(FRAMEWORK_DETECTORS)) {
-    if (packages.some((p) => (p in allDeps))) {
-      detected.push(framework);
-    }
-  }
-  if (detected.length === 0) {
-    return [];
-  }
-  return ["--frameworks", ...detected];
-}
-function buildUltraciteCommand(options) {
-  const cmd = [
-    "ultracite",
-    "init",
-    "--linter",
-    "biome",
-    "--pm",
-    "bun",
-    "--quiet"
-  ];
-  if (options.frameworks && options.frameworks.length > 0) {
-    cmd.push("--frameworks", ...options.frameworks);
-  }
-  return cmd;
-}
-async function runInit(cwd = process.cwd()) {
-  const pkgPath = `${cwd}/package.json`;
-  const pkgFile = Bun.file(pkgPath);
-  if (!await pkgFile.exists()) {
-    process.stderr.write(`No package.json found in current directory
-`);
-    process.exit(1);
-  }
-  const pkg = await pkgFile.json();
-  const frameworkFlags = detectFrameworks(pkg);
-  const frameworks = frameworkFlags.length > 0 ? frameworkFlags.slice(1) : [];
-  const cmd = buildUltraciteCommand({ frameworks });
-  process.stdout.write(`Running: bun x ${cmd.join(" ")}
-`);
-  const proc = Bun.spawn(["bun", "x", ...cmd], {
-    cwd,
-    stdio: ["inherit", "inherit", "inherit"]
-  });
-  const exitCode = await proc.exited;
-  process.exit(exitCode);
-}
-
-// src/cli/pre-push.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2, resolve as resolve4 } from "node:path";
-import ts from "typescript";
-var COLORS5 = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m"
-};
-function log(msg) {
-  process.stdout.write(`${msg}
-`);
-}
-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));
-}
-async function printTsdocSummary() {
-  const glob = new Bun.Glob("packages/*/src/index.ts");
-  const cwd = process.cwd();
-  const allDeclarations = [];
-  for (const entry of glob.scanSync({ cwd })) {
-    const filePath = resolve4(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`);
-  log(`${COLORS5.blue}TSDoc${COLORS5.reset}: ${coverage.percentage}% coverage (${parts.join(", ")} of ${coverage.total} total)`);
-}
-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 maybeSkipForRedPhase(reason, branch) {
-  const changedFiles = getChangedFilesForPush();
-  if (!changedFiles.deterministic) {
-    log(`${COLORS5.yellow}RED-phase bypass denied${COLORS5.reset}: could not determine full push diff range`);
-    log("Running strict verification.");
-    log("");
-    return false;
-  }
-  if (!canBypassRedPhaseByChangedFiles(changedFiles)) {
-    log(`${COLORS5.yellow}RED-phase bypass denied${COLORS5.reset}: changed files are not test-only`);
-    if (changedFiles.files.length > 0) {
-      log(`Changed files (${changedFiles.source}): ${changedFiles.files.join(", ")}`);
-    } else {
-      log(`No changed files detected in ${changedFiles.source} range. Running strict verification.`);
-    }
-    log("");
-    return false;
-  }
-  if (reason === "branch") {
-    log(`${COLORS5.yellow}TDD RED phase${COLORS5.reset} detected: ${COLORS5.blue}${branch}${COLORS5.reset}`);
-  } else {
-    log(`${COLORS5.yellow}Scaffold branch${COLORS5.reset} with RED phase branch in context: ${COLORS5.blue}${branch}${COLORS5.reset}`);
-  }
-  log(`${COLORS5.yellow}Skipping strict verification${COLORS5.reset} - changed files are test-only`);
-  log(`Diff source: ${changedFiles.source}`);
-  log("");
-  log("Remember: GREEN phase (implementation) must make these tests pass!");
-  return true;
-}
-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(/^[│├└─◉◯ ]*/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: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 = join2(cwd, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(readFileSync2(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 runScript(scriptName) {
-  log("");
-  log(`Running: ${COLORS5.blue}bun run ${scriptName}${COLORS5.reset}`);
-  const result = Bun.spawnSync(["bun", "run", scriptName], {
-    stdio: ["inherit", "inherit", "inherit"]
-  });
-  return result.exitCode === 0;
-}
-async function runPrePush(options = {}) {
-  log(`${COLORS5.blue}Pre-push verify${COLORS5.reset} (TDD-aware)`);
-  log("");
-  const branch = getCurrentBranch();
-  if (isReleaseBranch(branch)) {
-    log(`${COLORS5.yellow}Release branch detected${COLORS5.reset}: ${COLORS5.blue}${branch}${COLORS5.reset}`);
-    log(`${COLORS5.yellow}Skipping strict verification${COLORS5.reset} for automated changeset release push`);
-    process.exit(0);
-  }
-  if (isRedPhaseBranch(branch)) {
-    if (maybeSkipForRedPhase("branch", branch)) {
-      process.exit(0);
-    }
-  }
-  if (isScaffoldBranch(branch)) {
-    if (hasRedPhaseBranchInContext(branch)) {
-      if (maybeSkipForRedPhase("context", branch)) {
-        process.exit(0);
-      }
-    }
-  }
-  if (options.force) {
-    log(`${COLORS5.yellow}Force flag set${COLORS5.reset} - skipping strict verification`);
-    process.exit(0);
-  }
-  const plan = createVerificationPlan(readPackageScripts());
-  if (!plan.ok) {
-    log(`${COLORS5.red}Strict pre-push verification is not configured${COLORS5.reset}`);
-    log(plan.error);
-    log("");
-    log("Add one of:");
-    log("  - verify:ci");
-    log("  - typecheck + (check or lint) + build + test");
-    process.exit(1);
-  }
-  log(`Running strict verification for branch: ${COLORS5.blue}${branch}${COLORS5.reset}`);
-  if (plan.source === "verify:ci") {
-    log("Using `verify:ci` script.");
-  } else {
-    log(`Using fallback scripts: ${plan.scripts.join(" -> ")}`);
-  }
-  for (const scriptName of plan.scripts) {
-    if (runScript(scriptName)) {
-      continue;
-    }
-    log("");
-    log(`${COLORS5.red}Verification failed${COLORS5.reset} on script: ${scriptName}`);
-    log("");
-    log("If this is intentional TDD RED phase work, name your branch:");
-    log("  - feature-tests");
-    log("  - feature/tests");
-    log("  - feature_tests");
-    process.exit(1);
-  }
-  const changedFiles = getChangedFilesForPush();
-  if (hasPackageSourceChanges(changedFiles)) {
-    try {
-      await printTsdocSummary();
-    } catch {}
-  }
-  log("");
-  log(`${COLORS5.green}Strict verification passed${COLORS5.reset}`);
-  process.exit(0);
-}
-
-// src/cli/upgrade-bun.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "node:fs";
-import { join as join3 } from "node:path";
-var COLORS6 = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m"
-};
-function log2(msg) {
-  process.stdout.write(`${msg}
-`);
-}
-function info(msg) {
-  process.stdout.write(`${COLORS6.blue}▸${COLORS6.reset} ${msg}
-`);
-}
-function success(msg) {
-  process.stdout.write(`${COLORS6.green}✓${COLORS6.reset} ${msg}
-`);
-}
-function warn(msg) {
-  process.stdout.write(`${COLORS6.yellow}!${COLORS6.reset} ${msg}
-`);
-}
-async function fetchLatestVersion() {
-  const response = await fetch("https://api.github.com/repos/oven-sh/bun/releases/latest");
-  const data = await response.json();
-  const match = data.tag_name.match(/bun-v(.+)/);
-  if (!match?.[1]) {
-    throw new Error(`Could not parse version from tag: ${data.tag_name}`);
-  }
-  return match[1];
-}
-function findPackageJsonFiles(dir) {
-  const results = [];
-  const glob = new Bun.Glob("**/package.json");
-  for (const path of glob.scanSync({ cwd: dir })) {
-    if (!path.includes("node_modules")) {
-      results.push(join3(dir, path));
-    }
-  }
-  return results;
-}
-function updateEnginesBun(filePath, version) {
-  const content = readFileSync3(filePath, "utf-8");
-  const pattern = /"bun":\s*">=[\d.]+"/;
-  if (!pattern.test(content)) {
-    return false;
-  }
-  const updated = content.replace(pattern, `"bun": ">=${version}"`);
-  if (updated !== content) {
-    writeFileSync(filePath, updated);
-    return true;
-  }
-  return false;
-}
-function updateTypesBun(filePath, version) {
-  const content = readFileSync3(filePath, "utf-8");
-  const pattern = /"@types\/bun":\s*"\^[\d.]+"/;
-  if (!pattern.test(content)) {
-    return false;
-  }
-  const updated = content.replace(pattern, `"@types/bun": "^${version}"`);
-  if (updated !== content) {
-    writeFileSync(filePath, updated);
-    return true;
-  }
-  return false;
-}
-async function runUpgradeBun(targetVersion, options = {}) {
-  const cwd = process.cwd();
-  const bunVersionFile = join3(cwd, ".bun-version");
-  let version = targetVersion;
-  if (!version) {
-    info("Fetching latest Bun version...");
-    version = await fetchLatestVersion();
-    log2(`Latest version: ${version}`);
-  }
-  const currentVersion = existsSync3(bunVersionFile) ? readFileSync3(bunVersionFile, "utf-8").trim() : "unknown";
-  log2(`Current version: ${currentVersion}`);
-  if (currentVersion === version) {
-    success(`Already on version ${version}`);
-    return;
-  }
-  log2("");
-  info(`Upgrading Bun: ${currentVersion} → ${version}`);
-  log2("");
-  writeFileSync(bunVersionFile, `${version}
-`);
-  success("Updated .bun-version");
-  const packageFiles = findPackageJsonFiles(cwd);
-  info("Updating engines.bun...");
-  for (const file of packageFiles) {
-    if (updateEnginesBun(file, version)) {
-      log2(`  ${file.replace(`${cwd}/`, "")}`);
-    }
-  }
-  info("Updating @types/bun...");
-  for (const file of packageFiles) {
-    if (updateTypesBun(file, version)) {
-      log2(`  ${file.replace(`${cwd}/`, "")}`);
-    }
-  }
-  if (options.install !== false) {
-    log2("");
-    info(`Installing Bun ${version}...`);
-    const installResult = Bun.spawnSync([
-      "bash",
-      "-c",
-      `curl -fsSL https://bun.sh/install | bash -s "bun-v${version}"`
-    ]);
-    if (installResult.exitCode !== 0) {
-      warn("Could not install Bun automatically");
-      log2("Install manually: curl -fsSL https://bun.sh/install | bash");
-    } else {
-      success(`Bun ${version} installed`);
-      log2("");
-      info("Updating lockfile...");
-      const bunInstall = Bun.spawnSync(["bun", "install"], {
-        cwd,
-        env: {
-          ...process.env,
-          BUN_INSTALL: `${process.env["HOME"]}/.bun`,
-          PATH: `${process.env["HOME"]}/.bun/bin:${process.env["PATH"]}`
-        }
-      });
-      if (bunInstall.exitCode === 0) {
-        success("Lockfile updated");
-      } else {
-        warn("Could not update lockfile - run 'bun install' manually");
-      }
-    }
-  }
-  log2("");
-  success("Done! Changes ready to commit:");
-  log2("  - .bun-version");
-  log2("  - package.json files (engines.bun, @types/bun)");
-  log2("  - bun.lock");
-  log2("");
-  log2(`Commit with: git add -A && git commit -m 'chore: upgrade Bun to ${version}'`);
-}
-
-// src/cli/index.ts
 var cli = createCLI({
   name: "tooling",
   version: VERSION,
@@ -1271,10 +104,20 @@ register(new Command("check-tsdoc").description("Check TSDoc coverage on exporte
 register(new Command("check-clean-tree").description("Assert working tree is clean (no modified or untracked files)").option("--paths <paths...>", "Limit check to specific paths").action(async (options) => {
   await runCheckCleanTree(options);
 }));
+register(new Command("check-home-paths").description("Check staged files for hardcoded home directory paths").argument("[paths...]", "Specific files to scan").action((paths) => {
+  runCheckHomePaths(paths);
+}));
 register(new Command("check-readme-imports").description("Validate README import examples match package exports").option("--json", "Output results as JSON").action(async (options) => {
-  const { runCheckReadmeImports } = await import("../shared/chunk-7tdgbqb0.js");
+  const { runCheckReadmeImports } = await import("./check-readme-imports.js");
   await runCheckReadmeImports(options);
 }));
+register(new Command("check-markdown-links").description("Validate relative links in markdown files resolve to existing files").argument("[patterns...]", "Glob patterns to scan").action(async (patterns) => {
+  const cwd = process.cwd();
+  const exitCode = await runCheckMarkdownLinks(cwd, patterns.length > 0 ? patterns : undefined);
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}));
 register(new Command("check-boundary-invocations").description("Validate root/app scripts do not execute packages/*/src entrypoints directly").action(async () => {
   await runCheckBoundaryInvocations();
 }));