@outfitter/tooling 0.2.2 → 0.2.3

package/dist/cli/init.js

@@ -4,6 +4,7 @@ import {
   detectFrameworks,
   runInit
 } from "../shared/@outfitter/tooling-mxwc1n8w.js";
+import"../shared/@outfitter/tooling-dvwh9qve.js";
 export {
   runInit,
   detectFrameworks,

package/dist/cli/pre-push.js

@@ -8,6 +8,7 @@ import {
   isTestOnlyPath,
   runPrePush
 } from "../shared/@outfitter/tooling-8sd32ts6.js";
+import"../shared/@outfitter/tooling-dvwh9qve.js";
 export {
   runPrePush,
   isTestOnlyPath,

package/dist/cli/upgrade-bun.js

@@ -2,6 +2,7 @@
 import {
   runUpgradeBun
 } from "../shared/@outfitter/tooling-9yzd08v1.js";
+import"../shared/@outfitter/tooling-dvwh9qve.js";
 export {
   runUpgradeBun
 };

package/dist/index.d.ts

@@ -106,37 +106,6 @@ interface AddBlockOptions {
 	/** Working directory (defaults to cwd) */
 	cwd?: string;
 }
-/**
-* @outfitter/tooling
-*
-* Dev tooling configuration presets for Outfitter projects.
-* Provides standardized biome, TypeScript, lefthook, and markdownlint configurations.
-*
-* @example
-* ```json
-* // biome.json
-* {
-*   "extends": ["ultracite/biome/core", "@outfitter/tooling/biome.json"]
-* }
-* ```
-*
-* @example
-* ```json
-* // tsconfig.json
-* {
-*   "extends": "@outfitter/tooling/tsconfig.preset.bun.json"
-* }
-* ```
-*
-* @example
-* ```yaml
-* # .lefthook.yml
-* extends:
-*   - node_modules/@outfitter/tooling/lefthook.yml
-* ```
-*
-* @packageDocumentation
-*/
-/** Package version */
-declare const VERSION = "0.1.0-rc.1";
+/** Package version, read from package.json at load time. */
+declare const VERSION: string;
 export { VERSION, RegistrySchema, RegistryBuildConfig, Registry, FileEntrySchema, FileEntry, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  VERSION
+} from "./shared/chunk-8aenrm6f.js";
+import"./shared/chunk-3s189drz.js";
+
 // src/registry/schema.ts
 import { z } from "zod";
 var FileEntrySchema = z.object({
@@ -18,8 +23,6 @@ var RegistrySchema = z.object({
   version: z.string(),
   blocks: z.record(BlockSchema)
 });
-// src/index.ts
-var VERSION = "0.1.0-rc.1";
 export {
   VERSION,
   RegistrySchema,

package/dist/registry/build.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 // @bun
+import"../shared/@outfitter/tooling-dvwh9qve.js";
 
 // packages/tooling/src/registry/build.ts
 import {

package/dist/registry/index.js

@@ -5,6 +5,7 @@ import {
   FileEntrySchema,
   RegistrySchema
 } from "../shared/@outfitter/tooling-g83d0kjv.js";
+import"../shared/@outfitter/tooling-dvwh9qve.js";
 export {
   RegistrySchema,
   FileEntrySchema,

package/dist/registry/schema.js

@@ -4,6 +4,7 @@ import {
   FileEntrySchema,
   RegistrySchema
 } from "../shared/@outfitter/tooling-g83d0kjv.js";
+import"../shared/@outfitter/tooling-dvwh9qve.js";
 export {
   RegistrySchema,
   FileEntrySchema,

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

@@ -0,0 +1,70 @@
+// @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.exit(1);
+  }
+  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.exit(1);
+  }
+  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.exit(0);
+  }
+  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.exit(1);
+}
+
+export { parseGitDiff, parseUntrackedFiles, isCleanTree, runCheckCleanTree };

package/dist/shared/@outfitter/tooling-3w8vr2w3.js

@@ -0,0 +1,94 @@
+// @bun
+// packages/tooling/src/cli/check-changeset.ts
+function getChangedPackagePaths(files) {
+  const packageNames = new Set;
+  const pattern = /^packages\/([^/]+)\/src\//;
+  for (const file of files) {
+    const match = pattern.exec(file);
+    if (match?.[1]) {
+      packageNames.add(match[1]);
+    }
+  }
+  return [...packageNames].sort();
+}
+function getChangedChangesetFiles(files) {
+  const pattern = /^\.changeset\/([^/]+\.md)$/;
+  const results = [];
+  for (const file of files) {
+    const match = pattern.exec(file);
+    if (match?.[1] && match[1] !== "README.md") {
+      results.push(match[1]);
+    }
+  }
+  return results.sort();
+}
+function checkChangesetRequired(changedPackages, changesetFiles) {
+  if (changedPackages.length === 0) {
+    return { ok: true, missingFor: [] };
+  }
+  if (changesetFiles.length > 0) {
+    return { ok: true, missingFor: [] };
+  }
+  return { ok: false, missingFor: changedPackages };
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m"
+};
+async function runCheckChangeset(options = {}) {
+  if (options.skip || process.env["NO_CHANGESET"] === "1") {
+    process.stdout.write(`${COLORS.dim}check-changeset skipped (NO_CHANGESET=1)${COLORS.reset}
+`);
+    process.exit(0);
+  }
+  if (process.env["GITHUB_EVENT_NAME"] === "push") {
+    process.stdout.write(`${COLORS.dim}check-changeset skipped (push event)${COLORS.reset}
+`);
+    process.exit(0);
+  }
+  const cwd = process.cwd();
+  let changedFiles;
+  try {
+    const proc = Bun.spawnSync(["git", "diff", "--name-only", "origin/main...HEAD"], { cwd });
+    if (proc.exitCode !== 0) {
+      process.exit(0);
+    }
+    changedFiles = proc.stdout.toString().trim().split(`
+`).filter((line) => line.length > 0);
+  } catch {
+    process.exit(0);
+  }
+  const changedPackages = getChangedPackagePaths(changedFiles);
+  if (changedPackages.length === 0) {
+    process.stdout.write(`${COLORS.green}No package source changes detected.${COLORS.reset}
+`);
+    process.exit(0);
+  }
+  const changesetFiles = getChangedChangesetFiles(changedFiles);
+  const check = checkChangesetRequired(changedPackages, changesetFiles);
+  if (check.ok) {
+    process.stdout.write(`${COLORS.green}Changeset found for ${changedPackages.length} changed package(s).${COLORS.reset}
+`);
+    process.exit(0);
+  }
+  process.stderr.write(`${COLORS.red}Missing changeset!${COLORS.reset}
+
+`);
+  process.stderr.write(`The following packages have source changes but no changeset:
+
+`);
+  for (const pkg of check.missingFor) {
+    process.stderr.write(`  ${COLORS.yellow}@outfitter/${pkg}${COLORS.reset}
+`);
+  }
+  process.stderr.write(`
+Run ${COLORS.blue}bun run changeset${COLORS.reset} to add a changeset, ` + `or add the ${COLORS.blue}no-changeset${COLORS.reset} label to skip.
+`);
+  process.exit(1);
+}
+
+export { getChangedPackagePaths, getChangedChangesetFiles, checkChangesetRequired, runCheckChangeset };

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-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-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 };