@releasekit/notes 0.1.0 → 0.2.0-next.0

package/dist/chunk-XRLAWPB3.js

@@ -1,1410 +0,0 @@
-// src/core/config.ts
-import {
-  loadAuth,
-  loadNotesConfig as loadSharedNotesConfig,
-  saveAuth
-} from "@releasekit/config";
-function loadConfig(projectDir = process.cwd(), configFile) {
-  const options = { cwd: projectDir, configPath: configFile };
-  return loadSharedNotesConfig(options) ?? getDefaultConfig();
-}
-function getDefaultConfig() {
-  return {
-    output: [{ format: "markdown", file: "CHANGELOG.md" }],
-    updateStrategy: "prepend"
-  };
-}
-
-// 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 {
-  code = "INPUT_PARSE_ERROR";
-  suggestions = [
-    "Ensure input is valid JSON",
-    "Check that input matches expected schema",
-    "Use --input-source to specify format"
-  ];
-};
-var TemplateError = class extends NotesError {
-  code = "TEMPLATE_ERROR";
-  suggestions = [
-    "Check template syntax",
-    "Ensure all required files exist (document, version, entry)",
-    "Verify template engine matches file extension"
-  ];
-};
-var LLMError = class extends NotesError {
-  code = "LLM_ERROR";
-  suggestions = [
-    "Check API key is configured",
-    "Verify model name is correct",
-    "Check network connectivity",
-    "Try with --no-llm to skip LLM processing"
-  ];
-};
-var GitHubError = class extends NotesError {
-  code = "GITHUB_ERROR";
-  suggestions = [
-    "Ensure GITHUB_TOKEN is set",
-    "Check token has repo scope",
-    "Verify repository exists and is accessible"
-  ];
-};
-var ConfigError = class extends NotesError {
-  code = "CONFIG_ERROR";
-  suggestions = [
-    "Check config file syntax",
-    "Verify all required fields are present",
-    "Run releasekit-notes init to create default config"
-  ];
-};
-function getExitCode(error) {
-  switch (error.code) {
-    case "CONFIG_ERROR":
-      return EXIT_CODES.CONFIG_ERROR;
-    case "INPUT_PARSE_ERROR":
-      return EXIT_CODES.INPUT_ERROR;
-    case "TEMPLATE_ERROR":
-      return EXIT_CODES.TEMPLATE_ERROR;
-    case "LLM_ERROR":
-      return EXIT_CODES.LLM_ERROR;
-    case "GITHUB_ERROR":
-      return EXIT_CODES.GITHUB_ERROR;
-    default:
-      return EXIT_CODES.GENERAL_ERROR;
-  }
-}
-
-// src/input/package-versioner.ts
-import * as fs from "fs";
-function normalizeEntryType(type) {
-  const typeMap = {
-    added: "added",
-    feat: "added",
-    feature: "added",
-    changed: "changed",
-    update: "changed",
-    refactor: "changed",
-    deprecated: "deprecated",
-    removed: "removed",
-    fixed: "fixed",
-    fix: "fixed",
-    security: "security",
-    sec: "security"
-  };
-  return typeMap[type.toLowerCase()] ?? "changed";
-}
-function parsePackageVersioner(json) {
-  let data;
-  try {
-    data = JSON.parse(json);
-  } catch (error) {
-    throw new InputParseError(`Invalid JSON input: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!data.changelogs || !Array.isArray(data.changelogs)) {
-    throw new InputParseError('Input must contain a "changelogs" array');
-  }
-  const packages = data.changelogs.map((changelog) => ({
-    packageName: changelog.packageName,
-    version: changelog.version,
-    previousVersion: changelog.previousVersion,
-    revisionRange: changelog.revisionRange,
-    repoUrl: changelog.repoUrl,
-    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
-    entries: changelog.entries.map((entry) => ({
-      type: normalizeEntryType(entry.type),
-      description: entry.description,
-      issueIds: entry.issueIds,
-      scope: entry.scope,
-      originalType: entry.originalType,
-      breaking: entry.originalType?.includes("!")
-    }))
-  }));
-  const repoUrl = packages[0]?.repoUrl ?? null;
-  return {
-    source: "package-versioner",
-    packages,
-    metadata: {
-      repoUrl: repoUrl ?? void 0
-    }
-  };
-}
-function parsePackageVersionerFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf-8");
-  return parsePackageVersioner(content);
-}
-async function parsePackageVersionerStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  const content = chunks.join("");
-  return parsePackageVersioner(content);
-}
-
-// src/output/markdown.ts
-import * as fs2 from "fs";
-import * as path from "path";
-import { info, success } from "@releasekit/core";
-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) {
-  const lines = [];
-  const versionHeader = context.previousVersion ? `## [${context.version}]` : `## ${context.version}`;
-  lines.push(`${versionHeader} - ${context.date}`);
-  lines.push("");
-  if (context.compareUrl) {
-    lines.push(`[Full Changelog](${context.compareUrl})`);
-    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) {
-  const sections = [formatHeader()];
-  for (const context of contexts) {
-    sections.push(formatVersion(context));
-  }
-  return sections.join("\n");
-}
-function prependVersion(existingPath, context) {
-  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);
-      return `${header}
-
-${newVersion}
-${body}`;
-    }
-  }
-  return renderMarkdown([context]);
-}
-function writeMarkdown(outputPath, contexts, config, dryRun) {
-  const content = renderMarkdown(contexts);
-  if (dryRun) {
-    info("--- Changelog Preview ---");
-    console.log(content);
-    info("--- End Preview ---");
-    return;
-  }
-  const dir = path.dirname(outputPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  if (config.updateStrategy === "prepend" && fs2.existsSync(outputPath) && contexts.length === 1) {
-    const firstContext = contexts[0];
-    if (firstContext) {
-      const updated = prependVersion(outputPath, firstContext);
-      fs2.writeFileSync(outputPath, updated, "utf-8");
-    }
-  } else {
-    fs2.writeFileSync(outputPath, content, "utf-8");
-  }
-  success(`Changelog written to ${outputPath}`);
-}
-
-// src/output/json.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { info as info2, success as success2 } from "@releasekit/core";
-function renderJson(contexts) {
-  return JSON.stringify(
-    {
-      versions: contexts.map((ctx) => ({
-        packageName: ctx.packageName,
-        version: ctx.version,
-        previousVersion: ctx.previousVersion,
-        date: ctx.date,
-        entries: ctx.entries,
-        compareUrl: ctx.compareUrl
-      }))
-    },
-    null,
-    2
-  );
-}
-function writeJson(outputPath, contexts, dryRun) {
-  const content = renderJson(contexts);
-  if (dryRun) {
-    info2("--- JSON Output Preview ---");
-    console.log(content);
-    info2("--- End Preview ---");
-    return;
-  }
-  const dir = path2.dirname(outputPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  fs3.writeFileSync(outputPath, content, "utf-8");
-  success2(`JSON output written to ${outputPath}`);
-}
-
-// 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";
-
-// src/llm/defaults.ts
-var LLM_DEFAULTS = {
-  timeout: 6e4,
-  maxTokens: 2e3,
-  temperature: 0.7,
-  concurrency: 5,
-  retry: {
-    maxAttempts: 3,
-    initialDelay: 1e3,
-    maxDelay: 3e4,
-    backoffFactor: 2
-  },
-  models: {
-    openai: "gpt-4o-mini",
-    "openai-compatible": "gpt-4o-mini",
-    anthropic: "claude-3-5-haiku-latest",
-    ollama: "llama3.2"
-  }
-};
-
-// src/llm/anthropic.ts
-import Anthropic from "@anthropic-ai/sdk";
-
-// src/llm/base.ts
-var BaseLLMProvider = class {
-  getTimeout(options) {
-    return options?.timeout ?? LLM_DEFAULTS.timeout;
-  }
-  getMaxTokens(options) {
-    return options?.maxTokens ?? LLM_DEFAULTS.maxTokens;
-  }
-  getTemperature(options) {
-    return options?.temperature ?? LLM_DEFAULTS.temperature;
-  }
-};
-
-// src/llm/anthropic.ts
-var AnthropicProvider = class extends BaseLLMProvider {
-  name = "anthropic";
-  client;
-  model;
-  constructor(config = {}) {
-    super();
-    const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-      throw new LLMError("Anthropic API key not configured. Set ANTHROPIC_API_KEY or use --llm-api-key");
-    }
-    this.client = new Anthropic({ apiKey });
-    this.model = config.model ?? LLM_DEFAULTS.models.anthropic;
-  }
-  async complete(prompt, options) {
-    try {
-      const response = await this.client.messages.create({
-        model: this.model,
-        max_tokens: this.getMaxTokens(options),
-        messages: [{ role: "user", content: prompt }]
-      });
-      const firstBlock = response.content[0];
-      if (!firstBlock || firstBlock.type !== "text") {
-        throw new LLMError("Unexpected response format from Anthropic");
-      }
-      return firstBlock.text;
-    } catch (error) {
-      if (error instanceof LLMError) throw error;
-      throw new LLMError(`Anthropic API error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-};
-
-// src/llm/ollama.ts
-var OllamaProvider = class extends BaseLLMProvider {
-  name = "ollama";
-  baseURL;
-  model;
-  constructor(config = {}) {
-    super();
-    this.baseURL = config.baseURL ?? process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
-    this.model = config.model ?? LLM_DEFAULTS.models.ollama;
-  }
-  async complete(prompt, options) {
-    const requestBody = {
-      model: this.model,
-      prompt,
-      stream: false,
-      options: {
-        num_predict: this.getMaxTokens(options),
-        temperature: this.getTemperature(options)
-      }
-    };
-    try {
-      const response = await fetch(`${this.baseURL}/api/generate`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody)
-      });
-      if (!response.ok) {
-        const text = await response.text();
-        throw new LLMError(`Ollama request failed: ${response.status} ${text}`);
-      }
-      const data = await response.json();
-      if (!data.response) {
-        throw new LLMError("Empty response from Ollama");
-      }
-      return data.response;
-    } catch (error) {
-      if (error instanceof LLMError) throw error;
-      throw new LLMError(`Ollama error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-};
-
-// src/llm/openai.ts
-import OpenAI from "openai";
-var OpenAIProvider = class extends BaseLLMProvider {
-  name = "openai";
-  client;
-  model;
-  constructor(config = {}) {
-    super();
-    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new LLMError("OpenAI API key not configured. Set OPENAI_API_KEY or use --llm-api-key");
-    }
-    this.client = new OpenAI({
-      apiKey,
-      baseURL: config.baseURL
-    });
-    this.model = config.model ?? LLM_DEFAULTS.models.openai;
-  }
-  async complete(prompt, options) {
-    try {
-      const response = await this.client.chat.completions.create({
-        model: this.model,
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: this.getMaxTokens(options),
-        temperature: this.getTemperature(options)
-      });
-      const content = response.choices[0]?.message?.content;
-      if (!content) {
-        throw new LLMError("Empty response from OpenAI");
-      }
-      return content;
-    } catch (error) {
-      if (error instanceof LLMError) throw error;
-      throw new LLMError(`OpenAI API error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-};
-
-// src/llm/openai-compatible.ts
-import OpenAI2 from "openai";
-var OpenAICompatibleProvider = class extends BaseLLMProvider {
-  name = "openai-compatible";
-  client;
-  model;
-  constructor(config) {
-    super();
-    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY ?? "dummy";
-    this.client = new OpenAI2({
-      apiKey,
-      baseURL: config.baseURL
-    });
-    this.model = config.model ?? LLM_DEFAULTS.models["openai-compatible"];
-  }
-  async complete(prompt, options) {
-    try {
-      const response = await this.client.chat.completions.create({
-        model: this.model,
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: this.getMaxTokens(options),
-        temperature: this.getTemperature(options)
-      });
-      const content = response.choices[0]?.message?.content;
-      if (!content) {
-        throw new LLMError("Empty response from LLM");
-      }
-      return content;
-    } catch (error) {
-      if (error instanceof LLMError) throw error;
-      throw new LLMError(`LLM API error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-};
-
-// src/llm/tasks/categorize.ts
-import { warn } from "@releasekit/core";
-var 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").
-
-Output a JSON object where keys are category names and values are arrays of entry indices (0-based).
-
-Entries:
-{{entries}}
-
-Output only valid JSON, nothing else:`;
-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 prompt = CATEGORIZE_PROMPT.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 result = [];
-    for (const [category, indices] of Object.entries(parsed)) {
-      const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
-      if (categoryEntries.length > 0) {
-        result.push({
-          category,
-          entries: categoryEntries
-        });
-      }
-    }
-    return result;
-  } catch (error) {
-    warn(
-      `LLM categorization failed, falling back to General: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return [{ category: "General", entries }];
-  }
-}
-
-// src/llm/tasks/enhance.ts
-var 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:
-- Be concise (1-2 sentences max)
-- Use present tense ("Add feature" not "Added feature")
-- Focus on user impact, not implementation details
-- Don't use technical jargon unless necessary
-- Preserve the scope if mentioned (e.g., "core:", "api:")
-
-Original entry:
-Type: {{type}}
-{{#if scope}}Scope: {{scope}}{{/if}}
-Description: {{description}}
-
-Rewritten description (only output the new description, nothing else):`;
-async function enhanceEntry(provider, entry, _context) {
-  const prompt = ENHANCE_PROMPT.replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
-  const response = await provider.complete(prompt);
-  return response.trim();
-}
-async function enhanceEntries(provider, entries, context, concurrency = LLM_DEFAULTS.concurrency) {
-  const results = [];
-  for (let i = 0; i < entries.length; i += concurrency) {
-    const batch = entries.slice(i, i + concurrency);
-    const batchResults = await Promise.all(
-      batch.map(async (entry) => {
-        try {
-          const newDescription = await enhanceEntry(provider, entry, context);
-          return { ...entry, description: newDescription };
-        } catch {
-          return entry;
-        }
-      })
-    );
-    results.push(...batchResults);
-  }
-  return results;
-}
-
-// src/llm/tasks/release-notes.ts
-var RELEASE_NOTES_PROMPT = `You are writing release notes for a software project.
-
-Create engaging, user-friendly release notes for the following changes.
-
-Rules:
-- Start with a brief introduction (1-2 sentences)
-- Group related changes into sections
-- Use friendly, approachable language
-- Highlight breaking changes prominently
-- End with a brief conclusion or call to action
-- Use markdown formatting
-
-Version: {{version}}
-{{#if previousVersion}}Previous version: {{previousVersion}}{{/if}}
-Date: {{date}}
-
-Changes:
-{{entries}}
-
-Release notes (output only the markdown content):`;
-async function generateReleaseNotes(provider, entries, context) {
-  if (entries.length === 0) {
-    return `## Release ${context.version ?? "v1.0.0"}
-
-No notable changes in this release.`;
-  }
-  const entriesText = entries.map((e) => {
-    let line = `- [${e.type}]`;
-    if (e.scope) line += ` (${e.scope})`;
-    line += `: ${e.description}`;
-    if (e.breaking) line += " **BREAKING**";
-    return line;
-  }).join("\n");
-  const prompt = 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 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.
-
-Given the following changelog entries, create a brief summary (2-3 sentences) that captures the main themes of this release.
-
-Entries:
-{{entries}}
-
-Summary (only output the summary, nothing else):`;
-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 response = await provider.complete(prompt);
-  return response.trim();
-}
-
-// src/llm/index.ts
-function createProvider(config) {
-  const authKeys = loadAuth();
-  const apiKey = config.apiKey ?? authKeys[config.provider];
-  switch (config.provider) {
-    case "openai":
-      return new OpenAIProvider({
-        apiKey,
-        baseURL: config.baseURL,
-        model: config.model
-      });
-    case "anthropic":
-      return new AnthropicProvider({
-        apiKey,
-        model: config.model
-      });
-    case "ollama":
-      return new OllamaProvider({
-        baseURL: config.baseURL,
-        model: config.model
-      });
-    case "openai-compatible": {
-      if (!config.baseURL) {
-        throw new LLMError("openai-compatible provider requires baseURL");
-      }
-      return new OpenAICompatibleProvider({
-        apiKey,
-        baseURL: config.baseURL,
-        model: config.model
-      });
-    }
-    default:
-      throw new LLMError(`Unknown LLM provider: ${config.provider}`);
-  }
-}
-
-// src/output/github-release.ts
-import { Octokit } from "@octokit/rest";
-import { info as info3, success as success3 } from "@releasekit/core";
-var GitHubClient = class {
-  octokit;
-  owner;
-  repo;
-  constructor(options) {
-    const token = options.token ?? process.env.GITHUB_TOKEN;
-    if (!token) {
-      throw new GitHubError("GITHUB_TOKEN not set. Set it as an environment variable.");
-    }
-    this.octokit = new Octokit({ auth: token });
-    this.owner = options.owner;
-    this.repo = options.repo;
-  }
-  async createRelease(context, options = {}) {
-    const tagName = `v${context.version}`;
-    let body;
-    if (context.enhanced?.releaseNotes) {
-      body = context.enhanced.releaseNotes;
-    } else {
-      body = renderMarkdown([context]);
-    }
-    info3(`Creating GitHub release for ${tagName}`);
-    try {
-      const response = await this.octokit.repos.createRelease({
-        owner: this.owner,
-        repo: this.repo,
-        tag_name: tagName,
-        name: tagName,
-        body,
-        draft: options.draft ?? false,
-        prerelease: options.prerelease ?? false,
-        generate_release_notes: options.generateNotes ?? false
-      });
-      success3(`Release created: ${response.data.html_url}`);
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName
-      };
-    } catch (error) {
-      throw new GitHubError(`Failed to create release: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async updateRelease(releaseId, context, options = {}) {
-    const tagName = `v${context.version}`;
-    let body;
-    if (context.enhanced?.releaseNotes) {
-      body = context.enhanced.releaseNotes;
-    } else {
-      body = renderMarkdown([context]);
-    }
-    info3(`Updating GitHub release ${releaseId}`);
-    try {
-      const response = await this.octokit.repos.updateRelease({
-        owner: this.owner,
-        repo: this.repo,
-        release_id: releaseId,
-        tag_name: tagName,
-        name: tagName,
-        body,
-        draft: options.draft ?? false,
-        prerelease: options.prerelease ?? false
-      });
-      success3(`Release updated: ${response.data.html_url}`);
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName
-      };
-    } catch (error) {
-      throw new GitHubError(`Failed to update release: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async getReleaseByTag(tag) {
-    try {
-      const response = await this.octokit.repos.getReleaseByTag({
-        owner: this.owner,
-        repo: this.repo,
-        tag
-      });
-      return {
-        id: response.data.id,
-        htmlUrl: response.data.html_url,
-        tagName: response.data.tag_name
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-function parseRepoUrl(repoUrl) {
-  const patterns = [
-    /^https:\/\/github\.com\/([^/]+)\/([^/]+)/,
-    /^git@github\.com:([^/]+)\/([^/]+)/,
-    /^github\.com\/([^/]+)\/([^/]+)/
-  ];
-  for (const pattern of patterns) {
-    const match = repoUrl.match(pattern);
-    if (match?.[1] && match[2]) {
-      return {
-        owner: match[1],
-        repo: match[2].replace(/\.git$/, "")
-      };
-    }
-  }
-  return null;
-}
-async function createGitHubRelease(context, options) {
-  const client = new GitHubClient(options);
-  return client.createRelease(context, options);
-}
-
-// src/templates/ejs.ts
-import * as fs4 from "fs";
-import ejs from "ejs";
-function renderEjs(template, context) {
-  try {
-    return ejs.render(template, context);
-  } catch (error) {
-    throw new TemplateError(`EJS render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function renderEjsFile(filePath, context) {
-  if (!fs4.existsSync(filePath)) {
-    throw new TemplateError(`Template file not found: ${filePath}`);
-  }
-  const template = fs4.readFileSync(filePath, "utf-8");
-  return renderEjs(template, context);
-}
-
-// src/templates/handlebars.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
-import Handlebars from "handlebars";
-function registerHandlebarsHelpers() {
-  Handlebars.registerHelper("capitalize", (str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  Handlebars.registerHelper("eq", (a, b) => {
-    return a === b;
-  });
-  Handlebars.registerHelper("ne", (a, b) => {
-    return a !== b;
-  });
-  Handlebars.registerHelper("join", (arr, separator) => {
-    return Array.isArray(arr) ? arr.join(separator) : "";
-  });
-}
-function renderHandlebars(template, context) {
-  registerHandlebarsHelpers();
-  try {
-    const compiled = Handlebars.compile(template);
-    return compiled(context);
-  } catch (error) {
-    throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function renderHandlebarsFile(filePath, context) {
-  if (!fs5.existsSync(filePath)) {
-    throw new TemplateError(`Template file not found: ${filePath}`);
-  }
-  const template = fs5.readFileSync(filePath, "utf-8");
-  return renderHandlebars(template, context);
-}
-function renderHandlebarsComposable(templateDir, context) {
-  registerHandlebarsHelpers();
-  const versionPath = path3.join(templateDir, "version.hbs");
-  const entryPath = path3.join(templateDir, "entry.hbs");
-  const documentPath = path3.join(templateDir, "document.hbs");
-  if (!fs5.existsSync(documentPath)) {
-    throw new TemplateError(`Document template not found: ${documentPath}`);
-  }
-  if (fs5.existsSync(versionPath)) {
-    Handlebars.registerPartial("version", fs5.readFileSync(versionPath, "utf-8"));
-  }
-  if (fs5.existsSync(entryPath)) {
-    Handlebars.registerPartial("entry", fs5.readFileSync(entryPath, "utf-8"));
-  }
-  try {
-    const compiled = Handlebars.compile(fs5.readFileSync(documentPath, "utf-8"));
-    return compiled(context);
-  } catch (error) {
-    throw new TemplateError(`Handlebars render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-// src/templates/liquid.ts
-import * as fs6 from "fs";
-import * as path4 from "path";
-import { Liquid } from "liquidjs";
-function createLiquidEngine(root) {
-  return new Liquid({
-    root: root ? [root] : [],
-    extname: ".liquid",
-    cache: false
-  });
-}
-function renderLiquid(template, context) {
-  const engine = createLiquidEngine();
-  try {
-    return engine.renderSync(engine.parse(template), context);
-  } catch (error) {
-    throw new TemplateError(`Liquid render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function renderLiquidFile(filePath, context) {
-  if (!fs6.existsSync(filePath)) {
-    throw new TemplateError(`Template file not found: ${filePath}`);
-  }
-  const template = fs6.readFileSync(filePath, "utf-8");
-  return renderLiquid(template, context);
-}
-function renderLiquidComposable(templateDir, context) {
-  const documentPath = path4.join(templateDir, "document.liquid");
-  if (!fs6.existsSync(documentPath)) {
-    throw new TemplateError(`Document template not found: ${documentPath}`);
-  }
-  const engine = createLiquidEngine(templateDir);
-  try {
-    return engine.renderFileSync("document", context);
-  } catch (error) {
-    throw new TemplateError(`Liquid render error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-// src/templates/loader.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
-function getEngineFromFile(filePath) {
-  const ext = path5.extname(filePath).toLowerCase();
-  switch (ext) {
-    case ".liquid":
-      return "liquid";
-    case ".hbs":
-    case ".handlebars":
-      return "handlebars";
-    case ".ejs":
-      return "ejs";
-    default:
-      throw new TemplateError(`Unknown template extension: ${ext}`);
-  }
-}
-function getRenderFn(engine) {
-  switch (engine) {
-    case "liquid":
-      return renderLiquid;
-    case "handlebars":
-      return renderHandlebars;
-    case "ejs":
-      return renderEjs;
-  }
-}
-function getRenderFileFn(engine) {
-  switch (engine) {
-    case "liquid":
-      return renderLiquidFile;
-    case "handlebars":
-      return renderHandlebarsFile;
-    case "ejs":
-      return renderEjsFile;
-  }
-}
-function detectTemplateMode(templatePath) {
-  if (!fs7.existsSync(templatePath)) {
-    throw new TemplateError(`Template path not found: ${templatePath}`);
-  }
-  const stat = fs7.statSync(templatePath);
-  if (stat.isFile()) {
-    return "single";
-  }
-  if (stat.isDirectory()) {
-    return "composable";
-  }
-  throw new TemplateError(`Invalid template path: ${templatePath}`);
-}
-function renderSingleFile(templatePath, context, engine) {
-  const resolvedEngine = engine ?? getEngineFromFile(templatePath);
-  const renderFile = getRenderFileFn(resolvedEngine);
-  return {
-    content: renderFile(templatePath, context),
-    engine: resolvedEngine
-  };
-}
-function renderComposable(templateDir, context, engine) {
-  const files = fs7.readdirSync(templateDir);
-  const engineMap = {
-    liquid: { document: "document.liquid", version: "version.liquid", entry: "entry.liquid" },
-    handlebars: { document: "document.hbs", version: "version.hbs", entry: "entry.hbs" },
-    ejs: { document: "document.ejs", version: "version.ejs", entry: "entry.ejs" }
-  };
-  let resolvedEngine;
-  if (engine) {
-    resolvedEngine = engine;
-  } else {
-    const detected = detectEngineFromFiles(templateDir, files);
-    if (!detected) {
-      throw new TemplateError(`Could not detect template engine. Found files: ${files.join(", ")}`);
-    }
-    resolvedEngine = detected;
-  }
-  if (resolvedEngine === "liquid") {
-    return { content: renderLiquidComposable(templateDir, context), engine: resolvedEngine };
-  }
-  if (resolvedEngine === "handlebars") {
-    return { content: renderHandlebarsComposable(templateDir, context), engine: resolvedEngine };
-  }
-  const expectedFiles = engineMap[resolvedEngine];
-  const documentPath = path5.join(templateDir, expectedFiles.document);
-  if (!fs7.existsSync(documentPath)) {
-    throw new TemplateError(`Document template not found: ${expectedFiles.document}`);
-  }
-  const versionPath = path5.join(templateDir, expectedFiles.version);
-  const entryPath = path5.join(templateDir, expectedFiles.entry);
-  const render = getRenderFn(resolvedEngine);
-  const entryTemplate = fs7.existsSync(entryPath) ? fs7.readFileSync(entryPath, "utf-8") : null;
-  const versionTemplate = fs7.existsSync(versionPath) ? fs7.readFileSync(versionPath, "utf-8") : null;
-  if (entryTemplate && versionTemplate) {
-    const versionsWithEntries = context.versions.map((versionCtx) => {
-      const entries = versionCtx.entries.map((entry) => {
-        const entryCtx = { ...entry, packageName: versionCtx.packageName, version: versionCtx.version };
-        return render(entryTemplate, entryCtx);
-      });
-      return render(versionTemplate, { ...versionCtx, renderedEntries: entries });
-    });
-    const docContext = { ...context, renderedVersions: versionsWithEntries };
-    return {
-      content: render(fs7.readFileSync(documentPath, "utf-8"), docContext),
-      engine: resolvedEngine
-    };
-  }
-  return renderSingleFile(documentPath, context, resolvedEngine);
-}
-function detectEngineFromFiles(_dir, files) {
-  if (files.some((f) => f.endsWith(".liquid"))) return "liquid";
-  if (files.some((f) => f.endsWith(".hbs") || f.endsWith(".handlebars"))) return "handlebars";
-  if (files.some((f) => f.endsWith(".ejs"))) return "ejs";
-  return null;
-}
-function validateDocumentContext(context, templatePath) {
-  if (!context.project?.name) {
-    throw new TemplateError(`${templatePath}: DocumentContext missing required field "project.name"`);
-  }
-  if (!Array.isArray(context.versions)) {
-    throw new TemplateError(`${templatePath}: DocumentContext missing required field "versions" (must be an array)`);
-  }
-  const requiredVersionFields = ["packageName", "version", "date", "entries"];
-  for (const [i, v] of context.versions.entries()) {
-    for (const field of requiredVersionFields) {
-      if (v[field] === void 0 || v[field] === null) {
-        throw new TemplateError(`${templatePath}: versions[${i}] missing required field "${field}"`);
-      }
-    }
-    if (!Array.isArray(v.entries)) {
-      throw new TemplateError(`${templatePath}: versions[${i}].entries must be an array`);
-    }
-  }
-}
-function renderTemplate(templatePath, context, engine) {
-  validateDocumentContext(context, templatePath);
-  const mode = detectTemplateMode(templatePath);
-  if (mode === "single") {
-    return renderSingleFile(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)) {
-    return `${repoUrl}/-/compare/${from}...${to}`;
-  }
-  if (/bitbucket\.org/i.test(repoUrl)) {
-    return `${repoUrl}/branches/compare/${from}..${to}`;
-  }
-  return `${repoUrl}/compare/${from}...${to}`;
-}
-function createTemplateContext(pkg) {
-  const compareUrl = pkg.repoUrl && pkg.previousVersion ? generateCompareUrl(pkg.repoUrl, pkg.previousVersion, pkg.version) : void 0;
-  return {
-    packageName: pkg.packageName,
-    version: pkg.version,
-    previousVersion: pkg.previousVersion,
-    date: pkg.date,
-    repoUrl: pkg.repoUrl,
-    entries: pkg.entries,
-    compareUrl
-  };
-}
-function createDocumentContext(contexts, repoUrl) {
-  const compareUrls = {};
-  for (const ctx of contexts) {
-    if (ctx.compareUrl) {
-      compareUrls[ctx.version] = ctx.compareUrl;
-    }
-  }
-  return {
-    project: {
-      name: contexts[0]?.packageName ?? "project",
-      repoUrl
-    },
-    versions: contexts,
-    compareUrls: Object.keys(compareUrls).length > 0 ? compareUrls : void 0
-  };
-}
-async function processWithLLM(context, config) {
-  if (!config.llm) {
-    return context;
-  }
-  const tasks = config.llm.tasks ?? {};
-  const llmContext = {
-    packageName: context.packageName,
-    version: context.version,
-    previousVersion: context.previousVersion ?? void 0,
-    date: context.date
-  };
-  const enhanced = {
-    entries: context.entries
-  };
-  try {
-    const rawProvider = createProvider(config.llm);
-    const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
-    const provider = {
-      name: rawProvider.name,
-      complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, opts), retryOpts)
-    };
-    if (tasks.enhance) {
-      debug("Enhancing entries with LLM");
-      enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
-    }
-    if (tasks.summarize) {
-      debug("Summarizing entries with LLM");
-      enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
-    }
-    if (tasks.categorize) {
-      debug("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;
-      }
-    }
-    if (tasks.releaseNotes) {
-      debug("Generating release notes with LLM");
-      enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
-    }
-    return {
-      ...context,
-      entries: enhanced.entries,
-      enhanced
-    };
-  } catch (error) {
-    warn2(`LLM processing failed: ${error instanceof Error ? error.message : String(error)}`);
-    warn2("Falling back to raw entries");
-    return context;
-  }
-}
-function getBuiltinTemplatePath(style) {
-  let packageRoot;
-  try {
-    const currentUrl = import.meta.url;
-    packageRoot = path6.dirname(new URL(currentUrl).pathname);
-    packageRoot = path6.join(packageRoot, "..", "..");
-  } catch {
-    packageRoot = __dirname;
-  }
-  return path6.join(packageRoot, "templates", style);
-}
-async function generateWithTemplate(contexts, config, outputPath, dryRun) {
-  let templatePath;
-  if (config.templates?.path) {
-    templatePath = path6.resolve(config.templates.path);
-  } else {
-    templatePath = getBuiltinTemplatePath("keep-a-changelog");
-  }
-  const documentContext = createDocumentContext(
-    contexts,
-    config.templates?.path ? void 0 : contexts[0]?.repoUrl ?? void 0
-  );
-  const result = renderTemplate(templatePath, documentContext, config.templates?.engine);
-  if (dryRun) {
-    info4("--- Changelog Preview ---");
-    console.log(result.content);
-    info4("--- End Preview ---");
-    return;
-  }
-  const dir = path6.dirname(outputPath);
-  if (!fs8.existsSync(dir)) {
-    fs8.mkdirSync(dir, { recursive: true });
-  }
-  fs8.writeFileSync(outputPath, result.content, "utf-8");
-  success4(`Changelog written to ${outputPath} (using ${result.engine} template)`);
-}
-async function runPipeline(input, config, dryRun) {
-  debug(`Processing ${input.packages.length} package(s)`);
-  let contexts = input.packages.map(createTemplateContext);
-  if (config.llm && !process.env.CHANGELOG_NO_LLM && !dryRun) {
-    info4("Processing with LLM enhancement");
-    contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
-  } else if (config.llm && dryRun) {
-    info4("Skipping LLM processing in dry-run mode");
-  }
-  for (const output of config.output) {
-    info4(`Generating ${output.format} output`);
-    switch (output.format) {
-      case "markdown": {
-        const file = output.file ?? "CHANGELOG.md";
-        if (config.templates?.path || output.options?.template) {
-          await generateWithTemplate(contexts, config, file, dryRun);
-        } else {
-          writeMarkdown(file, contexts, config, dryRun);
-        }
-        break;
-      }
-      case "json": {
-        const file = output.file ?? "changelog.json";
-        writeJson(file, contexts, dryRun);
-        break;
-      }
-      case "github-release": {
-        if (dryRun) {
-          info4("[DRY RUN] Would create GitHub release");
-          break;
-        }
-        const firstContext = contexts[0];
-        if (!firstContext) {
-          warn2("No context available for GitHub release");
-          break;
-        }
-        const repoUrl = firstContext.repoUrl;
-        if (!repoUrl) {
-          warn2("No repo URL available, cannot create GitHub release");
-          break;
-        }
-        const parsed = parseRepoUrl(repoUrl);
-        if (!parsed) {
-          warn2(`Could not parse repo URL: ${repoUrl}`);
-          break;
-        }
-        await createGitHubRelease(firstContext, {
-          owner: parsed.owner,
-          repo: parsed.repo,
-          draft: output.options?.draft,
-          prerelease: output.options?.prerelease
-        });
-        break;
-      }
-    }
-  }
-}
-async function processInput(inputJson, config, dryRun) {
-  const input = parsePackageVersioner(inputJson);
-  await runPipeline(input, 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";
-
-// 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) {
-    info5(`[DRY RUN] Would write to ${outputPath}`);
-    console.log(content);
-    return;
-  }
-  const dir = path7.dirname(outputPath);
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
-  }
-  fs9.writeFileSync(outputPath, content, "utf-8");
-  success5(`Changelog written to ${outputPath}`);
-}
-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) {
-  if (options.mode === "root" || options.mode === "both") {
-    const aggregated = aggregateToRoot(contexts);
-    const rootPath = path7.join(options.rootPath, "CHANGELOG.md");
-    info5(`Writing root changelog to ${rootPath}`);
-    const rootContent = config.updateStrategy === "prepend" && fs9.existsSync(rootPath) ? prependVersion(rootPath, aggregated) : renderMarkdown([aggregated]);
-    writeFile(rootPath, rootContent, dryRun);
-  }
-  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 = path7.join(packageDir, "CHANGELOG.md");
-        info5(`Writing changelog for ${packageName} to ${changelogPath}`);
-        const pkgContent = config.updateStrategy === "prepend" && fs9.existsSync(changelogPath) ? prependVersion(changelogPath, ctx) : renderMarkdown([ctx]);
-        writeFile(changelogPath, pkgContent, dryRun);
-      } else {
-        info5(`Could not find directory for package ${packageName}, skipping`);
-      }
-    }
-  }
-}
-function buildPackageDirMap(rootPath, packagesPath) {
-  const map = /* @__PURE__ */ new Map();
-  const packagesDir = path7.join(rootPath, packagesPath);
-  if (!fs9.existsSync(packagesDir)) {
-    return map;
-  }
-  for (const entry of fs9.readdirSync(packagesDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const dirPath = path7.join(packagesDir, entry.name);
-    map.set(entry.name, dirPath);
-    const packageJsonPath = path7.join(dirPath, "package.json");
-    if (fs9.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
-        if (pkg.name) {
-          map.set(pkg.name, dirPath);
-        }
-      } catch {
-      }
-    }
-  }
-  return map;
-}
-function detectMonorepo(cwd) {
-  const pnpmWorkspacesPath = path7.join(cwd, "pnpm-workspace.yaml");
-  const packageJsonPath = path7.join(cwd, "package.json");
-  if (fs9.existsSync(pnpmWorkspacesPath)) {
-    const content = fs9.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 (fs9.existsSync(packageJsonPath)) {
-    try {
-      const content = fs9.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 {
-  loadAuth,
-  saveAuth,
-  loadConfig,
-  getDefaultConfig,
-  NotesError,
-  InputParseError,
-  TemplateError,
-  LLMError,
-  GitHubError,
-  ConfigError,
-  getExitCode,
-  EXIT_CODES2 as EXIT_CODES,
-  parsePackageVersioner,
-  parsePackageVersionerFile,
-  parsePackageVersionerStdin,
-  renderMarkdown,
-  writeMarkdown,
-  renderJson,
-  writeJson,
-  createTemplateContext,
-  runPipeline,
-  processInput,
-  aggregateToRoot,
-  writeMonorepoChangelogs,
-  detectMonorepo
-};