@releasekit/notes 0.2.0-next.5 → 0.2.0-next.7

package/dist/{chunk-ADZJSWND.js → chunk-BLWJTLRD.js}

@@ -520,15 +520,26 @@ Entries:
 Output only valid JSON, nothing else:`;
 function buildCustomCategorizePrompt(categories) {
   const categoryList = categories.map((c) => `- "${c.name}": ${c.description}`).join("\n");
+  const developerCategory = categories.find((c) => c.name === "Developer");
+  let scopeInstructions = "";
+  if (developerCategory) {
+    const scopeMatch = developerCategory.description.match(/from:\s*([^.]+)/);
+    if (scopeMatch?.[1]) {
+      const scopes = scopeMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+      if (scopes.length > 0) {
+        scopeInstructions = `
+
+For the "Developer" category, you MUST assign a scope from this exact list: ${scopes.join(", ")}.
+`;
+      }
+    }
+  }
   return `You are categorizing changelog entries for a software release.
 
-Given the following entries, group them into the specified categories. Only use the categories listed below.
+Given the following entries, group them into the specified categories. Only use the categories listed below in this exact order:
 
 Categories:
-${categoryList}
-
-For entries in categories that involve internal/developer changes, set a "scope" field on those entries with a short subcategory label (e.g., "CI", "Dependencies", "Testing", "Code Quality", "Build System").
-
+${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
@@ -630,6 +641,33 @@ async function enhanceEntries(provider, entries, context, concurrency = LLM_DEFA
 
 // src/llm/tasks/enhance-and-categorize.ts
 import { warn as warn2 } from "@releasekit/core";
+
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const initialDelay = options.initialDelay ?? 1e3;
+  const maxDelay = options.maxDelay ?? 3e4;
+  const backoffFactor = options.backoffFactor ?? 2;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
+        const jitter = base * 0.2 * (Math.random() * 2 - 1);
+        await sleep(Math.max(0, base + jitter));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/llm/tasks/enhance-and-categorize.ts
 function buildPrompt(entries, categories, style) {
   const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
   const styleText = style || 'Use present tense ("Add feature" not "Added feature"). Be concise.';
@@ -661,41 +699,46 @@ async function enhanceAndCategorize(provider, entries, context) {
   if (entries.length === 0) {
     return { enhancedEntries: [], categories: [] };
   }
-  const prompt = buildPrompt(entries, context.categories, context.style);
+  const retryOpts = LLM_DEFAULTS.retry;
   try {
-    const response = await provider.complete(prompt);
-    const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-    const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed.entries)) {
-      throw new Error('Response missing "entries" array');
-    }
-    const enhancedEntries = entries.map((original, i) => {
-      const result = parsed.entries[i];
-      if (!result) return original;
-      return {
-        ...original,
-        description: result.description || original.description,
-        scope: result.scope || original.scope
-      };
-    });
-    const categoryMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsed.entries.length; i++) {
-      const result = parsed.entries[i];
-      const category = result?.category || "General";
-      const entry = enhancedEntries[i];
-      if (!entry) continue;
-      if (!categoryMap.has(category)) {
-        categoryMap.set(category, []);
+    return await withRetry(async () => {
+      const prompt = buildPrompt(entries, context.categories, context.style);
+      const response = await provider.complete(prompt);
+      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed.entries)) {
+        throw new Error('Response missing "entries" array');
       }
-      categoryMap.get(category).push(entry);
-    }
-    const categories = [];
-    for (const [category, catEntries] of categoryMap) {
-      categories.push({ category, entries: catEntries });
-    }
-    return { enhancedEntries, categories };
+      const enhancedEntries = entries.map((original, i) => {
+        const result = parsed.entries[i];
+        if (!result) return original;
+        return {
+          ...original,
+          description: result.description || original.description,
+          scope: result.scope || original.scope
+        };
+      });
+      const categoryMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < parsed.entries.length; i++) {
+        const result = parsed.entries[i];
+        const category = result?.category || "General";
+        const entry = enhancedEntries[i];
+        if (!entry) continue;
+        if (!categoryMap.has(category)) {
+          categoryMap.set(category, []);
+        }
+        categoryMap.get(category).push(entry);
+      }
+      const categories = [];
+      for (const [category, catEntries] of categoryMap) {
+        categories.push({ category, entries: catEntries });
+      }
+      return { enhancedEntries, categories };
+    }, retryOpts);
   } catch (error) {
-    warn2(`Combined enhance+categorize failed: ${error instanceof Error ? error.message : String(error)}`);
+    warn2(
+      `Combined enhance+categorize failed after ${retryOpts.maxAttempts} attempts: ${error instanceof Error ? error.message : String(error)}`
+    );
     return {
       enhancedEntries: entries,
       categories: [{ category: "General", entries }]
@@ -1170,31 +1213,6 @@ function renderTemplate(templatePath, context, engine) {
   return renderComposable(templatePath, context, engine);
 }
 
-// src/utils/retry.ts
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function withRetry(fn, options = {}) {
-  const maxAttempts = options.maxAttempts ?? 3;
-  const initialDelay = options.initialDelay ?? 1e3;
-  const maxDelay = options.maxDelay ?? 3e4;
-  const backoffFactor = options.backoffFactor ?? 2;
-  let lastError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < maxAttempts - 1) {
-        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
-        const jitter = base * 0.2 * (Math.random() * 2 - 1);
-        await sleep(Math.max(0, base + jitter));
-      }
-    }
-  }
-  throw lastError;
-}
-
 // src/core/pipeline.ts
 function generateCompareUrl(repoUrl, from, to) {
   if (/gitlab\.com/i.test(repoUrl)) {
@@ -1263,7 +1281,7 @@ async function processWithLLM(context, config) {
     const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
     info4(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance && tasks.categorize) {
-      info4("Enhancing and categorizing entries with LLM (single call)...");
+      info4("Enhancing and categorizing entries with LLM...");
       const result = await enhanceAndCategorize(provider, context.entries, llmContext);
       enhanced.entries = result.enhancedEntries;
       enhanced.categories = {};

package/dist/cli.cjs

@@ -366,15 +366,26 @@ Entries:
 Output only valid JSON, nothing else:`;
 function buildCustomCategorizePrompt(categories) {
   const categoryList = categories.map((c) => `- "${c.name}": ${c.description}`).join("\n");
+  const developerCategory = categories.find((c) => c.name === "Developer");
+  let scopeInstructions = "";
+  if (developerCategory) {
+    const scopeMatch = developerCategory.description.match(/from:\s*([^.]+)/);
+    if (scopeMatch?.[1]) {
+      const scopes = scopeMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+      if (scopes.length > 0) {
+        scopeInstructions = `
+
+For the "Developer" category, you MUST assign a scope from this exact list: ${scopes.join(", ")}.
+`;
+      }
+    }
+  }
   return `You are categorizing changelog entries for a software release.
 
-Given the following entries, group them into the specified categories. Only use the categories listed below.
+Given the following entries, group them into the specified categories. Only use the categories listed below in this exact order:
 
 Categories:
-${categoryList}
-
-For entries in categories that involve internal/developer changes, set a "scope" field on those entries with a short subcategory label (e.g., "CI", "Dependencies", "Testing", "Code Quality", "Build System").
-
+${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
@@ -476,6 +487,33 @@ async function enhanceEntries(provider, entries, context, concurrency = LLM_DEFA
 
 // src/llm/tasks/enhance-and-categorize.ts
 var import_core4 = require("@releasekit/core");
+
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const initialDelay = options.initialDelay ?? 1e3;
+  const maxDelay = options.maxDelay ?? 3e4;
+  const backoffFactor = options.backoffFactor ?? 2;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error2) {
+      lastError = error2;
+      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.';
@@ -507,41 +545,46 @@ async function enhanceAndCategorize(provider, entries, context) {
   if (entries.length === 0) {
     return { enhancedEntries: [], categories: [] };
   }
-  const prompt = buildPrompt(entries, context.categories, context.style);
+  const retryOpts = LLM_DEFAULTS.retry;
   try {
-    const response = await provider.complete(prompt);
-    const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-    const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed.entries)) {
-      throw new Error('Response missing "entries" array');
-    }
-    const enhancedEntries = entries.map((original, i) => {
-      const result = parsed.entries[i];
-      if (!result) return original;
-      return {
-        ...original,
-        description: result.description || original.description,
-        scope: result.scope || original.scope
-      };
-    });
-    const categoryMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsed.entries.length; i++) {
-      const result = parsed.entries[i];
-      const category = result?.category || "General";
-      const entry = enhancedEntries[i];
-      if (!entry) continue;
-      if (!categoryMap.has(category)) {
-        categoryMap.set(category, []);
+    return await withRetry(async () => {
+      const prompt = buildPrompt(entries, context.categories, context.style);
+      const response = await provider.complete(prompt);
+      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed.entries)) {
+        throw new Error('Response missing "entries" array');
       }
-      categoryMap.get(category).push(entry);
-    }
-    const categories = [];
-    for (const [category, catEntries] of categoryMap) {
-      categories.push({ category, entries: catEntries });
-    }
-    return { enhancedEntries, categories };
+      const enhancedEntries = entries.map((original, i) => {
+        const result = parsed.entries[i];
+        if (!result) return original;
+        return {
+          ...original,
+          description: result.description || original.description,
+          scope: result.scope || original.scope
+        };
+      });
+      const categoryMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < parsed.entries.length; i++) {
+        const result = parsed.entries[i];
+        const category = result?.category || "General";
+        const entry = enhancedEntries[i];
+        if (!entry) continue;
+        if (!categoryMap.has(category)) {
+          categoryMap.set(category, []);
+        }
+        categoryMap.get(category).push(entry);
+      }
+      const categories = [];
+      for (const [category, catEntries] of categoryMap) {
+        categories.push({ category, entries: catEntries });
+      }
+      return { enhancedEntries, categories };
+    }, retryOpts);
   } catch (error2) {
-    (0, import_core4.warn)(`Combined enhance+categorize failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    (0, import_core4.warn)(
+      `Combined enhance+categorize failed after ${retryOpts.maxAttempts} attempts: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
     return {
       enhancedEntries: entries,
       categories: [{ category: "General", entries }]
@@ -1181,31 +1224,6 @@ function renderTemplate(templatePath, context, engine) {
   return renderComposable(templatePath, context, engine);
 }
 
-// src/utils/retry.ts
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function withRetry(fn, options = {}) {
-  const maxAttempts = options.maxAttempts ?? 3;
-  const initialDelay = options.initialDelay ?? 1e3;
-  const maxDelay = options.maxDelay ?? 3e4;
-  const backoffFactor = options.backoffFactor ?? 2;
-  let lastError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error2) {
-      lastError = error2;
-      if (attempt < maxAttempts - 1) {
-        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
-        const jitter = base * 0.2 * (Math.random() * 2 - 1);
-        await sleep(Math.max(0, base + jitter));
-      }
-    }
-  }
-  throw lastError;
-}
-
 // src/core/pipeline.ts
 var import_meta = {};
 function generateCompareUrl(repoUrl, from, to) {
@@ -1275,7 +1293,7 @@ async function processWithLLM(context, config) {
     const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
     (0, import_core8.info)(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance && tasks.categorize) {
-      (0, import_core8.info)("Enhancing and categorizing entries with LLM (single call)...");
+      (0, import_core8.info)("Enhancing and categorizing entries with LLM...");
       const result = await enhanceAndCategorize(provider, context.entries, llmContext);
       enhanced.entries = result.enhancedEntries;
       enhanced.categories = {};

package/dist/cli.js

@@ -11,7 +11,7 @@ import {
   runPipeline,
   saveAuth,
   writeMonorepoChangelogs
-} from "./chunk-ADZJSWND.js";
+} from "./chunk-BLWJTLRD.js";
 
 // src/cli.ts
 import * as fs from "fs";

package/dist/index.cjs

@@ -416,15 +416,26 @@ Entries:
 Output only valid JSON, nothing else:`;
 function buildCustomCategorizePrompt(categories) {
   const categoryList = categories.map((c) => `- "${c.name}": ${c.description}`).join("\n");
+  const developerCategory = categories.find((c) => c.name === "Developer");
+  let scopeInstructions = "";
+  if (developerCategory) {
+    const scopeMatch = developerCategory.description.match(/from:\s*([^.]+)/);
+    if (scopeMatch?.[1]) {
+      const scopes = scopeMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+      if (scopes.length > 0) {
+        scopeInstructions = `
+
+For the "Developer" category, you MUST assign a scope from this exact list: ${scopes.join(", ")}.
+`;
+      }
+    }
+  }
   return `You are categorizing changelog entries for a software release.
 
-Given the following entries, group them into the specified categories. Only use the categories listed below.
+Given the following entries, group them into the specified categories. Only use the categories listed below in this exact order:
 
 Categories:
-${categoryList}
-
-For entries in categories that involve internal/developer changes, set a "scope" field on those entries with a short subcategory label (e.g., "CI", "Dependencies", "Testing", "Code Quality", "Build System").
-
+${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
@@ -526,6 +537,33 @@ async function enhanceEntries(provider, entries, context, concurrency = LLM_DEFA
 
 // src/llm/tasks/enhance-and-categorize.ts
 var import_core4 = require("@releasekit/core");
+
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const initialDelay = options.initialDelay ?? 1e3;
+  const maxDelay = options.maxDelay ?? 3e4;
+  const backoffFactor = options.backoffFactor ?? 2;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
+        const jitter = base * 0.2 * (Math.random() * 2 - 1);
+        await sleep(Math.max(0, base + jitter));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/llm/tasks/enhance-and-categorize.ts
 function buildPrompt(entries, categories, style) {
   const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
   const styleText = style || 'Use present tense ("Add feature" not "Added feature"). Be concise.';
@@ -557,41 +595,46 @@ async function enhanceAndCategorize(provider, entries, context) {
   if (entries.length === 0) {
     return { enhancedEntries: [], categories: [] };
   }
-  const prompt = buildPrompt(entries, context.categories, context.style);
+  const retryOpts = LLM_DEFAULTS.retry;
   try {
-    const response = await provider.complete(prompt);
-    const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-    const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed.entries)) {
-      throw new Error('Response missing "entries" array');
-    }
-    const enhancedEntries = entries.map((original, i) => {
-      const result = parsed.entries[i];
-      if (!result) return original;
-      return {
-        ...original,
-        description: result.description || original.description,
-        scope: result.scope || original.scope
-      };
-    });
-    const categoryMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsed.entries.length; i++) {
-      const result = parsed.entries[i];
-      const category = result?.category || "General";
-      const entry = enhancedEntries[i];
-      if (!entry) continue;
-      if (!categoryMap.has(category)) {
-        categoryMap.set(category, []);
+    return await withRetry(async () => {
+      const prompt = buildPrompt(entries, context.categories, context.style);
+      const response = await provider.complete(prompt);
+      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed.entries)) {
+        throw new Error('Response missing "entries" array');
       }
-      categoryMap.get(category).push(entry);
-    }
-    const categories = [];
-    for (const [category, catEntries] of categoryMap) {
-      categories.push({ category, entries: catEntries });
-    }
-    return { enhancedEntries, categories };
+      const enhancedEntries = entries.map((original, i) => {
+        const result = parsed.entries[i];
+        if (!result) return original;
+        return {
+          ...original,
+          description: result.description || original.description,
+          scope: result.scope || original.scope
+        };
+      });
+      const categoryMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < parsed.entries.length; i++) {
+        const result = parsed.entries[i];
+        const category = result?.category || "General";
+        const entry = enhancedEntries[i];
+        if (!entry) continue;
+        if (!categoryMap.has(category)) {
+          categoryMap.set(category, []);
+        }
+        categoryMap.get(category).push(entry);
+      }
+      const categories = [];
+      for (const [category, catEntries] of categoryMap) {
+        categories.push({ category, entries: catEntries });
+      }
+      return { enhancedEntries, categories };
+    }, retryOpts);
   } catch (error) {
-    (0, import_core4.warn)(`Combined enhance+categorize failed: ${error instanceof Error ? error.message : String(error)}`);
+    (0, import_core4.warn)(
+      `Combined enhance+categorize failed after ${retryOpts.maxAttempts} attempts: ${error instanceof Error ? error.message : String(error)}`
+    );
     return {
       enhancedEntries: entries,
       categories: [{ category: "General", entries }]
@@ -1231,31 +1274,6 @@ function renderTemplate(templatePath, context, engine) {
   return renderComposable(templatePath, context, engine);
 }
 
-// src/utils/retry.ts
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function withRetry(fn, options = {}) {
-  const maxAttempts = options.maxAttempts ?? 3;
-  const initialDelay = options.initialDelay ?? 1e3;
-  const maxDelay = options.maxDelay ?? 3e4;
-  const backoffFactor = options.backoffFactor ?? 2;
-  let lastError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < maxAttempts - 1) {
-        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
-        const jitter = base * 0.2 * (Math.random() * 2 - 1);
-        await sleep(Math.max(0, base + jitter));
-      }
-    }
-  }
-  throw lastError;
-}
-
 // src/core/pipeline.ts
 var import_meta = {};
 function generateCompareUrl(repoUrl, from, to) {
@@ -1325,7 +1343,7 @@ async function processWithLLM(context, config) {
     const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
     (0, import_core8.info)(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance && tasks.categorize) {
-      (0, import_core8.info)("Enhancing and categorizing entries with LLM (single call)...");
+      (0, import_core8.info)("Enhancing and categorizing entries with LLM...");
       const result = await enhanceAndCategorize(provider, context.entries, llmContext);
       enhanced.entries = result.enhancedEntries;
       enhanced.categories = {};

package/dist/index.js

@@ -24,7 +24,7 @@ import {
   writeJson,
   writeMarkdown,
   writeMonorepoChangelogs
-} from "./chunk-ADZJSWND.js";
+} from "./chunk-BLWJTLRD.js";
 export {
   NotesError as ChangelogCreatorError,
   ConfigError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@releasekit/notes",
-  "version": "0.2.0-next.5",
+  "version": "0.2.0-next.7",
   "description": "Changelog generation with LLM-powered enhancement and flexible templating",
   "type": "module",
   "main": "./dist/index.cjs",