@theihtisham/ai-release-notes 1.0.0

package/__tests__/migration.test.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const {
+  detectBreakingChanges,
+  generateMigrationGuide,
+  generateUpgradeCommand,
+  createBreakingChange,
+  extractType,
+  extractPRNumber,
+  extractMigrationGuide,
+  extractBeforeCode,
+  extractAfterCode,
+  extractAffectedAPIs,
+  detectAPISignatureChange,
+} = require('../src/analyzers/migration');
+
+/**
+ * Create a sample commit object.
+ */
+function createCommit(message, sha = 'abc123') {
+  return { sha, commit: { message, author: { name: 'Dev', email: 'dev@test.com' } } };
+}
+
+describe('migration analyzer', () => {
+  describe('detectBreakingChanges', () => {
+    test('returns empty array for no commits', () => {
+      expect(detectBreakingChanges([])).toEqual([]);
+      expect(detectBreakingChanges(null)).toEqual([]);
+    });
+
+    test('detects BREAKING CHANGE footer', () => {
+      const commits = [
+        createCommit('feat: new API\n\nBREAKING CHANGE: old API removed'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+      expect(result[0].description).toContain('old API removed');
+    });
+
+    test('detects ! suffix in conventional commits', () => {
+      const commits = [
+        createCommit('feat!: completely redesigned API'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+      expect(result[0].description).toContain('completely redesigned API');
+      expect(result[0].severity).toBe('major');
+    });
+
+    test('detects "breaking:" prefix', () => {
+      const commits = [
+        createCommit('breaking: removed legacy support'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+    });
+
+    test('detects "breaking change" keyword in message', () => {
+      const commits = [
+        createCommit('refactor: this is a breaking change to the config module'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+    });
+
+    test('detects API signature changes from keywords', () => {
+      const commits = [
+        createCommit('refactor: remove getUserById method from UserService'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+      expect(result[0].affected_apis).toContain('getUserById');
+    });
+
+    test('detects renamed APIs', () => {
+      const commits = [
+        createCommit('refactor: rename fetchUsers to getUsers'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+      expect(result[0].affected_apis).toContain('fetchUsers');
+    });
+
+    test('detects deprecated APIs', () => {
+      const commits = [
+        createCommit('chore: deprecate Config.getOldValue'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(1);
+      expect(result[0].affected_apis).toContain('Config.getOldValue');
+    });
+
+    test('extracts scope from conventional commit', () => {
+      const commits = [
+        createCommit('feat(api)!: redesigned endpoint structure'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result[0].scope).toBe('api');
+    });
+
+    test('extracts PR number', () => {
+      const commits = [
+        createCommit('feat!: big change (#123)'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result[0].pr).toBe(123);
+    });
+
+    test('detects multiple breaking changes', () => {
+      const commits = [
+        createCommit('feat!: first breaking change'),
+        createCommit('fix(api)!: second breaking change\n\nBREAKING CHANGE: details here'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result.length).toBe(2);
+    });
+
+    test('extracts migration guide from body', () => {
+      const commits = [
+        createCommit('feat!: changed API\n\nMigration Guide:\n- Step 1\n- Step 2\n- Step 3'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result[0].migration_guide).toContain('Step 1');
+    });
+
+    test('extracts before code blocks', () => {
+      const commits = [
+        createCommit('feat!: changed API\n\nBefore:\n```javascript\noldAPI()\n```\n\nAfter:\n```javascript\nnewAPI()\n```'),
+      ];
+      const result = detectBreakingChanges(commits);
+      expect(result[0].before_code).toContain('oldAPI()');
+      expect(result[0].after_code).toContain('newAPI()');
+    });
+  });
+
+  describe('generateMigrationGuide', () => {
+    test('returns no-migration message for empty changes', () => {
+      const result = generateMigrationGuide([]);
+      expect(result).toContain('No breaking changes detected');
+    });
+
+    test('generates structured migration guide', () => {
+      const changes = [
+        {
+          description: 'Removed /api/v1/users endpoint',
+          scope: 'api',
+          severity: 'major',
+          migration_guide: 'Use /api/v2/users instead',
+          pr: 42,
+        },
+      ];
+      const result = generateMigrationGuide(changes);
+
+      expect(result).toContain('Migration Guide');
+      expect(result).toContain('Removed /api/v1/users endpoint');
+      expect(result).toContain('Use /api/v2/users instead');
+      expect(result).toContain('PR #42');
+    });
+
+    test('includes before/after code examples', () => {
+      const changes = [
+        {
+          description: 'Changed function signature',
+          scope: 'utils',
+          before_code: 'oldFunction(arg1)',
+          after_code: 'newFunction(arg1, options)',
+        },
+      ];
+      const result = generateMigrationGuide(changes);
+
+      expect(result).toContain('oldFunction(arg1)');
+      expect(result).toContain('newFunction(arg1, options)');
+    });
+
+    test('generates default steps when no migration guide', () => {
+      const changes = [
+        {
+          description: 'Something broke',
+          scope: 'core',
+        },
+      ];
+      const result = generateMigrationGuide(changes);
+
+      expect(result).toContain('Migration Steps');
+      expect(result).toContain('Review the changes');
+    });
+
+    test('includes deprecation timeline', () => {
+      const changes = [
+        { description: 'A change', scope: 'api', severity: 'major' },
+      ];
+      const result = generateMigrationGuide(changes);
+
+      expect(result).toContain('Deprecation Timeline');
+    });
+
+    test('handles multiple breaking changes', () => {
+      const changes = [
+        { description: 'Change 1', scope: 'a', severity: 'major' },
+        { description: 'Change 2', scope: 'b', severity: 'major' },
+      ];
+      const result = generateMigrationGuide(changes);
+
+      expect(result).toContain('Change 1');
+      expect(result).toContain('Change 2');
+    });
+
+    test('lists affected APIs', () => {
+      const changes = [
+        {
+          description: 'API changed',
+          scope: 'api',
+          affected_apis: ['oldEndpoint()', 'Config.set()'],
+        },
+      ];
+      const result = generateMigrationGuide(changes);
+
+      expect(result).toContain('oldEndpoint()');
+      expect(result).toContain('Config.set()');
+    });
+  });
+
+  describe('generateUpgradeCommand', () => {
+    test('generates npm command', () => {
+      const result = generateUpgradeCommand('1.0.0', '2.0.0', 'my-package');
+      expect(result).toContain('npm install my-package@2.0.0');
+    });
+
+    test('generates yarn command', () => {
+      const result = generateUpgradeCommand('1.0.0', '2.0.0', 'my-package');
+      expect(result).toContain('yarn add my-package@2.0.0');
+    });
+
+    test('generates pnpm command', () => {
+      const result = generateUpgradeCommand('1.0.0', '2.0.0', 'my-package');
+      expect(result).toContain('pnpm add my-package@2.0.0');
+    });
+
+    test('warns about major upgrades', () => {
+      const result = generateUpgradeCommand('1.0.0', '2.0.0');
+      expect(result).toContain('major version upgrade');
+    });
+
+    test('notes minor version upgrades', () => {
+      const result = generateUpgradeCommand('1.0.0', '1.1.0');
+      expect(result).toContain('minor version');
+      expect(result).toContain('Backward compatible');
+    });
+
+    test('notes patch version upgrades', () => {
+      const result = generateUpgradeCommand('1.0.0', '1.0.1');
+      expect(result).toContain('patch upgrade');
+      expect(result).toContain('Safe to upgrade');
+    });
+  });
+
+  describe('helper functions', () => {
+    test('extractType returns correct type', () => {
+      expect(extractType('feat: something')).toBe('feat');
+      expect(extractType('fix: something')).toBe('fix');
+      expect(extractType('random message')).toBe('other');
+    });
+
+    test('extractPRNumber returns correct PR number', () => {
+      expect(extractPRNumber('feat: something (#42)')).toBe(42);
+      expect(extractPRNumber('no PR')).toBeNull();
+    });
+
+    test('extractMigrationGuide finds migration text', () => {
+      const body = 'Migration Guide:\n- Step 1\n- Step 2\n\nOther text';
+      expect(extractMigrationGuide(body)).toContain('Step 1');
+    });
+
+    test('extractMigrationGuide finds MIGRATION text', () => {
+      const body = 'MIGRATION:\n- Update code\n- Run tests';
+      expect(extractMigrationGuide(body)).toContain('Update code');
+    });
+
+    test('extractMigrationGuide returns empty for no guide', () => {
+      expect(extractMigrationGuide('no guide here')).toBe('');
+      expect(extractMigrationGuide('')).toBe('');
+    });
+
+    test('extractBeforeCode extracts code blocks', () => {
+      const body = 'Before:\n```javascript\noldCode()\n```\nAfter:\n```javascript\nnewCode()\n```';
+      expect(extractBeforeCode(body)).toContain('oldCode()');
+    });
+
+    test('extractAfterCode extracts second code block', () => {
+      const body = 'Before:\n```javascript\noldCode()\n```\nAfter:\n```javascript\nnewCode()\n```';
+      expect(extractAfterCode(body)).toContain('newCode()');
+    });
+
+    test('extractAfterCode returns empty for single code block', () => {
+      const body = '```javascript\nonlyCode()\n```';
+      expect(extractAfterCode(body)).toBe('');
+    });
+
+    test('extractAffectedAPIs finds API patterns', () => {
+      const body = 'Changed: `myApp.getUser()` and affected API: `myApp.setUser()`';
+      const apis = extractAffectedAPIs(body);
+      expect(apis.length).toBeGreaterThanOrEqual(2);
+    });
+
+    test('detectAPISignatureChange detects removed methods', () => {
+      expect(detectAPISignatureChange('remove getUserById method from UserService')).toBe('getUserById');
+    });
+
+    test('detectAPISignatureChange detects renamed APIs', () => {
+      expect(detectAPISignatureChange('rename fetchUsers to getUsers')).toBe('fetchUsers');
+    });
+
+    test('detectAPISignatureChange detects deprecated APIs', () => {
+      expect(detectAPISignatureChange('deprecate Config.getOldValue')).toBe('Config.getOldValue');
+    });
+
+    test('detectAPISignatureChange returns null for no match', () => {
+      expect(detectAPISignatureChange('add new feature')).toBeNull();
+      expect(detectAPISignatureChange(null)).toBeNull();
+    });
+  });
+});

package/__tests__/semver.test.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { parseVersion, isPrerelease, getNextVersion, compareVersions } = require('../src/semver');
+
+describe('semver', () => {
+  describe('parseVersion', () => {
+    test('parses valid semver', () => {
+      const result = parseVersion('1.2.3');
+      expect(result).toBeTruthy();
+      if (result) {
+        expect(result.major).toBe(1);
+        expect(result.minor).toBe(2);
+        expect(result.patch).toBe(3);
+      }
+    });
+
+    test('parses semver with v prefix', () => {
+      const result = parseVersion('v1.2.3');
+      expect(result).toBeTruthy();
+      if (result) {
+        expect(result.major).toBe(1);
+      }
+    });
+
+    test('parses prerelease version', () => {
+      const result = parseVersion('1.2.3-beta.1');
+      expect(result).toBeTruthy();
+    });
+
+    test('returns null for invalid version', () => {
+      expect(parseVersion('not-a-version')).toBeNull();
+      expect(parseVersion('')).toBeNull();
+      expect(parseVersion('1')).toBeNull();
+    });
+  });
+
+  describe('isPrerelease', () => {
+    test('identifies prerelease versions', () => {
+      expect(isPrerelease('1.0.0-alpha.1')).toBe(true);
+      expect(isPrerelease('1.0.0-beta')).toBe(true);
+      expect(isPrerelease('1.0.0-rc.2')).toBe(true);
+    });
+
+    test('identifies stable versions', () => {
+      expect(isPrerelease('1.0.0')).toBe(false);
+      expect(isPrerelease('2.3.4')).toBe(false);
+    });
+
+    test('handles v prefix', () => {
+      expect(isPrerelease('v1.0.0-alpha')).toBe(true);
+      expect(isPrerelease('v1.0.0')).toBe(false);
+    });
+  });
+
+  describe('compareVersions', () => {
+    test('returns positive for greater version', () => {
+      expect(compareVersions('2.0.0', '1.0.0')).toBeGreaterThan(0);
+    });
+
+    test('returns negative for lesser version', () => {
+      expect(compareVersions('1.0.0', '2.0.0')).toBeLessThan(0);
+    });
+
+    test('returns 0 for equal versions', () => {
+      expect(compareVersions('1.0.0', '1.0.0')).toBe(0);
+    });
+  });
+
+  describe('getNextVersion', () => {
+    test('bumps major for breaking changes', () => {
+      const commits = [
+        { commit: { message: 'feat: new api\n\nBREAKING CHANGE: old API removed' } },
+      ];
+      const result = getNextVersion(commits, '1.2.3');
+      expect(result).toMatch(/^2\.0\.0/);
+    });
+
+    test('bumps minor for features', () => {
+      const commits = [
+        { commit: { message: 'feat: new feature' } },
+      ];
+      const result = getNextVersion(commits, '1.2.3');
+      expect(result).toMatch(/^1\.3\.0/);
+    });
+
+    test('bumps patch for fixes', () => {
+      const commits = [
+        { commit: { message: 'fix: bug fix' } },
+      ];
+      const result = getNextVersion(commits, '1.2.3');
+      expect(result).toMatch(/^1\.2\.4/);
+    });
+  });
+});

package/__tests__/tones.test.js

@@ -0,0 +1,252 @@
+'use strict';
+
+const { getTone, TONES, isValidTone, ProfessionalTone, CasualTone, HumorousTone, TechnicalTone } = require('../src/tones');
+
+/**
+ * Create sample release data for testing.
+ */
+function createSampleData(overrides = {}) {
+  return {
+    version: '2.1.0',
+    previousVersion: '2.0.0',
+    date: '2025-01-15',
+    summary: 'Release v2.1.0 with 3 features and 2 fixes.',
+    categories: {
+      '🚀 Features': [
+        { description: 'Added user avatar upload', type: 'feat', scope: 'api' },
+        { description: 'Added dark mode', type: 'feat', scope: 'ui' },
+      ],
+      '🐛 Bug Fixes': [
+        { description: 'Fixed login timeout', type: 'fix', scope: 'auth' },
+      ],
+    },
+    breaking: [
+      { description: 'Removed old API endpoint', scope: 'api', type: 'feat', migration_guide: 'Use new endpoint' },
+    ],
+    contributors: [
+      { login: 'alice', commits_count: 3, is_first_time: false },
+      { login: 'bob', commits_count: 1, is_first_time: true },
+    ],
+    repoUrl: 'https://github.com/acme/app',
+    ...overrides,
+  };
+}
+
+describe('tones', () => {
+  describe('tone factory', () => {
+    test('getTone returns ProfessionalTone', () => {
+      const t = getTone('professional');
+      expect(t).toBeInstanceOf(ProfessionalTone);
+      expect(t.name).toBe('professional');
+    });
+
+    test('getTone returns CasualTone', () => {
+      const t = getTone('casual');
+      expect(t).toBeInstanceOf(CasualTone);
+      expect(t.name).toBe('casual');
+    });
+
+    test('getTone returns HumorousTone', () => {
+      const t = getTone('humorous');
+      expect(t).toBeInstanceOf(HumorousTone);
+      expect(t.name).toBe('humorous');
+    });
+
+    test('getTone returns TechnicalTone', () => {
+      const t = getTone('technical');
+      expect(t).toBeInstanceOf(TechnicalTone);
+      expect(t.name).toBe('technical');
+    });
+
+    test('getTone throws for unknown tone', () => {
+      expect(() => getTone('sarcastic')).toThrow('Unknown tone');
+    });
+
+    test('TONES contains all tone types', () => {
+      expect(TONES).toEqual(['professional', 'casual', 'humorous', 'technical']);
+    });
+
+    test('isValidTone validates correctly', () => {
+      expect(isValidTone('professional')).toBe(true);
+      expect(isValidTone('casual')).toBe(true);
+      expect(isValidTone('unknown')).toBe(false);
+    });
+  });
+
+  describe('ProfessionalTone', () => {
+    test('applies professional language to summary', () => {
+      const data = createSampleData();
+      const tone = new ProfessionalTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain('We are pleased to announce');
+      expect(result.summary).toContain('2.1.0');
+    });
+
+    test('renames categories to professional names', () => {
+      const data = createSampleData();
+      const tone = new ProfessionalTone();
+      const result = tone.apply(data);
+
+      const categories = Object.keys(result.categories);
+      expect(categories.some(c => c.includes('New Features'))).toBe(true);
+      expect(categories.some(c => c.includes('Bug Fixes'))).toBe(true);
+    });
+
+    test('handles data without categories', () => {
+      const data = createSampleData({ categories: {} });
+      const tone = new ProfessionalTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain('2.1.0');
+    });
+  });
+
+  describe('CasualTone', () => {
+    test('applies casual language to summary', () => {
+      const data = createSampleData();
+      const tone = new CasualTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain("Here's what's new");
+      expect(result.summary).toContain('v2.1.0');
+    });
+
+    test('adds emojis to category names', () => {
+      const data = createSampleData();
+      const tone = new CasualTone();
+      const result = tone.apply(data);
+
+      const categories = Object.keys(result.categories);
+      expect(categories.some(c => c.includes(':rocket:') || c.includes(':bug:'))).toBe(true);
+    });
+
+    test('adds exclamation to feature descriptions', () => {
+      const data = createSampleData();
+      const tone = new CasualTone();
+      const result = tone.apply(data);
+
+      const featCategory = Object.keys(result.categories).find(c => c.includes('Cool'));
+      if (featCategory) {
+        const changes = result.categories[featCategory];
+        expect(changes.some(c => c.description.includes('!'))).toBe(true);
+      }
+    });
+
+    test('casual breaking changes include warning', () => {
+      const data = createSampleData();
+      const tone = new CasualTone();
+      const result = tone.apply(data);
+
+      expect(result.breaking[0].description).toContain('Watch out');
+    });
+  });
+
+  describe('HumorousTone', () => {
+    test('applies humorous language to summary', () => {
+      const data = createSampleData();
+      const tone = new HumorousTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain('v2.1.0');
+      // Should be funny - check for one of the known openings
+      const openings = ['Hold onto', 'Drumroll', 'Spoiler', 'Cue the', 'waiting for'];
+      expect(openings.some(o => result.summary.includes(o))).toBe(true);
+    });
+
+    test('uses humorous category names', () => {
+      const data = createSampleData();
+      const tone = new HumorousTone();
+      const result = tone.apply(data);
+
+      const categories = Object.keys(result.categories);
+      expect(categories.some(c => c.includes('New and Shiny') || c.includes('Bug Heaven'))).toBe(true);
+    });
+
+    test('adds humorous suffixes to feature descriptions', () => {
+      const data = createSampleData();
+      const tone = new HumorousTone();
+      const result = tone.apply(data);
+
+      const featCategory = Object.keys(result.categories).find(c => c.includes('Shiny'));
+      if (featCategory) {
+        const changes = result.categories[featCategory];
+        expect(changes.some(c =>
+          c.description.includes('love this') ||
+          c.description.includes('finally') ||
+          c.description.includes('really')
+        )).toBe(true);
+      }
+    });
+
+    test('adds funny prefixes to breaking changes', () => {
+      const data = createSampleData();
+      const tone = new HumorousTone();
+      const result = tone.apply(data);
+
+      const prefixes = ['Plot twist', 'Breaking news', 'Change of plans', 'In plot twist news'];
+      expect(prefixes.some(p => result.breaking[0].description.includes(p))).toBe(true);
+    });
+  });
+
+  describe('TechnicalTone', () => {
+    test('applies technical language to summary', () => {
+      const data = createSampleData();
+      const tone = new TechnicalTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain('v2.1.0');
+      expect(result.summary).toContain('MAJOR');
+    });
+
+    test('uses conventional commit prefixes in categories', () => {
+      const data = createSampleData();
+      const tone = new TechnicalTone();
+      const result = tone.apply(data);
+
+      const categories = Object.keys(result.categories);
+      expect(categories.some(c => c.startsWith('feat:') || c.startsWith('fix:'))).toBe(true);
+    });
+
+    test('includes scope in descriptions', () => {
+      const data = createSampleData();
+      const tone = new TechnicalTone();
+      const result = tone.apply(data);
+
+      const allChanges = Object.values(result.categories).flat();
+      expect(allChanges.some(c => c.description.includes('['))).toBe(true);
+    });
+
+    test('generates default migration guide for breaking changes', () => {
+      const data = createSampleData({
+        breaking: [{ description: 'Removed endpoint', scope: 'api', type: 'feat' }],
+      });
+      const tone = new TechnicalTone();
+      const result = tone.apply(data);
+
+      expect(result.breaking[0].migration_guide).toBeDefined();
+      expect(result.breaking[0].migration_guide).toContain('Migration Steps');
+    });
+
+    test('marks feature-only releases as MINOR', () => {
+      const data = createSampleData({ breaking: [] });
+      const tone = new TechnicalTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain('MINOR');
+    });
+
+    test('marks fix-only releases as PATCH', () => {
+      const data = createSampleData({
+        breaking: [],
+        categories: {
+          '🐛 Bug Fixes': [{ description: 'Fixed something', type: 'fix' }],
+        },
+      });
+      const tone = new TechnicalTone();
+      const result = tone.apply(data);
+
+      expect(result.summary).toContain('PATCH');
+    });
+  });
+});