@outfitter/tooling 0.2.0

package/dist/registry/build.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/tooling/src/registry/build.ts
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function findRepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== "/") {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        return dir;
+      }
+    }
+    dir = dirname(dir);
+  }
+  throw new Error("Could not find repository root");
+}
+function isExecutable(filePath) {
+  try {
+    const stats = statSync(filePath);
+    return (stats.mode & 64) !== 0;
+  } catch {
+    return false;
+  }
+}
+function readFileEntry(repoRoot, sourcePath, destPath) {
+  const fullPath = join(repoRoot, sourcePath);
+  if (!existsSync(fullPath)) {
+    throw new Error(`Source file not found: ${fullPath}`);
+  }
+  const content = readFileSync(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
+  };
+}
+var REGISTRY_CONFIG = {
+  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"
+      ]
+    },
+    biome: {
+      description: "Biome linter/formatter configuration via Ultracite",
+      files: ["packages/tooling/biome.json"],
+      remap: { "packages/tooling/biome.json": "biome.json" },
+      devDependencies: { ultracite: "^7.0.0" }
+    },
+    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: { lefthook: "^2.0.0" }
+    },
+    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: ["scripts/bootstrap.sh"]
+    },
+    scaffolding: {
+      description: "Full starter kit: Claude settings, Biome, Lefthook, markdownlint, and bootstrap script",
+      extends: ["claude", "biome", "lefthook", "markdownlint", "bootstrap"]
+    }
+  }
+};
+function main() {
+  const scriptDir = dirname(new URL(import.meta.url).pathname);
+  const repoRoot = findRepoRoot(scriptDir);
+  const outputDir = join(repoRoot, "packages/tooling/registry");
+  const outputPath = join(outputDir, "registry.json");
+  console.log(`Building registry from: ${repoRoot}`);
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const registry = buildRegistry(REGISTRY_CONFIG, repoRoot);
+  writeFileSync(outputPath, JSON.stringify(registry, null, 2) + `
+`);
+  const blockCount = Object.keys(registry.blocks).length;
+  const fileCount = Object.values(registry.blocks).flatMap((b) => b.files ?? []).length;
+  console.log(`\u2713 Generated ${outputPath}`);
+  console.log(`  ${blockCount} blocks, ${fileCount} files embedded`);
+}
+main();

package/dist/registry/index.d.ts

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

package/dist/registry/index.js

@@ -0,0 +1,12 @@
+// @bun
+import"../shared/@outfitter/tooling-kcvs6mys.js";
+import {
+  BlockSchema,
+  FileEntrySchema,
+  RegistrySchema
+} from "../shared/@outfitter/tooling-g83d0kjv.js";
+export {
+  RegistrySchema,
+  FileEntrySchema,
+  BlockSchema
+};

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";
+export { RegistrySchema, RegistryBuildConfig, Registry, FileEntrySchema, FileEntry, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };

package/dist/registry/schema.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  BlockSchema,
+  FileEntrySchema,
+  RegistrySchema
+} from "../shared/@outfitter/tooling-g83d0kjv.js";
+export {
+  RegistrySchema,
+  FileEntrySchema,
+  BlockSchema
+};

package/dist/shared/@outfitter/tooling-75j500dv.js

@@ -0,0 +1,142 @@
+// @bun
+// packages/tooling/src/cli/upgrade-bun.ts
+import { existsSync, readFileSync, writeFileSync } 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) {
+  console.log(msg);
+}
+function info(msg) {
+  console.log(`${COLORS.blue}\u25B8${COLORS.reset} ${msg}`);
+}
+function success(msg) {
+  console.log(`${COLORS.green}\u2713${COLORS.reset} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${COLORS.yellow}!${COLORS.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(join(dir, path));
+    }
+  }
+  return results;
+}
+function updateEnginesBun(filePath, version) {
+  const content = readFileSync(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 = readFileSync(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 = join(cwd, ".bun-version");
+  let version = targetVersion;
+  if (!version) {
+    info("Fetching latest Bun version...");
+    version = await fetchLatestVersion();
+    log(`Latest version: ${version}`);
+  }
+  const currentVersion = existsSync(bunVersionFile) ? readFileSync(bunVersionFile, "utf-8").trim() : "unknown";
+  log(`Current version: ${currentVersion}`);
+  if (currentVersion === version) {
+    success(`Already on version ${version}`);
+    return;
+  }
+  log("");
+  info(`Upgrading Bun: ${currentVersion} \u2192 ${version}`);
+  log("");
+  writeFileSync(bunVersionFile, `${version}
+`);
+  success("Updated .bun-version");
+  const packageFiles = findPackageJsonFiles(cwd);
+  info("Updating engines.bun...");
+  for (const file of packageFiles) {
+    if (updateEnginesBun(file, version)) {
+      log(`  ${file.replace(cwd + "/", "")}`);
+    }
+  }
+  info("Updating @types/bun...");
+  for (const file of packageFiles) {
+    if (updateTypesBun(file, version)) {
+      log(`  ${file.replace(cwd + "/", "")}`);
+    }
+  }
+  if (options.install !== false) {
+    log("");
+    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");
+      log("Install manually: curl -fsSL https://bun.sh/install | bash");
+    } else {
+      success(`Bun ${version} installed`);
+      log("");
+      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");
+      }
+    }
+  }
+  log("");
+  success("Done! Changes ready to commit:");
+  log("  - .bun-version");
+  log("  - package.json files (engines.bun, @types/bun)");
+  log("  - bun.lock");
+  log("");
+  log(`Commit with: git add -A && git commit -m 'chore: upgrade Bun to ${version}'`);
+}
+
+export { runUpgradeBun };

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

@@ -0,0 +1,23 @@
+// @bun
+// 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()).optional(),
+  devDependencies: z.record(z.string()).optional(),
+  extends: z.array(z.string()).optional()
+});
+var RegistrySchema = z.object({
+  version: z.string(),
+  blocks: z.record(BlockSchema)
+});
+
+export { FileEntrySchema, BlockSchema, RegistrySchema };

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

@@ -0,0 +1 @@
+// @bun

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

@@ -0,0 +1,99 @@
+// @bun
+// 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) {
+  console.log(msg);
+}
+function getCurrentBranch() {
+  const result = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+  return result.stdout.toString().trim();
+}
+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 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 runTests() {
+  log("");
+  const result = Bun.spawnSync(["bun", "run", "test"], {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  return result.exitCode === 0;
+}
+async function runPrePush(options = {}) {
+  log(`${COLORS.blue}Pre-push test${COLORS.reset} (TDD-aware)`);
+  log("");
+  const branch = getCurrentBranch();
+  if (isRedPhaseBranch(branch)) {
+    log(`${COLORS.yellow}TDD RED phase${COLORS.reset} detected: ${COLORS.blue}${branch}${COLORS.reset}`);
+    log(`${COLORS.yellow}Skipping test execution${COLORS.reset} - tests are expected to fail in RED phase`);
+    log("");
+    log("Remember: GREEN phase (implementation) must make these tests pass!");
+    process.exit(0);
+  }
+  if (isScaffoldBranch(branch)) {
+    if (hasRedPhaseBranchInContext(branch)) {
+      log(`${COLORS.yellow}Scaffold branch${COLORS.reset} with RED phase branch in context: ${COLORS.blue}${branch}${COLORS.reset}`);
+      log(`${COLORS.yellow}Skipping test execution${COLORS.reset} - RED phase tests expected to fail`);
+      log("");
+      process.exit(0);
+    }
+  }
+  if (options.force) {
+    log(`${COLORS.yellow}Force flag set${COLORS.reset} - skipping tests`);
+    process.exit(0);
+  }
+  log(`Running tests for branch: ${COLORS.blue}${branch}${COLORS.reset}`);
+  if (runTests()) {
+    log("");
+    log(`${COLORS.green}All tests passed${COLORS.reset}`);
+    process.exit(0);
+  } else {
+    log("");
+    log(`${COLORS.red}Tests failed${COLORS.reset}`);
+    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);
+  }
+}
+
+export { runPrePush };

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

@@ -0,0 +1,20 @@
+// @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 });
+  console.log(`Running: bun x ${cmd.join(" ")}`);
+  const proc = Bun.spawn(["bun", "x", ...cmd], {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+
+export { buildFixCommand, runFix };

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

@@ -0,0 +1,109 @@
+import { ZodType } from "zod";
+/**
+* File entry in a block.
+*/
+interface FileEntry {
+	/** Destination path relative to project root */
+	path: string;
+	/** File contents (embedded in registry) */
+	content: string;
+	/** Whether to chmod +x after copying */
+	executable?: boolean | undefined;
+	/** Whether to process as a template (future) */
+	template?: boolean | undefined;
+}
+/**
+* Schema for a file entry in a block.
+* Represents a file that will be copied to the user's project.
+*/
+declare const FileEntrySchema: ZodType<FileEntry>;
+/**
+* Block in the registry.
+*/
+interface Block {
+	/** Block name (matches the key in blocks record) */
+	name: string;
+	/** Human-readable description */
+	description: string;
+	/** Files included in this block */
+	files?: FileEntry[] | undefined;
+	/** npm dependencies to add to package.json */
+	dependencies?: Record<string, string> | undefined;
+	/** npm devDependencies to add to package.json */
+	devDependencies?: Record<string, string> | undefined;
+	/** Other blocks this block extends (for composite blocks) */
+	extends?: string[] | undefined;
+}
+/**
+* Schema for a block in the registry.
+* A block is a collection of related files that can be added together.
+*/
+declare const BlockSchema: ZodType<Block>;
+/**
+* Complete registry structure.
+*/
+interface Registry {
+	/** Registry schema version */
+	version: string;
+	/** Map of block name to block definition */
+	blocks: Record<string, Block>;
+}
+/**
+* Schema for the complete registry.
+* Contains all available blocks with their files and metadata.
+*/
+declare const RegistrySchema: ZodType<Registry>;
+/**
+* Block definition used in the build script.
+* Specifies how to collect source files into a block.
+*/
+interface BlockDefinition {
+	/** Human-readable description */
+	description: string;
+	/** Source file paths (relative to repo root) */
+	files?: string[];
+	/** Remap source paths to destination paths */
+	remap?: Record<string, string>;
+	/** npm dependencies */
+	dependencies?: Record<string, string>;
+	/** npm devDependencies */
+	devDependencies?: Record<string, string>;
+	/** Other blocks this block extends */
+	extends?: string[];
+}
+/**
+* Configuration for the registry build.
+*/
+interface RegistryBuildConfig {
+	/** Registry schema version */
+	version: string;
+	/** Block definitions */
+	blocks: Record<string, BlockDefinition>;
+}
+/**
+* Result of adding a block to a project.
+*/
+interface AddBlockResult {
+	/** Files that were created */
+	created: string[];
+	/** Files that were skipped (already exist) */
+	skipped: string[];
+	/** Files that were overwritten (with --force) */
+	overwritten: string[];
+	/** Dependencies added to package.json */
+	dependencies: Record<string, string>;
+	/** devDependencies added to package.json */
+	devDependencies: Record<string, string>;
+}
+/**
+* Options for the add command.
+*/
+interface AddBlockOptions {
+	/** Overwrite existing files */
+	force?: boolean;
+	/** Show what would be added without making changes */
+	dryRun?: boolean;
+	/** Working directory (defaults to cwd) */
+	cwd?: string;
+}
+export { FileEntry, FileEntrySchema, Block, BlockSchema, Registry, RegistrySchema, BlockDefinition, RegistryBuildConfig, AddBlockResult, AddBlockOptions };

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

@@ -0,0 +1,58 @@
+// @bun
+// packages/tooling/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()) {
+    console.error("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(" ")}`);
+  const proc = Bun.spawn(["bun", "x", ...cmd], {
+    cwd,
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+
+export { detectFrameworks, buildUltraciteCommand, runInit };

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

@@ -0,0 +1,20 @@
+// @bun
+// packages/tooling/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 });
+  console.log(`Running: bun x ${cmd.join(" ")}`);
+  const proc = Bun.spawn(["bun", "x", ...cmd], {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+
+export { buildCheckCommand, runCheck };

package/lefthook.yml

@@ -0,0 +1,30 @@
+# Lefthook configuration preset for Outfitter projects
+# https://github.com/evilmartians/lefthook
+#
+# Usage: In your project's .lefthook.yml, add:
+#   extends:
+#     - node_modules/@outfitter/tooling/lefthook.yml
+
+pre-commit:
+  parallel: true
+  commands:
+    ultracite:
+      glob: "*.{js,jsx,ts,tsx,json,jsonc,css}"
+      run: bun x ultracite fix {staged_files}
+      stage_fixed: true
+
+    typecheck:
+      glob: "*.{ts,tsx}"
+      run: bun run typecheck
+
+pre-push:
+  parallel: false
+  commands:
+    build:
+      run: bun run build
+
+    test:
+      # TDD-aware: skips tests on RED phase branches (*-tests, */tests, *_tests)
+      # Override with `run: bun run test` if you don't want TDD support
+      # Requires: @outfitter/tooling must be a devDependency in your project
+      run: bunx @outfitter/tooling pre-push