@releasekit/notes 0.2.0 → 0.3.0-next.0

package/dist/{chunk-DGZ6TM5J.js → chunk-X4LY5WGG.js}

@@ -1,3 +1,9 @@
+import {
+  formatVersion,
+  renderMarkdown,
+  writeMarkdown
+} from "./chunk-H7G2HRHI.js";
+
 // src/core/config.ts
 import {
   loadAuth,
@@ -145,138 +151,10 @@ async function parsePackageVersionerStdin() {
   return parsePackageVersioner(content);
 }
 
-// src/output/markdown.ts
+// src/output/json.ts
 import * as fs2 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 (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);
-      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 (!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);
-      fs2.writeFileSync(outputPath, updated, "utf-8");
-    }
-  } else {
-    fs2.writeFileSync(outputPath, content, "utf-8");
-  }
-  success(`Changelog written to ${outputPath}`);
-}
-
-// src/output/json.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { debug as debug2, info as info2, success as success2 } from "@releasekit/core";
 function renderJson(contexts) {
   return JSON.stringify(
     {
@@ -296,24 +174,24 @@ function renderJson(contexts) {
 function writeJson(outputPath, contexts, dryRun) {
   const content = renderJson(contexts);
   if (dryRun) {
-    info2(`Would write JSON output to ${outputPath}`);
-    debug2("--- JSON Output Preview ---");
-    debug2(content);
-    debug2("--- End Preview ---");
+    info(`Would write JSON output to ${outputPath}`);
+    debug("--- JSON Output Preview ---");
+    debug(content);
+    debug("--- End Preview ---");
     return;
   }
-  const dir = path2.dirname(outputPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const dir = path.dirname(outputPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs3.writeFileSync(outputPath, content, "utf-8");
-  success2(`JSON output written to ${outputPath}`);
+  fs2.writeFileSync(outputPath, content, "utf-8");
+  success(`JSON output written to ${outputPath}`);
 }
 
 // src/core/pipeline.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
-import { debug as debug3, info as info4, success as success4, warn as warn3 } from "@releasekit/core";
+import * as fs7 from "fs";
+import * as path5 from "path";
+import { debug as debug2, info as info3, success as success3, warn as warn3 } from "@releasekit/core";
 
 // src/llm/defaults.ts
 var LLM_DEFAULTS = {
@@ -949,7 +827,7 @@ function createProvider(config) {
 
 // src/output/github-release.ts
 import { Octokit } from "@octokit/rest";
-import { info as info3, success as success3 } from "@releasekit/core";
+import { info as info2, success as success2 } from "@releasekit/core";
 var GitHubClient = class {
   octokit;
   owner;
@@ -971,7 +849,7 @@ var GitHubClient = class {
     } else {
       body = renderMarkdown([context]);
     }
-    info3(`Creating GitHub release for ${tagName}`);
+    info2(`Creating GitHub release for ${tagName}`);
     try {
       const response = await this.octokit.repos.createRelease({
         owner: this.owner,
@@ -983,7 +861,7 @@ var GitHubClient = class {
         prerelease: options.prerelease ?? false,
         generate_release_notes: options.generateNotes ?? false
       });
-      success3(`Release created: ${response.data.html_url}`);
+      success2(`Release created: ${response.data.html_url}`);
       return {
         id: response.data.id,
         htmlUrl: response.data.html_url,
@@ -1001,7 +879,7 @@ var GitHubClient = class {
     } else {
       body = renderMarkdown([context]);
     }
-    info3(`Updating GitHub release ${releaseId}`);
+    info2(`Updating GitHub release ${releaseId}`);
     try {
       const response = await this.octokit.repos.updateRelease({
         owner: this.owner,
@@ -1013,7 +891,7 @@ var GitHubClient = class {
         draft: options.draft ?? false,
         prerelease: options.prerelease ?? false
       });
-      success3(`Release updated: ${response.data.html_url}`);
+      success2(`Release updated: ${response.data.html_url}`);
       return {
         id: response.data.id,
         htmlUrl: response.data.html_url,
@@ -1063,7 +941,7 @@ async function createGitHubRelease(context, options) {
 }
 
 // src/templates/ejs.ts
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 import ejs from "ejs";
 function renderEjs(template, context) {
   try {
@@ -1073,16 +951,16 @@ function renderEjs(template, context) {
   }
 }
 function renderEjsFile(filePath, context) {
-  if (!fs4.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs4.readFileSync(filePath, "utf-8");
+  const template = fs3.readFileSync(filePath, "utf-8");
   return renderEjs(template, context);
 }
 
 // src/templates/handlebars.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path2 from "path";
 import Handlebars from "handlebars";
 function registerHandlebarsHelpers() {
   Handlebars.registerHelper("capitalize", (str) => {
@@ -1108,28 +986,28 @@ function renderHandlebars(template, context) {
   }
 }
 function renderHandlebarsFile(filePath, context) {
-  if (!fs5.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs5.readFileSync(filePath, "utf-8");
+  const template = fs4.readFileSync(filePath, "utf-8");
   return renderHandlebars(template, context);
 }
 function renderHandlebarsComposable(templateDir, context) {
   registerHandlebarsHelpers();
-  const versionPath = path3.join(templateDir, "version.hbs");
-  const entryPath = path3.join(templateDir, "entry.hbs");
-  const documentPath = path3.join(templateDir, "document.hbs");
-  if (!fs5.existsSync(documentPath)) {
+  const versionPath = path2.join(templateDir, "version.hbs");
+  const entryPath = path2.join(templateDir, "entry.hbs");
+  const documentPath = path2.join(templateDir, "document.hbs");
+  if (!fs4.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${documentPath}`);
   }
-  if (fs5.existsSync(versionPath)) {
-    Handlebars.registerPartial("version", fs5.readFileSync(versionPath, "utf-8"));
+  if (fs4.existsSync(versionPath)) {
+    Handlebars.registerPartial("version", fs4.readFileSync(versionPath, "utf-8"));
   }
-  if (fs5.existsSync(entryPath)) {
-    Handlebars.registerPartial("entry", fs5.readFileSync(entryPath, "utf-8"));
+  if (fs4.existsSync(entryPath)) {
+    Handlebars.registerPartial("entry", fs4.readFileSync(entryPath, "utf-8"));
   }
   try {
-    const compiled = Handlebars.compile(fs5.readFileSync(documentPath, "utf-8"));
+    const compiled = Handlebars.compile(fs4.readFileSync(documentPath, "utf-8"));
     return compiled(context);
   } catch (error) {
     throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
@@ -1137,8 +1015,8 @@ function renderHandlebarsComposable(templateDir, context) {
 }
 
 // src/templates/liquid.ts
-import * as fs6 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path3 from "path";
 import { Liquid } from "liquidjs";
 function createLiquidEngine(root) {
   return new Liquid({
@@ -1156,15 +1034,15 @@ function renderLiquid(template, context) {
   }
 }
 function renderLiquidFile(filePath, context) {
-  if (!fs6.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs6.readFileSync(filePath, "utf-8");
+  const template = fs5.readFileSync(filePath, "utf-8");
   return renderLiquid(template, context);
 }
 function renderLiquidComposable(templateDir, context) {
-  const documentPath = path4.join(templateDir, "document.liquid");
-  if (!fs6.existsSync(documentPath)) {
+  const documentPath = path3.join(templateDir, "document.liquid");
+  if (!fs5.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${documentPath}`);
   }
   const engine = createLiquidEngine(templateDir);
@@ -1176,10 +1054,10 @@ function renderLiquidComposable(templateDir, context) {
 }
 
 // src/templates/loader.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path4 from "path";
 function getEngineFromFile(filePath) {
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   switch (ext) {
     case ".liquid":
       return "liquid";
@@ -1213,10 +1091,10 @@ function getRenderFileFn(engine) {
   }
 }
 function detectTemplateMode(templatePath) {
-  if (!fs7.existsSync(templatePath)) {
+  if (!fs6.existsSync(templatePath)) {
     throw new TemplateError(`Template path not found: ${templatePath}`);
   }
-  const stat = fs7.statSync(templatePath);
+  const stat = fs6.statSync(templatePath);
   if (stat.isFile()) {
     return "single";
   }
@@ -1234,7 +1112,7 @@ function renderSingleFile(templatePath, context, engine) {
   };
 }
 function renderComposable(templateDir, context, engine) {
-  const files = fs7.readdirSync(templateDir);
+  const files = fs6.readdirSync(templateDir);
   const engineMap = {
     liquid: { document: "document.liquid", version: "version.liquid", entry: "entry.liquid" },
     handlebars: { document: "document.hbs", version: "version.hbs", entry: "entry.hbs" },
@@ -1257,15 +1135,15 @@ function renderComposable(templateDir, context, engine) {
     return { content: renderHandlebarsComposable(templateDir, context), engine: resolvedEngine };
   }
   const expectedFiles = engineMap[resolvedEngine];
-  const documentPath = path5.join(templateDir, expectedFiles.document);
-  if (!fs7.existsSync(documentPath)) {
+  const documentPath = path4.join(templateDir, expectedFiles.document);
+  if (!fs6.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${expectedFiles.document}`);
   }
-  const versionPath = path5.join(templateDir, expectedFiles.version);
-  const entryPath = path5.join(templateDir, expectedFiles.entry);
+  const versionPath = path4.join(templateDir, expectedFiles.version);
+  const entryPath = path4.join(templateDir, expectedFiles.entry);
   const render = getRenderFn(resolvedEngine);
-  const entryTemplate = fs7.existsSync(entryPath) ? fs7.readFileSync(entryPath, "utf-8") : null;
-  const versionTemplate = fs7.existsSync(versionPath) ? fs7.readFileSync(versionPath, "utf-8") : null;
+  const entryTemplate = fs6.existsSync(entryPath) ? fs6.readFileSync(entryPath, "utf-8") : null;
+  const versionTemplate = fs6.existsSync(versionPath) ? fs6.readFileSync(versionPath, "utf-8") : null;
   if (entryTemplate && versionTemplate) {
     const versionsWithEntries = context.versions.map((versionCtx) => {
       const entries = versionCtx.entries.map((entry) => {
@@ -1276,7 +1154,7 @@ function renderComposable(templateDir, context, engine) {
     });
     const docContext = { ...context, renderedVersions: versionsWithEntries };
     return {
-      content: render(fs7.readFileSync(documentPath, "utf-8"), docContext),
+      content: render(fs6.readFileSync(documentPath, "utf-8"), docContext),
       engine: resolvedEngine
     };
   }
@@ -1383,9 +1261,9 @@ async function processWithLLM(context, config) {
     entries: context.entries
   };
   try {
-    info4(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
+    info3(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
     if (config.llm.baseURL) {
-      info4(`LLM base URL: ${config.llm.baseURL}`);
+      info3(`LLM base URL: ${config.llm.baseURL}`);
     }
     const rawProvider = createProvider(config.llm);
     const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
@@ -1394,47 +1272,47 @@ async function processWithLLM(context, config) {
       complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, opts), retryOpts)
     };
     const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
-    info4(`Running LLM tasks: ${activeTasks.join(", ")}`);
+    info3(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance && tasks.categorize) {
-      info4("Enhancing and categorizing entries with LLM...");
+      info3("Enhancing and categorizing entries with LLM...");
       const result = await enhanceAndCategorize(provider, context.entries, llmContext);
       enhanced.entries = result.enhancedEntries;
       enhanced.categories = {};
       for (const cat of result.categories) {
         enhanced.categories[cat.category] = cat.entries;
       }
-      info4(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
+      info3(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
     } else {
       if (tasks.enhance) {
-        info4("Enhancing entries with LLM...");
+        info3("Enhancing entries with LLM...");
         enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
-        info4(`Enhanced ${enhanced.entries.length} entries`);
+        info3(`Enhanced ${enhanced.entries.length} entries`);
       }
       if (tasks.categorize) {
-        info4("Categorizing entries with LLM...");
+        info3("Categorizing entries with LLM...");
         const categorized = await categorizeEntries(provider, enhanced.entries, llmContext);
         enhanced.categories = {};
         for (const cat of categorized) {
           enhanced.categories[cat.category] = cat.entries;
         }
-        info4(`Created ${categorized.length} categories`);
+        info3(`Created ${categorized.length} categories`);
       }
     }
     if (tasks.summarize) {
-      info4("Summarizing entries with LLM...");
+      info3("Summarizing entries with LLM...");
       enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
       if (enhanced.summary) {
-        info4("Summary generated successfully");
-        debug3(`Summary: ${enhanced.summary.substring(0, 100)}...`);
+        info3("Summary generated successfully");
+        debug2(`Summary: ${enhanced.summary.substring(0, 100)}...`);
       } else {
         warn3("Summary generation returned empty result");
       }
     }
     if (tasks.releaseNotes) {
-      info4("Generating release notes with LLM...");
+      info3("Generating release notes with LLM...");
       enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
       if (enhanced.releaseNotes) {
-        info4("Release notes generated successfully");
+        info3("Release notes generated successfully");
       } else {
         warn3("Release notes generation returned empty result");
       }
@@ -1453,17 +1331,17 @@ function getBuiltinTemplatePath(style) {
   let packageRoot;
   try {
     const currentUrl = import.meta.url;
-    packageRoot = path6.dirname(new URL(currentUrl).pathname);
-    packageRoot = path6.join(packageRoot, "..", "..");
+    packageRoot = path5.dirname(new URL(currentUrl).pathname);
+    packageRoot = path5.join(packageRoot, "..", "..");
   } catch {
     packageRoot = __dirname;
   }
-  return path6.join(packageRoot, "templates", style);
+  return path5.join(packageRoot, "templates", style);
 }
 async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   let templatePath;
   if (config.templates?.path) {
-    templatePath = path6.resolve(config.templates.path);
+    templatePath = path5.resolve(config.templates.path);
   } else {
     templatePath = getBuiltinTemplatePath("keep-a-changelog");
   }
@@ -1473,52 +1351,63 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   );
   const result = renderTemplate(templatePath, documentContext, config.templates?.engine);
   if (dryRun) {
-    info4(`Would write templated output to ${outputPath}`);
-    debug3("--- Changelog Preview ---");
-    debug3(result.content);
-    debug3("--- End Preview ---");
+    info3(`Would write templated output to ${outputPath}`);
+    debug2("--- Changelog Preview ---");
+    debug2(result.content);
+    debug2("--- End Preview ---");
     return;
   }
   if (outputPath === "-") {
     process.stdout.write(result.content);
     return;
   }
-  const dir = path6.dirname(outputPath);
-  if (!fs8.existsSync(dir)) {
-    fs8.mkdirSync(dir, { recursive: true });
+  const dir = path5.dirname(outputPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
-  fs8.writeFileSync(outputPath, result.content, "utf-8");
-  success4(`Changelog written to ${outputPath} (using ${result.engine} template)`);
+  fs7.writeFileSync(outputPath, result.content, "utf-8");
+  success3(`Changelog written to ${outputPath} (using ${result.engine} template)`);
 }
 async function runPipeline(input, config, dryRun) {
-  debug3(`Processing ${input.packages.length} package(s)`);
+  debug2(`Processing ${input.packages.length} package(s)`);
   let contexts = input.packages.map(createTemplateContext);
   if (config.llm && !process.env.CHANGELOG_NO_LLM) {
-    info4("Processing with LLM enhancement");
+    info3("Processing with LLM enhancement");
     contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
   }
+  const files = [];
   for (const output of config.output) {
-    info4(`Generating ${output.format} output`);
+    info3(`Generating ${output.format} output`);
     switch (output.format) {
       case "markdown": {
         const file = output.file ?? "CHANGELOG.md";
-        const effectiveTemplateConfig = output.templates ?? config.templates;
-        if (effectiveTemplateConfig?.path || output.options?.template) {
-          const configWithTemplate = { ...config, templates: effectiveTemplateConfig };
-          await generateWithTemplate(contexts, configWithTemplate, file, dryRun);
-        } else {
-          writeMarkdown(file, contexts, config, dryRun);
+        try {
+          const effectiveTemplateConfig = output.templates ?? config.templates;
+          if (effectiveTemplateConfig?.path || output.options?.template) {
+            const configWithTemplate = { ...config, templates: effectiveTemplateConfig };
+            await generateWithTemplate(contexts, configWithTemplate, file, dryRun);
+          } else {
+            writeMarkdown(file, contexts, config, dryRun);
+          }
+          if (!dryRun) files.push(file);
+        } catch (error) {
+          warn3(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
         }
         break;
       }
       case "json": {
         const file = output.file ?? "changelog.json";
-        writeJson(file, contexts, dryRun);
+        try {
+          writeJson(file, contexts, dryRun);
+          if (!dryRun) files.push(file);
+        } catch (error) {
+          warn3(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
         break;
       }
       case "github-release": {
         if (dryRun) {
-          info4("[DRY RUN] Would create GitHub release");
+          info3("[DRY RUN] Would create GitHub release");
           break;
         }
         const firstContext = contexts[0];
@@ -1546,139 +1435,33 @@ async function runPipeline(input, config, dryRun) {
       }
     }
   }
-}
-async function processInput(inputJson, config, dryRun) {
-  const input = parsePackageVersioner(inputJson);
-  await runPipeline(input, config, dryRun);
-}
-
-// src/monorepo/aggregator.ts
-import * as fs9 from "fs";
-import * as path7 from "path";
-import { debug as debug4, info as info5, success as success5 } 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) {
-    info5(`Would write to ${outputPath}`);
-    debug4(content);
-    return;
-  }
-  const dir = path7.dirname(outputPath);
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
-  }
-  fs9.writeFileSync(outputPath, content, "utf-8");
-  success5(`Changelog written to ${outputPath}`);
-}
-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) {
-  if (options.mode === "root" || options.mode === "both") {
-    const aggregated = aggregateToRoot(contexts);
-    const rootPath = path7.join(options.rootPath, "CHANGELOG.md");
-    info5(`Writing root changelog to ${rootPath}`);
-    const rootContent = config.updateStrategy === "prepend" && fs9.existsSync(rootPath) ? prependVersion(rootPath, aggregated) : renderMarkdown([aggregated]);
-    writeFile(rootPath, rootContent, dryRun);
-  }
-  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 = path7.join(packageDir, "CHANGELOG.md");
-        info5(`Writing changelog for ${packageName} to ${changelogPath}`);
-        const pkgContent = config.updateStrategy === "prepend" && fs9.existsSync(changelogPath) ? prependVersion(changelogPath, ctx) : renderMarkdown([ctx]);
-        writeFile(changelogPath, pkgContent, dryRun);
-      } else {
-        info5(`Could not find directory for package ${packageName}, skipping`);
-      }
+  if (config.monorepo?.mode) {
+    const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-BDTUZWOA.js");
+    const cwd = process.cwd();
+    const detected = detectMonorepo(cwd);
+    if (detected.isMonorepo) {
+      const monoFiles = writeMonorepoChangelogs(
+        contexts,
+        {
+          rootPath: config.monorepo.rootPath ?? cwd,
+          packagesPath: config.monorepo.packagesPath ?? detected.packagesPath,
+          mode: config.monorepo.mode
+        },
+        config,
+        dryRun
+      );
+      files.push(...monoFiles);
     }
   }
-}
-function buildPackageDirMap(rootPath, packagesPath) {
-  const map = /* @__PURE__ */ new Map();
-  const packagesDir = path7.join(rootPath, packagesPath);
-  if (!fs9.existsSync(packagesDir)) {
-    return map;
-  }
-  for (const entry of fs9.readdirSync(packagesDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const dirPath = path7.join(packagesDir, entry.name);
-    map.set(entry.name, dirPath);
-    const packageJsonPath = path7.join(dirPath, "package.json");
-    if (fs9.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
-        if (pkg.name) {
-          map.set(pkg.name, dirPath);
-        }
-      } catch {
-      }
-    }
+  const packageNotes = {};
+  for (const ctx of contexts) {
+    packageNotes[ctx.packageName] = formatVersion(ctx);
   }
-  return map;
+  return { packageNotes, files };
 }
-function detectMonorepo(cwd) {
-  const pnpmWorkspacesPath = path7.join(cwd, "pnpm-workspace.yaml");
-  const packageJsonPath = path7.join(cwd, "package.json");
-  if (fs9.existsSync(pnpmWorkspacesPath)) {
-    const content = fs9.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 (fs9.existsSync(packageJsonPath)) {
-    try {
-      const content = fs9.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: "" };
+async function processInput(inputJson, config, dryRun) {
+  const input = parsePackageVersioner(inputJson);
+  return runPipeline(input, config, dryRun);
 }
 
 export {
@@ -1697,14 +1480,9 @@ export {
   parsePackageVersioner,
   parsePackageVersionerFile,
   parsePackageVersionerStdin,
-  renderMarkdown,
-  writeMarkdown,
   renderJson,
   writeJson,
   createTemplateContext,
   runPipeline,
-  processInput,
-  aggregateToRoot,
-  writeMonorepoChangelogs,
-  detectMonorepo
+  processInput
 };