@outfitter/tooling 0.3.3 → 0.3.5

package/dist/registry/build.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env bun
+// @bun
+import"../shared/@outfitter/tooling-jnrs9rqd.js";
+
+// packages/tooling/src/registry/build.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// packages/presets/dist/index.js
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function loadWorkspaceCatalog(packageDir) {
+  let dir = packageDir;
+  for (let i = 0;i < 10; i++) {
+    const rootPkgPath = join(dir, "package.json");
+    if (existsSync(rootPkgPath)) {
+      try {
+        const raw = JSON.parse(readFileSync(rootPkgPath, "utf-8"));
+        if (isRecord(raw) && isRecord(raw["catalog"])) {
+          const catalog = {};
+          for (const [name, version] of Object.entries(raw["catalog"])) {
+            if (typeof version === "string") {
+              catalog[name] = version;
+            }
+          }
+          return catalog;
+        }
+      } catch {}
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return {};
+}
+function getResolvedVersions() {
+  const packageDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const packageJsonPath = join(packageDir, "package.json");
+  const raw = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  if (!isRecord(raw)) {
+    throw new Error("@outfitter/presets package.json must be a JSON object");
+  }
+  const all = {};
+  let hasCatalogRefs = false;
+  for (const section of DEPENDENCY_SECTIONS) {
+    const deps = raw[section];
+    if (!isRecord(deps))
+      continue;
+    for (const [name, version] of Object.entries(deps)) {
+      if (typeof version === "string") {
+        if (version === "catalog:") {
+          hasCatalogRefs = true;
+        } else {
+          all[name] = version;
+        }
+      }
+    }
+  }
+  if (hasCatalogRefs) {
+    const catalog = loadWorkspaceCatalog(packageDir);
+    const unresolved = [];
+    for (const section of DEPENDENCY_SECTIONS) {
+      const deps = raw[section];
+      if (!isRecord(deps))
+        continue;
+      for (const [name, version] of Object.entries(deps)) {
+        if (version === "catalog:") {
+          if (catalog[name]) {
+            all[name] = catalog[name];
+          } else {
+            unresolved.push(name);
+          }
+        }
+      }
+    }
+    if (unresolved.length > 0) {
+      throw new Error(`Unresolvable catalog: references (no catalog entry found): ${unresolved.join(", ")}`);
+    }
+  }
+  return { all };
+}
+
+// packages/tooling/src/registry/build.ts
+function log(message) {
+  process.stdout.write(`${message}
+`);
+}
+function findRepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== "/") {
+    const pkgPath = join2(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        return dir;
+      }
+    }
+    dir = dirname2(dir);
+  }
+  throw new Error("Could not find repository root");
+}
+function isExecutable(filePath) {
+  try {
+    const stats = statSync2(filePath);
+    return (stats.mode & 64) !== 0;
+  } catch {
+    return false;
+  }
+}
+function readFileEntry(repoRoot, sourcePath, destPath) {
+  const fullPath = join2(repoRoot, sourcePath);
+  if (!existsSync2(fullPath)) {
+    throw new Error(`Source file not found: ${fullPath}`);
+  }
+  const content = readFileSync2(fullPath, "utf-8");
+  const executable = isExecutable(fullPath);
+  return {
+    path: destPath,
+    content,
+    ...executable && { executable: true }
+  };
+}
+function buildBlock(repoRoot, name, def) {
+  const block = {
+    name,
+    description: def.description
+  };
+  if (def.files && def.files.length > 0) {
+    block.files = def.files.map((sourcePath) => {
+      const destPath = def.remap?.[sourcePath] ?? sourcePath;
+      return readFileEntry(repoRoot, sourcePath, destPath);
+    });
+  }
+  if (def.dependencies && Object.keys(def.dependencies).length > 0) {
+    block.dependencies = def.dependencies;
+  }
+  if (def.devDependencies && Object.keys(def.devDependencies).length > 0) {
+    block.devDependencies = def.devDependencies;
+  }
+  if (def.extends && def.extends.length > 0) {
+    block.extends = def.extends;
+  }
+  return block;
+}
+function buildRegistry(config, repoRoot) {
+  const blocks = {};
+  for (const [name, def] of Object.entries(config.blocks)) {
+    blocks[name] = buildBlock(repoRoot, name, def);
+  }
+  return {
+    version: config.version,
+    blocks
+  };
+}
+function resolveVersion(versions, name) {
+  const version = versions[name];
+  if (!version) {
+    throw new Error(`Missing resolved version for "${name}" in @outfitter/presets`);
+  }
+  return version;
+}
+function getWorkspacePackageVersion(relativePackageJsonPath) {
+  const pkgPath = join2(dirname2(fileURLToPath2(import.meta.url)), relativePackageJsonPath);
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  if (typeof pkg.version !== "string") {
+    throw new Error(`Expected version in package.json at ${pkgPath}`);
+  }
+  return `^${pkg.version}`;
+}
+function getToolingVersion() {
+  return getWorkspacePackageVersion("../../package.json");
+}
+function getOxlintPluginVersion() {
+  return getWorkspacePackageVersion("../../../oxlint-plugin/package.json");
+}
+function createRegistryConfig() {
+  const { all: versions } = getResolvedVersions();
+  const toolingVersion = getToolingVersion();
+  const oxlintPluginVersion = getOxlintPluginVersion();
+  return {
+    version: "1.0.0",
+    blocks: {
+      claude: {
+        description: "Claude Code settings and hooks for automated formatting",
+        files: [
+          ".claude/settings.json",
+          ".claude/hooks/format-code-on-stop.sh"
+        ]
+      },
+      linter: {
+        description: "Linter and formatter configuration (oxlint/oxfmt) via Ultracite",
+        files: [
+          "packages/tooling/configs/.oxlintrc.json",
+          "packages/tooling/configs/.oxfmtrc.jsonc"
+        ],
+        remap: {
+          "packages/tooling/configs/.oxlintrc.json": ".oxlintrc.json",
+          "packages/tooling/configs/.oxfmtrc.jsonc": ".oxfmtrc.jsonc"
+        },
+        devDependencies: {
+          "@outfitter/oxlint-plugin": oxlintPluginVersion,
+          ultracite: resolveVersion(versions, "ultracite"),
+          oxlint: resolveVersion(versions, "oxlint"),
+          oxfmt: resolveVersion(versions, "oxfmt")
+        }
+      },
+      lefthook: {
+        description: "Git hooks via Lefthook for pre-commit and pre-push",
+        files: ["packages/tooling/lefthook.yml"],
+        remap: { "packages/tooling/lefthook.yml": ".lefthook.yml" },
+        devDependencies: {
+          "@outfitter/tooling": toolingVersion,
+          lefthook: resolveVersion(versions, "lefthook"),
+          ultracite: resolveVersion(versions, "ultracite")
+        }
+      },
+      markdownlint: {
+        description: "Markdown linting configuration via markdownlint-cli2",
+        files: ["packages/tooling/.markdownlint-cli2.jsonc"],
+        remap: {
+          "packages/tooling/.markdownlint-cli2.jsonc": ".markdownlint-cli2.jsonc"
+        }
+      },
+      bootstrap: {
+        description: "Project bootstrap script for installing tools and dependencies",
+        files: ["packages/tooling/templates/bootstrap.sh"],
+        remap: {
+          "packages/tooling/templates/bootstrap.sh": "scripts/bootstrap.sh"
+        }
+      },
+      scaffolding: {
+        description: "Full starter kit: Claude settings, oxlint/oxfmt, Lefthook, markdownlint, and bootstrap script",
+        extends: ["claude", "linter", "lefthook", "markdownlint", "bootstrap"]
+      }
+    }
+  };
+}
+var REGISTRY_CONFIG = createRegistryConfig();
+function main() {
+  const scriptDir = dirname2(new URL(import.meta.url).pathname);
+  const repoRoot = findRepoRoot(scriptDir);
+  const outputDir = join2(repoRoot, "packages/tooling/registry");
+  const outputPath = join2(outputDir, "registry.json");
+  log(`Building registry from: ${repoRoot}`);
+  if (!existsSync2(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const registry = buildRegistry(REGISTRY_CONFIG, repoRoot);
+  writeFileSync(outputPath, `${JSON.stringify(registry, null, "\t")}
+`);
+  const blockCount = Object.keys(registry.blocks).length;
+  const fileCount = Object.values(registry.blocks).flatMap((b) => b.files ?? []).length;
+  log(`\u2713 Generated ${outputPath}`);
+  log(`  ${blockCount} blocks, ${fileCount} files embedded`);
+}
+if (import.meta.main) {
+  main();
+}
+export {
+  REGISTRY_CONFIG
+};

package/dist/registry/index.d.ts

@@ -0,0 +1,3 @@
+import "../shared/@outfitter/tooling-xqwn46sx.js";
+import { AddBlockOptions, AddBlockResult, Block, BlockDefinition, BlockSchema, FileEntry, FileEntrySchema, Registry, RegistryBuildConfig, RegistrySchema } from "../shared/@outfitter/tooling-sjm8nebx.js";
+export { RegistrySchema, RegistryBuildConfig, Registry, FileEntrySchema, FileEntry, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };

package/dist/registry/index.js

@@ -0,0 +1 @@
+export { BlockSchema, FileEntrySchema, RegistrySchema } from "./schema.js";

package/dist/registry/schema.d.ts

@@ -0,0 +1,2 @@
+import { AddBlockOptions, AddBlockResult, Block, BlockDefinition, BlockSchema, FileEntry, FileEntrySchema, Registry, RegistryBuildConfig, RegistrySchema } from "../shared/@outfitter/tooling-sjm8nebx.js";
+export { RegistrySchema, RegistryBuildConfig, Registry, FileEntrySchema, FileEntry, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };

package/dist/registry/schema.js

@@ -0,0 +1,28 @@
+// @bun
+import"../shared/@outfitter/tooling-jnrs9rqd.js";
+
+// packages/tooling/src/registry/schema.ts
+import { z } from "zod";
+var FileEntrySchema = z.object({
+  path: z.string().min(1),
+  content: z.string(),
+  executable: z.boolean().optional(),
+  template: z.boolean().optional()
+});
+var BlockSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  files: z.array(FileEntrySchema).optional(),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  devDependencies: z.record(z.string(), z.string()).optional(),
+  extends: z.array(z.string()).optional()
+});
+var RegistrySchema = z.object({
+  version: z.string(),
+  blocks: z.record(z.string(), BlockSchema)
+});
+export {
+  RegistrySchema,
+  FileEntrySchema,
+  BlockSchema
+};

package/dist/shared/@outfitter/tooling-0zjz8eg9.js

@@ -0,0 +1,106 @@
+// @bun
+import {
+  computeExpectedExports
+} from "./tooling-a6q3zh7t.js";
+import {
+  compareExports
+} from "./tooling-ayps7c4x.js";
+
+// packages/tooling/src/cli/check-exports.ts
+import { resolve } from "path";
+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 { resolveJsonMode, runCheckExports };

package/dist/shared/@outfitter/tooling-1hez6j9d.js

@@ -0,0 +1,21 @@
+// @bun
+// packages/tooling/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.exitCode = exitCode;
+}
+
+export { buildFixCommand, runFix };

package/dist/shared/@outfitter/tooling-2vv5y3s4.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  canBypassRedPhaseByChangedFiles,
+  checkBunVersion,
+  createVerificationPlan,
+  getChangedFilesForPush,
+  getCurrentBranch,
+  hasPackageSourceChanges,
+  hasRedPhaseBranchInContext,
+  isRedPhaseBranch,
+  isReleaseBranch,
+  isScaffoldBranch,
+  printTsdocSummary,
+  readPackageScripts
+} from "./tooling-c8q6mj8z.js";
+// packages/tooling/src/cli/pre-push.ts
+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 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 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;
+}
+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:push");
+    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:push" || plan.source === "verify:ci") {
+    log(`Using \`${plan.source}\` 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(log);
+    } catch {}
+  }
+  log("");
+  log(`${COLORS.green}Strict verification passed${COLORS.reset}`);
+  process.exitCode = 0;
+}
+
+export { runPrePush };