@releasekit/notes 0.3.0-next.3 → 0.3.0

package/dist/chunk-QUBVC5LF.js

@@ -1,1488 +0,0 @@
-import {
-  formatVersion,
-  renderMarkdown,
-  writeMarkdown
-} from "./chunk-QCF6V2IY.js";
-
-// src/core/config.ts
-import {
-  loadAuth,
-  loadNotesConfig as loadSharedNotesConfig,
-  saveAuth
-} from "@releasekit/config";
-function loadConfig(projectDir = process.cwd(), configFile) {
-  const options = { cwd: projectDir, configPath: configFile };
-  return loadSharedNotesConfig(options) ?? getDefaultConfig();
-}
-function getDefaultConfig() {
-  return {
-    output: [{ format: "markdown", file: "CHANGELOG.md" }],
-    updateStrategy: "prepend"
-  };
-}
-
-// src/errors/index.ts
-import { EXIT_CODES, ReleaseKitError } from "@releasekit/core";
-import { EXIT_CODES as EXIT_CODES2 } from "@releasekit/core";
-var NotesError = class extends 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 EXIT_CODES.CONFIG_ERROR;
-    case "INPUT_PARSE_ERROR":
-      return EXIT_CODES.INPUT_ERROR;
-    case "TEMPLATE_ERROR":
-      return EXIT_CODES.TEMPLATE_ERROR;
-    case "LLM_ERROR":
-      return EXIT_CODES.LLM_ERROR;
-    case "GITHUB_ERROR":
-      return EXIT_CODES.GITHUB_ERROR;
-    default:
-      return EXIT_CODES.GENERAL_ERROR;
-  }
-}
-
-// src/input/package-versioner.ts
-import * as fs from "fs";
-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/output/json.ts
-import * as fs2 from "fs";
-import * as path from "path";
-import { debug, info, success } from "@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) {
-    info(`Would write JSON output to ${outputPath}`);
-    debug("--- JSON Output Preview ---");
-    debug(content);
-    debug("--- End Preview ---");
-    return;
-  }
-  const dir = path.dirname(outputPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  fs2.writeFileSync(outputPath, content, "utf-8");
-  success(`JSON output written to ${outputPath}`);
-}
-
-// src/core/pipeline.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
-import { debug as debug2, info as info3, success as success3, warn as warn3 } from "@releasekit/core";
-
-// src/llm/defaults.ts
-var LLM_DEFAULTS = {
-  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
-import Anthropic from "@anthropic-ai/sdk";
-
-// 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 Anthropic({ 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
-import OpenAI from "openai";
-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 OpenAI({
-      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
-import OpenAI2 from "openai";
-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 OpenAI2({
-      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
-import { warn } from "@releasekit/core";
-
-// src/llm/prompts.ts
-function resolvePrompt(taskName, defaultPrompt, promptsConfig) {
-  if (!promptsConfig) return defaultPrompt;
-  const fullTemplate = promptsConfig.templates?.[taskName];
-  if (fullTemplate) return fullTemplate;
-  const additionalInstructions = promptsConfig.instructions?.[taskName];
-  if (additionalInstructions) {
-    const insertionPoint = defaultPrompt.lastIndexOf("Output only valid JSON");
-    if (insertionPoint !== -1) {
-      return `${defaultPrompt.slice(0, insertionPoint)}Additional instructions:
-${additionalInstructions}
-
-${defaultPrompt.slice(insertionPoint)}`;
-    }
-    return `${defaultPrompt}
-
-Additional instructions:
-${additionalInstructions}`;
-  }
-  return defaultPrompt;
-}
-
-// src/llm/scopes.ts
-function getAllowedScopesFromCategories(categories) {
-  const scopeMap = /* @__PURE__ */ new Map();
-  for (const cat of categories) {
-    if (cat.scopes && cat.scopes.length > 0) {
-      scopeMap.set(cat.name, cat.scopes);
-    }
-  }
-  return scopeMap;
-}
-function resolveAllowedScopes(scopeConfig, categories, packageNames) {
-  if (!scopeConfig || scopeConfig.mode === "unrestricted") return null;
-  if (scopeConfig.mode === "none") return [];
-  if (scopeConfig.mode === "packages") return packageNames ?? [];
-  if (scopeConfig.mode === "restricted") {
-    const explicit = scopeConfig.rules?.allowed ?? [];
-    const all = new Set(explicit);
-    if (categories) {
-      const fromCategories = getAllowedScopesFromCategories(categories);
-      for (const scopes of fromCategories.values()) {
-        for (const s of scopes) all.add(s);
-      }
-    }
-    return [...all];
-  }
-  return null;
-}
-function validateScope(scope, allowedScopes, rules) {
-  if (!scope || allowedScopes === null) return scope;
-  if (allowedScopes.length === 0) return void 0;
-  const caseSensitive = rules?.caseSensitive ?? false;
-  const normalise = (s) => caseSensitive ? s : s.toLowerCase();
-  const isAllowed = allowedScopes.some((a) => normalise(a) === normalise(scope));
-  if (isAllowed) return scope;
-  switch (rules?.invalidScopeAction ?? "remove") {
-    case "keep":
-      return scope;
-    case "fallback":
-      return rules?.fallbackScope;
-    default:
-      return void 0;
-  }
-}
-function validateEntryScopes(entries, scopeConfig, categories) {
-  const allowedScopes = resolveAllowedScopes(scopeConfig, categories);
-  if (allowedScopes === null) return entries;
-  return entries.map((entry) => ({
-    ...entry,
-    scope: validateScope(entry.scope, allowedScopes, scopeConfig?.rules)
-  }));
-}
-
-// src/llm/tasks/categorize.ts
-var DEFAULT_CATEGORIZE_PROMPT = `You are categorizing changelog entries for a software release.
-
-Given the following entries, group them into meaningful categories (e.g., "Core", "UI", "API", "Performance", "Bug Fixes", "Documentation").
-
-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) => {
-    const scopeInfo = c.scopes?.length ? ` Allowed scopes: ${c.scopes.join(", ")}.` : "";
-    return `- "${c.name}": ${c.description}${scopeInfo}`;
-  }).join("\n");
-  const scopeMap = getAllowedScopesFromCategories(categories);
-  let scopeInstructions = "";
-  if (scopeMap.size > 0) {
-    const entries = [];
-    for (const [catName, scopes] of scopeMap) {
-      entries.push(`For "${catName}", assign a scope from: ${scopes.join(", ")}.`);
-    }
-    scopeInstructions = `
-
-${entries.join("\n")}
-Only use scopes from these predefined lists. If an entry does not fit any scope, set scope to null.`;
-  }
-  return `You are categorizing changelog entries for a software release.
-
-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. Only include entries that have a valid scope from the predefined list.
-
-Entries:
-{{entries}}
-
-Output only valid JSON, nothing else:`;
-}
-async function categorizeEntries(provider, entries, context) {
-  if (entries.length === 0) {
-    return [];
-  }
-  const entriesCopy = entries.map((e) => ({ ...e, scope: void 0 }));
-  const entriesText = entriesCopy.map((e, i) => `${i}. [${e.type}]: ${e.description}`).join("\n");
-  const hasCustomCategories = context.categories && context.categories.length > 0;
-  const defaultPrompt = hasCustomCategories ? buildCustomCategorizePrompt(context.categories) : DEFAULT_CATEGORIZE_PROMPT;
-  const promptTemplate = resolvePrompt("categorize", defaultPrompt, context.prompts);
-  const prompt = promptTemplate.replace("{{entries}}", entriesText);
-  try {
-    const response = await provider.complete(prompt);
-    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 (entriesCopy[idx] && scope && scope.trim()) {
-          entriesCopy[idx] = { ...entriesCopy[idx], scope: scope.trim() };
-        }
-      }
-      const validatedEntries = validateEntryScopes(entriesCopy, context.scopes, context.categories);
-      for (const [category, rawIndices] of Object.entries(categoryMap)) {
-        const indices = Array.isArray(rawIndices) ? rawIndices : [];
-        const categoryEntries = indices.map((i) => validatedEntries[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) => entriesCopy[i]).filter((e) => e !== void 0);
-        if (categoryEntries.length > 0) {
-          result.push({ category, entries: categoryEntries });
-        }
-      }
-    }
-    return result;
-  } catch (error) {
-    warn(
-      `LLM categorization failed, falling back to General: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return [{ category: "General", entries: entriesCopy }];
-  }
-}
-
-// src/llm/tasks/enhance.ts
-var DEFAULT_ENHANCE_PROMPT = `You are improving changelog entries for a software project.
-Given a technical commit message, rewrite it as a clear, user-friendly changelog entry.
-
-Rules:
-- 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 defaultPrompt = DEFAULT_ENHANCE_PROMPT.replace("{{style}}", styleText).replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
-  const prompt = resolvePrompt("enhance", defaultPrompt, context.prompts);
-  const response = await provider.complete(prompt);
-  return response.trim();
-}
-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
-import { warn as warn2 } from "@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) => {
-    const scopeInfo = c.scopes?.length ? ` Allowed scopes: ${c.scopes.join(", ")}.` : "";
-    return `- "${c.name}": ${c.description}${scopeInfo}`;
-  }).join("\n")}` : `Categories: Group into meaningful categories (e.g., "New", "Fixed", "Changed", "Removed").`;
-  let scopeInstruction = "";
-  if (categories) {
-    const scopeMap = getAllowedScopesFromCategories(categories);
-    if (scopeMap.size > 0) {
-      const parts = [];
-      for (const [catName, scopes] of scopeMap) {
-        parts.push(`For "${catName}" entries, assign a scope from: ${scopes.join(", ")}.`);
-      }
-      scopeInstruction = `
-${parts.join("\n")}
-Only use scopes from these predefined lists. Set scope to null if no scope applies.`;
-    }
-  }
-  return `You are generating release notes for a software project. Given the following changelog entries, do two things:
-
-1. **Rewrite** each entry as a clear, user-friendly description
-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}${scopeInstruction}
-
-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 defaultPrompt = buildPrompt(entries, context.categories, context.style);
-      const prompt = resolvePrompt("enhanceAndCategorize", defaultPrompt, context.prompts);
-      const response = await provider.complete(prompt);
-      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-      const parsed = JSON.parse(cleaned);
-      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 validatedEntries = validateEntryScopes(enhancedEntries, context.scopes, context.categories);
-      const categoryMap = /* @__PURE__ */ new Map();
-      for (let i = 0; i < parsed.entries.length; i++) {
-        const result = parsed.entries[i];
-        const category = result?.category || "General";
-        const entry = validatedEntries[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: validatedEntries, categories };
-    }, retryOpts);
-  } catch (error) {
-    warn2(
-      `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 DEFAULT_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 defaultPrompt = DEFAULT_RELEASE_NOTES_PROMPT.replace("{{version}}", context.version ?? "v1.0.0").replace(
-    "{{#if previousVersion}}Previous version: {{previousVersion}}{{/if}}",
-    context.previousVersion ? `Previous version: ${context.previousVersion}` : ""
-  ).replace("{{date}}", context.date ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "").replace("{{entries}}", entriesText);
-  const prompt = resolvePrompt("releaseNotes", defaultPrompt, context.prompts);
-  const response = await provider.complete(prompt);
-  return response.trim();
-}
-
-// src/llm/tasks/summarize.ts
-var DEFAULT_SUMMARIZE_PROMPT = `You are creating a summary of changes for a software release.
-
-Given the following changelog entries, create a brief summary (2-3 sentences) that captures the main themes of this release.
-
-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 defaultPrompt = DEFAULT_SUMMARIZE_PROMPT.replace("{{entries}}", entriesText);
-  const prompt = resolvePrompt("summarize", defaultPrompt, context.prompts);
-  const response = await provider.complete(prompt);
-  return response.trim();
-}
-
-// src/llm/index.ts
-function createProvider(config) {
-  const authKeys = 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
-import { Octokit } from "@octokit/rest";
-import { info as info2, success as success2 } from "@releasekit/core";
-var GitHubClient = class {
-  octokit;
-  owner;
-  repo;
-  constructor(options) {
-    const token = options.token ?? process.env.GITHUB_TOKEN;
-    if (!token) {
-      throw new GitHubError("GITHUB_TOKEN not set. Set it as an environment variable.");
-    }
-    this.octokit = new Octokit({ auth: token });
-    this.owner = options.owner;
-    this.repo = options.repo;
-  }
-  async createRelease(context, options = {}) {
-    const tagName = `v${context.version}`;
-    let body;
-    if (context.enhanced?.releaseNotes) {
-      body = context.enhanced.releaseNotes;
-    } else {
-      body = renderMarkdown([context]);
-    }
-    info2(`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
-      });
-      success2(`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]);
-    }
-    info2(`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
-      });
-      success2(`Release updated: ${response.data.html_url}`);
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName
-      };
-    } catch (error) {
-      throw new GitHubError(`Failed to update release: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async getReleaseByTag(tag) {
-    try {
-      const response = await this.octokit.repos.getReleaseByTag({
-        owner: this.owner,
-        repo: this.repo,
-        tag
-      });
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName: response.data.tag_name
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-function parseRepoUrl(repoUrl) {
-  const patterns = [
-    /^https:\/\/github\.com\/([^/]+)\/([^/]+)/,
-    /^git@github\.com:([^/]+)\/([^/]+)/,
-    /^github\.com\/([^/]+)\/([^/]+)/
-  ];
-  for (const pattern of patterns) {
-    const match = repoUrl.match(pattern);
-    if (match?.[1] && match[2]) {
-      return {
-        owner: match[1],
-        repo: match[2].replace(/\.git$/, "")
-      };
-    }
-  }
-  return null;
-}
-async function createGitHubRelease(context, options) {
-  const client = new GitHubClient(options);
-  return client.createRelease(context, options);
-}
-
-// src/templates/ejs.ts
-import * as fs3 from "fs";
-import ejs from "ejs";
-function renderEjs(template, context) {
-  try {
-    return ejs.render(template, context);
-  } catch (error) {
-    throw new TemplateError(`EJS render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function renderEjsFile(filePath, context) {
-  if (!fs3.existsSync(filePath)) {
-    throw new TemplateError(`Template file not found: ${filePath}`);
-  }
-  const template = fs3.readFileSync(filePath, "utf-8");
-  return renderEjs(template, context);
-}
-
-// src/templates/handlebars.ts
-import * as fs4 from "fs";
-import * as path2 from "path";
-import Handlebars from "handlebars";
-function registerHandlebarsHelpers() {
-  Handlebars.registerHelper("capitalize", (str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  Handlebars.registerHelper("eq", (a, b) => {
-    return a === b;
-  });
-  Handlebars.registerHelper("ne", (a, b) => {
-    return a !== b;
-  });
-  Handlebars.registerHelper("join", (arr, separator) => {
-    return Array.isArray(arr) ? arr.join(separator) : "";
-  });
-}
-function renderHandlebars(template, context) {
-  registerHandlebarsHelpers();
-  try {
-    const compiled = Handlebars.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 (!fs4.existsSync(filePath)) {
-    throw new TemplateError(`Template file not found: ${filePath}`);
-  }
-  const template = fs4.readFileSync(filePath, "utf-8");
-  return renderHandlebars(template, context);
-}
-function renderHandlebarsComposable(templateDir, context) {
-  registerHandlebarsHelpers();
-  const versionPath = path2.join(templateDir, "version.hbs");
-  const entryPath = path2.join(templateDir, "entry.hbs");
-  const documentPath = path2.join(templateDir, "document.hbs");
-  if (!fs4.existsSync(documentPath)) {
-    throw new TemplateError(`Document template not found: ${documentPath}`);
-  }
-  if (fs4.existsSync(versionPath)) {
-    Handlebars.registerPartial("version", fs4.readFileSync(versionPath, "utf-8"));
-  }
-  if (fs4.existsSync(entryPath)) {
-    Handlebars.registerPartial("entry", fs4.readFileSync(entryPath, "utf-8"));
-  }
-  try {
-    const compiled = Handlebars.compile(fs4.readFileSync(documentPath, "utf-8"));
-    return compiled(context);
-  } catch (error) {
-    throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-// src/templates/liquid.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
-import { Liquid } from "liquidjs";
-function createLiquidEngine(root) {
-  return new 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 (!fs5.existsSync(filePath)) {
-    throw new TemplateError(`Template file not found: ${filePath}`);
-  }
-  const template = fs5.readFileSync(filePath, "utf-8");
-  return renderLiquid(template, context);
-}
-function renderLiquidComposable(templateDir, context) {
-  const documentPath = path3.join(templateDir, "document.liquid");
-  if (!fs5.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
-import * as fs6 from "fs";
-import * as path4 from "path";
-function getEngineFromFile(filePath) {
-  const ext = path4.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 (!fs6.existsSync(templatePath)) {
-    throw new TemplateError(`Template path not found: ${templatePath}`);
-  }
-  const stat = fs6.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 = fs6.readdirSync(templateDir);
-  const engineMap = {
-    liquid: { document: "document.liquid", version: "version.liquid", entry: "entry.liquid" },
-    handlebars: { document: "document.hbs", version: "version.hbs", entry: "entry.hbs" },
-    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 = path4.join(templateDir, expectedFiles.document);
-  if (!fs6.existsSync(documentPath)) {
-    throw new TemplateError(`Document template not found: ${expectedFiles.document}`);
-  }
-  const versionPath = path4.join(templateDir, expectedFiles.version);
-  const entryPath = path4.join(templateDir, expectedFiles.entry);
-  const render = getRenderFn(resolvedEngine);
-  const entryTemplate = fs6.existsSync(entryPath) ? fs6.readFileSync(entryPath, "utf-8") : null;
-  const versionTemplate = fs6.existsSync(versionPath) ? fs6.readFileSync(versionPath, "utf-8") : null;
-  if (entryTemplate && versionTemplate) {
-    const versionsWithEntries = context.versions.map((versionCtx) => {
-      const entries = versionCtx.entries.map((entry) => {
-        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(fs6.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
-function generateCompareUrl(repoUrl, from, to, packageName) {
-  const isPackageSpecific = from.includes("@") && packageName && from.includes(packageName);
-  let fromVersion;
-  let toVersion;
-  if (isPackageSpecific) {
-    fromVersion = from;
-    toVersion = `${packageName}@${to.startsWith("v") ? "" : "v"}${to}`;
-  } else {
-    fromVersion = from.replace(/^v/, "");
-    toVersion = to.replace(/^v/, "");
-  }
-  if (/gitlab\.com/i.test(repoUrl)) {
-    return `${repoUrl}/-/compare/${fromVersion}...${toVersion}`;
-  }
-  if (/bitbucket\.org/i.test(repoUrl)) {
-    return `${repoUrl}/branches/compare/${fromVersion}..${toVersion}`;
-  }
-  return `${repoUrl}/compare/${fromVersion}...${toVersion}`;
-}
-function createTemplateContext(pkg) {
-  const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version, pkg.packageName) : 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,
-    scopes: config.llm.scopes,
-    prompts: config.llm.prompts
-  };
-  const enhanced = {
-    entries: context.entries
-  };
-  try {
-    info3(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
-    if (config.llm.baseURL) {
-      info3(`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);
-    info3(`Running LLM tasks: ${activeTasks.join(", ")}`);
-    if (tasks.enhance && tasks.categorize) {
-      info3("Enhancing and categorizing entries with LLM...");
-      const result = await enhanceAndCategorize(provider, context.entries, llmContext);
-      enhanced.entries = result.enhancedEntries;
-      enhanced.categories = {};
-      for (const cat of result.categories) {
-        enhanced.categories[cat.category] = cat.entries;
-      }
-      info3(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
-    } else {
-      if (tasks.enhance) {
-        info3("Enhancing entries with LLM...");
-        enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
-        info3(`Enhanced ${enhanced.entries.length} entries`);
-      }
-      if (tasks.categorize) {
-        info3("Categorizing entries with LLM...");
-        const categorized = await categorizeEntries(provider, enhanced.entries, llmContext);
-        enhanced.categories = {};
-        for (const cat of categorized) {
-          enhanced.categories[cat.category] = cat.entries;
-        }
-        info3(`Created ${categorized.length} categories`);
-      }
-    }
-    if (tasks.summarize) {
-      info3("Summarizing entries with LLM...");
-      enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
-      if (enhanced.summary) {
-        info3("Summary generated successfully");
-        debug2(`Summary: ${enhanced.summary.substring(0, 100)}...`);
-      } else {
-        warn3("Summary generation returned empty result");
-      }
-    }
-    if (tasks.releaseNotes) {
-      info3("Generating release notes with LLM...");
-      enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
-      if (enhanced.releaseNotes) {
-        info3("Release notes generated successfully");
-      } else {
-        warn3("Release notes generation returned empty result");
-      }
-    }
-    return {
-      ...context,
-      enhanced
-    };
-  } catch (error) {
-    warn3(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
-    warn3("Falling back to raw entries");
-    return context;
-  }
-}
-function getBuiltinTemplatePath(style) {
-  let packageRoot;
-  try {
-    const currentUrl = import.meta.url;
-    packageRoot = path5.dirname(new URL(currentUrl).pathname);
-    packageRoot = path5.join(packageRoot, "..", "..");
-  } catch {
-    packageRoot = __dirname;
-  }
-  return path5.join(packageRoot, "templates", style);
-}
-async function generateWithTemplate(contexts, config, outputPath, dryRun) {
-  let templatePath;
-  if (config.templates?.path) {
-    templatePath = path5.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) {
-    info3(`Would write templated output to ${outputPath}`);
-    debug2("--- Changelog Preview ---");
-    debug2(result.content);
-    debug2("--- End Preview ---");
-    return;
-  }
-  if (outputPath === "-") {
-    process.stdout.write(result.content);
-    return;
-  }
-  const dir = path5.dirname(outputPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
-  }
-  fs7.writeFileSync(outputPath, result.content, "utf-8");
-  success3(`Changelog written to ${outputPath} (using ${result.engine} template)`);
-}
-async function runPipeline(input, config, dryRun) {
-  debug2(`Processing ${input.packages.length} package(s)`);
-  let contexts = input.packages.map(createTemplateContext);
-  if (config.llm && !process.env.CHANGELOG_NO_LLM) {
-    info3("Processing with LLM enhancement");
-    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
-  }
-  const files = [];
-  for (const output of config.output) {
-    const outputLabel = output.file ? `${output.format} output \u2192 ${output.file}` : `${output.format} output`;
-    info3(`Generating ${outputLabel}`);
-    switch (output.format) {
-      case "markdown": {
-        const file = output.file ?? "CHANGELOG.md";
-        try {
-          const effectiveTemplateConfig = output.templates ?? config.templates;
-          if (effectiveTemplateConfig?.path || output.options?.template) {
-            const configWithTemplate = { ...config, templates: effectiveTemplateConfig };
-            await generateWithTemplate(contexts, configWithTemplate, file, dryRun);
-          } else {
-            writeMarkdown(file, contexts, config, dryRun);
-          }
-          if (!dryRun) files.push(file);
-        } catch (error) {
-          warn3(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        break;
-      }
-      case "json": {
-        const file = output.file ?? "changelog.json";
-        try {
-          writeJson(file, contexts, dryRun);
-          if (!dryRun) files.push(file);
-        } catch (error) {
-          warn3(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        break;
-      }
-      case "github-release": {
-        if (dryRun) {
-          info3("[DRY RUN] Would create GitHub release");
-          break;
-        }
-        const firstContext = contexts[0];
-        if (!firstContext) {
-          warn3("No context available for GitHub release");
-          break;
-        }
-        const repoUrl = firstContext.repoUrl;
-        if (!repoUrl) {
-          warn3("No repo URL available, cannot create GitHub release");
-          break;
-        }
-        const parsed = parseRepoUrl(repoUrl);
-        if (!parsed) {
-          warn3(`Could not parse repo URL: ${repoUrl}`);
-          break;
-        }
-        await createGitHubRelease(firstContext, {
-          owner: parsed.owner,
-          repo: parsed.repo,
-          draft: output.options?.draft,
-          prerelease: output.options?.prerelease
-        });
-        break;
-      }
-    }
-  }
-  if (config.monorepo?.mode) {
-    const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-JZ3VUZKP.js");
-    const cwd = process.cwd();
-    const detected = detectMonorepo(cwd);
-    if (detected.isMonorepo) {
-      const monoFiles = writeMonorepoChangelogs(
-        contexts,
-        {
-          rootPath: config.monorepo.rootPath ?? cwd,
-          packagesPath: config.monorepo.packagesPath ?? detected.packagesPath,
-          mode: config.monorepo.mode
-        },
-        config,
-        dryRun
-      );
-      files.push(...monoFiles);
-    }
-  }
-  const packageNotes = {};
-  for (const ctx of contexts) {
-    packageNotes[ctx.packageName] = formatVersion(ctx);
-  }
-  return { packageNotes, files };
-}
-async function processInput(inputJson, config, dryRun) {
-  const input = parsePackageVersioner(inputJson);
-  return runPipeline(input, config, dryRun);
-}
-
-export {
-  loadAuth,
-  saveAuth,
-  loadConfig,
-  getDefaultConfig,
-  NotesError,
-  InputParseError,
-  TemplateError,
-  LLMError,
-  GitHubError,
-  ConfigError,
-  getExitCode,
-  EXIT_CODES2 as EXIT_CODES,
-  parsePackageVersioner,
-  parsePackageVersionerFile,
-  parsePackageVersionerStdin,
-  renderJson,
-  writeJson,
-  createTemplateContext,
-  runPipeline,
-  processInput
-};