@releasekit/notes 0.3.0-next.4 → 0.3.1

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

@@ -1,18 +1,424 @@
 import {
+  EXIT_CODES,
+  ReleaseKitError,
+  debug,
   formatVersion,
+  info,
   renderMarkdown,
+  success,
+  warn,
   writeMarkdown
-} from "./chunk-QCF6V2IY.js";
+} 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
-import {
-  loadAuth,
-  loadNotesConfig as loadSharedNotesConfig,
-  saveAuth
-} from "@releasekit/config";
-function loadConfig(projectDir = process.cwd(), configFile) {
+function loadConfig2(projectDir = process.cwd(), configFile) {
   const options = { cwd: projectDir, configPath: configFile };
-  return loadSharedNotesConfig(options) ?? getDefaultConfig();
+  return loadNotesConfig(options) ?? getDefaultConfig();
 }
 function getDefaultConfig() {
   return {
@@ -22,8 +428,6 @@ function getDefaultConfig() {
 }
 
 // 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 {
@@ -59,7 +463,7 @@ var GitHubError = class extends NotesError {
     "Verify repository exists and is accessible"
   ];
 };
-var ConfigError = class extends NotesError {
+var ConfigError2 = class extends NotesError {
   code = "CONFIG_ERROR";
   suggestions = [
     "Check config file syntax",
@@ -84,8 +488,8 @@ function getExitCode(error) {
   }
 }
 
-// src/input/package-versioner.ts
-import * as fs from "fs";
+// src/input/version-output.ts
+import * as fs4 from "fs";
 function normalizeEntryType(type) {
   const typeMap = {
     added: "added",
@@ -103,7 +507,7 @@ function normalizeEntryType(type) {
   };
   return typeMap[type.toLowerCase()] ?? "changed";
 }
-function parsePackageVersioner(json) {
+function parseVersionOutput(json) {
   let data;
   try {
     data = JSON.parse(json);
@@ -131,30 +535,29 @@ function parsePackageVersioner(json) {
   }));
   const repoUrl = packages[0]?.repoUrl ?? null;
   return {
-    source: "package-versioner",
+    source: "version",
     packages,
     metadata: {
       repoUrl: repoUrl ?? void 0
     }
   };
 }
-function parsePackageVersionerFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf-8");
-  return parsePackageVersioner(content);
+function parseVersionOutputFile(filePath) {
+  const content = fs4.readFileSync(filePath, "utf-8");
+  return parseVersionOutput(content);
 }
-async function parsePackageVersionerStdin() {
+async function parseVersionOutputStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
     chunks.push(chunk);
   }
   const content = chunks.join("");
-  return parsePackageVersioner(content);
+  return parseVersionOutput(content);
 }
 
 // src/output/json.ts
-import * as fs2 from "fs";
-import * as path from "path";
-import { debug, info, success } from "@releasekit/core";
+import * as fs5 from "fs";
+import * as path4 from "path";
 function renderJson(contexts) {
   return JSON.stringify(
     {
@@ -180,23 +583,22 @@ function writeJson(outputPath, contexts, dryRun) {
     debug("--- End Preview ---");
     return;
   }
-  const dir = path.dirname(outputPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const dir = path4.dirname(outputPath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-  fs2.writeFileSync(outputPath, content, "utf-8");
+  fs5.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";
+import * as fs10 from "fs";
+import * as path8 from "path";
 
 // src/llm/defaults.ts
 var LLM_DEFAULTS = {
   timeout: 6e4,
-  maxTokens: 2e3,
+  maxTokens: 4e3,
   temperature: 0.7,
   concurrency: 5,
   retry: {
@@ -386,8 +788,15 @@ var OpenAICompatibleProvider = class extends BaseLLMProvider {
   }
 };
 
-// src/llm/tasks/categorize.ts
-import { warn } from "@releasekit/core";
+// 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) {
@@ -519,8 +928,7 @@ async function categorizeEntries(provider, entries, context) {
   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 parsed = JSON.parse(extractJsonFromResponse(response));
     const result = [];
     if (hasCustomCategories && parsed.categories) {
       const categoryMap = parsed.categories;
@@ -601,9 +1009,6 @@ async function enhanceEntries(provider, entries, context, concurrency = LLM_DEFA
   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));
@@ -681,8 +1086,7 @@ async function enhanceAndCategorize(provider, entries, context) {
       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);
+      const parsed = JSON.parse(extractJsonFromResponse(response));
       if (!Array.isArray(parsed.entries)) {
         throw new Error('Response missing "entries" array');
       }
@@ -714,7 +1118,7 @@ async function enhanceAndCategorize(provider, entries, context) {
       return { enhancedEntries: validatedEntries, categories };
     }, retryOpts);
   } catch (error) {
-    warn2(
+    warn(
       `Combined enhance+categorize failed after ${retryOpts.maxAttempts} attempts: ${error instanceof Error ? error.message : String(error)}`
     );
     return {
@@ -826,7 +1230,6 @@ function createProvider(config) {
 
 // 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;
@@ -848,7 +1251,7 @@ var GitHubClient = class {
     } else {
       body = renderMarkdown([context]);
     }
-    info2(`Creating GitHub release for ${tagName}`);
+    info(`Creating GitHub release for ${tagName}`);
     try {
       const response = await this.octokit.repos.createRelease({
         owner: this.owner,
@@ -860,7 +1263,7 @@ var GitHubClient = class {
         prerelease: options.prerelease ?? false,
         generate_release_notes: options.generateNotes ?? false
       });
-      success2(`Release created: ${response.data.html_url}`);
+      success(`Release created: ${response.data.html_url}`);
       return {
         id: response.data.id,
         htmlUrl: response.data.html_url,
@@ -878,7 +1281,7 @@ var GitHubClient = class {
     } else {
       body = renderMarkdown([context]);
     }
-    info2(`Updating GitHub release ${releaseId}`);
+    info(`Updating GitHub release ${releaseId}`);
     try {
       const response = await this.octokit.repos.updateRelease({
         owner: this.owner,
@@ -890,7 +1293,7 @@ var GitHubClient = class {
         draft: options.draft ?? false,
         prerelease: options.prerelease ?? false
       });
-      success2(`Release updated: ${response.data.html_url}`);
+      success(`Release updated: ${response.data.html_url}`);
       return {
         id: response.data.id,
         htmlUrl: response.data.html_url,
@@ -940,7 +1343,7 @@ async function createGitHubRelease(context, options) {
 }
 
 // src/templates/ejs.ts
-import * as fs3 from "fs";
+import * as fs6 from "fs";
 import ejs from "ejs";
 function renderEjs(template, context) {
   try {
@@ -950,16 +1353,16 @@ function renderEjs(template, context) {
   }
 }
 function renderEjsFile(filePath, context) {
-  if (!fs3.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs3.readFileSync(filePath, "utf-8");
+  const template = fs6.readFileSync(filePath, "utf-8");
   return renderEjs(template, context);
 }
 
 // src/templates/handlebars.ts
-import * as fs4 from "fs";
-import * as path2 from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 import Handlebars from "handlebars";
 function registerHandlebarsHelpers() {
   Handlebars.registerHelper("capitalize", (str) => {
@@ -985,28 +1388,28 @@ function renderHandlebars(template, context) {
   }
 }
 function renderHandlebarsFile(filePath, context) {
-  if (!fs4.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs4.readFileSync(filePath, "utf-8");
+  const template = fs7.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)) {
+  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 (fs4.existsSync(versionPath)) {
-    Handlebars.registerPartial("version", fs4.readFileSync(versionPath, "utf-8"));
+  if (fs7.existsSync(versionPath)) {
+    Handlebars.registerPartial("version", fs7.readFileSync(versionPath, "utf-8"));
   }
-  if (fs4.existsSync(entryPath)) {
-    Handlebars.registerPartial("entry", fs4.readFileSync(entryPath, "utf-8"));
+  if (fs7.existsSync(entryPath)) {
+    Handlebars.registerPartial("entry", fs7.readFileSync(entryPath, "utf-8"));
   }
   try {
-    const compiled = Handlebars.compile(fs4.readFileSync(documentPath, "utf-8"));
+    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)}`);
@@ -1014,8 +1417,8 @@ function renderHandlebarsComposable(templateDir, context) {
 }
 
 // src/templates/liquid.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 import { Liquid } from "liquidjs";
 function createLiquidEngine(root) {
   return new Liquid({
@@ -1033,15 +1436,15 @@ function renderLiquid(template, context) {
   }
 }
 function renderLiquidFile(filePath, context) {
-  if (!fs5.existsSync(filePath)) {
+  if (!fs8.existsSync(filePath)) {
     throw new TemplateError(`Template file not found: ${filePath}`);
   }
-  const template = fs5.readFileSync(filePath, "utf-8");
+  const template = fs8.readFileSync(filePath, "utf-8");
   return renderLiquid(template, context);
 }
 function renderLiquidComposable(templateDir, context) {
-  const documentPath = path3.join(templateDir, "document.liquid");
-  if (!fs5.existsSync(documentPath)) {
+  const documentPath = path6.join(templateDir, "document.liquid");
+  if (!fs8.existsSync(documentPath)) {
     throw new TemplateError(`Document template not found: ${documentPath}`);
   }
   const engine = createLiquidEngine(templateDir);
@@ -1053,10 +1456,10 @@ function renderLiquidComposable(templateDir, context) {
 }
 
 // src/templates/loader.ts
-import * as fs6 from "fs";
-import * as path4 from "path";
+import * as fs9 from "fs";
+import * as path7 from "path";
 function getEngineFromFile(filePath) {
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   switch (ext) {
     case ".liquid":
       return "liquid";
@@ -1090,10 +1493,10 @@ function getRenderFileFn(engine) {
   }
 }
 function detectTemplateMode(templatePath) {
-  if (!fs6.existsSync(templatePath)) {
+  if (!fs9.existsSync(templatePath)) {
     throw new TemplateError(`Template path not found: ${templatePath}`);
   }
-  const stat = fs6.statSync(templatePath);
+  const stat = fs9.statSync(templatePath);
   if (stat.isFile()) {
     return "single";
   }
@@ -1111,7 +1514,7 @@ function renderSingleFile(templatePath, context, engine) {
   };
 }
 function renderComposable(templateDir, context, engine) {
-  const files = fs6.readdirSync(templateDir);
+  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" },
@@ -1134,15 +1537,15 @@ function renderComposable(templateDir, context, engine) {
     return { content: renderHandlebarsComposable(templateDir, context), engine: resolvedEngine };
   }
   const expectedFiles = engineMap[resolvedEngine];
-  const documentPath = path4.join(templateDir, expectedFiles.document);
-  if (!fs6.existsSync(documentPath)) {
+  const documentPath = path7.join(templateDir, expectedFiles.document);
+  if (!fs9.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 versionPath = path7.join(templateDir, expectedFiles.version);
+  const entryPath = path7.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;
+  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) => {
@@ -1153,7 +1556,7 @@ function renderComposable(templateDir, context, engine) {
     });
     const docContext = { ...context, renderedVersions: versionsWithEntries };
     return {
-      content: render(fs6.readFileSync(documentPath, "utf-8"), docContext),
+      content: render(fs9.readFileSync(documentPath, "utf-8"), docContext),
       engine: resolvedEngine
     };
   }
@@ -1213,6 +1616,16 @@ function generateCompareUrl(repoUrl, from, to, packageName) {
   }
   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 {
@@ -1260,60 +1673,57 @@ async function processWithLLM(context, config) {
     entries: context.entries
   };
   try {
-    info3(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
+    info(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
     if (config.llm.baseURL) {
-      info3(`LLM base URL: ${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,
-      complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, opts), retryOpts)
+      // 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);
-    info3(`Running LLM tasks: ${activeTasks.join(", ")}`);
+    info(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance && tasks.categorize) {
-      info3("Enhancing and categorizing entries with LLM...");
+      info("Enhancing and categorizing entries with LLM...");
       const result = await enhanceAndCategorize(provider, context.entries, llmContext);
       enhanced.entries = result.enhancedEntries;
-      enhanced.categories = {};
-      for (const cat of result.categories) {
-        enhanced.categories[cat.category] = cat.entries;
-      }
-      info3(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
+      enhanced.categories = buildOrderedCategories(result.categories, llmContext.categories);
+      info(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
     } else {
       if (tasks.enhance) {
-        info3("Enhancing entries with LLM...");
+        info("Enhancing entries with LLM...");
         enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
-        info3(`Enhanced ${enhanced.entries.length} entries`);
+        info(`Enhanced ${enhanced.entries.length} entries`);
       }
       if (tasks.categorize) {
-        info3("Categorizing entries with LLM...");
+        info("Categorizing entries with LLM...");
         const categorized = await categorizeEntries(provider, enhanced.entries, llmContext);
-        enhanced.categories = {};
-        for (const cat of categorized) {
-          enhanced.categories[cat.category] = cat.entries;
-        }
-        info3(`Created ${categorized.length} categories`);
+        enhanced.categories = buildOrderedCategories(categorized, llmContext.categories);
+        info(`Created ${categorized.length} categories`);
       }
     }
     if (tasks.summarize) {
-      info3("Summarizing entries with LLM...");
+      info("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)}...`);
+        info("Summary generated successfully");
+        debug(`Summary: ${enhanced.summary.substring(0, 100)}...`);
       } else {
-        warn3("Summary generation returned empty result");
+        warn("Summary generation returned empty result");
       }
     }
     if (tasks.releaseNotes) {
-      info3("Generating release notes with LLM...");
+      info("Generating release notes with LLM...");
       enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
       if (enhanced.releaseNotes) {
-        info3("Release notes generated successfully");
+        info("Release notes generated successfully");
       } else {
-        warn3("Release notes generation returned empty result");
+        warn("Release notes generation returned empty result");
       }
     }
     return {
@@ -1321,8 +1731,8 @@ async function processWithLLM(context, config) {
       enhanced
     };
   } catch (error) {
-    warn3(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
-    warn3("Falling back to raw entries");
+    warn(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
+    warn("Falling back to raw entries");
     return context;
   }
 }
@@ -1330,17 +1740,17 @@ function getBuiltinTemplatePath(style) {
   let packageRoot;
   try {
     const currentUrl = import.meta.url;
-    packageRoot = path5.dirname(new URL(currentUrl).pathname);
-    packageRoot = path5.join(packageRoot, "..", "..");
+    packageRoot = path8.dirname(new URL(currentUrl).pathname);
+    packageRoot = path8.join(packageRoot, "..", "..");
   } catch {
     packageRoot = __dirname;
   }
-  return path5.join(packageRoot, "templates", style);
+  return path8.join(packageRoot, "templates", style);
 }
 async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   let templatePath;
   if (config.templates?.path) {
-    templatePath = path5.resolve(config.templates.path);
+    templatePath = path8.resolve(config.templates.path);
   } else {
     templatePath = getBuiltinTemplatePath("keep-a-changelog");
   }
@@ -1350,79 +1760,83 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   );
   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 ---");
+    info(`[DRY RUN] Changelog preview (would write to ${outputPath}):`);
+    info(result.content);
     return;
   }
   if (outputPath === "-") {
     process.stdout.write(result.content);
     return;
   }
-  const dir = path5.dirname(outputPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(outputPath);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
-  fs7.writeFileSync(outputPath, result.content, "utf-8");
-  success3(`Changelog written to ${outputPath} (using ${result.engine} template)`);
+  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) {
-  debug2(`Processing ${input.packages.length} package(s)`);
+  debug(`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");
+    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 outputLabel = output.file ? `${output.format} output \u2192 ${output.file}` : `${output.format} output`;
-    info3(`Generating ${outputLabel}`);
+    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 file = output.file ?? "CHANGELOG.md";
+        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, file, dryRun);
+            await generateWithTemplate(contexts, configWithTemplate, file2, dryRun);
           } else {
-            writeMarkdown(file, contexts, config, dryRun);
+            writeMarkdown(file2, contexts, config, dryRun, fmtOpts);
           }
-          if (!dryRun) files.push(file);
+          if (!dryRun) files.push(file2);
         } catch (error) {
-          warn3(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
+          warn(`Failed to write ${file2}: ${error instanceof Error ? error.message : String(error)}`);
         }
         break;
       }
       case "json": {
-        const file = output.file ?? "changelog.json";
+        const file2 = output.file ?? "changelog.json";
         try {
-          writeJson(file, contexts, dryRun);
-          if (!dryRun) files.push(file);
+          writeJson(file2, contexts, dryRun);
+          if (!dryRun) files.push(file2);
         } catch (error) {
-          warn3(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`);
+          warn(`Failed to write ${file2}: ${error instanceof Error ? error.message : String(error)}`);
         }
         break;
       }
       case "github-release": {
         if (dryRun) {
-          info3("[DRY RUN] Would create GitHub release");
+          info("[DRY RUN] Would create GitHub release");
           break;
         }
         const firstContext = contexts[0];
         if (!firstContext) {
-          warn3("No context available for GitHub release");
+          warn("No context available for GitHub release");
           break;
         }
         const repoUrl = firstContext.repoUrl;
         if (!repoUrl) {
-          warn3("No repo URL available, cannot create GitHub release");
+          warn("No repo URL available, cannot create GitHub release");
           break;
         }
         const parsed = parseRepoUrl(repoUrl);
         if (!parsed) {
-          warn3(`Could not parse repo URL: ${repoUrl}`);
+          warn(`Could not parse repo URL: ${repoUrl}`);
           break;
         }
         await createGitHubRelease(firstContext, {
@@ -1436,7 +1850,7 @@ async function runPipeline(input, config, dryRun) {
     }
   }
   if (config.monorepo?.mode) {
-    const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-JZ3VUZKP.js");
+    const { detectMonorepo, writeMonorepoChangelogs } = await import("./aggregator-XJ2EILO3.js");
     const cwd = process.cwd();
     const detected = detectMonorepo(cwd);
     if (detected.isMonorepo) {
@@ -1460,26 +1874,25 @@ async function runPipeline(input, config, dryRun) {
   return { packageNotes, files };
 }
 async function processInput(inputJson, config, dryRun) {
-  const input = parsePackageVersioner(inputJson);
+  const input = parseVersionOutput(inputJson);
   return runPipeline(input, config, dryRun);
 }
 
 export {
   loadAuth,
   saveAuth,
-  loadConfig,
+  loadConfig2 as loadConfig,
   getDefaultConfig,
   NotesError,
   InputParseError,
   TemplateError,
   LLMError,
   GitHubError,
-  ConfigError,
+  ConfigError2 as ConfigError,
   getExitCode,
-  EXIT_CODES2 as EXIT_CODES,
-  parsePackageVersioner,
-  parsePackageVersionerFile,
-  parsePackageVersionerStdin,
+  parseVersionOutput,
+  parseVersionOutputFile,
+  parseVersionOutputStdin,
   renderJson,
   writeJson,
   createTemplateContext,