@outfitter/tooling 0.2.1 → 0.2.3

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

@@ -0,0 +1,226 @@
+// @bun
+// packages/tooling/src/cli/check-exports.ts
+import { resolve } from "path";
+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
+    }
+  };
+}
+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.sort();
+}
+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;
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m"
+};
+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.exit(1);
+    }
+    workspaces = rawConfig;
+  } catch {
+    process.stderr.write(`Could not load bunup.config.ts from ${cwd}
+`);
+    process.exit(1);
+  }
+  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 (options.json) {
+    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.exit(checkResult.ok ? 0 : 1);
+}
+
+export { entryToSubpath, compareExports, runCheckExports };

package/dist/shared/chunk-3s189drz.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/shared/chunk-6a7tjcgm.js

@@ -0,0 +1,193 @@
+import"./chunk-3s189drz.js";
+
+// src/cli/check-readme-imports.ts
+import { resolve } from "node:path";
+function parseSpecifier(specifier) {
+  if (!specifier.startsWith("@outfitter/")) {
+    return null;
+  }
+  const parts = specifier.split("/");
+  if (parts.length < 2) {
+    return null;
+  }
+  const packageName = `${parts[0]}/${parts[1]}`;
+  const rest = parts.slice(2);
+  if (rest.length === 0) {
+    return { packageName, subpath: "." };
+  }
+  return { packageName, subpath: `./${rest.join("/")}` };
+}
+function extractImports(content, file) {
+  const lines = content.split(`
+`);
+  const results = [];
+  const seen = new Set;
+  const CODE_FENCE_OPEN = /^```(?:typescript|ts|javascript|js)\s*$/;
+  const CODE_FENCE_CLOSE = /^```\s*$/;
+  const IMPORT_RE = /from\s+["'](@outfitter\/[^"']+)["']/;
+  const NON_CONTRACTUAL = /<!--\s*non-contractual\s*-->/;
+  let inCodeBlock = false;
+  let skipBlock = false;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!inCodeBlock) {
+      if (CODE_FENCE_OPEN.test(line)) {
+        inCodeBlock = true;
+        skipBlock = false;
+        for (let j = i - 1;j >= 0; j--) {
+          const prev = lines[j].trim();
+          if (prev === "")
+            continue;
+          if (NON_CONTRACTUAL.test(prev)) {
+            skipBlock = true;
+          }
+          break;
+        }
+      }
+      continue;
+    }
+    if (CODE_FENCE_CLOSE.test(line) && !CODE_FENCE_OPEN.test(line)) {
+      inCodeBlock = false;
+      skipBlock = false;
+      continue;
+    }
+    if (skipBlock)
+      continue;
+    const match = IMPORT_RE.exec(line);
+    if (!match?.[1])
+      continue;
+    const fullSpecifier = match[1];
+    if (seen.has(fullSpecifier))
+      continue;
+    seen.add(fullSpecifier);
+    const parsed = parseSpecifier(fullSpecifier);
+    if (!parsed)
+      continue;
+    results.push({
+      packageName: parsed.packageName,
+      subpath: parsed.subpath,
+      fullSpecifier,
+      file,
+      line: i + 1
+    });
+  }
+  return results;
+}
+function isExportedSubpath(subpath, exports) {
+  return subpath in exports;
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m"
+};
+async function runCheckReadmeImports(options = {}) {
+  const cwd = process.cwd();
+  const readmeGlob = new Bun.Glob("**/README.md");
+  const readmeDirs = ["packages", "docs/packages"];
+  const readmePaths = [];
+  for (const dir of readmeDirs) {
+    const fullDir = resolve(cwd, dir);
+    try {
+      for (const match of readmeGlob.scanSync({ cwd: fullDir, dot: false })) {
+        const segments = match.split("/");
+        if (segments.length === 2 && segments[1] === "README.md") {
+          readmePaths.push(resolve(fullDir, match));
+        }
+      }
+    } catch {}
+  }
+  if (readmePaths.length === 0) {
+    process.stdout.write(`No README.md files found.
+`);
+    return;
+  }
+  const exportsCache = new Map;
+  async function getExportsForPackage(packageName) {
+    if (exportsCache.has(packageName)) {
+      return exportsCache.get(packageName) ?? null;
+    }
+    const shortName = packageName.replace("@outfitter/", "");
+    const pkgPath = resolve(cwd, "packages", shortName, "package.json");
+    try {
+      const pkg = await Bun.file(pkgPath).json();
+      const exports = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
+      exportsCache.set(packageName, exports);
+      return exports;
+    } catch {
+      return null;
+    }
+  }
+  const results = [];
+  let hasInvalid = false;
+  for (const readmePath of readmePaths.sort()) {
+    const content = await Bun.file(readmePath).text();
+    const relativePath = readmePath.replace(`${cwd}/`, "");
+    const imports = extractImports(content, relativePath);
+    if (imports.length === 0)
+      continue;
+    const valid = [];
+    const invalid = [];
+    for (const imp of imports) {
+      const exports = await getExportsForPackage(imp.packageName);
+      if (exports === null) {
+        invalid.push(imp);
+        continue;
+      }
+      if (isExportedSubpath(imp.subpath, exports)) {
+        valid.push(imp);
+      } else {
+        invalid.push(imp);
+      }
+    }
+    if (valid.length > 0 || invalid.length > 0) {
+      results.push({ file: relativePath, valid, invalid });
+    }
+    if (invalid.length > 0) {
+      hasInvalid = true;
+    }
+  }
+  if (options.json) {
+    const output = {
+      ok: !hasInvalid,
+      files: results
+    };
+    process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+  } else {
+    const totalValid = results.reduce((n, r) => n + r.valid.length, 0);
+    const totalInvalid = results.reduce((n, r) => n + r.invalid.length, 0);
+    if (!hasInvalid) {
+      process.stdout.write(`${COLORS.green}All ${totalValid} README import examples match package exports.${COLORS.reset}
+`);
+    } else {
+      process.stderr.write(`${COLORS.red}Invalid README import examples found:${COLORS.reset}
+
+`);
+      for (const result of results) {
+        if (result.invalid.length === 0)
+          continue;
+        process.stderr.write(`  ${COLORS.yellow}${result.file}${COLORS.reset}
+`);
+        for (const imp of result.invalid) {
+          process.stderr.write(`    ${COLORS.red}line ${imp.line}:${COLORS.reset} ${imp.fullSpecifier}  ${COLORS.dim}(subpath ${imp.subpath} not in ${imp.packageName} exports)${COLORS.reset}
+`);
+        }
+        process.stderr.write(`
+`);
+      }
+      process.stderr.write(`${totalInvalid} invalid, ${totalValid} valid across ${results.length} file(s).
+`);
+    }
+  }
+  process.exit(hasInvalid ? 1 : 0);
+}
+export {
+  runCheckReadmeImports,
+  parseSpecifier,
+  isExportedSubpath,
+  extractImports
+};

package/dist/shared/chunk-8aenrm6f.js

@@ -0,0 +1,18 @@
+// 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;
+}
+var VERSION = readPackageVersion();
+
+export { VERSION };

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+import { VERSION } from "./shared/@outfitter/tooling-9vs606gq";
+export { VERSION };

package/dist/version.js

@@ -0,0 +1,8 @@
+// @bun
+import {
+  VERSION
+} from "./shared/@outfitter/tooling-ctmgnap5.js";
+import"./shared/@outfitter/tooling-dvwh9qve.js";
+export {
+  VERSION
+};

package/lefthook.yml

@@ -20,11 +20,9 @@ pre-commit:
 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
+    verify:
+      # TDD-aware: skips strict verification on explicit RED phase branches
+      # (*-tests, */tests, *_tests). Otherwise runs verify:ci (or a strict
+      # fallback: typecheck/check-or-lint/build/test).
+      # Requires: @outfitter/tooling as a dev dependency.
       run: bunx @outfitter/tooling pre-push