@releasekit/notes 0.3.0 → 0.4.0

package/README.md

@@ -1,15 +1,21 @@
 # @releasekit/notes
 
-Release notes and changelog generation from conventional commits with LLM-powered enhancement and flexible templating
+[![@releasekit/notes](https://img.shields.io/badge/@releasekit-notes-9feaf9?labelColor=1a1a1a&style=plastic)](https://www.npmjs.com/package/@releasekit/notes)
+[![Version](https://img.shields.io/npm/v/@releasekit/notes?color=28a745&labelColor=1a1a1a)](https://www.npmjs.com/package/@releasekit/notes)
+[![Downloads](https://img.shields.io/npm/dw/@releasekit/notes?color=6f42c1&labelColor=1a1a1a)](https://www.npmjs.com/package/@releasekit/notes)
+
+**Changelog and release notes generation from conventional commits**
+
+Generates CHANGELOG.md and release notes from `@releasekit/version` output, with optional LLM-powered enhancement and flexible templating.
 
 ## Features
 
-- **Multiple input sources** — `@releasekit/version` JSON, git log, or manual JSON
-- **Flexible templating** — Liquid, Handlebars, or EJS with single-file or composable templates
-- **LLM enhancement** (optional) — summarize, categorize, enhance descriptions, generate release notes
-- **Monorepo support** — root aggregation, per-package changelogs, or both
-- **Multiple outputs** — Markdown, JSON, or GitHub Releases API
-- **Dry-run mode** — preview without writing files
+- 📝 **Conventional changelog** — Keep a Changelog, Angular, or custom format
+- 🤖 **LLM enhancement** (optional) — enhance descriptions, summarize, categorize, or generate prose release notes
+- 🎨 **Flexible templating** — Liquid, Handlebars, or EJS; single-file or composable layout
+- 📦 **Monorepo support** — root aggregation, per-package changelogs, or both
+- 🔀 **Two outputs** — `CHANGELOG.md` and `RELEASE_NOTES.md` are configured independently
+- 🔍 **Dry-run mode** — preview without writing files
 
 ## Installation
 
@@ -19,7 +25,7 @@ npm install -g @releasekit/notes
 pnpm add -g @releasekit/notes
 ```
 
-> **Note:** This package is ESM only and requires Node.js 20+.
+> **Note:** ESM only. Requires Node.js 20+.
 
 ## Quick Start
 
@@ -30,107 +36,122 @@ releasekit-version --json | releasekit-notes
 # From a file
 releasekit-notes --input version-data.json
 
-# With LLM enhancement
-releasekit-notes --input version-data.json --llm-provider openai --llm-model gpt-4o-mini
-
 # Preview without writing
 releasekit-notes --dry-run
+
+# With LLM enhancement
+releasekit-notes --input version-data.json \
+  --llm-provider openai \
+  --llm-model gpt-4o-mini \
+  --llm-tasks enhance,summarize
 ```
 
 ## CLI Reference
 
+### `releasekit-notes generate` (default)
+
 | Flag | Description | Default |
 |------|-------------|---------|
 | `-i, --input <file>` | Input file path | stdin |
-| `-o, --output <spec>` | Output spec (`format:file`) | config |
+| `--changelog-mode <mode>` | Changelog location: `root`, `packages`, `both` | `root` |
+| `--changelog-file <name>` | Changelog file name override | `CHANGELOG.md` |
+| `--no-changelog` | Disable changelog generation | — |
+| `--release-notes-mode <mode>` | Enable release notes file output: `root`, `packages`, `both` | — |
+| `--release-notes-file <name>` | Release notes file name override | `RELEASE_NOTES.md` |
+| `--no-release-notes` | Disable release notes generation | — |
 | `-t, --template <path>` | Template file or directory | built-in |
 | `-e, --engine <engine>` | Template engine: `handlebars`, `liquid`, `ejs` | `liquid` |
 | `--monorepo <mode>` | Monorepo mode: `root`, `packages`, `both` | — |
 | `--llm-provider <name>` | LLM provider | — |
 | `--llm-model <model>` | LLM model | — |
-| `--llm-tasks <tasks>` | Comma-separated LLM tasks | — |
-| `--no-llm` | Disable LLM processing | `false` |
+| `--llm-base-url <url>` | Base URL for openai-compatible providers | — |
+| `--llm-tasks <tasks>` | Comma-separated tasks: `enhance`, `summarize`, `categorize`, `release-notes` | — |
+| `--no-llm` | Disable LLM processing | — |
+| `--target <package>` | Filter to a specific package name | — |
 | `--config <path>` | Config file path | `releasekit.config.json` |
+| `--regenerate` | Regenerate entire file instead of prepending | `false` |
 | `--dry-run` | Preview without writing | `false` |
-| `--regenerate` | Regenerate entire changelog | `false` |
-| `-v, --verbose` | Verbose logging | `false` |
-| `-q, --quiet` | Suppress non-error output | `false` |
-
-## Subcommands
-
-### `releasekit-notes init`
-
-Create a default configuration file.
-
-```bash
-releasekit-notes init [--force]
-```
+| `-v, --verbose` | Verbose logging (repeat for more: `-vv`) | — |
+| `-q, --quiet` | Suppress non-error output | — |
 
 ### `releasekit-notes auth <provider>`
 
-Configure API key for an LLM provider.
+Store an API key for an LLM provider.
 
 ```bash
-releasekit-notes auth openai --key sk-...
-releasekit-notes auth anthropic
+releasekit-notes auth openai
+releasekit-notes auth anthropic --key sk-ant-...
 ```
 
+Keys are saved to `~/.config/releasekit/auth.json`.
+
 ### `releasekit-notes providers`
 
 List available LLM providers.
 
 ## Configuration
 
-Configure via `releasekit.config.json`:
+All options live under the `notes` key in `releasekit.config.json`:
 
 ```json
 {
+  "$schema": "https://goosewobbler.github.io/releasekit/schema.json",
   "notes": {
-    "output": [
-      { "format": "markdown", "file": "CHANGELOG.md" }
-    ],
-    "updateStrategy": "prepend",
-    "templates": {
-      "path": "./templates/",
-      "engine": "liquid"
+    "changelog": {
+      "mode": "root",
+      "file": "CHANGELOG.md",
+      "templates": {
+        "path": "./templates/changelog/",
+        "engine": "liquid"
+      }
     },
-    "llm": {
-      "provider": "openai",
-      "model": "gpt-4o-mini",
-      "tasks": {
-        "summarize": true,
-        "enhance": true
+    "releaseNotes": {
+      "mode": "root",
+      "llm": {
+        "provider": "openai",
+        "model": "gpt-4o-mini",
+        "tasks": {
+          "enhance": true,
+          "summarize": true
+        }
       }
-    }
+    },
+    "updateStrategy": "prepend"
   }
 }
 ```
 
+`changelog` and `releaseNotes` are configured independently. Set either to `false` to disable it entirely.
+
 ## LLM Providers
 
-| Provider | Config Key | Notes |
-|----------|------------|-------|
-| OpenAI | `openai` | Requires `OPENAI_API_KEY` |
-| Anthropic | `anthropic` | Requires `ANTHROPIC_API_KEY` |
-| Ollama | `ollama` | Local, no API key needed |
-| OpenAI-Compatible | `openai-compatible` | Any OpenAI-compatible endpoint |
+LLM configuration lives under `notes.releaseNotes.llm`:
+
+| Provider | Key | Auth |
+|----------|-----|------|
+| OpenAI | `openai` | `OPENAI_API_KEY` or `releasekit-notes auth openai` |
+| Anthropic | `anthropic` | `ANTHROPIC_API_KEY` or `releasekit-notes auth anthropic` |
+| Ollama | `ollama` | None (local) |
+| OpenAI-compatible | `openai-compatible` | Varies — set `baseURL` and `apiKey` |
 
 ### LLM Tasks
 
-| Task | Description |
+| Task | What it does |
 |------|-------------|
-| `enhance` | Improve entry descriptions |
-| `summarize` | Create version summary |
-| `categorize` | Group entries by category |
-| `releaseNotes` | Generate release notes |
+| `enhance` | Rewrites each changelog entry description to be clearer |
+| `summarize` | Generates a one-paragraph summary of the release |
+| `categorize` | Groups entries into user-friendly categories (Features, Fixes, …) |
+| `releaseNotes` | Generates full prose release notes (use as GitHub release body) |
 
 ## Templates
 
-### Built-in
+### Built-in Templates
 
-- `keep-a-changelog` — Keep a Changelog format (default)
-- `angular` — Angular-style changelog
-- `github-release` — GitHub release notes
+| Name | Engine | Description |
+|------|--------|-------------|
+| `keep-a-changelog` | Liquid | [Keep a Changelog](https://keepachangelog.com) format (default) |
+| `angular` | Handlebars | Angular-style changelog |
+| `github-release` | EJS | GitHub release notes format |
 
 ### Custom Templates
 
@@ -138,32 +159,37 @@ Configure via `releasekit.config.json`:
 # Single file
 releasekit-notes --template ./my-changelog.liquid
 
-# Composable directory
+# Composable directory (document + version + entry)
 releasekit-notes --template ./templates/
 ```
 
-Composable directory structure:
-
-```
-templates/
-├── document.liquid
-├── version.liquid
-└── entry.liquid
-```
+See **[Templates guide](./docs/templates.md)** for the full template context reference and authoring guide.
 
 ## Monorepo Support
 
 ```bash
 # Root changelog only (aggregates all packages)
-releasekit-notes --monorepo root
+releasekit-notes --changelog-mode root
 
 # Per-package changelogs
-releasekit-notes --monorepo packages
+releasekit-notes --changelog-mode packages
 
-# Both
-releasekit-notes --monorepo both
+# Both root and per-package
+releasekit-notes --changelog-mode both
 ```
 
+See **[Monorepo guide](./docs/monorepo.md)** for details on file placement and aggregation behaviour.
+
+## Documentation
+
+**Getting Started**
+- [Configuration reference](./docs/configuration.md) — all `notes.*` options
+- [LLM providers](./docs/llm-providers.md) — provider setup, auth, tasks, prompt customisation
+
+**Guides**
+- [Templates](./docs/templates.md) — custom template authoring and context reference
+- [Monorepo](./docs/monorepo.md) — per-package and root output modes
+
 ## License
 
 MIT

package/dist/aggregator-IUQUAVJC.js

@@ -0,0 +1,13 @@
+import {
+  aggregateToRoot,
+  detectMonorepo,
+  splitByPackage,
+  writeMonorepoChangelogs
+} from "./chunk-F7MUVHZ2.js";
+import "./chunk-7TJSPQPW.js";
+export {
+  aggregateToRoot,
+  detectMonorepo,
+  splitByPackage,
+  writeMonorepoChangelogs
+};

package/dist/chunk-7TJSPQPW.js

@@ -0,0 +1,243 @@
+// ../core/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+function readPackageVersion(importMetaUrl) {
+  try {
+    const dir = path.dirname(fileURLToPath(importMetaUrl));
+    const packageJsonPath = path.resolve(dir, "../package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var PREFIXES = {
+  error: "[ERROR]",
+  warn: "[WARN]",
+  info: "[INFO]",
+  debug: "[DEBUG]",
+  trace: "[TRACE]"
+};
+var COLORS = {
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.blue,
+  debug: chalk.gray,
+  trace: chalk.dim
+};
+var currentLevel = "info";
+var quietMode = false;
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setQuietMode(quiet) {
+  quietMode = quiet;
+}
+function shouldLog(level) {
+  if (quietMode && level !== "error") return false;
+  return LOG_LEVELS[level] <= LOG_LEVELS[currentLevel];
+}
+function log(message, level = "info") {
+  if (!shouldLog(level)) return;
+  const formatted = COLORS[level](`${PREFIXES[level]} ${message}`);
+  console.error(formatted);
+}
+function error(message) {
+  log(message, "error");
+}
+function warn(message) {
+  log(message, "warn");
+}
+function info(message) {
+  log(message, "info");
+}
+function success(message) {
+  if (!shouldLog("info")) return;
+  console.error(chalk.green(`[SUCCESS] ${message}`));
+}
+function debug(message) {
+  log(message, "debug");
+}
+var ReleaseKitError = class _ReleaseKitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+  logError() {
+    log(this.message, "error");
+    if (this.suggestions.length > 0) {
+      log("\nSuggested solutions:", "info");
+      for (const [i, suggestion] of this.suggestions.entries()) {
+        log(`${i + 1}. ${suggestion}`, "info");
+      }
+    }
+  }
+  static isReleaseKitError(error2) {
+    return error2 instanceof _ReleaseKitError;
+  }
+};
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  CONFIG_ERROR: 2,
+  INPUT_ERROR: 3,
+  TEMPLATE_ERROR: 4,
+  LLM_ERROR: 5,
+  GITHUB_ERROR: 6,
+  GIT_ERROR: 7,
+  VERSION_ERROR: 8,
+  PUBLISH_ERROR: 9
+};
+
+// src/output/markdown.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var TYPE_ORDER = ["added", "changed", "deprecated", "removed", "fixed", "security"];
+var TYPE_LABELS = {
+  added: "Added",
+  changed: "Changed",
+  deprecated: "Deprecated",
+  removed: "Removed",
+  fixed: "Fixed",
+  security: "Security"
+};
+function groupEntriesByType(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const type of TYPE_ORDER) {
+    grouped.set(type, []);
+  }
+  for (const entry of entries) {
+    const existing = grouped.get(entry.type) ?? [];
+    existing.push(entry);
+    grouped.set(entry.type, existing);
+  }
+  return grouped;
+}
+function formatEntry(entry) {
+  let line;
+  if (entry.breaking && entry.scope) {
+    line = `- **BREAKING** **${entry.scope}**: ${entry.description}`;
+  } else if (entry.breaking) {
+    line = `- **BREAKING** ${entry.description}`;
+  } else if (entry.scope) {
+    line = `- **${entry.scope}**: ${entry.description}`;
+  } else {
+    line = `- ${entry.description}`;
+  }
+  if (entry.issueIds && entry.issueIds.length > 0) {
+    line += ` (${entry.issueIds.join(", ")})`;
+  }
+  return line;
+}
+function formatVersion(context, options) {
+  const lines = [];
+  const versionLabel = options?.includePackageName && context.packageName ? `${context.packageName}@${context.version}` : context.version;
+  const versionHeader = context.previousVersion ? `## [${versionLabel}]` : `## ${versionLabel}`;
+  lines.push(`${versionHeader} - ${context.date}`);
+  lines.push("");
+  if (context.compareUrl) {
+    lines.push(`[Full Changelog](${context.compareUrl})`);
+    lines.push("");
+  }
+  if (context.enhanced?.summary) {
+    lines.push(context.enhanced.summary);
+    lines.push("");
+  }
+  const grouped = groupEntriesByType(context.entries);
+  for (const [type, entries] of grouped) {
+    if (entries.length === 0) continue;
+    lines.push(`### ${TYPE_LABELS[type]}`);
+    for (const entry of entries) {
+      lines.push(formatEntry(entry));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatHeader() {
+  return `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+`;
+}
+function renderMarkdown(contexts, options) {
+  const sections = [formatHeader()];
+  for (const context of contexts) {
+    sections.push(formatVersion(context, options));
+  }
+  return sections.join("\n");
+}
+function prependVersion(existingPath, context, options) {
+  let existing = "";
+  if (fs2.existsSync(existingPath)) {
+    existing = fs2.readFileSync(existingPath, "utf-8");
+    const headerEnd = existing.indexOf("\n## ");
+    if (headerEnd >= 0) {
+      const header = existing.slice(0, headerEnd);
+      const body = existing.slice(headerEnd + 1);
+      const newVersion = formatVersion(context, options);
+      return `${header}
+
+${newVersion}
+${body}`;
+    }
+  }
+  return renderMarkdown([context]);
+}
+function writeMarkdown(outputPath, contexts, config, dryRun, options) {
+  const content = renderMarkdown(contexts, options);
+  const label = /changelog/i.test(outputPath) ? "Changelog" : "Release notes";
+  if (dryRun) {
+    info(`[DRY RUN] ${label} preview (would write to ${outputPath}):`);
+    info(content);
+    return;
+  }
+  const dir = path2.dirname(outputPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  if (outputPath === "-") {
+    process.stdout.write(content);
+    return;
+  }
+  if (config.updateStrategy !== "regenerate" && fs2.existsSync(outputPath) && contexts.length === 1) {
+    const firstContext = contexts[0];
+    if (firstContext) {
+      const updated = prependVersion(outputPath, firstContext, options);
+      fs2.writeFileSync(outputPath, updated, "utf-8");
+    }
+  } else {
+    fs2.writeFileSync(outputPath, content, "utf-8");
+  }
+  success(`${label} written to ${outputPath}`);
+}
+
+export {
+  readPackageVersion,
+  setLogLevel,
+  setQuietMode,
+  error,
+  warn,
+  info,
+  success,
+  debug,
+  ReleaseKitError,
+  EXIT_CODES,
+  formatVersion,
+  renderMarkdown,
+  prependVersion,
+  writeMarkdown
+};

package/dist/chunk-F7MUVHZ2.js

@@ -0,0 +1,165 @@
+import {
+  debug,
+  formatVersion,
+  info,
+  prependVersion,
+  renderMarkdown,
+  success
+} from "./chunk-7TJSPQPW.js";
+
+// src/monorepo/aggregator.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/monorepo/splitter.ts
+function splitByPackage(contexts) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    byPackage.set(ctx.packageName, ctx);
+  }
+  return byPackage;
+}
+
+// src/monorepo/aggregator.ts
+function writeFile(outputPath, content, dryRun) {
+  if (dryRun) {
+    info(`Would write to ${outputPath}`);
+    debug(content);
+    return false;
+  }
+  const dir = path.dirname(outputPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(outputPath, content, "utf-8");
+  success(`Changelog written to ${outputPath}`);
+  return true;
+}
+function aggregateToRoot(contexts) {
+  const aggregated = {
+    packageName: "monorepo",
+    version: contexts[0]?.version ?? "0.0.0",
+    previousVersion: contexts[0]?.previousVersion ?? null,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+    repoUrl: contexts[0]?.repoUrl ?? null,
+    entries: []
+  };
+  for (const ctx of contexts) {
+    for (const entry of ctx.entries) {
+      aggregated.entries.push({
+        ...entry,
+        scope: entry.scope ? `${ctx.packageName}/${entry.scope}` : ctx.packageName
+      });
+    }
+  }
+  return aggregated;
+}
+function writeMonorepoChangelogs(contexts, options, config, dryRun) {
+  const files = [];
+  if (options.mode === "root" || options.mode === "both") {
+    const rootPath = path.join(options.rootPath, options.fileName ?? "CHANGELOG.md");
+    const fmtOpts = { includePackageName: true };
+    info(`Writing root changelog to ${rootPath}`);
+    let rootContent;
+    if (config.updateStrategy !== "regenerate" && fs.existsSync(rootPath)) {
+      const newSections = contexts.map((ctx) => formatVersion(ctx, fmtOpts)).join("\n");
+      const existing = fs.readFileSync(rootPath, "utf-8");
+      const headerEnd = existing.indexOf("\n## ");
+      if (headerEnd >= 0) {
+        rootContent = `${existing.slice(0, headerEnd)}
+
+${newSections}
+${existing.slice(headerEnd + 1)}`;
+      } else {
+        rootContent = renderMarkdown(contexts, fmtOpts);
+      }
+    } else {
+      rootContent = renderMarkdown(contexts, fmtOpts);
+    }
+    if (writeFile(rootPath, rootContent, dryRun)) {
+      files.push(rootPath);
+    }
+  }
+  if (options.mode === "packages" || options.mode === "both") {
+    const byPackage = splitByPackage(contexts);
+    const packageDirMap = buildPackageDirMap(options.rootPath, options.packagesPath);
+    for (const [packageName, ctx] of byPackage) {
+      const simpleName = packageName.split("/").pop();
+      const packageDir = packageDirMap.get(packageName) ?? (simpleName ? packageDirMap.get(simpleName) : void 0) ?? null;
+      if (packageDir) {
+        const changelogPath = path.join(packageDir, options.fileName ?? "CHANGELOG.md");
+        info(`Writing changelog for ${packageName} to ${changelogPath}`);
+        const pkgContent = config.updateStrategy !== "regenerate" && fs.existsSync(changelogPath) ? prependVersion(changelogPath, ctx) : renderMarkdown([ctx]);
+        if (writeFile(changelogPath, pkgContent, dryRun)) {
+          files.push(changelogPath);
+        }
+      } else {
+        info(`Could not find directory for package ${packageName}, skipping`);
+      }
+    }
+  }
+  return files;
+}
+function buildPackageDirMap(rootPath, packagesPath) {
+  const map = /* @__PURE__ */ new Map();
+  const packagesDir = path.join(rootPath, packagesPath);
+  if (!fs.existsSync(packagesDir)) {
+    return map;
+  }
+  for (const entry of fs.readdirSync(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dirPath = path.join(packagesDir, entry.name);
+    map.set(entry.name, dirPath);
+    const packageJsonPath = path.join(dirPath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        if (pkg.name) {
+          map.set(pkg.name, dirPath);
+        }
+      } catch {
+      }
+    }
+  }
+  return map;
+}
+function detectMonorepo(cwd) {
+  const pnpmWorkspacesPath = path.join(cwd, "pnpm-workspace.yaml");
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pnpmWorkspacesPath)) {
+    const content = fs.readFileSync(pnpmWorkspacesPath, "utf-8");
+    const packagesMatch = content.match(/packages:\s*\n\s*-\s*['"]([^'"]+)['"]/);
+    if (packagesMatch?.[1]) {
+      const packagesGlob = packagesMatch[1];
+      const packagesPath = packagesGlob.replace(/\/?\*$/, "").replace(/\/\*\*$/, "");
+      return { isMonorepo: true, packagesPath: packagesPath || "packages" };
+    }
+    return { isMonorepo: true, packagesPath: "packages" };
+  }
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const content = fs.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.workspaces) {
+        const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages;
+        if (workspaces?.length) {
+          const firstWorkspace = workspaces[0];
+          if (firstWorkspace) {
+            const packagesPath = firstWorkspace.replace(/\/?\*$/, "").replace(/\/\*\*$/, "");
+            return { isMonorepo: true, packagesPath: packagesPath || "packages" };
+          }
+        }
+      }
+    } catch {
+      return { isMonorepo: false, packagesPath: "" };
+    }
+  }
+  return { isMonorepo: false, packagesPath: "" };
+}
+
+export {
+  splitByPackage,
+  aggregateToRoot,
+  writeMonorepoChangelogs,
+  detectMonorepo
+};