@cullit/core 1.8.0 → 1.9.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { EnrichmentType, OutputFormat, AIConfig, RepoSource, CullConfig } from '@cullit/config';
-export { AIConfig, AIProvider, Audience, BitbucketConfig, ConfluenceConfig, CullConfig, EnrichmentType, GitLabConfig, JiraConfig, LinearConfig, NotionConfig, OpenClawConfig, OutputFormat, PublishTarget, PublisherType, RepoSource, SourceConfig, Tone } from '@cullit/config';
+export { AIConfig, AIProvider, Audience, BitbucketConfig, ConfluenceConfig, CullConfig, EnrichmentType, GitLabConfig, JiraConfig, LinearConfig, NotionConfig, OpenClawConfig, OutputFormat, PublishTarget, PublisherType, RepoSource, SourceConfig, TemplateConfig, TemplateProfile, Tone } from '@cullit/config';
 
 interface GitCommit {
     hash: string;
@@ -71,7 +71,7 @@ interface PipelineResult {
     duration: number;
 }
 
-declare const VERSION = "1.8.0";
+declare const VERSION = "1.9.2";
 declare const DEFAULT_CATEGORIES: string[];
 declare const DEFAULT_MODELS: Record<string, string>;
 declare const AI_PROVIDERS: readonly ["anthropic", "openai", "gemini", "ollama", "openclaw", "none"];
@@ -218,7 +218,7 @@ declare function analyzeReleaseReadiness(cwd?: string): ReleaseAdvisory;
  * validateLicense() performs async remote validation with caching.
  * resolveLicense() remains sync for quick format-only checks (display).
  */
-type LicenseTier = 'free' | 'pro';
+type LicenseTier = 'free' | 'pro' | 'team' | 'enterprise';
 interface LicenseStatus {
     tier: LicenseTier;
     valid: boolean;
@@ -241,6 +241,7 @@ declare function validateLicense(): Promise<LicenseStatus>;
 declare function isProviderAllowed(provider: string, license: LicenseStatus): boolean;
 /**
  * Check whether the current license allows the requested publisher.
+ * Confluence, Notion, and Teams require Team tier or above.
  */
 declare function isPublisherAllowed(publisherType: string, license: LicenseStatus): boolean;
 /**
@@ -259,6 +260,15 @@ interface UsageLimits {
  * Get usage limits for a license tier.
  */
 declare function getTierLimits(tier: string): UsageLimits;
+type TeamFeature = 'drafts' | 'approvals' | 'shared_history' | 'project_templates' | 'hosted_changelog' | 'branded_widget' | 'team_publishers' | 'org_settings' | 'audit_logs' | 'sso';
+/**
+ * Check whether a license tier grants access to a Team/Enterprise feature.
+ */
+declare function isFeatureAllowed(feature: TeamFeature, tier: string): boolean;
+/**
+ * Build a gating summary for a tier — which features are unlocked.
+ */
+declare function getFeatureGating(tier: string): Record<TeamFeature, boolean>;
 /**
  * Report a generation event to the metering service.
  * Non-blocking — failures are logged but never block the pipeline.
@@ -308,6 +318,7 @@ declare function runPipeline(from: string, to: string, config: CullConfig, optio
     format?: OutputFormat;
     dryRun?: boolean;
     logger?: Logger;
+    templateProfile?: string;
 }): Promise<PipelineResult>;
 
-export { AI_PROVIDERS, AUDIENCES, CHANGE_CATEGORIES, type ChangeCategory, type ChangeEntry, type Collector, type CollectorFactory, DEFAULT_CATEGORIES, DEFAULT_MODELS, ENRICHMENT_TYPES, type EnrichedContext, type EnrichedTicket, type Enricher, type EnricherFactory, FilePublisher, type Generator, type GeneratorFactory, GitCollector, type GitCommit, type GitDiff, type LicenseStatus, type LicenseTier, type LogLevel, type Logger, MultiRepoCollector, OUTPUT_FORMATS, PUBLISHER_TYPES, type PipelineResult, type Publisher, type PublisherFactory, type ReleaseAdvisory, type ReleaseNotes, SOURCE_TYPES, type SemverBump, StdoutPublisher, TONES, TemplateGenerator, type UsageLimits, VERSION, analyzeReleaseReadiness, createLogger, fetchWithTimeout, formatNotes, getCollector, getEnricher, getFormatter, getGenerator, getLatestTag, getPublisher, getRecentTags, getTierLimits, hasCollector, hasEnricher, hasGenerator, hasPublisher, isEnrichmentAllowed, isProviderAllowed, isPublisherAllowed, listCollectors, listEnrichers, listFormatters, listGenerators, listPublishers, registerCollector, registerEnricher, registerFormatter, registerGenerator, registerPublisher, reportUsage, resolveLicense, runPipeline, upgradeMessage, validateLicense };
+export { AI_PROVIDERS, AUDIENCES, CHANGE_CATEGORIES, type ChangeCategory, type ChangeEntry, type Collector, type CollectorFactory, DEFAULT_CATEGORIES, DEFAULT_MODELS, ENRICHMENT_TYPES, type EnrichedContext, type EnrichedTicket, type Enricher, type EnricherFactory, FilePublisher, type Generator, type GeneratorFactory, GitCollector, type GitCommit, type GitDiff, type LicenseStatus, type LicenseTier, type LogLevel, type Logger, MultiRepoCollector, OUTPUT_FORMATS, PUBLISHER_TYPES, type PipelineResult, type Publisher, type PublisherFactory, type ReleaseAdvisory, type ReleaseNotes, SOURCE_TYPES, type SemverBump, StdoutPublisher, TONES, type TeamFeature, TemplateGenerator, type UsageLimits, VERSION, analyzeReleaseReadiness, createLogger, fetchWithTimeout, formatNotes, getCollector, getEnricher, getFeatureGating, getFormatter, getGenerator, getLatestTag, getPublisher, getRecentTags, getTierLimits, hasCollector, hasEnricher, hasGenerator, hasPublisher, isEnrichmentAllowed, isFeatureAllowed, isProviderAllowed, isPublisherAllowed, listCollectors, listEnrichers, listFormatters, listGenerators, listPublishers, registerCollector, registerEnricher, registerFormatter, registerGenerator, registerPublisher, reportUsage, resolveLicense, runPipeline, upgradeMessage, validateLicense };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/constants.ts
-var VERSION = "1.8.0";
+var VERSION = "1.9.2";
 var DEFAULT_CATEGORIES = ["features", "fixes", "breaking", "improvements", "chores"];
 var DEFAULT_MODELS = {
   anthropic: "claude-sonnet-4-20250514",
@@ -417,12 +417,15 @@ function formatNotes(notes, format) {
   const fn = formatters.get(format) || formatters.get("markdown");
   return fn(notes);
 }
+function escapeMarkdown(text) {
+  return escapeHtml(text).replace(/\r?\n/g, " ");
+}
 function formatMarkdown(notes) {
   const lines = [];
-  lines.push(`## ${notes.version} \u2014 ${notes.date}`);
+  lines.push(`## ${escapeMarkdown(notes.version)} \u2014 ${escapeMarkdown(notes.date)}`);
   lines.push("");
   if (notes.summary) {
-    lines.push(notes.summary);
+    lines.push(escapeMarkdown(notes.summary));
     lines.push("");
   }
   const grouped = groupByCategory(notes);
@@ -432,8 +435,8 @@ function formatMarkdown(notes) {
     lines.push(`### ${CATEGORY_LABELS[category]}`);
     lines.push("");
     for (const entry of entries) {
-      let line = `- ${entry.description}`;
-      if (entry.ticketKey) line += ` (${entry.ticketKey})`;
+      let line = `- ${escapeMarkdown(entry.description)}`;
+      if (entry.ticketKey) line += ` (${escapeMarkdown(entry.ticketKey)})`;
       lines.push(line);
     }
     lines.push("");
@@ -441,7 +444,7 @@ function formatMarkdown(notes) {
   if (notes.contributors?.length) {
     lines.push("### Contributors");
     lines.push("");
-    lines.push(notes.contributors.map((c) => `@${c}`).join(", "));
+    lines.push(notes.contributors.map((c) => `@${escapeMarkdown(c)}`).join(", "));
     lines.push("");
   }
   if (notes.metadata) {
@@ -713,6 +716,7 @@ async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT) {
 // src/gate.ts
 var FREE_PROVIDERS = /* @__PURE__ */ new Set(["none"]);
 var FREE_PUBLISHERS = /* @__PURE__ */ new Set(["stdout", "file"]);
+var TEAM_ONLY_PUBLISHERS = /* @__PURE__ */ new Set(["confluence", "notion", "teams"]);
 var LICENSE_CACHE_TTL = 24 * 60 * 60 * 1e3;
 var LICENSE_FAILURE_CACHE_TTL = 5 * 60 * 1e3;
 var cachedValidation = null;
@@ -750,7 +754,7 @@ async function validateLicense() {
     if (res.ok) {
       const data = await res.json();
       const status2 = {
-        tier: data.tier === "pro" ? "pro" : "free",
+        tier: data.tier === "team" || data.tier === "enterprise" ? data.tier : data.tier === "pro" ? "pro" : "free",
         valid: data.valid !== false,
         message: data.message
       };
@@ -772,15 +776,18 @@ async function validateLicense() {
   }
 }
 function isProviderAllowed(provider, license) {
-  if (license.tier === "pro" && license.valid) return true;
+  if (license.tier !== "free" && license.valid) return true;
   return FREE_PROVIDERS.has(provider);
 }
 function isPublisherAllowed(publisherType, license) {
-  if (license.tier === "pro" && license.valid) return true;
+  if (TEAM_ONLY_PUBLISHERS.has(publisherType)) {
+    return (license.tier === "team" || license.tier === "enterprise") && license.valid;
+  }
+  if (license.tier !== "free" && license.valid) return true;
   return FREE_PUBLISHERS.has(publisherType);
 }
 function isEnrichmentAllowed(license) {
-  return license.tier === "pro" && license.valid;
+  return license.tier !== "free" && license.valid;
 }
 function upgradeMessage(feature) {
   return `\u{1F512} ${feature} requires a Cullit Pro license.
@@ -788,14 +795,37 @@ function upgradeMessage(feature) {
    Then set CULLIT_API_KEY in your environment.`;
 }
 var TIER_LIMITS = {
-  free: { generationsPerMonth: 3, maxProjects: 1 },
-  pro: { generationsPerMonth: 500, maxProjects: 5 },
-  team: { generationsPerMonth: 2e3, maxProjects: 25 },
+  free: { generationsPerMonth: 5, maxProjects: 3 },
+  pro: { generationsPerMonth: 500, maxProjects: 100 },
+  team: { generationsPerMonth: 2e3, maxProjects: 250 },
   enterprise: { generationsPerMonth: Infinity, maxProjects: Infinity }
 };
 function getTierLimits(tier) {
   return TIER_LIMITS[tier] || TIER_LIMITS.free;
 }
+var FEATURE_TIERS = {
+  drafts: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  approvals: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  shared_history: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  project_templates: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  hosted_changelog: /* @__PURE__ */ new Set(["pro", "team", "enterprise"]),
+  branded_widget: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  team_publishers: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  org_settings: /* @__PURE__ */ new Set(["team", "enterprise"]),
+  audit_logs: /* @__PURE__ */ new Set(["enterprise"]),
+  sso: /* @__PURE__ */ new Set(["enterprise"])
+};
+function isFeatureAllowed(feature, tier) {
+  const allowed = FEATURE_TIERS[feature];
+  return allowed ? allowed.has(tier) : false;
+}
+function getFeatureGating(tier) {
+  const result = {};
+  for (const feature of Object.keys(FEATURE_TIERS)) {
+    result[feature] = isFeatureAllowed(feature, tier);
+  }
+  return result;
+}
 async function reportUsage(project = "default") {
   const key = process.env.CULLIT_API_KEY?.trim();
   const meterUrl = process.env.CULLIT_METER_URL?.trim();
@@ -880,9 +910,70 @@ registerCollector("multi-repo", (config) => {
 registerGenerator("none", () => new TemplateGenerator());
 registerPublisher("stdout", (_target) => new StdoutPublisher());
 registerPublisher("file", (target) => new FilePublisher(target.path));
+function normalizeSectionOrder(value) {
+  if (!Array.isArray(value)) return void 0;
+  const order = value.filter((v) => typeof v === "string").map((v) => v.trim()).filter(Boolean);
+  return order.length ? order : void 0;
+}
+function toResolvedTemplate(profile) {
+  if (!profile) return {};
+  const p = profile;
+  return {
+    format: typeof p.format === "string" ? p.format : void 0,
+    sectionOrder: normalizeSectionOrder(p.sectionOrder),
+    includeContributors: typeof p.includeContributors === "boolean" ? p.includeContributors : void 0,
+    includeMetadata: typeof p.includeMetadata === "boolean" ? p.includeMetadata : void 0,
+    summaryPrefix: typeof p.summaryPrefix === "string" ? p.summaryPrefix : void 0
+  };
+}
+function mergeTemplates(...templates) {
+  const merged = {};
+  for (const template of templates) {
+    if (!template) continue;
+    if (template.name) merged.name = template.name;
+    if (template.format) merged.format = template.format;
+    if (template.sectionOrder) merged.sectionOrder = template.sectionOrder;
+    if (typeof template.includeContributors === "boolean") merged.includeContributors = template.includeContributors;
+    if (typeof template.includeMetadata === "boolean") merged.includeMetadata = template.includeMetadata;
+    if (typeof template.summaryPrefix === "string") merged.summaryPrefix = template.summaryPrefix;
+  }
+  return merged;
+}
+function getTemplateProfileByName(config, name) {
+  if (!name) return void 0;
+  const profile = config.templates?.find((t) => t.name === name);
+  if (!profile) return void 0;
+  return { name, ...toResolvedTemplate(profile) };
+}
+function applyTemplateToNotes(notes, template) {
+  const next = {
+    ...notes,
+    changes: [...notes.changes]
+  };
+  if (template.sectionOrder?.length) {
+    const index = /* @__PURE__ */ new Map();
+    template.sectionOrder.forEach((category, i) => index.set(category, i));
+    next.changes = next.changes.map((change, i) => ({ change, i })).sort((a, b) => {
+      const ai = index.has(a.change.category) ? index.get(a.change.category) : Number.MAX_SAFE_INTEGER;
+      const bi = index.has(b.change.category) ? index.get(b.change.category) : Number.MAX_SAFE_INTEGER;
+      if (ai !== bi) return ai - bi;
+      return a.i - b.i;
+    }).map(({ change }) => change);
+  }
+  if (template.summaryPrefix) {
+    const currentSummary = next.summary || "";
+    next.summary = `${template.summaryPrefix}${currentSummary ? ` ${currentSummary}` : ""}`.trim();
+  }
+  if (template.includeContributors === false) {
+    delete next.contributors;
+  }
+  if (template.includeMetadata === false) {
+    delete next.metadata;
+  }
+  return next;
+}
 async function runPipeline(from, to, config, options = {}) {
   const startTime = Date.now();
-  const format = options.format || "markdown";
   const log = options.logger || createLogger("normal");
   const license = await validateLicense();
   if (!license.valid) {
@@ -951,8 +1042,16 @@ async function runPipeline(from, to, config, options = {}) {
   }
   const notes = await generator.generate(context, config.ai);
   log.info(`\xBB Generated ${notes.changes.length} change entries`);
-  const formatted = formatNotes(notes, format);
+  const selectedTemplateName = options.templateProfile || config.template?.default;
+  const baseTemplate = mergeTemplates(
+    toResolvedTemplate(config.template),
+    getTemplateProfileByName(config, selectedTemplateName)
+  );
+  const format = options.format || baseTemplate.format || "markdown";
+  const templatedNotes = applyTemplateToNotes(notes, baseTemplate);
+  const formatted = formatNotes(templatedNotes, format);
   const publishedTo = [];
+  const renderedCache = /* @__PURE__ */ new Map();
   if (!options.dryRun) {
     for (const target of config.publish) {
       try {
@@ -966,7 +1065,36 @@ async function runPipeline(from, to, config, options = {}) {
           continue;
         }
         const publisher = publisherFactory(target);
-        await publisher.publish(notes, format, formatted);
+        const targetTemplate = mergeTemplates(
+          baseTemplate,
+          getTemplateProfileByName(config, typeof target.templateProfile === "string" ? target.templateProfile : void 0),
+          {
+            format: typeof target.format === "string" ? target.format : void 0,
+            sectionOrder: normalizeSectionOrder(target.sectionOrder)
+          }
+        );
+        const targetFormat = targetTemplate.format || format;
+        const cacheKey = JSON.stringify({
+          f: targetFormat,
+          o: targetTemplate.sectionOrder || null,
+          c: targetTemplate.includeContributors,
+          m: targetTemplate.includeMetadata,
+          s: targetTemplate.summaryPrefix
+        });
+        let cached = renderedCache.get(cacheKey);
+        if (!cached) {
+          const targetNotes = applyTemplateToNotes(notes, targetTemplate);
+          const targetOutput = cacheKey === JSON.stringify({
+            f: format,
+            o: baseTemplate.sectionOrder || null,
+            c: baseTemplate.includeContributors,
+            m: baseTemplate.includeMetadata,
+            s: baseTemplate.summaryPrefix
+          }) ? formatted : formatNotes(targetNotes, targetFormat);
+          cached = { notes: targetNotes, output: targetOutput, format: targetFormat };
+          renderedCache.set(cacheKey, cached);
+        }
+        await publisher.publish(cached.notes, cached.format, cached.output);
         publishedTo.push(target.type === "file" ? `file:${target.path}` : target.type);
       } catch (err) {
         log.error(`\u2717 Failed to publish to ${target.type}: ${err.message}`);
@@ -980,7 +1108,7 @@ async function runPipeline(from, to, config, options = {}) {
   const duration = Date.now() - startTime;
   log.info(`
 \u2713 Done in ${(duration / 1e3).toFixed(1)}s`);
-  return { notes, formatted, publishedTo, duration };
+  return { notes: templatedNotes, formatted, publishedTo, duration };
 }
 export {
   AI_PROVIDERS,
@@ -1005,6 +1133,7 @@ export {
   formatNotes,
   getCollector,
   getEnricher,
+  getFeatureGating,
   getFormatter,
   getGenerator,
   getLatestTag,
@@ -1016,6 +1145,7 @@ export {
   hasGenerator,
   hasPublisher,
   isEnrichmentAllowed,
+  isFeatureAllowed,
   isProviderAllowed,
   isPublisherAllowed,
   listCollectors,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cullit/core",
-  "version": "1.8.0",
+  "version": "1.9.2",
   "type": "module",
   "description": "Core engine for Cullit — AI-powered release note generation.",
   "license": "MIT",
@@ -31,7 +31,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@cullit/config": "1.8.0"
+    "@cullit/config": "1.9.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean",