@releasekit/notes 0.3.0-next.4 → 0.3.1

package/README.md

@@ -19,6 +19,8 @@ npm install -g @releasekit/notes
 pnpm add -g @releasekit/notes
 ```
 
+> **Note:** This package is ESM only and requires Node.js 20+.
+
 ## Quick Start
 
 ```bash

package/dist/{aggregator-JZ3VUZKP.js → aggregator-XJ2EILO3.js}

@@ -3,8 +3,8 @@ import {
   detectMonorepo,
   splitByPackage,
   writeMonorepoChangelogs
-} from "./chunk-TSLTZ26C.js";
-import "./chunk-QCF6V2IY.js";
+} from "./chunk-DCQ32FVH.js";
+import "./chunk-E4454SIS.js";
 export {
   aggregateToRoot,
   detectMonorepo,

package/dist/{chunk-TSLTZ26C.js → chunk-DCQ32FVH.js}

@@ -1,13 +1,15 @@
 import {
+  debug,
   formatVersion,
+  info,
   prependVersion,
-  renderMarkdown
-} from "./chunk-QCF6V2IY.js";
+  renderMarkdown,
+  success
+} from "./chunk-E4454SIS.js";
 
 // src/monorepo/aggregator.ts
 import * as fs from "fs";
 import * as path from "path";
-import { debug, info, success } from "@releasekit/core";
 
 // src/monorepo/splitter.ts
 function splitByPackage(contexts) {

package/dist/chunk-E4454SIS.js

@@ -0,0 +1,243 @@
+// ../core/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+function readPackageVersion(importMetaUrl) {
+  try {
+    const dir = path.dirname(fileURLToPath(importMetaUrl));
+    const packageJsonPath = path.resolve(dir, "../package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+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
+};
+
+// src/output/markdown.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+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 === "prepend" && 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}`);
+}
+
+export {
+  readPackageVersion,
+  setLogLevel,
+  setQuietMode,
+  error,
+  warn,
+  info,
+  success,
+  debug,
+  ReleaseKitError,
+  EXIT_CODES,
+  formatVersion,
+  renderMarkdown,
+  prependVersion,
+  writeMarkdown
+};