@equilateral_ai/mindmeld 3.0.0

package/src/handlers/scheduled/analyzeGitHistory.js

@@ -0,0 +1,510 @@
+/**
+ * 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

@@ -0,0 +1,135 @@
+/**
+ * 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');
+});

package/src/handlers/scheduled/refreshActivity.js

@@ -0,0 +1,21 @@
+/**
+ * Refresh Activity Scheduled Job
+ * Refreshes materialized views for developer and project activity
+ *
+ * Schedule: Every 15 minutes
+ * Auth: None (Lambda scheduled event)
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
+
+exports.handler = wrapHandler(async (event, context) => {
+    // Refresh developer activity view
+    await executeQuery('SELECT rapport.refresh_developer_activity()');
+
+    // Refresh project activity view
+    await executeQuery('SELECT rapport.refresh_project_activity()');
+
+    return createSuccessResponse({
+        views_refreshed: ['developer_activity', 'project_activity']
+    }, 'Activity views refreshed');
+});