@releasekit/notes 0.2.0-next.0 → 0.2.0-next.10

package/dist/{chunk-NHDLQLG2.js → chunk-ACXCEHQT.js}

@@ -256,6 +256,10 @@ function writeMarkdown(outputPath, contexts, config, dryRun) {
   if (!fs2.existsSync(dir)) {
     fs2.mkdirSync(dir, { recursive: true });
   }
+  if (outputPath === "-") {
+    process.stdout.write(content);
+    return;
+  }
   if (config.updateStrategy === "prepend" && fs2.existsSync(outputPath) && contexts.length === 1) {
     const firstContext = contexts[0];
     if (firstContext) {
@@ -307,7 +311,7 @@ function writeJson(outputPath, contexts, dryRun) {
 // src/core/pipeline.ts
 import * as fs8 from "fs";
 import * as path6 from "path";
-import { debug, info as info4, success as success4, warn as warn2 } from "@releasekit/core";
+import { debug, info as info4, success as success4, warn as warn3 } from "@releasekit/core";
 
 // src/llm/defaults.ts
 var LLM_DEFAULTS = {
@@ -516,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
@@ -556,7 +571,8 @@ async function categorizeEntries(provider, entries, context) {
           entries[idx] = { ...entries[idx], scope };
         }
       }
-      for (const [category, indices] of Object.entries(categoryMap)) {
+      for (const [category, rawIndices] of Object.entries(categoryMap)) {
+        const indices = Array.isArray(rawIndices) ? rawIndices : [];
         const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
         if (categoryEntries.length > 0) {
           result.push({ category, entries: categoryEntries });
@@ -564,7 +580,8 @@ async function categorizeEntries(provider, entries, context) {
       }
     } else {
       const categoryMap = parsed;
-      for (const [category, indices] of Object.entries(categoryMap)) {
+      for (const [category, rawIndices] of Object.entries(categoryMap)) {
+        const indices = Array.isArray(rawIndices) ? rawIndices : [];
         const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
         if (categoryEntries.length > 0) {
           result.push({ category, entries: categoryEntries });
@@ -622,6 +639,113 @@ 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));
+}
+async function withRetry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const initialDelay = options.initialDelay ?? 1e3;
+  const maxDelay = options.maxDelay ?? 3e4;
+  const backoffFactor = options.backoffFactor ?? 2;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
+        const jitter = base * 0.2 * (Math.random() * 2 - 1);
+        await sleep(Math.max(0, base + jitter));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/llm/tasks/enhance-and-categorize.ts
+function buildPrompt(entries, categories, style) {
+  const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
+  const styleText = style || 'Use present tense ("Add feature" not "Added feature"). Be concise.';
+  const categorySection = categories ? `Categories (use ONLY these):
+${categories.map((c) => `- "${c.name}": ${c.description}`).join("\n")}` : `Categories: Group into meaningful categories (e.g., "New", "Fixed", "Changed", "Removed").`;
+  return `You are generating release notes for a software project. Given the following changelog entries, do two things:
+
+1. **Rewrite** each entry as a clear, user-friendly description
+2. **Categorize** each entry into the appropriate category
+
+Style guidelines:
+- ${styleText}
+- Be concise (1 short sentence per entry)
+- Focus on what changed, not implementation details
+
+${categorySection}
+
+${categories ? 'For entries in categories involving internal/developer changes, set a "scope" field with a short subcategory label (e.g., "CI", "Dependencies", "Testing").' : ""}
+
+Entries:
+${entriesText}
+
+Output a JSON object with:
+- "entries": array of objects, one per input entry (same order), each with: { "description": "rewritten text", "category": "CategoryName", "scope": "optional subcategory label or null" }
+
+Output only valid JSON, nothing else:`;
+}
+async function enhanceAndCategorize(provider, entries, context) {
+  if (entries.length === 0) {
+    return { enhancedEntries: [], categories: [] };
+  }
+  const retryOpts = LLM_DEFAULTS.retry;
+  try {
+    return await withRetry(async () => {
+      const prompt = buildPrompt(entries, context.categories, context.style);
+      const response = await provider.complete(prompt);
+      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed.entries)) {
+        throw new Error('Response missing "entries" array');
+      }
+      const enhancedEntries = entries.map((original, i) => {
+        const result = parsed.entries[i];
+        if (!result) return original;
+        return {
+          ...original,
+          description: result.description || original.description,
+          scope: result.scope || original.scope
+        };
+      });
+      const categoryMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < parsed.entries.length; i++) {
+        const result = parsed.entries[i];
+        const category = result?.category || "General";
+        const entry = enhancedEntries[i];
+        if (!entry) continue;
+        if (!categoryMap.has(category)) {
+          categoryMap.set(category, []);
+        }
+        categoryMap.get(category).push(entry);
+      }
+      const categories = [];
+      for (const [category, catEntries] of categoryMap) {
+        categories.push({ category, entries: catEntries });
+      }
+      return { enhancedEntries, categories };
+    }, retryOpts);
+  } catch (error) {
+    warn2(
+      `Combined enhance+categorize failed after ${retryOpts.maxAttempts} attempts: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {
+      enhancedEntries: entries,
+      categories: [{ category: "General", entries }]
+    };
+  }
+}
+
 // src/llm/tasks/release-notes.ts
 var RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
 
@@ -1089,40 +1213,23 @@ 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));
-      }
-    }
+// src/core/pipeline.ts
+function extractVersionFromTag(tag) {
+  if (tag.includes("@") && !tag.startsWith("@")) {
+    return tag;
   }
-  throw lastError;
+  return tag.replace(/^v/, "");
 }
-
-// src/core/pipeline.ts
 function generateCompareUrl(repoUrl, from, to) {
+  const fromVersion = extractVersionFromTag(from);
+  const toVersion = extractVersionFromTag(to);
   if (/gitlab\.com/i.test(repoUrl)) {
-    return `${repoUrl}/-/compare/${from}...${to}`;
+    return `${repoUrl}/-/compare/${fromVersion}...${toVersion}`;
   }
   if (/bitbucket\.org/i.test(repoUrl)) {
-    return `${repoUrl}/branches/compare/${from}..${to}`;
+    return `${repoUrl}/branches/compare/${fromVersion}..${toVersion}`;
   }
-  return `${repoUrl}/compare/${from}...${to}`;
+  return `${repoUrl}/compare/${fromVersion}...${toVersion}`;
 }
 function createTemplateContext(pkg) {
   const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version) : void 0;
@@ -1181,10 +1288,30 @@ 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) {
-      info4("Enhancing entries with LLM...");
-      enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
-      info4(`Enhanced ${enhanced.entries.length} entries`);
+    if (tasks.enhance && tasks.categorize) {
+      info4("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;
+      }
+      info4(`Enhanced ${enhanced.entries.length} entries into ${result.categories.length} categories`);
+    } else {
+      if (tasks.enhance) {
+        info4("Enhancing entries with LLM...");
+        enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
+        info4(`Enhanced ${enhanced.entries.length} entries`);
+      }
+      if (tasks.categorize) {
+        info4("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;
+        }
+        info4(`Created ${categorized.length} categories`);
+      }
     }
     if (tasks.summarize) {
       info4("Summarizing entries with LLM...");
@@ -1193,25 +1320,16 @@ async function processWithLLM(context, config) {
         info4("Summary generated successfully");
         debug(`Summary: ${enhanced.summary.substring(0, 100)}...`);
       } else {
-        warn2("Summary generation returned empty result");
+        warn3("Summary generation returned empty result");
       }
     }
-    if (tasks.categorize) {
-      info4("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;
-      }
-      info4(`Created ${categorized.length} categories`);
-    }
     if (tasks.releaseNotes) {
       info4("Generating release notes with LLM...");
       enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
       if (enhanced.releaseNotes) {
         info4("Release notes generated successfully");
       } else {
-        warn2("Release notes generation returned empty result");
+        warn3("Release notes generation returned empty result");
       }
     }
     return {
@@ -1220,8 +1338,8 @@ async function processWithLLM(context, config) {
       enhanced
     };
   } catch (error) {
-    warn2(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
-    warn2("Falling back to raw entries");
+    warn3(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
+    warn3("Falling back to raw entries");
     return context;
   }
 }
@@ -1254,6 +1372,10 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
     info4("--- End Preview ---");
     return;
   }
+  if (outputPath === "-") {
+    process.stdout.write(result.content);
+    return;
+  }
   const dir = path6.dirname(outputPath);
   if (!fs8.existsSync(dir)) {
     fs8.mkdirSync(dir, { recursive: true });
@@ -1292,17 +1414,17 @@ async function runPipeline(input, config, dryRun) {
         }
         const firstContext = contexts[0];
         if (!firstContext) {
-          warn2("No context available for GitHub release");
+          warn3("No context available for GitHub release");
           break;
         }
         const repoUrl = firstContext.repoUrl;
         if (!repoUrl) {
-          warn2("No repo URL available, cannot create GitHub release");
+          warn3("No repo URL available, cannot create GitHub release");
           break;
         }
         const parsed = parseRepoUrl(repoUrl);
         if (!parsed) {
-          warn2(`Could not parse repo URL: ${repoUrl}`);
+          warn3(`Could not parse repo URL: ${repoUrl}`);
           break;
         }
         await createGitHubRelease(firstContext, {