@theihtisham/ai-release-notes 1.0.0

package/src/generator.js

@@ -0,0 +1,297 @@
+'use strict';
+
+const github = require('@actions/github');
+const logger = require('./logger');
+const { analyzeCommits } = require('./analyzer');
+const { analyzeDiff, formatDiffStats } = require('./diff-analyzer');
+const { generateReleaseNotes: aiGenerate } = require('./ai-writer');
+const { formatReleaseNotes, generateSummary } = require('./formatter');
+const { postToIntegrations } = require('./integrations/indexer');
+const { parseVersion, isPrerelease } = require('./semver');
+const { createGitHubRateLimiter } = require('./rate-limiter');
+
+/**
+ * Main orchestrator — generate release notes and post to integrations.
+ * @param {Object} config - Validated configuration object
+ * @returns {Object} { notes, url, version, summary }
+ */
+async function generate(config) {
+  logger.info('Starting release notes generation');
+
+  const octokit = github.getOctokit(config.githubToken);
+  const context = github.context;
+  const rateLimiter = createGitHubRateLimiter();
+
+  // Set repo info on config for formatter
+  config.repoFullName = `${context.repo.owner}/${context.repo.repo}`;
+  config.repoUrl = `https://github.com/${config.repoFullName}`;
+
+  // Step 1: Determine version
+  const version = determineVersion(config, context);
+  logger.info(`Version: ${version}`);
+
+  // Step 2: Determine previous version
+  const previousVersion = await determinePreviousVersion(config, octokit, context, rateLimiter);
+  logger.info(`Previous version: ${previousVersion || 'none (first release)'}`);
+
+  // Step 3: Collect changes
+  const { commits, prs } = await collectChanges(
+    config, octokit, context, previousVersion, version, rateLimiter
+  );
+  logger.info(`Collected ${commits.length} commits and ${prs.length} PRs`);
+
+  // Step 4: Analyze changes
+  const analysis = analyzeCommits(commits, config);
+  logger.info(`Analysis: ${analysis.stats.total_commits} commits in ${Object.keys(analysis.categories).length} categories`);
+
+  // Step 5: Analyze diff (optional)
+  let diffSummary = null;
+  if (config.includeDiffStats) {
+    try {
+      await rateLimiter.wait();
+      diffSummary = await analyzeDiff(commits.slice(0, Math.min(commits.length, 50)), octokit, context);
+    } catch (err) {
+      logger.warn('Diff analysis failed, continuing without it', err);
+      diffSummary = { files_changed: 0, additions: 0, deletions: 0, impact: 'low', affected_areas: [], potential_breaking: [], files: [], files_added: 0, files_modified: 0, files_deleted: 0 };
+    }
+  }
+
+  // Step 6: Generate release notes (AI or template)
+  let notes;
+  if (config.hasAI) {
+    try {
+      const aiNotes = await aiGenerate(analysis, diffSummary, version, config);
+      if (aiNotes) {
+        notes = aiNotes;
+        logger.info('Using AI-generated release notes');
+      } else {
+        notes = formatReleaseNotes(analysis, diffSummary, version, previousVersion, config);
+        logger.info('AI failed or returned nothing — using template-based notes');
+      }
+    } catch (err) {
+      logger.warn('AI generation threw error — falling back to template', err);
+      notes = formatReleaseNotes(analysis, diffSummary, version, previousVersion, config);
+    }
+  } else {
+    notes = formatReleaseNotes(analysis, diffSummary, version, previousVersion, config);
+    logger.info('Using template-based release notes (no API key)');
+  }
+
+  // Generate summary
+  const summary = generateSummary(analysis, version);
+
+  // Step 7: Post to integrations
+  const releaseData = {
+    version,
+    notes,
+    summary,
+    url: '',
+    contributors: analysis.contributors || [],
+  };
+
+  if (!config.dryRun) {
+    try {
+      const integrationResults = await postToIntegrations(config, releaseData, octokit, context);
+      if (integrationResults.githubRelease && integrationResults.githubRelease.url) {
+        releaseData.url = integrationResults.githubRelease.url;
+      }
+    } catch (err) {
+      logger.error('Integration posting failed (non-fatal)', err);
+    }
+  } else {
+    logger.info('Dry run mode — skipping all integrations');
+  }
+
+  logger.info(`Release notes generated for v${version}`);
+
+  return {
+    notes: releaseData.notes,
+    url: releaseData.url,
+    version: version,
+    summary: summary,
+  };
+}
+
+/**
+ * Determine the current version based on config.
+ */
+function determineVersion(config, context) {
+  switch (config.versionFrom) {
+    case 'tag': {
+      const ref = process.env.GITHUB_REF || '';
+      const tagMatch = ref.match(/refs\/tags\/v?(.+)/);
+      if (tagMatch) {
+        return tagMatch[1];
+      }
+      // Try to get from context payload
+      if (context.payload.release && context.payload.release.tag_name) {
+        return context.payload.release.tag_name.replace(/^v/, '');
+      }
+      logger.warn('Could not determine version from tag');
+      return '0.0.0';
+    }
+    case 'package-json': {
+      try {
+        const fs = require('fs');
+        const path = require('path');
+        const pkgPath = path.join(process.env.GITHUB_WORKSPACE || process.cwd(), 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.version || '0.0.0';
+      } catch (err) {
+        logger.warn('Could not read version from package.json', err);
+        return '0.0.0';
+      }
+    }
+    case 'manual':
+      return config.version || '0.0.0';
+    default:
+      return '0.0.0';
+  }
+}
+
+/**
+ * Determine the previous version/tag.
+ */
+async function determinePreviousVersion(config, octokit, context, rateLimiter) {
+  // Manual override
+  if (config.previousTag) {
+    return config.previousTag.replace(/^v/, '');
+  }
+
+  // Auto-detect from GitHub releases
+  try {
+    await rateLimiter.wait();
+    const { data: releases } = await octokit.rest.repos.listReleases({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      per_page: 10,
+    });
+
+    for (const release of releases) {
+      const tag = release.tag_name.replace(/^v/, '');
+      if (!isPrerelease(tag) || release.prerelease) {
+        // Skip prereleases for finding previous stable
+        if (!release.prerelease) {
+          return tag;
+        }
+      }
+    }
+
+    // If no stable release found, use the latest release of any type
+    if (releases.length > 0) {
+      return releases[0].tag_name.replace(/^v/, '');
+    }
+  } catch (err) {
+    logger.debug(`Could not auto-detect previous version: ${err.message}`);
+  }
+
+  return '';
+}
+
+/**
+ * Collect changes (commits and/or PRs) between versions.
+ */
+async function collectChanges(config, octokit, context, previousVersion, currentVersion, rateLimiter) {
+  const owner = context.repo.owner;
+  const repo = context.repo.repo;
+  let commits = [];
+  let prs = [];
+
+  const commitMode = config.commitMode;
+
+  // Determine if we should use PR mode
+  let usePRs = false;
+  if (commitMode === 'pull-requests') {
+    usePRs = true;
+  } else if (commitMode === 'auto') {
+    // Check if there are PRs between the versions
+    try {
+      await rateLimiter.wait();
+      const base = previousVersion ? `v${previousVersion}` : undefined;
+      const head = `v${currentVersion}`;
+      if (base) {
+        const { data: compareData } = await octokit.rest.repos.compareCommits({
+          owner,
+          repo,
+          base,
+          head,
+        });
+        // If commits have PR numbers, prefer PR mode
+        const commitsWithPRs = (compareData.commits || []).filter(
+          c => c.commit.message.match(/\(#\d+\)/)
+        );
+        usePRs = commitsWithPRs.length > (compareData.commits || []).length * 0.3;
+      }
+    } catch (err) {
+      logger.debug(`Could not determine auto mode: ${err.message}`);
+      usePRs = false;
+    }
+  }
+
+  if (usePRs) {
+    // Collect merged PRs between versions
+    try {
+      await rateLimiter.wait();
+      const prQuery = previousVersion
+        ? `is:pr is:merged repo:${owner}/${repo} base:main merged:>="${new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString().split('T')[0]}"`
+        : `is:pr is:merged repo:${owner}/${repo}`;
+
+      // Use search API for PRs
+      const { data: searchResult } = await octokit.rest.search.issuesAndPullRequests({
+        q: prQuery,
+        sort: 'updated',
+        order: 'desc',
+        per_page: Math.min(config.maxCommits, 100),
+      });
+
+      prs = searchResult.items || [];
+      commits = prs.map(pr => ({
+        sha: pr.merge_commit_sha || '',
+        message: pr.title || '',
+        author: pr.user || {},
+        url: pr.html_url,
+        _pr: pr.number,
+      }));
+    } catch (err) {
+      logger.warn(`PR collection failed, falling back to commits: ${err.message}`);
+      usePRs = false;
+    }
+  }
+
+  if (!usePRs) {
+    // Collect commits between versions
+    try {
+      if (previousVersion) {
+        await rateLimiter.wait();
+        const { data: compareData } = await octokit.rest.repos.compareCommits({
+          owner,
+          repo,
+          base: `v${previousVersion}`,
+          head: `v${currentVersion}`,
+        });
+        commits = (compareData.commits || []).slice(0, config.maxCommits);
+      } else {
+        // No previous version — get recent commits
+        await rateLimiter.wait();
+        const { data: commitList } = await octokit.rest.repos.listCommits({
+          owner,
+          repo,
+          per_page: Math.min(config.maxCommits, 100),
+        });
+        commits = commitList;
+      }
+    } catch (err) {
+      logger.warn(`Commit collection failed: ${err.message}`);
+      commits = [];
+    }
+  }
+
+  // Handle no changes
+  if (commits.length === 0 && prs.length === 0) {
+    logger.info('No changes found between versions');
+  }
+
+  return { commits, prs };
+}
+
+module.exports = { generate, determineVersion, determinePreviousVersion, collectChanges };

package/src/integrations/changelog.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const logger = require('../logger');
+
+/**
+ * Update CHANGELOG.md with new release entry.
+ * @param {Object} octokit - Octokit instance
+ * @param {Object} context - GitHub Actions context
+ * @param {Object} config - Configuration object
+ * @param {string} notes - Release notes body
+ * @param {string} version - Version string
+ * @returns {Object} { success, message }
+ */
+async function updateChangelog(octokit, context, config, notes, version) {
+  try {
+    const owner = context.repo.owner;
+    const repo = context.repo.repo;
+    const changelogPath = config.changelogPath || 'CHANGELOG.md';
+    const date = new Date().toISOString().split('T')[0];
+
+    logger.info(`Updating ${changelogPath} with v${version}`);
+
+    // Read existing changelog
+    let existingContent = '';
+    let sha = null;
+    try {
+      const { data } = await octokit.rest.repos.getContent({
+        owner,
+        repo,
+        path: changelogPath,
+        ref: context.payload.ref || 'HEAD',
+      });
+      existingContent = Buffer.from(data.content, 'base64').toString('utf-8');
+      sha = data.sha;
+    } catch (err) {
+      if (err.status === 404) {
+        logger.info('No existing CHANGELOG.md — creating new one');
+        existingContent = '# Changelog\n\n';
+        sha = null;
+      } else {
+        throw err;
+      }
+    }
+
+    // Build new entry
+    const newEntry = buildChangelogEntry(version, date, notes);
+
+    // Prepend new entry after the header
+    const updatedContent = prependEntry(existingContent, newEntry);
+
+    // Commit and push
+    const commitMessage = `docs(changelog): update for v${version}`;
+
+    await octokit.rest.repos.createOrUpdateFileContents({
+      owner,
+      repo,
+      path: changelogPath,
+      message: commitMessage,
+      content: Buffer.from(updatedContent).toString('base64'),
+      sha: sha,
+      branch: context.payload.ref ? context.payload.ref.replace('refs/heads/', '') : 'main',
+    });
+
+    logger.info(`Changelog updated: ${changelogPath}`);
+    return { success: true, message: `Updated ${changelogPath}` };
+  } catch (err) {
+    logger.error('Failed to update changelog', err);
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Build a structured changelog entry from release notes.
+ */
+function buildChangelogEntry(version, date, notes) {
+  const lines = [];
+  lines.push(`## [${version}] - ${date}`);
+  lines.push('');
+
+  if (notes) {
+    // Parse notes into structured sections
+    const noteLines = notes.split('\n');
+    for (const line of noteLines) {
+      // Skip h1 headers and full changelog links
+      if (line.match(/^# /)) continue;
+      if (line.match(/\*\*Full Changelog\*\*/)) continue;
+      lines.push(line);
+    }
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Prepend a new entry to the existing changelog content.
+ * Inserts after the first header (# Changelog) if present.
+ */
+function prependEntry(existingContent, newEntry) {
+  const lines = existingContent.split('\n');
+  let insertIndex = 0;
+
+  // Find the first header
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^#\s+/)) {
+      // Skip the header and any trailing blank lines
+      insertIndex = i + 1;
+      while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+        insertIndex++;
+      }
+      break;
+    }
+  }
+
+  // Insert new entry
+  lines.splice(insertIndex, 0, newEntry);
+
+  // Clean up excessive blank lines
+  let result = lines.join('\n');
+  result = result.replace(/\n{3,}/g, '\n\n');
+
+  return result;
+}
+
+module.exports = { updateChangelog, buildChangelogEntry, prependEntry };

package/src/integrations/discord.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const logger = require('../logger');
+
+/**
+ * Post release notes to Discord via webhook.
+ * @param {string} webhookUrl - Discord webhook URL
+ * @param {Object} releaseData - { version, notes, summary, url, contributors }
+ * @returns {Object} { success, message }
+ */
+async function postToDiscord(webhookUrl, releaseData) {
+  try {
+    if (!webhookUrl) {
+      logger.debug('No Discord webhook provided — skipping');
+      return { success: false, message: 'No webhook URL' };
+    }
+
+    const { version, summary, url, contributors } = releaseData;
+    const topChanges = extractTopChangesDiscord(releaseData.notes, 5);
+
+    const fields = [
+      {
+        name: 'Version',
+        value: `v${version}`,
+        inline: true,
+      },
+      {
+        name: 'Date',
+        value: new Date().toISOString().split('T')[0],
+        inline: true,
+      },
+    ];
+
+    if (contributors && contributors.length > 0) {
+      fields.push({
+        name: 'Contributors',
+        value: contributors.slice(0, 5).map(c => `@${c.login}`).join(', ') +
+          (contributors.length > 5 ? ` and ${contributors.length - 5} more` : ''),
+        inline: false,
+      });
+    }
+
+    let description = summary || `Version ${version} has been released!`;
+    if (topChanges.length > 0) {
+      description += '\n\n**Key Changes:**\n' + topChanges.map(c => `  - ${c}`).join('\n');
+    }
+
+    const embed = {
+      title: `New Release: v${version}`,
+      url: url || '',
+      color: 0x00ff00, // Green
+      description: description.substring(0, 2048), // Discord limit
+      fields: fields,
+      footer: {
+        text: 'Powered by AI Release Notes',
+      },
+      timestamp: new Date().toISOString(),
+    };
+
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        embeds: [embed],
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Discord API returned ${response.status}: ${text}`);
+    }
+
+    logger.info('Discord notification sent successfully');
+    return { success: true, message: 'Posted to Discord' };
+  } catch (err) {
+    logger.error('Failed to post to Discord', err);
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Extract top N changes from release notes for Discord.
+ */
+function extractTopChangesDiscord(notes, count) {
+  if (!notes) return [];
+
+  const lines = notes.split('\n');
+  const bullets = lines
+    .filter(line => line.match(/^-\s+/))
+    .map(line => line.replace(/^-\s+/, '').trim())
+    .filter(line => line.length > 0 && line.length < 150);
+
+  return bullets.slice(0, count);
+}
+
+module.exports = { postToDiscord };

package/src/integrations/github-release.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const logger = require('../logger');
+const { isPrerelease } = require('../semver');
+
+/**
+ * Create or update a GitHub Release.
+ * @param {Object} octokit - Octokit instance
+ * @param {Object} context - GitHub Actions context
+ * @param {string} version - Version string
+ * @param {string} notes - Release notes body
+ * @param {Object} config - Configuration object
+ * @returns {Object} { url, created }
+ */
+async function createRelease(octokit, context, version, notes, config) {
+  try {
+    const owner = context.repo.owner;
+    const repo = context.repo.repo;
+    const tag = `v${version}`;
+    const prerelease = isPrerelease(version);
+
+    logger.info(`Creating GitHub Release for ${tag} (prerelease=${prerelease})`);
+
+    // Check if release already exists for this tag
+    let existingRelease = null;
+    try {
+      const { data } = await octokit.rest.repos.getReleaseByTag({
+        owner,
+        repo,
+        tag,
+      });
+      existingRelease = data;
+    } catch (err) {
+      // 404 means no existing release — expected for new releases
+      if (err.status !== 404) {
+        logger.debug(`Error checking existing release: ${err.message}`);
+      }
+    }
+
+    if (existingRelease) {
+      // Update existing release
+      logger.info(`Updating existing release for ${tag}`);
+      const { data: updated } = await octokit.rest.repos.updateRelease({
+        owner,
+        repo,
+        release_id: existingRelease.id,
+        body: notes,
+        draft: false,
+        prerelease: prerelease,
+      });
+
+      logger.info(`Release updated: ${updated.html_url}`);
+      return { url: updated.html_url, created: false };
+    }
+
+    // Create new release
+    const { data: release } = await octokit.rest.repos.createRelease({
+      owner,
+      repo,
+      tag_name: tag,
+      name: tag,
+      body: notes,
+      draft: false,
+      prerelease: prerelease,
+    });
+
+    logger.info(`Release created: ${release.html_url}`);
+    return { url: release.html_url, created: true };
+  } catch (err) {
+    logger.error('Failed to create/update GitHub Release', err);
+    throw err;
+  }
+}
+
+module.exports = { createRelease };