@cullit/core 1.8.0 → 1.10.0

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.10.0";
 declare const DEFAULT_CATEGORIES: string[];
 declare const DEFAULT_MODELS: Record<string, string>;
 declare const AI_PROVIDERS: readonly ["anthropic", "openai", "gemini", "ollama", "openclaw", "none"];
@@ -159,6 +159,7 @@ declare function registerFormatter(format: string, fn: FormatterFn): void;
 declare function getFormatter(format: string): FormatterFn | undefined;
 declare function listFormatters(): string[];
 declare function formatNotes(notes: ReleaseNotes, format: OutputFormat): string;
+declare function escapeHtml(str: string): string;
 
 /**
  * Outputs release notes to stdout (default).
@@ -218,7 +219,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 +242,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 +261,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.
@@ -271,7 +282,7 @@ declare function reportUsage(project?: string): Promise<void>;
  * Core registers: git collector, template generator, stdout/file publishers.
  * Pro registers:  AI generator, Jira/Linear collectors + enrichers, Slack/Discord/GitHub publishers.
  *
- * The CLI calls `await import('@cullit/pro')` to load pro plugins if installed.
+ * Paid plugin registration is preloaded by the licensed distribution package.
  */
 
 type CollectorFactory = (...args: any[]) => Collector;
@@ -308,6 +319,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, escapeHtml, 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.10.0";
 var DEFAULT_CATEGORIES = ["features", "fixes", "breaking", "improvements", "chores"];
 var DEFAULT_MODELS = {
   anthropic: "claude-sonnet-4-20250514",
@@ -72,7 +72,8 @@ var GitCollector = class {
         { cwd: this.cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
       );
     } catch (error) {
-      const stderr = error?.stderr?.toString?.() || "";
+      const errWithStderr = typeof error === "object" && error !== null && "stderr" in error ? error : void 0;
+      const stderr = errWithStderr?.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}`
@@ -417,12 +418,15 @@ function formatNotes(notes, format) {
   const fn = formatters.get(format) || formatters.get("markdown");
   return fn(notes);
 }
+function sanitizeForMarkdown(text) {
+  return escapeHtml(text).replace(/\r?\n/g, " ");
+}
 function formatMarkdown(notes) {
   const lines = [];
-  lines.push(`## ${notes.version} \u2014 ${notes.date}`);
+  lines.push(`## ${sanitizeForMarkdown(notes.version)} \u2014 ${sanitizeForMarkdown(notes.date)}`);
   lines.push("");
   if (notes.summary) {
-    lines.push(notes.summary);
+    lines.push(sanitizeForMarkdown(notes.summary));
     lines.push("");
   }
   const grouped = groupByCategory(notes);
@@ -432,8 +436,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 = `- ${sanitizeForMarkdown(entry.description)}`;
+      if (entry.ticketKey) line += ` (${sanitizeForMarkdown(entry.ticketKey)})`;
       lines.push(line);
     }
     lines.push("");
@@ -441,7 +445,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) => `@${sanitizeForMarkdown(c)}`).join(", "));
     lines.push("");
   }
   if (notes.metadata) {
@@ -713,6 +717,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 +755,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
       };
@@ -768,19 +773,22 @@ async function validateLicense() {
     if (cachedValidation && cachedValidation.key === key) {
       return cachedValidation.status;
     }
-    return { tier: "pro", valid: true, message: "Offline validation \u2014 using cached license." };
+    return { tier: "free", valid: true, message: "License validation unavailable offline. Run while connected to activate your Pro license." };
   }
 }
 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 +796,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,13 +911,77 @@ 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) {
-    throw new Error(license.message || "Invalid CULLIT_API_KEY");
+    if (!isProviderAllowed(config.ai.provider, license)) {
+      throw new Error(license.message || "Invalid CULLIT_API_KEY");
+    }
+    log.warn(`\u26A0 ${license.message || "Invalid CULLIT_API_KEY \u2014 running in free mode."}`);
   }
   if (!isProviderAllowed(config.ai.provider, license)) {
     throw new Error(upgradeMessage(`AI provider "${config.ai.provider}"`));
@@ -894,7 +989,7 @@ async function runPipeline(from, to, config, options = {}) {
   const collectorFactory = getCollector(config.source.type);
   if (!collectorFactory) {
     throw new Error(
-      `Source type "${config.source.type}" is not available. ` + (config.source.type !== "local" ? "Install @cullit/pro to use this source." : "Valid sources: local")
+      `Source type "${config.source.type}" is not available. ` + (config.source.type !== "local" ? "Install @cullit/licensed (private distribution) to use this source." : "Valid sources: local")
     );
   }
   const sourceLabel = config.source.type === "local" ? `commits between ${from}..${to}` : `items from ${config.source.type}`;
@@ -916,7 +1011,7 @@ async function runPipeline(from, to, config, options = {}) {
     }
     const enricherFactory = getEnricher(source);
     if (!enricherFactory) {
-      log.info(`\xBB Skipping ${source} enrichment \u2014 install @cullit/pro to enable`);
+      log.info(`\xBB Skipping ${source} enrichment \u2014 install @cullit/licensed to enable`);
       continue;
     }
     log.info(`\xBB Enriching from ${source}...`);
@@ -940,7 +1035,7 @@ async function runPipeline(from, to, config, options = {}) {
   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." : "")
+      `AI provider "${config.ai.provider}" is not available. ` + (config.ai.provider !== "none" ? "Install @cullit/licensed (private distribution) to use AI providers." : "")
     );
   }
   let generator;
@@ -951,8 +1046,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 {
@@ -962,11 +1065,40 @@ async function runPipeline(from, to, config, options = {}) {
         }
         const publisherFactory = getPublisher(target.type);
         if (!publisherFactory) {
-          log.info(`\xBB Skipping ${target.type} \u2014 install @cullit/pro to enable`);
+          log.info(`\xBB Skipping ${target.type} \u2014 install @cullit/licensed to enable`);
           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 +1112,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,
@@ -1001,10 +1133,12 @@ export {
   VERSION,
   analyzeReleaseReadiness,
   createLogger,
+  escapeHtml,
   fetchWithTimeout,
   formatNotes,
   getCollector,
   getEnricher,
+  getFeatureGating,
   getFormatter,
   getGenerator,
   getLatestTag,
@@ -1016,6 +1150,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.10.0",
   "type": "module",
   "description": "Core engine for Cullit — AI-powered release note generation.",
   "license": "MIT",
@@ -16,6 +16,10 @@
     "ai",
     "automation"
   ],
+  "homepage": "https://cullit.io",
+  "bugs": {
+    "url": "https://github.com/mttaylor/cullit/issues"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -28,10 +32,13 @@
     "dist"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@cullit/config": "1.8.0"
+    "@cullit/config": "1.10.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean",