@tspub-dev/tspub 0.1.0

package/dist/bin/tspub.js

@@ -0,0 +1,1308 @@
+#!/usr/bin/env node
+import {
+  ALLOW_LIST_PROFILES,
+  PROFILES,
+  allRules,
+  build,
+  check,
+  createHooksFromConfig,
+  debugResolution,
+  discoverWorkspaces,
+  doctor,
+  fileExists,
+  filterPackages,
+  generateMarkdownReport,
+  isMonorepoRoot,
+  loadConfig,
+  loadConfigWithInheritance,
+  logger,
+  parseSeverityOverrides,
+  printGroupedResults,
+  printListRules,
+  printResolutionTable,
+  publishMonorepo,
+  publishPackage,
+  pushWithTags,
+  readPackageJson,
+  runTypeTests,
+  scaffold,
+  scan,
+  topoSort,
+  writePackageJson
+} from "../chunk-TNGZXD6W.js";
+import "../chunk-DGUM43GV.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { createRequire } from "node:module";
+
+// src/scaffold/prompts.ts
+import prompts from "prompts";
+async function promptInit(defaultName) {
+  const answers = await prompts([
+    {
+      type: "text",
+      name: "name",
+      message: "Package name",
+      initial: defaultName ?? "my-package"
+    },
+    {
+      type: "text",
+      name: "description",
+      message: "Description",
+      initial: ""
+    },
+    {
+      type: "text",
+      name: "author",
+      message: "Author",
+      initial: ""
+    },
+    {
+      type: "select",
+      name: "license",
+      message: "License",
+      choices: [
+        { title: "MIT", value: "MIT" },
+        { title: "Apache-2.0", value: "Apache-2.0" },
+        { title: "ISC", value: "ISC" }
+      ],
+      initial: 0
+    },
+    {
+      type: "confirm",
+      name: "dualPublish",
+      message: "Include CJS output (dual publish)?",
+      initial: false
+    },
+    {
+      type: "confirm",
+      name: "react",
+      message: "Add React/JSX support?",
+      initial: false
+    }
+  ]);
+  return answers;
+}
+
+// src/cli/init.ts
+function registerInit(program) {
+  program.command("init [name]").description("Scaffold a new TypeScript package").option("--esm-only", "Skip CJS output (recommended for new packages)", true).option("--cjs", "Include CJS output (dual publishing)").option("--monorepo", "Init inside an existing monorepo").option("--react", "Add JSX support + react peer dep").option("--author <name>", "Author name").option("--description <desc>", "Package description").option("--license <license>", "License (MIT, Apache-2.0, ISC)").option("--no-git", "Skip git init").action(async (name, options) => {
+    let packageName = name ?? "my-package";
+    let dualPublish = options.cjs === true;
+    let react = options.react === true;
+    let { author, description, license } = options;
+    const monorepo = options.monorepo === true;
+    if (!name && process.stdin.isTTY) {
+      try {
+        const answers = await promptInit();
+        packageName = answers.name;
+        dualPublish = answers.dualPublish;
+        react = answers.react;
+        author = answers.author || author;
+        description = answers.description || description;
+        license = answers.license || license;
+      } catch {
+      }
+    }
+    logger.heading(`tspub init \u2014 creating ${packageName}`);
+    try {
+      await scaffold({
+        name: packageName,
+        dualPublish,
+        react,
+        monorepo,
+        dir: process.cwd(),
+        author,
+        description,
+        license,
+        git: options.git
+      });
+      logger.success(`Package ${packageName} created successfully!`);
+      console.log();
+      console.log(`  cd ${packageName}`);
+      console.log("  npm install");
+      console.log("  npm run build");
+      console.log();
+    } catch (err) {
+      logger.error(
+        `Failed to create package: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli/build.ts
+function parseEntryFlag(raw) {
+  const parts = raw.split(",").map((e) => e.trim());
+  if (parts.some((p) => p.includes("="))) {
+    const result = {};
+    for (const part of parts) {
+      const eqIdx = part.indexOf("=");
+      if (eqIdx === -1) {
+        const name = part.replace(/^src\//, "").replace(/\.tsx?$/, "");
+        result[name] = part;
+      } else {
+        result[part.slice(0, eqIdx)] = part.slice(eqIdx + 1);
+      }
+    }
+    return result;
+  }
+  return parts;
+}
+async function buildSinglePackage(dir, options, config, prefix) {
+  const buildConfig = config?.build;
+  const VALID_FORMATS = /* @__PURE__ */ new Set(["esm", "cjs", "iife"]);
+  let formats;
+  if (options.format) {
+    const parsed = options.format.split(",").map((f) => f.trim());
+    const invalid = parsed.filter((f) => !VALID_FORMATS.has(f));
+    if (invalid.length > 0) {
+      logger.error(`Invalid format(s): ${invalid.join(", ")}. Valid formats: esm, cjs, iife`);
+      return false;
+    }
+    formats = parsed;
+  } else {
+    formats = buildConfig?.formats ?? ["esm"];
+  }
+  const entry = options.entry ? parseEntryFlag(options.entry) : buildConfig?.entry ?? void 0;
+  const clean = options.clean === true || options.clean === void 0 && buildConfig?.clean === true;
+  const outDir = options.outDir ?? buildConfig?.outDir ?? "dist";
+  const dts = options.dts !== false && (options.dts !== void 0 || buildConfig?.dts !== false);
+  const sourcemap = options.sourcemap !== false && (options.sourcemap !== void 0 || buildConfig?.sourcemap !== false);
+  const label = prefix ? `[${prefix}] ` : "";
+  try {
+    await build({
+      formats,
+      dts,
+      sourcemap,
+      watch: options.watch === true,
+      dir,
+      entry,
+      clean,
+      outDir,
+      minify: options.minify ?? buildConfig?.minify,
+      splitting: options.splitting ?? buildConfig?.splitting,
+      target: options.target ?? buildConfig?.target,
+      platform: options.platform ?? buildConfig?.platform,
+      external: options.external ? options.external.split(",").map((e) => e.trim()) : buildConfig?.external,
+      noExternal: buildConfig?.noExternal,
+      define: buildConfig?.define,
+      banner: buildConfig?.banner,
+      footer: buildConfig?.footer,
+      cjsInterop: options.cjsInterop !== false ? buildConfig?.cjsInterop ?? true : false,
+      esbuildPlugins: buildConfig?.esbuildPlugins,
+      loader: buildConfig?.loader,
+      envProduction: options.envProduction ?? buildConfig?.envProduction,
+      replaceNodeEnv: buildConfig?.replaceNodeEnv,
+      globalName: options.globalName ?? buildConfig?.globalName,
+      onSuccess: buildConfig?.onSuccess,
+      treeshake: options.noTreeshake === true ? false : buildConfig?.treeshake,
+      publicDir: options.publicDir ?? buildConfig?.publicDir,
+      inject: buildConfig?.inject,
+      dtsBundle: options.dtsBundle ?? buildConfig?.dtsBundle,
+      dtsResolve: buildConfig?.dtsResolve,
+      legacy: options.legacy
+    });
+    logger.success(`${label}Build complete`);
+    return true;
+  } catch (err) {
+    logger.error(
+      `${label}Build failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
+function registerBuild(program) {
+  program.command("build").description("Build ESM + CJS + types").option("--format <formats>", "Output formats (comma-separated: esm,cjs,iife)").option("--no-dts", "Skip .d.ts generation").option("--no-sourcemap", "Skip sourcemap generation").option("--watch", "Watch mode").option("--entry <paths>", "Entry file(s): paths or name=path mappings (comma-separated)").option("--clean", "Remove output directory before building").option("--out-dir <dir>", "Output directory").option("--filter <pattern>", "Filter workspace packages by name pattern").option("--minify", "Minify output").option("--target <target>", "Build target (e.g. node18, es2020)").option("--platform <platform>", "Target platform (node, browser, neutral)").option("--splitting", "Enable code splitting (ESM only)").option("--external <deps>", "Additional externals (comma-separated)").option("--no-cjs-interop", "Disable CJS default export interop").option("--legacy", "Use legacy tsc-only build").option("--env-production", "Replace process.env.NODE_ENV with 'production'").option("--global-name <name>", "Global variable name for IIFE builds").option("--no-treeshake", "Disable tree-shaking").option("--public-dir <dir>", "Copy static assets from this directory").option("--dts-bundle", "Bundle .d.ts into single files per entry").action(async (options) => {
+    const dir = process.cwd();
+    logger.heading("tspub build");
+    if (await isMonorepoRoot(dir)) {
+      let packages = topoSort(await discoverWorkspaces(dir));
+      if (options.filter) {
+        packages = filterPackages(packages, options.filter);
+      }
+      logger.info(`Monorepo detected \u2014 building ${packages.length} package(s)`);
+      let hasErrors = false;
+      for (const wp of packages) {
+        logger.info(`[${wp.name}] Building...`);
+        const config = await loadConfigWithInheritance(wp.dir, dir);
+        const ok = await buildSinglePackage(wp.dir, options, config, wp.name);
+        if (!ok) hasErrors = true;
+      }
+      if (hasErrors) process.exitCode = 1;
+    } else {
+      const config = await loadConfig(dir);
+      const ok = await buildSinglePackage(dir, options, config);
+      if (!ok) process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli/check.ts
+import chalk from "chalk";
+function registerCheck(program) {
+  program.command("check").description("Validate package.json, exports, types, and more").option("--fix", "Auto-fix package.json issues where possible").option("--fix-dry-run", "Show what fixes would be applied without writing").option("--fix-type <types>", "Only fix specific categories (exports,files,metadata)").option("-i, --interactive", "Confirm each fix before applying (requires --fix)").option("--unsafe", "Also apply unsafe fixes (requires --fix)").option("--strict", "Treat warnings as errors").option("--rule <spec>", "Override rule severity (e.g. exports/file-exists=off)", collect, []).option("--format <fmt>", "Output format: text, json, or table", "text").option("--filter <pattern>", "Filter workspace packages by name pattern").option("--list-rules", "Print all available rules and exit").option("--ignore-rules <ids>", "Comma-separated rule IDs to skip").option("--profile <name>", "Check profile: strict, library, or app").option("--compare", "Show equivalent publint/attw rule IDs alongside results").action(async (options) => {
+    if (options.listRules) {
+      printListRules();
+      return;
+    }
+    const isJson = options.format === "json";
+    const isTable = options.format === "table";
+    if (!isJson && !isTable) {
+      logger.heading("tspub check \u2014 validating your package...");
+    }
+    try {
+      const dryRun = options.fixDryRun === true;
+      const fixTypes = options.fixType ? options.fixType.split(",").map((s) => s.trim()) : void 0;
+      const severityOverrides = parseSeverityOverrides(options.rule);
+      if (options.ignoreRules) {
+        for (const id of options.ignoreRules.split(",").map((s) => s.trim())) {
+          if (id) severityOverrides[id] = "off";
+        }
+      }
+      if (options.profile && PROFILES[options.profile]) {
+        const profileRules = PROFILES[options.profile];
+        if (ALLOW_LIST_PROFILES.has(options.profile)) {
+          const allowed = new Set(profileRules);
+          for (const rule of allRules) {
+            if (!allowed.has(rule.meta.id) && !(rule.meta.id in severityOverrides)) {
+              severityOverrides[rule.meta.id] = "off";
+            }
+          }
+        } else {
+          for (const id of profileRules) {
+            if (!(id in severityOverrides)) {
+              severityOverrides[id] = "off";
+            }
+          }
+        }
+      }
+      const dir = process.cwd();
+      let results;
+      if (await isMonorepoRoot(dir)) {
+        let packages = topoSort(await discoverWorkspaces(dir));
+        if (options.filter) {
+          packages = filterPackages(packages, options.filter);
+        }
+        if (!isJson && !isTable) logger.info(`Monorepo detected \u2014 checking ${packages.length} package(s)`);
+        results = [];
+        for (const wp of packages) {
+          if (!isJson && !isTable) logger.info(`[${wp.name}] Checking...`);
+          const inheritedConfig = await loadConfigWithInheritance(wp.dir, dir);
+          const mergedOverrides = {
+            ...inheritedConfig?.check?.severityOverrides,
+            ...severityOverrides
+          };
+          const pkgResults = await check({
+            dir: wp.dir,
+            fix: options.fix === true || dryRun,
+            unsafe: options.unsafe === true,
+            strict: options.strict === true || options.profile === "strict",
+            dryRun,
+            fixTypes,
+            interactive: options.interactive === true,
+            severityOverrides: mergedOverrides
+          });
+          for (const r of pkgResults) {
+            results.push({
+              ...r,
+              message: `[${wp.name}] ${r.message}`
+            });
+          }
+        }
+      } else {
+        results = await check({
+          dir,
+          fix: options.fix === true || dryRun,
+          unsafe: options.unsafe === true,
+          strict: options.strict === true || options.profile === "strict",
+          dryRun,
+          fixTypes,
+          interactive: options.interactive === true,
+          severityOverrides
+        });
+      }
+      if (isJson) {
+        let errors2 = 0;
+        let warnings2 = 0;
+        let passed2 = 0;
+        for (const r of results) {
+          if (r.severity === "error") errors2++;
+          else if (r.severity === "warning") warnings2++;
+          else if (r.severity === "ok") passed2++;
+        }
+        console.log(
+          JSON.stringify({ results, summary: { errors: errors2, warnings: warnings2, passed: passed2, total: allRules.length } }, null, 2)
+        );
+        if (errors2 > 0) process.exitCode = 1;
+        return;
+      }
+      if (isTable) {
+        printResolutionTable(results);
+      }
+      const isStrict = options.strict === true || options.profile === "strict";
+      const { errors, warnings, passed } = printGroupedResults(results, isStrict, options.compare === true);
+      console.log();
+      const parts = [];
+      if (passed > 0) parts.push(chalk.green(`\u2713 ${passed} passed`));
+      if (errors > 0) parts.push(chalk.red(`\u2717 ${errors} error(s)`));
+      if (warnings > 0) parts.push(chalk.yellow(`\u26A0 ${warnings} warning(s)`));
+      if (parts.length > 0) {
+        console.log(parts.join(chalk.dim(" \xB7 ")));
+      }
+      if (errors > 0) {
+        process.exitCode = 1;
+      } else if (warnings === 0 && errors === 0) {
+        logger.success("All checks passed!");
+      }
+    } catch (err) {
+      logger.error(
+        `Check failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+function collect(value, prev) {
+  return [...prev, value];
+}
+
+// src/cli/publish.ts
+var VALID_BUMPS = /* @__PURE__ */ new Set(["major", "minor", "patch"]);
+function registerPublish(program) {
+  program.command("publish [bump]").description("Build + check + version + changelog + npm publish").option("--dry-run", "Preview without publishing").option("--tag <tag>", "npm dist-tag", "latest").option("--otp <code>", "npm OTP for 2FA").option("--access <level>", "public or restricted").option("--no-changelog", "Skip changelog generation").option("--no-git", "Skip git tag + commit").option("--prerelease <tag>", "Create prerelease version (e.g. beta, alpha)").option("--provenance", "Publish with provenance attestation").option("--registry <url>", "npm registry URL").option("--changelog-style <style>", "Changelog style: simple, conventional, auto", "auto").option("--ci", "CI mode: auto-detect version bump from commits").option("--filter <pattern>", "Filter workspace packages by name pattern").option("--github-release", "Create a GitHub release (default: auto when GITHUB_TOKEN is set)").option("--no-github-release", "Skip GitHub release creation").option("-y, --yes", "Skip confirmation prompt").action(async (bump, options) => {
+    const dir = process.cwd();
+    const config = await loadConfig(dir);
+    logger.heading("tspub publish");
+    if (bump && !VALID_BUMPS.has(bump) && !/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(bump)) {
+      logger.error(`Invalid bump "${bump}". Use: major, minor, patch, or an explicit version (e.g. 1.2.3)`);
+      process.exitCode = 1;
+      return;
+    }
+    const isCi = options.ci === true || config?.publish?.ci?.enabled === true;
+    const registry = options.registry ?? config?.publish?.registry;
+    const registryArgs = registry ? ["--registry", registry] : [];
+    const hooks = createHooksFromConfig(config?.publish);
+    if (await isMonorepoRoot(dir)) {
+      const results = await publishMonorepo({
+        dir,
+        bump,
+        options,
+        hooks
+      });
+      if (results.some((r) => !r.success)) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+    const result = await publishPackage({
+      dir,
+      bump,
+      options,
+      config,
+      isCi,
+      registry,
+      registryArgs,
+      hooks
+    });
+    if (!result.success) {
+      for (const d of result.prereqDiagnostics) {
+        if (d.severity === "error") logger.error(d.message);
+        else if (d.severity === "warning") logger.warn(d.message);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (options.git !== false && !options.dryRun) {
+      if (!isCi || config?.publish?.ci?.skipPush === false) {
+        const { ok } = pushWithTags(dir);
+        if (ok) {
+          logger.info("Pushed to remote");
+        } else {
+          logger.warn("Git push failed \u2014 push manually");
+        }
+      }
+    }
+  });
+}
+
+// src/doctor/formatter.ts
+import chalk2 from "chalk";
+var CATEGORY_ORDER = ["environment", "typescript", "build", "dependencies"];
+function formatDoctorResults(results, format = "text") {
+  if (format === "json") {
+    console.log(JSON.stringify(results, null, 2));
+    return countSeverities(results);
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const cat of CATEGORY_ORDER) {
+    grouped.set(cat, []);
+  }
+  for (const r of results) {
+    const cat = r.ruleId.split("/")[0] ?? "other";
+    if (!grouped.has(cat)) grouped.set(cat, []);
+    grouped.get(cat).push(r);
+  }
+  for (const [category, catResults] of grouped) {
+    if (catResults.length === 0) continue;
+    console.log();
+    console.log(chalk2.bold.cyan(`\u2500\u2500 ${category} \u2500\u2500`));
+    for (const result of catResults) {
+      const fixHint = result.fixable ? chalk2.dim(` [fixable: ${result.fixable}]`) : "";
+      if (result.severity === "error") {
+        logger.error(result.message + fixHint);
+      } else if (result.severity === "warning") {
+        logger.warn(result.message + fixHint);
+      } else {
+        logger.info(result.message + fixHint);
+      }
+    }
+  }
+  return countSeverities(results);
+}
+function countSeverities(results) {
+  let errors = 0;
+  let warnings = 0;
+  for (const r of results) {
+    if (r.severity === "error") errors++;
+    else if (r.severity === "warning") warnings++;
+  }
+  return { errors, warnings };
+}
+
+// src/cli/doctor.ts
+function registerDoctor(program) {
+  program.command("doctor").description("Diagnose environment, dependencies, and package health").option("--check <subpath>", "Debug resolution of a specific subpath export").option("--fix", "Apply auto-fixes").option("--unsafe", "Allow unsafe fixes").option("--dry-run", "Preview fixes without applying").option("--profile <profile>", "Use preset profile (strict, quick)").option("--rule <id=severity>", "Override rule severity", collect2, []).option("--format <format>", "Output format: text or json", "text").action(async (options) => {
+    const dir = process.cwd();
+    const format = options.format === "json" ? "json" : "text";
+    if (format === "text") {
+      logger.heading("tspub doctor \u2014 scanning your package...");
+    }
+    try {
+      if (options.check) {
+        const pkg = await readPackageJson(dir);
+        const diags = debugResolution(pkg, options.check);
+        if (format === "json") {
+          console.log(JSON.stringify(diags, null, 2));
+        } else {
+          for (const d of diags) {
+            if (d.severity === "error") logger.error(d.message);
+            else if (d.severity === "warning") logger.warn(d.message);
+            else logger.info(d.message);
+          }
+        }
+        if (diags.some((d) => d.severity === "error")) {
+          process.exitCode = 1;
+        }
+        return;
+      }
+      const severityOverrides = options.rule && options.rule.length > 0 ? parseSeverityOverrides(options.rule) : void 0;
+      const envResults = await doctor({
+        dir,
+        fix: options.fix ?? false,
+        unsafe: options.unsafe,
+        dryRun: options.dryRun,
+        severityOverrides,
+        profile: options.profile,
+        format
+      });
+      if (format === "json") {
+        const checkResults = await check({ dir, fix: false, strict: false });
+        console.log(JSON.stringify({ doctor: envResults, check: checkResults }, null, 2));
+        const hasErrors = envResults.some((r) => r.severity === "error") || checkResults.some((r) => r.severity === "error");
+        if (hasErrors) process.exitCode = 1;
+        return;
+      }
+      const formatted = envResults.map((r) => ({
+        ruleId: r.ruleId ?? r.category,
+        severity: r.severity,
+        message: r.message,
+        fixable: r.fixable
+      }));
+      const { errors: doctorErrors, warnings: doctorWarnings } = formatDoctorResults(formatted);
+      const results = await check({ dir, fix: false, strict: false });
+      let errors = doctorErrors;
+      let warnings = doctorWarnings;
+      for (const result of results) {
+        if (result.severity === "error") {
+          logger.error(result.message);
+          errors++;
+        } else if (result.severity === "warning") {
+          logger.warn(result.message);
+          warnings++;
+        } else if (result.severity === "ok") {
+          logger.ok(result.message);
+        } else {
+          logger.info(result.message);
+        }
+      }
+      console.log();
+      if (errors > 0 || warnings > 0) {
+        logger.info(
+          `Found ${errors} error(s), ${warnings} warning(s).`
+        );
+      } else {
+        logger.success("Your package looks great!");
+      }
+      if (errors > 0) process.exitCode = 1;
+    } catch (err) {
+      logger.error(
+        `Doctor failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+function collect2(value, previous) {
+  return [...previous, value];
+}
+
+// src/cli/scan.ts
+import { writeFileSync } from "node:fs";
+function registerScan(program) {
+  program.command("scan [url]").description("Scan GitHub repos for TypeScript packaging issues").option("--top <n>", "Discover and scan top N TypeScript npm packages", parseInt).option("--json", "Output results as JSON", false).option("--fix", "Report what --fix would change in each package", false).option("--concurrency <n>", "Parallel clone concurrency", parseInt).option("--min-stars <n>", "Minimum GitHub stars", parseInt).option("--query <q>", "Custom GitHub search query").option("--profile <p>", "Check profile (strict, exports-only, types-only)").option("--report <path>", "Save markdown report to file").option("--rule <id=severity>", "Override rule severity", collect3, []).action(async (url, options) => {
+    if (!url && !options.top) {
+      logger.error("Provide a GitHub URL or use --top <n>");
+      process.exitCode = 1;
+      return;
+    }
+    if (!options.json) {
+      const fixLabel = options.fix ? " (with fix preview)" : "";
+      logger.heading(
+        `tspub scan \u2014 scanning ${url ? url : `top ${options.top} repos`}${fixLabel}...`
+      );
+    }
+    try {
+      const severityOverrides = options.rule && options.rule.length > 0 ? parseSeverityOverrides(options.rule) : void 0;
+      const results = await scan(
+        {
+          url,
+          top: options.top,
+          json: options.json,
+          fix: options.fix,
+          concurrency: options.concurrency,
+          minStars: options.minStars,
+          query: options.query,
+          severityOverrides,
+          profile: options.profile
+        },
+        options.json ? void 0 : (msg) => logger.dim(msg)
+      );
+      if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      for (const result of results) {
+        if (result.errors) {
+          for (const err of result.errors) {
+            logger.error(`[${err.repo}] ${err.phase}: ${err.message}`);
+          }
+        }
+        for (const pkg of result.packages) {
+          for (const r of pkg.results) {
+            if (r.severity === "error") {
+              logger.error(`${pkg.name}: ${r.message}`);
+            } else if (r.severity === "warning") {
+              logger.warn(`${pkg.name}: ${r.message}`);
+            }
+          }
+          if (pkg.fixChanges && pkg.fixChanges.length > 0) {
+            logger.info(`${pkg.name}: --fix would change:`);
+            for (const change of pkg.fixChanges) {
+              if (change.before === null || change.before === void 0) {
+                logger.dim(`  + ${change.field}: ${JSON.stringify(change.after)}`);
+              } else {
+                logger.dim(`  ~ ${change.field}: ${JSON.stringify(change.before)} \u2192 ${JSON.stringify(change.after)}`);
+              }
+            }
+          }
+        }
+      }
+      const totalRepos = results.length;
+      const totalPackages = results.reduce((sum, r) => sum + r.packages.length, 0);
+      const withErrors = results.filter(
+        (r) => r.packages.some((p) => p.errors > 0)
+      ).length;
+      const withWarningsOnly = results.filter(
+        (r) => r.packages.some((p) => p.warnings > 0) && !r.packages.some((p) => p.errors > 0)
+      ).length;
+      const clean = totalRepos - withErrors - withWarningsOnly;
+      console.log();
+      logger.heading("=== RESULTS ===");
+      logger.info(`${totalRepos} repos scanned, ${totalPackages} packages checked`);
+      if (clean > 0) logger.ok(`${clean} clean`);
+      if (withWarningsOnly > 0) logger.warn(`${withWarningsOnly} with warnings only`);
+      if (withErrors > 0) logger.error(`${withErrors} with errors`);
+      if (options.fix) {
+        const fixablePackages = results.flatMap((r) => r.packages).filter(
+          (p) => p.fixChanges && p.fixChanges.length > 0
+        );
+        const totalFixFields = fixablePackages.reduce(
+          (sum, p) => sum + (p.fixChanges?.length ?? 0),
+          0
+        );
+        if (fixablePackages.length > 0) {
+          console.log();
+          logger.info(
+            `${fixablePackages.length} package(s) fixable, ${totalFixFields} field(s) would change`
+          );
+          const fieldCounts = /* @__PURE__ */ new Map();
+          for (const pkg of fixablePackages) {
+            for (const change of pkg.fixChanges) {
+              fieldCounts.set(change.field, (fieldCounts.get(change.field) ?? 0) + 1);
+            }
+          }
+          const sortedFields = [...fieldCounts.entries()].sort((a, b) => b[1] - a[1]);
+          for (const [field, count] of sortedFields) {
+            logger.dim(`  ${count}x  ${field}`);
+          }
+        } else {
+          logger.ok("Nothing to fix");
+        }
+      }
+      const issueCounts = /* @__PURE__ */ new Map();
+      for (const result of results) {
+        for (const pkg of result.packages) {
+          for (const r of pkg.results) {
+            if (r.severity === "error" || r.severity === "warning") {
+              issueCounts.set(r.message, (issueCounts.get(r.message) ?? 0) + 1);
+            }
+          }
+        }
+      }
+      if (issueCounts.size > 0) {
+        console.log();
+        logger.info("Top issues:");
+        const sorted = [...issueCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+        for (const [msg, count] of sorted) {
+          logger.dim(`  ${count}x  ${msg}`);
+        }
+      }
+      if (options.report) {
+        const report = generateMarkdownReport(results);
+        writeFileSync(options.report, report);
+        logger.info(`Report saved to ${options.report}`);
+      }
+      if (withErrors > 0) {
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      logger.error(
+        `Scan failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+function collect3(value, previous) {
+  return [...previous, value];
+}
+
+// src/cli/test-types.ts
+function registerTestTypes(program) {
+  program.command("test-types").description("Run type declaration tests (.test-d.ts files)").option("--dir <directory>", "Directory containing .test-d.ts files", "test-d").action(async (options) => {
+    const dir = process.cwd();
+    logger.heading("tspub test-types");
+    try {
+      const result = await runTypeTests({
+        dir,
+        directory: options.dir
+      });
+      if (result.fileCount === 0) {
+        logger.info("No .test-d.ts files found");
+        return;
+      }
+      logger.info(`Found ${result.fileCount} type test file(s)`);
+      if (result.passed) {
+        logger.success("All type tests passed!");
+      } else {
+        for (const err of result.errors) {
+          logger.error(`${err.file}:${err.line} \u2014 ${err.message}`);
+        }
+        logger.error(`${result.errors.length} type error(s) found`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      logger.error(
+        `Type test failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/changeset/writer.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function writeChangeset(dir, entries, summary) {
+  const id = randomUUID().slice(0, 8);
+  const changesetDir = join(dir, ".changeset");
+  await mkdir(changesetDir, { recursive: true });
+  const frontmatter = entries.map((e) => `"${e.packageName}": ${e.bump}`).join("\n");
+  const content = `---
+${frontmatter}
+---
+
+${summary}
+`;
+  const filePath = join(changesetDir, `${id}.md`);
+  await writeFile(filePath, content, "utf-8");
+  return filePath;
+}
+
+// src/changeset/version.ts
+import { readFile as readFile2, writeFile as writeFile2, readdir, unlink } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/changeset/parser.ts
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+function parseChangesetContent(content, id) {
+  const lines = content.split("\n");
+  let firstDash = -1;
+  let secondDash = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      if (firstDash === -1) {
+        firstDash = i;
+      } else {
+        secondDash = i;
+        break;
+      }
+    }
+  }
+  if (firstDash === -1 || secondDash === -1) {
+    throw new Error(`Invalid changeset format in "${id}": missing --- delimiters`);
+  }
+  const entries = [];
+  for (let i = firstDash + 1; i < secondDash; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    const match = line.match(/^"([^"]+)":\s*(major|minor|patch)$/);
+    if (!match) {
+      throw new Error(`Invalid changeset entry in "${id}": ${line}`);
+    }
+    entries.push({
+      packageName: match[1],
+      bump: match[2]
+    });
+  }
+  const summary = lines.slice(secondDash + 1).join("\n").trim();
+  return { id, entries, summary };
+}
+async function parseChangeset(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const id = basename(filePath, ".md");
+  return parseChangesetContent(content, id);
+}
+
+// src/changeset/dependent-bumping.ts
+var BUMP_ORDER = {
+  patch: 0,
+  minor: 1,
+  major: 2
+};
+function higherBump(a, b) {
+  return BUMP_ORDER[a] >= BUMP_ORDER[b] ? a : b;
+}
+function computeDependentBumps(packages, initialBumps, mode) {
+  const bumps = new Map(initialBumps);
+  if (mode === "none") {
+    return bumps;
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const dep of Object.keys(allDeps)) {
+      let list = dependents.get(dep);
+      if (!list) {
+        list = [];
+        dependents.set(dep, list);
+      }
+      list.push(pkg.name);
+    }
+  }
+  const queue = [...bumps.keys()];
+  const inQueue = new Set(queue);
+  while (queue.length > 0) {
+    const name = queue.shift();
+    inQueue.delete(name);
+    const bump = bumps.get(name);
+    if (mode === "major" && bump !== "major") continue;
+    const deps = dependents.get(name);
+    if (!deps) continue;
+    for (const dep of deps) {
+      const existing = bumps.get(dep);
+      if (!existing) {
+        bumps.set(dep, "patch");
+        if (!inQueue.has(dep)) {
+          queue.push(dep);
+          inQueue.add(dep);
+        }
+      } else {
+        const higher = higherBump(existing, "patch");
+        if (higher !== existing) {
+          bumps.set(dep, higher);
+          if (!inQueue.has(dep)) {
+            queue.push(dep);
+            inQueue.add(dep);
+          }
+        }
+      }
+    }
+  }
+  return bumps;
+}
+
+// src/changeset/version.ts
+function bumpVersion(version, bump) {
+  const base = version.split("-")[0];
+  const parts = base.split(".").map(Number);
+  const [major = 0, minor = 0, patch = 0] = parts;
+  switch (bump) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+var BUMP_ORDER2 = {
+  patch: 0,
+  minor: 1,
+  major: 2
+};
+function semverGt(a, b) {
+  const [aBase = "", aPre] = a.split("-", 2);
+  const [bBase = "", bPre] = b.split("-", 2);
+  const [aMaj = 0, aMin = 0, aPat = 0] = aBase.split(".").map(Number);
+  const [bMaj = 0, bMin = 0, bPat = 0] = bBase.split(".").map(Number);
+  if (aMaj !== bMaj) return aMaj > bMaj;
+  if (aMin !== bMin) return aMin > bMin;
+  if (aPat !== bPat) return aPat > bPat;
+  if (!aPre && bPre) return true;
+  if (aPre && !bPre) return false;
+  if (!aPre && !bPre) return false;
+  const aIds = aPre.split(".");
+  const bIds = bPre.split(".");
+  const len = Math.max(aIds.length, bIds.length);
+  for (let i = 0; i < len; i++) {
+    const aId = aIds[i];
+    const bId = bIds[i];
+    if (aId === void 0) return false;
+    if (bId === void 0) return true;
+    const aNum = /^\d+$/.test(aId) ? Number(aId) : NaN;
+    const bNum = /^\d+$/.test(bId) ? Number(bId) : NaN;
+    if (!isNaN(aNum) && !isNaN(bNum)) {
+      if (aNum !== bNum) return aNum > bNum;
+    } else {
+      if (!isNaN(aNum)) return false;
+      if (!isNaN(bNum)) return true;
+      if (aId !== bId) return aId > bId;
+    }
+  }
+  return false;
+}
+function applyLinkedGroups(aggregated, linked) {
+  for (const group of linked) {
+    let highestBump = null;
+    for (const name of group) {
+      const entry = aggregated.get(name);
+      if (entry && (!highestBump || BUMP_ORDER2[entry.bump] > BUMP_ORDER2[highestBump])) {
+        highestBump = entry.bump;
+      }
+    }
+    if (highestBump) {
+      for (const name of group) {
+        if (!aggregated.has(name)) {
+          aggregated.set(name, { bump: highestBump, summaries: ["Linked version bump"] });
+        } else {
+          aggregated.get(name).bump = highestBump;
+        }
+      }
+    }
+  }
+}
+function applyFixedGroups(aggregated, fixed, packageVersions) {
+  for (const group of fixed) {
+    let highestVersion = "0.0.0";
+    let highestBump = null;
+    for (const name of group) {
+      const version = packageVersions.get(name) ?? "0.0.0";
+      if (semverGt(version, highestVersion)) highestVersion = version;
+      const entry = aggregated.get(name);
+      if (entry && (!highestBump || BUMP_ORDER2[entry.bump] > BUMP_ORDER2[highestBump])) {
+        highestBump = entry.bump;
+      }
+    }
+    if (highestBump) {
+      const targetVersion = bumpVersion(highestVersion, highestBump);
+      for (const name of group) {
+        const existing = aggregated.get(name);
+        if (!existing) {
+          aggregated.set(name, { bump: highestBump, summaries: ["Fixed group version bump"], targetVersion });
+        } else {
+          existing.bump = highestBump;
+          existing.targetVersion = targetVersion;
+        }
+      }
+    }
+  }
+}
+async function consumeChangesets(rootDir, packageDirs, options) {
+  const changesetDir = join2(rootDir, ".changeset");
+  const files = await readdir(changesetDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md") && f !== "README.md");
+  if (mdFiles.length === 0) return { updates: [], cleanup: async () => {
+  } };
+  const aggregated = /* @__PURE__ */ new Map();
+  for (const file of mdFiles) {
+    const changeset = await parseChangeset(join2(changesetDir, file));
+    for (const entry of changeset.entries) {
+      const existing = aggregated.get(entry.packageName);
+      if (existing) {
+        if (BUMP_ORDER2[entry.bump] > BUMP_ORDER2[existing.bump]) {
+          existing.bump = entry.bump;
+        }
+        existing.summaries.push(changeset.summary);
+      } else {
+        aggregated.set(entry.packageName, {
+          bump: entry.bump,
+          summaries: [changeset.summary]
+        });
+      }
+    }
+  }
+  const packageVersions = /* @__PURE__ */ new Map();
+  const allPackageNames = new Set(aggregated.keys());
+  for (const group of options?.linked ?? []) {
+    for (const name of group) allPackageNames.add(name);
+  }
+  for (const group of options?.fixed ?? []) {
+    for (const name of group) allPackageNames.add(name);
+  }
+  for (const pkgName of allPackageNames) {
+    const pkgDir = packageDirs?.get(pkgName) ?? rootDir;
+    const pkgJson = await readPackageJson(pkgDir);
+    packageVersions.set(pkgName, pkgJson.version ?? "0.0.0");
+  }
+  if (options?.linked?.length) {
+    applyLinkedGroups(aggregated, options.linked);
+  }
+  if (options?.fixed?.length && packageDirs) {
+    applyFixedGroups(aggregated, options.fixed, packageVersions);
+  }
+  if (packageDirs && packageDirs.size > 0) {
+    const mode = options?.dependentBumping ?? "none";
+    if (mode !== "none") {
+      const packageInfos = [];
+      for (const [name, dir] of packageDirs) {
+        const pkg = await readPackageJson(dir);
+        packageInfos.push({
+          name,
+          dependencies: pkg.dependencies ?? {},
+          devDependencies: pkg.devDependencies ?? {}
+        });
+      }
+      const initialBumps = /* @__PURE__ */ new Map();
+      for (const [name, { bump }] of aggregated) {
+        initialBumps.set(name, bump);
+      }
+      const allBumps = computeDependentBumps(packageInfos, initialBumps, mode);
+      for (const [name, bump] of allBumps) {
+        if (!aggregated.has(name)) {
+          aggregated.set(name, { bump, summaries: ["Dependency version bump"] });
+        }
+      }
+    }
+  }
+  const updates = [];
+  for (const [pkgName, { bump, summaries, targetVersion }] of aggregated) {
+    const pkgDir = packageDirs?.get(pkgName) ?? rootDir;
+    const pkgJson = await readPackageJson(pkgDir);
+    const oldVersion = pkgJson.version ?? "0.0.0";
+    const newVersion = targetVersion ?? bumpVersion(oldVersion, bump);
+    const changelogEntry = summaries.map((s) => `- ${s}`).join("\n");
+    const changelog = `## ${newVersion}
+
+${changelogEntry}`;
+    pkgJson.version = newVersion;
+    await writePackageJson(pkgDir, pkgJson);
+    const changelogPath = join2(pkgDir, "CHANGELOG.md");
+    let existingChangelog = "";
+    if (await fileExists(changelogPath)) {
+      existingChangelog = await readFile2(changelogPath, "utf-8");
+    }
+    const newChangelog = existingChangelog ? `${changelog}
+
+${existingChangelog}` : `# Changelog
+
+${changelog}
+`;
+    await writeFile2(changelogPath, newChangelog, "utf-8");
+    updates.push({
+      packageName: pkgName,
+      oldVersion,
+      newVersion,
+      bump,
+      changelog
+    });
+  }
+  const cleanup = async () => {
+    for (const file of mdFiles) {
+      await unlink(join2(changesetDir, file));
+    }
+  };
+  return { updates, cleanup };
+}
+
+// src/changeset/snapshot.ts
+import { readdir as readdir2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+async function createSnapshot(rootDir, tag, packageDirs) {
+  const changesetDir = join3(rootDir, ".changeset");
+  const files = await readdir2(changesetDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md") && f !== "README.md");
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of mdFiles) {
+    const changeset = await parseChangeset(join3(changesetDir, file));
+    for (const entry of changeset.entries) {
+      packages.add(entry.packageName);
+    }
+  }
+  const timestamp = Date.now();
+  const suffix = tag ? `${tag}-${timestamp}` : `snapshot-${timestamp}`;
+  const snapshotVersion = `0.0.0-${suffix}`;
+  const versions = [];
+  for (const pkgName of packages) {
+    const pkgDir = packageDirs?.get(pkgName) ?? rootDir;
+    const pkgJson = await readPackageJson(pkgDir);
+    pkgJson.version = snapshotVersion;
+    await writePackageJson(pkgDir, pkgJson);
+    versions.push(`${pkgName}@${snapshotVersion}`);
+  }
+  return versions;
+}
+
+// src/cli/changeset.ts
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join4, basename as basename2 } from "node:path";
+function registerChangeset(program) {
+  const cmd = program.command("changeset").description("Manage changesets for versioning");
+  cmd.action(async () => {
+    await addChangeset();
+  });
+  cmd.command("add").description("Create a new changeset").action(async () => {
+    await addChangeset();
+  });
+  cmd.command("version").description("Consume changesets and update versions").option("--dry-run", "Preview without making changes").action(async (options) => {
+    const dir = process.cwd();
+    logger.heading("tspub changeset version");
+    if (options.dryRun) {
+      const changesetDir = join4(dir, ".changeset");
+      try {
+        const files = (await readdir3(changesetDir)).filter((f) => f.endsWith(".md") && f !== "README.md");
+        if (files.length === 0) {
+          logger.info("No pending changesets");
+          return;
+        }
+        const bumps = /* @__PURE__ */ new Map();
+        for (const file of files) {
+          const cs = await parseChangeset(join4(changesetDir, file));
+          for (const entry of cs.entries) {
+            const current = bumps.get(entry.packageName);
+            if (!current || bumpRank(entry.bump) > bumpRank(current)) {
+              bumps.set(entry.packageName, entry.bump);
+            }
+          }
+        }
+        for (const [name, bump] of bumps) {
+          logger.info(`${name}: ${bump}`);
+        }
+      } catch {
+        logger.info("No .changeset directory found");
+      }
+      return;
+    }
+    let packageDirs;
+    if (await isMonorepoRoot(dir)) {
+      const workspaces = await discoverWorkspaces(dir);
+      packageDirs = new Map(workspaces.map((w) => [w.name, w.dir]));
+    }
+    const config = await loadConfig(dir);
+    const csConfig = config?.changeset;
+    const { updates, cleanup } = await consumeChangesets(dir, packageDirs, {
+      dependentBumping: csConfig?.dependentBumping,
+      linked: csConfig?.linked,
+      fixed: csConfig?.fixed
+    });
+    if (updates.length === 0) {
+      logger.info("No changesets to consume");
+      return;
+    }
+    for (const u of updates) {
+      logger.success(`${u.packageName}: ${u.oldVersion} \u2192 ${u.newVersion} (${u.bump})`);
+    }
+    await cleanup();
+  });
+  cmd.command("status").description("Show pending changesets").action(async () => {
+    const dir = process.cwd();
+    const changesetDir = join4(dir, ".changeset");
+    try {
+      const files = (await readdir3(changesetDir)).filter((f) => f.endsWith(".md") && f !== "README.md");
+      if (files.length === 0) {
+        logger.info("No pending changesets");
+        return;
+      }
+      logger.heading("Pending changesets");
+      for (const file of files) {
+        const cs = await parseChangeset(join4(changesetDir, file));
+        const pkgs = cs.entries.map((e) => `${e.packageName}:${e.bump}`).join(", ");
+        logger.info(`${basename2(file, ".md")}: ${pkgs} \u2014 ${cs.summary.slice(0, 60)}`);
+      }
+    } catch {
+      logger.info("No .changeset directory found");
+    }
+  });
+  cmd.command("snapshot").description("Publish snapshot versions").option("--tag <tag>", "Snapshot tag", "snapshot").action(async (options) => {
+    const dir = process.cwd();
+    logger.heading("tspub changeset snapshot");
+    const versions = await createSnapshot(dir, options.tag);
+    if (versions.length === 0) {
+      logger.info("No changesets found for snapshot");
+      return;
+    }
+    for (const v of versions) {
+      logger.success(`Snapshot: ${v}`);
+    }
+  });
+}
+function bumpRank(bump) {
+  switch (bump) {
+    case "major":
+      return 3;
+    case "minor":
+      return 2;
+    case "patch":
+      return 1;
+  }
+}
+async function addChangeset() {
+  const dir = process.cwd();
+  logger.heading("tspub changeset add");
+  let packageName;
+  const prompts2 = (await import("prompts")).default;
+  if (await isMonorepoRoot(dir)) {
+    const workspaces = await discoverWorkspaces(dir);
+    const { selected } = await prompts2({
+      type: "multiselect",
+      name: "selected",
+      message: "Select packages",
+      choices: workspaces.map((w) => ({ title: w.name, value: w.name }))
+    });
+    if (!selected || selected.length === 0) {
+      logger.info("No packages selected");
+      return;
+    }
+    const { bump } = await prompts2({
+      type: "select",
+      name: "bump",
+      message: "Bump type",
+      choices: [
+        { title: "patch", value: "patch" },
+        { title: "minor", value: "minor" },
+        { title: "major", value: "major" }
+      ]
+    });
+    const { summary } = await prompts2({
+      type: "text",
+      name: "summary",
+      message: "Summary"
+    });
+    if (!summary) {
+      logger.info("Cancelled");
+      return;
+    }
+    const entries = selected.map((name) => ({ packageName: name, bump }));
+    const filePath = await writeChangeset(dir, entries, summary);
+    logger.success(`Created changeset: ${filePath}`);
+  } else {
+    const pkg = await readPackageJson(dir);
+    packageName = pkg.name ?? basename2(dir);
+    const { bump } = await prompts2({
+      type: "select",
+      name: "bump",
+      message: "Bump type",
+      choices: [
+        { title: "patch", value: "patch" },
+        { title: "minor", value: "minor" },
+        { title: "major", value: "major" }
+      ]
+    });
+    const { summary } = await prompts2({
+      type: "text",
+      name: "summary",
+      message: "Summary"
+    });
+    if (!summary) {
+      logger.info("Cancelled");
+      return;
+    }
+    const filePath = await writeChangeset(dir, [{ packageName, bump }], summary);
+    logger.success(`Created changeset: ${filePath}`);
+  }
+}
+
+// src/cli/index.ts
+function getVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("../../package.json");
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function createProgram() {
+  const program = new Command();
+  program.name("tspub").description(
+    "The unified TypeScript package toolkit \u2014 init, build, check, publish in one tool"
+  ).version(getVersion()).option("--verbose", "Enable verbose logging").option("--silent", "Suppress all output except errors").hook("preAction", (_thisCommand, actionCommand) => {
+    const opts = actionCommand.optsWithGlobals();
+    if (opts["verbose"]) {
+      logger.setLevel("verbose");
+    } else if (opts["silent"]) {
+      logger.setLevel("silent");
+    }
+  });
+  registerInit(program);
+  registerBuild(program);
+  registerCheck(program);
+  registerPublish(program);
+  registerDoctor(program);
+  registerScan(program);
+  registerTestTypes(program);
+  registerChangeset(program);
+  program.command("pack").description("Preview what gets published").action(async () => {
+    try {
+      const { execFileSync } = await import("node:child_process");
+      console.log(execFileSync("npm", ["pack", "--dry-run"], { encoding: "utf-8" }));
+    } catch (err) {
+      logger.error(`Pack failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+    }
+  });
+  return program;
+}
+function run(argv) {
+  const program = createProgram();
+  program.parse(argv);
+}
+
+// bin/tspub.ts
+run(process.argv);
+//# sourceMappingURL=tspub.js.map