Merge pull request #444 from Juwonlo/impact

Implemented automated changelog generation

Author: Xhristin3

.github/workflows/generate-changelog.yml

@@ -0,0 +1,36 @@
+name: Generate Changelog
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to generate changelog for (e.g., v1.0.0)'
+        required: false
+
+jobs:
+  changelog:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+
+      - name: Generate Changelog
+        run: node scripts/generate-changelog.js
+
+      - name: Commit Changelog
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add CHANGELOG.md
+          git commit -m "docs(changelog): update for release [skip ci]" || echo "No changes to commit"
+          git push origin HEAD:main

recommendation-system/src/explainability/explainability.ts

@@ -14,7 +14,90 @@ import * as Types from '../types';
 // EXPLANATION GENERATOR
 // ============================================================================
 
+export interface ExplanationStrategy {
+  matches(dominantSignal: string): boolean;
+  extract(
+    rankingSignal: any,
+    userProfile: Types.UserProfile,
+    similarUsers?: string[]
+  ): {
+    primaryReason: string;
+    supportingSignals: string[];
+    featureAttribution: Array<{ feature: string; importance: number; contribution: string }>;
+  };
+}
+
+export class CollaborativeSignalStrategy implements ExplanationStrategy {
+  matches(signal: string): boolean { return signal === 'collaborativeSignal'; }
+  extract(rankingSignal: any, _userProfile: Types.UserProfile, similarUsers?: string[]) {
+    const result = { primaryReason: '', supportingSignals: [] as string[], featureAttribution: [] as any[] };
+    if (similarUsers && similarUsers.length > 0) {
+      result.primaryReason = `Users like you enjoyed this content`;
+      result.supportingSignals.push(`Liked by ${similarUsers.length} similar learners`);
+      result.featureAttribution.push({
+        feature: 'user_similarity',
+        importance: rankingSignal.collaborativeSignal,
+        contribution: `Based on similar learning patterns`,
+      });
+    }
+    return result;
+  }
+}
+
+export class ContentSignalStrategy implements ExplanationStrategy {
+  matches(signal: string): boolean { return signal === 'contentSignal'; }
+  extract(rankingSignal: any, userProfile: Types.UserProfile) {
+    const result = { primaryReason: '', supportingSignals: [] as string[], featureAttribution: [] as any[] };
+    result.primaryReason = `Matches your interests`;
+    const topics = Array.from(userProfile.features.topicAffinities.keys()).slice(0, 2);
+    result.supportingSignals.push(`Related to your interest in ${topics.join(' and ')}`);
+    result.featureAttribution.push({
+      feature: 'topic_match',
+      importance: rankingSignal.contentSignal,
+      contribution: `Content topic alignment with your profile`,
+    });
+    return result;
+  }
+}
+
+export class LearningPathSignalStrategy implements ExplanationStrategy {
+  matches(signal: string): boolean { return signal === 'learningPathSignal'; }
+  extract(rankingSignal: any) {
+    return {
+      primaryReason: `Recommended based on your learning path`,
+      supportingSignals: [`Prerequisite for your next goal`],
+      featureAttribution: [{
+        feature: 'learning_path_fit',
+        importance: rankingSignal.learningPathSignal,
+        contribution: `Aligns with recommended progression`,
+      }]
+    };
+  }
+}
+
+export class QualitySignalStrategy implements ExplanationStrategy {
+  matches(signal: string): boolean { return signal === 'qualitySignal'; }
+  extract(rankingSignal: any) {
+    return {
+      primaryReason: `High-quality content`,
+      supportingSignals: [`Highly rated by other learners`],
+      featureAttribution: [{
+        feature: 'content_quality',
+        importance: rankingSignal.qualitySignal,
+        contribution: `Strong engagement and completion metrics`,
+      }]
+    };
+  }
+}
+
 export class ExplanationGenerator {
+  private strategies: ExplanationStrategy[] = [
+    new CollaborativeSignalStrategy(),
+    new ContentSignalStrategy(),
+    new LearningPathSignalStrategy(),
+    new QualitySignalStrategy(),
+  ];
+
   /**
    * Generate explanation for a recommendation
    */
@@ -82,54 +165,11 @@ export class ExplanationGenerator {
     supportingSignals: string[];
     featureAttribution: Array<{ feature: string; importance: number; contribution: string }>;
   } {
-    const result = {
-      primaryReason: '',
-      supportingSignals: [] as string[],
-      featureAttribution: [] as Array<{ feature: string; importance: number; contribution: string }>,
-    };
-
-    switch (dominantSignal) {
-      case 'collaborativeSignal':
-        if (!similarUsers || similarUsers.length === 0) break; // Guard clause
-        result.primaryReason = `Users like you enjoyed this content`;
-        result.supportingSignals.push(`Liked by ${similarUsers.length} similar learners`);
-        result.featureAttribution.push({
-          feature: 'user_similarity',
-          importance: rankingSignal.collaborativeSignal,
-          contribution: `Based on similar learning patterns`,
-        });
-        break;
-      case 'contentSignal':
-        result.primaryReason = `Matches your interests`;
-        const topics = Array.from(userProfile.features.topicAffinities.keys()).slice(0, 2);
-        result.supportingSignals.push(`Related to your interest in ${topics.join(' and ')}`);
-        result.featureAttribution.push({
-          feature: 'topic_match',
-          importance: rankingSignal.contentSignal,
-          contribution: `Content topic alignment with your profile`,
-        });
-        break;
-      case 'learningPathSignal':
-        result.primaryReason = `Recommended based on your learning path`;
-        result.supportingSignals.push(`Prerequisite for your next goal`);
-        result.featureAttribution.push({
-          feature: 'learning_path_fit',
-          importance: rankingSignal.learningPathSignal,
-          contribution: `Aligns with recommended progression`,
-        });
-        break;
-      case 'qualitySignal':
-        result.primaryReason = `High-quality content`;
-        result.supportingSignals.push(`Highly rated by other learners`);
-        result.featureAttribution.push({
-          feature: 'content_quality',
-          importance: rankingSignal.qualitySignal,
-          contribution: `Strong engagement and completion metrics`,
-        });
-        break;
+    const strategy = this.strategies.find(s => s.matches(dominantSignal));
+    if (strategy) {
+      return strategy.extract(rankingSignal, userProfile, similarUsers);
     }
-
-    return result;
+    return { primaryReason: '', supportingSignals: [], featureAttribution: [] };
   }
 
   /**

recommendation-system/src/privacy/privacy.ts

@@ -421,6 +421,49 @@ export class DataMinimizer {
 // PRIVACY COMPLIANCE MANAGER
 // ============================================================================
 
+export class PrivacyComplianceManagerBuilder {
+  private anonymizer?: UserAnonymizer;
+  private dpEngine?: DifferentialPrivacyEngine;
+  private optOutManager?: OptOutManager;
+  private piiFilter?: PIIFilter;
+  private dataMinimizer?: DataMinimizer;
+
+  withAnonymizer(anonymizer: UserAnonymizer): this {
+    this.anonymizer = anonymizer;
+    return this;
+  }
+
+  withDifferentialPrivacy(dpEngine: DifferentialPrivacyEngine): this {
+    this.dpEngine = dpEngine;
+    return this;
+  }
+
+  withOptOutManager(optOutManager: OptOutManager): this {
+    this.optOutManager = optOutManager;
+    return this;
+  }
+
+  withPIIFilter(piiFilter: PIIFilter): this {
+    this.piiFilter = piiFilter;
+    return this;
+  }
+
+  withDataMinimizer(dataMinimizer: DataMinimizer): this {
+    this.dataMinimizer = dataMinimizer;
+    return this;
+  }
+
+  build(): PrivacyComplianceManager {
+    return new PrivacyComplianceManager(
+      this.anonymizer,
+      this.dpEngine,
+      this.optOutManager,
+      this.piiFilter,
+      this.dataMinimizer
+    );
+  }
+}
+
 export class PrivacyComplianceManager {
   private anonymizer: UserAnonymizer;
   private dpEngine: DifferentialPrivacyEngine;

scripts/generate-changelog.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+/**
+ * Automated Changelog Generator
+ * 
+ * Parses conventional commit messages, categorizes changes, 
+ * tracks versions based on git tags, and generates release notes.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function runCommand(command) {
+  try {
+    return execSync(command, { encoding: 'utf-8' }).trim();
+  } catch (error) {
+    return '';
+  }
+}
+
+function generateChangelog() {
+  console.log('Generating changelog...');
+
+  // Get tags sorted by semantic version
+  const tagsOutput = runCommand('git tag --sort=-v:refname');
+  const tags = tagsOutput.split('\n').filter(Boolean);
+  
+  let currentVersion = 'vUnreleased';
+  let previousTag = '';
+  let gitLogCmd = 'git log --format="%H|%s"';
+
+  if (tags.length > 0) {
+    currentVersion = tags[0];
+    if (tags.length > 1) {
+      previousTag = tags[1];
+      gitLogCmd = `git log ${previousTag}..${currentVersion} --format="%H|%s"`;
+    } else {
+      gitLogCmd = `git log ${currentVersion} --format="%H|%s"`;
+    }
+  }
+
+  const logOutput = runCommand(gitLogCmd);
+  if (!logOutput) {
+    console.log('No commits found for the current range.');
+    return;
+  }
+  
+  const commits = logOutput.split('\n').filter(Boolean);
+
+  // Categories for release notes
+  const categories = {
+    feat: { title: '🚀 Features', items: [] },
+    fix: { title: '🐛 Bug Fixes', items: [] },
+    security: { title: '🔒 Security', items: [] },
+    perf: { title: '⚡ Performance', items: [] },
+    refactor: { title: '♻️ Refactoring', items: [] },
+    docs: { title: '📚 Documentation', items: [] },
+    test: { title: '🧪 Testing', items: [] },
+    chore: { title: '🔧 Chores & Maintenance', items: [] },
+  };
+
+  const commitRegex = /^(feat|fix|docs|style|refactor|perf|test|chore|security)(?:\(([^)]+)\))?:\s*(.+)$/i;
+
+  commits.forEach(commitLine => {
+    const parts = commitLine.split('|');
+    if (parts.length < 2) return;
+    const hash = parts[0];
+    const subject = parts.slice(1).join('|');
+
+    const match = subject.match(commitRegex);
+    if (match) {
+      const type = match[1].toLowerCase();
+      const scope = match[2];
+      const message = match[3];
+
+      if (categories[type]) {
+        const shortHash = hash.substring(0, 7);
+        const scopeStr = scope ? `**${scope}:** ` : '';
+        categories[type].items.push(`- ${scopeStr}${message} (${shortHash})`);
+      }
+    }
+  });
+
+  const date = new Date().toISOString().split('T')[0];
+  let releaseNotes = `## [${currentVersion}] - ${date}\n\n`;
+  
+  if (previousTag) {
+    releaseNotes += `Compare with ${previousTag}\n\n`;
+  }
+
+  let hasChanges = false;
+  for (const key in categories) {
+    if (categories[key].items.length > 0) {
+      hasChanges = true;
+      releaseNotes += `### ${categories[key].title}\n\n`;
+      releaseNotes += categories[key].items.join('\n') + '\n\n';
+    }
+  }
+
+  if (!hasChanges) {
+    releaseNotes += 'No significant changes in this release.\n\n';
+  }
+
+  const changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+  let currentChangelog = '';
+  
+  if (fs.existsSync(changelogPath)) {
+    currentChangelog = fs.readFileSync(changelogPath, 'utf8');
+  } else {
+    currentChangelog = '# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n';
+  }
+
+  // Prevent duplicate entries for the same version
+  if (currentChangelog.includes(`## [${currentVersion}]`)) {
+    console.log(`Version ${currentVersion} already exists in CHANGELOG.md`);
+    return;
+  }
+
+  // Insert release notes after the main header
+  const headerMatch = currentChangelog.match(/^# Changelog[^\n]*\n+/i);
+  if (headerMatch) {
+    const header = headerMatch[0];
+    const rest = currentChangelog.substring(header.length);
+    fs.writeFileSync(changelogPath, header + releaseNotes + rest);
+  } else {
+    fs.writeFileSync(changelogPath, '# Changelog\n\n' + releaseNotes + currentChangelog);
+  }
+
+  console.log(`Successfully generated release notes for ${currentVersion}`);
+}
+
+generateChangelog();