@releasekit/release 0.7.10 → 0.7.12

package/dist/aggregator-IUQUAVJC-OQZ5KHNS.js

@@ -0,0 +1,18 @@
+import {
+  aggregateToRoot,
+  detectMonorepo,
+  splitByPackage,
+  writeMonorepoChangelogs
+} from "./chunk-275AVVZE.js";
+import {
+  init_esm_shims
+} from "./chunk-NOZSTVTV.js";
+
+// ../notes/dist/aggregator-IUQUAVJC.js
+init_esm_shims();
+export {
+  aggregateToRoot,
+  detectMonorepo,
+  splitByPackage,
+  writeMonorepoChangelogs
+};

package/dist/baseError-DQHIJACF-4NWA3LJM.js

@@ -0,0 +1,12 @@
+import {
+  BaseVersionError
+} from "./chunk-3AKDKIIQ.js";
+import {
+  init_esm_shims
+} from "./chunk-NOZSTVTV.js";
+
+// ../version/dist/baseError-DQHIJACF.js
+init_esm_shims();
+export {
+  BaseVersionError
+};

package/dist/chunk-275AVVZE.js

@@ -0,0 +1,382 @@
+import {
+  init_esm_shims
+} from "./chunk-NOZSTVTV.js";
+
+// ../notes/dist/chunk-7TJSPQPW.js
+init_esm_shims();
+import chalk from "chalk";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var PREFIXES = {
+  error: "[ERROR]",
+  warn: "[WARN]",
+  info: "[INFO]",
+  debug: "[DEBUG]",
+  trace: "[TRACE]"
+};
+var COLORS = {
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.blue,
+  debug: chalk.gray,
+  trace: chalk.dim
+};
+var currentLevel = "info";
+var quietMode = false;
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setQuietMode(quiet) {
+  quietMode = quiet;
+}
+function shouldLog(level) {
+  if (quietMode && level !== "error") return false;
+  return LOG_LEVELS[level] <= LOG_LEVELS[currentLevel];
+}
+function log(message, level = "info") {
+  if (!shouldLog(level)) return;
+  const formatted = COLORS[level](`${PREFIXES[level]} ${message}`);
+  console.error(formatted);
+}
+function error(message) {
+  log(message, "error");
+}
+function warn(message) {
+  log(message, "warn");
+}
+function info(message) {
+  log(message, "info");
+}
+function success(message) {
+  if (!shouldLog("info")) return;
+  console.error(chalk.green(`[SUCCESS] ${message}`));
+}
+function debug(message) {
+  log(message, "debug");
+}
+var ReleaseKitError = class _ReleaseKitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+  logError() {
+    log(this.message, "error");
+    if (this.suggestions.length > 0) {
+      log("\nSuggested solutions:", "info");
+      for (const [i, suggestion] of this.suggestions.entries()) {
+        log(`${i + 1}. ${suggestion}`, "info");
+      }
+    }
+  }
+  static isReleaseKitError(error2) {
+    return error2 instanceof _ReleaseKitError;
+  }
+};
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  CONFIG_ERROR: 2,
+  INPUT_ERROR: 3,
+  TEMPLATE_ERROR: 4,
+  LLM_ERROR: 5,
+  GITHUB_ERROR: 6,
+  GIT_ERROR: 7,
+  VERSION_ERROR: 8,
+  PUBLISH_ERROR: 9
+};
+var TYPE_ORDER = ["added", "changed", "deprecated", "removed", "fixed", "security"];
+var TYPE_LABELS = {
+  added: "Added",
+  changed: "Changed",
+  deprecated: "Deprecated",
+  removed: "Removed",
+  fixed: "Fixed",
+  security: "Security"
+};
+function groupEntriesByType(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const type of TYPE_ORDER) {
+    grouped.set(type, []);
+  }
+  for (const entry of entries) {
+    const existing = grouped.get(entry.type) ?? [];
+    existing.push(entry);
+    grouped.set(entry.type, existing);
+  }
+  return grouped;
+}
+function formatEntry(entry) {
+  let line;
+  if (entry.breaking && entry.scope) {
+    line = `- **BREAKING** **${entry.scope}**: ${entry.description}`;
+  } else if (entry.breaking) {
+    line = `- **BREAKING** ${entry.description}`;
+  } else if (entry.scope) {
+    line = `- **${entry.scope}**: ${entry.description}`;
+  } else {
+    line = `- ${entry.description}`;
+  }
+  if (entry.issueIds && entry.issueIds.length > 0) {
+    line += ` (${entry.issueIds.join(", ")})`;
+  }
+  return line;
+}
+function formatVersion(context, options) {
+  const lines = [];
+  const versionLabel = options?.includePackageName && context.packageName ? `${context.packageName}@${context.version}` : context.version;
+  const versionHeader = context.previousVersion ? `## [${versionLabel}]` : `## ${versionLabel}`;
+  lines.push(`${versionHeader} - ${context.date}`);
+  lines.push("");
+  if (context.compareUrl) {
+    lines.push(`[Full Changelog](${context.compareUrl})`);
+    lines.push("");
+  }
+  if (context.enhanced?.summary) {
+    lines.push(context.enhanced.summary);
+    lines.push("");
+  }
+  const grouped = groupEntriesByType(context.entries);
+  for (const [type, entries] of grouped) {
+    if (entries.length === 0) continue;
+    lines.push(`### ${TYPE_LABELS[type]}`);
+    for (const entry of entries) {
+      lines.push(formatEntry(entry));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatHeader() {
+  return `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+`;
+}
+function renderMarkdown(contexts, options) {
+  const sections = [formatHeader()];
+  for (const context of contexts) {
+    sections.push(formatVersion(context, options));
+  }
+  return sections.join("\n");
+}
+function prependVersion(existingPath, context, options) {
+  let existing = "";
+  if (fs2.existsSync(existingPath)) {
+    existing = fs2.readFileSync(existingPath, "utf-8");
+    const headerEnd = existing.indexOf("\n## ");
+    if (headerEnd >= 0) {
+      const header = existing.slice(0, headerEnd);
+      const body = existing.slice(headerEnd + 1);
+      const newVersion = formatVersion(context, options);
+      return `${header}
+
+${newVersion}
+${body}`;
+    }
+  }
+  return renderMarkdown([context]);
+}
+function writeMarkdown(outputPath, contexts, config, dryRun, options) {
+  const content = renderMarkdown(contexts, options);
+  const label = /changelog/i.test(outputPath) ? "Changelog" : "Release notes";
+  if (dryRun) {
+    info(`[DRY RUN] ${label} preview (would write to ${outputPath}):`);
+    info(content);
+    return;
+  }
+  const dir = path2.dirname(outputPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  if (outputPath === "-") {
+    process.stdout.write(content);
+    return;
+  }
+  if (config.updateStrategy !== "regenerate" && fs2.existsSync(outputPath) && contexts.length === 1) {
+    const firstContext = contexts[0];
+    if (firstContext) {
+      const updated = prependVersion(outputPath, firstContext, options);
+      fs2.writeFileSync(outputPath, updated, "utf-8");
+    }
+  } else {
+    fs2.writeFileSync(outputPath, content, "utf-8");
+  }
+  success(`${label} written to ${outputPath}`);
+}
+
+// ../notes/dist/chunk-F7MUVHZ2.js
+init_esm_shims();
+import * as fs from "fs";
+import * as path from "path";
+function splitByPackage(contexts) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    byPackage.set(ctx.packageName, ctx);
+  }
+  return byPackage;
+}
+function writeFile(outputPath, content, dryRun) {
+  if (dryRun) {
+    info(`Would write to ${outputPath}`);
+    debug(content);
+    return false;
+  }
+  const dir = path.dirname(outputPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(outputPath, content, "utf-8");
+  success(`Changelog written to ${outputPath}`);
+  return true;
+}
+function aggregateToRoot(contexts) {
+  const aggregated = {
+    packageName: "monorepo",
+    version: contexts[0]?.version ?? "0.0.0",
+    previousVersion: contexts[0]?.previousVersion ?? null,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+    repoUrl: contexts[0]?.repoUrl ?? null,
+    entries: []
+  };
+  for (const ctx of contexts) {
+    for (const entry of ctx.entries) {
+      aggregated.entries.push({
+        ...entry,
+        scope: entry.scope ? `${ctx.packageName}/${entry.scope}` : ctx.packageName
+      });
+    }
+  }
+  return aggregated;
+}
+function writeMonorepoChangelogs(contexts, options, config, dryRun) {
+  const files = [];
+  if (options.mode === "root" || options.mode === "both") {
+    const rootPath = path.join(options.rootPath, options.fileName ?? "CHANGELOG.md");
+    const fmtOpts = { includePackageName: true };
+    info(`Writing root changelog to ${rootPath}`);
+    let rootContent;
+    if (config.updateStrategy !== "regenerate" && fs.existsSync(rootPath)) {
+      const newSections = contexts.map((ctx) => formatVersion(ctx, fmtOpts)).join("\n");
+      const existing = fs.readFileSync(rootPath, "utf-8");
+      const headerEnd = existing.indexOf("\n## ");
+      if (headerEnd >= 0) {
+        rootContent = `${existing.slice(0, headerEnd)}
+
+${newSections}
+${existing.slice(headerEnd + 1)}`;
+      } else {
+        rootContent = renderMarkdown(contexts, fmtOpts);
+      }
+    } else {
+      rootContent = renderMarkdown(contexts, fmtOpts);
+    }
+    if (writeFile(rootPath, rootContent, dryRun)) {
+      files.push(rootPath);
+    }
+  }
+  if (options.mode === "packages" || options.mode === "both") {
+    const byPackage = splitByPackage(contexts);
+    const packageDirMap = buildPackageDirMap(options.rootPath, options.packagesPath);
+    for (const [packageName, ctx] of byPackage) {
+      const simpleName = packageName.split("/").pop();
+      const packageDir = packageDirMap.get(packageName) ?? (simpleName ? packageDirMap.get(simpleName) : void 0) ?? null;
+      if (packageDir) {
+        const changelogPath = path.join(packageDir, options.fileName ?? "CHANGELOG.md");
+        info(`Writing changelog for ${packageName} to ${changelogPath}`);
+        const pkgContent = config.updateStrategy !== "regenerate" && fs.existsSync(changelogPath) ? prependVersion(changelogPath, ctx) : renderMarkdown([ctx]);
+        if (writeFile(changelogPath, pkgContent, dryRun)) {
+          files.push(changelogPath);
+        }
+      } else {
+        info(`Could not find directory for package ${packageName}, skipping`);
+      }
+    }
+  }
+  return files;
+}
+function buildPackageDirMap(rootPath, packagesPath) {
+  const map = /* @__PURE__ */ new Map();
+  const packagesDir = path.join(rootPath, packagesPath);
+  if (!fs.existsSync(packagesDir)) {
+    return map;
+  }
+  for (const entry of fs.readdirSync(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dirPath = path.join(packagesDir, entry.name);
+    map.set(entry.name, dirPath);
+    const packageJsonPath = path.join(dirPath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        if (pkg.name) {
+          map.set(pkg.name, dirPath);
+        }
+      } catch {
+      }
+    }
+  }
+  return map;
+}
+function detectMonorepo(cwd) {
+  const pnpmWorkspacesPath = path.join(cwd, "pnpm-workspace.yaml");
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pnpmWorkspacesPath)) {
+    const content = fs.readFileSync(pnpmWorkspacesPath, "utf-8");
+    const packagesMatch = content.match(/packages:\s*\n\s*-\s*['"]([^'"]+)['"]/);
+    if (packagesMatch?.[1]) {
+      const packagesGlob = packagesMatch[1];
+      const packagesPath = packagesGlob.replace(/\/?\*$/, "").replace(/\/\*\*$/, "");
+      return { isMonorepo: true, packagesPath: packagesPath || "packages" };
+    }
+    return { isMonorepo: true, packagesPath: "packages" };
+  }
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const content = fs.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.workspaces) {
+        const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages;
+        if (workspaces?.length) {
+          const firstWorkspace = workspaces[0];
+          if (firstWorkspace) {
+            const packagesPath = firstWorkspace.replace(/\/?\*$/, "").replace(/\/\*\*$/, "");
+            return { isMonorepo: true, packagesPath: packagesPath || "packages" };
+          }
+        }
+      }
+    } catch {
+      return { isMonorepo: false, packagesPath: "" };
+    }
+  }
+  return { isMonorepo: false, packagesPath: "" };
+}
+
+export {
+  setLogLevel,
+  setQuietMode,
+  error,
+  warn,
+  info,
+  success,
+  debug,
+  ReleaseKitError,
+  EXIT_CODES,
+  formatVersion,
+  renderMarkdown,
+  writeMarkdown,
+  splitByPackage,
+  aggregateToRoot,
+  writeMonorepoChangelogs,
+  detectMonorepo
+};

package/dist/chunk-3AKDKIIQ.js

@@ -0,0 +1,78 @@
+import {
+  init_esm_shims
+} from "./chunk-NOZSTVTV.js";
+
+// ../version/dist/chunk-Q3FHZORY.js
+init_esm_shims();
+import chalk from "chalk";
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var PREFIXES = {
+  error: "[ERROR]",
+  warn: "[WARN]",
+  info: "[INFO]",
+  debug: "[DEBUG]",
+  trace: "[TRACE]"
+};
+var COLORS = {
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.blue,
+  debug: chalk.gray,
+  trace: chalk.dim
+};
+var currentLevel = "info";
+var quietMode = false;
+function shouldLog(level) {
+  if (quietMode && level !== "error") return false;
+  return LOG_LEVELS[level] <= LOG_LEVELS[currentLevel];
+}
+function log(message, level = "info") {
+  if (!shouldLog(level)) return;
+  const formatted = COLORS[level](`${PREFIXES[level]} ${message}`);
+  console.error(formatted);
+}
+var ReleaseKitError = class _ReleaseKitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+  logError() {
+    log(this.message, "error");
+    if (this.suggestions.length > 0) {
+      log("\nSuggested solutions:", "info");
+      for (const [i, suggestion] of this.suggestions.entries()) {
+        log(`${i + 1}. ${suggestion}`, "info");
+      }
+    }
+  }
+  static isReleaseKitError(error2) {
+    return error2 instanceof _ReleaseKitError;
+  }
+};
+function sanitizePackageName(name) {
+  return name.startsWith("@") ? name.slice(1).replace(/\//g, "-") : name;
+}
+var BaseVersionError = class _BaseVersionError extends ReleaseKitError {
+  code;
+  suggestions;
+  constructor(message, code, suggestions) {
+    super(message);
+    this.code = code;
+    this.suggestions = suggestions ?? [];
+  }
+  static isVersionError(error) {
+    return error instanceof _BaseVersionError;
+  }
+};
+
+export {
+  ReleaseKitError,
+  sanitizePackageName,
+  BaseVersionError
+};

package/dist/{chunk-D6HRZXZZ.js → chunk-6UI4L62T.js}

@@ -1,4 +1,9 @@
+import {
+  init_esm_shims
+} from "./chunk-NOZSTVTV.js";
+
 // ../core/dist/index.js
+init_esm_shims();
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
@@ -98,19 +103,19 @@ var EXIT_CODES = {
 };
 
 // src/release.ts
+init_esm_shims();
 import { execSync } from "child_process";
 
 // ../config/dist/index.js
-import * as fs2 from "fs";
-import * as path2 from "path";
+init_esm_shims();
 import * as TOML from "smol-toml";
 import * as fs3 from "fs";
 import * as path3 from "path";
 import { z as z2 } from "zod";
 import { z } from "zod";
-import * as fs22 from "fs";
+import * as fs2 from "fs";
 import * as os from "os";
-import * as path22 from "path";
+import * as path2 from "path";
 var ConfigError = class extends ReleaseKitError {
   code = "CONFIG_ERROR";
   suggestions;
@@ -434,9 +439,9 @@ function substituteVariables(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path22.join(os.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path2.join(os.homedir(), filePath.slice(1)) : filePath;
     try {
-      return fs22.readFileSync(expandedPath, "utf-8").trim();
+      return fs2.readFileSync(expandedPath, "utf-8").trim();
     } catch {
       return "";
     }
@@ -464,8 +469,8 @@ function substituteInObject(obj) {
   }
   return obj;
 }
-var AUTH_DIR = path22.join(os.homedir(), ".config", "releasekit");
-var AUTH_FILE = path22.join(AUTH_DIR, "auth.json");
+var AUTH_DIR = path2.join(os.homedir(), ".config", "releasekit");
+var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
 var CONFIG_FILE = "releasekit.config.json";
 function loadConfigFile(configPath) {
   if (!fs3.existsSync(configPath)) {
@@ -557,7 +562,7 @@ async function runRelease(inputOptions) {
     return null;
   }
   if (!options.dryRun) {
-    const { flushPendingWrites } = await import("@releasekit/version");
+    const { flushPendingWrites } = await import("./dist-7RSHM4ZO.js");
     flushPendingWrites();
   }
   info(`Found ${versionOutput.updates.length} package update(s)`);
@@ -586,7 +591,7 @@ async function runRelease(inputOptions) {
   return { versionOutput, notesGenerated, packageNotes, releaseNotes, publishOutput };
 }
 async function runVersionStep(options) {
-  const { loadConfig: loadConfig2, VersionEngine, enableJsonOutput, getJsonData } = await import("@releasekit/version");
+  const { loadConfig: loadConfig2, VersionEngine, enableJsonOutput, getJsonData } = await import("./dist-7RSHM4ZO.js");
   enableJsonOutput(options.dryRun);
   const config = loadConfig2({ cwd: options.projectDir, configPath: options.config });
   if (options.dryRun) config.dryRun = true;
@@ -619,14 +624,14 @@ async function runVersionStep(options) {
   return getJsonData();
 }
 async function runNotesStep(versionOutput, options) {
-  const { parseVersionOutput, runPipeline, loadConfig: loadConfig2 } = await import("@releasekit/notes");
+  const { parseVersionOutput, runPipeline, loadConfig: loadConfig2 } = await import("./dist-HVRDLODI.js");
   const config = loadConfig2(options.projectDir, options.config);
   const input = parseVersionOutput(JSON.stringify(versionOutput));
   const result = await runPipeline(input, config, options.dryRun);
   return { packageNotes: result.packageNotes, releaseNotes: result.releaseNotes, files: result.files };
 }
 async function runPublishStep(versionOutput, options, releaseNotes, additionalFiles) {
-  const { runPipeline, loadConfig: loadConfig2 } = await import("@releasekit/publish");
+  const { runPipeline, loadConfig: loadConfig2 } = await import("./dist-4RETAAT2.js");
   const config = loadConfig2({ configPath: options.config });
   if (options.branch) {
     config.git.branch = options.branch;
@@ -647,7 +652,11 @@ async function runPublishStep(versionOutput, options, releaseNotes, additionalFi
   return runPipeline(versionOutput, config, publishOptions);
 }
 
+// src/preview.ts
+init_esm_shims();
+
 // src/preview-context.ts
+init_esm_shims();
 import * as fs4 from "fs";
 function resolvePreviewContext(opts) {
   const token = process.env.GITHUB_TOKEN;
@@ -691,6 +700,7 @@ function resolveRepo(cliValue) {
 }
 
 // src/preview-detect.ts
+init_esm_shims();
 import * as fs5 from "fs";
 import * as path4 from "path";
 function detectPrerelease(packagePaths, projectDir) {
@@ -716,6 +726,7 @@ function parsePrerelease(version) {
 }
 
 // src/preview-format.ts
+init_esm_shims();
 var MARKER = "<!-- releasekit-preview -->";
 var FOOTER = "*Updated automatically by [ReleaseKit](https://github.com/goosewobbler/releasekit)*";
 var TYPE_LABELS = {
@@ -886,6 +897,7 @@ function capitalize(str) {
 }
 
 // src/preview-github.ts
+init_esm_shims();
 import { Octokit } from "@octokit/rest";
 function createOctokit(token) {
   return new Octokit({ auth: token });

package/dist/{chunk-ALHJU3KL.js → chunk-FEMWVXXM.js}

@@ -2,9 +2,13 @@ import {
   EXIT_CODES,
   runPreview,
   runRelease
-} from "./chunk-D6HRZXZZ.js";
+} from "./chunk-6UI4L62T.js";
+import {
+  init_esm_shims
+} from "./chunk-NOZSTVTV.js";
 
 // src/preview-command.ts
+init_esm_shims();
 import { Command } from "commander";
 function createPreviewCommand() {
   return new Command("preview").description("Post a release preview comment on the current pull request").option("-c, --config <path>", "Path to config file").option("--project-dir <path>", "Project directory", process.cwd()).option("--pr <number>", "PR number (auto-detected from GitHub Actions)").option("--repo <owner/repo>", "Repository (auto-detected from GITHUB_REPOSITORY)").option("-p, --prerelease [identifier]", "Force prerelease preview (auto-detected by default)").option("--stable", "Force stable release preview (graduation from prerelease)", false).option(
@@ -30,6 +34,7 @@ function createPreviewCommand() {
 }
 
 // src/release-command.ts
+init_esm_shims();
 import { Command as Command2, Option } from "commander";
 function createReleaseCommand() {
   return new Command2("release").description("Run the full release pipeline").option("-c, --config <path>", "Path to config file").option("-d, --dry-run", "Preview all steps without side effects", false).option("-b, --bump <type>", "Force bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --sync", "Use synchronized versioning across all packages", false).option("-t, --target <packages>", "Target specific packages (comma-separated)").option("--branch <name>", "Override the git branch used for push").addOption(new Option("--npm-auth <method>", "NPM auth method").choices(["auto", "oidc", "token"]).default("auto")).option("--skip-notes", "Skip changelog generation", false).option("--skip-publish", "Skip registry publishing and git operations", false).option("--skip-git", "Skip git commit/tag/push", false).option("--skip-github-release", "Skip GitHub release creation", false).option("--skip-verification", "Skip post-publish verification", false).option("-j, --json", "Output results as JSON", false).option("-v, --verbose", "Verbose logging", false).option("-q, --quiet", "Suppress non-error output", false).option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {

package/dist/chunk-NOZSTVTV.js

@@ -0,0 +1,55 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  __dirname,
+  init_esm_shims
+};