@equilateral_ai/mindmeld 3.5.3 → 4.0.2

package/src/handlers/scheduled/analyzeGitHistory.js

@@ -1,510 +0,0 @@
-/**
- * Analyze Git History Scheduled Job
- * Extracts BluOptima-style metrics from git repositories
- *
- * Schedule: Daily at 2am (or triggered via API)
- * Auth: None (Lambda scheduled event)
- *
- * Features:
- * - Commit frequency and volume metrics
- * - Working pattern analysis (time of day, day of week)
- * - File churn and bus factor detection
- * - Standards compliance scanning
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Main handler - wrapped with wrapHandler for consistent error handling
- */
-exports.handler = wrapHandler(async (event, context) => {
-    // Get all repositories that need analysis
-    const repos = await getRepositoriesToAnalyze();
-
-    if (repos.length === 0) {
-        return createSuccessResponse({ repositories_analyzed: 0 }, 'No repositories to analyze');
-    }
-
-    const results = [];
-    for (const repo of repos) {
-        try {
-            const result = await analyzeRepository(repo);
-            results.push({ repo_id: repo.repo_id, success: true, ...result });
-        } catch (error) {
-            results.push({ repo_id: repo.repo_id, success: false, error: error.message });
-        }
-    }
-
-    return createSuccessResponse({
-        repositories_analyzed: results.length,
-        results
-    }, 'Git history analysis complete');
-});
-
-/**
- * Get repositories due for analysis
- */
-async function getRepositoriesToAnalyze() {
-    const result = await executeQuery(`
-        SELECT repo_id, Company_ID, repo_url, repo_name, default_branch,
-               clone_path, last_commit_sha, settings
-        FROM rapport.git_repositories
-        WHERE last_analyzed_at IS NULL
-           OR last_analyzed_at < NOW() - INTERVAL '1 day'
-        ORDER BY last_analyzed_at ASC NULLS FIRST
-        LIMIT 10
-    `);
-    return result.rows;
-}
-
-/**
- * Analyze a single repository
- */
-async function analyzeRepository(repo) {
-    const periodEnd = new Date();
-    const periodStart = new Date();
-    periodStart.setDate(periodStart.getDate() - 7); // Last 7 days
-
-    // Get git log data
-    const gitLog = await fetchGitLog(repo, periodStart);
-
-    if (!gitLog || gitLog.length === 0) {
-        return { commits: 0, developers: 0 };
-    }
-
-    // Parse and aggregate metrics
-    const developerMetrics = aggregateDeveloperMetrics(gitLog, periodStart, periodEnd);
-    const fileMetrics = aggregateFileMetrics(gitLog, periodStart, periodEnd);
-    const workingPatterns = analyzeWorkingPatterns(gitLog, periodStart, periodEnd);
-
-    // Store metrics
-    await storeDeveloperMetrics(repo.repo_id, developerMetrics);
-    await storeFileMetrics(repo.repo_id, fileMetrics);
-    await storeWorkingPatterns(repo.repo_id, workingPatterns);
-
-    // Scan for standards compliance
-    const complianceResults = await scanForCompliance(repo, gitLog);
-
-    // Update bus factor analysis
-    await updateBusFactor(repo.repo_id);
-
-    // Mark repository as analyzed
-    await executeQuery(`
-        UPDATE rapport.git_repositories
-        SET last_analyzed_at = NOW(),
-            last_commit_sha = $2
-        WHERE repo_id = $1
-    `, [repo.repo_id, gitLog[0]?.sha || repo.last_commit_sha]);
-
-    return {
-        commits: gitLog.length,
-        developers: Object.keys(developerMetrics).length,
-        files: Object.keys(fileMetrics).length,
-        compliance: complianceResults
-    };
-}
-
-/**
- * Fetch git log via GitHub API or local clone
- * Returns array of commit objects
- */
-async function fetchGitLog(repo, since) {
-    // For now, use GitHub API. In production, could use local clone for speed
-    const sinceDate = since.toISOString();
-
-    // Parse owner/repo from URL
-    const match = repo.repo_url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
-    if (!match) {
-        console.warn(`Cannot parse GitHub URL: ${repo.repo_url}`);
-        return [];
-    }
-
-    const [, owner, repoName] = match;
-
-    // Use GitHub API via https
-    const https = require('https');
-
-    return new Promise((resolve, reject) => {
-        const options = {
-            hostname: 'api.github.com',
-            path: `/repos/${owner}/${repoName}/commits?since=${sinceDate}&per_page=100`,
-            method: 'GET',
-            headers: {
-                'User-Agent': 'MindMeld-GitAnalyzer/1.0',
-                'Accept': 'application/vnd.github.v3+json'
-            },
-            timeout: 30000
-        };
-
-        // Add auth if available
-        if (process.env.GITHUB_TOKEN) {
-            options.headers['Authorization'] = `token ${process.env.GITHUB_TOKEN}`;
-        }
-
-        const req = https.request(options, (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                try {
-                    if (res.statusCode !== 200) {
-                        console.warn(`GitHub API returned ${res.statusCode}: ${data}`);
-                        resolve([]);
-                        return;
-                    }
-                    const commits = JSON.parse(data);
-                    resolve(commits.map(c => ({
-                        sha: c.sha,
-                        message: c.commit.message,
-                        author_email: c.commit.author.email,
-                        author_name: c.commit.author.name,
-                        committed_at: new Date(c.commit.author.date),
-                        // Note: file stats require separate API call per commit
-                        files: []
-                    })));
-                } catch (e) {
-                    reject(e);
-                }
-            });
-        });
-
-        req.on('error', reject);
-        req.on('timeout', () => {
-            req.destroy();
-            reject(new Error('GitHub API timeout'));
-        });
-
-        req.end();
-    });
-}
-
-/**
- * Aggregate developer metrics from git log
- */
-function aggregateDeveloperMetrics(gitLog, periodStart, periodEnd) {
-    const metrics = {};
-
-    for (const commit of gitLog) {
-        const email = commit.author_email;
-
-        if (!metrics[email]) {
-            metrics[email] = {
-                developer_email: email,
-                developer_name: commit.author_name,
-                period_start: periodStart,
-                period_end: periodEnd,
-                commit_count: 0,
-                lines_added: 0,
-                lines_removed: 0,
-                files_changed: 0,
-                active_days: new Set(),
-                commit_times: [],
-                first_commit_time: null,
-                last_commit_time: null
-            };
-        }
-
-        const m = metrics[email];
-        m.commit_count++;
-
-        // Track active days
-        const dateStr = commit.committed_at.toISOString().split('T')[0];
-        m.active_days.add(dateStr);
-
-        // Track commit times
-        m.commit_times.push(commit.committed_at);
-
-        // Track first/last commit times
-        const timeStr = commit.committed_at.toTimeString().split(' ')[0];
-        if (!m.first_commit_time || commit.committed_at < new Date(`1970-01-01T${m.first_commit_time}`)) {
-            m.first_commit_time = timeStr;
-        }
-        if (!m.last_commit_time || commit.committed_at > new Date(`1970-01-01T${m.last_commit_time}`)) {
-            m.last_commit_time = timeStr;
-        }
-
-        // Aggregate file stats (if available)
-        if (commit.files) {
-            m.files_changed += commit.files.length;
-            for (const file of commit.files) {
-                m.lines_added += file.additions || 0;
-                m.lines_removed += file.deletions || 0;
-            }
-        }
-    }
-
-    // Finalize metrics
-    for (const email in metrics) {
-        const m = metrics[email];
-        m.active_days = m.active_days.size;
-        m.avg_commits_per_active_day = m.active_days > 0
-            ? (m.commit_count / m.active_days).toFixed(2)
-            : 0;
-        delete m.commit_times; // Don't store raw times
-    }
-
-    return metrics;
-}
-
-/**
- * Aggregate file metrics for churn analysis
- */
-function aggregateFileMetrics(gitLog, periodStart, periodEnd) {
-    const metrics = {};
-
-    for (const commit of gitLog) {
-        if (!commit.files) continue;
-
-        for (const file of commit.files) {
-            const filePath = file.filename || file.path;
-            if (!filePath) continue;
-
-            if (!metrics[filePath]) {
-                metrics[filePath] = {
-                    file_path: filePath,
-                    period_start: periodStart,
-                    period_end: periodEnd,
-                    change_count: 0,
-                    lines_added: 0,
-                    lines_removed: 0,
-                    contributors: new Set(),
-                    last_modified_by: null,
-                    last_modified_at: null
-                };
-            }
-
-            const m = metrics[filePath];
-            m.change_count++;
-            m.lines_added += file.additions || 0;
-            m.lines_removed += file.deletions || 0;
-            m.contributors.add(commit.author_email);
-            m.last_modified_by = commit.author_email;
-            m.last_modified_at = commit.committed_at;
-        }
-    }
-
-    // Finalize
-    for (const filePath in metrics) {
-        const m = metrics[filePath];
-        m.unique_contributors = m.contributors.size;
-        m.is_single_contributor = m.unique_contributors === 1;
-        m.bus_factor = m.unique_contributors;
-        delete m.contributors;
-    }
-
-    return metrics;
-}
-
-/**
- * Analyze working patterns (time of day, day of week)
- */
-function analyzeWorkingPatterns(gitLog, periodStart, periodEnd) {
-    const patterns = {};
-
-    for (const commit of gitLog) {
-        const email = commit.author_email;
-
-        if (!patterns[email]) {
-            patterns[email] = {
-                developer_email: email,
-                period_start: periodStart,
-                period_end: periodEnd,
-                commits_by_hour: {},
-                commits_by_day: {},
-                weekend_commits: 0,
-                after_hours_commits: 0
-            };
-        }
-
-        const p = patterns[email];
-        const hour = commit.committed_at.getHours();
-        const day = commit.committed_at.getDay();
-
-        // Count by hour
-        p.commits_by_hour[hour] = (p.commits_by_hour[hour] || 0) + 1;
-
-        // Count by day
-        p.commits_by_day[day] = (p.commits_by_day[day] || 0) + 1;
-
-        // Weekend commits (Sat=6, Sun=0)
-        if (day === 0 || day === 6) {
-            p.weekend_commits++;
-        }
-
-        // After hours (before 9am or after 6pm)
-        if (hour < 9 || hour >= 18) {
-            p.after_hours_commits++;
-        }
-    }
-
-    // Calculate peak hour/day
-    for (const email in patterns) {
-        const p = patterns[email];
-        p.peak_hour = findPeak(p.commits_by_hour);
-        p.peak_day = findPeak(p.commits_by_day);
-    }
-
-    return patterns;
-}
-
-function findPeak(obj) {
-    let maxKey = null;
-    let maxVal = 0;
-    for (const key in obj) {
-        if (obj[key] > maxVal) {
-            maxVal = obj[key];
-            maxKey = parseInt(key);
-        }
-    }
-    return maxKey;
-}
-
-/**
- * Store developer metrics in database
- */
-async function storeDeveloperMetrics(repoId, metrics) {
-    for (const email in metrics) {
-        const m = metrics[email];
-        await executeQuery(`
-            INSERT INTO rapport.developer_metrics (
-                repo_id, developer_email, developer_name,
-                period_start, period_end,
-                commit_count, lines_added, lines_removed, files_changed,
-                first_commit_time, last_commit_time,
-                active_days, avg_commits_per_active_day
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
-            ON CONFLICT (repo_id, developer_email, period_start, period_end)
-            DO UPDATE SET
-                commit_count = EXCLUDED.commit_count,
-                lines_added = EXCLUDED.lines_added,
-                lines_removed = EXCLUDED.lines_removed,
-                files_changed = EXCLUDED.files_changed,
-                first_commit_time = EXCLUDED.first_commit_time,
-                last_commit_time = EXCLUDED.last_commit_time,
-                active_days = EXCLUDED.active_days,
-                avg_commits_per_active_day = EXCLUDED.avg_commits_per_active_day
-        `, [
-            repoId, m.developer_email, m.developer_name,
-            m.period_start, m.period_end,
-            m.commit_count, m.lines_added, m.lines_removed, m.files_changed,
-            m.first_commit_time, m.last_commit_time,
-            m.active_days, m.avg_commits_per_active_day
-        ]);
-    }
-}
-
-/**
- * Store file metrics
- */
-async function storeFileMetrics(repoId, metrics) {
-    for (const filePath in metrics) {
-        const m = metrics[filePath];
-        await executeQuery(`
-            INSERT INTO rapport.file_metrics (
-                repo_id, file_path, period_start, period_end,
-                change_count, lines_added, lines_removed,
-                unique_contributors, is_single_contributor, bus_factor,
-                last_modified_by, last_modified_at
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
-            ON CONFLICT (repo_id, file_path, period_start, period_end)
-            DO UPDATE SET
-                change_count = EXCLUDED.change_count,
-                lines_added = EXCLUDED.lines_added,
-                lines_removed = EXCLUDED.lines_removed,
-                unique_contributors = EXCLUDED.unique_contributors,
-                is_single_contributor = EXCLUDED.is_single_contributor,
-                bus_factor = EXCLUDED.bus_factor,
-                last_modified_by = EXCLUDED.last_modified_by,
-                last_modified_at = EXCLUDED.last_modified_at
-        `, [
-            repoId, m.file_path, m.period_start, m.period_end,
-            m.change_count, m.lines_added, m.lines_removed,
-            m.unique_contributors, m.is_single_contributor, m.bus_factor,
-            m.last_modified_by, m.last_modified_at
-        ]);
-    }
-}
-
-/**
- * Store working patterns
- */
-async function storeWorkingPatterns(repoId, patterns) {
-    for (const email in patterns) {
-        const p = patterns[email];
-        await executeQuery(`
-            INSERT INTO rapport.working_patterns (
-                repo_id, developer_email, period_start, period_end,
-                commits_by_hour, commits_by_day,
-                peak_hour, peak_day,
-                weekend_commits, after_hours_commits
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-            ON CONFLICT (repo_id, developer_email, period_start, period_end)
-            DO UPDATE SET
-                commits_by_hour = EXCLUDED.commits_by_hour,
-                commits_by_day = EXCLUDED.commits_by_day,
-                peak_hour = EXCLUDED.peak_hour,
-                peak_day = EXCLUDED.peak_day,
-                weekend_commits = EXCLUDED.weekend_commits,
-                after_hours_commits = EXCLUDED.after_hours_commits
-        `, [
-            repoId, p.developer_email, p.period_start, p.period_end,
-            JSON.stringify(p.commits_by_hour), JSON.stringify(p.commits_by_day),
-            p.peak_hour, p.peak_day,
-            p.weekend_commits, p.after_hours_commits
-        ]);
-    }
-}
-
-/**
- * Scan commits for standards compliance
- */
-async function scanForCompliance(repo, gitLog) {
-    // Get patterns to scan for
-    const patternsResult = await executeQuery(`
-        SELECT pattern_id, pattern_name, pattern_type, language, regex_pattern, severity
-        FROM rapport.code_patterns
-        WHERE enabled = true
-    `);
-    const patterns = patternsResult.rows;
-
-    // This would need file content - for now, return placeholder
-    // In production, fetch file content via GitHub API or local clone
-    return {
-        scanned: false,
-        reason: 'File content scanning requires GitHub token with contents permission'
-    };
-}
-
-/**
- * Update bus factor analysis
- */
-async function updateBusFactor(repoId) {
-    await executeQuery(`
-        INSERT INTO rapport.knowledge_silos (repo_id, module_path, primary_contributor, contribution_percentage, total_contributors, risk_level)
-        SELECT
-            $1,
-            SUBSTRING(file_path FROM '^[^/]+'),
-            last_modified_by,
-            100.0 / NULLIF(unique_contributors, 0),
-            unique_contributors,
-            CASE
-                WHEN unique_contributors = 1 THEN 'critical'
-                WHEN unique_contributors = 2 THEN 'high'
-                WHEN unique_contributors <= 3 THEN 'medium'
-                ELSE 'low'
-            END
-        FROM rapport.file_metrics
-        WHERE repo_id = $1
-        AND is_single_contributor = true
-        ON CONFLICT (repo_id, module_path) DO UPDATE SET
-            primary_contributor = EXCLUDED.primary_contributor,
-            contribution_percentage = EXCLUDED.contribution_percentage,
-            total_contributors = EXCLUDED.total_contributors,
-            risk_level = EXCLUDED.risk_level,
-            last_analyzed_at = NOW()
-    `, [repoId]);
-}
-
-// Removed manual success/failure helpers - using wrapHandler pattern

package/src/handlers/scheduled/generateAlerts.js

@@ -1,135 +0,0 @@
-/**
- * Generate Alerts Scheduled Job
- * Generates attention alerts for developers who may need support
- *
- * Schedule: Every hour
- * Auth: None (Lambda scheduled event)
- *
- * Alert Types:
- * - stale_commits: No commits in X days
- * - low_conversion: Low session-to-commit conversion rate
- * - no_ai_usage: Active committer not using AI assistance
- * - high_violation_rate: Developer frequently violating standards
- * - stalled_patterns: Developer's patterns not maturing/being used
- * - declining_activity: Activity trending downward
- */
-
-const { wrapHandler, createSuccessResponse, executeQuery } = require('./helpers');
-const { AlertEngine, setExecuteQuery } = require('./core/AlertEngine');
-
-// Initialize AlertEngine with database connection
-setExecuteQuery(executeQuery);
-
-// Configuration can be overridden via environment variables
-const getThresholdConfig = () => {
-    const config = {};
-
-    // Stale commits config
-    if (process.env.ALERT_STALE_COMMITS_CRITICAL_DAYS) {
-        config.staleCommits = config.staleCommits || {};
-        config.staleCommits.criticalDays = parseInt(process.env.ALERT_STALE_COMMITS_CRITICAL_DAYS);
-    }
-    if (process.env.ALERT_STALE_COMMITS_WARNING_DAYS) {
-        config.staleCommits = config.staleCommits || {};
-        config.staleCommits.warningDays = parseInt(process.env.ALERT_STALE_COMMITS_WARNING_DAYS);
-    }
-    if (process.env.ALERT_STALE_COMMITS_INFO_DAYS) {
-        config.staleCommits = config.staleCommits || {};
-        config.staleCommits.infoDays = parseInt(process.env.ALERT_STALE_COMMITS_INFO_DAYS);
-    }
-
-    // Low conversion config
-    if (process.env.ALERT_LOW_CONVERSION_MIN_SESSIONS) {
-        config.lowConversion = config.lowConversion || {};
-        config.lowConversion.minSessions = parseInt(process.env.ALERT_LOW_CONVERSION_MIN_SESSIONS);
-    }
-    if (process.env.ALERT_LOW_CONVERSION_THRESHOLD) {
-        config.lowConversion = config.lowConversion || {};
-        config.lowConversion.infoThreshold = parseInt(process.env.ALERT_LOW_CONVERSION_THRESHOLD);
-    }
-
-    // High violation config
-    if (process.env.ALERT_VIOLATION_RATE_CRITICAL) {
-        config.highViolationRate = config.highViolationRate || {};
-        config.highViolationRate.criticalThreshold = parseInt(process.env.ALERT_VIOLATION_RATE_CRITICAL);
-    }
-    if (process.env.ALERT_VIOLATION_RATE_WARNING) {
-        config.highViolationRate = config.highViolationRate || {};
-        config.highViolationRate.warningThreshold = parseInt(process.env.ALERT_VIOLATION_RATE_WARNING);
-    }
-
-    // Aggregation config
-    if (process.env.ALERT_COOLDOWN_HOURS) {
-        config.aggregation = config.aggregation || {};
-        config.aggregation.cooldownHours = parseInt(process.env.ALERT_COOLDOWN_HOURS);
-    }
-    if (process.env.ALERT_EXPIRATION_DAYS) {
-        config.aggregation = config.aggregation || {};
-        config.aggregation.expirationDays = parseInt(process.env.ALERT_EXPIRATION_DAYS);
-    }
-
-    // Feature flags to disable specific alert types
-    if (process.env.ALERT_DISABLE_STALE_COMMITS === 'true') {
-        config.staleCommits = config.staleCommits || {};
-        config.staleCommits.enabled = false;
-    }
-    if (process.env.ALERT_DISABLE_LOW_CONVERSION === 'true') {
-        config.lowConversion = config.lowConversion || {};
-        config.lowConversion.enabled = false;
-    }
-    if (process.env.ALERT_DISABLE_NO_AI_USAGE === 'true') {
-        config.noAiUsage = config.noAiUsage || {};
-        config.noAiUsage.enabled = false;
-    }
-    if (process.env.ALERT_DISABLE_VIOLATION_RATE === 'true') {
-        config.highViolationRate = config.highViolationRate || {};
-        config.highViolationRate.enabled = false;
-    }
-    if (process.env.ALERT_DISABLE_STALLED_PATTERNS === 'true') {
-        config.stalledPatterns = config.stalledPatterns || {};
-        config.stalledPatterns.enabled = false;
-    }
-    if (process.env.ALERT_DISABLE_DECLINING_ACTIVITY === 'true') {
-        config.decliningActivity = config.decliningActivity || {};
-        config.decliningActivity.enabled = false;
-    }
-
-    return config;
-};
-
-exports.handler = wrapHandler(async (event, context) => {
-    console.log('[GenerateAlerts] Starting scheduled alert generation');
-
-    // Get optional company filter from event (for testing or targeted runs)
-    const companyId = event?.companyId || null;
-    const dryRun = event?.dryRun || process.env.ALERT_DRY_RUN === 'true';
-
-    // Initialize AlertEngine with configuration
-    const thresholds = getThresholdConfig();
-    const alertEngine = new AlertEngine({
-        thresholds,
-        dryRun
-    });
-
-    // Log configuration for debugging
-    console.log('[GenerateAlerts] Configuration:', {
-        companyId: companyId || 'all',
-        dryRun,
-        thresholdsOverride: Object.keys(thresholds).length > 0 ? thresholds : 'defaults'
-    });
-
-    // Generate alerts
-    const summary = await alertEngine.generateAlerts(companyId);
-
-    console.log('[GenerateAlerts] Completed:', summary);
-
-    return createSuccessResponse({
-        alerts_created: summary.alertsCreated,
-        alerts_expired: summary.alertsExpired,
-        by_type: summary.byType,
-        errors: summary.errors,
-        started_at: summary.startedAt,
-        completed_at: summary.completedAt,
-        dry_run: dryRun
-    }, 'Alerts generated successfully');
-});