@outfitter/tooling 0.3.0 → 0.3.3

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

@@ -1,405 +0,0 @@
-// @bun
-import {
-  __require
-} from "./tooling-dvwh9qve.js";
-
-// packages/tooling/src/cli/check-tsdoc.ts
-import { resolve } from "path";
-import ts from "typescript";
-import { z } from "zod";
-var coverageLevelSchema = z.enum([
-  "documented",
-  "partial",
-  "undocumented"
-]);
-var declarationCoverageSchema = z.object({
-  name: z.string(),
-  kind: z.string(),
-  level: coverageLevelSchema,
-  file: z.string(),
-  line: z.number()
-});
-var coverageSummarySchema = z.object({
-  documented: z.number(),
-  partial: z.number(),
-  undocumented: z.number(),
-  total: z.number(),
-  percentage: z.number()
-});
-var packageCoverageSchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  declarations: z.array(declarationCoverageSchema),
-  documented: z.number(),
-  partial: z.number(),
-  undocumented: z.number(),
-  total: z.number(),
-  percentage: z.number()
-});
-var tsDocCheckResultSchema = z.object({
-  ok: z.boolean(),
-  packages: z.array(packageCoverageSchema),
-  summary: coverageSummarySchema
-});
-function isExportedDeclaration(node) {
-  if (ts.isExportDeclaration(node))
-    return false;
-  if (ts.isExportAssignment(node))
-    return false;
-  const isDeclaration = ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
-  if (!isDeclaration)
-    return false;
-  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-  if (!modifiers)
-    return false;
-  return modifiers.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword);
-}
-function getDeclarationName(node) {
-  if (ts.isVariableStatement(node)) {
-    const decl = node.declarationList.declarations[0];
-    if (decl && ts.isIdentifier(decl.name)) {
-      return decl.name.text;
-    }
-    return;
-  }
-  if (ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) {
-    return node.name?.text;
-  }
-  return;
-}
-function getDeclarationKind(node) {
-  if (ts.isFunctionDeclaration(node))
-    return "function";
-  if (ts.isInterfaceDeclaration(node))
-    return "interface";
-  if (ts.isTypeAliasDeclaration(node))
-    return "type";
-  if (ts.isClassDeclaration(node))
-    return "class";
-  if (ts.isEnumDeclaration(node))
-    return "enum";
-  if (ts.isVariableStatement(node))
-    return "variable";
-  return "unknown";
-}
-function hasJSDocComment(node, sourceFile) {
-  const sourceText = sourceFile.getFullText();
-  const ranges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
-  if (!ranges)
-    return false;
-  return ranges.some((range) => {
-    if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia)
-      return false;
-    const text = sourceText.slice(range.pos, range.end);
-    return text.startsWith("/**");
-  });
-}
-function memberHasJSDoc(member, sourceFile) {
-  const sourceText = sourceFile.getFullText();
-  const ranges = ts.getLeadingCommentRanges(sourceText, member.getFullStart());
-  if (!ranges)
-    return false;
-  return ranges.some((range) => {
-    if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia)
-      return false;
-    const text = sourceText.slice(range.pos, range.end);
-    return text.startsWith("/**");
-  });
-}
-function classifyDeclaration(node, sourceFile) {
-  const hasDoc = hasJSDocComment(node, sourceFile);
-  if (!hasDoc)
-    return "undocumented";
-  if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node)) {
-    const members = node.members;
-    if (members.length > 0) {
-      const allMembersDocumented = members.every((member) => memberHasJSDoc(member, sourceFile));
-      if (!allMembersDocumented)
-        return "partial";
-    }
-  }
-  return "documented";
-}
-function analyzeSourceFile(sourceFile) {
-  const results = [];
-  for (const statement of sourceFile.statements) {
-    if (!isExportedDeclaration(statement))
-      continue;
-    const name = getDeclarationName(statement);
-    if (!name)
-      continue;
-    const kind = getDeclarationKind(statement);
-    const level = classifyDeclaration(statement, sourceFile);
-    const { line } = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
-    results.push({
-      name,
-      kind,
-      level,
-      file: sourceFile.fileName,
-      line: line + 1
-    });
-  }
-  return results;
-}
-function calculateCoverage(declarations) {
-  const total = declarations.length;
-  if (total === 0) {
-    return {
-      documented: 0,
-      partial: 0,
-      undocumented: 0,
-      total: 0,
-      percentage: 100
-    };
-  }
-  const documented = declarations.filter((d) => d.level === "documented").length;
-  const partial = declarations.filter((d) => d.level === "partial").length;
-  const undocumented = declarations.filter((d) => d.level === "undocumented").length;
-  const score = documented + partial * 0.5;
-  const percentage = Math.round(score / total * 100);
-  return { documented, partial, undocumented, total, percentage };
-}
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m",
-  bold: "\x1B[1m"
-};
-function resolveJsonMode(options = {}) {
-  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
-}
-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}${"\u2588".repeat(filled)}${COLORS.dim}${"\u2591".repeat(empty)}${COLORS.reset}`;
-}
-function discoverPackages(cwd) {
-  const packages = [];
-  const seenEntryPoints = new Set;
-  for (const pattern of ["packages/*/src/index.ts", "apps/*/src/index.ts"]) {
-    const glob = new Bun.Glob(pattern);
-    for (const match of glob.scanSync({ cwd, dot: false })) {
-      const parts = match.split("/");
-      const rootDir = parts[0];
-      const pkgDir = parts[1];
-      if (!rootDir || !pkgDir)
-        continue;
-      const entryPoint = resolve(cwd, match);
-      if (seenEntryPoints.has(entryPoint)) {
-        continue;
-      }
-      seenEntryPoints.add(entryPoint);
-      const pkgRoot = resolve(cwd, rootDir, pkgDir);
-      let pkgName = pkgDir;
-      try {
-        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
-        if (pkgJson.name)
-          pkgName = pkgJson.name;
-      } catch {}
-      packages.push({
-        name: pkgName,
-        path: pkgRoot,
-        entryPoint
-      });
-    }
-  }
-  if (packages.length === 0) {
-    const entryPoint = resolve(cwd, "src/index.ts");
-    try {
-      __require("fs").accessSync(entryPoint);
-      let pkgName = "root";
-      try {
-        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
-        if (pkgJson.name)
-          pkgName = pkgJson.name;
-      } catch {}
-      packages.push({
-        name: pkgName,
-        path: cwd,
-        entryPoint
-      });
-      seenEntryPoints.add(entryPoint);
-    } catch {}
-  }
-  return packages.sort((a, b) => a.name.localeCompare(b.name));
-}
-function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
-  const result = [];
-  const seen = new Set;
-  for (const statement of sourceFile.statements) {
-    if (!ts.isExportDeclaration(statement))
-      continue;
-    if (!statement.moduleSpecifier)
-      continue;
-    if (!ts.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    const specifier = statement.moduleSpecifier.text;
-    if (!specifier.startsWith("."))
-      continue;
-    const resolvedModule = ts.resolveModuleName(specifier, sourceFile.fileName, program.getCompilerOptions(), ts.sys);
-    const resolvedFileName = resolvedModule.resolvedModule?.resolvedFileName;
-    if (!resolvedFileName)
-      continue;
-    if (!resolvedFileName.startsWith(pkgPath))
-      continue;
-    if (seen.has(resolvedFileName))
-      continue;
-    seen.add(resolvedFileName);
-    const sf = program.getSourceFile(resolvedFileName);
-    if (sf)
-      result.push(sf);
-  }
-  return result;
-}
-function analyzePackage(pkg, workspaceCwd) {
-  try {
-    __require("fs").accessSync(pkg.entryPoint);
-  } catch {
-    return {
-      name: pkg.name,
-      path: pkg.path,
-      declarations: [],
-      documented: 0,
-      partial: 0,
-      undocumented: 0,
-      total: 0,
-      percentage: 0
-    };
-  }
-  let tsconfigPath = resolve(pkg.path, "tsconfig.json");
-  try {
-    __require("fs").accessSync(tsconfigPath);
-  } catch {
-    tsconfigPath = resolve(workspaceCwd, "tsconfig.json");
-  }
-  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, pkg.path);
-  const program = ts.createProgram({
-    rootNames: [pkg.entryPoint],
-    options: parsedConfig.options,
-    host: ts.createCompilerHost(parsedConfig.options)
-  });
-  const sourceFile = program.getSourceFile(pkg.entryPoint);
-  if (!sourceFile) {
-    return {
-      name: pkg.name,
-      path: pkg.path,
-      declarations: [],
-      documented: 0,
-      partial: 0,
-      undocumented: 0,
-      total: 0,
-      percentage: 0
-    };
-  }
-  const declarations = analyzeSourceFile(sourceFile);
-  const reExportedFiles = collectReExportedSourceFiles(sourceFile, program, pkg.path);
-  for (const sf of reExportedFiles) {
-    declarations.push(...analyzeSourceFile(sf));
-  }
-  const stats = calculateCoverage(declarations);
-  return {
-    name: pkg.name,
-    path: pkg.path,
-    declarations,
-    ...stats
-  };
-}
-function analyzeCheckTsdoc(options = {}) {
-  const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
-  const minCoverage = options.minCoverage ?? 0;
-  let packages;
-  if (options.paths && options.paths.length > 0) {
-    packages = options.paths.map((p) => {
-      const absPath = resolve(cwd, p);
-      const entryPoint = resolve(absPath, "src/index.ts");
-      let name = p;
-      try {
-        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
-        if (pkgJson.name)
-          name = pkgJson.name;
-      } catch {}
-      return { name, path: absPath, entryPoint };
-    });
-  } else {
-    packages = discoverPackages(cwd);
-  }
-  if (packages.length === 0) {
-    return null;
-  }
-  const packageResults = [];
-  for (const pkg of packages) {
-    packageResults.push(analyzePackage(pkg, cwd));
-  }
-  const allDeclarations = packageResults.flatMap((p) => p.declarations);
-  const summary = calculateCoverage(allDeclarations);
-  const ok = !options.strict || summary.percentage >= minCoverage;
-  return {
-    ok,
-    packages: packageResults,
-    summary
-  };
-}
-function printCheckTsdocHuman(result, options) {
-  process.stdout.write(`
-${COLORS.bold}TSDoc Coverage Report${COLORS.reset}
-
-`);
-  for (const pkg of result.packages) {
-    const color = pkg.percentage >= 80 ? COLORS.green : pkg.percentage >= 50 ? COLORS.yellow : COLORS.red;
-    process.stdout.write(`  ${color}${pkg.percentage.toString().padStart(3)}%${COLORS.reset} ${bar(pkg.percentage)} ${pkg.name}
-`);
-    if (pkg.total > 0) {
-      const parts = [];
-      if (pkg.documented > 0)
-        parts.push(`${COLORS.green}${pkg.documented} documented${COLORS.reset}`);
-      if (pkg.partial > 0)
-        parts.push(`${COLORS.yellow}${pkg.partial} partial${COLORS.reset}`);
-      if (pkg.undocumented > 0)
-        parts.push(`${COLORS.red}${pkg.undocumented} undocumented${COLORS.reset}`);
-      process.stdout.write(`       ${COLORS.dim}${pkg.total} declarations:${COLORS.reset} ${parts.join(", ")}
-`);
-    } else {
-      process.stdout.write(`       ${COLORS.dim}no exported declarations${COLORS.reset}
-`);
-    }
-  }
-  const { summary } = result;
-  process.stdout.write(`
-  ${COLORS.bold}Summary:${COLORS.reset} ${summary.percentage}% coverage (${summary.documented} documented, ${summary.partial} partial, ${summary.undocumented} undocumented of ${summary.total} total)
-`);
-  const minCoverage = options?.minCoverage ?? 0;
-  if (options?.strict && summary.percentage < minCoverage) {
-    process.stderr.write(`
-  ${COLORS.red}Coverage ${summary.percentage}% is below minimum threshold of ${minCoverage}%${COLORS.reset}
-`);
-  }
-  process.stdout.write(`
-`);
-}
-async function runCheckTsdoc(options = {}) {
-  const result = analyzeCheckTsdoc(options);
-  if (!result) {
-    process.stderr.write(`No packages found with src/index.ts entry points.
-` + `Searched: packages/*/src/index.ts, apps/*/src/index.ts, src/index.ts
-` + `Use --package <path> to specify a package path explicitly.
-`);
-    process.exit(1);
-  }
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
-  } else {
-    printCheckTsdocHuman(result, {
-      strict: options.strict,
-      minCoverage: options.minCoverage
-    });
-  }
-  process.exit(result.ok ? 0 : 1);
-}
-
-export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };

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

@@ -1,100 +0,0 @@
-// @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-sjm8nebx.d.ts

@@ -1,109 +0,0 @@
-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-t17gnh9b.js

@@ -1,78 +0,0 @@
-// @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 };