@cullit/core 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,13 +1,21 @@
 // src/constants.ts
-var VERSION = "0.3.0";
+var VERSION = "0.5.0";
 var DEFAULT_CATEGORIES = ["features", "fixes", "breaking", "improvements", "chores"];
 var DEFAULT_MODELS = {
   anthropic: "claude-sonnet-4-20250514",
   openai: "gpt-4o",
   gemini: "gemini-2.0-flash",
   ollama: "llama3.1",
-  openclaw: "claude-sonnet-4-6"
+  openclaw: "anthropic/claude-sonnet-4-6"
 };
+var AI_PROVIDERS = ["anthropic", "openai", "gemini", "ollama", "openclaw", "none"];
+var OUTPUT_FORMATS = ["markdown", "html", "json"];
+var PUBLISHER_TYPES = ["stdout", "file", "slack", "discord", "github-release"];
+var ENRICHMENT_TYPES = ["jira", "linear"];
+var CHANGE_CATEGORIES = ["features", "fixes", "breaking", "improvements", "chores", "other"];
+var AUDIENCES = ["developer", "end-user", "executive"];
+var TONES = ["professional", "casual", "terse"];
+var SOURCE_TYPES = ["local", "jira", "linear"];
 
 // src/logger.ts
 function createLogger(level = "normal") {
@@ -151,510 +159,28 @@ function getLatestTag(cwd = process.cwd()) {
     return null;
   }
 }
-
-// src/fetch.ts
-var DEFAULT_TIMEOUT = 3e4;
-async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { ...init, signal: controller.signal });
-  } catch (err) {
-    if (err.name === "AbortError") {
-      throw new Error(`Request to ${new URL(url).hostname} timed out after ${timeoutMs / 1e3}s`);
-    }
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// src/collectors/jira.ts
-var JiraCollector = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async collect(from, to) {
-    const jql = this.buildJQL(from, to);
-    const issues = await this.fetchIssues(jql);
-    const commits = issues.map((issue) => ({
-      hash: issue.key,
-      shortHash: issue.key,
-      author: issue.assignee || "unassigned",
-      date: issue.resolved || issue.updated || (/* @__PURE__ */ new Date()).toISOString(),
-      message: `${issue.type ? `[${issue.type}] ` : ""}${issue.summary}`,
-      body: issue.description?.substring(0, 500),
-      issueKeys: [issue.key]
-    }));
-    return {
-      from: `jira:${from}`,
-      to: to === "HEAD" ? `jira:${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}` : `jira:${to}`,
-      commits,
-      filesChanged: 0
-    };
-  }
-  buildJQL(from, to) {
-    if (from.includes("=") || from.includes("AND") || from.includes("OR")) {
-      const statusFilter = " AND status in (Done, Closed, Resolved)";
-      return from.includes("status") ? from : from + statusFilter;
-    }
-    if (!/^[A-Z][A-Z0-9_]{0,30}$/.test(from)) {
-      throw new Error(`Invalid Jira project key: "${from}". Must be uppercase letters, digits, or underscores (e.g., PROJ, MY_PROJ).`);
-    }
-    const safeVersion = to.replace(/["'\\]/g, "");
-    if (to === "HEAD") {
-      return `project = ${from} AND status in (Done, Closed, Resolved) AND resolved >= -30d ORDER BY resolved DESC`;
-    }
-    return `project = ${from} AND fixVersion = "${safeVersion}" AND status in (Done, Closed, Resolved) ORDER BY resolved DESC`;
-  }
-  async fetchIssues(jql) {
-    const { domain, email, apiToken } = this.config;
-    if (!/^[a-zA-Z0-9.-]+\.atlassian\.net$/.test(domain)) {
-      throw new Error(`Invalid Jira domain: "${domain}". Expected format: yourcompany.atlassian.net`);
-    }
-    const resolvedEmail = email || process.env.JIRA_EMAIL;
-    const resolvedToken = apiToken || process.env.JIRA_API_TOKEN;
-    if (!resolvedEmail || !resolvedToken) {
-      throw new Error("Jira credentials not configured. Set JIRA_EMAIL and JIRA_API_TOKEN.");
-    }
-    const auth = Buffer.from(`${resolvedEmail}:${resolvedToken}`).toString("base64");
-    const issues = [];
-    let startAt = 0;
-    const maxResults = 50;
-    while (true) {
-      const url = new URL(`https://${domain}/rest/api/3/search`);
-      url.searchParams.set("jql", jql);
-      url.searchParams.set("startAt", String(startAt));
-      url.searchParams.set("maxResults", String(maxResults));
-      url.searchParams.set("fields", "summary,issuetype,assignee,status,resolution,resolutiondate,updated,labels,priority,description,fixVersions");
-      const response = await fetchWithTimeout(url.toString(), {
-        headers: {
-          "Authorization": `Basic ${auth}`,
-          "Accept": "application/json"
-        }
-      });
-      if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Jira API error (${response.status}): ${error}`);
-      }
-      const data = await response.json();
-      const batch = (data.issues || []).map((issue) => ({
-        key: issue.key,
-        summary: issue.fields.summary,
-        type: issue.fields.issuetype?.name?.toLowerCase(),
-        assignee: issue.fields.assignee?.displayName,
-        status: issue.fields.status?.name,
-        resolved: issue.fields.resolutiondate,
-        updated: issue.fields.updated,
-        description: issue.fields.description?.content?.[0]?.content?.[0]?.text,
-        labels: issue.fields.labels || [],
-        priority: issue.fields.priority?.name
-      }));
-      issues.push(...batch);
-      if (issues.length >= data.total || batch.length < maxResults) break;
-      startAt += maxResults;
-    }
-    return issues;
-  }
-};
-
-// src/collectors/linear.ts
-var LinearCollector = class {
-  apiKey;
-  constructor(apiKey) {
-    const resolved = apiKey || process.env.LINEAR_API_KEY;
-    if (!resolved) {
-      throw new Error("Linear API key not configured. Set LINEAR_API_KEY.");
-    }
-    this.apiKey = resolved;
-  }
-  async collect(from, to) {
-    const filter = this.parseFilter(from);
-    const issues = await this.fetchIssues(filter);
-    const commits = issues.map((issue) => ({
-      hash: issue.identifier,
-      shortHash: issue.identifier,
-      author: issue.assignee || "unassigned",
-      date: issue.completedAt || issue.updatedAt || (/* @__PURE__ */ new Date()).toISOString(),
-      message: `${issue.type ? `[${issue.type}] ` : ""}${issue.title}`,
-      body: issue.description?.substring(0, 500),
-      issueKeys: [issue.identifier]
-    }));
+function getCommitsSince(from, to, cwd = process.cwd()) {
+  validateRef(from);
+  validateRef(to);
+  const format = "%H|%h|%an|%aI|%s";
+  const separator = "---CULLIT_COMMIT---";
+  const log = execSync(
+    `git log ${from}..${to} --format="${format}${separator}" --no-merges`,
+    { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+  );
+  if (!log.trim()) return [];
+  return log.split(separator).filter((e) => e.trim()).map((entry) => {
+    const [hash, shortHash, author, date, ...msgParts] = entry.trim().split("|");
     return {
-      from: `linear:${from}`,
-      to: to === "HEAD" ? `linear:${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}` : `linear:${to}`,
-      commits,
-      filesChanged: 0
-    };
-  }
-  parseFilter(from) {
-    const [type, ...valueParts] = from.split(":");
-    const value = valueParts.join(":") || type;
-    switch (type.toLowerCase()) {
-      case "team":
-        return { type: "team", value };
-      case "project":
-        return { type: "project", value };
-      case "cycle":
-        return { type: "cycle", value };
-      case "label":
-        return { type: "label", value };
-      default:
-        return { type: "team", value: from };
-    }
-  }
-  async fetchIssues(filter) {
-    const filterClause = this.buildFilterClause(filter);
-    const needsVariable = filter.type !== "cycle" || filter.value !== "current";
-    const query = needsVariable ? `
-      query CompletedIssues($filterValue: String!) {
-        issues(
-          filter: {
-            state: { type: { in: ["completed", "canceled"] } }
-            ${filterClause}
-          }
-          first: 100
-          orderBy: completedAt
-        ) {
-          nodes {
-            identifier
-            title
-            description
-            priority
-            completedAt
-            updatedAt
-            assignee { displayName }
-            state { name type }
-            labels { nodes { name } }
-            project { name }
-          }
-        }
-      }
-    ` : `
-      query CompletedIssues {
-        issues(
-          filter: {
-            state: { type: { in: ["completed", "canceled"] } }
-            ${filterClause}
-          }
-          first: 100
-          orderBy: completedAt
-        ) {
-          nodes {
-            identifier
-            title
-            description
-            priority
-            completedAt
-            updatedAt
-            assignee { displayName }
-            state { name type }
-            labels { nodes { name } }
-            project { name }
-          }
-        }
-      }
-    `;
-    const variables = needsVariable ? { filterValue: filter.value } : void 0;
-    const response = await fetchWithTimeout("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({ query, variables })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Linear API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    const nodes = data.data?.issues?.nodes || [];
-    const priorityMap = {
-      0: "none",
-      1: "urgent",
-      2: "high",
-      3: "medium",
-      4: "low"
-    };
-    return nodes.map((issue) => ({
-      identifier: issue.identifier,
-      title: issue.title,
-      description: issue.description?.substring(0, 500),
-      type: issue.labels?.nodes?.[0]?.name?.toLowerCase(),
-      assignee: issue.assignee?.displayName,
-      status: issue.state?.name,
-      completedAt: issue.completedAt,
-      updatedAt: issue.updatedAt,
-      labels: issue.labels?.nodes?.map((l) => l.name) || [],
-      priority: priorityMap[issue.priority]
-    }));
-  }
-  buildFilterClause(filter) {
-    switch (filter.type) {
-      case "team":
-        return `team: { key: { eq: $filterValue } }`;
-      case "project":
-        return `project: { name: { containsIgnoreCase: $filterValue } }`;
-      case "cycle":
-        if (filter.value === "current") {
-          return `cycle: { isActive: { eq: true } }`;
-        }
-        return `cycle: { name: { containsIgnoreCase: $filterValue } }`;
-      case "label":
-        return `labels: { name: { eq: $filterValue } }`;
-      default:
-        return "";
-    }
-  }
-};
-
-// src/generators/ai.ts
-var AIGenerator = class {
-  openclawConfig;
-  timeoutMs;
-  constructor(openclawConfig, timeoutMs = 6e4) {
-    this.openclawConfig = openclawConfig;
-    this.timeoutMs = timeoutMs;
-  }
-  async fetch(url, init) {
-    return fetchWithTimeout(url, init, this.timeoutMs);
-  }
-  async generate(context, config) {
-    const prompt = this.buildPrompt(context, config);
-    const apiKey = this.resolveApiKey(config);
-    let rawResponse;
-    if (config.provider === "anthropic") {
-      rawResponse = await this.callAnthropic(prompt, apiKey, config.model);
-    } else if (config.provider === "openai") {
-      rawResponse = await this.callOpenAI(prompt, apiKey, config.model);
-    } else if (config.provider === "gemini") {
-      rawResponse = await this.callGemini(prompt, apiKey, config.model);
-    } else if (config.provider === "ollama") {
-      rawResponse = await this.callOllama(prompt, config.model);
-    } else if (config.provider === "openclaw") {
-      rawResponse = await this.callOpenClaw(prompt, config.model);
-    } else {
-      throw new Error(`Unsupported AI provider: ${config.provider}`);
-    }
-    return this.parseResponse(rawResponse, context);
-  }
-  resolveApiKey(config) {
-    if (config.apiKey) return config.apiKey;
-    if (config.provider === "ollama" || config.provider === "openclaw") return "";
-    const envVarMap = {
-      anthropic: "ANTHROPIC_API_KEY",
-      openai: "OPENAI_API_KEY",
-      gemini: "GOOGLE_API_KEY"
-    };
-    const envVar = envVarMap[config.provider];
-    if (!envVar) throw new Error(`Unknown provider: ${config.provider}`);
-    const key = process.env[envVar];
-    if (!key) {
-      throw new Error(
-        `No API key found. Set ${envVar} in your environment or provide it in .cullit.yml under ai.apiKey`
-      );
-    }
-    return key;
-  }
-  buildPrompt(context, config) {
-    const { diff, tickets } = context;
-    const commitList = diff.commits.map((c) => {
-      let line = `- ${c.shortHash}: ${c.message}`;
-      if (c.issueKeys?.length) line += ` [${c.issueKeys.join(", ")}]`;
-      return line;
-    }).join("\n");
-    const ticketList = tickets.length > 0 ? tickets.map(
-      (t) => `- ${t.key}: ${t.title}${t.type ? ` (${t.type})` : ""}${t.labels?.length ? ` [${t.labels.join(", ")}]` : ""}`
-    ).join("\n") : "No enrichment data available.";
-    const audienceInstructions = {
-      "developer": "Write for developers. Include technical details, API changes, and migration notes.",
-      "end-user": "Write for end users. Use plain language. Focus on benefits and behavior changes. No jargon.",
-      "executive": "Write a brief executive summary. Focus on business impact, key metrics, and strategic changes."
-    };
-    const toneInstructions = {
-      "professional": "Tone: professional and clear.",
-      "casual": "Tone: conversational and approachable, but still informative.",
-      "terse": "Tone: minimal and direct. Short bullet points only."
+      hash: hash.trim(),
+      shortHash: shortHash.trim(),
+      author: author.trim(),
+      date: date.trim(),
+      message: msgParts.join("|").trim()
     };
-    const categories = config.categories.join(", ");
-    return `You are a release notes generator. Analyze the following git commits and related tickets, then produce structured release notes.
-
-## Input
-
-### Commits (${diff.from} \u2192 ${diff.to})
-${commitList}
-
-### Related Tickets
-${ticketList}
-
-## Instructions
-
-${audienceInstructions[config.audience]}
-${toneInstructions[config.tone]}
-
-Categorize each change into one of: ${categories}
-
-## Output Format
-
-Respond with ONLY valid JSON (no markdown, no backticks, no preamble):
-{
-  "summary": "One paragraph summarizing this release",
-  "changes": [
-    {
-      "description": "Human-readable description of the change",
-      "category": "features|fixes|breaking|improvements|chores",
-      "ticketKey": "PROJ-123 or null"
-    }
-  ]
+  });
 }
 
-Rules:
-- Combine related commits into single change entries
-- Skip trivial commits (merge commits, formatting, typos) unless they fix bugs
-- Each description should be one clear sentence
-- Include ticket keys when available
-- Group by category
-- Maximum 20 change entries
-- If a commit message mentions a breaking change, categorize it as "breaking"`;
-  }
-  async callAnthropic(prompt, apiKey, model) {
-    const response = await this.fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: model || "claude-sonnet-4-20250514",
-        max_tokens: 4096,
-        messages: [{ role: "user", content: prompt }]
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    return data.content[0]?.text || "";
-  }
-  async callOpenAI(prompt, apiKey, model) {
-    const response = await this.fetch("https://api.openai.com/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model: model || "gpt-4o",
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: 4096,
-        temperature: 0.3
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    return data.choices[0]?.message?.content || "";
-  }
-  async callGemini(prompt, apiKey, model) {
-    const modelId = model || "gemini-2.0-flash";
-    const response = await this.fetch(
-      `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${encodeURIComponent(apiKey)}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          contents: [{ parts: [{ text: prompt }] }],
-          generationConfig: { temperature: 0.3, maxOutputTokens: 4096 }
-        })
-      }
-    );
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    return data.candidates?.[0]?.content?.parts?.[0]?.text || "";
-  }
-  async callOllama(prompt, model) {
-    const baseUrl = process.env.OLLAMA_HOST || "http://localhost:11434";
-    const response = await this.fetch(`${baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: model || "llama3.1",
-        messages: [{ role: "user", content: prompt }],
-        stream: false,
-        options: { temperature: 0.3 }
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Ollama API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    return data.message?.content || "";
-  }
-  async callOpenClaw(prompt, model) {
-    const baseUrl = this.openclawConfig?.baseUrl || process.env.OPENCLAW_URL || "http://localhost:18789";
-    const token = this.openclawConfig?.token || process.env.OPENCLAW_TOKEN || "";
-    const headers = { "Content-Type": "application/json" };
-    if (token) headers["Authorization"] = `Bearer ${token}`;
-    const response = await this.fetch(`${baseUrl}/v1/chat/completions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        model: model || "anthropic/claude-sonnet-4-6",
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: 4096,
-        temperature: 0.3
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenClaw API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    return data.choices?.[0]?.message?.content || "";
-  }
-  parseResponse(raw, context) {
-    const cleaned = raw.replace(/```json\s*/g, "").replace(/```\s*/g, "").trim();
-    let parsed;
-    try {
-      parsed = JSON.parse(cleaned);
-    } catch {
-      throw new Error(`Failed to parse AI response as JSON. Raw response:
-${raw.substring(0, 500)}`);
-    }
-    const validCategories = /* @__PURE__ */ new Set(["features", "fixes", "breaking", "improvements", "chores", "other"]);
-    const changes = (parsed.changes || []).map((c) => ({
-      description: c.description,
-      category: validCategories.has(c.category) ? c.category : "other",
-      ticketKey: c.ticketKey || void 0
-    }));
-    const contributors = [...new Set(context.diff.commits.map((c) => c.author))];
-    return {
-      version: context.diff.to,
-      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-      summary: parsed.summary,
-      changes,
-      contributors,
-      metadata: {
-        commitCount: context.diff.commits.length,
-        prCount: context.diff.commits.filter((c) => c.prNumber).length,
-        ticketCount: context.tickets.length,
-        generatedBy: "cullit",
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-};
-
 // src/generators/template.ts
 var TemplateGenerator = class {
   async generate(context, config) {
@@ -679,7 +205,7 @@ var TemplateGenerator = class {
     return {
       version: diff.to,
       date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-      summary: this.buildSummary(deduped, diff.commits.length),
+      summary: this.buildSummary(deduped, diff.commits.length, config.tone),
       changes: deduped.slice(0, 20),
       contributors,
       metadata: {
@@ -749,7 +275,7 @@ var TemplateGenerator = class {
     }
     return result;
   }
-  buildSummary(changes, commitCount) {
+  buildSummary(changes, commitCount, tone) {
     const counts = {};
     for (const c of changes) {
       counts[c.category] = (counts[c.category] || 0) + 1;
@@ -759,12 +285,28 @@ var TemplateGenerator = class {
     if (counts["features"]) parts.push(`${counts["features"]} feature${counts["features"] > 1 ? "s" : ""}`);
     if (counts["fixes"]) parts.push(`${counts["fixes"]} fix${counts["fixes"] > 1 ? "es" : ""}`);
     if (counts["improvements"]) parts.push(`${counts["improvements"]} improvement${counts["improvements"] > 1 ? "s" : ""}`);
-    const summary = parts.length > 0 ? `This release includes ${parts.join(", ")} across ${commitCount} commits.` : `This release includes ${commitCount} commits.`;
-    return summary;
+    if (tone === "terse") {
+      return parts.length > 0 ? parts.join(", ") : `${commitCount} commits`;
+    }
+    if (tone === "casual") {
+      if (parts.length === 0) return `A quick update with ${commitCount} commits \u2014 nothing too wild.`;
+      return `We've got ${parts.join(", ")} packed into ${commitCount} commits. Let's go!`;
+    }
+    return parts.length > 0 ? `This release includes ${parts.join(", ")} across ${commitCount} commits.` : `This release includes ${commitCount} commits.`;
   }
 };
 
 // src/formatter.ts
+var formatters = /* @__PURE__ */ new Map();
+function registerFormatter(format, fn) {
+  formatters.set(format, fn);
+}
+function getFormatter(format) {
+  return formatters.get(format);
+}
+function listFormatters() {
+  return Array.from(formatters.keys());
+}
 var CATEGORY_LABELS = {
   features: "\u2728 Features",
   fixes: "\u{1F41B} Bug Fixes",
@@ -782,16 +324,8 @@ var CATEGORY_ORDER = [
   "other"
 ];
 function formatNotes(notes, format) {
-  switch (format) {
-    case "markdown":
-      return formatMarkdown(notes);
-    case "html":
-      return formatHTML(notes);
-    case "json":
-      return JSON.stringify(notes, null, 2);
-    default:
-      return formatMarkdown(notes);
-  }
+  const fn = formatters.get(format) || formatters.get("markdown");
+  return fn(notes);
 }
 function formatMarkdown(notes) {
   const lines = [];
@@ -862,393 +396,27 @@ function groupByCategory(notes) {
   }
   return grouped;
 }
+registerFormatter("markdown", formatMarkdown);
+registerFormatter("html", formatHTML);
+registerFormatter("json", (notes) => JSON.stringify(notes, null, 2));
 
 // src/publishers/index.ts
 import { writeFileSync } from "fs";
 var StdoutPublisher = class {
-  async publish(notes, format) {
-    const formatted = formatNotes(notes, format);
-    console.log(formatted);
+  async publish(notes, format, preformatted) {
+    console.log(preformatted || formatNotes(notes, format));
   }
 };
 var FilePublisher = class {
   constructor(path) {
     this.path = path;
   }
-  async publish(notes, format) {
-    const formatted = formatNotes(notes, format);
-    writeFileSync(this.path, formatted, "utf-8");
+  async publish(notes, format, preformatted) {
+    const output = preformatted || formatNotes(notes, format);
+    writeFileSync(this.path, output, "utf-8");
     console.log(`\u2713 Release notes written to ${this.path}`);
   }
 };
-var SlackPublisher = class {
-  constructor(webhookUrl) {
-    this.webhookUrl = webhookUrl;
-    if (!webhookUrl.startsWith("https://hooks.slack.com/") && !webhookUrl.startsWith("https://hooks.slack-gov.com/")) {
-      throw new Error("Invalid Slack webhook URL \u2014 must start with https://hooks.slack.com/ or https://hooks.slack-gov.com/");
-    }
-  }
-  async publish(notes, _format) {
-    const text = this.buildSlackMessage(notes);
-    const response = await fetchWithTimeout(this.webhookUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ text })
-    });
-    if (!response.ok) {
-      throw new Error(`Slack webhook failed (${response.status})`);
-    }
-    console.log("\u2713 Published to Slack");
-  }
-  buildSlackMessage(notes) {
-    let msg = `*${notes.version}* \u2014 ${notes.date}
-`;
-    if (notes.summary) msg += `${notes.summary}
-
-`;
-    const categoryEmoji = {
-      features: "\u2728",
-      fixes: "\u{1F41B}",
-      breaking: "\u26A0\uFE0F",
-      improvements: "\u{1F527}",
-      chores: "\u{1F9F9}",
-      other: "\u{1F4DD}"
-    };
-    for (const change of notes.changes) {
-      const emoji = categoryEmoji[change.category] || "\u2022";
-      msg += `${emoji} ${change.description}`;
-      if (change.ticketKey) msg += ` (\`${change.ticketKey}\`)`;
-      msg += "\n";
-    }
-    return msg;
-  }
-};
-var DiscordPublisher = class {
-  constructor(webhookUrl) {
-    this.webhookUrl = webhookUrl;
-    if (!webhookUrl.startsWith("https://discord.com/api/webhooks/") && !webhookUrl.startsWith("https://discordapp.com/api/webhooks/")) {
-      throw new Error("Invalid Discord webhook URL \u2014 must start with https://discord.com/api/webhooks/");
-    }
-  }
-  async publish(notes, _format) {
-    const content = this.buildDiscordMessage(notes);
-    const response = await fetchWithTimeout(this.webhookUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        embeds: [{
-          title: `Release ${notes.version}`,
-          description: content,
-          color: 15269703,
-          // Cullit accent color
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          footer: { text: "Generated by Cullit" }
-        }]
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Discord webhook failed (${response.status})`);
-    }
-    console.log("\u2713 Published to Discord");
-  }
-  buildDiscordMessage(notes) {
-    let msg = "";
-    if (notes.summary) msg += `${notes.summary}
-
-`;
-    for (const change of notes.changes) {
-      msg += `\u2022 ${change.description}`;
-      if (change.ticketKey) msg += ` (${change.ticketKey})`;
-      msg += "\n";
-    }
-    return msg.substring(0, 4e3);
-  }
-};
-var GitHubReleasePublisher = class {
-  token;
-  owner;
-  repo;
-  constructor() {
-    this.token = process.env["GITHUB_TOKEN"] || "";
-    const ghRepo = process.env["GITHUB_REPOSITORY"] || "";
-    const parts = ghRepo.split("/");
-    this.owner = parts[0] || "";
-    this.repo = parts[1] || "";
-  }
-  async publish(notes, format) {
-    if (!this.token) {
-      throw new Error("GITHUB_TOKEN is required for GitHub Release publishing");
-    }
-    if (!this.owner || !this.repo) {
-      throw new Error(
-        "GITHUB_REPOSITORY env var is required (format: owner/repo). This is set automatically in GitHub Actions."
-      );
-    }
-    const formatted = formatNotes(notes, format);
-    const tagName = notes.version.startsWith("v") ? notes.version : `v${notes.version}`;
-    const existing = await this.getRelease(tagName);
-    if (existing) {
-      await this.updateRelease(existing.id, formatted, notes);
-      console.log(`\u2713 Updated GitHub Release: ${tagName}`);
-    } else {
-      await this.createRelease(tagName, formatted, notes);
-      console.log(`\u2713 Created GitHub Release: ${tagName}`);
-    }
-  }
-  async getRelease(tag) {
-    const url = `https://api.github.com/repos/${this.owner}/${this.repo}/releases/tags/${encodeURIComponent(tag)}`;
-    const response = await fetchWithTimeout(url, {
-      headers: this.headers()
-    });
-    if (response.status === 404) return null;
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub API error (${response.status}): ${error}`);
-    }
-    const data = await response.json();
-    return data;
-  }
-  async createRelease(tag, body, notes) {
-    const url = `https://api.github.com/repos/${this.owner}/${this.repo}/releases`;
-    const response = await fetchWithTimeout(url, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({
-        tag_name: tag,
-        name: `${tag} \u2014 ${notes.date}`,
-        body,
-        draft: false,
-        prerelease: tag.includes("-")
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub Release creation failed (${response.status}): ${error}`);
-    }
-  }
-  async updateRelease(id, body, notes) {
-    const tag = notes.version.startsWith("v") ? notes.version : `v${notes.version}`;
-    const url = `https://api.github.com/repos/${this.owner}/${this.repo}/releases/${id}`;
-    const response = await fetchWithTimeout(url, {
-      method: "PATCH",
-      headers: this.headers(),
-      body: JSON.stringify({
-        body,
-        name: `${tag} \u2014 ${notes.date}`
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub Release update failed (${response.status}): ${error}`);
-    }
-  }
-  headers() {
-    return {
-      "Accept": "application/vnd.github+json",
-      "Authorization": `Bearer ${this.token}`,
-      "X-GitHub-Api-Version": "2022-11-28"
-    };
-  }
-};
-
-// src/enrichers/jira.ts
-var JiraEnricher = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async enrich(diff) {
-    const keys = this.extractUniqueKeys(diff);
-    if (keys.length === 0) return [];
-    const tickets = [];
-    for (const key of keys) {
-      try {
-        const ticket = await this.fetchTicket(key);
-        if (ticket) tickets.push(ticket);
-      } catch (err) {
-        console.warn(`\u26A0 Could not fetch Jira ticket ${key}: ${err.message}`);
-      }
-    }
-    return tickets;
-  }
-  extractUniqueKeys(diff) {
-    const allKeys = [];
-    for (const commit of diff.commits) {
-      if (commit.issueKeys) allKeys.push(...commit.issueKeys);
-    }
-    return [...new Set(allKeys)];
-  }
-  async fetchTicket(key) {
-    const { domain, email, apiToken } = this.config;
-    const resolvedEmail = email || process.env.JIRA_EMAIL;
-    const resolvedToken = apiToken || process.env.JIRA_API_TOKEN;
-    if (!resolvedEmail || !resolvedToken) {
-      throw new Error("Jira credentials not configured. Set JIRA_EMAIL and JIRA_API_TOKEN.");
-    }
-    const auth = Buffer.from(`${resolvedEmail}:${resolvedToken}`).toString("base64");
-    const response = await fetchWithTimeout(
-      `https://${domain}/rest/api/3/issue/${key}?fields=summary,issuetype,labels,priority,status,description`,
-      {
-        headers: {
-          "Authorization": `Basic ${auth}`,
-          "Accept": "application/json"
-        }
-      }
-    );
-    if (response.status === 404) return null;
-    if (!response.ok) {
-      throw new Error(`Jira API error (${response.status})`);
-    }
-    const data = await response.json();
-    const fields = data.fields;
-    return {
-      key,
-      title: fields.summary || key,
-      type: fields.issuetype?.name?.toLowerCase(),
-      labels: fields.labels || [],
-      priority: fields.priority?.name,
-      status: fields.status?.name,
-      source: "jira"
-    };
-  }
-};
-
-// src/enrichers/linear.ts
-var LinearEnricher = class {
-  apiKey;
-  constructor(apiKey) {
-    const resolved = apiKey || process.env.LINEAR_API_KEY;
-    if (!resolved) {
-      throw new Error("Linear API key not configured. Set LINEAR_API_KEY.");
-    }
-    this.apiKey = resolved;
-  }
-  async enrich(diff) {
-    const keys = this.extractUniqueKeys(diff);
-    if (keys.length === 0) return [];
-    try {
-      return await this.fetchIssuesBatch(keys);
-    } catch (err) {
-      console.warn(`\u26A0 Linear batch fetch failed, falling back to individual queries: ${err.message}`);
-      return this.fetchIssuesIndividually(keys);
-    }
-  }
-  async fetchIssuesIndividually(keys) {
-    const tickets = [];
-    for (const key of keys) {
-      try {
-        const ticket = await this.fetchIssue(key);
-        if (ticket) tickets.push(ticket);
-      } catch (err) {
-        console.warn(`\u26A0 Could not fetch Linear issue ${key}: ${err.message}`);
-      }
-    }
-    return tickets;
-  }
-  extractUniqueKeys(diff) {
-    const allKeys = [];
-    for (const commit of diff.commits) {
-      if (commit.issueKeys) allKeys.push(...commit.issueKeys);
-    }
-    return [...new Set(allKeys)];
-  }
-  async fetchIssuesBatch(identifiers) {
-    const query = `
-      query BatchIssues($filter: IssueFilter!) {
-        issues(filter: $filter, first: 100) {
-          nodes {
-            identifier
-            title
-            description
-            priority
-            state { name }
-            labels { nodes { name } }
-          }
-        }
-      }
-    `;
-    const response = await fetchWithTimeout("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        query,
-        variables: {
-          filter: { identifier: { in: identifiers } }
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Linear API error (${response.status})`);
-    }
-    const data = await response.json();
-    const issues = data.data?.issues?.nodes || [];
-    const priorityMap = {
-      0: "none",
-      1: "urgent",
-      2: "high",
-      3: "medium",
-      4: "low"
-    };
-    return issues.map((issue) => ({
-      key: issue.identifier,
-      title: issue.title,
-      description: issue.description?.substring(0, 500),
-      labels: issue.labels?.nodes?.map((l) => l.name) || [],
-      priority: priorityMap[issue.priority] || void 0,
-      status: issue.state?.name,
-      source: "linear"
-    }));
-  }
-  async fetchIssue(identifier) {
-    const query = `
-      query IssueByIdentifier($id: String!) {
-        issueSearch(filter: { identifier: { eq: $id } }, first: 1) {
-          nodes {
-            identifier
-            title
-            description
-            priority
-            state { name }
-            labels { nodes { name } }
-          }
-        }
-      }
-    `;
-    const response = await fetchWithTimeout("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({ query, variables: { id: identifier } })
-    });
-    if (!response.ok) {
-      throw new Error(`Linear API error (${response.status})`);
-    }
-    const data = await response.json();
-    const issue = data.data?.issueSearch?.nodes?.[0];
-    if (!issue) return null;
-    const priorityMap = {
-      0: "none",
-      1: "urgent",
-      2: "high",
-      3: "medium",
-      4: "low"
-    };
-    return {
-      key: issue.identifier,
-      title: issue.title,
-      description: issue.description?.substring(0, 500),
-      labels: issue.labels?.nodes?.map((l) => l.name) || [],
-      priority: priorityMap[issue.priority] || void 0,
-      status: issue.state?.name,
-      source: "linear"
-    };
-  }
-};
 
 // src/advisor.ts
 import { execSync as execSync2 } from "child_process";
@@ -1280,24 +448,8 @@ function bumpVersion(version, bump) {
   }
 }
 function getCommitsSinceTag(tag, cwd) {
-  const format = "%H|%h|%an|%aI|%s";
-  const separator = "---CULLIT_COMMIT---";
   try {
-    const log = execSync2(
-      `git log ${tag}..HEAD --format="${format}${separator}" --no-merges`,
-      { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
-    );
-    if (!log.trim()) return [];
-    return log.split(separator).filter((e) => e.trim()).map((entry) => {
-      const [hash, shortHash, author, date, ...msgParts] = entry.trim().split("|");
-      return {
-        hash: hash.trim(),
-        shortHash: shortHash.trim(),
-        author: author.trim(),
-        date: date.trim(),
-        message: msgParts.join("|").trim()
-      };
-    });
+    return getCommitsSince(tag, "HEAD", cwd);
   } catch {
     return [];
   }
@@ -1392,9 +544,28 @@ function analyzeReleaseReadiness(cwd = process.cwd()) {
   };
 }
 
+// src/fetch.ts
+var DEFAULT_TIMEOUT = 3e4;
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err.name === "AbortError") {
+      throw new Error(`Request to ${new URL(url).hostname} timed out after ${timeoutMs / 1e3}s`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/gate.ts
 var FREE_PROVIDERS = /* @__PURE__ */ new Set(["none"]);
 var FREE_PUBLISHERS = /* @__PURE__ */ new Set(["stdout", "file"]);
+var LICENSE_CACHE_TTL = 24 * 60 * 60 * 1e3;
+var cachedValidation = null;
 function resolveLicense() {
   const key = process.env.CULLIT_API_KEY?.trim();
   if (!key) {
@@ -1405,6 +576,48 @@ function resolveLicense() {
   }
   return { tier: "pro", valid: true };
 }
+async function validateLicense() {
+  const key = process.env.CULLIT_API_KEY?.trim();
+  const validationUrl = process.env.CULLIT_LICENSE_URL?.trim();
+  if (!key) {
+    return { tier: "free", valid: true };
+  }
+  if (!/^clt_[a-zA-Z0-9]{32,}$/.test(key)) {
+    return { tier: "free", valid: false, message: "Invalid CULLIT_API_KEY format. Expected: clt_<key>" };
+  }
+  if (cachedValidation && cachedValidation.key === key && Date.now() < cachedValidation.expiresAt) {
+    return cachedValidation.status;
+  }
+  if (!validationUrl) {
+    return { tier: "pro", valid: true };
+  }
+  try {
+    const res = await fetchWithTimeout(validationUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+      body: JSON.stringify({ key })
+    }, 1e4);
+    if (res.ok) {
+      const data = await res.json();
+      const status2 = {
+        tier: data.tier === "pro" ? "pro" : "free",
+        valid: data.valid !== false,
+        message: data.message
+      };
+      cachedValidation = { status: status2, key, expiresAt: Date.now() + LICENSE_CACHE_TTL };
+      return status2;
+    }
+    const status = {
+      tier: "free",
+      valid: false,
+      message: "License validation failed. Check your API key at https://cullit.io/pricing"
+    };
+    cachedValidation = { status, key, expiresAt: Date.now() + LICENSE_CACHE_TTL };
+    return status;
+  } catch {
+    return { tier: "pro", valid: true };
+  }
+}
 function isProviderAllowed(provider, license) {
   if (license.tier === "pro" && license.valid) return true;
   return FREE_PROVIDERS.has(provider);
@@ -1422,30 +635,85 @@ function upgradeMessage(feature) {
    Then set CULLIT_API_KEY in your environment.`;
 }
 
+// src/registry.ts
+var collectors = /* @__PURE__ */ new Map();
+var enrichers = /* @__PURE__ */ new Map();
+var generators = /* @__PURE__ */ new Map();
+var publishers = /* @__PURE__ */ new Map();
+function registerCollector(type, factory) {
+  collectors.set(type, factory);
+}
+function registerEnricher(type, factory) {
+  enrichers.set(type, factory);
+}
+function registerGenerator(provider, factory) {
+  generators.set(provider, factory);
+}
+function registerPublisher(type, factory) {
+  publishers.set(type, factory);
+}
+function getCollector(type) {
+  return collectors.get(type);
+}
+function getEnricher(type) {
+  return enrichers.get(type);
+}
+function getGenerator(provider) {
+  return generators.get(provider);
+}
+function getPublisher(type) {
+  return publishers.get(type);
+}
+function hasGenerator(provider) {
+  return generators.has(provider);
+}
+function hasCollector(type) {
+  return collectors.has(type);
+}
+function hasPublisher(type) {
+  return publishers.has(type);
+}
+function hasEnricher(type) {
+  return enrichers.has(type);
+}
+function listCollectors() {
+  return Array.from(collectors.keys());
+}
+function listEnrichers() {
+  return Array.from(enrichers.keys());
+}
+function listGenerators() {
+  return Array.from(generators.keys());
+}
+function listPublishers() {
+  return Array.from(publishers.keys());
+}
+
 // src/index.ts
+registerCollector("local", () => new GitCollector());
+registerGenerator("none", () => new TemplateGenerator());
+registerPublisher("stdout", (_target) => new StdoutPublisher());
+registerPublisher("file", (target) => new FilePublisher(target.path));
 async function runPipeline(from, to, config, options = {}) {
   const startTime = Date.now();
   const format = options.format || "markdown";
   const log = options.logger || createLogger("normal");
-  const license = resolveLicense();
+  const license = await validateLicense();
   if (!license.valid) {
     throw new Error(license.message || "Invalid CULLIT_API_KEY");
   }
   if (!isProviderAllowed(config.ai.provider, license)) {
     throw new Error(upgradeMessage(`AI provider "${config.ai.provider}"`));
   }
-  let collector;
-  if (config.source.type === "jira") {
-    if (!config.jira) throw new Error("Jira source requires jira config in .cullit.yml");
-    log.info(`\xBB Collecting issues from Jira...`);
-    collector = new JiraCollector(config.jira);
-  } else if (config.source.type === "linear") {
-    log.info(`\xBB Collecting issues from Linear...`);
-    collector = new LinearCollector(config.linear?.apiKey);
-  } else {
-    log.info(`\xBB Collecting commits between ${from}..${to}`);
-    collector = new GitCollector();
+  const collectorFactory = getCollector(config.source.type);
+  if (!collectorFactory) {
+    throw new Error(
+      `Source type "${config.source.type}" is not available. ` + (config.source.type !== "local" ? "Install @cullit/pro to use this source." : "Valid sources: local")
+    );
   }
+  const sourceLabel = config.source.type === "local" ? `commits between ${from}..${to}` : `items from ${config.source.type}`;
+  log.info(`\xBB Collecting ${sourceLabel}`);
+  const collector = collectorFactory(config);
   const diff = await collector.collect(from, to);
   const itemLabel = config.source.type === "jira" || config.source.type === "linear" ? "issues" : "commits";
   log.info(`\xBB Found ${diff.commits.length} ${itemLabel}${diff.filesChanged ? `, ${diff.filesChanged} files changed` : ""}`);
@@ -1456,28 +724,20 @@ async function runPipeline(from, to, config, options = {}) {
   const tickets = [];
   const enrichmentSources = config.source.enrichment || [];
   for (const source of enrichmentSources) {
-    if (source === "jira" && config.jira) {
-      if (!isEnrichmentAllowed(license)) {
-        log.info(`\xBB Skipping Jira enrichment \u2014 ${upgradeMessage("Jira enrichment")}`);
-        continue;
-      }
-      log.info("\xBB Enriching from Jira...");
-      const enricher = new JiraEnricher(config.jira);
-      const jiraTickets = await enricher.enrich(diff);
-      tickets.push(...jiraTickets);
-      log.info(`\xBB Jira: found ${jiraTickets.length} tickets`);
+    if (!isEnrichmentAllowed(license)) {
+      log.info(`\xBB Skipping ${source} enrichment \u2014 ${upgradeMessage(`${source} enrichment`)}`);
+      continue;
     }
-    if (source === "linear") {
-      if (!isEnrichmentAllowed(license)) {
-        log.info(`\xBB Skipping Linear enrichment \u2014 ${upgradeMessage("Linear enrichment")}`);
-        continue;
-      }
-      log.info("\xBB Enriching from Linear...");
-      const enricher = new LinearEnricher(config.linear?.apiKey);
-      const linearTickets = await enricher.enrich(diff);
-      tickets.push(...linearTickets);
-      log.info(`\xBB Linear: found ${linearTickets.length} issues`);
+    const enricherFactory = getEnricher(source);
+    if (!enricherFactory) {
+      log.info(`\xBB Skipping ${source} enrichment \u2014 install @cullit/pro to enable`);
+      continue;
     }
+    log.info(`\xBB Enriching from ${source}...`);
+    const enricher = enricherFactory(config);
+    const enrichedTickets = await enricher.enrich(diff);
+    tickets.push(...enrichedTickets);
+    log.info(`\xBB ${source}: found ${enrichedTickets.length} ${source === "jira" ? "tickets" : "issues"}`);
   }
   const context = { diff, tickets };
   const providerNames = {
@@ -1491,14 +751,19 @@ async function runPipeline(from, to, config, options = {}) {
   const providerName = providerNames[config.ai.provider] || config.ai.provider;
   const modelName = config.ai.provider === "none" ? "template" : config.ai.model || DEFAULT_MODELS[config.ai.provider] || "default";
   log.info(`\xBB Generating with ${providerName} (${modelName})...`);
-  let notes;
+  const generatorFactory = getGenerator(config.ai.provider);
+  if (!generatorFactory) {
+    throw new Error(
+      `AI provider "${config.ai.provider}" is not available. ` + (config.ai.provider !== "none" ? "Install @cullit/pro to use AI providers." : "")
+    );
+  }
+  let generator;
   if (config.ai.provider === "none") {
-    const generator = new TemplateGenerator();
-    notes = await generator.generate(context, config.ai);
+    generator = generatorFactory();
   } else {
-    const generator = new AIGenerator(config.openclaw);
-    notes = await generator.generate(context, config.ai);
+    generator = generatorFactory(config.openclaw);
   }
+  const notes = await generator.generate(context, config.ai);
   log.info(`\xBB Generated ${notes.changes.length} change entries`);
   const formatted = formatNotes(notes, format);
   const publishedTo = [];
@@ -1509,34 +774,14 @@ async function runPipeline(from, to, config, options = {}) {
           log.info(`\xBB Skipping ${target.type} \u2014 ${upgradeMessage(`${target.type} publishing`)}`);
           continue;
         }
-        switch (target.type) {
-          case "stdout":
-            await new StdoutPublisher().publish(notes, format);
-            publishedTo.push("stdout");
-            break;
-          case "file":
-            if (target.path) {
-              await new FilePublisher(target.path).publish(notes, format);
-              publishedTo.push(`file:${target.path}`);
-            }
-            break;
-          case "slack":
-            if (target.webhookUrl) {
-              await new SlackPublisher(target.webhookUrl).publish(notes, format);
-              publishedTo.push("slack");
-            }
-            break;
-          case "discord":
-            if (target.webhookUrl) {
-              await new DiscordPublisher(target.webhookUrl).publish(notes, format);
-              publishedTo.push("discord");
-            }
-            break;
-          case "github-release":
-            await new GitHubReleasePublisher().publish(notes, format);
-            publishedTo.push("github-release");
-            break;
+        const publisherFactory = getPublisher(target.type);
+        if (!publisherFactory) {
+          log.info(`\xBB Skipping ${target.type} \u2014 install @cullit/pro to enable`);
+          continue;
         }
+        const publisher = publisherFactory(target);
+        await publisher.publish(notes, format, formatted);
+        publishedTo.push(target.type === "file" ? `file:${target.path}` : target.type);
       } catch (err) {
         log.error(`\u2717 Failed to publish to ${target.type}: ${err.message}`);
       }
@@ -1552,30 +797,51 @@ async function runPipeline(from, to, config, options = {}) {
   return { notes, formatted, publishedTo, duration };
 }
 export {
-  AIGenerator,
+  AI_PROVIDERS,
+  AUDIENCES,
+  CHANGE_CATEGORIES,
   DEFAULT_CATEGORIES,
   DEFAULT_MODELS,
-  DiscordPublisher,
+  ENRICHMENT_TYPES,
   FilePublisher,
   GitCollector,
-  GitHubReleasePublisher,
-  JiraCollector,
-  JiraEnricher,
-  LinearCollector,
-  LinearEnricher,
-  SlackPublisher,
+  OUTPUT_FORMATS,
+  PUBLISHER_TYPES,
+  SOURCE_TYPES,
   StdoutPublisher,
+  TONES,
   TemplateGenerator,
   VERSION,
   analyzeReleaseReadiness,
   createLogger,
+  fetchWithTimeout,
   formatNotes,
+  getCollector,
+  getEnricher,
+  getFormatter,
+  getGenerator,
   getLatestTag,
+  getPublisher,
   getRecentTags,
+  hasCollector,
+  hasEnricher,
+  hasGenerator,
+  hasPublisher,
   isEnrichmentAllowed,
   isProviderAllowed,
   isPublisherAllowed,
+  listCollectors,
+  listEnrichers,
+  listFormatters,
+  listGenerators,
+  listPublishers,
+  registerCollector,
+  registerEnricher,
+  registerFormatter,
+  registerGenerator,
+  registerPublisher,
   resolveLicense,
   runPipeline,
-  upgradeMessage
+  upgradeMessage,
+  validateLicense
 };