@releasekit/release 0.7.11 → 0.7.13

package/dist/chunk-QGM4M3NI.js

@@ -0,0 +1,37 @@
+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 __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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-X6K5NWRA.js

@@ -0,0 +1,376 @@
+// ../notes/dist/chunk-7TJSPQPW.js
+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
+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/cli.js

@@ -2,10 +2,11 @@
 import {
   createPreviewCommand,
   createReleaseCommand
-} from "./chunk-ALHJU3KL.js";
+} from "./chunk-6PUHZHPR.js";
 import {
   readPackageVersion
-} from "./chunk-D6HRZXZZ.js";
+} from "./chunk-LTPOKPAP.js";
+import "./chunk-QGM4M3NI.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";

package/dist/commandExecutor-E44ID5U4-ZQZNV25N.js

@@ -0,0 +1,9 @@
+import {
+  execAsync,
+  execSync
+} from "./chunk-FM2YXFEQ.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  execAsync,
+  execSync
+};

package/dist/dispatcher.js

@@ -1,27 +1,39 @@
 #!/usr/bin/env node
+import {
+  createNotesCommand
+} from "./chunk-BLLATA3P.js";
+import {
+  detectMonorepo
+} from "./chunk-X6K5NWRA.js";
+import {
+  createPublishCommand
+} from "./chunk-OOW3QGRT.js";
 import {
   createPreviewCommand,
   createReleaseCommand
-} from "./chunk-ALHJU3KL.js";
+} from "./chunk-6PUHZHPR.js";
 import {
   EXIT_CODES,
   error,
   info,
   readPackageVersion,
   success
-} from "./chunk-D6HRZXZZ.js";
+} from "./chunk-LTPOKPAP.js";
+import {
+  createVersionCommand
+} from "./chunk-MKXM4ZCM.js";
+import "./chunk-PJO2QZSV.js";
+import "./chunk-FM2YXFEQ.js";
+import "./chunk-HW3BIMUI.js";
+import "./chunk-QGM4M3NI.js";
 
 // src/dispatcher.ts
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
-import { createNotesCommand } from "@releasekit/notes/cli";
-import { createPublishCommand } from "@releasekit/publish/cli";
-import { createVersionCommand } from "@releasekit/version/cli";
 import { Command as Command2 } from "commander";
 
 // src/init-command.ts
 import * as fs from "fs";
-import { detectMonorepo } from "@releasekit/notes";
 import { Command } from "commander";
 function createInitCommand() {
   return new Command("init").description("Create a default releasekit.config.json").option("-f, --force", "Overwrite existing config").action((options) => {

package/dist/dist-3OF3AQKY.js

@@ -0,0 +1,37 @@
+import {
+  PackageProcessor,
+  VersionEngine,
+  VersionErrorCode,
+  calculateVersion,
+  createAsyncStrategy,
+  createSingleStrategy,
+  createSyncStrategy,
+  createVersionCommand,
+  createVersionError,
+  enableJsonOutput,
+  flushPendingWrites,
+  getJsonData,
+  loadConfig2
+} from "./chunk-MKXM4ZCM.js";
+import "./chunk-PJO2QZSV.js";
+import "./chunk-FM2YXFEQ.js";
+import {
+  BaseVersionError
+} from "./chunk-HW3BIMUI.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  BaseVersionError,
+  PackageProcessor,
+  VersionEngine,
+  VersionErrorCode,
+  calculateVersion,
+  createAsyncStrategy,
+  createSingleStrategy,
+  createSyncStrategy,
+  createVersionCommand,
+  createVersionError,
+  enableJsonOutput,
+  flushPendingWrites,
+  getJsonData,
+  loadConfig2 as loadConfig
+};

package/dist/dist-J7662OKQ.js

@@ -0,0 +1,104 @@
+import "./chunk-QGM4M3NI.js";
+
+// ../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/utils.js
+function isMatch(object, source) {
+  let aValue;
+  let bValue;
+  for (const key in source) {
+    aValue = object[key];
+    bValue = source[key];
+    if (typeof aValue === "string") {
+      aValue = aValue.trim();
+    }
+    if (typeof bValue === "string") {
+      bValue = bValue.trim();
+    }
+    if (aValue !== bValue) {
+      return false;
+    }
+  }
+  return true;
+}
+function findRevertCommit(commit, reverts) {
+  if (!reverts.size) {
+    return null;
+  }
+  const rawCommit = commit.raw || commit;
+  for (const revertCommit of reverts) {
+    if (revertCommit.revert && isMatch(rawCommit, revertCommit.revert)) {
+      return revertCommit;
+    }
+  }
+  return null;
+}
+
+// ../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/RevertedCommitsFilter.js
+var RevertedCommitsFilter = class {
+  hold = /* @__PURE__ */ new Set();
+  holdRevertsCount = 0;
+  /**
+   * Process commit to filter reverted commits
+   * @param commit
+   * @yields Commit
+   */
+  *process(commit) {
+    const { hold } = this;
+    const revertCommit = findRevertCommit(commit, hold);
+    if (revertCommit) {
+      hold.delete(revertCommit);
+      this.holdRevertsCount--;
+      return;
+    }
+    if (commit.revert) {
+      hold.add(commit);
+      this.holdRevertsCount++;
+      return;
+    }
+    if (this.holdRevertsCount > 0) {
+      hold.add(commit);
+    } else {
+      if (hold.size) {
+        yield* hold;
+        hold.clear();
+      }
+      yield commit;
+    }
+  }
+  /**
+   * Flush all held commits
+   * @yields Held commits
+   */
+  *flush() {
+    const { hold } = this;
+    if (hold.size) {
+      yield* hold;
+      hold.clear();
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/filters.js
+import { Transform } from "stream";
+async function* filterRevertedCommits(commits) {
+  const filter = new RevertedCommitsFilter();
+  for await (const commit of commits) {
+    yield* filter.process(commit);
+  }
+  yield* filter.flush();
+}
+function* filterRevertedCommitsSync(commits) {
+  const filter = new RevertedCommitsFilter();
+  for (const commit of commits) {
+    yield* filter.process(commit);
+  }
+  yield* filter.flush();
+}
+function filterRevertedCommitsStream() {
+  return Transform.from(filterRevertedCommits);
+}
+export {
+  RevertedCommitsFilter,
+  filterRevertedCommits,
+  filterRevertedCommitsStream,
+  filterRevertedCommitsSync
+};

package/dist/dist-KJOL5QEY.js

@@ -0,0 +1,59 @@
+import {
+  ConfigError2,
+  GitHubError,
+  InputParseError,
+  LLMError,
+  NotesError,
+  TemplateError,
+  createNotesCommand,
+  createTemplateContext,
+  getDefaultConfig,
+  getExitCode,
+  loadAuth,
+  loadConfig2,
+  parseVersionOutput,
+  parseVersionOutputFile,
+  parseVersionOutputStdin,
+  processInput,
+  renderJson,
+  runPipeline,
+  saveAuth,
+  writeJson
+} from "./chunk-BLLATA3P.js";
+import {
+  aggregateToRoot,
+  detectMonorepo,
+  formatVersion,
+  renderMarkdown,
+  writeMarkdown,
+  writeMonorepoChangelogs
+} from "./chunk-X6K5NWRA.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  ConfigError2 as ConfigError,
+  GitHubError,
+  InputParseError,
+  LLMError,
+  NotesError,
+  TemplateError,
+  aggregateToRoot,
+  createNotesCommand,
+  createTemplateContext,
+  detectMonorepo,
+  formatVersion,
+  getDefaultConfig,
+  getExitCode,
+  loadAuth,
+  loadConfig2 as loadConfig,
+  parseVersionOutput,
+  parseVersionOutputFile,
+  parseVersionOutputStdin,
+  processInput,
+  renderJson,
+  renderMarkdown,
+  runPipeline,
+  saveAuth,
+  writeJson,
+  writeMarkdown,
+  writeMonorepoChangelogs
+};