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

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,295 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/output/markdown.ts
+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) {
+    (0, import_core5.info)(`Would write changelog to ${outputPath}`);
+    (0, import_core5.debug)("--- Changelog Preview ---");
+    (0, import_core5.debug)(content);
+    (0, import_core5.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");
+  }
+  (0, import_core5.success)(`Changelog written to ${outputPath}`);
+}
+var fs2, path, import_core5, TYPE_ORDER, TYPE_LABELS;
+var init_markdown = __esm({
+  "src/output/markdown.ts"() {
+    "use strict";
+    fs2 = __toESM(require("fs"), 1);
+    path = __toESM(require("path"), 1);
+    import_core5 = require("@releasekit/core");
+    TYPE_ORDER = ["added", "changed", "deprecated", "removed", "fixed", "security"];
+    TYPE_LABELS = {
+      added: "Added",
+      changed: "Changed",
+      deprecated: "Deprecated",
+      removed: "Removed",
+      fixed: "Fixed",
+      security: "Security"
+    };
+  }
+});
+
+// src/monorepo/splitter.ts
+function splitByPackage(contexts) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    byPackage.set(ctx.packageName, ctx);
+  }
+  return byPackage;
+}
+var init_splitter = __esm({
+  "src/monorepo/splitter.ts"() {
+    "use strict";
+  }
+});
+
+// src/monorepo/aggregator.ts
+var aggregator_exports = {};
+__export(aggregator_exports, {
+  aggregateToRoot: () => aggregateToRoot,
+  detectMonorepo: () => detectMonorepo,
+  splitByPackage: () => splitByPackage,
+  writeMonorepoChangelogs: () => writeMonorepoChangelogs
+});
+function writeFile(outputPath, content, dryRun) {
+  if (dryRun) {
+    (0, import_core8.info)(`Would write to ${outputPath}`);
+    (0, import_core8.debug)(content);
+    return false;
+  }
+  const dir = path6.dirname(outputPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
+  }
+  fs8.writeFileSync(outputPath, content, "utf-8");
+  (0, import_core8.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 = path6.join(options.rootPath, "CHANGELOG.md");
+    (0, import_core8.info)(`Writing root changelog to ${rootPath}`);
+    const rootContent = config.updateStrategy === "prepend" && fs8.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 = path6.join(packageDir, "CHANGELOG.md");
+        (0, import_core8.info)(`Writing changelog for ${packageName} to ${changelogPath}`);
+        const pkgContent = config.updateStrategy === "prepend" && fs8.existsSync(changelogPath) ? prependVersion(changelogPath, ctx) : renderMarkdown([ctx]);
+        if (writeFile(changelogPath, pkgContent, dryRun)) {
+          files.push(changelogPath);
+        }
+      } else {
+        (0, import_core8.info)(`Could not find directory for package ${packageName}, skipping`);
+      }
+    }
+  }
+  return files;
+}
+function buildPackageDirMap(rootPath, packagesPath) {
+  const map = /* @__PURE__ */ new Map();
+  const packagesDir = path6.join(rootPath, packagesPath);
+  if (!fs8.existsSync(packagesDir)) {
+    return map;
+  }
+  for (const entry of fs8.readdirSync(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dirPath = path6.join(packagesDir, entry.name);
+    map.set(entry.name, dirPath);
+    const packageJsonPath = path6.join(dirPath, "package.json");
+    if (fs8.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        if (pkg.name) {
+          map.set(pkg.name, dirPath);
+        }
+      } catch {
+      }
+    }
+  }
+  return map;
+}
+function detectMonorepo(cwd) {
+  const pnpmWorkspacesPath = path6.join(cwd, "pnpm-workspace.yaml");
+  const packageJsonPath = path6.join(cwd, "package.json");
+  if (fs8.existsSync(pnpmWorkspacesPath)) {
+    const content = fs8.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 (fs8.existsSync(packageJsonPath)) {
+    try {
+      const content = fs8.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: "" };
+}
+var fs8, path6, import_core8;
+var init_aggregator = __esm({
+  "src/monorepo/aggregator.ts"() {
+    "use strict";
+    fs8 = __toESM(require("fs"), 1);
+    path6 = __toESM(require("path"), 1);
+    import_core8 = require("@releasekit/core");
+    init_markdown();
+    init_splitter();
+    init_splitter();
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -41,6 +333,7 @@ __export(index_exports, {
   aggregateToRoot: () => aggregateToRoot,
   createTemplateContext: () => createTemplateContext,
   detectMonorepo: () => detectMonorepo,
+  formatVersion: () => formatVersion,
   getDefaultConfig: () => getDefaultConfig,
   getExitCode: () => getExitCode,
   loadAuth: () => import_config.loadAuth,
@@ -73,9 +366,9 @@ function getDefaultConfig() {
 }
 
 // src/core/pipeline.ts
-var fs8 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
-var import_core8 = require("@releasekit/core");
+var fs9 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+var import_core9 = require("@releasekit/core");
 
 // src/input/package-versioner.ts
 var fs = __toESM(require("fs"), 1);
@@ -404,6 +697,83 @@ var OpenAICompatibleProvider = class extends BaseLLMProvider {
 
 // src/llm/tasks/categorize.ts
 var import_core3 = require("@releasekit/core");
+
+// src/llm/prompts.ts
+function resolvePrompt(taskName, defaultPrompt, promptsConfig) {
+  if (!promptsConfig) return defaultPrompt;
+  const fullTemplate = promptsConfig.templates?.[taskName];
+  if (fullTemplate) return fullTemplate;
+  const additionalInstructions = promptsConfig.instructions?.[taskName];
+  if (additionalInstructions) {
+    const insertionPoint = defaultPrompt.lastIndexOf("Output only valid JSON");
+    if (insertionPoint !== -1) {
+      return `${defaultPrompt.slice(0, insertionPoint)}Additional instructions:
+${additionalInstructions}
+
+${defaultPrompt.slice(insertionPoint)}`;
+    }
+    return `${defaultPrompt}
+
+Additional instructions:
+${additionalInstructions}`;
+  }
+  return defaultPrompt;
+}
+
+// src/llm/scopes.ts
+function getAllowedScopesFromCategories(categories) {
+  const scopeMap = /* @__PURE__ */ new Map();
+  for (const cat of categories) {
+    if (cat.scopes && cat.scopes.length > 0) {
+      scopeMap.set(cat.name, cat.scopes);
+    }
+  }
+  return scopeMap;
+}
+function resolveAllowedScopes(scopeConfig, categories, packageNames) {
+  if (!scopeConfig || scopeConfig.mode === "unrestricted") return null;
+  if (scopeConfig.mode === "none") return [];
+  if (scopeConfig.mode === "packages") return packageNames ?? [];
+  if (scopeConfig.mode === "restricted") {
+    const explicit = scopeConfig.rules?.allowed ?? [];
+    const all = new Set(explicit);
+    if (categories) {
+      const fromCategories = getAllowedScopesFromCategories(categories);
+      for (const scopes of fromCategories.values()) {
+        for (const s of scopes) all.add(s);
+      }
+    }
+    return [...all];
+  }
+  return null;
+}
+function validateScope(scope, allowedScopes, rules) {
+  if (!scope || allowedScopes === null) return scope;
+  if (allowedScopes.length === 0) return void 0;
+  const caseSensitive = rules?.caseSensitive ?? false;
+  const normalise = (s) => caseSensitive ? s : s.toLowerCase();
+  const isAllowed = allowedScopes.some((a) => normalise(a) === normalise(scope));
+  if (isAllowed) return scope;
+  switch (rules?.invalidScopeAction ?? "remove") {
+    case "keep":
+      return scope;
+    case "fallback":
+      return rules?.fallbackScope;
+    case "remove":
+    default:
+      return void 0;
+  }
+}
+function validateEntryScopes(entries, scopeConfig, categories) {
+  const allowedScopes = resolveAllowedScopes(scopeConfig, categories);
+  if (allowedScopes === null) return entries;
+  return entries.map((entry) => ({
+    ...entry,
+    scope: validateScope(entry.scope, allowedScopes, scopeConfig?.rules)
+  }));
+}
+
+// src/llm/tasks/categorize.ts
 var DEFAULT_CATEGORIZE_PROMPT = `You are categorizing changelog entries for a software release.
 
 Given the following entries, group them into meaningful categories (e.g., "Core", "UI", "API", "Performance", "Bug Fixes", "Documentation").
@@ -415,20 +785,21 @@ Entries:
 
 Output only valid JSON, nothing else:`;
 function buildCustomCategorizePrompt(categories) {
-  const categoryList = categories.map((c) => `- "${c.name}": ${c.description}`).join("\n");
-  const developerCategory = categories.find((c) => c.name === "Developer");
+  const categoryList = categories.map((c) => {
+    const scopeInfo = c.scopes?.length ? ` Allowed scopes: ${c.scopes.join(", ")}.` : "";
+    return `- "${c.name}": ${c.description}${scopeInfo}`;
+  }).join("\n");
+  const scopeMap = getAllowedScopesFromCategories(categories);
   let scopeInstructions = "";
-  if (developerCategory) {
-    const scopeMatch = developerCategory.description.match(/from:\s*([^.]+)/);
-    if (scopeMatch?.[1]) {
-      const scopes = scopeMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
-      if (scopes.length > 0) {
-        scopeInstructions = `
-
-For the "Developer" category, you MUST assign a scope from this exact list: ${scopes.join(", ")}.
-`;
-      }
+  if (scopeMap.size > 0) {
+    const entries = [];
+    for (const [catName, scopes] of scopeMap) {
+      entries.push(`For "${catName}", assign a scope from: ${scopes.join(", ")}.`);
     }
+    scopeInstructions = `
+
+${entries.join("\n")}
+Only use scopes from these predefined lists. If an entry does not fit any scope, set scope to null.`;
   }
   return `You are categorizing changelog entries for a software release.
 
@@ -436,9 +807,10 @@ Given the following entries, group them into the specified categories. Only use
 
 Categories:
 ${categoryList}${scopeInstructions}
+
 Output a JSON object with two fields:
 - "categories": an object where keys are category names and values are arrays of entry indices (0-based)
-- "scopes": an object where keys are entry indices (as strings) and values are scope labels
+- "scopes": an object where keys are entry indices (as strings) and values are scope labels. Only include entries that have a valid scope from the predefined list.
 
 Entries:
 {{entries}}
@@ -449,9 +821,11 @@ async function categorizeEntries(provider, entries, context) {
   if (entries.length === 0) {
     return [];
   }
-  const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
+  const entriesCopy = entries.map((e) => ({ ...e, scope: void 0 }));
+  const entriesText = entriesCopy.map((e, i) => `${i}. [${e.type}]: ${e.description}`).join("\n");
   const hasCustomCategories = context.categories && context.categories.length > 0;
-  const promptTemplate = hasCustomCategories ? buildCustomCategorizePrompt(context.categories) : DEFAULT_CATEGORIZE_PROMPT;
+  const defaultPrompt = hasCustomCategories ? buildCustomCategorizePrompt(context.categories) : DEFAULT_CATEGORIZE_PROMPT;
+  const promptTemplate = resolvePrompt("categorize", defaultPrompt, context.prompts);
   const prompt = promptTemplate.replace("{{entries}}", entriesText);
   try {
     const response = await provider.complete(prompt);
@@ -463,13 +837,14 @@ async function categorizeEntries(provider, entries, context) {
       const scopeMap = parsed.scopes || {};
       for (const [indexStr, scope] of Object.entries(scopeMap)) {
         const idx = Number.parseInt(indexStr, 10);
-        if (entries[idx] && scope) {
-          entries[idx] = { ...entries[idx], scope };
+        if (entriesCopy[idx] && scope && scope.trim()) {
+          entriesCopy[idx] = { ...entriesCopy[idx], scope: scope.trim() };
         }
       }
+      const validatedEntries = validateEntryScopes(entriesCopy, context.scopes, context.categories);
       for (const [category, rawIndices] of Object.entries(categoryMap)) {
         const indices = Array.isArray(rawIndices) ? rawIndices : [];
-        const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
+        const categoryEntries = indices.map((i) => validatedEntries[i]).filter((e) => e !== void 0);
         if (categoryEntries.length > 0) {
           result.push({ category, entries: categoryEntries });
         }
@@ -478,7 +853,7 @@ async function categorizeEntries(provider, entries, context) {
       const categoryMap = parsed;
       for (const [category, rawIndices] of Object.entries(categoryMap)) {
         const indices = Array.isArray(rawIndices) ? rawIndices : [];
-        const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
+        const categoryEntries = indices.map((i) => entriesCopy[i]).filter((e) => e !== void 0);
         if (categoryEntries.length > 0) {
           result.push({ category, entries: categoryEntries });
         }
@@ -489,12 +864,12 @@ async function categorizeEntries(provider, entries, context) {
     (0, import_core3.warn)(
       `LLM categorization failed, falling back to General: ${error instanceof Error ? error.message : String(error)}`
     );
-    return [{ category: "General", entries }];
+    return [{ category: "General", entries: entriesCopy }];
   }
 }
 
 // src/llm/tasks/enhance.ts
-var ENHANCE_PROMPT = `You are improving changelog entries for a software project.
+var DEFAULT_ENHANCE_PROMPT = `You are improving changelog entries for a software project.
 Given a technical commit message, rewrite it as a clear, user-friendly changelog entry.
 
 Rules:
@@ -510,9 +885,10 @@ Type: {{type}}
 Description: {{description}}
 
 Rewritten description (only output the new description, nothing else):`;
-async function enhanceEntry(provider, entry, _context) {
-  const styleText = _context.style ? `- ${_context.style}` : '- Use present tense ("Add feature" not "Added feature")';
-  const prompt = ENHANCE_PROMPT.replace("{{style}}", styleText).replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
+async function enhanceEntry(provider, entry, context) {
+  const styleText = context.style ? `- ${context.style}` : '- Use present tense ("Add feature" not "Added feature")';
+  const defaultPrompt = DEFAULT_ENHANCE_PROMPT.replace("{{style}}", styleText).replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
+  const prompt = resolvePrompt("enhance", defaultPrompt, context.prompts);
   const response = await provider.complete(prompt);
   return response.trim();
 }
@@ -568,7 +944,23 @@ function buildPrompt(entries, categories, style) {
   const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
   const styleText = style || 'Use present tense ("Add feature" not "Added feature"). Be concise.';
   const categorySection = categories ? `Categories (use ONLY these):
-${categories.map((c) => `- "${c.name}": ${c.description}`).join("\n")}` : `Categories: Group into meaningful categories (e.g., "New", "Fixed", "Changed", "Removed").`;
+${categories.map((c) => {
+    const scopeInfo = c.scopes?.length ? ` Allowed scopes: ${c.scopes.join(", ")}.` : "";
+    return `- "${c.name}": ${c.description}${scopeInfo}`;
+  }).join("\n")}` : `Categories: Group into meaningful categories (e.g., "New", "Fixed", "Changed", "Removed").`;
+  let scopeInstruction = "";
+  if (categories) {
+    const scopeMap = getAllowedScopesFromCategories(categories);
+    if (scopeMap.size > 0) {
+      const parts = [];
+      for (const [catName, scopes] of scopeMap) {
+        parts.push(`For "${catName}" entries, assign a scope from: ${scopes.join(", ")}.`);
+      }
+      scopeInstruction = `
+${parts.join("\n")}
+Only use scopes from these predefined lists. Set scope to null if no scope applies.`;
+    }
+  }
   return `You are generating release notes for a software project. Given the following changelog entries, do two things:
 
 1. **Rewrite** each entry as a clear, user-friendly description
@@ -579,9 +971,7 @@ Style guidelines:
 - Be concise (1 short sentence per entry)
 - Focus on what changed, not implementation details
 
-${categorySection}
-
-${categories ? 'For entries in categories involving internal/developer changes, set a "scope" field with a short subcategory label (e.g., "CI", "Dependencies", "Testing").' : ""}
+${categorySection}${scopeInstruction}
 
 Entries:
 ${entriesText}
@@ -598,7 +988,8 @@ async function enhanceAndCategorize(provider, entries, context) {
   const retryOpts = LLM_DEFAULTS.retry;
   try {
     return await withRetry(async () => {
-      const prompt = buildPrompt(entries, context.categories, context.style);
+      const defaultPrompt = buildPrompt(entries, context.categories, context.style);
+      const prompt = resolvePrompt("enhanceAndCategorize", defaultPrompt, context.prompts);
       const response = await provider.complete(prompt);
       const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
       const parsed = JSON.parse(cleaned);
@@ -614,22 +1005,23 @@ async function enhanceAndCategorize(provider, entries, context) {
           scope: result.scope || original.scope
         };
       });
+      const validatedEntries = validateEntryScopes(enhancedEntries, context.scopes, context.categories);
       const categoryMap = /* @__PURE__ */ new Map();
       for (let i = 0; i < parsed.entries.length; i++) {
         const result = parsed.entries[i];
         const category = result?.category || "General";
-        const entry = enhancedEntries[i];
+        const entry = validatedEntries[i];
         if (!entry) continue;
         if (!categoryMap.has(category)) {
           categoryMap.set(category, []);
         }
-        categoryMap.get(category).push(entry);
+        categoryMap.get(category)?.push(entry);
       }
       const categories = [];
       for (const [category, catEntries] of categoryMap) {
         categories.push({ category, entries: catEntries });
       }
-      return { enhancedEntries, categories };
+      return { enhancedEntries: validatedEntries, categories };
     }, retryOpts);
   } catch (error) {
     (0, import_core4.warn)(
@@ -643,7 +1035,7 @@ async function enhanceAndCategorize(provider, entries, context) {
 }
 
 // src/llm/tasks/release-notes.ts
-var RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
+var DEFAULT_RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
 
 Create engaging, user-friendly release notes for the following changes.
 
@@ -676,16 +1068,17 @@ No notable changes in this release.`;
     if (e.breaking) line += " **BREAKING**";
     return line;
   }).join("\n");
-  const prompt = RELEASE_NOTES_PROMPT.replace("{{version}}", context.version ?? "v1.0.0").replace(
+  const defaultPrompt = DEFAULT_RELEASE_NOTES_PROMPT.replace("{{version}}", context.version ?? "v1.0.0").replace(
     "{{#if previousVersion}}Previous version: {{previousVersion}}{{/if}}",
     context.previousVersion ? `Previous version: ${context.previousVersion}` : ""
   ).replace("{{date}}", context.date ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "").replace("{{entries}}", entriesText);
+  const prompt = resolvePrompt("releaseNotes", defaultPrompt, context.prompts);
   const response = await provider.complete(prompt);
   return response.trim();
 }
 
 // src/llm/tasks/summarize.ts
-var SUMMARIZE_PROMPT = `You are creating a summary of changes for a software release.
+var DEFAULT_SUMMARIZE_PROMPT = `You are creating a summary of changes for a software release.
 
 Given the following changelog entries, create a brief summary (2-3 sentences) that captures the main themes of this release.
 
@@ -693,12 +1086,13 @@ Entries:
 {{entries}}
 
 Summary (only output the summary, nothing else):`;
-async function summarizeEntries(provider, entries, _context) {
+async function summarizeEntries(provider, entries, context) {
   if (entries.length === 0) {
     return "";
   }
   const entriesText = entries.map((e) => `- [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
-  const prompt = SUMMARIZE_PROMPT.replace("{{entries}}", entriesText);
+  const defaultPrompt = DEFAULT_SUMMARIZE_PROMPT.replace("{{entries}}", entriesText);
+  const prompt = resolvePrompt("summarize", defaultPrompt, context.prompts);
   const response = await provider.complete(prompt);
   return response.trim();
 }
@@ -743,135 +1137,7 @@ function createProvider(config) {
 // src/output/github-release.ts
 var import_rest = require("@octokit/rest");
 var import_core6 = require("@releasekit/core");
-
-// src/output/markdown.ts
-var fs2 = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var import_core5 = require("@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) {
-    (0, import_core5.info)("--- Changelog Preview ---");
-    console.log(content);
-    (0, import_core5.info)("--- 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");
-  }
-  (0, import_core5.success)(`Changelog written to ${outputPath}`);
-}
-
-// src/output/github-release.ts
+init_markdown();
 var GitHubClient = class {
   octokit;
   owner;
@@ -1007,9 +1273,10 @@ function renderJson(contexts) {
 function writeJson(outputPath, contexts, dryRun) {
   const content = renderJson(contexts);
   if (dryRun) {
-    (0, import_core7.info)("--- JSON Output Preview ---");
-    console.log(content);
-    (0, import_core7.info)("--- End Preview ---");
+    (0, import_core7.info)(`Would write JSON output to ${outputPath}`);
+    (0, import_core7.debug)("--- JSON Output Preview ---");
+    (0, import_core7.debug)(content);
+    (0, import_core7.debug)("--- End Preview ---");
     return;
   }
   const dir = path2.dirname(outputPath);
@@ -1020,6 +1287,9 @@ function writeJson(outputPath, contexts, dryRun) {
   (0, import_core7.success)(`JSON output written to ${outputPath}`);
 }
 
+// src/core/pipeline.ts
+init_markdown();
+
 // src/templates/ejs.ts
 var fs4 = __toESM(require("fs"), 1);
 var import_ejs = __toESM(require("ejs"), 1);
@@ -1276,17 +1546,27 @@ function renderTemplate(templatePath, context, engine) {
 
 // src/core/pipeline.ts
 var import_meta = {};
-function generateCompareUrl(repoUrl, from, to) {
+function generateCompareUrl(repoUrl, from, to, packageName) {
+  const isPackageSpecific = from.includes("@") && packageName && from.includes(packageName);
+  let fromVersion;
+  let toVersion;
+  if (isPackageSpecific) {
+    fromVersion = from;
+    toVersion = `${packageName}@${to.startsWith("v") ? "" : "v"}${to}`;
+  } else {
+    fromVersion = from.replace(/^v/, "");
+    toVersion = to.replace(/^v/, "");
+  }
   if (/gitlab\.com/i.test(repoUrl)) {
-    return `${repoUrl}/-/compare/${from}...${to}`;
+    return `${repoUrl}/-/compare/${fromVersion}...${toVersion}`;
   }
   if (/bitbucket\.org/i.test(repoUrl)) {
-    return `${repoUrl}/branches/compare/${from}..${to}`;
+    return `${repoUrl}/branches/compare/${fromVersion}..${toVersion}`;
   }
-  return `${repoUrl}/compare/${from}...${to}`;
+  return `${repoUrl}/compare/${fromVersion}...${toVersion}`;
 }
 function createTemplateContext(pkg) {
-  const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version) : void 0;
+  const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version, pkg.packageName) : void 0;
   return {
     packageName: pkg.packageName,
     version: pkg.version,
@@ -1324,15 +1604,17 @@ async function processWithLLM(context, config) {
     previousVersion: context.previousVersion ?? void 0,
     date: context.date,
     categories: config.llm.categories,
-    style: config.llm.style
+    style: config.llm.style,
+    scopes: config.llm.scopes,
+    prompts: config.llm.prompts
   };
   const enhanced = {
     entries: context.entries
   };
   try {
-    (0, import_core8.info)(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
+    (0, import_core9.info)(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
     if (config.llm.baseURL) {
-      (0, import_core8.info)(`LLM base URL: ${config.llm.baseURL}`);
+      (0, import_core9.info)(`LLM base URL: ${config.llm.baseURL}`);
     }
     const rawProvider = createProvider(config.llm);
     const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
@@ -1341,59 +1623,58 @@ 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);
-    (0, import_core8.info)(`Running LLM tasks: ${activeTasks.join(", ")}`);
+    (0, import_core9.info)(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance && tasks.categorize) {
-      (0, import_core8.info)("Enhancing and categorizing entries with LLM...");
+      (0, import_core9.info)("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;
       }
-      (0, import_core8.info)(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
+      (0, import_core9.info)(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
     } else {
       if (tasks.enhance) {
-        (0, import_core8.info)("Enhancing entries with LLM...");
+        (0, import_core9.info)("Enhancing entries with LLM...");
         enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
-        (0, import_core8.info)(`Enhanced ${enhanced.entries.length} entries`);
+        (0, import_core9.info)(`Enhanced ${enhanced.entries.length} entries`);
       }
       if (tasks.categorize) {
-        (0, import_core8.info)("Categorizing entries with LLM...");
+        (0, import_core9.info)("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;
         }
-        (0, import_core8.info)(`Created ${categorized.length} categories`);
+        (0, import_core9.info)(`Created ${categorized.length} categories`);
       }
     }
     if (tasks.summarize) {
-      (0, import_core8.info)("Summarizing entries with LLM...");
+      (0, import_core9.info)("Summarizing entries with LLM...");
       enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
       if (enhanced.summary) {
-        (0, import_core8.info)("Summary generated successfully");
-        (0, import_core8.debug)(`Summary: ${enhanced.summary.substring(0, 100)}...`);
+        (0, import_core9.info)("Summary generated successfully");
+        (0, import_core9.debug)(`Summary: ${enhanced.summary.substring(0, 100)}...`);
       } else {
-        (0, import_core8.warn)("Summary generation returned empty result");
+        (0, import_core9.warn)("Summary generation returned empty result");
       }
     }
     if (tasks.releaseNotes) {
-      (0, import_core8.info)("Generating release notes with LLM...");
+      (0, import_core9.info)("Generating release notes with LLM...");
       enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
       if (enhanced.releaseNotes) {
-        (0, import_core8.info)("Release notes generated successfully");
+        (0, import_core9.info)("Release notes generated successfully");
       } else {
-        (0, import_core8.warn)("Release notes generation returned empty result");
+        (0, import_core9.warn)("Release notes generation returned empty result");
       }
     }
     return {
       ...context,
-      entries: enhanced.entries,
       enhanced
     };
   } catch (error) {
-    (0, import_core8.warn)(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
-    (0, import_core8.warn)("Falling back to raw entries");
+    (0, import_core9.warn)(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
+    (0, import_core9.warn)("Falling back to raw entries");
     return context;
   }
 }
@@ -1401,17 +1682,17 @@ function getBuiltinTemplatePath(style) {
   let packageRoot;
   try {
     const currentUrl = import_meta.url;
-    packageRoot = path6.dirname(new URL(currentUrl).pathname);
-    packageRoot = path6.join(packageRoot, "..", "..");
+    packageRoot = path7.dirname(new URL(currentUrl).pathname);
+    packageRoot = path7.join(packageRoot, "..", "..");
   } catch {
     packageRoot = __dirname;
   }
-  return path6.join(packageRoot, "templates", style);
+  return path7.join(packageRoot, "templates", style);
 }
 async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   let templatePath;
   if (config.templates?.path) {
-    templatePath = path6.resolve(config.templates.path);
+    templatePath = path7.resolve(config.templates.path);
   } else {
     templatePath = getBuiltinTemplatePath("keep-a-changelog");
   }
@@ -1421,64 +1702,78 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   );
   const result = renderTemplate(templatePath, documentContext, config.templates?.engine);
   if (dryRun) {
-    (0, import_core8.info)("--- Changelog Preview ---");
-    console.log(result.content);
-    (0, import_core8.info)("--- End Preview ---");
+    (0, import_core9.info)(`Would write templated output to ${outputPath}`);
+    (0, import_core9.debug)("--- Changelog Preview ---");
+    (0, import_core9.debug)(result.content);
+    (0, import_core9.debug)("--- 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 = path7.dirname(outputPath);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
-  fs8.writeFileSync(outputPath, result.content, "utf-8");
-  (0, import_core8.success)(`Changelog written to ${outputPath} (using ${result.engine} template)`);
+  fs9.writeFileSync(outputPath, result.content, "utf-8");
+  (0, import_core9.success)(`Changelog written to ${outputPath} (using ${result.engine} template)`);
 }
 async function runPipeline(input, config, dryRun) {
-  (0, import_core8.debug)(`Processing ${input.packages.length} package(s)`);
+  (0, import_core9.debug)(`Processing ${input.packages.length} package(s)`);
   let contexts = input.packages.map(createTemplateContext);
   if (config.llm && !process.env.CHANGELOG_NO_LLM) {
-    (0, import_core8.info)("Processing with LLM enhancement");
+    (0, import_core9.info)("Processing with LLM enhancement");
     contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
   }
+  const files = [];
   for (const output of config.output) {
-    (0, import_core8.info)(`Generating ${output.format} output`);
+    (0, import_core9.info)(`Generating ${output.format} output`);
     switch (output.format) {
       case "markdown": {
         const file = output.file ?? "CHANGELOG.md";
-        if (config.templates?.path || output.options?.template) {
-          await generateWithTemplate(contexts, config, 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) {
+          (0, import_core9.warn)(`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) {
+          (0, import_core9.warn)(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
         break;
       }
       case "github-release": {
         if (dryRun) {
-          (0, import_core8.info)("[DRY RUN] Would create GitHub release");
+          (0, import_core9.info)("[DRY RUN] Would create GitHub release");
           break;
         }
         const firstContext = contexts[0];
         if (!firstContext) {
-          (0, import_core8.warn)("No context available for GitHub release");
+          (0, import_core9.warn)("No context available for GitHub release");
           break;
         }
         const repoUrl = firstContext.repoUrl;
         if (!repoUrl) {
-          (0, import_core8.warn)("No repo URL available, cannot create GitHub release");
+          (0, import_core9.warn)("No repo URL available, cannot create GitHub release");
           break;
         }
         const parsed = parseRepoUrl(repoUrl);
         if (!parsed) {
-          (0, import_core8.warn)(`Could not parse repo URL: ${repoUrl}`);
+          (0, import_core9.warn)(`Could not parse repo URL: ${repoUrl}`);
           break;
         }
         await createGitHubRelease(firstContext, {
@@ -1491,140 +1786,38 @@ 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
-var fs9 = __toESM(require("fs"), 1);
-var path7 = __toESM(require("path"), 1);
-var import_core9 = require("@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) {
-    (0, import_core9.info)(`[DRY RUN] Would write to ${outputPath}`);
-    console.log(content);
-    return;
-  }
-  const dir = path7.dirname(outputPath);
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
-  }
-  fs9.writeFileSync(outputPath, content, "utf-8");
-  (0, import_core9.success)(`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
-      });
+  if (config.monorepo?.mode) {
+    const { detectMonorepo: detectMonorepo2, writeMonorepoChangelogs: writeMonorepoChangelogs2 } = await Promise.resolve().then(() => (init_aggregator(), aggregator_exports));
+    const cwd = process.cwd();
+    const detected = detectMonorepo2(cwd);
+    if (detected.isMonorepo) {
+      const monoFiles = writeMonorepoChangelogs2(
+        contexts,
+        {
+          rootPath: config.monorepo.rootPath ?? cwd,
+          packagesPath: config.monorepo.packagesPath ?? detected.packagesPath,
+          mode: config.monorepo.mode
+        },
+        config,
+        dryRun
+      );
+      files.push(...monoFiles);
     }
   }
-  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");
-    (0, import_core9.info)(`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");
-        (0, import_core9.info)(`Writing changelog for ${packageName} to ${changelogPath}`);
-        const pkgContent = config.updateStrategy === "prepend" && fs9.existsSync(changelogPath) ? prependVersion(changelogPath, ctx) : renderMarkdown([ctx]);
-        writeFile(changelogPath, pkgContent, dryRun);
-      } else {
-        (0, import_core9.info)(`Could not find directory for package ${packageName}, skipping`);
-      }
-    }
-  }
-}
-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);
 }
+
+// src/index.ts
+init_aggregator();
+init_markdown();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChangelogCreatorError,
@@ -1638,6 +1831,7 @@ function detectMonorepo(cwd) {
   aggregateToRoot,
   createTemplateContext,
   detectMonorepo,
+  formatVersion,
   getDefaultConfig,
   getExitCode,
   loadAuth,