@outfitter/tooling 0.3.3 → 0.3.4

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

@@ -0,0 +1,349 @@
+// @bun
+import {
+  analyzeSourceFile,
+  calculateCoverage
+} from "./tooling-875svjnz.js";
+
+// packages/tooling/src/cli/pre-push.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import ts from "typescript";
+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");
+}
+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 = 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`);
+  log(`${COLORS.blue}TSDoc${COLORS.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(`${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;
+}
+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 runPrePush(options = {}) {
+  log(`${COLORS.blue}Pre-push verify${COLORS.reset} (TDD-aware)`);
+  log("");
+  if (options.force) {
+    log(`${COLORS.yellow}Force flag set${COLORS.reset} - skipping strict verification`);
+    process.exitCode = 0;
+    return;
+  }
+  const versionCheck = checkBunVersion();
+  if (!versionCheck.matches) {
+    log(`${COLORS.red}Bun version mismatch${COLORS.reset}: running ${versionCheck.actual}, pinned ${versionCheck.expected}`);
+    log("Fix: bunx @outfitter/tooling upgrade-bun");
+    log("");
+    process.exitCode = 1;
+    return;
+  }
+  const branch = getCurrentBranch();
+  if (isReleaseBranch(branch)) {
+    log(`${COLORS.yellow}Release branch detected${COLORS.reset}: ${COLORS.blue}${branch}${COLORS.reset}`);
+    log(`${COLORS.yellow}Skipping strict verification${COLORS.reset} for automated changeset release push`);
+    process.exitCode = 0;
+    return;
+  }
+  if (isRedPhaseBranch(branch)) {
+    if (maybeSkipForRedPhase("branch", branch)) {
+      process.exitCode = 0;
+      return;
+    }
+  }
+  if (isScaffoldBranch(branch)) {
+    if (hasRedPhaseBranchInContext(branch)) {
+      if (maybeSkipForRedPhase("context", branch)) {
+        process.exitCode = 0;
+        return;
+      }
+    }
+  }
+  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.exitCode = 1;
+    return;
+  }
+  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.exitCode = 1;
+    return;
+  }
+  const changedFiles = getChangedFilesForPush();
+  if (hasPackageSourceChanges(changedFiles)) {
+    try {
+      await printTsdocSummary();
+    } catch {}
+  }
+  log("");
+  log(`${COLORS.green}Strict verification passed${COLORS.reset}`);
+  process.exitCode = 0;
+}
+
+export { isRedPhaseBranch, isScaffoldBranch, isReleaseBranch, isTestOnlyPath, areFilesTestOnly, canBypassRedPhaseByChangedFiles, hasPackageSourceChanges, createVerificationPlan, checkBunVersion, runPrePush };

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

@@ -0,0 +1,231 @@
+// @bun
+// packages/tooling/src/cli/check-exports.ts
+import { resolve } from "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.toSorted();
+}
+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 COLORS = {
+  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 = resolve(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.exitCode = 1;
+      return;
+    }
+    workspaces = rawConfig;
+  } catch {
+    process.stderr.write(`Could not load bunup.config.ts from ${cwd}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const results = [];
+  for (const workspace of workspaces) {
+    const packageRoot = resolve(cwd, workspace.root);
+    const pkgPath = resolve(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(`${COLORS.green}All ${results.length} packages have exports in sync.${COLORS.reset}
+`);
+    } else {
+      process.stderr.write(`${COLORS.red}Export drift detected in ${drifted.length} package(s):${COLORS.reset}
+
+`);
+      for (const result of drifted) {
+        const drift = result.drift;
+        if (!drift)
+          continue;
+        process.stderr.write(`  ${COLORS.yellow}${result.name}${COLORS.reset} ${COLORS.dim}(${drift.path})${COLORS.reset}
+`);
+        for (const key of drift.added) {
+          process.stderr.write(`    ${COLORS.green}+ ${key}${COLORS.reset}  ${COLORS.dim}(missing from package.json)${COLORS.reset}
+`);
+        }
+        for (const key of drift.removed) {
+          process.stderr.write(`    ${COLORS.red}- ${key}${COLORS.reset}  ${COLORS.dim}(not in source)${COLORS.reset}
+`);
+        }
+        for (const entry of drift.changed) {
+          process.stderr.write(`    ${COLORS.yellow}~ ${entry.key}${COLORS.reset}  ${COLORS.dim}(value mismatch)${COLORS.reset}
+`);
+        }
+        process.stderr.write(`
+`);
+      }
+      process.stderr.write(`Run ${COLORS.blue}bun run build${COLORS.reset} to regenerate exports.
+`);
+    }
+  }
+  process.exitCode = checkResult.ok ? 0 : 1;
+}
+
+export { entryToSubpath, compareExports, resolveJsonMode, runCheckExports };