@theihtisham/ai-release-notes 1.0.0

package/src/rate-limiter.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const logger = require('./logger');
+
+/**
+ * Simple rate limiter for API calls.
+ * Tracks calls per time window and enforces delays when approaching limits.
+ */
+class RateLimiter {
+  constructor(options = {}) {
+    this.maxRequests = options.maxRequests || 60;
+    this.windowMs = options.windowMs || 60 * 1000; // 1 minute
+    this.minDelay = options.minDelay || 100; // 100ms between calls
+    this.calls = [];
+  }
+
+  /**
+   * Wait before making the next API call if needed.
+   * Call this before each API request.
+   */
+  async wait() {
+    const now = Date.now();
+
+    // Clean up old calls outside the window
+    this.calls = this.calls.filter(time => now - time < this.windowMs);
+
+    // If at limit, wait until oldest call expires
+    if (this.calls.length >= this.maxRequests) {
+      const oldestCall = this.calls[0];
+      const waitTime = this.windowMs - (now - oldestCall) + 100;
+      if (waitTime > 0) {
+        logger.debug(`Rate limit approaching — waiting ${waitTime}ms`);
+        await this.sleep(waitTime);
+      }
+      // Clean again after waiting
+      this.calls = this.calls.filter(time => Date.now() - time < this.windowMs);
+    }
+
+    // Enforce minimum delay between calls
+    if (this.calls.length > 0) {
+      const lastCall = this.calls[this.calls.length - 1];
+      const elapsed = Date.now() - lastCall;
+      if (elapsed < this.minDelay) {
+        await this.sleep(this.minDelay - elapsed);
+      }
+    }
+
+    // Record this call
+    this.calls.push(Date.now());
+  }
+
+  /**
+   * Get the number of calls made in the current window.
+   */
+  getCallCount() {
+    const now = Date.now();
+    this.calls = this.calls.filter(time => now - time < this.windowMs);
+    return this.calls.length;
+  }
+
+  /**
+   * Reset the rate limiter.
+   */
+  reset() {
+    this.calls = [];
+  }
+
+  /**
+   * Sleep for a given number of milliseconds.
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Create a rate limiter configured for GitHub API.
+ * GitHub allows ~60 requests per minute for unauthenticated,
+ * and ~5000 per hour for authenticated (but we conservatively limit per minute).
+ */
+function createGitHubRateLimiter() {
+  return new RateLimiter({
+    maxRequests: 60,
+    windowMs: 60 * 1000,
+    minDelay: 100,
+  });
+}
+
+module.exports = {
+  RateLimiter,
+  createGitHubRateLimiter,
+};

package/src/semver.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const logger = require('./logger');
+
+/**
+ * Parse a version string or tag into components.
+ * Handles: v1.2.3, 1.2.3, v1.2.3-beta.1, v1.2.3-alpha, etc.
+ */
+function parseVersion(tag) {
+  if (!tag || typeof tag !== 'string') {
+    return null;
+  }
+
+  const cleaned = tag.replace(/^v/, '').trim();
+  const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)(?:[-.]([\w.]+))?$/i);
+
+  if (!match) {
+    logger.debug(`Could not parse version from: ${tag}`);
+    return null;
+  }
+
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    prerelease: match[4] || null,
+    raw: tag,
+    clean: cleaned,
+  };
+}
+
+/**
+ * Compare two version strings or parsed version objects.
+ * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+ */
+function compareVersions(a, b) {
+  const vA = typeof a === 'string' ? parseVersion(a) : a;
+  const vB = typeof b === 'string' ? parseVersion(b) : b;
+
+  if (!vA && !vB) return 0;
+  if (!vA) return -1;
+  if (!vB) return 1;
+
+  if (vA.major !== vB.major) return vA.major > vB.major ? 1 : -1;
+  if (vA.minor !== vB.minor) return vA.minor > vB.minor ? 1 : -1;
+  if (vA.patch !== vB.patch) return vA.patch > vB.patch ? 1 : -1;
+
+  // No prerelease > prerelease
+  if (!vA.prerelease && vB.prerelease) return 1;
+  if (vA.prerelease && !vB.prerelease) return -1;
+  if (vA.prerelease && vB.prerelease) {
+    if (vA.prerelease < vB.prerelease) return -1;
+    if (vA.prerelease > vB.prerelease) return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Determine the next version based on commit analysis.
+ * Breaking changes -> major bump
+ * Features -> minor bump
+ * Fixes only -> patch bump
+ */
+function getNextVersion(commits, currentVersion) {
+  const parsed = typeof currentVersion === 'string' ? parseVersion(currentVersion) : currentVersion;
+  if (!parsed) {
+    logger.warn(`Cannot determine next version: invalid current version "${currentVersion}"`);
+    return currentVersion;
+  }
+
+  let hasBreaking = false;
+  let hasFeature = false;
+  let hasFix = false;
+
+  for (const commit of commits) {
+    const message = (commit.message || commit.commit?.message || '').toLowerCase();
+    const type = commit._type || '';
+
+    if (
+      message.includes('breaking change') ||
+      message.includes('breaking:') ||
+      type === 'breaking'
+    ) {
+      hasBreaking = true;
+    }
+    if (type === 'feat' || message.match(/^feat[(!:]/)) {
+      hasFeature = true;
+    }
+    if (type === 'fix' || message.match(/^fix[(!:]/)) {
+      hasFix = true;
+    }
+  }
+
+  let nextMajor = parsed.major;
+  let nextMinor = parsed.minor;
+  let nextPatch = parsed.patch;
+
+  if (hasBreaking) {
+    nextMajor += 1;
+    nextMinor = 0;
+    nextPatch = 0;
+  } else if (hasFeature) {
+    nextMinor += 1;
+    nextPatch = 0;
+  } else if (hasFix) {
+    nextPatch += 1;
+  }
+
+  const nextVersion = `${nextMajor}.${nextMinor}.${nextPatch}`;
+  logger.info(`Next version determined: ${nextVersion} (breaking=${hasBreaking}, feature=${hasFeature}, fix=${hasFix})`);
+  return nextVersion;
+}
+
+/**
+ * Check if a version tag indicates a prerelease.
+ */
+function isPrerelease(tag) {
+  if (!tag || typeof tag !== 'string') return false;
+  const cleaned = tag.replace(/^v/, '').trim();
+  return /[-.](alpha|beta|rc|pre|dev|canary|next|experimental|nightly)[-.]?\d*/i.test(cleaned);
+}
+
+module.exports = {
+  parseVersion,
+  compareVersions,
+  getNextVersion,
+  isPrerelease,
+};

package/src/tones/casual.js

@@ -0,0 +1,114 @@
+'use strict';
+
+/**
+ * Casual tone adapter.
+ * Developer-friendly, conversational, emoji-rich, approachable.
+ */
+class CasualTone {
+  constructor() {
+    this.name = 'casual';
+  }
+
+  /**
+   * Apply casual tone to release data.
+   * @param {Object} data - ReleaseData object
+   * @returns {Object} Modified release data with casual tone
+   */
+  apply(data) {
+    const result = { ...data };
+
+    // Transform summary
+    result.summary = this._casualSummary(data);
+
+    // Transform categories
+    if (data.categories) {
+      result.categories = {};
+      for (const [category, changes] of Object.entries(data.categories)) {
+        const newCategory = this._casualCategoryName(category);
+        result.categories[newCategory] = changes.map(c => ({
+          ...c,
+          description: this._casualDescription(c.description, c.type),
+        }));
+      }
+    }
+
+    // Transform breaking changes
+    if (data.breaking) {
+      result.breaking = data.breaking.map(bc => ({
+        ...bc,
+        description: this._casualBreaking(bc.description),
+      }));
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate a casual summary.
+   */
+  _casualSummary(data) {
+    const version = data.version || '0.0.0';
+    const parts = [`Here's what's new in v${version}!`];
+
+    const catCount = Object.keys(data.categories || {}).length;
+    if (catCount > 3) {
+      parts.push(` This release is packed with ${catCount} types of changes.`);
+    } else if (catCount > 0) {
+      parts.push(` We've got a bunch of goodies for you.`);
+    }
+
+    if (data.breaking && data.breaking.length > 0) {
+      parts.push(` Heads up: there ${data.breaking.length === 1 ? 'is' : 'are'} ${data.breaking.length} breaking change${data.breaking.length > 1 ? 's' : ''}!`);
+    }
+
+    if (data.contributors && data.contributors.length > 0) {
+      parts.push(` Huge thanks to ${data.contributors.length} contributor${data.contributors.length > 1 ? 's' : ''}!`);
+    }
+
+    return parts.join('');
+  }
+
+  /**
+   * Map category names to casual names with emojis.
+   */
+  _casualCategoryName(category) {
+    const map = {
+      '🚀 Features': ':rocket: Cool New Stuff',
+      '🐛 Bug Fixes': ':bug: Squashed Bugs',
+      '💥 Breaking Changes': ':boom: Heads Up - Breaking Changes!',
+      '⚡ Performance': ':zap: Speed Boosts',
+      '♻️ Refactoring': ':recycle: Under the Hood',
+      '📝 Documentation': ':memo: Docs & Guides',
+      '🎨 Style': ':art: Pretty Code',
+      '🧪 Tests': ':test_tube: Test Improvements',
+      '🔧 Chore': ':wrench: Housekeeping',
+      '🔒 Security': ':lock: Security Fixes',
+      'New Features': ':rocket: Cool New Stuff',
+      'Bug Fixes and Resolutions': ':bug: Squashed Bugs',
+      'Performance Improvements': ':zap: Speed Boosts',
+    };
+    return map[category] || `:sparkles: ${category}`;
+  }
+
+  /**
+   * Make a description more casual.
+   */
+  _casualDescription(desc, type) {
+    if (!desc) return desc;
+    // Add exclamation for features
+    if (type === 'feat' && !desc.endsWith('!') && !desc.endsWith('.')) {
+      return desc + '!';
+    }
+    return desc;
+  }
+
+  /**
+   * Casual breaking change description.
+   */
+  _casualBreaking(desc) {
+    if (!desc) return desc;
+    return `Watch out! ${desc}`;
+  }
+}
+
+module.exports = { CasualTone };

package/src/tones/humorous.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * Humorous tone adapter.
+ * Fun, witty descriptions with pop culture references.
+ * Memorable and shareable.
+ */
+class HumorousTone {
+  constructor() {
+    this.name = 'humorous';
+    this._celebrations = [
+      'Hold onto your keyboards!',
+      'Drumroll please...',
+      'Spoiler alert: it\'s awesome.',
+      'Cue the confetti!',
+      'The release you\'ve been waiting for (probably).',
+    ];
+    this._fixPhrases = [
+      'We fixed it. You\'re welcome.',
+      'The bug met its maker.',
+      'Squashed like the creepy-crawly it was.',
+      'Take that, bug!',
+      'Another one bites the dust.',
+    ];
+  }
+
+  /**
+   * Apply humorous tone to release data.
+   * @param {Object} data - ReleaseData object
+   * @returns {Object} Modified release data with humorous tone
+   */
+  apply(data) {
+    const result = { ...data };
+
+    // Transform summary
+    result.summary = this._humorousSummary(data);
+
+    // Transform categories
+    if (data.categories) {
+      result.categories = {};
+      for (const [category, changes] of Object.entries(data.categories)) {
+        const newCategory = this._humorousCategoryName(category);
+        result.categories[newCategory] = changes.map((c, i) => ({
+          ...c,
+          description: this._humorousDescription(c.description, c.type, i),
+        }));
+      }
+    }
+
+    // Transform breaking changes
+    if (data.breaking) {
+      result.breaking = data.breaking.map(bc => ({
+        ...bc,
+        description: this._humorousBreaking(bc.description),
+        migration_guide: bc.migration_guide
+          ? `Don't panic! ${bc.migration_guide}`
+          : 'Update your code. We believe in you.',
+      }));
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate a humorous summary.
+   */
+  _humorousSummary(data) {
+    const version = data.version || '0.0.0';
+    const opener = this._celebrations[Math.floor(Math.random() * this._celebrations.length)];
+
+    const parts = [`${opener} v${version} has landed.`];
+
+    if (data.breaking && data.breaking.length > 0) {
+      parts.push(` Yes, there ${data.breaking.length === 1 ? 'is a' : 'are'} breaking change${data.breaking.length > 1 ? 's' : ''}. No pain, no gain, right?`);
+    }
+
+    const catCount = Object.keys(data.categories || {}).length;
+    if (catCount > 0) {
+      parts.push(` ${catCount} categor${catCount !== 1 ? 'ies' : 'y'} of stuff that's different now.`);
+    }
+
+    if (data.contributors && data.contributors.length > 0) {
+      if (data.contributors.length === 1) {
+        parts.push(` One brave soul made this happen.`);
+      } else {
+        parts.push(` ${data.contributors.length} amazing humans made this happen.`);
+      }
+    }
+
+    return parts.join('');
+  }
+
+  /**
+   * Map category names to humorous names.
+   */
+  _humorousCategoryName(category) {
+    const map = {
+      '🚀 Features': ':rocket: Things That Are New and Shiny',
+      '🐛 Bug Fixes': ':bug: Bugs We Sent to Bug Heaven',
+      '💥 Breaking Changes': ':boom: Things We Broke (Sorry, Not Sorry)',
+      '⚡ Performance': ':zap: We Made It Go Brrr',
+      '♻️ Refactoring': ':recycle: Code We Rewrote for Fun',
+      '📝 Documentation': ':memo: Words About Code',
+      '🎨 Style': ':art: Making Code Pretty Again',
+      '🧪 Tests': ':test_tube: We Actually Test Things',
+      '🔧 Chore': ':wrench: Things Nobody Sees But Everyone Needs',
+      '🔒 Security': ':lock: Fort Knox Mode',
+      'New Features': ':rocket: Things That Are New and Shiny',
+      'Bug Fixes and Resolutions': ':bug: Bugs We Sent to Bug Heaven',
+      'Performance Improvements': ':zap: We Made It Go Brrr',
+      'Code Quality Improvements': ':recycle: Code We Rewrote for Fun',
+      'Documentation Updates': ':memo: Words About Code',
+      'Test Coverage': ':test_tube: We Actually Test Things',
+      'Security Enhancements': ':lock: Fort Knox Mode',
+    };
+    return map[category] || `:sparkles: ${category}`;
+  }
+
+  /**
+   * Make a description more humorous.
+   */
+  _humorousDescription(desc, type, index) {
+    if (!desc) return desc;
+
+    if (type === 'fix') {
+      const phrase = this._fixPhrases[index % this._fixPhrases.length];
+      return `${desc} - ${phrase}`;
+    }
+
+    if (type === 'feat') {
+      const additions = [
+        ' (you\'re gonna love this)',
+        ' (finally!)',
+        ' (yes, really)',
+        ' (the people demanded it)',
+        ' (you\'re welcome)',
+      ];
+      return desc + additions[index % additions.length];
+    }
+
+    if (type === 'perf') {
+      return `${desc} - it\'s fast now. Like, really fast.`;
+    }
+
+    return desc;
+  }
+
+  /**
+   * Humorous breaking change description.
+   */
+  _humorousBreaking(desc) {
+    if (!desc) return desc;
+    const prefixes = [
+      'Plot twist:',
+      'In plot twist news:',
+      'Breaking news (literally):',
+      'Change of plans:',
+    ];
+    const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
+    return `${prefix} ${desc}`;
+  }
+}
+
+module.exports = { HumorousTone };

package/src/tones/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { TONES, isValidTone } = require('./types');
+const { ProfessionalTone } = require('./professional');
+const { CasualTone } = require('./casual');
+const { HumorousTone } = require('./humorous');
+const { TechnicalTone } = require('./technical');
+
+/**
+ * Tone factory. Returns the appropriate tone adapter for a given tone name.
+ * @param {string} tone - Tone identifier ('professional', 'casual', 'humorous', 'technical')
+ * @returns {Object} Tone adapter instance with name and apply() method
+ * @throws {Error} If tone is not recognized
+ */
+function getTone(tone) {
+  switch (tone) {
+    case 'professional':
+      return new ProfessionalTone();
+    case 'casual':
+      return new CasualTone();
+    case 'humorous':
+      return new HumorousTone();
+    case 'technical':
+      return new TechnicalTone();
+    default:
+      throw new Error(`Unknown tone: "${tone}". Valid tones: ${TONES.join(', ')}`);
+  }
+}
+
+module.exports = {
+  getTone,
+  TONES,
+  isValidTone,
+  ProfessionalTone,
+  CasualTone,
+  HumorousTone,
+  TechnicalTone,
+};

package/src/tones/professional.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * Professional tone adapter.
+ * Enterprise/corporate language with formal headers and structured sections.
+ */
+class ProfessionalTone {
+  constructor() {
+    this.name = 'professional';
+  }
+
+  /**
+   * Apply professional tone to release data.
+   * @param {Object} data - ReleaseData object
+   * @returns {Object} Modified release data with professional tone
+   */
+  apply(data) {
+    const result = { ...data };
+
+    // Transform summary
+    result.summary = this._professionalSummary(data);
+
+    // Transform categories
+    if (data.categories) {
+      result.categories = {};
+      for (const [category, changes] of Object.entries(data.categories)) {
+        const newCategory = this._professionalCategoryName(category);
+        result.categories[newCategory] = changes.map(c => ({
+          ...c,
+          description: this._professionalDescription(c.description, c.type),
+        }));
+      }
+    }
+
+    // Transform breaking changes
+    if (data.breaking) {
+      result.breaking = data.breaking.map(bc => ({
+        ...bc,
+        description: this._professionalBreaking(bc.description),
+        migration_guide: bc.migration_guide
+          ? this._professionalMigration(bc.migration_guide)
+          : undefined,
+      }));
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate a professional summary.
+   */
+  _professionalSummary(data) {
+    const parts = [];
+    const version = data.version || '0.0.0';
+
+    if (data.breaking && data.breaking.length > 0) {
+      parts.push(`We are pleased to announce the release of version ${version}, which includes ${data.breaking.length} breaking change${data.breaking.length > 1 ? 's' : ''}`);
+    } else if (Object.keys(data.categories || {}).length > 0) {
+      const catCount = Object.keys(data.categories).length;
+      parts.push(`We are pleased to announce the release of version ${version}, comprising ${catCount} categor${catCount !== 1 ? 'ies' : 'y'} of improvements`);
+    } else {
+      parts.push(`We are pleased to announce the release of version ${version}`);
+    }
+
+    if (data.contributors && data.contributors.length > 0) {
+      parts.push(`with contributions from ${data.contributors.length} developer${data.contributors.length > 1 ? 's' : ''}`);
+    }
+
+    parts.push('.');
+    return parts.join(' ');
+  }
+
+  /**
+   * Map emoji category names to professional names.
+   */
+  _professionalCategoryName(category) {
+    const map = {
+      '🚀 Features': 'New Features',
+      '🐛 Bug Fixes': 'Bug Fixes and Resolutions',
+      '💥 Breaking Changes': 'Breaking Changes',
+      '⚡ Performance': 'Performance Improvements',
+      '♻️ Refactoring': 'Code Quality Improvements',
+      '📝 Documentation': 'Documentation Updates',
+      '🎨 Style': 'Code Style and Formatting',
+      '🧪 Tests': 'Test Coverage',
+      '🔧 Chore': 'Maintenance and Infrastructure',
+      '🔒 Security': 'Security Enhancements',
+    };
+    return map[category] || category.replace(/[^\w\s&]/g, '').trim();
+  }
+
+  /**
+   * Make a description more professional.
+   */
+  _professionalDescription(desc, type) {
+    if (!desc) return desc;
+    // Capitalize first letter, ensure period at end if appropriate
+    let result = desc.charAt(0).toUpperCase() + desc.slice(1);
+    if (type === 'feat' && !result.startsWith('Implemented') && !result.startsWith('Added') && !result.startsWith('Introduced')) {
+      return result;
+    }
+    if (type === 'fix' && !result.startsWith('Resolved') && !result.startsWith('Fixed') && !result.startsWith('Addressed')) {
+      return result;
+    }
+    return result;
+  }
+
+  /**
+   * Professional breaking change description.
+   */
+  _professionalBreaking(desc) {
+    if (!desc) return desc;
+    return `This release introduces a change to ${desc.charAt(0).toLowerCase() + desc.slice(1)}`;
+  }
+
+  /**
+   * Professional migration guide.
+   */
+  _professionalMigration(guide) {
+    if (!guide) return guide;
+    return guide;
+  }
+}
+
+module.exports = { ProfessionalTone };