@equilateral_ai/mindmeld 3.0.0

package/src/handlers/correlations/correlationsProjectGet.js

@@ -0,0 +1,161 @@
+/**
+ * Get Project Correlations Handler
+ * Returns session-to-commit correlation data for a specific project
+ *
+ * GET /api/correlations/project/{projectId}
+ * Query params:
+ *   - lookbackDays (optional, default: 30)
+ *
+ * Returns:
+ *   - Project productivity metrics
+ *   - Developer breakdown
+ *   - Pattern effectiveness for project
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+const { CorrelationAnalyzer } = require('../../core/CorrelationAnalyzer');
+
+exports.handler = wrapHandler(async (event, context) => {
+    // Extract user email from Cognito claims
+    const email = event.requestContext?.authorizer?.claims?.email;
+    if (!email) {
+        return createErrorResponse(401, 'Unauthorized - no email in claims');
+    }
+
+    // Get project ID from path parameters
+    const projectId = event.pathParameters?.projectId;
+    if (!projectId) {
+        return createErrorResponse(400, 'Project ID is required');
+    }
+
+    // Parse query parameters
+    const queryParams = event.queryStringParameters || {};
+    const lookbackDays = parseInt(queryParams.lookbackDays) || 30;
+
+    // Verify user has access to this project
+    const accessResult = await executeQuery(`
+        SELECT p.project_id, p.project_name, p.company_id
+        FROM rapport.projects p
+        JOIN rapport.project_collaborators pc ON p.project_id = pc.project_id
+        WHERE p.project_id = $1
+        AND pc.email_address = $2
+    `, [projectId, email]);
+
+    if (accessResult.rows.length === 0) {
+        return createErrorResponse(403, 'Access denied to this project');
+    }
+
+    const project = accessResult.rows[0];
+
+    // Initialize analyzer
+    const analyzer = new CorrelationAnalyzer();
+
+    // Get project productivity metrics
+    const projectMetrics = await analyzer.getProjectProductivity(projectId, lookbackDays);
+
+    // Get developer breakdown for the project
+    const developerBreakdown = await getDeveloperBreakdown(projectId, lookbackDays);
+
+    // Get pattern effectiveness for this project
+    const patternEffectiveness = await analyzer.getPatternEffectiveness(projectId, lookbackDays);
+
+    // Get recent correlations
+    const recentCorrelations = await getRecentCorrelations(projectId, 10);
+
+    return createSuccessResponse({
+        project: {
+            projectId: project.project_id,
+            projectName: project.project_name,
+            companyId: project.company_id
+        },
+        metrics: projectMetrics,
+        developerBreakdown,
+        patternEffectiveness,
+        recentCorrelations
+    });
+});
+
+/**
+ * Get developer breakdown for a project
+ */
+async function getDeveloperBreakdown(projectId, lookbackDays) {
+    const query = `
+        SELECT
+            sc.email_address,
+            u."User_Display_Name" as display_name,
+            COUNT(*) as total_sessions,
+            COUNT(*) FILTER (WHERE sc.has_commits = true) as productive_sessions,
+            ROUND(
+                COUNT(*) FILTER (WHERE sc.has_commits = true)::decimal /
+                NULLIF(COUNT(*), 0) * 100,
+                1
+            ) as conversion_rate,
+            SUM(sc.commit_count) as total_commits,
+            SUM(sc.total_insertions) as total_insertions,
+            SUM(sc.total_deletions) as total_deletions,
+            ROUND(AVG(sc.session_duration_seconds) / 60, 0) as avg_session_minutes,
+            MAX(sc.session_started_at) as last_session
+        FROM rapport.session_correlations sc
+        JOIN "Users" u ON sc.email_address = u."Email_Address"
+        WHERE sc.project_id = $1
+        AND sc.session_started_at > NOW() - INTERVAL '${lookbackDays} days'
+        GROUP BY sc.email_address, u."User_Display_Name"
+        ORDER BY total_commits DESC NULLS LAST
+    `;
+
+    const result = await executeQuery(query, [projectId]);
+
+    return result.rows.map(row => ({
+        email: row.email_address,
+        displayName: row.display_name,
+        totalSessions: parseInt(row.total_sessions) || 0,
+        productiveSessions: parseInt(row.productive_sessions) || 0,
+        conversionRate: parseFloat(row.conversion_rate) || 0,
+        totalCommits: parseInt(row.total_commits) || 0,
+        totalInsertions: parseInt(row.total_insertions) || 0,
+        totalDeletions: parseInt(row.total_deletions) || 0,
+        avgSessionMinutes: parseInt(row.avg_session_minutes) || 0,
+        lastSession: row.last_session
+    }));
+}
+
+/**
+ * Get recent correlations for a project
+ */
+async function getRecentCorrelations(projectId, limit) {
+    const query = `
+        SELECT
+            sc.session_id,
+            sc.email_address,
+            u."User_Display_Name" as display_name,
+            sc.session_started_at,
+            sc.session_duration_seconds,
+            sc.has_commits,
+            sc.commit_count,
+            sc.total_insertions,
+            sc.total_deletions,
+            sc.correlation_type,
+            sc.correlation_score
+        FROM rapport.session_correlations sc
+        JOIN "Users" u ON sc.email_address = u."Email_Address"
+        WHERE sc.project_id = $1
+        ORDER BY sc.session_started_at DESC
+        LIMIT $2
+    `;
+
+    const result = await executeQuery(query, [projectId, limit]);
+
+    return result.rows.map(row => ({
+        sessionId: row.session_id,
+        email: row.email_address,
+        displayName: row.display_name,
+        sessionStarted: row.session_started_at,
+        sessionDurationMinutes: Math.round((row.session_duration_seconds || 0) / 60),
+        hasCommits: row.has_commits,
+        commitCount: row.commit_count,
+        totalInsertions: row.total_insertions,
+        totalDeletions: row.total_deletions,
+        correlationType: row.correlation_type,
+        correlationScore: parseFloat(row.correlation_score) || 0
+    }));
+}

package/src/handlers/github/githubConnectionStatus.js

@@ -0,0 +1,49 @@
+/**
+ * GitHub Connection Status Handler
+ * Returns current GitHub connection status
+ *
+ * GET /api/github/status (CognitoAuthorizer)
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('../helpers');
+
+async function githubConnectionStatus({ requestContext }) {
+    try {
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        // Check for active connection
+        const connResult = await executeQuery(`
+            SELECT github_username, connected_at, last_used_at
+            FROM rapport.github_connections
+            WHERE email_address = $1 AND revoked = FALSE
+        `, [email]);
+
+        const connected = connResult.rowCount > 0;
+        const github_username = connected ? connResult.rows[0].github_username : null;
+
+        // Count projects with GitHub connected
+        const projectsResult = await executeQuery(`
+            SELECT COUNT(*) as count FROM rapport.projects p
+            JOIN rapport.project_collaborators pc ON p.project_id = pc.project_id
+            WHERE pc.email_address = $1
+            AND p.github_owner IS NOT NULL
+            AND p.archived = FALSE
+        `, [email]);
+
+        const projects_connected = parseInt(projectsResult.rows[0].count);
+
+        return createSuccessResponse(
+            { connected, github_username, projects_connected },
+            'Status retrieved'
+        );
+    } catch (error) {
+        console.error('GitHub Status Error:', error);
+        return createErrorResponse(500, 'Failed to get connection status');
+    }
+}
+
+exports.handler = wrapHandler(githubConnectionStatus);

package/src/handlers/github/githubDiscoverPatterns.js

@@ -0,0 +1,364 @@
+/**
+ * GitHub Discover Patterns Handler
+ * Analyzes a GitHub repo to discover coding patterns
+ *
+ * POST /api/github/discover (CognitoAuthorizer)
+ * Body: { project_id, owner, repo, branch }
+ * Timeout: 120s, Memory: 512MB
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('../helpers');
+const crypto = require('crypto');
+const https = require('https');
+
+function httpsGet(path, token) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: 'api.github.com',
+            path: path,
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'User-Agent': 'MindMeld-App',
+                'Accept': 'application/json'
+            }
+        }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    resolve({ statusCode: res.statusCode, body: JSON.parse(data) });
+                } catch (e) {
+                    resolve({ statusCode: res.statusCode, body: data });
+                }
+            });
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+
+function decryptToken(encryptedData, key) {
+    const [ivHex, encrypted] = encryptedData.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+
+async function githubDiscoverPatterns({ body, requestContext }) {
+    try {
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const { project_id, owner, repo, branch } = body;
+        if (!project_id || !owner || !repo) {
+            return createErrorResponse(400, 'project_id, owner, and repo are required');
+        }
+
+        const targetBranch = branch || 'main';
+
+        // Verify user has access to project
+        const accessResult = await executeQuery(`
+            SELECT role FROM rapport.project_collaborators
+            WHERE project_id = $1 AND email_address = $2
+        `, [project_id, email]);
+
+        if (accessResult.rowCount === 0) {
+            return createErrorResponse(403, 'Access denied to project');
+        }
+
+        // Get decrypted token
+        const connResult = await executeQuery(`
+            SELECT access_token_encrypted FROM rapport.github_connections
+            WHERE email_address = $1 AND revoked = FALSE
+        `, [email]);
+
+        if (connResult.rowCount === 0) {
+            return createErrorResponse(404, 'No GitHub connection found');
+        }
+
+        const encryptionKey = process.env.GITHUB_TOKEN_ENCRYPTION_KEY;
+        const accessToken = decryptToken(connResult.rows[0].access_token_encrypted, encryptionKey);
+
+        // Fetch repo data in parallel
+        const [languagesRes, treeRes, commitsRes] = await Promise.all([
+            httpsGet(`/repos/${owner}/${repo}/languages`, accessToken),
+            httpsGet(`/repos/${owner}/${repo}/git/trees/${targetBranch}?recursive=1`, accessToken),
+            httpsGet(`/repos/${owner}/${repo}/commits?per_page=50`, accessToken)
+        ]);
+
+        const discoveries = [];
+
+        // --- Analyze Languages (tech_stack) ---
+        if (languagesRes.statusCode === 200 && languagesRes.body) {
+            const languages = languagesRes.body;
+            const totalBytes = Object.values(languages).reduce((a, b) => a + b, 0);
+
+            for (const [lang, bytes] of Object.entries(languages)) {
+                const percentage = bytes / totalBytes;
+                if (percentage >= 0.05) { // At least 5% of codebase
+                    discoveries.push({
+                        discovery_type: 'tech_stack',
+                        pattern_name: `Primary language: ${lang}`,
+                        pattern_description: `${lang} makes up ${Math.round(percentage * 100)}% of the codebase`,
+                        confidence: Math.min(percentage * 2, 0.99),
+                        evidence: [{ source: 'languages_api', percentage: Math.round(percentage * 100) }]
+                    });
+                }
+            }
+        }
+
+        // --- Analyze File Tree (architecture, testing, ci_cd, naming) ---
+        if (treeRes.statusCode === 200 && treeRes.body?.tree) {
+            const tree = treeRes.body.tree;
+            const files = tree.filter(t => t.type === 'blob').map(t => t.path);
+            const dirs = tree.filter(t => t.type === 'tree').map(t => t.path);
+
+            // Detect test framework
+            const testFiles = files.filter(f =>
+                f.includes('.test.') || f.includes('.spec.') || f.includes('__tests__/')
+            );
+            if (testFiles.length > 0) {
+                const isJest = testFiles.some(f => f.endsWith('.test.js') || f.endsWith('.test.ts'));
+                const isMocha = files.some(f => f.includes('.mocharc') || f.includes('mocha'));
+                const isPytest = testFiles.some(f => f.startsWith('test_') || f.includes('/test_'));
+
+                let framework = 'Unknown';
+                if (isJest) framework = 'Jest';
+                else if (isMocha) framework = 'Mocha';
+                else if (isPytest) framework = 'pytest';
+
+                discoveries.push({
+                    discovery_type: 'testing',
+                    pattern_name: `Test framework: ${framework}`,
+                    pattern_description: `Found ${testFiles.length} test files using ${framework} conventions`,
+                    confidence: Math.min(testFiles.length / 10, 0.95),
+                    evidence: [{ source: 'file_tree', test_files_count: testFiles.length, sample: testFiles.slice(0, 5) }]
+                });
+            }
+
+            // Detect CI/CD
+            const ciFiles = files.filter(f =>
+                f.startsWith('.github/workflows/') || f === '.gitlab-ci.yml' ||
+                f === 'Jenkinsfile' || f === '.circleci/config.yml'
+            );
+            if (ciFiles.length > 0) {
+                const ciTool = ciFiles[0].startsWith('.github/') ? 'GitHub Actions' :
+                    ciFiles[0].includes('gitlab') ? 'GitLab CI' :
+                    ciFiles[0] === 'Jenkinsfile' ? 'Jenkins' : 'CircleCI';
+
+                discoveries.push({
+                    discovery_type: 'ci_cd',
+                    pattern_name: `CI/CD: ${ciTool}`,
+                    pattern_description: `Uses ${ciTool} with ${ciFiles.length} workflow file(s)`,
+                    confidence: 0.95,
+                    evidence: [{ source: 'file_tree', ci_files: ciFiles }]
+                });
+            }
+
+            // Detect Docker
+            const dockerFiles = files.filter(f =>
+                f === 'Dockerfile' || f === 'docker-compose.yml' || f === 'docker-compose.yaml' ||
+                f.endsWith('/Dockerfile')
+            );
+            if (dockerFiles.length > 0) {
+                discoveries.push({
+                    discovery_type: 'ci_cd',
+                    pattern_name: 'Containerization: Docker',
+                    pattern_description: `Found ${dockerFiles.length} Docker configuration file(s)`,
+                    confidence: 0.9,
+                    evidence: [{ source: 'file_tree', docker_files: dockerFiles }]
+                });
+            }
+
+            // Detect architecture patterns
+            const srcDirs = dirs.filter(d => d.split('/').length <= 2);
+            const hasSrcDir = srcDirs.some(d => d === 'src' || d.startsWith('src/'));
+            const hasLibDir = srcDirs.some(d => d === 'lib' || d.startsWith('lib/'));
+            const hasComponentsDir = dirs.some(d => d.includes('components'));
+            const hasPagesDir = dirs.some(d => d.includes('pages') || d.includes('views'));
+            const hasHandlersDir = dirs.some(d => d.includes('handlers') || d.includes('controllers'));
+
+            if (hasComponentsDir && hasPagesDir) {
+                discoveries.push({
+                    discovery_type: 'architecture',
+                    pattern_name: 'Frontend: Component-based architecture',
+                    pattern_description: 'Uses components/ and pages/ directory structure (React/Vue/Svelte pattern)',
+                    confidence: 0.85,
+                    evidence: [{ source: 'file_tree', pattern: 'components_pages' }]
+                });
+            }
+
+            if (hasHandlersDir) {
+                discoveries.push({
+                    discovery_type: 'architecture',
+                    pattern_name: 'Backend: Handler/Controller pattern',
+                    pattern_description: 'Uses handlers/ or controllers/ for request handling',
+                    confidence: 0.8,
+                    evidence: [{ source: 'file_tree', pattern: 'handlers_controllers' }]
+                });
+            }
+
+            // Detect naming conventions
+            const jsFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+            const camelCaseFiles = jsFiles.filter(f => {
+                const name = f.split('/').pop().replace(/\.(js|ts|tsx|jsx)$/, '');
+                return /^[a-z][a-zA-Z]*$/.test(name);
+            });
+            const kebabCaseFiles = jsFiles.filter(f => {
+                const name = f.split('/').pop().replace(/\.(js|ts|tsx|jsx)$/, '');
+                return /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(name);
+            });
+            const pascalCaseFiles = jsFiles.filter(f => {
+                const name = f.split('/').pop().replace(/\.(js|ts|tsx|jsx)$/, '');
+                return /^[A-Z][a-zA-Z]*$/.test(name);
+            });
+
+            if (jsFiles.length > 5) {
+                let namingConvention = 'mixed';
+                let confidence = 0.5;
+                const total = jsFiles.length;
+
+                if (camelCaseFiles.length / total > 0.6) {
+                    namingConvention = 'camelCase';
+                    confidence = camelCaseFiles.length / total;
+                } else if (kebabCaseFiles.length / total > 0.6) {
+                    namingConvention = 'kebab-case';
+                    confidence = kebabCaseFiles.length / total;
+                } else if (pascalCaseFiles.length / total > 0.6) {
+                    namingConvention = 'PascalCase';
+                    confidence = pascalCaseFiles.length / total;
+                }
+
+                if (namingConvention !== 'mixed') {
+                    discoveries.push({
+                        discovery_type: 'naming',
+                        pattern_name: `File naming: ${namingConvention}`,
+                        pattern_description: `${Math.round(confidence * 100)}% of JS/TS files use ${namingConvention} naming`,
+                        confidence: Math.min(confidence, 0.95),
+                        evidence: [{ source: 'file_tree', convention: namingConvention, sample_count: jsFiles.length }]
+                    });
+                }
+            }
+
+            // Detect TypeScript
+            const tsFiles = files.filter(f => f.endsWith('.ts') || f.endsWith('.tsx'));
+            const tsconfigExists = files.some(f => f === 'tsconfig.json');
+            if (tsFiles.length > 0 && tsconfigExists) {
+                discoveries.push({
+                    discovery_type: 'tech_stack',
+                    pattern_name: 'TypeScript enabled',
+                    pattern_description: `Found ${tsFiles.length} TypeScript files with tsconfig.json`,
+                    confidence: 0.95,
+                    evidence: [{ source: 'file_tree', ts_files_count: tsFiles.length }]
+                });
+            }
+        }
+
+        // --- Analyze package.json if available ---
+        const pkgRes = await httpsGet(`/repos/${owner}/${repo}/contents/package.json`, accessToken);
+        if (pkgRes.statusCode === 200 && pkgRes.body?.content) {
+            try {
+                const pkgContent = JSON.parse(Buffer.from(pkgRes.body.content, 'base64').toString());
+
+                // Detect frameworks from dependencies
+                const allDeps = { ...pkgContent.dependencies, ...pkgContent.devDependencies };
+                const frameworks = [];
+
+                if (allDeps['react']) frameworks.push('React');
+                if (allDeps['next']) frameworks.push('Next.js');
+                if (allDeps['vue']) frameworks.push('Vue.js');
+                if (allDeps['express']) frameworks.push('Express');
+                if (allDeps['fastify']) frameworks.push('Fastify');
+                if (allDeps['@angular/core']) frameworks.push('Angular');
+                if (allDeps['svelte']) frameworks.push('Svelte');
+                if (allDeps['tailwindcss']) frameworks.push('Tailwind CSS');
+
+                for (const fw of frameworks) {
+                    discoveries.push({
+                        discovery_type: 'tech_stack',
+                        pattern_name: `Framework: ${fw}`,
+                        pattern_description: `${fw} is listed as a dependency`,
+                        confidence: 0.95,
+                        evidence: [{ source: 'package_json', dependency: fw.toLowerCase() }]
+                    });
+                }
+
+                // Detect test runner from devDeps
+                if (allDeps['jest'] || allDeps['@jest/core']) {
+                    // Only add if not already detected from file tree
+                    if (!discoveries.some(d => d.pattern_name.includes('Jest'))) {
+                        discoveries.push({
+                            discovery_type: 'testing',
+                            pattern_name: 'Test framework: Jest',
+                            pattern_description: 'Jest is configured as a dev dependency',
+                            confidence: 0.9,
+                            evidence: [{ source: 'package_json' }]
+                        });
+                    }
+                }
+            } catch (e) {
+                console.log('Failed to parse package.json:', e.message);
+            }
+        }
+
+        // --- Analyze Commit Patterns ---
+        if (commitsRes.statusCode === 200 && Array.isArray(commitsRes.body)) {
+            const commits = commitsRes.body;
+
+            // Detect conventional commits
+            const conventionalPattern = /^(feat|fix|chore|docs|style|refactor|test|perf|ci|build|revert)(\(.+\))?: /;
+            const conventionalCount = commits.filter(c =>
+                conventionalPattern.test(c.commit?.message || '')
+            ).length;
+
+            if (conventionalCount > commits.length * 0.3) {
+                discoveries.push({
+                    discovery_type: 'naming',
+                    pattern_name: 'Commit convention: Conventional Commits',
+                    pattern_description: `${Math.round(conventionalCount / commits.length * 100)}% of recent commits follow conventional commit format`,
+                    confidence: Math.min(conventionalCount / commits.length, 0.95),
+                    evidence: [{ source: 'commits', conventional_count: conventionalCount, total: commits.length }]
+                });
+            }
+        }
+
+        // Filter out low-confidence discoveries
+        const validDiscoveries = discoveries.filter(d => d.confidence >= 0.3);
+
+        // Update project with GitHub info
+        await executeQuery(`
+            UPDATE rapport.projects SET github_owner = $1, github_repo = $2
+            WHERE project_id = $3
+        `, [owner, repo, project_id]);
+
+        // Save discoveries to DB
+        for (const discovery of validDiscoveries) {
+            await executeQuery(`
+                INSERT INTO rapport.onboarding_discoveries (
+                    project_id, email_address, discovery_type, pattern_name,
+                    pattern_description, confidence, evidence
+                ) VALUES ($1, $2, $3, $4, $5, $6, $7)
+            `, [
+                project_id, email, discovery.discovery_type, discovery.pattern_name,
+                discovery.pattern_description, discovery.confidence,
+                JSON.stringify(discovery.evidence)
+            ]);
+        }
+
+        return createSuccessResponse(
+            { discoveries: validDiscoveries, count: validDiscoveries.length },
+            'Pattern discovery complete'
+        );
+    } catch (error) {
+        console.error('GitHub Discover Patterns Error:', error);
+        return createErrorResponse(500, 'Failed to discover patterns');
+    }
+}
+
+exports.handler = wrapHandler(githubDiscoverPatterns);