@cullit/core 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,22 +1,50 @@
 // src/constants.ts
-var VERSION = "0.1.0";
+var VERSION = "0.4.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"
 };
 
+// src/logger.ts
+function createLogger(level = "normal") {
+  return {
+    info(msg) {
+      if (level !== "quiet") console.log(msg);
+    },
+    verbose(msg) {
+      if (level === "verbose") console.log(msg);
+    },
+    warn(msg) {
+      if (level !== "quiet") console.warn(msg);
+    },
+    error(msg) {
+      console.error(msg);
+    }
+  };
+}
+
 // src/collectors/git.ts
 import { execSync } from "child_process";
+function validateRef(ref) {
+  if (!ref || ref.length > 256) {
+    throw new Error(`Invalid git ref: too ${ref ? "long" : "short"}`);
+  }
+  if (!/^[a-zA-Z0-9._\-/~^]+$/.test(ref)) {
+    throw new Error(`Invalid git ref "${ref}" \u2014 only alphanumeric, dots, dashes, underscores, slashes, tildes, and carets are allowed`);
+  }
+}
 var GitCollector = class {
   cwd;
   constructor(cwd = process.cwd()) {
     this.cwd = cwd;
   }
   async collect(from, to) {
+    validateRef(from);
+    validateRef(to);
     const log = this.getLog(from, to);
     const commits = this.parseLog(log);
     return {
@@ -123,471 +151,28 @@ function getLatestTag(cwd = process.cwd()) {
     return null;
   }
 }
-
-// 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 (to === "HEAD") {
-      return `project = ${from} AND status in (Done, Closed, Resolved) AND resolved >= -30d ORDER BY resolved DESC`;
-    }
-    return `project = ${from} AND fixVersion = "${to}" AND status in (Done, Closed, Resolved) ORDER BY resolved DESC`;
-  }
-  async fetchIssues(jql) {
-    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 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 fetch(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 query = `
-      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 response = await fetch("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": this.apiKey
-      },
-      body: JSON.stringify({ query })
-    });
-    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"
+      hash: hash.trim(),
+      shortHash: shortHash.trim(),
+      author: author.trim(),
+      date: date.trim(),
+      message: msgParts.join("|").trim()
     };
-    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: "${filter.value}" } }`;
-      case "project":
-        return `project: { name: { containsIgnoreCase: "${filter.value}" } }`;
-      case "cycle":
-        if (filter.value === "current") {
-          return `cycle: { isActive: { eq: true } }`;
-        }
-        return `cycle: { name: { containsIgnoreCase: "${filter.value}" } }`;
-      case "label":
-        return `labels: { name: { eq: "${filter.value}" } }`;
-      default:
-        return "";
-    }
-  }
-};
-
-// src/generators/ai.ts
-var AIGenerator = class {
-  openclawConfig;
-  timeoutMs;
-  constructor(openclawConfig, timeoutMs = 6e4) {
-    this.openclawConfig = openclawConfig;
-    this.timeoutMs = timeoutMs;
-  }
-  async fetchWithTimeout(url, init) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.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 ${this.timeoutMs / 1e3}s`);
-      }
-      throw err;
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  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."
-    };
-    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.fetchWithTimeout("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.fetchWithTimeout("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.fetchWithTimeout(
-      `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.fetchWithTimeout(`${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.fetchWithTimeout(`${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: "cull",
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-};
-
 // src/generators/template.ts
 var TemplateGenerator = class {
   async generate(context, config) {
@@ -612,14 +197,14 @@ 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: {
         commitCount: diff.commits.length,
         prCount: diff.commits.filter((c) => c.prNumber).length,
         ticketCount: tickets.length,
-        generatedBy: "cull-template",
+        generatedBy: "cullit-template",
         generatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }
     };
@@ -682,7 +267,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;
@@ -692,8 +277,14 @@ 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.`;
   }
 };
 
@@ -755,7 +346,7 @@ function formatMarkdown(notes) {
   }
   if (notes.metadata) {
     lines.push("---");
-    lines.push(`*Generated by [Cull](https://cullit.io) \u2022 ${notes.metadata.commitCount} commits, ${notes.metadata.prCount} PRs*`);
+    lines.push(`*Generated by [Cullit](https://cullit.io) \u2022 ${notes.metadata.commitCount} commits, ${notes.metadata.prCount} PRs*`);
   }
   return lines.join("\n");
 }
@@ -781,7 +372,7 @@ function formatHTML(notes) {
     html += `</ul>`;
   }
   if (notes.metadata) {
-    html += `<footer><small>Generated by <a href="https://cullit.io">Cull</a> &bull; ${notes.metadata.commitCount} commits, ${notes.metadata.prCount} PRs</small></footer>`;
+    html += `<footer><small>Generated by <a href="https://cullit.io">Cullit</a> &bull; ${notes.metadata.commitCount} commits, ${notes.metadata.prCount} PRs</small></footer>`;
   }
   html += `</div>`;
   return html;
@@ -799,345 +390,272 @@ function groupByCategory(notes) {
 // 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;
-  }
-  async publish(notes, _format) {
-    const text = this.buildSlackMessage(notes);
-    const response = await fetch(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;
-  }
-  async publish(notes, _format) {
-    const content = this.buildDiscordMessage(notes);
-    const response = await fetch(this.webhookUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        embeds: [{
-          title: `Release ${notes.version}`,
-          description: content,
-          color: 15269703,
-          // Cull accent color
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          footer: { text: "Generated by Cull" }
-        }]
-      })
-    });
-    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}`);
-    }
+// src/advisor.ts
+import { execSync as execSync2 } from "child_process";
+var COMMIT_PATTERNS = [
+  { pattern: /^breaking[(!:]|^BREAKING CHANGE/i, category: "breaking" },
+  { pattern: /!:/, category: "breaking" },
+  { pattern: /^feat[(!:]|^feature[(!:]/i, category: "features" },
+  { pattern: /^fix[(!:]/i, category: "fixes" },
+  { pattern: /^chore[(!:]|^docs[(!:]|^ci[(!:]|^test[(!:]|^style[(!:]|^refactor[(!:]/i, category: "chores" }
+];
+function categorizeCommit(message) {
+  for (const { pattern, category } of COMMIT_PATTERNS) {
+    if (pattern.test(message)) return category;
   }
-  async getRelease(tag) {
-    const url = `https://api.github.com/repos/${this.owner}/${this.repo}/releases/tags/${encodeURIComponent(tag)}`;
-    const response = await fetch(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;
+  return "other";
+}
+function bumpVersion(version, bump) {
+  const prefix = version.startsWith("v") ? "v" : "";
+  const clean = version.replace(/^v/, "");
+  const parts = clean.split(".").map(Number);
+  if (parts.length !== 3 || parts.some(isNaN)) return version;
+  switch (bump) {
+    case "major":
+      return `${prefix}${parts[0] + 1}.0.0`;
+    case "minor":
+      return `${prefix}${parts[0]}.${parts[1] + 1}.0`;
+    case "patch":
+      return `${prefix}${parts[0]}.${parts[1]}.${parts[2] + 1}`;
   }
-  async createRelease(tag, body, notes) {
-    const url = `https://api.github.com/repos/${this.owner}/${this.repo}/releases`;
-    const response = await fetch(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}`);
-    }
+}
+function getCommitsSinceTag(tag, cwd) {
+  try {
+    return getCommitsSince(tag, "HEAD", cwd);
+  } catch {
+    return [];
   }
-  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 fetch(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}`);
-    }
+}
+function getTagDate(tag, cwd) {
+  try {
+    const dateStr = execSync2(
+      `git log -1 --format=%aI ${tag}`,
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return new Date(dateStr);
+  } catch {
+    return null;
   }
-  headers() {
+}
+function analyzeReleaseReadiness(cwd = process.cwd()) {
+  const latestTag = getLatestTag(cwd);
+  const reasons = [];
+  if (!latestTag) {
     return {
-      "Accept": "application/vnd.github+json",
-      "Authorization": `Bearer ${this.token}`,
-      "X-GitHub-Api-Version": "2022-11-28"
+      shouldRelease: true,
+      suggestedBump: "minor",
+      currentVersion: null,
+      nextVersion: null,
+      commitCount: 0,
+      contributorCount: 0,
+      daysSinceRelease: null,
+      breakdown: { features: 0, fixes: 0, breaking: 0, chores: 0, other: 0 },
+      reasons: ["No tags found. Consider creating your first release."]
     };
   }
-};
+  const commits = getCommitsSinceTag(latestTag, cwd);
+  const commitCount = commits.length;
+  const breakdown = { features: 0, fixes: 0, breaking: 0, chores: 0, other: 0 };
+  for (const commit of commits) {
+    breakdown[categorizeCommit(commit.message)]++;
+  }
+  const contributors = new Set(commits.map((c) => c.author));
+  const tagDate = getTagDate(latestTag, cwd);
+  const daysSinceRelease = tagDate ? Math.floor((Date.now() - tagDate.getTime()) / (1e3 * 60 * 60 * 24)) : null;
+  let suggestedBump = "patch";
+  if (breakdown.breaking > 0) {
+    suggestedBump = "major";
+    reasons.push(`${breakdown.breaking} breaking change(s) detected \u2014 major bump recommended`);
+  } else if (breakdown.features > 0) {
+    suggestedBump = "minor";
+    reasons.push(`${breakdown.features} new feature(s) \u2014 minor bump recommended`);
+  } else if (breakdown.fixes > 0) {
+    reasons.push(`${breakdown.fixes} bug fix(es) \u2014 patch bump recommended`);
+  }
+  let shouldRelease = false;
+  if (breakdown.breaking > 0) {
+    shouldRelease = true;
+    reasons.push("\u26A0 Breaking changes should be released and communicated promptly");
+  }
+  const securityCommits = commits.filter(
+    (c) => /security|cve|vuln|exploit|xss|injection|auth.*(fix|patch)/i.test(c.message)
+  );
+  if (securityCommits.length > 0) {
+    shouldRelease = true;
+    reasons.push(`\u{1F512} ${securityCommits.length} security-related commit(s) \u2014 release ASAP`);
+  }
+  if (commitCount >= 5) {
+    shouldRelease = true;
+    reasons.push(`${commitCount} unreleased commits \u2014 consider releasing to keep changes small and reviewable`);
+  }
+  if (daysSinceRelease !== null && daysSinceRelease >= 14 && commitCount > 0) {
+    shouldRelease = true;
+    reasons.push(`${daysSinceRelease} days since last release \u2014 regular cadence helps users stay current`);
+  }
+  if (breakdown.features >= 3) {
+    shouldRelease = true;
+    reasons.push("Multiple features accumulated \u2014 users are missing out");
+  }
+  if (commitCount > 0 && commitCount < 5 && !shouldRelease) {
+    reasons.push(`${commitCount} commit(s) since ${latestTag} \u2014 no urgency, but keep an eye on it`);
+  }
+  if (commitCount === 0) {
+    reasons.push("No unreleased commits \u2014 you're up to date!");
+  }
+  const nextVersion = bumpVersion(latestTag, suggestedBump);
+  return {
+    shouldRelease,
+    suggestedBump,
+    currentVersion: latestTag,
+    nextVersion,
+    commitCount,
+    contributorCount: contributors.size,
+    daysSinceRelease,
+    breakdown,
+    reasons
+  };
+}
 
-// 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 fetch(
-      `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/gate.ts
+var FREE_PROVIDERS = /* @__PURE__ */ new Set(["none"]);
+var FREE_PUBLISHERS = /* @__PURE__ */ new Set(["stdout", "file"]);
+function resolveLicense() {
+  const key = process.env.CULLIT_API_KEY?.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>" };
+  }
+  return { tier: "pro", valid: true };
+}
+function isProviderAllowed(provider, license) {
+  if (license.tier === "pro" && license.valid) return true;
+  return FREE_PROVIDERS.has(provider);
+}
+function isPublisherAllowed(publisherType, license) {
+  if (license.tier === "pro" && license.valid) return true;
+  return FREE_PUBLISHERS.has(publisherType);
+}
+function isEnrichmentAllowed(license) {
+  return license.tier === "pro" && license.valid;
+}
+function upgradeMessage(feature) {
+  return `\u{1F512} ${feature} requires a Cullit Pro license.
+   Get your API key at https://cullit.io/pricing
+   Then set CULLIT_API_KEY in your environment.`;
+}
 
-// 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 [];
-    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 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 fetch("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": this.apiKey
-      },
-      body: JSON.stringify({ query, variables: { id: identifier } })
-    });
-    if (!response.ok) {
-      throw new Error(`Linear API error (${response.status})`);
+// 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);
+}
+
+// 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`);
     }
-    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"
-    };
+    throw err;
+  } finally {
+    clearTimeout(timer);
   }
-};
+}
 
 // src/index.ts
+registerCollector("local", () => new GitCollector());
+registerGenerator("none", () => new TemplateGenerator());
+registerPublisher("stdout", () => new StdoutPublisher());
+registerPublisher("file", (path) => new FilePublisher(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();
+  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}"`));
+  }
+  const collectorFactory = getCollector(config.source.type);
+  if (!collectorFactory) {
+    throw new Error(
+      `Source type "${config.source.type}" is not available. ` + (config.source.type === "jira" || config.source.type === "linear" ? "Install @cullit/pro to use this source." : "Valid sources: local")
+    );
+  }
+  const sourceLabel = config.source.type === "jira" ? "issues from Jira" : config.source.type === "linear" ? "issues from Linear" : `commits between ${from}..${to}`;
+  log.info(`\xBB Collecting ${sourceLabel}`);
   let collector;
   if (config.source.type === "jira") {
     if (!config.jira) throw new Error("Jira source requires jira config in .cullit.yml");
-    console.log(`\xBB Collecting issues from Jira...`);
-    collector = new JiraCollector(config.jira);
+    collector = collectorFactory(config.jira);
   } else if (config.source.type === "linear") {
-    console.log(`\xBB Collecting issues from Linear...`);
-    collector = new LinearCollector(config.linear?.apiKey);
+    collector = collectorFactory(config.linear?.apiKey);
   } else {
-    console.log(`\xBB Collecting commits between ${from}..${to}`);
-    collector = new GitCollector();
+    collector = collectorFactory();
   }
   const diff = await collector.collect(from, to);
   const itemLabel = config.source.type === "jira" || config.source.type === "linear" ? "issues" : "commits";
-  console.log(`\xBB Found ${diff.commits.length} ${itemLabel}${diff.filesChanged ? `, ${diff.filesChanged} files changed` : ""}`);
+  log.info(`\xBB Found ${diff.commits.length} ${itemLabel}${diff.filesChanged ? `, ${diff.filesChanged} files changed` : ""}`);
   if (diff.commits.length === 0) {
     const source = config.source.type === "jira" ? "Jira" : config.source.type === "linear" ? "Linear" : `${from} and ${to}`;
     throw new Error(`No ${itemLabel} found from ${source}`);
@@ -1145,20 +663,27 @@ async function runPipeline(from, to, config, options = {}) {
   const tickets = [];
   const enrichmentSources = config.source.enrichment || [];
   for (const source of enrichmentSources) {
-    if (source === "jira" && config.jira) {
-      console.log("\xBB Enriching from Jira...");
-      const enricher = new JiraEnricher(config.jira);
-      const jiraTickets = await enricher.enrich(diff);
-      tickets.push(...jiraTickets);
-      console.log(`\xBB Jira: found ${jiraTickets.length} tickets`);
+    if (!isEnrichmentAllowed(license)) {
+      log.info(`\xBB Skipping ${source} enrichment \u2014 ${upgradeMessage(`${source} enrichment`)}`);
+      continue;
     }
-    if (source === "linear") {
-      console.log("\xBB Enriching from Linear...");
-      const enricher = new LinearEnricher(config.linear?.apiKey);
-      const linearTickets = await enricher.enrich(diff);
-      tickets.push(...linearTickets);
-      console.log(`\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}...`);
+    let enricher;
+    if (source === "jira" && config.jira) {
+      enricher = enricherFactory(config.jira);
+    } else if (source === "linear") {
+      enricher = enricherFactory(config.linear?.apiKey);
+    } else {
+      continue;
+    }
+    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 = {
@@ -1171,81 +696,101 @@ 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";
-  console.log(`\xBB Generating with ${providerName} (${modelName})...`);
-  let notes;
+  log.info(`\xBB Generating with ${providerName} (${modelName})...`);
+  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);
   }
-  console.log(`\xBB Generated ${notes.changes.length} change entries`);
+  const notes = await generator.generate(context, config.ai);
+  log.info(`\xBB Generated ${notes.changes.length} change entries`);
   const formatted = formatNotes(notes, format);
   const publishedTo = [];
   if (!options.dryRun) {
     for (const target of config.publish) {
       try {
+        if (!isPublisherAllowed(target.type, license)) {
+          log.info(`\xBB Skipping ${target.type} \u2014 ${upgradeMessage(`${target.type} publishing`)}`);
+          continue;
+        }
+        const publisherFactory = getPublisher(target.type);
+        if (!publisherFactory) {
+          log.info(`\xBB Skipping ${target.type} \u2014 install @cullit/pro to enable`);
+          continue;
+        }
+        let publisher;
         switch (target.type) {
           case "stdout":
-            await new StdoutPublisher().publish(notes, format);
-            publishedTo.push("stdout");
+            publisher = publisherFactory();
             break;
           case "file":
-            if (target.path) {
-              await new FilePublisher(target.path).publish(notes, format);
-              publishedTo.push(`file:${target.path}`);
-            }
+            if (!target.path) continue;
+            publisher = publisherFactory(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");
-            }
+            if (!target.webhookUrl) continue;
+            publisher = publisherFactory(target.webhookUrl);
             break;
           case "github-release":
-            await new GitHubReleasePublisher().publish(notes, format);
-            publishedTo.push("github-release");
+            publisher = publisherFactory();
             break;
+          default:
+            continue;
         }
+        await publisher.publish(notes, format, formatted);
+        publishedTo.push(target.type === "file" ? `file:${target.path}` : target.type);
       } catch (err) {
-        console.error(`\u2717 Failed to publish to ${target.type}: ${err.message}`);
+        log.error(`\u2717 Failed to publish to ${target.type}: ${err.message}`);
       }
     }
   } else {
-    console.log("\n[DRY RUN \u2014 Not publishing]\n");
-    console.log(formatted);
+    log.info("\n[DRY RUN \u2014 Not publishing]\n");
+    log.info(formatted);
     publishedTo.push("dry-run");
   }
   const duration = Date.now() - startTime;
-  console.log(`
+  log.info(`
 \u2713 Done in ${(duration / 1e3).toFixed(1)}s`);
   return { notes, formatted, publishedTo, duration };
 }
 export {
-  AIGenerator,
   DEFAULT_CATEGORIES,
   DEFAULT_MODELS,
-  DiscordPublisher,
   FilePublisher,
   GitCollector,
-  GitHubReleasePublisher,
-  JiraCollector,
-  JiraEnricher,
-  LinearCollector,
-  LinearEnricher,
-  SlackPublisher,
   StdoutPublisher,
   TemplateGenerator,
   VERSION,
+  analyzeReleaseReadiness,
+  createLogger,
+  fetchWithTimeout,
   formatNotes,
+  getCollector,
+  getEnricher,
+  getGenerator,
   getLatestTag,
+  getPublisher,
   getRecentTags,
-  runPipeline
+  hasCollector,
+  hasEnricher,
+  hasGenerator,
+  hasPublisher,
+  isEnrichmentAllowed,
+  isProviderAllowed,
+  isPublisherAllowed,
+  registerCollector,
+  registerEnricher,
+  registerGenerator,
+  registerPublisher,
+  resolveLicense,
+  runPipeline,
+  upgradeMessage
 };