@outfitter/tooling 0.3.4 → 0.3.6-canary-20260317141105

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-875svjnz.js → tooling-5xxctk9b.js}

@@ -3,44 +3,9 @@ import {
   __require
 } from "./tooling-jnrs9rqd.js";
 
-// packages/tooling/src/cli/check-tsdoc.ts
+// packages/tooling/src/cli/internal/tsdoc-analysis.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;
@@ -159,24 +124,6 @@ function calculateCoverage(declarations) {
   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;
@@ -344,63 +291,5 @@ function analyzeCheckTsdoc(options = {}) {
     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.exitCode = 1;
-    return;
-  }
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
-  } else {
-    printCheckTsdocHuman(result, {
-      strict: options.strict,
-      minCoverage: options.minCoverage
-    });
-  }
-  process.exitCode = result.ok ? 0 : 1;
-}
 
-export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };
+export { isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, discoverPackages, collectReExportedSourceFiles, analyzePackage, analyzeCheckTsdoc };

package/dist/shared/@outfitter/tooling-5ynz680q.js

@@ -0,0 +1,59 @@
+// @bun
+// packages/tooling/src/cli/internal/tsdoc-formatting.ts
+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 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(`
+`);
+}
+
+export { resolveJsonMode, printCheckTsdocHuman };

package/dist/shared/@outfitter/tooling-7437rmy6.js

@@ -0,0 +1,39 @@
+// @bun
+// packages/tooling/src/cli/internal/tsdoc-types.ts
+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
+});
+
+export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema };

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

@@ -0,0 +1,32 @@
+// @bun
+import {
+  printCheckTsdocHuman,
+  resolveJsonMode
+} from "./tooling-5ynz680q.js";
+import {
+  analyzeCheckTsdoc
+} from "./tooling-5xxctk9b.js";
+// packages/tooling/src/cli/check-tsdoc.ts
+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.exitCode = 1;
+    return;
+  }
+  if (resolveJsonMode(options)) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    printCheckTsdocHuman(result, {
+      strict: options.strict,
+      minCoverage: options.minCoverage
+    });
+  }
+  process.exitCode = result.ok ? 0 : 1;
+}
+
+export { runCheckTsdoc };

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

@@ -0,0 +1,86 @@
+// @bun
+import {
+  entryToSubpath
+} from "./tooling-ayps7c4x.js";
+
+// packages/tooling/src/cli/internal/exports-fs.ts
+function matchesExclude(subpath, excludes) {
+  return excludes.some((pattern) => new Bun.Glob(pattern).match(subpath));
+}
+var CLI_EXCLUSION_PATTERNS = [
+  "**/cli.ts",
+  "**/cli/index.ts",
+  "**/bin.ts",
+  "**/bin/index.ts"
+];
+function isCliEntrypoint(entry) {
+  return CLI_EXCLUSION_PATTERNS.some((pattern) => new Bun.Glob(pattern).match(entry));
+}
+function buildExportValue(entry) {
+  const distPath = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
+  return {
+    import: {
+      types: `./dist/${distPath}.d.ts`,
+      default: `./dist/${distPath}.js`
+    }
+  };
+}
+function discoverEntries(packageRoot) {
+  const glob = new Bun.Glob("src/**/*.ts");
+  const entries = [];
+  for (const match of glob.scanSync({ cwd: packageRoot, dot: false })) {
+    if (match.includes("__tests__") || match.endsWith(".test.ts")) {
+      continue;
+    }
+    entries.push(match);
+  }
+  return entries.toSorted();
+}
+function addConfigFileExports(expected, pkg) {
+  const CONFIG_RE = /\.(json|jsonc|yml|yaml|toml)$/;
+  const configFiles = (pkg.files ?? []).filter((file) => CONFIG_RE.test(file) && file !== "package.json");
+  for (const file of configFiles) {
+    expected[`./${file}`] = `./${file}`;
+    let base = file.replace(CONFIG_RE, "");
+    const match = base.match(/^(.+)\.preset(?:\.(.+))?$/);
+    if (match?.[1]) {
+      base = match[2] ? `${match[1]}-${match[2]}` : match[1];
+    }
+    if (base !== file) {
+      expected[`./${base}`] = `./${file}`;
+    }
+  }
+}
+function computeExpectedExports(packageRoot, workspace, pkg) {
+  const entries = discoverEntries(packageRoot);
+  const exportsConfig = typeof workspace.config?.exports === "object" ? workspace.config.exports : undefined;
+  const excludes = exportsConfig?.exclude ?? [];
+  const customExports = exportsConfig?.customExports ?? {};
+  const expected = {};
+  const subpathEntries = new Map;
+  for (const entry of entries) {
+    if (isCliEntrypoint(entry))
+      continue;
+    const subpath = entryToSubpath(entry);
+    if (matchesExclude(subpath, excludes))
+      continue;
+    const existing = subpathEntries.get(subpath);
+    if (existing) {
+      if (!existing.endsWith("/index.ts") && entry.endsWith("/index.ts")) {
+        continue;
+      }
+    }
+    subpathEntries.set(subpath, entry);
+  }
+  for (const [subpath, entry] of subpathEntries) {
+    expected[subpath] = buildExportValue(entry);
+  }
+  for (const [key, value] of Object.entries(customExports)) {
+    expected[`./${key.replace(/^\.\//, "")}`] = value;
+  }
+  addConfigFileExports(expected, pkg);
+  expected["./package.json"] = "./package.json";
+  return expected;
+}
+
+export { computeExpectedExports };

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

@@ -0,0 +1,58 @@
+// @bun
+// packages/tooling/src/cli/internal/exports-analysis.ts
+function entryToSubpath(entry) {
+  const stripped = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
+  if (stripped === "index") {
+    return ".";
+  }
+  if (stripped.endsWith("/index")) {
+    return `./${stripped.slice(0, -"/index".length)}`;
+  }
+  return `./${stripped}`;
+}
+function compareExports(input) {
+  const { name, actual, expected, path } = input;
+  const actualKeys = new Set(Object.keys(actual));
+  const expectedKeys = new Set(Object.keys(expected));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const key of expectedKeys) {
+    if (!actualKeys.has(key)) {
+      added.push(key);
+    }
+  }
+  for (const key of actualKeys) {
+    if (!expectedKeys.has(key)) {
+      removed.push(key);
+    }
+  }
+  for (const key of actualKeys) {
+    if (expectedKeys.has(key)) {
+      const actualValue = actual[key];
+      const expectedValue = expected[key];
+      if (JSON.stringify(actualValue) !== JSON.stringify(expectedValue)) {
+        changed.push({ key, expected: expectedValue, actual: actualValue });
+      }
+    }
+  }
+  added.sort();
+  removed.sort();
+  changed.sort((a, b) => a.key.localeCompare(b.key));
+  if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+    return { name, status: "ok" };
+  }
+  return {
+    name,
+    status: "drift",
+    drift: {
+      package: name,
+      path: path ?? "",
+      added,
+      removed,
+      changed
+    }
+  };
+}
+
+export { entryToSubpath, compareExports };

package/dist/shared/@outfitter/{tooling-wesswf21.d.ts → tooling-cb0b8wsx.d.ts}

@@ -1,3 +1,11 @@
+/**
+* Pure analysis functions for comparing maps.
+*
+* Types and stateless comparison logic used by the check-exports command.
+* No filesystem access — all inputs are passed as arguments.
+*
+* @packageDocumentation
+*/
 /** 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 */
@@ -46,14 +54,4 @@ declare function entryToSubpath(entry: string): string;
 * Returns a PackageResult with status "ok" or "drift" and detailed diff.
 */
 declare function compareExports(input: CompareInput): PackageResult;
-interface CheckExportsOptions {
-	readonly json?: boolean;
-}
-declare function resolveJsonMode(options?: CheckExportsOptions): 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, resolveJsonMode, runCheckExports };
+export { ExportMap, ExportDrift, PackageResult, CheckResult, CompareInput, entryToSubpath, compareExports };

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

@@ -0,0 +1,16 @@
+import { CheckTsDocOptions, TsDocCheckResult } from "./tooling-tj9p41vj.js";
+/** Resolve whether JSON output mode is active. */
+declare function resolveJsonMode(options?: CheckTsDocOptions): boolean;
+/**
+* Print a TSDoc coverage result in human-readable format.
+*
+* Renders a bar chart per package with summary statistics. Writes to stdout/stderr.
+*
+* @param result - The coverage result to print
+* @param options - Display options (strict mode, coverage threshold for warning)
+*/
+declare function printCheckTsdocHuman(result: TsDocCheckResult, options?: {
+	strict?: boolean | undefined;
+	minCoverage?: number | undefined;
+}): void;
+export { resolveJsonMode, printCheckTsdocHuman };