@cullit/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1251 @@
+// src/constants.ts
+var VERSION = "0.1.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"
+};
+
+// src/collectors/git.ts
+import { execSync } from "child_process";
+var GitCollector = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  async collect(from, to) {
+    const log = this.getLog(from, to);
+    const commits = this.parseLog(log);
+    return {
+      from,
+      to,
+      commits,
+      filesChanged: this.getFilesChanged(from, to)
+    };
+  }
+  getLog(from, to) {
+    const format = "%H|%h|%an|%aI|%s|%b";
+    const separator = "---CULLIT_COMMIT---";
+    try {
+      return execSync(
+        `git log ${from}..${to} --format="${format}${separator}" --no-merges`,
+        { cwd: this.cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+      );
+    } catch (error) {
+      const stderr = error?.stderr?.toString?.() || "";
+      const hint = stderr.includes("unknown revision") ? 'Check that both refs exist (run "cullit tags" to see tags).' : stderr.includes("not a git repository") ? "Run this command inside a git repository." : `Make sure both refs exist and you're in a git repository.`;
+      throw new Error(
+        `Failed to read git log between ${from} and ${to}. ${hint}`
+      );
+    }
+  }
+  parseLog(log) {
+    if (!log.trim()) return [];
+    const separator = "---CULLIT_COMMIT---";
+    const entries = log.split(separator).filter((e) => e.trim());
+    return entries.map((entry) => {
+      const parts = entry.trim().split("|");
+      const [hash, shortHash, author, date, message, ...bodyParts] = parts;
+      const body = bodyParts.join("|").trim() || void 0;
+      const fullMessage = body ? `${message}
+${body}` : message;
+      return {
+        hash: hash.trim(),
+        shortHash: shortHash.trim(),
+        author: author.trim(),
+        date: date.trim(),
+        message: message.trim(),
+        body,
+        prNumber: this.extractPRNumber(fullMessage),
+        issueKeys: this.extractIssueKeys(fullMessage)
+      };
+    });
+  }
+  /**
+   * Extracts PR number from commit messages.
+   * Matches patterns like: (#123), Merge pull request #123, PR #123
+   */
+  extractPRNumber(message) {
+    const patterns = [
+      /\(#(\d+)\)/,
+      // (#123)
+      /Merge pull request #(\d+)/i,
+      // Merge pull request #123
+      /PR\s*#(\d+)/i
+      // PR #123
+    ];
+    for (const pattern of patterns) {
+      const match = message.match(pattern);
+      if (match) return parseInt(match[1], 10);
+    }
+    return void 0;
+  }
+  /**
+   * Extracts issue keys from commit messages.
+   * Matches patterns like: PROJ-123, FIX-456, LIN-789
+   */
+  extractIssueKeys(message) {
+    const pattern = /\b([A-Z][A-Z0-9]+-\d+)\b/g;
+    const matches = message.match(pattern);
+    return matches ? [...new Set(matches)] : [];
+  }
+  getFilesChanged(from, to) {
+    try {
+      const output = execSync(
+        `git diff --shortstat ${from}..${to}`,
+        { cwd: this.cwd, encoding: "utf-8" }
+      );
+      const match = output.match(/(\d+) files? changed/);
+      return match ? parseInt(match[1], 10) : 0;
+    } catch {
+      return 0;
+    }
+  }
+};
+function getRecentTags(cwd = process.cwd(), count = 10) {
+  try {
+    const output = execSync(
+      `git tag --sort=-v:refname`,
+      { cwd, encoding: "utf-8" }
+    );
+    return output.trim().split("\n").filter(Boolean).slice(0, count);
+  } catch {
+    return [];
+  }
+}
+function getLatestTag(cwd = process.cwd()) {
+  try {
+    return execSync("git describe --tags --abbrev=0", { cwd, encoding: "utf-8" }).trim();
+  } catch {
+    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]
+    }));
+    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"
+    };
+    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) {
+    const { diff, tickets } = context;
+    const changes = [];
+    const ticketMap = new Map(tickets.map((t) => [t.key, t]));
+    for (const commit of diff.commits) {
+      const category = this.categorize(commit.message, commit.issueKeys, ticketMap);
+      const description = this.cleanMessage(commit.message);
+      if (this.isTrivial(description)) continue;
+      changes.push({
+        description,
+        category,
+        ticketKey: commit.issueKeys?.[0],
+        commits: [commit.shortHash]
+      });
+    }
+    const deduped = this.deduplicateByTicket(changes);
+    const categoryOrder = ["breaking", "features", "improvements", "fixes", "chores", "other"];
+    deduped.sort((a, b) => categoryOrder.indexOf(a.category) - categoryOrder.indexOf(b.category));
+    const contributors = [...new Set(diff.commits.map((c) => c.author))];
+    return {
+      version: diff.to,
+      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      summary: this.buildSummary(deduped, diff.commits.length),
+      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",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  categorize(message, issueKeys, ticketMap) {
+    const lower = message.toLowerCase();
+    if (/^(feat|feature)[(!:]/.test(lower)) return "features";
+    if (/^fix[(!:]/.test(lower)) return "fixes";
+    if (/^breaking[ -]?change/i.test(lower) || lower.includes("!:")) return "breaking";
+    if (/^(refactor|perf|improve)[(!:]/.test(lower)) return "improvements";
+    if (/^(chore|ci|build|docs|style|test)[(!:]/.test(lower)) return "chores";
+    if (issueKeys?.length) {
+      for (const key of issueKeys) {
+        const ticket = ticketMap.get(key);
+        if (ticket?.type) {
+          if (["bug", "bugfix", "defect"].includes(ticket.type)) return "fixes";
+          if (["feature", "story", "enhancement"].includes(ticket.type)) return "features";
+          if (["improvement", "refactor"].includes(ticket.type)) return "improvements";
+          if (["task", "chore", "sub-task"].includes(ticket.type)) return "chores";
+        }
+      }
+    }
+    if (/\b(add|new|implement|introduce|create)\b/i.test(lower)) return "features";
+    if (/\b(fix|resolve|patch|correct|repair)\b/i.test(lower)) return "fixes";
+    if (/\b(update|improve|optimize|enhance|refactor)\b/i.test(lower)) return "improvements";
+    if (/\b(remove|delete|deprecate|drop)\b/i.test(lower)) return "chores";
+    return "other";
+  }
+  cleanMessage(message) {
+    let cleaned = message.replace(/^(feat|fix|chore|docs|style|refactor|perf|test|ci|build|breaking change)(\(.+?\))?[!]?:\s*/i, "");
+    cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+    cleaned = cleaned.replace(/\.$/, "");
+    return cleaned;
+  }
+  isTrivial(description) {
+    const trivialPatterns = [
+      /^merge\b/i,
+      /^wip\b/i,
+      /^typo\b/i,
+      /^formatting\b/i,
+      /^lint\b/i,
+      /^whitespace\b/i,
+      /^bump version/i
+    ];
+    return trivialPatterns.some((p) => p.test(description));
+  }
+  deduplicateByTicket(changes) {
+    const seen = /* @__PURE__ */ new Map();
+    const result = [];
+    for (const change of changes) {
+      if (change.ticketKey && seen.has(change.ticketKey)) {
+        const existing = seen.get(change.ticketKey);
+        if (change.commits) {
+          existing.commits = [...existing.commits || [], ...change.commits];
+        }
+      } else {
+        if (change.ticketKey) seen.set(change.ticketKey, change);
+        result.push(change);
+      }
+    }
+    return result;
+  }
+  buildSummary(changes, commitCount) {
+    const counts = {};
+    for (const c of changes) {
+      counts[c.category] = (counts[c.category] || 0) + 1;
+    }
+    const parts = [];
+    if (counts["breaking"]) parts.push(`${counts["breaking"]} breaking change${counts["breaking"] > 1 ? "s" : ""}`);
+    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;
+  }
+};
+
+// src/formatter.ts
+var CATEGORY_LABELS = {
+  features: "\u2728 Features",
+  fixes: "\u{1F41B} Bug Fixes",
+  breaking: "\u26A0\uFE0F Breaking Changes",
+  improvements: "\u{1F527} Improvements",
+  chores: "\u{1F9F9} Chores",
+  other: "\u{1F4DD} Other"
+};
+var CATEGORY_ORDER = [
+  "breaking",
+  "features",
+  "improvements",
+  "fixes",
+  "chores",
+  "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);
+  }
+}
+function formatMarkdown(notes) {
+  const lines = [];
+  lines.push(`## ${notes.version} \u2014 ${notes.date}`);
+  lines.push("");
+  if (notes.summary) {
+    lines.push(notes.summary);
+    lines.push("");
+  }
+  const grouped = groupByCategory(notes);
+  for (const category of CATEGORY_ORDER) {
+    const entries = grouped.get(category);
+    if (!entries?.length) continue;
+    lines.push(`### ${CATEGORY_LABELS[category]}`);
+    lines.push("");
+    for (const entry of entries) {
+      let line = `- ${entry.description}`;
+      if (entry.ticketKey) line += ` (${entry.ticketKey})`;
+      lines.push(line);
+    }
+    lines.push("");
+  }
+  if (notes.contributors?.length) {
+    lines.push("### Contributors");
+    lines.push("");
+    lines.push(notes.contributors.map((c) => `@${c}`).join(", "));
+    lines.push("");
+  }
+  if (notes.metadata) {
+    lines.push("---");
+    lines.push(`*Generated by [Cull](https://cullit.io) \u2022 ${notes.metadata.commitCount} commits, ${notes.metadata.prCount} PRs*`);
+  }
+  return lines.join("\n");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function formatHTML(notes) {
+  const grouped = groupByCategory(notes);
+  let html = `<div class="cull-release">`;
+  html += `<h2>${escapeHtml(notes.version)} \u2014 ${escapeHtml(notes.date)}</h2>`;
+  if (notes.summary) {
+    html += `<p class="summary">${escapeHtml(notes.summary)}</p>`;
+  }
+  for (const category of CATEGORY_ORDER) {
+    const entries = grouped.get(category);
+    if (!entries?.length) continue;
+    html += `<h3>${CATEGORY_LABELS[category]}</h3><ul>`;
+    for (const entry of entries) {
+      html += `<li>${escapeHtml(entry.description)}`;
+      if (entry.ticketKey) html += ` <code>${escapeHtml(entry.ticketKey)}</code>`;
+      html += `</li>`;
+    }
+    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 += `</div>`;
+  return html;
+}
+function groupByCategory(notes) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of notes.changes) {
+    const existing = grouped.get(entry.category) || [];
+    existing.push(entry);
+    grouped.set(entry.category, existing);
+  }
+  return grouped;
+}
+
+// src/publishers/index.ts
+import { writeFileSync } from "fs";
+var StdoutPublisher = class {
+  async publish(notes, format) {
+    const formatted = formatNotes(notes, format);
+    console.log(formatted);
+  }
+};
+var FilePublisher = class {
+  constructor(path) {
+    this.path = path;
+  }
+  async publish(notes, format) {
+    const formatted = formatNotes(notes, format);
+    writeFileSync(this.path, formatted, "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}`);
+    }
+  }
+  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;
+  }
+  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}`);
+    }
+  }
+  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}`);
+    }
+  }
+  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 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/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})`);
+    }
+    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/index.ts
+async function runPipeline(from, to, config, options = {}) {
+  const startTime = Date.now();
+  const format = options.format || "markdown";
+  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);
+  } else if (config.source.type === "linear") {
+    console.log(`\xBB Collecting issues from Linear...`);
+    collector = new LinearCollector(config.linear?.apiKey);
+  } else {
+    console.log(`\xBB Collecting commits between ${from}..${to}`);
+    collector = new GitCollector();
+  }
+  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` : ""}`);
+  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}`);
+  }
+  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 (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 context = { diff, tickets };
+  const providerNames = {
+    anthropic: "Claude",
+    openai: "OpenAI",
+    gemini: "Gemini",
+    ollama: "Ollama",
+    openclaw: "OpenClaw",
+    none: "Template"
+  };
+  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;
+  if (config.ai.provider === "none") {
+    const generator = new TemplateGenerator();
+    notes = await generator.generate(context, config.ai);
+  } else {
+    const generator = new AIGenerator(config.openclaw);
+    notes = await generator.generate(context, config.ai);
+  }
+  console.log(`\xBB Generated ${notes.changes.length} change entries`);
+  const formatted = formatNotes(notes, format);
+  const publishedTo = [];
+  if (!options.dryRun) {
+    for (const target of config.publish) {
+      try {
+        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;
+        }
+      } catch (err) {
+        console.error(`\u2717 Failed to publish to ${target.type}: ${err.message}`);
+      }
+    }
+  } else {
+    console.log("\n[DRY RUN \u2014 Not publishing]\n");
+    console.log(formatted);
+    publishedTo.push("dry-run");
+  }
+  const duration = Date.now() - startTime;
+  console.log(`
+\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,
+  formatNotes,
+  getLatestTag,
+  getRecentTags,
+  runPipeline
+};