@theihtisham/ai-release-notes 1.0.0

package/src/integrations/indexer.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const logger = require('../logger');
+const { createRelease } = require('./github-release');
+const { postToSlack } = require('./slack');
+const { postToDiscord } = require('./discord');
+const { postTweet } = require('./twitter');
+const { updateChangelog } = require('./changelog');
+
+/**
+ * Route release data to all configured integrations.
+ * Executes in parallel where possible.
+ * Never fails the action — logs errors and continues.
+ *
+ * @param {Object} config - Configuration object
+ * @param {Object} releaseData - { version, notes, summary, url, contributors }
+ * @param {Object} octokit - Octokit instance (optional)
+ * @param {Object} context - GitHub Actions context (optional)
+ * @returns {Object} Results from each integration
+ */
+async function postToIntegrations(config, releaseData, octokit, context) {
+  const results = {};
+
+  logger.info('Posting to configured integrations...');
+
+  // GitHub Release (always attempt if octokit/context available)
+  if (octokit && context && !config.dryRun) {
+    try {
+      const releaseResult = await createRelease(
+        octokit,
+        context,
+        releaseData.version,
+        releaseData.notes,
+        config
+      );
+      results.githubRelease = {
+        success: true,
+        url: releaseResult.url,
+        created: releaseResult.created,
+      };
+      releaseData.url = releaseResult.url;
+    } catch (err) {
+      results.githubRelease = { success: false, message: err.message };
+      logger.error('GitHub Release integration failed', err);
+    }
+  }
+
+  // Run remaining integrations in parallel
+  const parallelTasks = [];
+
+  // Slack
+  if (config.hasSlack && !config.dryRun) {
+    parallelTasks.push(
+      postToSlack(config.slackWebhook, releaseData)
+        .then(result => { results.slack = result; })
+        .catch(err => {
+          results.slack = { success: false, message: err.message };
+          logger.error('Slack integration failed', err);
+        })
+    );
+  }
+
+  // Discord
+  if (config.hasDiscord && !config.dryRun) {
+    parallelTasks.push(
+      postToDiscord(config.discordWebhook, releaseData)
+        .then(result => { results.discord = result; })
+        .catch(err => {
+          results.discord = { success: false, message: err.message };
+          logger.error('Discord integration failed', err);
+        })
+    );
+  }
+
+  // Twitter
+  if (config.hasTwitter && !config.dryRun) {
+    parallelTasks.push(
+      postTweet(
+        {
+          consumerKey: config.twitterConsumerKey,
+          consumerSecret: config.twitterConsumerSecret,
+          accessToken: config.twitterAccessToken,
+          accessSecret: config.twitterAccessSecret,
+        },
+        releaseData
+      )
+        .then(result => { results.twitter = result; })
+        .catch(err => {
+          results.twitter = { success: false, message: err.message };
+          logger.error('Twitter integration failed', err);
+        })
+    );
+  }
+
+  // Changelog
+  if (config.updateChangelog && octokit && context && !config.dryRun) {
+    parallelTasks.push(
+      updateChangelog(octokit, context, config, releaseData.notes, releaseData.version)
+        .then(result => { results.changelog = result; })
+        .catch(err => {
+          results.changelog = { success: false, message: err.message };
+          logger.error('Changelog integration failed', err);
+        })
+    );
+  }
+
+  // Wait for all parallel tasks to complete
+  await Promise.all(parallelTasks);
+
+  // Log summary
+  const summary = Object.entries(results)
+    .map(([name, result]) => `${name}: ${result.success ? 'OK' : 'FAILED'}`)
+    .join(', ');
+  logger.info(`Integration results: ${summary || 'none configured'}`);
+
+  return results;
+}
+
+module.exports = { postToIntegrations };

package/src/integrations/slack.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const logger = require('../logger');
+
+/**
+ * Post release notes to Slack via webhook.
+ * @param {string} webhookUrl - Slack webhook URL
+ * @param {Object} releaseData - { version, notes, summary, url, contributors }
+ * @returns {Object} { success, message }
+ */
+async function postToSlack(webhookUrl, releaseData) {
+  try {
+    if (!webhookUrl) {
+      logger.debug('No Slack webhook provided — skipping');
+      return { success: false, message: 'No webhook URL' };
+    }
+
+    const { version, summary, url, contributors } = releaseData;
+    const topChanges = extractTopChanges(releaseData.notes, 5);
+
+    const blocks = [
+      {
+        type: 'header',
+        text: {
+          type: 'plain_text',
+          text: `New Release: v${version}`,
+          emoji: true,
+        },
+      },
+      {
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: summary || `Version ${version} has been released!`,
+        },
+      },
+    ];
+
+    if (topChanges.length > 0) {
+      blocks.push({
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: `*Key Changes:*\n${topChanges.map(c => `  - ${c}`).join('\n')}`,
+        },
+      });
+    }
+
+    if (url) {
+      blocks.push({
+        type: 'actions',
+        elements: [
+          {
+            type: 'button',
+            text: {
+              type: 'plain_text',
+              text: 'View Full Release Notes',
+            },
+            url: url,
+          },
+        ],
+      });
+    }
+
+    if (contributors && contributors.length > 0) {
+      const names = contributors.slice(0, 5).map(c => `@${c.login}`).join(', ');
+      blocks.push({
+        type: 'context',
+        elements: [
+          {
+            type: 'mrkdwn',
+            text: `Contributors: ${names}${contributors.length > 5 ? ` and ${contributors.length - 5} more` : ''}`,
+          },
+        ],
+      });
+    }
+
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ blocks }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Slack API returned ${response.status}: ${text}`);
+    }
+
+    logger.info('Slack notification sent successfully');
+    return { success: true, message: 'Posted to Slack' };
+  } catch (err) {
+    logger.error('Failed to post to Slack', err);
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Extract top N changes from release notes markdown.
+ */
+function extractTopChanges(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 = { postToSlack };

package/src/integrations/twitter.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const logger = require('../logger');
+
+/**
+ * Post a release tweet via Twitter API v2.
+ * @param {Object} credentials - { consumerKey, consumerSecret, accessToken, accessSecret }
+ * @param {Object} releaseData - { version, summary, url, notes }
+ * @returns {Object} { success, message, tweetUrl }
+ */
+async function postTweet(credentials, releaseData) {
+  try {
+    if (!credentials || !credentials.consumerKey) {
+      logger.debug('No Twitter credentials provided — skipping');
+      return { success: false, message: 'No credentials' };
+    }
+
+    const { version, summary, url } = releaseData;
+
+    // Generate tweet text
+    const tweetText = generateTweetText(version, summary, releaseData.notes, url);
+
+    logger.info(`Posting tweet (${tweetText.length} chars): ${tweetText.substring(0, 50)}...`);
+
+    // Use twitter-api-v2 with OAuth 1.0a
+    const { TwitterApi } = require('twitter-api-v2');
+
+    const client = new TwitterApi({
+      appKey: credentials.consumerKey,
+      appSecret: credentials.consumerSecret,
+      accessToken: credentials.accessToken,
+      accessSecret: credentials.accessSecret,
+    });
+
+    const tweetClient = client.readWrite;
+
+    const result = await tweetClient.v2.tweet(tweetText);
+
+    const tweetId = result.data.id;
+    const tweetUrl = `https://twitter.com/i/status/${tweetId}`;
+
+    logger.info(`Tweet posted: ${tweetUrl}`);
+    return { success: true, message: 'Tweet posted', tweetUrl };
+  } catch (err) {
+    logger.error('Failed to post tweet', err);
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Generate tweet text within 280 character limit.
+ */
+function generateTweetText(version, summary, notes, url) {
+  const topFeature = extractTopFeature(notes);
+  const topFix = extractTopFix(notes);
+
+  let text = `v${version} is here!`;
+
+  if (summary && summary.length < 100) {
+    text = `v${version} is here! ${summary}`;
+  }
+
+  // Add top feature and fix
+  const extras = [];
+  if (topFeature) extras.push(`Feature: ${topFeature}`);
+  if (topFix) extras.push(`Fix: ${topFix}`);
+
+  if (extras.length > 0) {
+    const extraText = extras.join(' | ');
+    const withoutUrl = `${text}\n\n${extraText}\n\n#changelog #release`;
+    if (url && withoutUrl.length + url.length + 2 <= 280) {
+      return `${withoutUrl}\n${url}`;
+    }
+    if (withoutUrl.length <= 280) {
+      return withoutUrl;
+    }
+  }
+
+  // Simplified: just version, short summary, and link
+  const base = `v${version} released! `;
+  const hashtags = '#changelog #release';
+
+  if (url) {
+    const available = 280 - base.length - url.length - hashtags.length - 6;
+    const shortSummary = summary ? summary.substring(0, Math.max(0, available)) : '';
+    return `${base}${shortSummary}\n${url}\n\n${hashtags}`;
+  }
+
+  return `${base}${hashtags}`;
+}
+
+/**
+ * Extract top feature description from notes.
+ */
+function extractTopFeature(notes) {
+  if (!notes) return null;
+
+  const lines = notes.split('\n');
+  for (const line of lines) {
+    const cleaned = line.replace(/^[-*]\s+/, '').trim();
+    if (cleaned.length > 10 && cleaned.length < 80) {
+      return cleaned;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract top fix description from notes.
+ */
+function extractTopFix(notes) {
+  if (!notes) return null;
+
+  const lines = notes.split('\n');
+  const fixes = lines.filter(
+    l => l.toLowerCase().includes('fix') || l.toLowerCase().includes('bug')
+  );
+
+  for (const line of fixes) {
+    const cleaned = line.replace(/^[-*]\s+/, '').trim();
+    if (cleaned.length > 10 && cleaned.length < 80) {
+      return cleaned;
+    }
+  }
+  return null;
+}
+
+module.exports = { postTweet, generateTweetText };

package/src/logger.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const core = require('@actions/core');
+
+class Logger {
+  constructor(debugEnabled = false) {
+    this.debugEnabled = debugEnabled;
+  }
+
+  debug(message, data) {
+    if (this.debugEnabled) {
+      core.debug(message);
+      if (data) {
+        core.debug(JSON.stringify(data, null, 2));
+      }
+    }
+  }
+
+  info(message) {
+    core.info(message);
+  }
+
+  warn(message) {
+    core.warning(message);
+  }
+
+  error(message, err) {
+    if (err) {
+      core.error(`${message}: ${err.message || err}`);
+      if (err.stack && this.debugEnabled) {
+        core.debug(err.stack);
+      }
+    } else {
+      core.error(message);
+    }
+  }
+
+  group(name) {
+    core.startGroup(name);
+  }
+
+  groupEnd() {
+    core.endGroup();
+  }
+
+  setDebugEnabled(enabled) {
+    this.debugEnabled = enabled;
+  }
+}
+
+module.exports = new Logger();
+module.exports.Logger = Logger;

package/src/prompts.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const { LANGUAGES } = require('./constants');
+
+/**
+ * Get the system prompt for AI release note generation.
+ * @param {Object} config - Configuration object
+ * @returns {string} System prompt
+ */
+function getSystemPrompt(config) {
+  const lang = LANGUAGES[config.language] || LANGUAGES.en;
+  const styleGuidance = getStyleGuidance(config.template);
+
+  return `You are an expert technical writer specializing in software release notes. Your task is to generate clear, informative, and well-structured release notes from commit and PR data.
+
+## Language
+Write the release notes in ${config.language === 'en' ? 'English' : lang.title} (${config.language}).
+
+## Style
+${styleGuidance}
+
+## Rules
+1. Use past tense ("Added", "Fixed", "Improved" — not "Add", "Fix", "Improve")
+2. Group related changes logically under category headings
+3. Include PR numbers as clickable markdown links: [#123](https://github.com/example/repo/pull/123) — use the repo from context
+4. For breaking changes, always include a "Migration Guide" subsection with specific steps
+5. Be specific and concrete ("Added user avatar upload API endpoint at POST /api/users/avatar" not "Added new features")
+6. Maximum 2000 words
+7. Use proper markdown formatting with headers (##), bullet points (-), bold (**), and code blocks where appropriate
+8. Start with a one-paragraph summary of the release
+9. Do not include empty sections
+10. Include contributor acknowledgments at the end
+11. Preserve any technical details, version numbers, or configuration references from the source data
+12. Handle unicode characters correctly in commit messages
+
+## Output Format
+Return ONLY the markdown content for the release notes body. Do not include a top-level heading (h1) — start with a summary paragraph or h2 sections.`;
+}
+
+/**
+ * Get style guidance based on template.
+ */
+function getStyleGuidance(template) {
+  switch (template) {
+    case 'enterprise':
+      return `Write in a formal, professional tone suitable for enterprise audiences. Include:
+- Executive Summary section (2-3 sentences)
+- Structured Change sections with clear categorization
+- Impact Assessment for each significant change
+- Action Items section (what users should do after upgrading)
+- Known Issues section (if applicable)
+- Avoid emojis. Use clear, precise language.`;
+
+    case 'fun':
+      return `Write in a casual, celebratory tone! Use emojis liberally. Include:
+- Enthusiastic language ("This release is packed with awesomeness!")
+- Fun metaphors and analogies
+- Celebrate contributor achievements
+- Use emojis for section headers and bullet points
+- Keep it light but still informative
+- End with something encouraging`;
+
+    case 'minimal':
+      return `Be extremely concise. Use simple bullet points only.
+- One line per change
+- No sections, no summary paragraph
+- Just the facts, ma'am
+- PR number and brief description`;
+
+    case 'detailed':
+      return `Be thorough and comprehensive. Include:
+- Detailed summary paragraph
+- Every change with full context
+- Author credits for each change
+- Diff statistics and affected areas
+- Linked issues with full URLs
+- Migration guides for breaking changes
+- Screenshots section (if images detected)`;
+
+    case 'default':
+    default:
+      return `Use a balanced, developer-friendly tone. Be clear and concise but friendly. Include:
+- Brief summary paragraph
+- Categorized changes with bullet points
+- Contributor thanks section
+- Full changelog link`;
+  }
+}
+
+/**
+ * Get the user prompt with structured data from the analysis.
+ * @param {Object} analysis - Analysis results from analyzer
+ * @param {Object} diffSummary - Diff analysis results
+ * @param {string} version - Current version
+ * @param {Object} config - Configuration object
+ * @returns {string} User prompt
+ */
+function getUserPrompt(analysis, diffSummary, version, config) {
+  const sections = [];
+
+  sections.push(`# Release Data for v${version}`);
+  sections.push('');
+  sections.push(`## Repository: ${config.repoFullName || 'unknown'}`);
+  sections.push(`## Date: ${new Date().toISOString().split('T')[0]}`);
+  sections.push('');
+
+  // Stats
+  if (analysis.stats) {
+    sections.push('## Statistics');
+    sections.push(`- Total commits: ${analysis.stats.total_commits}`);
+    sections.push(`- Total PRs: ${analysis.stats.total_prs}`);
+    sections.push(`- Files changed: ${analysis.stats.total_files_changed}`);
+    sections.push(`- Additions: ${analysis.stats.additions}`);
+    sections.push(`- Deletions: ${analysis.stats.deletions}`);
+    sections.push('');
+  }
+
+  // Categories
+  if (analysis.categories) {
+    sections.push('## Categorized Changes');
+    for (const [category, changes] of Object.entries(analysis.categories)) {
+      sections.push(`### ${category}`);
+      for (const change of changes) {
+        let line = `- ${change.description}`;
+        if (change.pr) {
+          line += ` (#${change.pr})`;
+        }
+        if (change.scope) {
+          line += ` [${change.scope}]`;
+        }
+        if (change.author) {
+          line += ` by @${change.author}`;
+        }
+        sections.push(line);
+      }
+      sections.push('');
+    }
+  }
+
+  // Breaking changes
+  if (analysis.breaking && analysis.breaking.length > 0) {
+    sections.push('## Breaking Changes');
+    for (const bc of analysis.breaking) {
+      sections.push(`- ${bc.description}`);
+      if (bc.migration_guide) {
+        sections.push(`  Migration: ${bc.migration_guide}`);
+      }
+      if (bc.scope) {
+        sections.push(`  Scope: ${bc.scope}`);
+      }
+    }
+    sections.push('');
+  }
+
+  // Contributors
+  if (analysis.contributors && analysis.contributors.length > 0) {
+    sections.push('## Contributors');
+    for (const c of analysis.contributors) {
+      sections.push(`- @${c.login} (${c.commits_count} commit${c.commits_count !== 1 ? 's' : ''})${c.is_first_time ? ' [FIRST TIME]' : ''}`);
+    }
+    sections.push('');
+  }
+
+  // Diff summary
+  if (diffSummary && diffSummary.files_changed > 0) {
+    sections.push('## Diff Summary');
+    sections.push(`- Files changed: ${diffSummary.files_changed} (${diffSummary.files_added} added, ${diffSummary.files_modified} modified, ${diffSummary.files_deleted} deleted)`);
+    sections.push(`- Lines: +${diffSummary.additions} / -${diffSummary.deletions}`);
+    sections.push(`- Impact: ${diffSummary.impact}`);
+    if (diffSummary.affected_areas.length > 0) {
+      sections.push(`- Affected areas: ${diffSummary.affected_areas.join(', ')}`);
+    }
+    if (diffSummary.potential_breaking.length > 0) {
+      sections.push('- Potential breaking changes detected:');
+      for (const pb of diffSummary.potential_breaking) {
+        sections.push(`  - ${pb.file}: ${pb.reason}`);
+      }
+    }
+    sections.push('');
+  }
+
+  // Scopes
+  if (analysis.scopes && Object.keys(analysis.scopes).length > 0) {
+    sections.push('## Scopes');
+    for (const [scope, count] of Object.entries(analysis.scopes)) {
+      sections.push(`- ${scope}: ${count} change${count !== 1 ? 's' : ''}`);
+    }
+    sections.push('');
+  }
+
+  // Linked issues
+  if (analysis.linkedIssues && analysis.linkedIssues.length > 0) {
+    sections.push('## Linked Issues');
+    for (const issue of analysis.linkedIssues) {
+      sections.push(`- #${issue.number}`);
+    }
+    sections.push('');
+  }
+
+  sections.push('---');
+  sections.push('Generate the release notes now based on the above data.');
+
+  return sections.join('\n');
+}
+
+module.exports = {
+  getSystemPrompt,
+  getUserPrompt,
+  getStyleGuidance,
+};