@releasekit/notes 0.3.0 → 0.3.1

package/dist/chunk-ENAWZXFG.js

@@ -0,0 +1,1901 @@
+import {
+  EXIT_CODES,
+  ReleaseKitError,
+  debug,
+  formatVersion,
+  info,
+  renderMarkdown,
+  success,
+  warn,
+  writeMarkdown
+} from "./chunk-E4454SIS.js";
+
+// ../config/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as TOML from "smol-toml";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { z as z2 } from "zod";
+import { z } from "zod";
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+var ConfigError = class extends ReleaseKitError {
+  code = "CONFIG_ERROR";
+  suggestions;
+  constructor(message, suggestions) {
+    super(message);
+    this.suggestions = suggestions ?? [
+      "Check that releasekit.config.json exists and is valid JSON",
+      "Run with --verbose for more details"
+    ];
+  }
+};
+var MAX_JSONC_LENGTH = 1e5;
+function parseJsonc(content) {
+  if (content.length > MAX_JSONC_LENGTH) {
+    throw new Error(`JSONC content too long: ${content.length} characters (max ${MAX_JSONC_LENGTH})`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    const cleaned = content.replace(/\/\/[^\r\n]{0,10000}$/gm, "").replace(/\/\*[\s\S]{0,50000}?\*\//g, "").trim();
+    return JSON.parse(cleaned);
+  }
+}
+var GitConfigSchema = z.object({
+  remote: z.string().default("origin"),
+  branch: z.string().default("main"),
+  pushMethod: z.enum(["auto", "ssh", "https"]).default("auto"),
+  /**
+   * Optional env var name containing a GitHub token for HTTPS pushes.
+   * When set, publish steps can use this token without mutating git remotes.
+   */
+  httpsTokenEnv: z.string().optional(),
+  push: z.boolean().optional(),
+  skipHooks: z.boolean().optional()
+});
+var MonorepoConfigSchema = z.object({
+  mode: z.enum(["root", "packages", "both"]).optional(),
+  rootPath: z.string().optional(),
+  packagesPath: z.string().optional(),
+  mainPackage: z.string().optional()
+});
+var BranchPatternSchema = z.object({
+  pattern: z.string(),
+  releaseType: z.enum(["major", "minor", "patch", "prerelease"])
+});
+var VersionCargoConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  paths: z.array(z.string()).optional()
+});
+var VersionConfigSchema = z.object({
+  tagTemplate: z.string().default("v{version}"),
+  packageSpecificTags: z.boolean().default(false),
+  preset: z.string().default("conventional"),
+  sync: z.boolean().default(true),
+  packages: z.array(z.string()).default([]),
+  mainPackage: z.string().optional(),
+  updateInternalDependencies: z.enum(["major", "minor", "patch", "no-internal-update"]).default("minor"),
+  skip: z.array(z.string()).optional(),
+  commitMessage: z.string().optional(),
+  versionStrategy: z.enum(["branchPattern", "commitMessage"]).default("commitMessage"),
+  branchPatterns: z.array(BranchPatternSchema).optional(),
+  defaultReleaseType: z.enum(["major", "minor", "patch", "prerelease"]).optional(),
+  mismatchStrategy: z.enum(["error", "warn", "ignore", "prefer-package", "prefer-git"]).default("warn"),
+  versionPrefix: z.string().default(""),
+  prereleaseIdentifier: z.string().optional(),
+  strictReachable: z.boolean().default(false),
+  cargo: VersionCargoConfigSchema.optional()
+});
+var NpmConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  auth: z.enum(["auto", "oidc", "token"]).default("auto"),
+  provenance: z.boolean().default(true),
+  access: z.enum(["public", "restricted"]).default("public"),
+  registry: z.string().default("https://registry.npmjs.org"),
+  copyFiles: z.array(z.string()).default(["LICENSE"]),
+  tag: z.string().default("latest")
+});
+var CargoPublishConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  noVerify: z.boolean().default(false),
+  publishOrder: z.array(z.string()).default([]),
+  clean: z.boolean().default(false)
+});
+var PublishGitConfigSchema = z.object({
+  push: z.boolean().default(true),
+  pushMethod: z.enum(["auto", "ssh", "https"]).optional(),
+  remote: z.string().optional(),
+  branch: z.string().optional(),
+  httpsTokenEnv: z.string().optional(),
+  skipHooks: z.boolean().optional()
+});
+var GitHubReleaseConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  draft: z.boolean().default(true),
+  perPackage: z.boolean().default(true),
+  prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
+  /**
+   * Controls how release notes are sourced for GitHub releases.
+   * - 'auto': Use RELEASE_NOTES.md if it exists, then per-package changelog
+   *   data from the version output, then GitHub's auto-generated notes.
+   * - 'github': Always use GitHub's auto-generated notes.
+   * - 'none': No notes body.
+   * - Any other string: Treated as a file path to read notes from.
+   */
+  releaseNotes: z.union([z.literal("auto"), z.literal("github"), z.literal("none"), z.string()]).default("auto")
+});
+var VerifyRegistryConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  maxAttempts: z.number().int().positive().default(5),
+  initialDelay: z.number().int().positive().default(15e3),
+  backoffMultiplier: z.number().positive().default(2)
+});
+var VerifyConfigSchema = z.object({
+  npm: VerifyRegistryConfigSchema.default({
+    enabled: true,
+    maxAttempts: 5,
+    initialDelay: 15e3,
+    backoffMultiplier: 2
+  }),
+  cargo: VerifyRegistryConfigSchema.default({
+    enabled: true,
+    maxAttempts: 10,
+    initialDelay: 3e4,
+    backoffMultiplier: 2
+  })
+});
+var PublishConfigSchema = z.object({
+  git: PublishGitConfigSchema.optional(),
+  npm: NpmConfigSchema.default({
+    enabled: true,
+    auth: "auto",
+    provenance: true,
+    access: "public",
+    registry: "https://registry.npmjs.org",
+    copyFiles: ["LICENSE"],
+    tag: "latest"
+  }),
+  cargo: CargoPublishConfigSchema.default({
+    enabled: false,
+    noVerify: false,
+    publishOrder: [],
+    clean: false
+  }),
+  githubRelease: GitHubReleaseConfigSchema.default({
+    enabled: true,
+    draft: true,
+    perPackage: true,
+    prerelease: "auto",
+    releaseNotes: "auto"
+  }),
+  verify: VerifyConfigSchema.default({
+    npm: {
+      enabled: true,
+      maxAttempts: 5,
+      initialDelay: 15e3,
+      backoffMultiplier: 2
+    },
+    cargo: {
+      enabled: true,
+      maxAttempts: 10,
+      initialDelay: 3e4,
+      backoffMultiplier: 2
+    }
+  })
+});
+var TemplateConfigSchema = z.object({
+  path: z.string().optional(),
+  engine: z.enum(["handlebars", "liquid", "ejs"]).optional()
+});
+var OutputConfigSchema = z.object({
+  format: z.enum(["markdown", "github-release", "json"]),
+  file: z.string().optional(),
+  options: z.record(z.string(), z.unknown()).optional(),
+  templates: TemplateConfigSchema.optional()
+});
+var LLMOptionsSchema = z.object({
+  timeout: z.number().optional(),
+  maxTokens: z.number().optional(),
+  temperature: z.number().optional()
+});
+var LLMRetryConfigSchema = z.object({
+  maxAttempts: z.number().int().positive().optional(),
+  initialDelay: z.number().nonnegative().optional(),
+  maxDelay: z.number().positive().optional(),
+  backoffFactor: z.number().positive().optional()
+});
+var LLMTasksConfigSchema = z.object({
+  summarize: z.boolean().optional(),
+  enhance: z.boolean().optional(),
+  categorize: z.boolean().optional(),
+  releaseNotes: z.boolean().optional()
+});
+var LLMCategorySchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  scopes: z.array(z.string()).optional()
+});
+var ScopeRulesSchema = z.object({
+  allowed: z.array(z.string()).optional(),
+  caseSensitive: z.boolean().default(false),
+  invalidScopeAction: z.enum(["remove", "keep", "fallback"]).default("remove"),
+  fallbackScope: z.string().optional()
+});
+var ScopeConfigSchema = z.object({
+  mode: z.enum(["restricted", "packages", "none", "unrestricted"]).default("unrestricted"),
+  rules: ScopeRulesSchema.optional()
+});
+var LLMPromptOverridesSchema = z.object({
+  enhance: z.string().optional(),
+  categorize: z.string().optional(),
+  enhanceAndCategorize: z.string().optional(),
+  summarize: z.string().optional(),
+  releaseNotes: z.string().optional()
+});
+var LLMPromptsConfigSchema = z.object({
+  instructions: LLMPromptOverridesSchema.optional(),
+  templates: LLMPromptOverridesSchema.optional()
+});
+var LLMConfigSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  baseURL: z.string().optional(),
+  apiKey: z.string().optional(),
+  options: LLMOptionsSchema.optional(),
+  concurrency: z.number().int().positive().optional(),
+  retry: LLMRetryConfigSchema.optional(),
+  tasks: LLMTasksConfigSchema.optional(),
+  categories: z.array(LLMCategorySchema).optional(),
+  style: z.string().optional(),
+  scopes: ScopeConfigSchema.optional(),
+  prompts: LLMPromptsConfigSchema.optional()
+});
+var NotesInputConfigSchema = z.object({
+  source: z.string().optional(),
+  file: z.string().optional()
+});
+var NotesConfigSchema = z.object({
+  input: NotesInputConfigSchema.optional(),
+  output: z.array(OutputConfigSchema).default([{ format: "markdown", file: "CHANGELOG.md" }]),
+  monorepo: MonorepoConfigSchema.optional(),
+  templates: TemplateConfigSchema.optional(),
+  llm: LLMConfigSchema.optional(),
+  updateStrategy: z.enum(["prepend", "regenerate"]).default("prepend")
+});
+var CILabelsConfigSchema = z.object({
+  stable: z.string().default("release:stable"),
+  prerelease: z.string().default("release:prerelease"),
+  skip: z.string().default("release:skip"),
+  major: z.string().default("release:major"),
+  minor: z.string().default("release:minor"),
+  patch: z.string().default("release:patch")
+});
+var CIConfigSchema = z.object({
+  releaseStrategy: z.enum(["manual", "direct", "standing-pr", "scheduled"]).default("direct"),
+  releaseTrigger: z.enum(["commit", "label"]).default("label"),
+  prPreview: z.boolean().default(true),
+  autoRelease: z.boolean().default(false),
+  /**
+   * Commit message prefixes that should not trigger a release.
+   * Defaults to `['chore: release ']` to match the release commit template
+   * (`chore: release ${packageName} v${version}`) and provide a
+   * secondary loop-prevention guard alongside `[skip ci]`.
+   */
+  skipPatterns: z.array(z.string()).default(["chore: release "]),
+  minChanges: z.number().int().positive().default(1),
+  labels: CILabelsConfigSchema.default({
+    stable: "release:stable",
+    prerelease: "release:prerelease",
+    skip: "release:skip",
+    major: "release:major",
+    minor: "release:minor",
+    patch: "release:patch"
+  })
+});
+var ReleaseCIConfigSchema = z.object({
+  skipPatterns: z.array(z.string().min(1)).optional(),
+  minChanges: z.number().int().positive().optional(),
+  /** Set to `false` to disable GitHub release creation in CI. */
+  githubRelease: z.literal(false).optional(),
+  /** Set to `false` to disable changelog generation in CI. */
+  notes: z.literal(false).optional()
+});
+var ReleaseConfigSchema = z.object({
+  /**
+   * Optional steps to enable. The version step always runs; only 'notes' and
+   * 'publish' can be opted out. Omitting a step is equivalent to --skip-<step>.
+   */
+  steps: z.array(z.enum(["notes", "publish"])).min(1).optional(),
+  ci: ReleaseCIConfigSchema.optional()
+});
+var ReleaseKitConfigSchema = z.object({
+  git: GitConfigSchema.optional(),
+  monorepo: MonorepoConfigSchema.optional(),
+  version: VersionConfigSchema.optional(),
+  publish: PublishConfigSchema.optional(),
+  notes: NotesConfigSchema.optional(),
+  ci: CIConfigSchema.optional(),
+  release: ReleaseConfigSchema.optional()
+});
+var MAX_INPUT_LENGTH = 1e4;
+function substituteVariables(value) {
+  if (value.length > MAX_INPUT_LENGTH) {
+    throw new Error(`Input too long: ${value.length} characters (max ${MAX_INPUT_LENGTH})`);
+  }
+  const envPattern = /\{env:([^}]{1,1000})\}/g;
+  const filePattern = /\{file:([^}]{1,1000})\}/g;
+  let result = value;
+  result = result.replace(envPattern, (_, varName) => {
+    return process.env[varName] ?? "";
+  });
+  result = result.replace(filePattern, (_, filePath) => {
+    const expandedPath = filePath.startsWith("~") ? path2.join(os.homedir(), filePath.slice(1)) : filePath;
+    try {
+      return fs2.readFileSync(expandedPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  });
+  return result;
+}
+var SOLE_REFERENCE_PATTERN = /^\{(?:env|file):[^}]+\}$/;
+function substituteInObject(obj) {
+  if (typeof obj === "string") {
+    const result = substituteVariables(obj);
+    if (result === "" && SOLE_REFERENCE_PATTERN.test(obj)) {
+      return void 0;
+    }
+    return result;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => substituteInObject(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = substituteInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var AUTH_DIR = path2.join(os.homedir(), ".config", "releasekit");
+var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
+function loadAuth() {
+  if (fs2.existsSync(AUTH_FILE)) {
+    try {
+      const content = fs2.readFileSync(AUTH_FILE, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function saveAuth(provider, apiKey) {
+  if (!fs2.existsSync(AUTH_DIR)) {
+    fs2.mkdirSync(AUTH_DIR, { recursive: true });
+  }
+  const existing = loadAuth();
+  existing[provider] = apiKey;
+  fs2.writeFileSync(AUTH_FILE, JSON.stringify(existing, null, 2), { encoding: "utf-8", mode: 384 });
+}
+var CONFIG_FILE = "releasekit.config.json";
+function loadConfigFile(configPath) {
+  if (!fs3.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    const parsed = parseJsonc(content);
+    const substituted = substituteInObject(parsed);
+    return ReleaseKitConfigSchema.parse(substituted);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      const issues = error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new ConfigError(`Config validation errors:
+${issues}`);
+    }
+    if (error instanceof SyntaxError) {
+      throw new ConfigError(`Invalid JSON in config file: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function loadConfig(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const configPath = options?.configPath ?? path3.join(cwd, CONFIG_FILE);
+  return loadConfigFile(configPath);
+}
+function loadNotesConfig(options) {
+  const config = loadConfig(options);
+  return config.notes;
+}
+
+// src/core/config.ts
+function loadConfig2(projectDir = process.cwd(), configFile) {
+  const options = { cwd: projectDir, configPath: configFile };
+  return loadNotesConfig(options) ?? getDefaultConfig();
+}
+function getDefaultConfig() {
+  return {
+    output: [{ format: "markdown", file: "CHANGELOG.md" }],
+    updateStrategy: "prepend"
+  };
+}
+
+// src/errors/index.ts
+var NotesError = class extends ReleaseKitError {
+};
+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 ConfigError2 = 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/version-output.ts
+import * as fs4 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 parseVersionOutput(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: "version",
+    packages,
+    metadata: {
+      repoUrl: repoUrl ?? void 0
+    }
+  };
+}
+function parseVersionOutputFile(filePath) {
+  const content = fs4.readFileSync(filePath, "utf-8");
+  return parseVersionOutput(content);
+}
+async function parseVersionOutputStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const content = chunks.join("");
+  return parseVersionOutput(content);
+}
+
+// src/output/json.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+function renderJson(contexts) {
+  return JSON.stringify(
+    {
+      versions: contexts.map((ctx) => ({
+        packageName: ctx.packageName,
+        version: ctx.version,
+        previousVersion: ctx.previousVersion,
+        date: ctx.date,
+        entries: ctx.entries,
+        compareUrl: ctx.compareUrl
+      }))
+    },
+    null,
+    2
+  );
+}
+function writeJson(outputPath, contexts, dryRun) {
+  const content = renderJson(contexts);
+  if (dryRun) {
+    info(`Would write JSON output to ${outputPath}`);
+    debug("--- JSON Output Preview ---");
+    debug(content);
+    debug("--- End Preview ---");
+    return;
+  }
+  const dir = path4.dirname(outputPath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  fs5.writeFileSync(outputPath, content, "utf-8");
+  success(`JSON output written to ${outputPath}`);
+}
+
+// src/core/pipeline.ts
+import * as fs10 from "fs";
+import * as path8 from "path";
+
+// src/llm/defaults.ts
+var LLM_DEFAULTS = {
+  timeout: 6e4,
+  maxTokens: 4e3,
+  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/utils/json.ts
+function extractJsonFromResponse(response) {
+  const stripped = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+  const objectMatch = stripped.match(/\{[\s\S]*\}/);
+  if (objectMatch) return objectMatch[0];
+  const arrayMatch = stripped.match(/\[[\s\S]*\]/);
+  if (arrayMatch) return arrayMatch[0];
+  return stripped;
+}
+
+// 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 parsed = JSON.parse(extractJsonFromResponse(response));
+    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/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 parsed = JSON.parse(extractJsonFromResponse(response));
+      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) {
+    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 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";
+var GitHubClient = class {
+  octokit;
+  owner;
+  repo;
+  constructor(options) {
+    const token = options.token ?? process.env.GITHUB_TOKEN;
+    if (!token) {
+      throw new GitHubError("GITHUB_TOKEN not set. Set it as an environment variable.");
+    }
+    this.octokit = new Octokit({ auth: token });
+    this.owner = options.owner;
+    this.repo = options.repo;
+  }
+  async createRelease(context, options = {}) {
+    const tagName = `v${context.version}`;
+    let body;
+    if (context.enhanced?.releaseNotes) {
+      body = context.enhanced.releaseNotes;
+    } else {
+      body = renderMarkdown([context]);
+    }
+    info(`Creating GitHub release for ${tagName}`);
+    try {
+      const response = await this.octokit.repos.createRelease({
+        owner: this.owner,
+        repo: this.repo,
+        tag_name: tagName,
+        name: tagName,
+        body,
+        draft: options.draft ?? false,
+        prerelease: options.prerelease ?? false,
+        generate_release_notes: options.generateNotes ?? false
+      });
+      success(`Release created: ${response.data.html_url}`);
+      return {
+        id: response.data.id,
+        htmlUrl: response.data.html_url,
+        tagName
+      };
+    } catch (error) {
+      throw new GitHubError(`Failed to create release: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async updateRelease(releaseId, context, options = {}) {
+    const tagName = `v${context.version}`;
+    let body;
+    if (context.enhanced?.releaseNotes) {
+      body = context.enhanced.releaseNotes;
+    } else {
+      body = renderMarkdown([context]);
+    }
+    info(`Updating GitHub release ${releaseId}`);
+    try {
+      const response = await this.octokit.repos.updateRelease({
+        owner: this.owner,
+        repo: this.repo,
+        release_id: releaseId,
+        tag_name: tagName,
+        name: tagName,
+        body,
+        draft: options.draft ?? false,
+        prerelease: options.prerelease ?? false
+      });
+      success(`Release updated: ${response.data.html_url}`);
+      return {
+        id: response.data.id,
+        htmlUrl: response.data.html_url,
+        tagName
+      };
+    } catch (error) {
+      throw new GitHubError(`Failed to update release: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async getReleaseByTag(tag) {
+    try {
+      const response = await this.octokit.repos.getReleaseByTag({
+        owner: this.owner,
+        repo: this.repo,
+        tag
+      });
+      return {
+        id: response.data.id,
+        htmlUrl: response.data.html_url,
+        tagName: response.data.tag_name
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+function parseRepoUrl(repoUrl) {
+  const patterns = [
+    /^https:\/\/github\.com\/([^/]+)\/([^/]+)/,
+    /^git@github\.com:([^/]+)\/([^/]+)/,
+    /^github\.com\/([^/]+)\/([^/]+)/
+  ];
+  for (const pattern of patterns) {
+    const match = repoUrl.match(pattern);
+    if (match?.[1] && match[2]) {
+      return {
+        owner: match[1],
+        repo: match[2].replace(/\.git$/, "")
+      };
+    }
+  }
+  return null;
+}
+async function createGitHubRelease(context, options) {
+  const client = new GitHubClient(options);
+  return client.createRelease(context, options);
+}
+
+// src/templates/ejs.ts
+import * as fs6 from "fs";
+import 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 (!fs6.existsSync(filePath)) {
+    throw new TemplateError(`Template file not found: ${filePath}`);
+  }
+  const template = fs6.readFileSync(filePath, "utf-8");
+  return renderEjs(template, context);
+}
+
+// src/templates/handlebars.ts
+import * as fs7 from "fs";
+import * as path5 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 (!fs7.existsSync(filePath)) {
+    throw new TemplateError(`Template file not found: ${filePath}`);
+  }
+  const template = fs7.readFileSync(filePath, "utf-8");
+  return renderHandlebars(template, context);
+}
+function renderHandlebarsComposable(templateDir, context) {
+  registerHandlebarsHelpers();
+  const versionPath = path5.join(templateDir, "version.hbs");
+  const entryPath = path5.join(templateDir, "entry.hbs");
+  const documentPath = path5.join(templateDir, "document.hbs");
+  if (!fs7.existsSync(documentPath)) {
+    throw new TemplateError(`Document template not found: ${documentPath}`);
+  }
+  if (fs7.existsSync(versionPath)) {
+    Handlebars.registerPartial("version", fs7.readFileSync(versionPath, "utf-8"));
+  }
+  if (fs7.existsSync(entryPath)) {
+    Handlebars.registerPartial("entry", fs7.readFileSync(entryPath, "utf-8"));
+  }
+  try {
+    const compiled = Handlebars.compile(fs7.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 fs8 from "fs";
+import * as path6 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 (!fs8.existsSync(filePath)) {
+    throw new TemplateError(`Template file not found: ${filePath}`);
+  }
+  const template = fs8.readFileSync(filePath, "utf-8");
+  return renderLiquid(template, context);
+}
+function renderLiquidComposable(templateDir, context) {
+  const documentPath = path6.join(templateDir, "document.liquid");
+  if (!fs8.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 fs9 from "fs";
+import * as path7 from "path";
+function getEngineFromFile(filePath) {
+  const ext = path7.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 (!fs9.existsSync(templatePath)) {
+    throw new TemplateError(`Template path not found: ${templatePath}`);
+  }
+  const stat = fs9.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 = fs9.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 = path7.join(templateDir, expectedFiles.document);
+  if (!fs9.existsSync(documentPath)) {
+    throw new TemplateError(`Document template not found: ${expectedFiles.document}`);
+  }
+  const versionPath = path7.join(templateDir, expectedFiles.version);
+  const entryPath = path7.join(templateDir, expectedFiles.entry);
+  const render = getRenderFn(resolvedEngine);
+  const entryTemplate = fs9.existsSync(entryPath) ? fs9.readFileSync(entryPath, "utf-8") : null;
+  const versionTemplate = fs9.existsSync(versionPath) ? fs9.readFileSync(versionPath, "utf-8") : null;
+  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(fs9.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 buildOrderedCategories(rawCategories, configCategories) {
+  const order = configCategories?.map((c) => c.name) ?? [];
+  const mapped = rawCategories.map((c) => ({ name: c.category, entries: c.entries }));
+  if (order.length === 0) return mapped;
+  return mapped.sort((a, b) => {
+    const ai = order.indexOf(a.name);
+    const bi = order.indexOf(b.name);
+    return (ai === -1 ? order.length : ai) - (bi === -1 ? order.length : bi);
+  });
+}
+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 {
+    info(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
+    if (config.llm.baseURL) {
+      info(`LLM base URL: ${config.llm.baseURL}`);
+    }
+    const rawProvider = createProvider(config.llm);
+    const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
+    const configOptions = config.llm.options;
+    const provider = {
+      name: rawProvider.name,
+      // Merge user-configured options (timeout, maxTokens, temperature) as base defaults,
+      // allowing any per-call overrides to take precedence.
+      complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, { ...configOptions, ...opts }), retryOpts)
+    };
+    const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
+    info(`Running LLM tasks: ${activeTasks.join(", ")}`);
+    if (tasks.enhance && tasks.categorize) {
+      info("Enhancing and categorizing entries with LLM...");
+      const result = await enhanceAndCategorize(provider, context.entries, llmContext);
+      enhanced.entries = result.enhancedEntries;
+      enhanced.categories = buildOrderedCategories(result.categories, llmContext.categories);
+      info(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
+    } else {
+      if (tasks.enhance) {
+        info("Enhancing entries with LLM...");
+        enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
+        info(`Enhanced ${enhanced.entries.length} entries`);
+      }
+      if (tasks.categorize) {
+        info("Categorizing entries with LLM...");
+        const categorized = await categorizeEntries(provider, enhanced.entries, llmContext);
+        enhanced.categories = buildOrderedCategories(categorized, llmContext.categories);
+        info(`Created ${categorized.length} categories`);
+      }
+    }
+    if (tasks.summarize) {
+      info("Summarizing entries with LLM...");
+      enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
+      if (enhanced.summary) {
+        info("Summary generated successfully");
+        debug(`Summary: ${enhanced.summary.substring(0, 100)}...`);
+      } else {
+        warn("Summary generation returned empty result");
+      }
+    }
+    if (tasks.releaseNotes) {
+      info("Generating release notes with LLM...");
+      enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
+      if (enhanced.releaseNotes) {
+        info("Release notes generated successfully");
+      } else {
+        warn("Release notes generation returned empty result");
+      }
+    }
+    return {
+      ...context,
+      enhanced
+    };
+  } catch (error) {
+    warn(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
+    warn("Falling back to raw entries");
+    return context;
+  }
+}
+function getBuiltinTemplatePath(style) {
+  let packageRoot;
+  try {
+    const currentUrl = import.meta.url;
+    packageRoot = path8.dirname(new URL(currentUrl).pathname);
+    packageRoot = path8.join(packageRoot, "..", "..");
+  } catch {
+    packageRoot = __dirname;
+  }
+  return path8.join(packageRoot, "templates", style);
+}
+async function generateWithTemplate(contexts, config, outputPath, dryRun) {
+  let templatePath;
+  if (config.templates?.path) {
+    templatePath = path8.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) {
+    info(`[DRY RUN] Changelog preview (would write to ${outputPath}):`);
+    info(result.content);
+    return;
+  }
+  if (outputPath === "-") {
+    process.stdout.write(result.content);
+    return;
+  }
+  const dir = path8.dirname(outputPath);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  fs10.writeFileSync(outputPath, result.content, "utf-8");
+  const label = /changelog/i.test(outputPath) ? "Changelog" : "Release notes";
+  success(`${label} written to ${outputPath} (using ${result.engine} template)`);
+}
+async function runPipeline(input, config, dryRun) {
+  debug(`Processing ${input.packages.length} package(s)`);
+  let contexts = input.packages.map(createTemplateContext);
+  if (config.llm && !process.env.CHANGELOG_NO_LLM) {
+    info("Processing with LLM enhancement");
+    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
+  }
+  const files = [];
+  const fmtOpts = {
+    includePackageName: contexts.length > 1 || contexts.some((c) => c.packageName.includes("/"))
+  };
+  for (const output of config.output) {
+    const file = output.file ?? (output.format === "json" ? "changelog.json" : "CHANGELOG.md");
+    const isChangelog = /changelog/i.test(file);
+    const outputKind = isChangelog ? "changelog" : "release notes";
+    info(`Generating ${outputKind} \u2192 ${file}`);
+    switch (output.format) {
+      case "markdown": {
+        const file2 = output.file ?? "CHANGELOG.md";
+        try {
+          const effectiveTemplateConfig = output.templates ?? config.templates;
+          if (effectiveTemplateConfig?.path || output.options?.template) {
+            const configWithTemplate = { ...config, templates: effectiveTemplateConfig };
+            await generateWithTemplate(contexts, configWithTemplate, file2, dryRun);
+          } else {
+            writeMarkdown(file2, contexts, config, dryRun, fmtOpts);
+          }
+          if (!dryRun) files.push(file2);
+        } catch (error) {
+          warn(`Failed to write ${file2}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        break;
+      }
+      case "json": {
+        const file2 = output.file ?? "changelog.json";
+        try {
+          writeJson(file2, contexts, dryRun);
+          if (!dryRun) files.push(file2);
+        } catch (error) {
+          warn(`Failed to write ${file2}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        break;
+      }
+      case "github-release": {
+        if (dryRun) {
+          info("[DRY RUN] Would create GitHub release");
+          break;
+        }
+        const firstContext = contexts[0];
+        if (!firstContext) {
+          warn("No context available for GitHub release");
+          break;
+        }
+        const repoUrl = firstContext.repoUrl;
+        if (!repoUrl) {
+          warn("No repo URL available, cannot create GitHub release");
+          break;
+        }
+        const parsed = parseRepoUrl(repoUrl);
+        if (!parsed) {
+          warn(`Could not parse repo URL: ${repoUrl}`);
+          break;
+        }
+        await createGitHubRelease(firstContext, {
+          owner: parsed.owner,
+          repo: parsed.repo,
+          draft: output.options?.draft,
+          prerelease: output.options?.prerelease
+        });
+        break;
+      }
+    }
+  }
+  if (config.monorepo?.mode) {
+    const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-XJ2EILO3.js");
+    const cwd = process.cwd();
+    const detected = detectMonorepo(cwd);
+    if (detected.isMonorepo) {
+      const monoFiles = writeMonorepoChangelogs(
+        contexts,
+        {
+          rootPath: config.monorepo.rootPath ?? cwd,
+          packagesPath: config.monorepo.packagesPath ?? detected.packagesPath,
+          mode: config.monorepo.mode
+        },
+        config,
+        dryRun
+      );
+      files.push(...monoFiles);
+    }
+  }
+  const packageNotes = {};
+  for (const ctx of contexts) {
+    packageNotes[ctx.packageName] = formatVersion(ctx);
+  }
+  return { packageNotes, files };
+}
+async function processInput(inputJson, config, dryRun) {
+  const input = parseVersionOutput(inputJson);
+  return runPipeline(input, config, dryRun);
+}
+
+export {
+  loadAuth,
+  saveAuth,
+  loadConfig2 as loadConfig,
+  getDefaultConfig,
+  NotesError,
+  InputParseError,
+  TemplateError,
+  LLMError,
+  GitHubError,
+  ConfigError2 as ConfigError,
+  getExitCode,
+  parseVersionOutput,
+  parseVersionOutputFile,
+  parseVersionOutputStdin,
+  renderJson,
+  writeJson,
+  createTemplateContext,
+  runPipeline,
+  processInput
+};