@releasekit/notes 0.2.0-next.8 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sam Maister
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @releasekit/notes
 
-Changelog generation with LLM-powered enhancement and flexible templating.
+Changelog generation from conventional commits with LLM-powered enhancement and flexible templating
 
 ## Features
 

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

@@ -148,7 +148,7 @@ async function parsePackageVersionerStdin() {
 // src/output/markdown.ts
 import * as fs2 from "fs";
 import * as path from "path";
-import { info, success } from "@releasekit/core";
+import { debug, info, success } from "@releasekit/core";
 var TYPE_ORDER = ["added", "changed", "deprecated", "removed", "fixed", "security"];
 var TYPE_LABELS = {
   added: "Added",
@@ -247,9 +247,10 @@ ${body}`;
 function writeMarkdown(outputPath, contexts, config, dryRun) {
   const content = renderMarkdown(contexts);
   if (dryRun) {
-    info("--- Changelog Preview ---");
-    console.log(content);
-    info("--- End Preview ---");
+    info(`Would write changelog to ${outputPath}`);
+    debug("--- Changelog Preview ---");
+    debug(content);
+    debug("--- End Preview ---");
     return;
   }
   const dir = path.dirname(outputPath);
@@ -275,7 +276,7 @@ function writeMarkdown(outputPath, contexts, config, dryRun) {
 // src/output/json.ts
 import * as fs3 from "fs";
 import * as path2 from "path";
-import { info as info2, success as success2 } from "@releasekit/core";
+import { debug as debug2, info as info2, success as success2 } from "@releasekit/core";
 function renderJson(contexts) {
   return JSON.stringify(
     {
@@ -295,9 +296,10 @@ function renderJson(contexts) {
 function writeJson(outputPath, contexts, dryRun) {
   const content = renderJson(contexts);
   if (dryRun) {
-    info2("--- JSON Output Preview ---");
-    console.log(content);
-    info2("--- End Preview ---");
+    info2(`Would write JSON output to ${outputPath}`);
+    debug2("--- JSON Output Preview ---");
+    debug2(content);
+    debug2("--- End Preview ---");
     return;
   }
   const dir = path2.dirname(outputPath);
@@ -311,7 +313,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 warn3 } from "@releasekit/core";
+import { debug as debug3, info as info4, success as success4, warn as warn3 } from "@releasekit/core";
 
 // src/llm/defaults.ts
 var LLM_DEFAULTS = {
@@ -508,6 +510,83 @@ var OpenAICompatibleProvider = class extends BaseLLMProvider {
 
 // src/llm/tasks/categorize.ts
 import { warn } from "@releasekit/core";
+
+// src/llm/prompts.ts
+function resolvePrompt(taskName, defaultPrompt, promptsConfig) {
+  if (!promptsConfig) return defaultPrompt;
+  const fullTemplate = promptsConfig.templates?.[taskName];
+  if (fullTemplate) return fullTemplate;
+  const additionalInstructions = promptsConfig.instructions?.[taskName];
+  if (additionalInstructions) {
+    const insertionPoint = defaultPrompt.lastIndexOf("Output only valid JSON");
+    if (insertionPoint !== -1) {
+      return `${defaultPrompt.slice(0, insertionPoint)}Additional instructions:
+${additionalInstructions}
+
+${defaultPrompt.slice(insertionPoint)}`;
+    }
+    return `${defaultPrompt}
+
+Additional instructions:
+${additionalInstructions}`;
+  }
+  return defaultPrompt;
+}
+
+// src/llm/scopes.ts
+function getAllowedScopesFromCategories(categories) {
+  const scopeMap = /* @__PURE__ */ new Map();
+  for (const cat of categories) {
+    if (cat.scopes && cat.scopes.length > 0) {
+      scopeMap.set(cat.name, cat.scopes);
+    }
+  }
+  return scopeMap;
+}
+function resolveAllowedScopes(scopeConfig, categories, packageNames) {
+  if (!scopeConfig || scopeConfig.mode === "unrestricted") return null;
+  if (scopeConfig.mode === "none") return [];
+  if (scopeConfig.mode === "packages") return packageNames ?? [];
+  if (scopeConfig.mode === "restricted") {
+    const explicit = scopeConfig.rules?.allowed ?? [];
+    const all = new Set(explicit);
+    if (categories) {
+      const fromCategories = getAllowedScopesFromCategories(categories);
+      for (const scopes of fromCategories.values()) {
+        for (const s of scopes) all.add(s);
+      }
+    }
+    return [...all];
+  }
+  return null;
+}
+function validateScope(scope, allowedScopes, rules) {
+  if (!scope || allowedScopes === null) return scope;
+  if (allowedScopes.length === 0) return void 0;
+  const caseSensitive = rules?.caseSensitive ?? false;
+  const normalise = (s) => caseSensitive ? s : s.toLowerCase();
+  const isAllowed = allowedScopes.some((a) => normalise(a) === normalise(scope));
+  if (isAllowed) return scope;
+  switch (rules?.invalidScopeAction ?? "remove") {
+    case "keep":
+      return scope;
+    case "fallback":
+      return rules?.fallbackScope;
+    case "remove":
+    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").
@@ -519,20 +598,21 @@ 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");
+  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 (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(", ")}.
-`;
-      }
+  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.
 
@@ -540,9 +620,10 @@ Given the following entries, group them into the specified categories. Only use
 
 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
+- "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}}
@@ -553,9 +634,11 @@ async function categorizeEntries(provider, entries, context) {
   if (entries.length === 0) {
     return [];
   }
-  const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
+  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 promptTemplate = hasCustomCategories ? buildCustomCategorizePrompt(context.categories) : DEFAULT_CATEGORIZE_PROMPT;
+  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);
@@ -567,13 +650,14 @@ async function categorizeEntries(provider, entries, context) {
       const scopeMap = parsed.scopes || {};
       for (const [indexStr, scope] of Object.entries(scopeMap)) {
         const idx = Number.parseInt(indexStr, 10);
-        if (entries[idx] && scope) {
-          entries[idx] = { ...entries[idx], scope };
+        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) => entries[i]).filter((e) => e !== void 0);
+        const categoryEntries = indices.map((i) => validatedEntries[i]).filter((e) => e !== void 0);
         if (categoryEntries.length > 0) {
           result.push({ category, entries: categoryEntries });
         }
@@ -582,7 +666,7 @@ async function categorizeEntries(provider, entries, context) {
       const categoryMap = parsed;
       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);
+        const categoryEntries = indices.map((i) => entriesCopy[i]).filter((e) => e !== void 0);
         if (categoryEntries.length > 0) {
           result.push({ category, entries: categoryEntries });
         }
@@ -593,12 +677,12 @@ async function categorizeEntries(provider, entries, context) {
     warn(
       `LLM categorization failed, falling back to General: ${error instanceof Error ? error.message : String(error)}`
     );
-    return [{ category: "General", entries }];
+    return [{ category: "General", entries: entriesCopy }];
   }
 }
 
 // src/llm/tasks/enhance.ts
-var ENHANCE_PROMPT = `You are improving changelog entries for a software project.
+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:
@@ -614,9 +698,10 @@ Type: {{type}}
 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 prompt = ENHANCE_PROMPT.replace("{{style}}", styleText).replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
+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();
 }
@@ -672,7 +757,23 @@ 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").`;
+${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
@@ -683,9 +784,7 @@ Style guidelines:
 - 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").' : ""}
+${categorySection}${scopeInstruction}
 
 Entries:
 ${entriesText}
@@ -702,7 +801,8 @@ async function enhanceAndCategorize(provider, entries, context) {
   const retryOpts = LLM_DEFAULTS.retry;
   try {
     return await withRetry(async () => {
-      const prompt = buildPrompt(entries, context.categories, context.style);
+      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);
@@ -718,22 +818,23 @@ async function enhanceAndCategorize(provider, entries, context) {
           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 = enhancedEntries[i];
+        const entry = validatedEntries[i];
         if (!entry) continue;
         if (!categoryMap.has(category)) {
           categoryMap.set(category, []);
         }
-        categoryMap.get(category).push(entry);
+        categoryMap.get(category)?.push(entry);
       }
       const categories = [];
       for (const [category, catEntries] of categoryMap) {
         categories.push({ category, entries: catEntries });
       }
-      return { enhancedEntries, categories };
+      return { enhancedEntries: validatedEntries, categories };
     }, retryOpts);
   } catch (error) {
     warn2(
@@ -747,7 +848,7 @@ async function enhanceAndCategorize(provider, entries, context) {
 }
 
 // src/llm/tasks/release-notes.ts
-var RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
+var DEFAULT_RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
 
 Create engaging, user-friendly release notes for the following changes.
 
@@ -780,16 +881,17 @@ No notable changes in this release.`;
     if (e.breaking) line += " **BREAKING**";
     return line;
   }).join("\n");
-  const prompt = RELEASE_NOTES_PROMPT.replace("{{version}}", context.version ?? "v1.0.0").replace(
+  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 SUMMARIZE_PROMPT = `You are creating a summary of changes for a software release.
+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.
 
@@ -797,12 +899,13 @@ Entries:
 {{entries}}
 
 Summary (only output the summary, nothing else):`;
-async function summarizeEntries(provider, entries, _context) {
+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 prompt = SUMMARIZE_PROMPT.replace("{{entries}}", entriesText);
+  const defaultPrompt = DEFAULT_SUMMARIZE_PROMPT.replace("{{entries}}", entriesText);
+  const prompt = resolvePrompt("summarize", defaultPrompt, context.prompts);
   const response = await provider.complete(prompt);
   return response.trim();
 }
@@ -1214,17 +1317,27 @@ function renderTemplate(templatePath, context, engine) {
 }
 
 // src/core/pipeline.ts
-function generateCompareUrl(repoUrl, from, to) {
+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/${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;
+  const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version, pkg.packageName) : void 0;
   return {
     packageName: pkg.packageName,
     version: pkg.version,
@@ -1262,7 +1375,9 @@ async function processWithLLM(context, config) {
     previousVersion: context.previousVersion ?? void 0,
     date: context.date,
     categories: config.llm.categories,
-    style: config.llm.style
+    style: config.llm.style,
+    scopes: config.llm.scopes,
+    prompts: config.llm.prompts
   };
   const enhanced = {
     entries: context.entries
@@ -1310,7 +1425,7 @@ async function processWithLLM(context, config) {
       enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
       if (enhanced.summary) {
         info4("Summary generated successfully");
-        debug(`Summary: ${enhanced.summary.substring(0, 100)}...`);
+        debug3(`Summary: ${enhanced.summary.substring(0, 100)}...`);
       } else {
         warn3("Summary generation returned empty result");
       }
@@ -1326,7 +1441,6 @@ async function processWithLLM(context, config) {
     }
     return {
       ...context,
-      entries: enhanced.entries,
       enhanced
     };
   } catch (error) {
@@ -1359,9 +1473,10 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   );
   const result = renderTemplate(templatePath, documentContext, config.templates?.engine);
   if (dryRun) {
-    info4("--- Changelog Preview ---");
-    console.log(result.content);
-    info4("--- End Preview ---");
+    info4(`Would write templated output to ${outputPath}`);
+    debug3("--- Changelog Preview ---");
+    debug3(result.content);
+    debug3("--- End Preview ---");
     return;
   }
   if (outputPath === "-") {
@@ -1376,7 +1491,7 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
   success4(`Changelog written to ${outputPath} (using ${result.engine} template)`);
 }
 async function runPipeline(input, config, dryRun) {
-  debug(`Processing ${input.packages.length} package(s)`);
+  debug3(`Processing ${input.packages.length} package(s)`);
   let contexts = input.packages.map(createTemplateContext);
   if (config.llm && !process.env.CHANGELOG_NO_LLM) {
     info4("Processing with LLM enhancement");
@@ -1387,8 +1502,10 @@ async function runPipeline(input, config, dryRun) {
     switch (output.format) {
       case "markdown": {
         const file = output.file ?? "CHANGELOG.md";
-        if (config.templates?.path || output.options?.template) {
-          await generateWithTemplate(contexts, config, file, dryRun);
+        const effectiveTemplateConfig = output.templates ?? config.templates;
+        if (effectiveTemplateConfig?.path || output.options?.template) {
+          const configWithTemplate = { ...config, templates: effectiveTemplateConfig };
+          await generateWithTemplate(contexts, configWithTemplate, file, dryRun);
         } else {
           writeMarkdown(file, contexts, config, dryRun);
         }
@@ -1438,7 +1555,7 @@ async function processInput(inputJson, config, dryRun) {
 // src/monorepo/aggregator.ts
 import * as fs9 from "fs";
 import * as path7 from "path";
-import { info as info5, success as success5 } from "@releasekit/core";
+import { debug as debug4, info as info5, success as success5 } from "@releasekit/core";
 
 // src/monorepo/splitter.ts
 function splitByPackage(contexts) {
@@ -1452,8 +1569,8 @@ function splitByPackage(contexts) {
 // src/monorepo/aggregator.ts
 function writeFile(outputPath, content, dryRun) {
   if (dryRun) {
-    info5(`[DRY RUN] Would write to ${outputPath}`);
-    console.log(content);
+    info5(`Would write to ${outputPath}`);
+    debug4(content);
     return;
   }
   const dir = path7.dirname(outputPath);