@outfitter/tooling 0.3.3 → 0.3.4

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-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-6cxfdx0q.js

@@ -0,0 +1,187 @@
+// @bun
+// packages/tooling/src/cli/check-changeset.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+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].toSorted();
+}
+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.toSorted();
+}
+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 };
+}
+function parseIgnoredPackagesFromChangesetConfig(jsonContent) {
+  try {
+    const parsed = JSON.parse(jsonContent);
+    if (!Array.isArray(parsed.ignore)) {
+      return [];
+    }
+    return parsed.ignore.filter((entry) => typeof entry === "string");
+  } catch {
+    return [];
+  }
+}
+function parseChangesetFrontmatterPackageNames(markdownContent) {
+  const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdownContent);
+  if (!frontmatterMatch?.[1]) {
+    return [];
+  }
+  const packages = new Set;
+  for (const line of frontmatterMatch[1].split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const match = /^(["']?)(@[^"':\s]+\/[^"':\s]+)\1\s*:/.exec(trimmed);
+    if (match?.[2]) {
+      packages.add(match[2]);
+    }
+  }
+  return [...packages].toSorted();
+}
+function findIgnoredPackageReferences(input) {
+  if (input.ignoredPackages.length === 0 || input.changesetFiles.length === 0) {
+    return [];
+  }
+  const ignored = new Set(input.ignoredPackages);
+  const results = [];
+  for (const file of input.changesetFiles) {
+    const content = input.readChangesetFile(file);
+    const referencedPackages = parseChangesetFrontmatterPackageNames(content);
+    const invalidReferences = referencedPackages.filter((pkg) => ignored.has(pkg));
+    if (invalidReferences.length > 0) {
+      results.push({ file, packages: invalidReferences.toSorted() });
+    }
+  }
+  return results.toSorted((a, b) => a.file.localeCompare(b.file));
+}
+function loadIgnoredPackages(cwd) {
+  const configPath = join(cwd, ".changeset", "config.json");
+  if (!existsSync(configPath)) {
+    return [];
+  }
+  try {
+    return parseIgnoredPackagesFromChangesetConfig(readFileSync(configPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getIgnoredReferencesForChangedChangesets(cwd, changesetFiles) {
+  const ignoredPackages = loadIgnoredPackages(cwd);
+  return findIgnoredPackageReferences({
+    changesetFiles,
+    ignoredPackages,
+    readChangesetFile: (filename) => {
+      try {
+        return readFileSync(join(cwd, ".changeset", filename), "utf-8");
+      } catch {
+        return "";
+      }
+    }
+  });
+}
+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.exitCode = 0;
+    return;
+  }
+  if (process.env["GITHUB_EVENT_NAME"] === "push") {
+    process.stdout.write(`${COLORS.dim}check-changeset skipped (push event)${COLORS.reset}
+`);
+    process.exitCode = 0;
+    return;
+  }
+  const cwd = process.cwd();
+  let changedFiles;
+  try {
+    const proc = Bun.spawnSync(["git", "diff", "--name-only", "origin/main...HEAD"], { cwd });
+    if (proc.exitCode !== 0) {
+      process.exitCode = 0;
+      return;
+    }
+    changedFiles = proc.stdout.toString().trim().split(`
+`).filter((line) => line.length > 0);
+  } catch {
+    process.exitCode = 0;
+    return;
+  }
+  const changedPackages = getChangedPackagePaths(changedFiles);
+  if (changedPackages.length === 0) {
+    process.stdout.write(`${COLORS.green}No package source changes detected.${COLORS.reset}
+`);
+    process.exitCode = 0;
+    return;
+  }
+  const changesetFiles = getChangedChangesetFiles(changedFiles);
+  const check = checkChangesetRequired(changedPackages, changesetFiles);
+  if (!check.ok) {
+    process.stderr.write(`${COLORS.yellow}No changeset found.${COLORS.reset} ` + "Consider adding one with `bun run changeset` for a custom changelog entry.\n\n");
+    process.stderr.write(`Packages with source changes:
+
+`);
+    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} for a custom changelog entry, ` + `or add ${COLORS.blue}release:none${COLORS.reset} to skip.
+`);
+  }
+  const ignoredReferences = getIgnoredReferencesForChangedChangesets(cwd, changesetFiles);
+  if (ignoredReferences.length > 0) {
+    process.stderr.write(`${COLORS.red}Invalid changeset package reference(s).${COLORS.reset}
+
+`);
+    process.stderr.write(`Changesets must not reference packages listed in .changeset/config.json ignore:
+
+`);
+    for (const reference of ignoredReferences) {
+      process.stderr.write(`  ${COLORS.yellow}${reference.file}${COLORS.reset}
+`);
+      for (const pkg of reference.packages) {
+        process.stderr.write(`    - ${pkg}
+`);
+      }
+    }
+    process.stderr.write(`
+Update the affected changeset files to remove ignored packages before merging.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`${COLORS.green}Changeset found for ${changedPackages.length} changed package(s).${COLORS.reset}
+`);
+  process.exitCode = 0;
+}
+
+export { getChangedPackagePaths, getChangedChangesetFiles, checkChangesetRequired, parseIgnoredPackagesFromChangesetConfig, parseChangesetFrontmatterPackageNames, findIgnoredPackageReferences, runCheckChangeset };

package/dist/shared/{chunk-cmde0fwx.js → @outfitter/tooling-875svjnz.js}

@@ -1,9 +1,10 @@
+// @bun
 import {
   __require
-} from "./chunk-3s189drz.js";
+} from "./tooling-jnrs9rqd.js";
 
-// src/cli/check-tsdoc.ts
-import { resolve } from "node:path";
+// packages/tooling/src/cli/check-tsdoc.ts
+import { resolve } from "path";
 import ts from "typescript";
 import { z } from "zod";
 var coverageLevelSchema = z.enum([
@@ -174,7 +175,7 @@ function bar(percentage, width = 20) {
   const filled = Math.round(percentage / 100 * width);
   const empty = width - filled;
   const color = percentage >= 80 ? COLORS.green : percentage >= 50 ? COLORS.yellow : COLORS.red;
-  return `${color}${"█".repeat(filled)}${COLORS.dim}${"░".repeat(empty)}${COLORS.reset}`;
+  return `${color}${"\u2588".repeat(filled)}${COLORS.dim}${"\u2591".repeat(empty)}${COLORS.reset}`;
 }
 function discoverPackages(cwd) {
   const packages = [];
@@ -195,7 +196,7 @@ function discoverPackages(cwd) {
       const pkgRoot = resolve(cwd, rootDir, pkgDir);
       let pkgName = pkgDir;
       try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
         if (pkgJson.name)
           pkgName = pkgJson.name;
       } catch {}
@@ -209,10 +210,10 @@ function discoverPackages(cwd) {
   if (packages.length === 0) {
     const entryPoint = resolve(cwd, "src/index.ts");
     try {
-      __require("node:fs").accessSync(entryPoint);
+      __require("fs").accessSync(entryPoint);
       let pkgName = "root";
       try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
         if (pkgJson.name)
           pkgName = pkgJson.name;
       } catch {}
@@ -224,7 +225,7 @@ function discoverPackages(cwd) {
       seenEntryPoints.add(entryPoint);
     } catch {}
   }
-  return packages.sort((a, b) => a.name.localeCompare(b.name));
+  return packages.toSorted((a, b) => a.name.localeCompare(b.name));
 }
 function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
   const result = [];
@@ -256,7 +257,7 @@ function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
 }
 function analyzePackage(pkg, workspaceCwd) {
   try {
-    __require("node:fs").accessSync(pkg.entryPoint);
+    __require("fs").accessSync(pkg.entryPoint);
   } catch {
     return {
       name: pkg.name,
@@ -271,7 +272,7 @@ function analyzePackage(pkg, workspaceCwd) {
   }
   let tsconfigPath = resolve(pkg.path, "tsconfig.json");
   try {
-    __require("node:fs").accessSync(tsconfigPath);
+    __require("fs").accessSync(tsconfigPath);
   } catch {
     tsconfigPath = resolve(workspaceCwd, "tsconfig.json");
   }
@@ -318,7 +319,7 @@ function analyzeCheckTsdoc(options = {}) {
       const entryPoint = resolve(absPath, "src/index.ts");
       let name = p;
       try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
         if (pkgJson.name)
           name = pkgJson.name;
       } catch {}
@@ -387,7 +388,8 @@ async function runCheckTsdoc(options = {}) {
 ` + `Searched: packages/*/src/index.ts, apps/*/src/index.ts, src/index.ts
 ` + `Use --package <path> to specify a package path explicitly.
 `);
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
   if (resolveJsonMode(options)) {
     process.stdout.write(`${JSON.stringify(result, null, 2)}
@@ -398,24 +400,7 @@ async function runCheckTsdoc(options = {}) {
       minCoverage: options.minCoverage
     });
   }
-  process.exit(result.ok ? 0 : 1);
-}
-
-// src/version.ts
-import { readFileSync } from "node:fs";
-import { createRequire } from "node: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;
+  process.exitCode = result.ok ? 0 : 1;
 }
-var VERSION = readPackageVersion();
 
-export { coverageLevelSchema, declarationCoverageSchema, packageCoverageSchema, tsDocCheckResultSchema, analyzeSourceFile, calculateCoverage, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc, VERSION };
+export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };

package/dist/shared/@outfitter/tooling-9ram55dd.js

@@ -0,0 +1,69 @@
+// @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",
+    "oxlint",
+    "--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.exitCode = 1;
+    return;
+  }
+  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.exitCode = exitCode;
+}
+
+export { detectFrameworks, buildUltraciteCommand, runInit };

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

@@ -0,0 +1,21 @@
+// @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 });
+  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 { buildCheckCommand, runCheck };

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

@@ -0,0 +1,102 @@
+// @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.toSorted((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.exitCode = 1;
+    return;
+  }
+  const violations = findBoundaryViolations(entries);
+  if (violations.length === 0) {
+    process.stdout.write(`No boundary invocation violations detected in root/apps scripts.
+`);
+    process.exitCode = 0;
+    return;
+  }
+  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.exitCode = 1;
+}
+
+export { detectBoundaryViolation, findBoundaryViolations, readScriptEntries, runCheckBoundaryInvocations };

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