@outfitter/tooling 0.3.3 → 0.3.5

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

@@ -0,0 +1,10 @@
+import { CheckTsDocOptions } from "./tooling-tj9p41vj.js";
+/**
+* Run check-tsdoc across workspace packages.
+*
+* Discovers packages with `src/index.ts` entry points, analyzes TSDoc
+* coverage on exported declarations, and reports per-package statistics.
+* Calls `process.exit()` on completion.
+*/
+declare function runCheckTsdoc(options?: CheckTsDocOptions): Promise<void>;
+export { runCheckTsdoc };

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

@@ -0,0 +1,214 @@
+// @bun
+// packages/tooling/src/cli/check-markdown-links.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+var MD_LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+var SKIP_PROTOCOLS = /^(https?:\/\/|mailto:|data:|tel:)/;
+var FENCE_RE = /^(\s*)((`{3,})|~{3,})(.*)$/;
+function stripInlineCodeSpans(line) {
+  let result = "";
+  let index = 0;
+  while (index < line.length) {
+    if (line[index] !== "`") {
+      result += line[index];
+      index += 1;
+      continue;
+    }
+    let tickCount = 1;
+    while (line[index + tickCount] === "`") {
+      tickCount += 1;
+    }
+    const opener = line.slice(index, index + tickCount);
+    index += tickCount;
+    let closingIndex = -1;
+    let cursor = index;
+    while (cursor < line.length) {
+      if (line[cursor] !== "`") {
+        cursor += 1;
+        continue;
+      }
+      let runLength = 1;
+      while (line[cursor + runLength] === "`") {
+        runLength += 1;
+      }
+      if (runLength === tickCount) {
+        closingIndex = cursor;
+        break;
+      }
+      cursor += runLength;
+    }
+    if (closingIndex === -1) {
+      result += opener;
+      continue;
+    }
+    index = closingIndex + tickCount;
+  }
+  return result;
+}
+function extractMarkdownLinks(content) {
+  const lines = content.split(`
+`);
+  const links = [];
+  let inCodeFence = false;
+  let fenceChar = "";
+  let fenceCount = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const fenceMatch = FENCE_RE.exec(trimmed);
+    if (fenceMatch) {
+      const marker = fenceMatch[2] ?? "";
+      const char = marker[0] ?? "`";
+      const count = marker.length;
+      if (!inCodeFence) {
+        inCodeFence = true;
+        fenceChar = char;
+        fenceCount = count;
+        continue;
+      }
+      if (char === fenceChar && count >= fenceCount && !(fenceMatch[4] ?? "").trim()) {
+        inCodeFence = false;
+        continue;
+      }
+    }
+    if (inCodeFence)
+      continue;
+    const stripped = stripInlineCodeSpans(line);
+    for (const match of stripped.matchAll(MD_LINK_RE)) {
+      let target = match[2];
+      if (SKIP_PROTOCOLS.test(target))
+        continue;
+      if (target.startsWith("#"))
+        continue;
+      const hashIndex = target.indexOf("#");
+      if (hashIndex !== -1) {
+        target = target.substring(0, hashIndex);
+      }
+      if (target === "")
+        continue;
+      links.push({ target, line: i + 1 });
+    }
+  }
+  return links;
+}
+async function validateLinks(rootDir, files) {
+  const broken = [];
+  for (const file of files) {
+    const absolutePath = resolve(rootDir, file);
+    const content = await Bun.file(absolutePath).text();
+    const links = extractMarkdownLinks(content);
+    const fileDir = dirname(absolutePath);
+    for (const link of links) {
+      if (link.target.startsWith("docs/packages/") || link.target.startsWith("./docs/packages/") || link.target.startsWith("../docs/packages/")) {
+        continue;
+      }
+      const resolvedTarget = resolve(fileDir, link.target);
+      const relativeFromRoot = resolvedTarget.substring(rootDir.length + 1);
+      if (relativeFromRoot.startsWith("docs/packages/")) {
+        continue;
+      }
+      if (!existsSync(resolvedTarget)) {
+        broken.push({
+          source: file,
+          target: link.target,
+          line: link.line
+        });
+      }
+    }
+  }
+  return broken;
+}
+var DEFAULT_PATTERNS = [
+  "docs/**/*.md",
+  "packages/*/README.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "README.md",
+  ".claude/CLAUDE.md"
+];
+async function discoverFiles(rootDir, patterns) {
+  const files = new Set;
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const match of glob.scan({ cwd: rootDir, absolute: false })) {
+      files.add(match);
+    }
+  }
+  return [...files].toSorted();
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m"
+};
+async function runCheckMarkdownLinks(rootDir, patterns) {
+  const effectivePatterns = patterns ?? DEFAULT_PATTERNS;
+  const files = await discoverFiles(rootDir, effectivePatterns);
+  if (files.length === 0) {
+    process.stdout.write(`No markdown files found.
+`);
+    return 0;
+  }
+  const broken = await validateLinks(rootDir, files);
+  if (broken.length === 0) {
+    process.stdout.write(`${COLORS.green}All links valid across ${files.length} markdown file(s).${COLORS.reset}
+`);
+    return 0;
+  }
+  const bySource = new Map;
+  for (const link of broken) {
+    const existing = bySource.get(link.source);
+    if (existing) {
+      existing.push(link);
+    } else {
+      bySource.set(link.source, [link]);
+    }
+  }
+  process.stderr.write(`${COLORS.red}Found ${broken.length} broken link(s):${COLORS.reset}
+
+`);
+  for (const [source, links] of bySource) {
+    process.stderr.write(`  ${COLORS.yellow}${source}${COLORS.reset}
+`);
+    for (const link of links) {
+      process.stderr.write(`    ${COLORS.cyan}${link.line}${COLORS.reset}  ${COLORS.dim}${link.target}${COLORS.reset}
+`);
+    }
+    process.stderr.write(`
+`);
+  }
+  return 1;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(`Usage: check-markdown-links [dirs/patterns...]
+
+Validates that relative links in markdown files resolve to existing files.
+
+Arguments:
+  dirs/patterns  Glob patterns to scan (defaults: docs/, packages/*/README.md, etc.)
+
+Options:
+  --help  Show this help message
+
+Exit codes:
+  0  All links valid
+  1  Broken links found
+`);
+    process.exitCode = 0;
+    return;
+  }
+  const cwd = process.cwd();
+  const patterns = args.length > 0 ? args.filter((a) => !a.startsWith("--")) : undefined;
+  const exitCode = await runCheckMarkdownLinks(cwd, patterns);
+  process.exitCode = exitCode;
+}
+if (import.meta.main) {
+  main();
+}
+
+export { extractMarkdownLinks, validateLinks, runCheckMarkdownLinks };

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

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

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

@@ -0,0 +1,23 @@
+// @bun
+// packages/tooling/src/bun-version-compat.ts
+function parseSemver(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match?.[1] || !match[2] || !match[3]) {
+    return;
+  }
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10)
+  };
+}
+function isTypesBunVersionCompatible(bunVersion, bunTypesVersion) {
+  const parsedBun = parseSemver(bunVersion);
+  const parsedTypes = parseSemver(bunTypesVersion);
+  if (!parsedBun || !parsedTypes) {
+    return bunVersion === bunTypesVersion;
+  }
+  return parsedBun.major === parsedTypes.major && parsedBun.minor === parsedTypes.minor && parsedTypes.patch <= parsedBun.patch;
+}
+
+export { parseSemver, isTypesBunVersionCompatible };

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

@@ -0,0 +1,285 @@
+// @bun
+// packages/tooling/src/cli/check-changeset.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function toWorkspacePackageName(packageName) {
+  return packageName.startsWith("@outfitter/") ? packageName : `@outfitter/${packageName}`;
+}
+function getReleasableChangedPackages(changedPackages, ignoredPackages) {
+  const ignored = new Set(ignoredPackages.map(toWorkspacePackageName));
+  return changedPackages.filter((packageName) => !ignored.has(toWorkspacePackageName(packageName)));
+}
+function getChangedPackagePaths(files) {
+  const packageNames = new Set;
+  const pattern = /^packages\/([^/]+)\/src\/(.+)$/;
+  for (const file of files) {
+    const match = pattern.exec(file);
+    if (match?.[1] && match[2] && isReleaseRelevantSourcePath(match[2])) {
+      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(releasablePackages, changesetFiles, coveredPackages = []) {
+  if (releasablePackages.length === 0) {
+    return { ok: true, missingFor: [] };
+  }
+  if (changesetFiles.length === 0) {
+    return { ok: false, missingFor: releasablePackages };
+  }
+  const covered = new Set(coveredPackages);
+  const missingFor = releasablePackages.filter((packageName) => !covered.has(toWorkspacePackageName(packageName)));
+  return missingFor.length === 0 ? { ok: true, missingFor: [] } : { ok: false, missingFor };
+}
+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 isReleaseRelevantSourcePath(relativePath) {
+  if (/(^|\/)__tests__\//.test(relativePath)) {
+    return false;
+  }
+  if (/(^|\/)__snapshots__\//.test(relativePath)) {
+    return false;
+  }
+  if (/\.(test|spec)\.[^/]+$/.test(relativePath)) {
+    return false;
+  }
+  return true;
+}
+function getDefaultGitDiffRange() {
+  return {
+    base: "origin/main",
+    head: "HEAD",
+    label: "origin/main...HEAD",
+    source: "default"
+  };
+}
+function resolveGitDiffRange(input) {
+  if (input.eventName !== "pull_request" || !input.eventPath) {
+    return getDefaultGitDiffRange();
+  }
+  const readEventFile = input.readEventFile ?? ((path) => readFileSync(path, "utf-8"));
+  try {
+    const payload = JSON.parse(readEventFile(input.eventPath));
+    const baseRef = payload.pull_request?.base?.ref;
+    const baseSha = payload.pull_request?.base?.sha;
+    const headRef = payload.pull_request?.head?.ref;
+    const headSha = payload.pull_request?.head?.sha;
+    if (!baseSha || !headSha) {
+      return getDefaultGitDiffRange();
+    }
+    return {
+      base: baseSha,
+      head: headSha,
+      label: `${baseRef ?? "base"} (${baseSha})...${headRef ?? "head"} (${headSha})`,
+      source: "pull_request"
+    };
+  } catch {
+    return getDefaultGitDiffRange();
+  }
+}
+function analyzeChangesetReferences(referencedPackages, ignored) {
+  const coveredPackages = referencedPackages.filter((packageName) => !ignored.has(packageName));
+  const ignoredReferences = referencedPackages.filter((packageName) => ignored.has(packageName));
+  return {
+    coveredPackages: coveredPackages.toSorted(),
+    ignoredReferences: ignoredReferences.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 = analyzeChangesetReferences(referencedPackages, ignored).ignoredReferences;
+    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 analyzeChangedChangesets(cwd, changesetFiles, ignoredPackages) {
+  const covered = new Set;
+  const ignored = new Set(ignoredPackages);
+  const ignoredReferences = [];
+  for (const filename of changesetFiles) {
+    try {
+      const content = readFileSync(join(cwd, ".changeset", filename), "utf-8");
+      const referencedPackages = parseChangesetFrontmatterPackageNames(content);
+      const analysis = analyzeChangesetReferences(referencedPackages, ignored);
+      for (const packageName of analysis.coveredPackages) {
+        covered.add(packageName);
+      }
+      if (analysis.ignoredReferences.length > 0) {
+        ignoredReferences.push({
+          file: filename,
+          packages: analysis.ignoredReferences
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    coveredPackages: [...covered].toSorted(),
+    ignoredReferences: ignoredReferences.toSorted((a, b) => a.file.localeCompare(b.file))
+  };
+}
+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();
+  const diffRange = resolveGitDiffRange({
+    eventName: process.env["GITHUB_EVENT_NAME"],
+    eventPath: process.env["GITHUB_EVENT_PATH"],
+    readEventFile: (path) => readFileSync(path, "utf-8")
+  });
+  let changedFiles;
+  try {
+    const proc = Bun.spawnSync(["git", "diff", "--name-only", `${diffRange.base}...${diffRange.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;
+  }
+  if (process.env["GITHUB_EVENT_NAME"]) {
+    process.stdout.write(`${COLORS.dim}check-changeset diff basis: ${diffRange.label}${COLORS.reset}
+`);
+  }
+  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 ignoredPackages = loadIgnoredPackages(cwd);
+  const releasablePackages = getReleasableChangedPackages(changedPackages, ignoredPackages);
+  const changesetAnalysis = analyzeChangedChangesets(cwd, changesetFiles, ignoredPackages);
+  const check = checkChangesetRequired(releasablePackages, changesetFiles, changesetAnalysis.coveredPackages);
+  const ignoredReferences = changesetAnalysis.ignoredReferences;
+  let hasErrors = false;
+  if (!check.ok) {
+    process.stderr.write(`${COLORS.red}Changeset coverage missing.${COLORS.reset} ` + `Every changed releasable package must be mentioned in at least one current PR changeset.
+
+`);
+    process.stderr.write(`Packages missing changeset coverage:
+
+`);
+    for (const pkg of check.missingFor) {
+      process.stderr.write(`  ${COLORS.yellow}${toWorkspacePackageName(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.
+`);
+    hasErrors = true;
+  }
+  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.
+`);
+    hasErrors = true;
+  }
+  if (hasErrors) {
+    process.exitCode = 1;
+    return;
+  }
+  if (releasablePackages.length === 0) {
+    process.stdout.write(`${COLORS.green}Only ignored package source changes detected.${COLORS.reset}
+`);
+  } else {
+    process.stdout.write(`${COLORS.green}Changesets cover ${releasablePackages.length} changed package(s).${COLORS.reset}
+`);
+  }
+  process.exitCode = 0;
+}
+
+export { getReleasableChangedPackages, getChangedPackagePaths, getChangedChangesetFiles, checkChangesetRequired, parseIgnoredPackagesFromChangesetConfig, parseChangesetFrontmatterPackageNames, resolveGitDiffRange, findIgnoredPackageReferences, runCheckChangeset };