@releasekit/notes 0.2.0-next.9 → 0.3.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sam Maister
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @releasekit/notes
 
-Changelog generation with LLM-powered enhancement and flexible templating.
+Release notes and changelog generation from conventional commits with LLM-powered enhancement and flexible templating
 
 ## Features
 

package/dist/aggregator-BDTUZWOA.js

@@ -0,0 +1,13 @@
+import {
+  aggregateToRoot,
+  detectMonorepo,
+  splitByPackage,
+  writeMonorepoChangelogs
+} from "./chunk-O4VCGEZT.js";
+import "./chunk-H7G2HRHI.js";
+export {
+  aggregateToRoot,
+  detectMonorepo,
+  splitByPackage,
+  writeMonorepoChangelogs
+};

package/dist/chunk-H7G2HRHI.js

@@ -0,0 +1,134 @@
+// src/output/markdown.ts
+import * as fs from "fs";
+import * as path from "path";
+import { debug, info, success } from "@releasekit/core";
+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) {
+  const lines = [];
+  const versionHeader = context.previousVersion ? `## [${context.version}]` : `## ${context.version}`;
+  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) {
+  const sections = [formatHeader()];
+  for (const context of contexts) {
+    sections.push(formatVersion(context));
+  }
+  return sections.join("\n");
+}
+function prependVersion(existingPath, context) {
+  let existing = "";
+  if (fs.existsSync(existingPath)) {
+    existing = fs.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);
+      return `${header}
+
+${newVersion}
+${body}`;
+    }
+  }
+  return renderMarkdown([context]);
+}
+function writeMarkdown(outputPath, contexts, config, dryRun) {
+  const content = renderMarkdown(contexts);
+  if (dryRun) {
+    info(`Would write changelog to ${outputPath}`);
+    debug("--- Changelog Preview ---");
+    debug(content);
+    debug("--- End Preview ---");
+    return;
+  }
+  const dir = path.dirname(outputPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  if (outputPath === "-") {
+    process.stdout.write(content);
+    return;
+  }
+  if (config.updateStrategy === "prepend" && fs.existsSync(outputPath) && contexts.length === 1) {
+    const firstContext = contexts[0];
+    if (firstContext) {
+      const updated = prependVersion(outputPath, firstContext);
+      fs.writeFileSync(outputPath, updated, "utf-8");
+    }
+  } else {
+    fs.writeFileSync(outputPath, content, "utf-8");
+  }
+  success(`Changelog written to ${outputPath}`);
+}
+
+export {
+  formatVersion,
+  renderMarkdown,
+  prependVersion,
+  writeMarkdown
+};

package/dist/chunk-O4VCGEZT.js

@@ -0,0 +1,147 @@
+import {
+  prependVersion,
+  renderMarkdown
+} from "./chunk-H7G2HRHI.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) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    byPackage.set(ctx.packageName, ctx);
+  }
+  return byPackage;
+}
+
+// src/monorepo/aggregator.ts
+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 aggregated = aggregateToRoot(contexts);
+    const rootPath = path.join(options.rootPath, "CHANGELOG.md");
+    info(`Writing root changelog to ${rootPath}`);
+    const rootContent = config.updateStrategy === "prepend" && fs.existsSync(rootPath) ? prependVersion(rootPath, aggregated) : renderMarkdown([aggregated]);
+    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, "CHANGELOG.md");
+        info(`Writing changelog for ${packageName} to ${changelogPath}`);
+        const pkgContent = config.updateStrategy === "prepend" && 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 {
+  splitByPackage,
+  aggregateToRoot,
+  writeMonorepoChangelogs,
+  detectMonorepo
+};