@releasekit/notes 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1473 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChangelogCreatorError: () => NotesError,
+  ConfigError: () => ConfigError,
+  EXIT_CODES: () => import_core2.EXIT_CODES,
+  GitHubError: () => GitHubError,
+  InputParseError: () => InputParseError,
+  LLMError: () => LLMError,
+  NotesError: () => NotesError,
+  TemplateError: () => TemplateError,
+  aggregateToRoot: () => aggregateToRoot,
+  createTemplateContext: () => createTemplateContext,
+  detectMonorepo: () => detectMonorepo,
+  getDefaultConfig: () => getDefaultConfig,
+  getExitCode: () => getExitCode,
+  loadAuth: () => import_config.loadAuth,
+  loadConfig: () => loadConfig,
+  parsePackageVersioner: () => parsePackageVersioner,
+  parsePackageVersionerFile: () => parsePackageVersionerFile,
+  parsePackageVersionerStdin: () => parsePackageVersionerStdin,
+  processInput: () => processInput,
+  renderJson: () => renderJson,
+  renderMarkdown: () => renderMarkdown,
+  runPipeline: () => runPipeline,
+  saveAuth: () => import_config.saveAuth,
+  writeJson: () => writeJson,
+  writeMarkdown: () => writeMarkdown,
+  writeMonorepoChangelogs: () => writeMonorepoChangelogs
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/config.ts
+var import_config = require("@releasekit/config");
+function loadConfig(projectDir = process.cwd(), configFile) {
+  const options = { cwd: projectDir, configPath: configFile };
+  return (0, import_config.loadNotesConfig)(options) ?? getDefaultConfig();
+}
+function getDefaultConfig() {
+  return {
+    output: [{ format: "markdown", file: "CHANGELOG.md" }],
+    updateStrategy: "prepend"
+  };
+}
+
+// src/core/pipeline.ts
+var fs8 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+var import_core7 = require("@releasekit/core");
+
+// src/input/package-versioner.ts
+var fs = __toESM(require("fs"), 1);
+
+// src/errors/index.ts
+var import_core = require("@releasekit/core");
+var import_core2 = require("@releasekit/core");
+var NotesError = class extends import_core.ReleaseKitError {
+};
+var InputParseError = class extends NotesError {
+  code = "INPUT_PARSE_ERROR";
+  suggestions = [
+    "Ensure input is valid JSON",
+    "Check that input matches expected schema",
+    "Use --input-source to specify format"
+  ];
+};
+var TemplateError = class extends NotesError {
+  code = "TEMPLATE_ERROR";
+  suggestions = [
+    "Check template syntax",
+    "Ensure all required files exist (document, version, entry)",
+    "Verify template engine matches file extension"
+  ];
+};
+var LLMError = class extends NotesError {
+  code = "LLM_ERROR";
+  suggestions = [
+    "Check API key is configured",
+    "Verify model name is correct",
+    "Check network connectivity",
+    "Try with --no-llm to skip LLM processing"
+  ];
+};
+var GitHubError = class extends NotesError {
+  code = "GITHUB_ERROR";
+  suggestions = [
+    "Ensure GITHUB_TOKEN is set",
+    "Check token has repo scope",
+    "Verify repository exists and is accessible"
+  ];
+};
+var ConfigError = class extends NotesError {
+  code = "CONFIG_ERROR";
+  suggestions = [
+    "Check config file syntax",
+    "Verify all required fields are present",
+    "Run releasekit-notes init to create default config"
+  ];
+};
+function getExitCode(error) {
+  switch (error.code) {
+    case "CONFIG_ERROR":
+      return import_core.EXIT_CODES.CONFIG_ERROR;
+    case "INPUT_PARSE_ERROR":
+      return import_core.EXIT_CODES.INPUT_ERROR;
+    case "TEMPLATE_ERROR":
+      return import_core.EXIT_CODES.TEMPLATE_ERROR;
+    case "LLM_ERROR":
+      return import_core.EXIT_CODES.LLM_ERROR;
+    case "GITHUB_ERROR":
+      return import_core.EXIT_CODES.GITHUB_ERROR;
+    default:
+      return import_core.EXIT_CODES.GENERAL_ERROR;
+  }
+}
+
+// src/input/package-versioner.ts
+function normalizeEntryType(type) {
+  const typeMap = {
+    added: "added",
+    feat: "added",
+    feature: "added",
+    changed: "changed",
+    update: "changed",
+    refactor: "changed",
+    deprecated: "deprecated",
+    removed: "removed",
+    fixed: "fixed",
+    fix: "fixed",
+    security: "security",
+    sec: "security"
+  };
+  return typeMap[type.toLowerCase()] ?? "changed";
+}
+function parsePackageVersioner(json) {
+  let data;
+  try {
+    data = JSON.parse(json);
+  } catch (error) {
+    throw new InputParseError(`Invalid JSON input: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!data.changelogs || !Array.isArray(data.changelogs)) {
+    throw new InputParseError('Input must contain a "changelogs" array');
+  }
+  const packages = data.changelogs.map((changelog) => ({
+    packageName: changelog.packageName,
+    version: changelog.version,
+    previousVersion: changelog.previousVersion,
+    revisionRange: changelog.revisionRange,
+    repoUrl: changelog.repoUrl,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+    entries: changelog.entries.map((entry) => ({
+      type: normalizeEntryType(entry.type),
+      description: entry.description,
+      issueIds: entry.issueIds,
+      scope: entry.scope,
+      originalType: entry.originalType,
+      breaking: entry.breaking ?? entry.originalType?.includes("!") ?? false
+    }))
+  }));
+  const repoUrl = packages[0]?.repoUrl ?? null;
+  return {
+    source: "package-versioner",
+    packages,
+    metadata: {
+      repoUrl: repoUrl ?? void 0
+    }
+  };
+}
+function parsePackageVersionerFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return parsePackageVersioner(content);
+}
+async function parsePackageVersionerStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const content = chunks.join("");
+  return parsePackageVersioner(content);
+}
+
+// src/llm/defaults.ts
+var LLM_DEFAULTS = {
+  timeout: 6e4,
+  maxTokens: 2e3,
+  temperature: 0.7,
+  concurrency: 5,
+  retry: {
+    maxAttempts: 3,
+    initialDelay: 1e3,
+    maxDelay: 3e4,
+    backoffFactor: 2
+  },
+  models: {
+    openai: "gpt-4o-mini",
+    "openai-compatible": "gpt-4o-mini",
+    anthropic: "claude-3-5-haiku-latest",
+    ollama: "llama3.2"
+  }
+};
+
+// src/llm/anthropic.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+
+// src/llm/base.ts
+var BaseLLMProvider = class {
+  getTimeout(options) {
+    return options?.timeout ?? LLM_DEFAULTS.timeout;
+  }
+  getMaxTokens(options) {
+    return options?.maxTokens ?? LLM_DEFAULTS.maxTokens;
+  }
+  getTemperature(options) {
+    return options?.temperature ?? LLM_DEFAULTS.temperature;
+  }
+};
+
+// src/llm/anthropic.ts
+var AnthropicProvider = class extends BaseLLMProvider {
+  name = "anthropic";
+  client;
+  model;
+  constructor(config = {}) {
+    super();
+    const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new LLMError("Anthropic API key not configured. Set ANTHROPIC_API_KEY or use --llm-api-key");
+    }
+    this.client = new import_sdk.default({ apiKey });
+    this.model = config.model ?? LLM_DEFAULTS.models.anthropic;
+  }
+  async complete(prompt, options) {
+    try {
+      const response = await this.client.messages.create({
+        model: this.model,
+        max_tokens: this.getMaxTokens(options),
+        messages: [{ role: "user", content: prompt }]
+      });
+      const firstBlock = response.content[0];
+      if (!firstBlock || firstBlock.type !== "text") {
+        throw new LLMError("Unexpected response format from Anthropic");
+      }
+      return firstBlock.text;
+    } catch (error) {
+      if (error instanceof LLMError) throw error;
+      throw new LLMError(`Anthropic API error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// src/llm/ollama.ts
+var OllamaProvider = class extends BaseLLMProvider {
+  name = "ollama";
+  baseURL;
+  model;
+  constructor(config = {}) {
+    super();
+    this.baseURL = config.baseURL ?? process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+    this.model = config.model ?? LLM_DEFAULTS.models.ollama;
+  }
+  async complete(prompt, options) {
+    const requestBody = {
+      model: this.model,
+      prompt,
+      stream: false,
+      options: {
+        num_predict: this.getMaxTokens(options),
+        temperature: this.getTemperature(options)
+      }
+    };
+    try {
+      const response = await fetch(`${this.baseURL}/api/generate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new LLMError(`Ollama request failed: ${response.status} ${text}`);
+      }
+      const data = await response.json();
+      if (!data.response) {
+        throw new LLMError("Empty response from Ollama");
+      }
+      return data.response;
+    } catch (error) {
+      if (error instanceof LLMError) throw error;
+      throw new LLMError(`Ollama error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// src/llm/openai.ts
+var import_openai = __toESM(require("openai"), 1);
+var OpenAIProvider = class extends BaseLLMProvider {
+  name = "openai";
+  client;
+  model;
+  constructor(config = {}) {
+    super();
+    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new LLMError("OpenAI API key not configured. Set OPENAI_API_KEY or use --llm-api-key");
+    }
+    this.client = new import_openai.default({
+      apiKey,
+      baseURL: config.baseURL
+    });
+    this.model = config.model ?? LLM_DEFAULTS.models.openai;
+  }
+  async complete(prompt, options) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: this.getMaxTokens(options),
+        temperature: this.getTemperature(options)
+      });
+      const content = response.choices[0]?.message?.content;
+      if (!content) {
+        throw new LLMError("Empty response from OpenAI");
+      }
+      return content;
+    } catch (error) {
+      if (error instanceof LLMError) throw error;
+      throw new LLMError(`OpenAI API error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// src/llm/openai-compatible.ts
+var import_openai2 = __toESM(require("openai"), 1);
+var OpenAICompatibleProvider = class extends BaseLLMProvider {
+  name = "openai-compatible";
+  client;
+  model;
+  constructor(config) {
+    super();
+    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY ?? "dummy";
+    this.client = new import_openai2.default({
+      apiKey,
+      baseURL: config.baseURL
+    });
+    this.model = config.model ?? LLM_DEFAULTS.models["openai-compatible"];
+  }
+  async complete(prompt, options) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: this.getMaxTokens(options),
+        temperature: this.getTemperature(options)
+      });
+      const content = response.choices[0]?.message?.content;
+      if (!content) {
+        throw new LLMError("Empty response from LLM");
+      }
+      return content;
+    } catch (error) {
+      if (error instanceof LLMError) throw error;
+      throw new LLMError(`LLM API error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// src/llm/tasks/categorize.ts
+var import_core3 = require("@releasekit/core");
+var 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").
+
+Output a JSON object where keys are category names and values are arrays of entry indices (0-based).
+
+Entries:
+{{entries}}
+
+Output only valid JSON, nothing else:`;
+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 prompt = CATEGORIZE_PROMPT.replace("{{entries}}", entriesText);
+  try {
+    const response = await provider.complete(prompt);
+    const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const result = [];
+    for (const [category, indices] of Object.entries(parsed)) {
+      const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
+      if (categoryEntries.length > 0) {
+        result.push({
+          category,
+          entries: categoryEntries
+        });
+      }
+    }
+    return result;
+  } catch (error) {
+    (0, import_core3.warn)(
+      `LLM categorization failed, falling back to General: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return [{ category: "General", entries }];
+  }
+}
+
+// src/llm/tasks/enhance.ts
+var 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:
+- Be concise (1-2 sentences max)
+- Use present tense ("Add feature" not "Added feature")
+- Focus on user impact, not implementation details
+- Don't use technical jargon unless necessary
+- Preserve the scope if mentioned (e.g., "core:", "api:")
+
+Original entry:
+Type: {{type}}
+{{#if scope}}Scope: {{scope}}{{/if}}
+Description: {{description}}
+
+Rewritten description (only output the new description, nothing else):`;
+async function enhanceEntry(provider, entry, _context) {
+  const prompt = ENHANCE_PROMPT.replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
+  const response = await provider.complete(prompt);
+  return response.trim();
+}
+async function enhanceEntries(provider, entries, context, concurrency = LLM_DEFAULTS.concurrency) {
+  const results = [];
+  for (let i = 0; i < entries.length; i += concurrency) {
+    const batch = entries.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(async (entry) => {
+        try {
+          const newDescription = await enhanceEntry(provider, entry, context);
+          return { ...entry, description: newDescription };
+        } catch {
+          return entry;
+        }
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/llm/tasks/release-notes.ts
+var RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
+
+Create engaging, user-friendly release notes for the following changes.
+
+Rules:
+- Start with a brief introduction (1-2 sentences)
+- Group related changes into sections
+- Use friendly, approachable language
+- Highlight breaking changes prominently
+- End with a brief conclusion or call to action
+- Use markdown formatting
+
+Version: {{version}}
+{{#if previousVersion}}Previous version: {{previousVersion}}{{/if}}
+Date: {{date}}
+
+Changes:
+{{entries}}
+
+Release notes (output only the markdown content):`;
+async function generateReleaseNotes(provider, entries, context) {
+  if (entries.length === 0) {
+    return `## Release ${context.version ?? "v1.0.0"}
+
+No notable changes in this release.`;
+  }
+  const entriesText = entries.map((e) => {
+    let line = `- [${e.type}]`;
+    if (e.scope) line += ` (${e.scope})`;
+    line += `: ${e.description}`;
+    if (e.breaking) line += " **BREAKING**";
+    return line;
+  }).join("\n");
+  const prompt = 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 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.
+
+Given the following changelog entries, create a brief summary (2-3 sentences) that captures the main themes of this release.
+
+Entries:
+{{entries}}
+
+Summary (only output the summary, nothing else):`;
+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 response = await provider.complete(prompt);
+  return response.trim();
+}
+
+// src/llm/index.ts
+function createProvider(config) {
+  const authKeys = (0, import_config.loadAuth)();
+  const apiKey = config.apiKey ?? authKeys[config.provider];
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIProvider({
+        apiKey,
+        baseURL: config.baseURL,
+        model: config.model
+      });
+    case "anthropic":
+      return new AnthropicProvider({
+        apiKey,
+        model: config.model
+      });
+    case "ollama":
+      return new OllamaProvider({
+        baseURL: config.baseURL,
+        model: config.model
+      });
+    case "openai-compatible": {
+      if (!config.baseURL) {
+        throw new LLMError("openai-compatible provider requires baseURL");
+      }
+      return new OpenAICompatibleProvider({
+        apiKey,
+        baseURL: config.baseURL,
+        model: config.model
+      });
+    }
+    default:
+      throw new LLMError(`Unknown LLM provider: ${config.provider}`);
+  }
+}
+
+// src/output/github-release.ts
+var import_rest = require("@octokit/rest");
+var import_core5 = require("@releasekit/core");
+
+// src/output/markdown.ts
+var fs2 = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_core4 = 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("");
+  }
+  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_core4.info)("--- Changelog Preview ---");
+    console.log(content);
+    (0, import_core4.info)("--- End Preview ---");
+    return;
+  }
+  const dir = path.dirname(outputPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  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_core4.success)(`Changelog written to ${outputPath}`);
+}
+
+// src/output/github-release.ts
+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 import_rest.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]);
+    }
+    (0, import_core5.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
+      });
+      (0, import_core5.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]);
+    }
+    (0, import_core5.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
+      });
+      (0, import_core5.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/output/json.ts
+var fs3 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_core6 = require("@releasekit/core");
+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) {
+    (0, import_core6.info)("--- JSON Output Preview ---");
+    console.log(content);
+    (0, import_core6.info)("--- End Preview ---");
+    return;
+  }
+  const dir = path2.dirname(outputPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(outputPath, content, "utf-8");
+  (0, import_core6.success)(`JSON output written to ${outputPath}`);
+}
+
+// src/templates/ejs.ts
+var fs4 = __toESM(require("fs"), 1);
+var import_ejs = __toESM(require("ejs"), 1);
+function renderEjs(template, context) {
+  try {
+    return import_ejs.default.render(template, context);
+  } catch (error) {
+    throw new TemplateError(`EJS render error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function renderEjsFile(filePath, context) {
+  if (!fs4.existsSync(filePath)) {
+    throw new TemplateError(`Template file not found: ${filePath}`);
+  }
+  const template = fs4.readFileSync(filePath, "utf-8");
+  return renderEjs(template, context);
+}
+
+// src/templates/handlebars.ts
+var fs5 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_handlebars = __toESM(require("handlebars"), 1);
+function registerHandlebarsHelpers() {
+  import_handlebars.default.registerHelper("capitalize", (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  import_handlebars.default.registerHelper("eq", (a, b) => {
+    return a === b;
+  });
+  import_handlebars.default.registerHelper("ne", (a, b) => {
+    return a !== b;
+  });
+  import_handlebars.default.registerHelper("join", (arr, separator) => {
+    return Array.isArray(arr) ? arr.join(separator) : "";
+  });
+}
+function renderHandlebars(template, context) {
+  registerHandlebarsHelpers();
+  try {
+    const compiled = import_handlebars.default.compile(template);
+    return compiled(context);
+  } catch (error) {
+    throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function renderHandlebarsFile(filePath, context) {
+  if (!fs5.existsSync(filePath)) {
+    throw new TemplateError(`Template file not found: ${filePath}`);
+  }
+  const template = fs5.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)) {
+    throw new TemplateError(`Document template not found: ${documentPath}`);
+  }
+  if (fs5.existsSync(versionPath)) {
+    import_handlebars.default.registerPartial("version", fs5.readFileSync(versionPath, "utf-8"));
+  }
+  if (fs5.existsSync(entryPath)) {
+    import_handlebars.default.registerPartial("entry", fs5.readFileSync(entryPath, "utf-8"));
+  }
+  try {
+    const compiled = import_handlebars.default.compile(fs5.readFileSync(documentPath, "utf-8"));
+    return compiled(context);
+  } catch (error) {
+    throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/templates/liquid.ts
+var fs6 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_liquidjs = require("liquidjs");
+function createLiquidEngine(root) {
+  return new import_liquidjs.Liquid({
+    root: root ? [root] : [],
+    extname: ".liquid",
+    cache: false
+  });
+}
+function renderLiquid(template, context) {
+  const engine = createLiquidEngine();
+  try {
+    return engine.renderSync(engine.parse(template), context);
+  } catch (error) {
+    throw new TemplateError(`Liquid render error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function renderLiquidFile(filePath, context) {
+  if (!fs6.existsSync(filePath)) {
+    throw new TemplateError(`Template file not found: ${filePath}`);
+  }
+  const template = fs6.readFileSync(filePath, "utf-8");
+  return renderLiquid(template, context);
+}
+function renderLiquidComposable(templateDir, context) {
+  const documentPath = path4.join(templateDir, "document.liquid");
+  if (!fs6.existsSync(documentPath)) {
+    throw new TemplateError(`Document template not found: ${documentPath}`);
+  }
+  const engine = createLiquidEngine(templateDir);
+  try {
+    return engine.renderFileSync("document", context);
+  } catch (error) {
+    throw new TemplateError(`Liquid render error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/templates/loader.ts
+var fs7 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+function getEngineFromFile(filePath) {
+  const ext = path5.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".liquid":
+      return "liquid";
+    case ".hbs":
+    case ".handlebars":
+      return "handlebars";
+    case ".ejs":
+      return "ejs";
+    default:
+      throw new TemplateError(`Unknown template extension: ${ext}`);
+  }
+}
+function getRenderFn(engine) {
+  switch (engine) {
+    case "liquid":
+      return renderLiquid;
+    case "handlebars":
+      return renderHandlebars;
+    case "ejs":
+      return renderEjs;
+  }
+}
+function getRenderFileFn(engine) {
+  switch (engine) {
+    case "liquid":
+      return renderLiquidFile;
+    case "handlebars":
+      return renderHandlebarsFile;
+    case "ejs":
+      return renderEjsFile;
+  }
+}
+function detectTemplateMode(templatePath) {
+  if (!fs7.existsSync(templatePath)) {
+    throw new TemplateError(`Template path not found: ${templatePath}`);
+  }
+  const stat = fs7.statSync(templatePath);
+  if (stat.isFile()) {
+    return "single";
+  }
+  if (stat.isDirectory()) {
+    return "composable";
+  }
+  throw new TemplateError(`Invalid template path: ${templatePath}`);
+}
+function renderSingleFile(templatePath, context, engine) {
+  const resolvedEngine = engine ?? getEngineFromFile(templatePath);
+  const renderFile = getRenderFileFn(resolvedEngine);
+  return {
+    content: renderFile(templatePath, context),
+    engine: resolvedEngine
+  };
+}
+function renderComposable(templateDir, context, engine) {
+  const files = fs7.readdirSync(templateDir);
+  const engineMap = {
+    liquid: { document: "document.liquid", version: "version.liquid", entry: "entry.liquid" },
+    handlebars: { document: "document.hbs", version: "version.hbs", entry: "entry.hbs" },
+    ejs: { document: "document.ejs", version: "version.ejs", entry: "entry.ejs" }
+  };
+  let resolvedEngine;
+  if (engine) {
+    resolvedEngine = engine;
+  } else {
+    const detected = detectEngineFromFiles(templateDir, files);
+    if (!detected) {
+      throw new TemplateError(`Could not detect template engine. Found files: ${files.join(", ")}`);
+    }
+    resolvedEngine = detected;
+  }
+  if (resolvedEngine === "liquid") {
+    return { content: renderLiquidComposable(templateDir, context), engine: resolvedEngine };
+  }
+  if (resolvedEngine === "handlebars") {
+    return { content: renderHandlebarsComposable(templateDir, context), engine: resolvedEngine };
+  }
+  const expectedFiles = engineMap[resolvedEngine];
+  const documentPath = path5.join(templateDir, expectedFiles.document);
+  if (!fs7.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 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;
+  if (entryTemplate && versionTemplate) {
+    const versionsWithEntries = context.versions.map((versionCtx) => {
+      const entries = versionCtx.entries.map((entry) => {
+        const entryCtx = { ...entry, packageName: versionCtx.packageName, version: versionCtx.version };
+        return render(entryTemplate, entryCtx);
+      });
+      return render(versionTemplate, { ...versionCtx, renderedEntries: entries });
+    });
+    const docContext = { ...context, renderedVersions: versionsWithEntries };
+    return {
+      content: render(fs7.readFileSync(documentPath, "utf-8"), docContext),
+      engine: resolvedEngine
+    };
+  }
+  return renderSingleFile(documentPath, context, resolvedEngine);
+}
+function detectEngineFromFiles(_dir, files) {
+  if (files.some((f) => f.endsWith(".liquid"))) return "liquid";
+  if (files.some((f) => f.endsWith(".hbs") || f.endsWith(".handlebars"))) return "handlebars";
+  if (files.some((f) => f.endsWith(".ejs"))) return "ejs";
+  return null;
+}
+function validateDocumentContext(context, templatePath) {
+  if (!context.project?.name) {
+    throw new TemplateError(`${templatePath}: DocumentContext missing required field "project.name"`);
+  }
+  if (!Array.isArray(context.versions)) {
+    throw new TemplateError(`${templatePath}: DocumentContext missing required field "versions" (must be an array)`);
+  }
+  const requiredVersionFields = ["packageName", "version", "date", "entries"];
+  for (const [i, v] of context.versions.entries()) {
+    for (const field of requiredVersionFields) {
+      if (v[field] === void 0 || v[field] === null) {
+        throw new TemplateError(`${templatePath}: versions[${i}] missing required field "${field}"`);
+      }
+    }
+    if (!Array.isArray(v.entries)) {
+      throw new TemplateError(`${templatePath}: versions[${i}].entries must be an array`);
+    }
+  }
+}
+function renderTemplate(templatePath, context, engine) {
+  validateDocumentContext(context, templatePath);
+  const mode = detectTemplateMode(templatePath);
+  if (mode === "single") {
+    return renderSingleFile(templatePath, context, engine);
+  }
+  return renderComposable(templatePath, context, engine);
+}
+
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const initialDelay = options.initialDelay ?? 1e3;
+  const maxDelay = options.maxDelay ?? 3e4;
+  const backoffFactor = options.backoffFactor ?? 2;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
+        const jitter = base * 0.2 * (Math.random() * 2 - 1);
+        await sleep(Math.max(0, base + jitter));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/core/pipeline.ts
+var import_meta = {};
+function generateCompareUrl(repoUrl, from, to) {
+  if (/gitlab\.com/i.test(repoUrl)) {
+    return `${repoUrl}/-/compare/${from}...${to}`;
+  }
+  if (/bitbucket\.org/i.test(repoUrl)) {
+    return `${repoUrl}/branches/compare/${from}..${to}`;
+  }
+  return `${repoUrl}/compare/${from}...${to}`;
+}
+function createTemplateContext(pkg) {
+  const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version) : void 0;
+  return {
+    packageName: pkg.packageName,
+    version: pkg.version,
+    previousVersion: pkg.previousVersion,
+    date: pkg.date,
+    repoUrl: pkg.repoUrl,
+    entries: pkg.entries,
+    compareUrl
+  };
+}
+function createDocumentContext(contexts, repoUrl) {
+  const compareUrls = {};
+  for (const ctx of contexts) {
+    if (ctx.compareUrl) {
+      compareUrls[ctx.version] = ctx.compareUrl;
+    }
+  }
+  return {
+    project: {
+      name: contexts[0]?.packageName ?? "project",
+      repoUrl
+    },
+    versions: contexts,
+    compareUrls: Object.keys(compareUrls).length > 0 ? compareUrls : void 0
+  };
+}
+async function processWithLLM(context, config) {
+  if (!config.llm) {
+    return context;
+  }
+  const tasks = config.llm.tasks ?? {};
+  const llmContext = {
+    packageName: context.packageName,
+    version: context.version,
+    previousVersion: context.previousVersion ?? void 0,
+    date: context.date
+  };
+  const enhanced = {
+    entries: context.entries
+  };
+  try {
+    const rawProvider = createProvider(config.llm);
+    const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
+    const provider = {
+      name: rawProvider.name,
+      complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, opts), retryOpts)
+    };
+    if (tasks.enhance) {
+      (0, import_core7.debug)("Enhancing entries with LLM");
+      enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
+    }
+    if (tasks.summarize) {
+      (0, import_core7.debug)("Summarizing entries with LLM");
+      enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
+    }
+    if (tasks.categorize) {
+      (0, import_core7.debug)("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;
+      }
+    }
+    if (tasks.releaseNotes) {
+      (0, import_core7.debug)("Generating release notes with LLM");
+      enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
+    }
+    return {
+      ...context,
+      entries: enhanced.entries,
+      enhanced
+    };
+  } catch (error) {
+    (0, import_core7.warn)(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
+    (0, import_core7.warn)("Falling back to raw entries");
+    return context;
+  }
+}
+function getBuiltinTemplatePath(style) {
+  let packageRoot;
+  try {
+    const currentUrl = import_meta.url;
+    packageRoot = path6.dirname(new URL(currentUrl).pathname);
+    packageRoot = path6.join(packageRoot, "..", "..");
+  } catch {
+    packageRoot = __dirname;
+  }
+  return path6.join(packageRoot, "templates", style);
+}
+async function generateWithTemplate(contexts, config, outputPath, dryRun) {
+  let templatePath;
+  if (config.templates?.path) {
+    templatePath = path6.resolve(config.templates.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);
+  if (dryRun) {
+    (0, import_core7.info)("--- Changelog Preview ---");
+    console.log(result.content);
+    (0, import_core7.info)("--- End Preview ---");
+    return;
+  }
+  const dir = path6.dirname(outputPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
+  }
+  fs8.writeFileSync(outputPath, result.content, "utf-8");
+  (0, import_core7.success)(`Changelog written to ${outputPath} (using ${result.engine} template)`);
+}
+async function runPipeline(input, config, dryRun) {
+  (0, import_core7.debug)(`Processing ${input.packages.length} package(s)`);
+  let contexts = input.packages.map(createTemplateContext);
+  if (config.llm && !process.env.CHANGELOG_NO_LLM && !dryRun) {
+    (0, import_core7.info)("Processing with LLM enhancement");
+    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
+  } else if (config.llm && dryRun) {
+    (0, import_core7.info)("Skipping LLM processing in dry-run mode");
+  }
+  for (const output of config.output) {
+    (0, import_core7.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);
+        }
+        break;
+      }
+      case "json": {
+        const file = output.file ?? "changelog.json";
+        writeJson(file, contexts, dryRun);
+        break;
+      }
+      case "github-release": {
+        if (dryRun) {
+          (0, import_core7.info)("[DRY RUN] Would create GitHub release");
+          break;
+        }
+        const firstContext = contexts[0];
+        if (!firstContext) {
+          (0, import_core7.warn)("No context available for GitHub release");
+          break;
+        }
+        const repoUrl = firstContext.repoUrl;
+        if (!repoUrl) {
+          (0, import_core7.warn)("No repo URL available, cannot create GitHub release");
+          break;
+        }
+        const parsed = parseRepoUrl(repoUrl);
+        if (!parsed) {
+          (0, import_core7.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;
+      }
+    }
+  }
+}
+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_core8 = 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_core8.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_core8.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
+      });
+    }
+  }
+  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_core8.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_core8.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_core8.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 {
+      }
+    }
+  }
+  return map;
+}
+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: "" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChangelogCreatorError,
+  ConfigError,
+  EXIT_CODES,
+  GitHubError,
+  InputParseError,
+  LLMError,
+  NotesError,
+  TemplateError,
+  aggregateToRoot,
+  createTemplateContext,
+  detectMonorepo,
+  getDefaultConfig,
+  getExitCode,
+  loadAuth,
+  loadConfig,
+  parsePackageVersioner,
+  parsePackageVersionerFile,
+  parsePackageVersionerStdin,
+  processInput,
+  renderJson,
+  renderMarkdown,
+  runPipeline,
+  saveAuth,
+  writeJson,
+  writeMarkdown,
+  writeMonorepoChangelogs
+});