@outfitter/tooling 0.3.4 → 0.3.5

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-d363b88r.js → tooling-c8q6mj8z.js}

@@ -2,23 +2,12 @@
 import {
   analyzeSourceFile,
   calculateCoverage
-} from "./tooling-875svjnz.js";
+} from "./tooling-5xxctk9b.js";
 
-// packages/tooling/src/cli/pre-push.ts
+// packages/tooling/src/cli/internal/pre-push-checks.ts
 import { existsSync, readFileSync } from "fs";
 import { join, resolve } from "path";
 import ts from "typescript";
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m"
-};
-function log(msg) {
-  process.stdout.write(`${msg}
-`);
-}
 function getCurrentBranch() {
   const result = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
   return result.stdout.toString().trim();
@@ -70,28 +59,6 @@ function hasPackageSourceChanges(changedFiles) {
   const packageSrcPattern = /^packages\/[^/]+\/src\//;
   return changedFiles.files.some((f) => packageSrcPattern.test(f));
 }
-async function printTsdocSummary() {
-  const glob = new Bun.Glob("packages/*/src/index.ts");
-  const cwd = process.cwd();
-  const allDeclarations = [];
-  for (const entry of glob.scanSync({ cwd })) {
-    const filePath = resolve(cwd, entry);
-    const content = await Bun.file(filePath).text();
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-    allDeclarations.push(...analyzeSourceFile(sourceFile));
-  }
-  if (allDeclarations.length === 0)
-    return;
-  const coverage = calculateCoverage(allDeclarations);
-  const parts = [];
-  if (coverage.documented > 0)
-    parts.push(`${coverage.documented} documented`);
-  if (coverage.partial > 0)
-    parts.push(`${coverage.partial} partial`);
-  if (coverage.undocumented > 0)
-    parts.push(`${coverage.undocumented} undocumented`);
-  log(`${COLORS.blue}TSDoc${COLORS.reset}: ${coverage.percentage}% coverage (${parts.join(", ")} of ${coverage.total} total)`);
-}
 function resolveBaseRef() {
   const candidates = [
     "origin/main",
@@ -150,35 +117,6 @@ function getChangedFilesForPush() {
     source: "undetermined"
   };
 }
-function maybeSkipForRedPhase(reason, branch) {
-  const changedFiles = getChangedFilesForPush();
-  if (!changedFiles.deterministic) {
-    log(`${COLORS.yellow}RED-phase bypass denied${COLORS.reset}: could not determine full push diff range`);
-    log("Running strict verification.");
-    log("");
-    return false;
-  }
-  if (!canBypassRedPhaseByChangedFiles(changedFiles)) {
-    log(`${COLORS.yellow}RED-phase bypass denied${COLORS.reset}: changed files are not test-only`);
-    if (changedFiles.files.length > 0) {
-      log(`Changed files (${changedFiles.source}): ${changedFiles.files.join(", ")}`);
-    } else {
-      log(`No changed files detected in ${changedFiles.source} range. Running strict verification.`);
-    }
-    log("");
-    return false;
-  }
-  if (reason === "branch") {
-    log(`${COLORS.yellow}TDD RED phase${COLORS.reset} detected: ${COLORS.blue}${branch}${COLORS.reset}`);
-  } else {
-    log(`${COLORS.yellow}Scaffold branch${COLORS.reset} with RED phase branch in context: ${COLORS.blue}${branch}${COLORS.reset}`);
-  }
-  log(`${COLORS.yellow}Skipping strict verification${COLORS.reset} - changed files are test-only`);
-  log(`Diff source: ${changedFiles.source}`);
-  log("");
-  log("Remember: GREEN phase (implementation) must make these tests pass!");
-  return true;
-}
 function hasRedPhaseBranchInContext(currentBranch) {
   let branches = [];
   try {
@@ -209,6 +147,9 @@ function hasRedPhaseBranchInContext(currentBranch) {
   return false;
 }
 function createVerificationPlan(scripts) {
+  if (scripts["verify:push"]) {
+    return { ok: true, scripts: ["verify:push"], source: "verify:push" };
+  }
   if (scripts["verify:ci"]) {
     return { ok: true, scripts: ["verify:ci"], source: "verify:ci" };
   }
@@ -247,14 +188,6 @@ function readPackageScripts(cwd = process.cwd()) {
     return {};
   }
 }
-function runScript(scriptName) {
-  log("");
-  log(`Running: ${COLORS.blue}bun run ${scriptName}${COLORS.reset}`);
-  const result = Bun.spawnSync(["bun", "run", scriptName], {
-    stdio: ["inherit", "inherit", "inherit"]
-  });
-  return result.exitCode === 0;
-}
 function checkBunVersion(projectRoot = process.cwd()) {
   const versionFile = join(projectRoot, ".bun-version");
   if (!existsSync(versionFile)) {
@@ -267,83 +200,29 @@ function checkBunVersion(projectRoot = process.cwd()) {
   }
   return { matches: false, expected, actual };
 }
-async function runPrePush(options = {}) {
-  log(`${COLORS.blue}Pre-push verify${COLORS.reset} (TDD-aware)`);
-  log("");
-  if (options.force) {
-    log(`${COLORS.yellow}Force flag set${COLORS.reset} - skipping strict verification`);
-    process.exitCode = 0;
-    return;
-  }
-  const versionCheck = checkBunVersion();
-  if (!versionCheck.matches) {
-    log(`${COLORS.red}Bun version mismatch${COLORS.reset}: running ${versionCheck.actual}, pinned ${versionCheck.expected}`);
-    log("Fix: bunx @outfitter/tooling upgrade-bun");
-    log("");
-    process.exitCode = 1;
-    return;
-  }
-  const branch = getCurrentBranch();
-  if (isReleaseBranch(branch)) {
-    log(`${COLORS.yellow}Release branch detected${COLORS.reset}: ${COLORS.blue}${branch}${COLORS.reset}`);
-    log(`${COLORS.yellow}Skipping strict verification${COLORS.reset} for automated changeset release push`);
-    process.exitCode = 0;
-    return;
-  }
-  if (isRedPhaseBranch(branch)) {
-    if (maybeSkipForRedPhase("branch", branch)) {
-      process.exitCode = 0;
-      return;
-    }
-  }
-  if (isScaffoldBranch(branch)) {
-    if (hasRedPhaseBranchInContext(branch)) {
-      if (maybeSkipForRedPhase("context", branch)) {
-        process.exitCode = 0;
-        return;
-      }
-    }
-  }
-  const plan = createVerificationPlan(readPackageScripts());
-  if (!plan.ok) {
-    log(`${COLORS.red}Strict pre-push verification is not configured${COLORS.reset}`);
-    log(plan.error);
-    log("");
-    log("Add one of:");
-    log("  - verify:ci");
-    log("  - typecheck + (check or lint) + build + test");
-    process.exitCode = 1;
-    return;
-  }
-  log(`Running strict verification for branch: ${COLORS.blue}${branch}${COLORS.reset}`);
-  if (plan.source === "verify:ci") {
-    log("Using `verify:ci` script.");
-  } else {
-    log(`Using fallback scripts: ${plan.scripts.join(" -> ")}`);
+async function printTsdocSummary(log) {
+  const glob = new Bun.Glob("packages/*/src/index.ts");
+  const cwd = process.cwd();
+  const allDeclarations = [];
+  for (const entry of glob.scanSync({ cwd })) {
+    const filePath = resolve(cwd, entry);
+    const content = await Bun.file(filePath).text();
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    allDeclarations.push(...analyzeSourceFile(sourceFile));
   }
-  for (const scriptName of plan.scripts) {
-    if (runScript(scriptName)) {
-      continue;
-    }
-    log("");
-    log(`${COLORS.red}Verification failed${COLORS.reset} on script: ${scriptName}`);
-    log("");
-    log("If this is intentional TDD RED phase work, name your branch:");
-    log("  - feature-tests");
-    log("  - feature/tests");
-    log("  - feature_tests");
-    process.exitCode = 1;
+  if (allDeclarations.length === 0)
     return;
-  }
-  const changedFiles = getChangedFilesForPush();
-  if (hasPackageSourceChanges(changedFiles)) {
-    try {
-      await printTsdocSummary();
-    } catch {}
-  }
-  log("");
-  log(`${COLORS.green}Strict verification passed${COLORS.reset}`);
-  process.exitCode = 0;
+  const coverage = calculateCoverage(allDeclarations);
+  const parts = [];
+  if (coverage.documented > 0)
+    parts.push(`${coverage.documented} documented`);
+  if (coverage.partial > 0)
+    parts.push(`${coverage.partial} partial`);
+  if (coverage.undocumented > 0)
+    parts.push(`${coverage.undocumented} undocumented`);
+  const BLUE = "\x1B[34m";
+  const RESET = "\x1B[0m";
+  log(`${BLUE}TSDoc${RESET}: ${coverage.percentage}% coverage (${parts.join(", ")} of ${coverage.total} total)`);
 }
 
-export { isRedPhaseBranch, isScaffoldBranch, isReleaseBranch, isTestOnlyPath, areFilesTestOnly, canBypassRedPhaseByChangedFiles, hasPackageSourceChanges, createVerificationPlan, checkBunVersion, runPrePush };
+export { getCurrentBranch, runGit, isRedPhaseBranch, isScaffoldBranch, isReleaseBranch, isTestOnlyPath, areFilesTestOnly, canBypassRedPhaseByChangedFiles, hasPackageSourceChanges, getChangedFilesForPush, hasRedPhaseBranchInContext, createVerificationPlan, readPackageScripts, checkBunVersion, printTsdocSummary };

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

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

@@ -0,0 +1,139 @@
+// @bun
+// packages/tooling/src/cli/check-home-paths.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { resolve } from "path";
+function formatLeakLineText(lineText) {
+  return lineText.trimEnd();
+}
+function writeLeakSummary(stderr, leaks) {
+  stderr.write(`Hardcoded home directory paths detected:
+`);
+  for (const leak of leaks) {
+    stderr.write(`  ${leak.filePath}:${leak.line}:${leak.column} ${formatLeakLineText(leak.lineText)}
+`);
+  }
+}
+function writeReplacementHint(stderr, leaks) {
+  const matchedText = leaks[0]?.matchedText;
+  if (!matchedText) {
+    return;
+  }
+  stderr.write(`
+Replace ${JSON.stringify(matchedText)} with a repo-relative or home-agnostic path before committing.
+`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildHomePathPattern(homePath) {
+  if (homePath.trim().length === 0) {
+    return;
+  }
+  const patternSource = homePath.split(/(\\+)/).map((segment) => segment.includes("\\") ? "\\\\+" : escapeRegExp(segment)).join("");
+  return new RegExp(`${patternSource}(?![\\w.-])`, "g");
+}
+function findHomePathLeaks(content, homePathOrPattern) {
+  let pattern;
+  if (homePathOrPattern instanceof RegExp) {
+    if (!homePathOrPattern.flags.includes("g")) {
+      throw new TypeError("findHomePathLeaks: RegExp must have the global (g) flag set");
+    }
+    pattern = homePathOrPattern;
+  } else {
+    pattern = buildHomePathPattern(homePathOrPattern);
+  }
+  if (!pattern) {
+    return [];
+  }
+  const leaks = [];
+  const lines = content.split(/\r?\n/);
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    for (const match of line.matchAll(pattern)) {
+      leaks.push({
+        line: index + 1,
+        column: (match.index ?? 0) + 1,
+        matchedText: match[0],
+        lineText: line
+      });
+    }
+  }
+  return leaks;
+}
+function scanFilesForHardcodedHomePaths(filePaths, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const homePath = options.homeDir ?? homedir();
+  const readFile = options.readFile ?? readFileSync;
+  const leaks = [];
+  const failures = [];
+  const pattern = buildHomePathPattern(homePath);
+  if (!pattern) {
+    return { leaks, failures };
+  }
+  for (const filePath of filePaths) {
+    const absolutePath = resolve(cwd, filePath);
+    let fileContent;
+    try {
+      fileContent = readFile(absolutePath, "utf-8");
+    } catch (error) {
+      const errno = error;
+      if (errno.code === "ENOENT") {
+        continue;
+      }
+      failures.push({
+        filePath,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    const fileLeaks = findHomePathLeaks(fileContent, pattern);
+    for (const leak of fileLeaks) {
+      leaks.push({
+        filePath,
+        ...leak
+      });
+    }
+  }
+  return { leaks, failures };
+}
+function runCheckHomePaths(paths, options = {}) {
+  const stderr = options.stderr ?? process.stderr;
+  const setExitCode = options.setExitCode ?? ((code) => {
+    process.exitCode = code;
+  });
+  const { failures, leaks } = scanFilesForHardcodedHomePaths(paths, options.scanOptions);
+  if (failures.length > 0) {
+    const unreadableTarget = failures.length === 1 ? "file" : "files";
+    stderr.write(`Unreadable ${unreadableTarget} while scanning for hardcoded home paths:
+`);
+    for (const failure of failures) {
+      stderr.write(`  ${failure.filePath}: ${failure.reason}
+`);
+    }
+    if (leaks.length > 0) {
+      stderr.write(`
+`);
+      writeLeakSummary(stderr, leaks);
+      writeReplacementHint(stderr, leaks);
+      stderr.write(`
+`);
+    } else {
+      stderr.write(`
+`);
+    }
+    stderr.write(`Fix file permissions or remove the unreadable ${unreadableTarget} before committing.
+`);
+    setExitCode(1);
+    return;
+  }
+  if (leaks.length === 0) {
+    setExitCode(0);
+    return;
+  }
+  writeLeakSummary(stderr, leaks);
+  writeReplacementHint(stderr, leaks);
+  setExitCode(1);
+}
+
+export { findHomePathLeaks, scanFilesForHardcodedHomePaths, runCheckHomePaths };

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