@outfitter/tooling 0.2.1 → 0.2.3

package/dist/shared/@outfitter/tooling-8sd32ts6.js

@@ -0,0 +1,277 @@
+// @bun
+// packages/tooling/src/cli/pre-push.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var COLORS = {
+  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");
+}
+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 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(`${COLORS.yellow}RED-phase bypass denied${COLORS.reset}: could not determine full push diff range`);
+    log("Running strict verification.");
+    log("");
+    return false;
+  }
+  if (!canBypassRedPhaseByChangedFiles(changedFiles)) {
+    log(`${COLORS.yellow}RED-phase bypass denied${COLORS.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(`${COLORS.yellow}TDD RED phase${COLORS.reset} detected: ${COLORS.blue}${branch}${COLORS.reset}`);
+  } else {
+    log(`${COLORS.yellow}Scaffold branch${COLORS.reset} with RED phase branch in context: ${COLORS.blue}${branch}${COLORS.reset}`);
+  }
+  log(`${COLORS.yellow}Skipping strict verification${COLORS.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(/^[\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: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 runScript(scriptName) {
+  log("");
+  log(`Running: ${COLORS.blue}bun run ${scriptName}${COLORS.reset}`);
+  const result = Bun.spawnSync(["bun", "run", scriptName], {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  return result.exitCode === 0;
+}
+async function runPrePush(options = {}) {
+  log(`${COLORS.blue}Pre-push verify${COLORS.reset} (TDD-aware)`);
+  log("");
+  const branch = getCurrentBranch();
+  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(`${COLORS.yellow}Force flag set${COLORS.reset} - skipping strict verification`);
+    process.exit(0);
+  }
+  const plan = createVerificationPlan(readPackageScripts());
+  if (!plan.ok) {
+    log(`${COLORS.red}Strict pre-push verification is not configured${COLORS.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: ${COLORS.blue}${branch}${COLORS.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(`${COLORS.red}Verification failed${COLORS.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);
+  }
+  log("");
+  log(`${COLORS.green}Strict verification passed${COLORS.reset}`);
+  process.exit(0);
+}
+
+export { isRedPhaseBranch, isScaffoldBranch, isTestOnlyPath, areFilesTestOnly, canBypassRedPhaseByChangedFiles, createVerificationPlan, runPrePush };

package/dist/shared/@outfitter/{tooling-s4eqq91d.js → tooling-9errkcvk.js}

@@ -9,7 +9,8 @@ function buildFixCommand(options) {
 }
 async function runFix(paths = []) {
   const cmd = buildFixCommand({ paths });
-  console.log(`Running: bun x ${cmd.join(" ")}`);
+  process.stdout.write(`Running: bun x ${cmd.join(" ")}
+`);
   const proc = Bun.spawn(["bun", "x", ...cmd], {
     stdio: ["inherit", "inherit", "inherit"]
   });

package/dist/shared/@outfitter/tooling-9vs606gq.d.ts

@@ -0,0 +1,3 @@
+/** Package version, read from package.json at load time. */
+declare const VERSION: string;
+export { VERSION };

package/dist/shared/@outfitter/{tooling-75j500dv.js → tooling-9yzd08v1.js}

@@ -10,16 +10,20 @@ var COLORS = {
   blue: "\x1B[34m"
 };
 function log(msg) {
-  console.log(msg);
+  process.stdout.write(`${msg}
+`);
 }
 function info(msg) {
-  console.log(`${COLORS.blue}\u25B8${COLORS.reset} ${msg}`);
+  process.stdout.write(`${COLORS.blue}\u25B8${COLORS.reset} ${msg}
+`);
 }
 function success(msg) {
-  console.log(`${COLORS.green}\u2713${COLORS.reset} ${msg}`);
+  process.stdout.write(`${COLORS.green}\u2713${COLORS.reset} ${msg}
+`);
 }
 function warn(msg) {
-  console.log(`${COLORS.yellow}!${COLORS.reset} ${msg}`);
+  process.stdout.write(`${COLORS.yellow}!${COLORS.reset} ${msg}
+`);
 }
 async function fetchLatestVersion() {
   const response = await fetch("https://api.github.com/repos/oven-sh/bun/releases/latest");
@@ -91,13 +95,13 @@ async function runUpgradeBun(targetVersion, options = {}) {
   info("Updating engines.bun...");
   for (const file of packageFiles) {
     if (updateEnginesBun(file, version)) {
-      log(`  ${file.replace(cwd + "/", "")}`);
+      log(`  ${file.replace(`${cwd}/`, "")}`);
     }
   }
   info("Updating @types/bun...");
   for (const file of packageFiles) {
     if (updateTypesBun(file, version)) {
-      log(`  ${file.replace(cwd + "/", "")}`);
+      log(`  ${file.replace(`${cwd}/`, "")}`);
     }
   }
   if (options.install !== false) {

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-dvwh9qve.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/shared/@outfitter/{tooling-xaxdr9da.js → tooling-mxwc1n8w.js}

@@ -29,7 +29,15 @@ function detectFrameworks(pkg) {
   return ["--frameworks", ...detected];
 }
 function buildUltraciteCommand(options) {
-  const cmd = ["ultracite", "init", "--linter", "biome", "--pm", "bun", "--quiet"];
+  const cmd = [
+    "ultracite",
+    "init",
+    "--linter",
+    "biome",
+    "--pm",
+    "bun",
+    "--quiet"
+  ];
   if (options.frameworks && options.frameworks.length > 0) {
     cmd.push("--frameworks", ...options.frameworks);
   }
@@ -39,14 +47,16 @@ async function runInit(cwd = process.cwd()) {
   const pkgPath = `${cwd}/package.json`;
   const pkgFile = Bun.file(pkgPath);
   if (!await pkgFile.exists()) {
-    console.error("No package.json found in current directory");
+    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 });
-  console.log(`Running: bun x ${cmd.join(" ")}`);
+  process.stdout.write(`Running: bun x ${cmd.join(" ")}
+`);
   const proc = Bun.spawn(["bun", "x", ...cmd], {
     cwd,
     stdio: ["inherit", "inherit", "inherit"]

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

@@ -0,0 +1,58 @@
+/** 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;
+interface CheckExportsOptions {
+	readonly json?: boolean;
+}
+/**
+* Run check-exports across all workspace packages.
+*
+* Reads the bunup workspace config to discover packages and their * settings, then compares expected vs actual exports in each package.json.
+*/
+declare function runCheckExports(options?: CheckExportsOptions): Promise<void>;
+export { ExportMap, ExportDrift, PackageResult, CheckResult, CompareInput, entryToSubpath, compareExports, CheckExportsOptions, runCheckExports };

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

@@ -0,0 +1,100 @@
+// @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.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);
+}
+
+export { detectBoundaryViolation, findBoundaryViolations, readScriptEntries, runCheckBoundaryInvocations };

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

@@ -0,0 +1,78 @@
+// @bun
+// packages/tooling/src/cli/check-bunup-registry.ts
+import { resolve } from "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 = resolve(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 = resolve(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);
+}
+
+export { extractBunupFilterName, findUnregisteredPackages, runCheckBunupRegistry };