@releasekit/notes 0.3.1 → 0.4.0

package/dist/{chunk-ENAWZXFG.js → chunk-QX23CBNW.js}

@@ -4,11 +4,10 @@ import {
   debug,
   formatVersion,
   info,
-  renderMarkdown,
   success,
   warn,
   writeMarkdown
-} from "./chunk-E4454SIS.js";
+} from "./chunk-7TJSPQPW.js";
 
 // ../config/dist/index.js
 import * as fs from "fs";
@@ -118,14 +117,14 @@ var GitHubReleaseConfigSchema = z.object({
   perPackage: z.boolean().default(true),
   prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
   /**
-   * Controls how release notes are sourced for GitHub releases.
-   * - 'auto': Use RELEASE_NOTES.md if it exists, then per-package changelog
-   *   data from the version output, then GitHub's auto-generated notes.
-   * - 'github': Always use GitHub's auto-generated notes.
-   * - 'none': No notes body.
-   * - Any other string: Treated as a file path to read notes from.
+   * Controls the source for the GitHub release body.
+   * - 'auto': Use release notes if enabled, else changelog, else GitHub auto-generated.
+   * - 'releaseNotes': Use LLM-generated release notes (requires notes.releaseNotes.enabled: true).
+   * - 'changelog': Use formatted changelog entries.
+   * - 'generated': Use GitHub's auto-generated notes.
+   * - 'none': No body.
    */
-  releaseNotes: z.union([z.literal("auto"), z.literal("github"), z.literal("none"), z.string()]).default("auto")
+  body: z.enum(["auto", "releaseNotes", "changelog", "generated", "none"]).default("auto")
 });
 var VerifyRegistryConfigSchema = z.object({
   enabled: z.boolean().default(true),
@@ -169,7 +168,7 @@ var PublishConfigSchema = z.object({
     draft: true,
     perPackage: true,
     prerelease: "auto",
-    releaseNotes: "auto"
+    body: "auto"
   }),
   verify: VerifyConfigSchema.default({
     npm: {
@@ -190,10 +189,10 @@ var TemplateConfigSchema = z.object({
   path: z.string().optional(),
   engine: z.enum(["handlebars", "liquid", "ejs"]).optional()
 });
-var OutputConfigSchema = z.object({
-  format: z.enum(["markdown", "github-release", "json"]),
+var LocationModeSchema = z.enum(["root", "packages", "both"]);
+var ChangelogConfigSchema = z.object({
+  mode: LocationModeSchema.optional(),
   file: z.string().optional(),
-  options: z.record(z.string(), z.unknown()).optional(),
   templates: TemplateConfigSchema.optional()
 });
 var LLMOptionsSchema = z.object({
@@ -253,17 +252,20 @@ var LLMConfigSchema = z.object({
   scopes: ScopeConfigSchema.optional(),
   prompts: LLMPromptsConfigSchema.optional()
 });
+var ReleaseNotesConfigSchema = z.object({
+  mode: LocationModeSchema.optional(),
+  file: z.string().optional(),
+  templates: TemplateConfigSchema.optional(),
+  llm: LLMConfigSchema.optional()
+});
 var NotesInputConfigSchema = z.object({
   source: z.string().optional(),
   file: z.string().optional()
 });
 var NotesConfigSchema = z.object({
-  input: NotesInputConfigSchema.optional(),
-  output: z.array(OutputConfigSchema).default([{ format: "markdown", file: "CHANGELOG.md" }]),
-  monorepo: MonorepoConfigSchema.optional(),
-  templates: TemplateConfigSchema.optional(),
-  llm: LLMConfigSchema.optional(),
-  updateStrategy: z.enum(["prepend", "regenerate"]).default("prepend")
+  changelog: z.union([z.literal(false), ChangelogConfigSchema]).optional(),
+  releaseNotes: z.union([z.literal(false), ReleaseNotesConfigSchema]).optional(),
+  updateStrategy: z.enum(["prepend", "regenerate"]).optional()
 });
 var CILabelsConfigSchema = z.object({
   stable: z.string().default("release:stable"),
@@ -410,22 +412,6 @@ function loadConfig(options) {
   const configPath = options?.configPath ?? path3.join(cwd, CONFIG_FILE);
   return loadConfigFile(configPath);
 }
-function loadNotesConfig(options) {
-  const config = loadConfig(options);
-  return config.notes;
-}
-
-// src/core/config.ts
-function loadConfig2(projectDir = process.cwd(), configFile) {
-  const options = { cwd: projectDir, configPath: configFile };
-  return loadNotesConfig(options) ?? getDefaultConfig();
-}
-function getDefaultConfig() {
-  return {
-    output: [{ format: "markdown", file: "CHANGELOG.md" }],
-    updateStrategy: "prepend"
-  };
-}
 
 // src/errors/index.ts
 var NotesError = class extends ReleaseKitError {
@@ -555,50 +541,28 @@ async function parseVersionOutputStdin() {
   return parseVersionOutput(content);
 }
 
-// src/output/json.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
-function renderJson(contexts) {
-  return JSON.stringify(
-    {
-      versions: contexts.map((ctx) => ({
-        packageName: ctx.packageName,
-        version: ctx.version,
-        previousVersion: ctx.previousVersion,
-        date: ctx.date,
-        entries: ctx.entries,
-        compareUrl: ctx.compareUrl
-      }))
-    },
-    null,
-    2
-  );
-}
-function writeJson(outputPath, contexts, dryRun) {
-  const content = renderJson(contexts);
-  if (dryRun) {
-    info(`Would write JSON output to ${outputPath}`);
-    debug("--- JSON Output Preview ---");
-    debug(content);
-    debug("--- End Preview ---");
-    return;
-  }
-  const dir = path4.dirname(outputPath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+// src/core/config.ts
+function loadConfig2(projectDir = process.cwd(), configFile) {
+  const options = { cwd: projectDir, configPath: configFile };
+  const fullConfig = loadConfig(options);
+  const config = fullConfig.notes ?? getDefaultConfig();
+  if (fullConfig.monorepo && !config.monorepo) {
+    config.monorepo = fullConfig.monorepo;
   }
-  fs5.writeFileSync(outputPath, content, "utf-8");
-  success(`JSON output written to ${outputPath}`);
+  return config;
+}
+function getDefaultConfig() {
+  return {};
 }
 
 // src/core/pipeline.ts
-import * as fs10 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path7 from "path";
 
 // src/llm/defaults.ts
 var LLM_DEFAULTS = {
   timeout: 6e4,
-  maxTokens: 4e3,
+  maxTokens: 16384,
   temperature: 0.7,
   concurrency: 5,
   retry: {
@@ -610,7 +574,7 @@ var LLM_DEFAULTS = {
   models: {
     openai: "gpt-4o-mini",
     "openai-compatible": "gpt-4o-mini",
-    anthropic: "claude-3-5-haiku-latest",
+    anthropic: "claude-haiku-4-5-20251001",
     ollama: "llama3.2"
   }
 };
@@ -700,6 +664,13 @@ var OllamaProvider = class extends BaseLLMProvider {
         body: JSON.stringify(requestBody)
       });
       if (!response.ok) {
+        if (response.status === 401 || response.status === 403) {
+          const text2 = await response.text();
+          const keyHint = this.apiKey ? "OLLAMA_API_KEY is set but may be invalid or rejected by the server." : "OLLAMA_API_KEY is not set. Set the environment variable or use --no-llm to skip LLM processing.";
+          throw new LLMError(
+            `Ollama request failed: ${response.status} ${response.statusText}${text2 ? ` - ${text2}` : ""}. ${keyHint}`
+          );
+        }
         const text = await response.text();
         throw new LLMError(`Ollama request failed: ${response.status} ${text}`);
       }
@@ -1228,122 +1199,8 @@ function createProvider(config) {
   }
 }
 
-// src/output/github-release.ts
-import { Octokit } from "@octokit/rest";
-var GitHubClient = class {
-  octokit;
-  owner;
-  repo;
-  constructor(options) {
-    const token = options.token ?? process.env.GITHUB_TOKEN;
-    if (!token) {
-      throw new GitHubError("GITHUB_TOKEN not set. Set it as an environment variable.");
-    }
-    this.octokit = new Octokit({ auth: token });
-    this.owner = options.owner;
-    this.repo = options.repo;
-  }
-  async createRelease(context, options = {}) {
-    const tagName = `v${context.version}`;
-    let body;
-    if (context.enhanced?.releaseNotes) {
-      body = context.enhanced.releaseNotes;
-    } else {
-      body = renderMarkdown([context]);
-    }
-    info(`Creating GitHub release for ${tagName}`);
-    try {
-      const response = await this.octokit.repos.createRelease({
-        owner: this.owner,
-        repo: this.repo,
-        tag_name: tagName,
-        name: tagName,
-        body,
-        draft: options.draft ?? false,
-        prerelease: options.prerelease ?? false,
-        generate_release_notes: options.generateNotes ?? false
-      });
-      success(`Release created: ${response.data.html_url}`);
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName
-      };
-    } catch (error) {
-      throw new GitHubError(`Failed to create release: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async updateRelease(releaseId, context, options = {}) {
-    const tagName = `v${context.version}`;
-    let body;
-    if (context.enhanced?.releaseNotes) {
-      body = context.enhanced.releaseNotes;
-    } else {
-      body = renderMarkdown([context]);
-    }
-    info(`Updating GitHub release ${releaseId}`);
-    try {
-      const response = await this.octokit.repos.updateRelease({
-        owner: this.owner,
-        repo: this.repo,
-        release_id: releaseId,
-        tag_name: tagName,
-        name: tagName,
-        body,
-        draft: options.draft ?? false,
-        prerelease: options.prerelease ?? false
-      });
-      success(`Release updated: ${response.data.html_url}`);
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName
-      };
-    } catch (error) {
-      throw new GitHubError(`Failed to update release: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async getReleaseByTag(tag) {
-    try {
-      const response = await this.octokit.repos.getReleaseByTag({
-        owner: this.owner,
-        repo: this.repo,
-        tag
-      });
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName: response.data.tag_name
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-function parseRepoUrl(repoUrl) {
-  const patterns = [
-    /^https:\/\/github\.com\/([^/]+)\/([^/]+)/,
-    /^git@github\.com:([^/]+)\/([^/]+)/,
-    /^github\.com\/([^/]+)\/([^/]+)/
-  ];
-  for (const pattern of patterns) {
-    const match = repoUrl.match(pattern);
-    if (match?.[1] && match[2]) {
-      return {
-        owner: match[1],
-        repo: match[2].replace(/\.git$/, "")
-      };
-    }
-  }
-  return null;
-}
-async function createGitHubRelease(context, options) {
-  const client = new GitHubClient(options);
-  return client.createRelease(context, options);
-}
-
 // src/templates/ejs.ts
-import * as fs6 from "fs";
+import * as fs5 from "fs";
 import ejs from "ejs";
 function renderEjs(template, context) {
   try {
@@ -1353,16 +1210,16 @@ function renderEjs(template, context) {
   }
 }
 function renderEjsFile(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 renderEjs(template, context);
 }
 
 // src/templates/handlebars.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path4 from "path";
 import Handlebars from "handlebars";
 function registerHandlebarsHelpers() {
   Handlebars.registerHelper("capitalize", (str) => {
@@ -1388,28 +1245,28 @@ function renderHandlebars(template, context) {
   }
 }
 function renderHandlebarsFile(filePath, context) {
-  if (!fs7.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs7.readFileSync(filePath, "utf-8");
+  const template = fs6.readFileSync(filePath, "utf-8");
   return renderHandlebars(template, context);
 }
 function renderHandlebarsComposable(templateDir, context) {
   registerHandlebarsHelpers();
-  const versionPath = path5.join(templateDir, "version.hbs");
-  const entryPath = path5.join(templateDir, "entry.hbs");
-  const documentPath = path5.join(templateDir, "document.hbs");
-  if (!fs7.existsSync(documentPath)) {
+  const versionPath = path4.join(templateDir, "version.hbs");
+  const entryPath = path4.join(templateDir, "entry.hbs");
+  const documentPath = path4.join(templateDir, "document.hbs");
+  if (!fs6.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${documentPath}`);
   }
-  if (fs7.existsSync(versionPath)) {
-    Handlebars.registerPartial("version", fs7.readFileSync(versionPath, "utf-8"));
+  if (fs6.existsSync(versionPath)) {
+    Handlebars.registerPartial("version", fs6.readFileSync(versionPath, "utf-8"));
   }
-  if (fs7.existsSync(entryPath)) {
-    Handlebars.registerPartial("entry", fs7.readFileSync(entryPath, "utf-8"));
+  if (fs6.existsSync(entryPath)) {
+    Handlebars.registerPartial("entry", fs6.readFileSync(entryPath, "utf-8"));
   }
   try {
-    const compiled = Handlebars.compile(fs7.readFileSync(documentPath, "utf-8"));
+    const compiled = Handlebars.compile(fs6.readFileSync(documentPath, "utf-8"));
     return compiled(context);
   } catch (error) {
     throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
@@ -1417,8 +1274,8 @@ function renderHandlebarsComposable(templateDir, context) {
 }
 
 // src/templates/liquid.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 import { Liquid } from "liquidjs";
 function createLiquidEngine(root) {
   return new Liquid({
@@ -1436,15 +1293,15 @@ function renderLiquid(template, context) {
   }
 }
 function renderLiquidFile(filePath, context) {
-  if (!fs8.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs8.readFileSync(filePath, "utf-8");
+  const template = fs7.readFileSync(filePath, "utf-8");
   return renderLiquid(template, context);
 }
 function renderLiquidComposable(templateDir, context) {
-  const documentPath = path6.join(templateDir, "document.liquid");
-  if (!fs8.existsSync(documentPath)) {
+  const documentPath = path5.join(templateDir, "document.liquid");
+  if (!fs7.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${documentPath}`);
   }
   const engine = createLiquidEngine(templateDir);
@@ -1456,10 +1313,10 @@ function renderLiquidComposable(templateDir, context) {
 }
 
 // src/templates/loader.ts
-import * as fs9 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 function getEngineFromFile(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   switch (ext) {
     case ".liquid":
       return "liquid";
@@ -1493,10 +1350,10 @@ function getRenderFileFn(engine) {
   }
 }
 function detectTemplateMode(templatePath) {
-  if (!fs9.existsSync(templatePath)) {
+  if (!fs8.existsSync(templatePath)) {
     throw new TemplateError(`Template path not found: ${templatePath}`);
   }
-  const stat = fs9.statSync(templatePath);
+  const stat = fs8.statSync(templatePath);
   if (stat.isFile()) {
     return "single";
   }
@@ -1514,7 +1371,7 @@ function renderSingleFile(templatePath, context, engine) {
   };
 }
 function renderComposable(templateDir, context, engine) {
-  const files = fs9.readdirSync(templateDir);
+  const files = fs8.readdirSync(templateDir);
   const engineMap = {
     liquid: { document: "document.liquid", version: "version.liquid", entry: "entry.liquid" },
     handlebars: { document: "document.hbs", version: "version.hbs", entry: "entry.hbs" },
@@ -1537,15 +1394,15 @@ function renderComposable(templateDir, context, engine) {
     return { content: renderHandlebarsComposable(templateDir, context), engine: resolvedEngine };
   }
   const expectedFiles = engineMap[resolvedEngine];
-  const documentPath = path7.join(templateDir, expectedFiles.document);
-  if (!fs9.existsSync(documentPath)) {
+  const documentPath = path6.join(templateDir, expectedFiles.document);
+  if (!fs8.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${expectedFiles.document}`);
   }
-  const versionPath = path7.join(templateDir, expectedFiles.version);
-  const entryPath = path7.join(templateDir, expectedFiles.entry);
+  const versionPath = path6.join(templateDir, expectedFiles.version);
+  const entryPath = path6.join(templateDir, expectedFiles.entry);
   const render = getRenderFn(resolvedEngine);
-  const entryTemplate = fs9.existsSync(entryPath) ? fs9.readFileSync(entryPath, "utf-8") : null;
-  const versionTemplate = fs9.existsSync(versionPath) ? fs9.readFileSync(versionPath, "utf-8") : null;
+  const entryTemplate = fs8.existsSync(entryPath) ? fs8.readFileSync(entryPath, "utf-8") : null;
+  const versionTemplate = fs8.existsSync(versionPath) ? fs8.readFileSync(versionPath, "utf-8") : null;
   if (entryTemplate && versionTemplate) {
     const versionsWithEntries = context.versions.map((versionCtx) => {
       const entries = versionCtx.entries.map((entry) => {
@@ -1556,7 +1413,7 @@ function renderComposable(templateDir, context, engine) {
     });
     const docContext = { ...context, renderedVersions: versionsWithEntries };
     return {
-      content: render(fs9.readFileSync(documentPath, "utf-8"), docContext),
+      content: render(fs8.readFileSync(documentPath, "utf-8"), docContext),
       engine: resolvedEngine
     };
   }
@@ -1654,36 +1511,31 @@ function createDocumentContext(contexts, repoUrl) {
     compareUrls: Object.keys(compareUrls).length > 0 ? compareUrls : void 0
   };
 }
-async function processWithLLM(context, config) {
-  if (!config.llm) {
-    return context;
-  }
-  const tasks = config.llm.tasks ?? {};
+async function processWithLLM(context, llmConfig) {
+  const tasks = llmConfig.tasks ?? {};
   const llmContext = {
     packageName: context.packageName,
     version: context.version,
     previousVersion: context.previousVersion ?? void 0,
     date: context.date,
-    categories: config.llm.categories,
-    style: config.llm.style,
-    scopes: config.llm.scopes,
-    prompts: config.llm.prompts
+    categories: llmConfig.categories,
+    style: llmConfig.style,
+    scopes: llmConfig.scopes,
+    prompts: llmConfig.prompts
   };
   const enhanced = {
     entries: context.entries
   };
   try {
-    info(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
-    if (config.llm.baseURL) {
-      info(`LLM base URL: ${config.llm.baseURL}`);
+    info(`Using LLM provider: ${llmConfig.provider}${llmConfig.model ? ` (${llmConfig.model})` : ""}`);
+    if (llmConfig.baseURL) {
+      info(`LLM base URL: ${llmConfig.baseURL}`);
     }
-    const rawProvider = createProvider(config.llm);
-    const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
-    const configOptions = config.llm.options;
+    const rawProvider = createProvider(llmConfig);
+    const retryOpts = llmConfig.retry ?? LLM_DEFAULTS.retry;
+    const configOptions = llmConfig.options;
     const provider = {
       name: rawProvider.name,
-      // Merge user-configured options (timeout, maxTokens, temperature) as base defaults,
-      // allowing any per-call overrides to take precedence.
       complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, { ...configOptions, ...opts }), retryOpts)
     };
     const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
@@ -1697,7 +1549,7 @@ async function processWithLLM(context, config) {
     } else {
       if (tasks.enhance) {
         info("Enhancing entries with LLM...");
-        enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
+        enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, llmConfig.concurrency);
         info(`Enhanced ${enhanced.entries.length} entries`);
       }
       if (tasks.categorize) {
@@ -1740,25 +1592,22 @@ function getBuiltinTemplatePath(style) {
   let packageRoot;
   try {
     const currentUrl = import.meta.url;
-    packageRoot = path8.dirname(new URL(currentUrl).pathname);
-    packageRoot = path8.join(packageRoot, "..", "..");
+    packageRoot = path7.dirname(new URL(currentUrl).pathname);
+    packageRoot = path7.join(packageRoot, "..", "..");
   } catch {
     packageRoot = __dirname;
   }
-  return path8.join(packageRoot, "templates", style);
+  return path7.join(packageRoot, "templates", style);
 }
-async function generateWithTemplate(contexts, config, outputPath, dryRun) {
+async function generateWithTemplate(contexts, templatesConfig, outputPath, repoUrl, dryRun) {
   let templatePath;
-  if (config.templates?.path) {
-    templatePath = path8.resolve(config.templates.path);
+  if (templatesConfig?.path) {
+    templatePath = path7.resolve(templatesConfig.path);
   } else {
     templatePath = getBuiltinTemplatePath("keep-a-changelog");
   }
-  const documentContext = createDocumentContext(
-    contexts,
-    config.templates?.path ? void 0 : contexts[0]?.repoUrl ?? void 0
-  );
-  const result = renderTemplate(templatePath, documentContext, config.templates?.engine);
+  const documentContext = createDocumentContext(contexts, templatesConfig?.path ? void 0 : repoUrl);
+  const result = renderTemplate(templatePath, documentContext, templatesConfig?.engine);
   if (dryRun) {
     info(`[DRY RUN] Changelog preview (would write to ${outputPath}):`);
     info(result.content);
@@ -1768,121 +1617,128 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
     process.stdout.write(result.content);
     return;
   }
-  const dir = path8.dirname(outputPath);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(outputPath);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
-  fs10.writeFileSync(outputPath, result.content, "utf-8");
+  fs9.writeFileSync(outputPath, result.content, "utf-8");
   const label = /changelog/i.test(outputPath) ? "Changelog" : "Release notes";
   success(`${label} written to ${outputPath} (using ${result.engine} template)`);
 }
 async function runPipeline(input, config, dryRun) {
   debug(`Processing ${input.packages.length} package(s)`);
   let contexts = input.packages.map(createTemplateContext);
-  if (config.llm && !process.env.CHANGELOG_NO_LLM) {
+  const changelogConfig = config.changelog === false ? false : { mode: "root", ...config.changelog ?? {} };
+  const releaseNotesConfig = config.releaseNotes === false || config.releaseNotes === void 0 ? void 0 : config.releaseNotes.mode !== void 0 || config.releaseNotes.file !== void 0 ? { mode: "root", ...config.releaseNotes } : config.releaseNotes;
+  const llmConfig = releaseNotesConfig?.llm;
+  if (llmConfig && !process.env.CHANGELOG_NO_LLM) {
     info("Processing with LLM enhancement");
-    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
+    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, llmConfig)));
   }
   const files = [];
   const fmtOpts = {
     includePackageName: contexts.length > 1 || contexts.some((c) => c.packageName.includes("/"))
   };
-  for (const output of config.output) {
-    const file = output.file ?? (output.format === "json" ? "changelog.json" : "CHANGELOG.md");
-    const isChangelog = /changelog/i.test(file);
-    const outputKind = isChangelog ? "changelog" : "release notes";
-    info(`Generating ${outputKind} \u2192 ${file}`);
-    switch (output.format) {
-      case "markdown": {
-        const file2 = output.file ?? "CHANGELOG.md";
-        try {
-          const effectiveTemplateConfig = output.templates ?? config.templates;
-          if (effectiveTemplateConfig?.path || output.options?.template) {
-            const configWithTemplate = { ...config, templates: effectiveTemplateConfig };
-            await generateWithTemplate(contexts, configWithTemplate, file2, dryRun);
-          } else {
-            writeMarkdown(file2, contexts, config, dryRun, fmtOpts);
-          }
-          if (!dryRun) files.push(file2);
-        } catch (error) {
-          warn(`Failed to write ${file2}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        break;
-      }
-      case "json": {
-        const file2 = output.file ?? "changelog.json";
-        try {
-          writeJson(file2, contexts, dryRun);
-          if (!dryRun) files.push(file2);
-        } catch (error) {
-          warn(`Failed to write ${file2}: ${error instanceof Error ? error.message : String(error)}`);
+  if (changelogConfig !== false && changelogConfig.mode) {
+    const fileName = changelogConfig.file ?? "CHANGELOG.md";
+    const mode = changelogConfig.mode;
+    info(`Generating changelog \u2192 ${fileName}`);
+    try {
+      if (mode === "root" || mode === "both") {
+        if (changelogConfig.templates?.path) {
+          await generateWithTemplate(
+            contexts,
+            changelogConfig.templates,
+            fileName,
+            contexts[0]?.repoUrl ?? void 0,
+            dryRun
+          );
+        } else {
+          writeMarkdown(fileName, contexts, config, dryRun, fmtOpts);
         }
-        break;
+        if (!dryRun) files.push(fileName);
       }
-      case "github-release": {
-        if (dryRun) {
-          info("[DRY RUN] Would create GitHub release");
-          break;
-        }
-        const firstContext = contexts[0];
-        if (!firstContext) {
-          warn("No context available for GitHub release");
-          break;
-        }
-        const repoUrl = firstContext.repoUrl;
-        if (!repoUrl) {
-          warn("No repo URL available, cannot create GitHub release");
-          break;
-        }
-        const parsed = parseRepoUrl(repoUrl);
-        if (!parsed) {
-          warn(`Could not parse repo URL: ${repoUrl}`);
-          break;
-        }
-        await createGitHubRelease(firstContext, {
-          owner: parsed.owner,
-          repo: parsed.repo,
-          draft: output.options?.draft,
-          prerelease: output.options?.prerelease
-        });
-        break;
+      if (mode === "packages" || mode === "both") {
+        const monoFiles = await writeMonorepoFiles(contexts, config, dryRun, changelogConfig.file ?? "CHANGELOG.md");
+        files.push(...monoFiles);
       }
+    } catch (error) {
+      warn(`Failed to write changelog: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  if (config.monorepo?.mode) {
-    const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-XJ2EILO3.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);
+  if (releaseNotesConfig?.mode) {
+    const fileName = releaseNotesConfig.file ?? "RELEASE_NOTES.md";
+    const mode = releaseNotesConfig.mode;
+    info(`Generating release notes \u2192 ${fileName}`);
+    try {
+      if (mode === "root" || mode === "both") {
+        if (releaseNotesConfig.templates?.path) {
+          await generateWithTemplate(
+            contexts,
+            releaseNotesConfig.templates,
+            fileName,
+            contexts[0]?.repoUrl ?? void 0,
+            dryRun
+          );
+        } else {
+          writeMarkdown(fileName, contexts, config, dryRun, fmtOpts);
+        }
+        if (!dryRun) files.push(fileName);
+      }
+      if (mode === "packages" || mode === "both") {
+        const monoFiles = await writeMonorepoFiles(
+          contexts,
+          config,
+          dryRun,
+          releaseNotesConfig.file ?? "RELEASE_NOTES.md"
+        );
+        files.push(...monoFiles);
+      }
+    } catch (error) {
+      warn(`Failed to write release notes: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   const packageNotes = {};
+  const releaseNotesResult = {};
   for (const ctx of contexts) {
     packageNotes[ctx.packageName] = formatVersion(ctx);
+    if (ctx.enhanced?.releaseNotes) {
+      releaseNotesResult[ctx.packageName] = ctx.enhanced.releaseNotes;
+    }
   }
-  return { packageNotes, files };
+  return {
+    packageNotes,
+    files,
+    releaseNotes: Object.keys(releaseNotesResult).length > 0 ? releaseNotesResult : void 0
+  };
 }
 async function processInput(inputJson, config, dryRun) {
   const input = parseVersionOutput(inputJson);
   return runPipeline(input, config, dryRun);
 }
+async function writeMonorepoFiles(contexts, config, dryRun, fileName) {
+  const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-IUQUAVJC.js");
+  const cwd = process.cwd();
+  const detected = detectMonorepo(cwd);
+  if (!detected.isMonorepo) return [];
+  const monoFiles = writeMonorepoChangelogs(
+    contexts,
+    {
+      rootPath: config.monorepo?.rootPath ?? cwd,
+      packagesPath: config.monorepo?.packagesPath ?? detected.packagesPath,
+      mode: "packages",
+      fileName
+    },
+    config,
+    dryRun
+  );
+  return monoFiles;
+}
 
 export {
   loadAuth,
   saveAuth,
-  loadConfig2 as loadConfig,
-  getDefaultConfig,
+  loadConfig,
   NotesError,
   InputParseError,
   TemplateError,
@@ -1893,8 +1749,8 @@ export {
   parseVersionOutput,
   parseVersionOutputFile,
   parseVersionOutputStdin,
-  renderJson,
-  writeJson,
+  loadConfig2,
+  getDefaultConfig,
   createTemplateContext,
   runPipeline,
   processInput