@releasekit/notes 0.2.0-next.9 → 0.2.1

package/dist/index.cjs

@@ -1,1656 +0,0 @@
-"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_core8 = 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;
-  apiKey;
-  constructor(config = {}) {
-    super();
-    this.baseURL = config.baseURL ?? process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
-    this.model = config.model ?? LLM_DEFAULTS.models.ollama;
-    this.apiKey = config.apiKey ?? process.env.OLLAMA_API_KEY;
-  }
-  async complete(prompt, options) {
-    const requestBody = {
-      model: this.model,
-      messages: [{ role: "user", content: prompt }],
-      stream: false,
-      options: {
-        num_predict: this.getMaxTokens(options),
-        temperature: this.getTemperature(options)
-      }
-    };
-    try {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (this.apiKey) {
-        headers["Authorization"] = `Bearer ${this.apiKey}`;
-      }
-      const baseUrl = this.baseURL.endsWith("/api") ? this.baseURL.slice(0, -4) : this.baseURL;
-      const response = await fetch(`${baseUrl}/api/chat`, {
-        method: "POST",
-        headers,
-        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.message?.content) {
-        throw new LLMError("Empty response from Ollama");
-      }
-      return data.message.content;
-    } 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 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").
-
-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:`;
-function buildCustomCategorizePrompt(categories) {
-  const categoryList = categories.map((c) => `- "${c.name}": ${c.description}`).join("\n");
-  const developerCategory = categories.find((c) => c.name === "Developer");
-  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(", ")}.
-`;
-      }
-    }
-  }
-  return `You are categorizing changelog entries for a software release.
-
-Given the following entries, group them into the specified categories. Only use the categories listed below in this exact order:
-
-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
-
-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 hasCustomCategories = context.categories && context.categories.length > 0;
-  const promptTemplate = hasCustomCategories ? buildCustomCategorizePrompt(context.categories) : DEFAULT_CATEGORIZE_PROMPT;
-  const prompt = promptTemplate.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 = [];
-    if (hasCustomCategories && parsed.categories) {
-      const categoryMap = parsed.categories;
-      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 };
-        }
-      }
-      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);
-        if (categoryEntries.length > 0) {
-          result.push({ category, entries: categoryEntries });
-        }
-      }
-    } else {
-      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);
-        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)
-- Focus on user impact, not implementation details
-- Don't use technical jargon unless necessary
-- Preserve the scope if mentioned (e.g., "core:", "api:")
-{{style}}
-
-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 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);
-  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/enhance-and-categorize.ts
-var import_core4 = require("@releasekit/core");
-
-// 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/llm/tasks/enhance-and-categorize.ts
-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").`;
-  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
-2. **Categorize** each entry into the appropriate category
-
-Style guidelines:
-- ${styleText}
-- 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").' : ""}
-
-Entries:
-${entriesText}
-
-Output a JSON object with:
-- "entries": array of objects, one per input entry (same order), each with: { "description": "rewritten text", "category": "CategoryName", "scope": "optional subcategory label or null" }
-
-Output only valid JSON, nothing else:`;
-}
-async function enhanceAndCategorize(provider, entries, context) {
-  if (entries.length === 0) {
-    return { enhancedEntries: [], categories: [] };
-  }
-  const retryOpts = LLM_DEFAULTS.retry;
-  try {
-    return await withRetry(async () => {
-      const prompt = buildPrompt(entries, context.categories, context.style);
-      const response = await provider.complete(prompt);
-      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-      const parsed = JSON.parse(cleaned);
-      if (!Array.isArray(parsed.entries)) {
-        throw new Error('Response missing "entries" array');
-      }
-      const enhancedEntries = entries.map((original, i) => {
-        const result = parsed.entries[i];
-        if (!result) return original;
-        return {
-          ...original,
-          description: result.description || original.description,
-          scope: result.scope || original.scope
-        };
-      });
-      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];
-        if (!entry) continue;
-        if (!categoryMap.has(category)) {
-          categoryMap.set(category, []);
-        }
-        categoryMap.get(category).push(entry);
-      }
-      const categories = [];
-      for (const [category, catEntries] of categoryMap) {
-        categories.push({ category, entries: catEntries });
-      }
-      return { enhancedEntries, categories };
-    }, retryOpts);
-  } catch (error) {
-    (0, import_core4.warn)(
-      `Combined enhance+categorize failed after ${retryOpts.maxAttempts} attempts: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return {
-      enhancedEntries: entries,
-      categories: [{ category: "General", entries }]
-    };
-  }
-}
-
-// 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({
-        apiKey,
-        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_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
-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_core6.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_core6.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_core6.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_core6.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_core7 = 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_core7.info)("--- JSON Output Preview ---");
-    console.log(content);
-    (0, import_core7.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_core7.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/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,
-    categories: config.llm.categories,
-    style: config.llm.style
-  };
-  const enhanced = {
-    entries: context.entries
-  };
-  try {
-    (0, import_core8.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}`);
-    }
-    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)
-    };
-    const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
-    (0, import_core8.info)(`Running LLM tasks: ${activeTasks.join(", ")}`);
-    if (tasks.enhance && tasks.categorize) {
-      (0, import_core8.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`);
-    } else {
-      if (tasks.enhance) {
-        (0, import_core8.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`);
-      }
-      if (tasks.categorize) {
-        (0, import_core8.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`);
-      }
-    }
-    if (tasks.summarize) {
-      (0, import_core8.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)}...`);
-      } else {
-        (0, import_core8.warn)("Summary generation returned empty result");
-      }
-    }
-    if (tasks.releaseNotes) {
-      (0, import_core8.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");
-      } else {
-        (0, import_core8.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");
-    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_core8.info)("--- Changelog Preview ---");
-    console.log(result.content);
-    (0, import_core8.info)("--- 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 });
-  }
-  fs8.writeFileSync(outputPath, result.content, "utf-8");
-  (0, import_core8.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)`);
-  let contexts = input.packages.map(createTemplateContext);
-  if (config.llm && !process.env.CHANGELOG_NO_LLM) {
-    (0, import_core8.info)("Processing with LLM enhancement");
-    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
-  }
-  for (const output of config.output) {
-    (0, import_core8.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_core8.info)("[DRY RUN] Would create GitHub release");
-          break;
-        }
-        const firstContext = contexts[0];
-        if (!firstContext) {
-          (0, import_core8.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");
-          break;
-        }
-        const parsed = parseRepoUrl(repoUrl);
-        if (!parsed) {
-          (0, import_core8.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_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
-      });
-    }
-  }
-  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 {
-      }
-    }
-  }
-  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
-});