@outfitter/tooling 0.2.1 → 0.2.2

package/dist/cli/index.js

@@ -1,23 +1,532 @@
 #!/usr/bin/env bun
-// @bun
-import {
-  runCheck
-} from "../shared/@outfitter/tooling-xx1146e3.js";
-import {
-  runInit
-} from "../shared/@outfitter/tooling-xaxdr9da.js";
-import {
-  runPrePush
-} from "../shared/@outfitter/tooling-qm7jeg0d.js";
-import {
-  runFix
-} from "../shared/@outfitter/tooling-s4eqq91d.js";
-import {
-  runUpgradeBun
-} from "../shared/@outfitter/tooling-75j500dv.js";
 
-// packages/tooling/src/cli/index.ts
+// src/cli/index.ts
 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/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, readFileSync } from "node:fs";
+import { join } from "node: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(/^[│├└─◉◯ ]*/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);
+}
+
+// src/cli/upgrade-bun.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var COLORS2 = {
+  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(`${COLORS2.blue}▸${COLORS2.reset} ${msg}
+`);
+}
+function success(msg) {
+  process.stdout.write(`${COLORS2.green}✓${COLORS2.reset} ${msg}
+`);
+}
+function warn(msg) {
+  process.stdout.write(`${COLORS2.yellow}!${COLORS2.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(join2(dir, path));
+    }
+  }
+  return results;
+}
+function updateEnginesBun(filePath, version) {
+  const content = readFileSync2(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 = readFileSync2(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 = join2(cwd, ".bun-version");
+  let version = targetVersion;
+  if (!version) {
+    info("Fetching latest Bun version...");
+    version = await fetchLatestVersion();
+    log2(`Latest version: ${version}`);
+  }
+  const currentVersion = existsSync2(bunVersionFile) ? readFileSync2(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 program = new Command;
 program.name("tooling").description("Dev tooling configuration management for Outfitter projects").version("0.1.0-rc.1");
 program.command("init").description("Initialize tooling config in the current project").action(async () => {
@@ -32,7 +541,7 @@ program.command("fix").description("Fix linting issues (wraps ultracite)").argum
 program.command("upgrade-bun").description("Upgrade Bun version across the project").argument("[version]", "Target version (defaults to latest)").option("--no-install", "Skip installing Bun and updating lockfile").action(async (version, options) => {
   await runUpgradeBun(version, options);
 });
-program.command("pre-push").description("TDD-aware pre-push test hook").option("-f, --force", "Skip tests entirely").action(async (options) => {
+program.command("pre-push").description("TDD-aware pre-push strict verification hook").option("-f, --force", "Skip strict verification entirely").action(async (options) => {
   await runPrePush(options);
 });
 program.parse();

package/dist/cli/init.js

@@ -3,7 +3,7 @@ import {
   buildUltraciteCommand,
   detectFrameworks,
   runInit
-} from "../shared/@outfitter/tooling-xaxdr9da.js";
+} from "../shared/@outfitter/tooling-mxwc1n8w.js";
 export {
   runInit,
   detectFrameworks,

package/dist/cli/pre-push.d.ts

@@ -1,3 +1,36 @@
+/**
+* Check if branch is a TDD RED phase branch
+*/
+declare function isRedPhaseBranch(branch: string): boolean;
+/**
+* Check if branch is a scaffold branch
+*/
+declare function isScaffoldBranch(branch: string): boolean;
+declare function isTestOnlyPath(path: string): boolean;
+declare function areFilesTestOnly(paths: readonly string[]): boolean;
+interface PushChangedFiles {
+	readonly files: readonly string[];
+	readonly deterministic: boolean;
+	readonly source: "upstream" | "baseRef" | "undetermined";
+}
+declare function canBypassRedPhaseByChangedFiles(changedFiles: PushChangedFiles): boolean;
+type ScriptMap = Readonly<Record<string, string | undefined>>;
+type VerificationPlan = {
+	readonly ok: true;
+	readonly scripts: readonly string[];
+	readonly source: "verify:ci" | "fallback";
+} | {
+	readonly ok: false;
+	readonly error: string;
+};
+/**
+* Derive strict pre-push verification from package scripts.
+*
+* Priority:
+* 1) `verify:ci`
+* 2) fallback sequence: `typecheck`, `check|lint`, `build`, `test`
+*/
+declare function createVerificationPlan(scripts: ScriptMap): VerificationPlan;
 interface PrePushOptions {
 	force?: boolean;
 }
@@ -5,4 +38,4 @@ interface PrePushOptions {
 * Main pre-push command
 */
 declare function runPrePush(options?: PrePushOptions): Promise<void>;
-export { runPrePush, PrePushOptions };
+export { runPrePush, isTestOnlyPath, isScaffoldBranch, isRedPhaseBranch, createVerificationPlan, canBypassRedPhaseByChangedFiles, areFilesTestOnly, VerificationPlan, PushChangedFiles, PrePushOptions };

package/dist/cli/pre-push.js

@@ -1,7 +1,19 @@
 // @bun
 import {
+  areFilesTestOnly,
+  canBypassRedPhaseByChangedFiles,
+  createVerificationPlan,
+  isRedPhaseBranch,
+  isScaffoldBranch,
+  isTestOnlyPath,
   runPrePush
-} from "../shared/@outfitter/tooling-qm7jeg0d.js";
+} from "../shared/@outfitter/tooling-8sd32ts6.js";
 export {
-  runPrePush
+  runPrePush,
+  isTestOnlyPath,
+  isScaffoldBranch,
+  isRedPhaseBranch,
+  createVerificationPlan,
+  canBypassRedPhaseByChangedFiles,
+  areFilesTestOnly
 };

package/dist/cli/upgrade-bun.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   runUpgradeBun
-} from "../shared/@outfitter/tooling-75j500dv.js";
+} from "../shared/@outfitter/tooling-9yzd08v1.js";
 export {
   runUpgradeBun
 };