@equilateral_ai/mindmeld 3.0.0

package/src/core/TeamLoadBearingDetector.js

@@ -0,0 +1,431 @@
+/**
+ * Team Load-Bearing Detector
+ *
+ * Extends LoadBearingDetector to aggregate across multiple team members.
+ *
+ * Key insight: Load-bearing context detection is more accurate when analyzing
+ * patterns across the entire team, not just individual users.
+ *
+ * Example:
+ * - User A: coordinate_system present = 90% success (10 handoffs)
+ * - User B: coordinate_system present = 92% success (15 handoffs)
+ * - Team aggregate: coordinate_system present = 91.2% success (25 handoffs)
+ * → Higher confidence in load-bearing classification
+ */
+
+const LoadBearingDetector = require('./LoadBearingDetector');
+
+class TeamLoadBearingDetector {
+  constructor(config = {}) {
+    // Configuration
+    this.config = {
+      correlationThreshold: config.correlationThreshold || 0.7,
+      minObservations: config.minObservations || 10,  // Higher threshold for team
+      minTeamMembers: config.minTeamMembers || 2,  // Need 2+ users for team analysis
+      ...config
+    };
+
+    // Per-user detectors
+    this.userDetectors = new Map();  // userId -> LoadBearingDetector
+
+    // Team-wide aggregation
+    this.teamLoadBearing = new Map();  // element key -> team statistics
+
+    // Team members
+    this.teamMembers = new Set();
+  }
+
+  /**
+   * Get or create detector for user
+   */
+  getDetectorForUser(userId) {
+    if (!this.userDetectors.has(userId)) {
+      this.userDetectors.set(userId, new LoadBearingDetector());
+      this.teamMembers.add(userId);
+    }
+
+    return this.userDetectors.get(userId);
+  }
+
+  /**
+   * Analyze handoff for specific user
+   */
+  analyzeHandoff(userId, handoff, outcome) {
+    const detector = this.getDetectorForUser(userId);
+
+    // Analyze for individual user
+    const result = detector.analyzeHandoff(handoff, outcome);
+
+    // Update team-wide aggregation
+    this.aggregateTeamStatistics();
+
+    return {
+      ...result,
+      teamLoadBearing: this.getTeamLoadBearing()
+    };
+  }
+
+  /**
+   * Aggregate load-bearing statistics across all team members
+   */
+  aggregateTeamStatistics() {
+    this.teamLoadBearing.clear();
+
+    // Collect all context elements from all users
+    for (const [userId, detector] of this.userDetectors.entries()) {
+      for (const [key, stats] of detector.contextElements.entries()) {
+        // Get or create team stats for this element
+        if (!this.teamLoadBearing.has(key)) {
+          this.teamLoadBearing.set(key, {
+            element: stats.element,
+            userStats: new Map(),  // userId -> user's stats for this element
+            aggregated: {
+              observations: 0,
+              presentAndSuccess: 0,
+              presentAndFailure: 0,
+              totalPresent: 0,
+              userCount: 0
+            }
+          });
+        }
+
+        const teamStats = this.teamLoadBearing.get(key);
+
+        // Store user's stats
+        teamStats.userStats.set(userId, stats);
+
+        // Aggregate across team
+        teamStats.aggregated.observations += stats.observations;
+        teamStats.aggregated.presentAndSuccess += stats.presentAndSuccess || 0;
+        teamStats.aggregated.presentAndFailure += stats.presentAndFailure || 0;
+        teamStats.aggregated.totalPresent += stats.totalPresent || 0;
+        teamStats.aggregated.userCount = teamStats.userStats.size;
+      }
+    }
+  }
+
+  /**
+   * Get team-wide load-bearing elements
+   */
+  getTeamLoadBearing() {
+    const loadBearing = [];
+
+    for (const [key, teamStats] of this.teamLoadBearing.entries()) {
+      const agg = teamStats.aggregated;
+
+      // Check minimum observations
+      if (agg.observations < this.config.minObservations) {
+        continue;
+      }
+
+      // Check minimum team members
+      if (agg.userCount < this.config.minTeamMembers) {
+        continue;
+      }
+
+      // Calculate team correlation
+      const correlation = agg.totalPresent > 0
+        ? agg.presentAndSuccess / agg.totalPresent
+        : 0;
+
+      if (correlation >= this.config.correlationThreshold) {
+        loadBearing.push({
+          element: teamStats.element,
+          correlation,
+          observations: agg.observations,
+          teamSize: agg.userCount,
+          confidence: this.calculateTeamConfidence(teamStats),
+          userBreakdown: this.getUserBreakdown(teamStats),
+          recommendation: 'LOAD_BEARING'
+        });
+      }
+    }
+
+    return loadBearing.sort((a, b) => b.correlation - a.correlation);
+  }
+
+  /**
+   * Calculate confidence in load-bearing classification based on team agreement
+   */
+  calculateTeamConfidence(teamStats) {
+    const agg = teamStats.aggregated;
+
+    // Factor 1: Observation count (more = higher confidence)
+    const observationConfidence = Math.min(agg.observations / 50, 1.0);
+
+    // Factor 2: Team size (more users = higher confidence)
+    const teamSizeConfidence = Math.min(agg.userCount / 5, 1.0);
+
+    // Factor 3: User agreement (all users see similar correlation)
+    const agreementConfidence = this.calculateUserAgreement(teamStats);
+
+    // Factor 4: Correlation strength
+    const correlation = agg.totalPresent > 0
+      ? agg.presentAndSuccess / agg.totalPresent
+      : 0;
+
+    // Weighted average
+    return (
+      observationConfidence * 0.2 +
+      teamSizeConfidence * 0.2 +
+      agreementConfidence * 0.3 +
+      correlation * 0.3
+    );
+  }
+
+  /**
+   * Calculate agreement across team members
+   *
+   * High agreement = all users see similar correlation
+   * Low agreement = users see different results
+   */
+  calculateUserAgreement(teamStats) {
+    const userCorrelations = [];
+
+    for (const [userId, stats] of teamStats.userStats.entries()) {
+      if (stats.totalPresent > 0) {
+        const correlation = stats.presentAndSuccess / stats.totalPresent;
+        userCorrelations.push(correlation);
+      }
+    }
+
+    if (userCorrelations.length < 2) {
+      return 0.5;  // Not enough data for agreement
+    }
+
+    // Calculate standard deviation
+    const mean = userCorrelations.reduce((a, b) => a + b, 0) / userCorrelations.length;
+    const variance = userCorrelations.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / userCorrelations.length;
+    const stdDev = Math.sqrt(variance);
+
+    // Low std dev = high agreement
+    // Agreement score: 1.0 - stdDev (capped at 0)
+    return Math.max(0, 1.0 - stdDev);
+  }
+
+  /**
+   * Get breakdown by user
+   */
+  getUserBreakdown(teamStats) {
+    const breakdown = [];
+
+    for (const [userId, stats] of teamStats.userStats.entries()) {
+      const correlation = stats.totalPresent > 0
+        ? stats.presentAndSuccess / stats.totalPresent
+        : 0;
+
+      breakdown.push({
+        userId,
+        observations: stats.observations,
+        correlation,
+        presentAndSuccess: stats.presentAndSuccess,
+        presentAndFailure: stats.presentAndFailure
+      });
+    }
+
+    return breakdown.sort((a, b) => b.correlation - a.correlation);
+  }
+
+  /**
+   * Apply team recommendations to decision frame
+   */
+  applyTeamRecommendations(decisionFrame, userId) {
+    const loadBearing = this.getTeamLoadBearing();
+    const recommendations = this.generateTeamRecommendations(loadBearing);
+
+    // Use individual user's detector to apply
+    const detector = this.getDetectorForUser(userId);
+    return detector.applyRecommendations(decisionFrame, recommendations);
+  }
+
+  /**
+   * Generate recommendations with team context
+   */
+  generateTeamRecommendations(loadBearing) {
+    const recommendations = [];
+
+    for (const lb of loadBearing) {
+      if (lb.element.type === 'constraint') {
+        recommendations.push({
+          type: 'mark_constraint_load_bearing',
+          constraint: lb.element.value,
+          reason: `Team-wide: ${(lb.correlation * 100).toFixed(1)}% success rate across ${lb.teamSize} users (${lb.observations} observations)`,
+          confidence: lb.confidence,
+          teamSize: lb.teamSize
+        });
+      }
+
+      if (lb.element.type === 'context_key') {
+        recommendations.push({
+          type: 'always_include_context',
+          key: lb.element.key,
+          reason: `Team-wide: ${(lb.correlation * 100).toFixed(1)}% success rate across ${lb.teamSize} users (${lb.observations} observations)`,
+          confidence: lb.confidence,
+          teamSize: lb.teamSize
+        });
+      }
+
+      if (lb.element.type === 'missing') {
+        recommendations.push({
+          type: 'prevent_missing_context',
+          key: lb.element.key,
+          reason: `Team-wide: ${(lb.correlation * 100).toFixed(1)}% failure rate when missing across ${lb.teamSize} users (${lb.observations} observations)`,
+          confidence: lb.confidence,
+          teamSize: lb.teamSize
+        });
+      }
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Get patterns shared across team
+   */
+  getSharedPatterns() {
+    const shared = [];
+
+    for (const [key, teamStats] of this.teamLoadBearing.entries()) {
+      if (teamStats.aggregated.userCount >= 2) {
+        const agg = teamStats.aggregated;
+        const correlation = agg.totalPresent > 0
+          ? agg.presentAndSuccess / agg.totalPresent
+          : 0;
+
+        if (correlation >= this.config.correlationThreshold) {
+          shared.push({
+            element: teamStats.element,
+            sharedBy: Array.from(teamStats.userStats.keys()),
+            correlation,
+            observations: agg.observations
+          });
+        }
+      }
+    }
+
+    return shared.sort((a, b) => b.sharedBy.length - a.sharedBy.length);
+  }
+
+  /**
+   * Get load-bearing elements discovered by one user but applicable to all
+   */
+  getCrossPollination() {
+    const crossPollinated = [];
+
+    for (const [key, teamStats] of this.teamLoadBearing.entries()) {
+      // Found by one user, but high correlation
+      if (teamStats.aggregated.userCount === 1) {
+        const userId = Array.from(teamStats.userStats.keys())[0];
+        const stats = teamStats.userStats.get(userId);
+
+        const correlation = stats.totalPresent > 0
+          ? stats.presentAndSuccess / stats.totalPresent
+          : 0;
+
+        if (correlation >= this.config.correlationThreshold && stats.observations >= 5) {
+          crossPollinated.push({
+            element: teamStats.element,
+            discoveredBy: userId,
+            correlation,
+            observations: stats.observations,
+            potentialForTeam: true,
+            recommendation: 'Share with team - high correlation in solo use'
+          });
+        }
+      }
+    }
+
+    return crossPollinated.sort((a, b) => b.correlation - a.correlation);
+  }
+
+  /**
+   * Get team summary
+   */
+  getTeamSummary() {
+    const summary = {
+      teamSize: this.teamMembers.size,
+      totalHandoffs: 0,
+      successfulHandoffs: 0,
+      teamLoadBearingElements: this.getTeamLoadBearing().length,
+      sharedPatterns: this.getSharedPatterns().length,
+      crossPollination: this.getCrossPollination().length,
+      byUser: {}
+    };
+
+    // Aggregate by user
+    for (const [userId, detector] of this.userDetectors.entries()) {
+      const userSummary = detector.getSummary();
+      summary.totalHandoffs += userSummary.totalHandoffs;
+      summary.successfulHandoffs += userSummary.successfulHandoffs;
+
+      summary.byUser[userId] = {
+        handoffs: userSummary.totalHandoffs,
+        successRate: userSummary.totalHandoffs > 0
+          ? userSummary.successfulHandoffs / userSummary.totalHandoffs
+          : 0,
+        loadBearingDetected: userSummary.loadBearingDetected
+      };
+    }
+
+    return summary;
+  }
+
+  /**
+   * Export team data
+   */
+  exportTeamData() {
+    return {
+      teamMembers: Array.from(this.teamMembers),
+      userDetectors: Object.fromEntries(
+        Array.from(this.userDetectors.entries()).map(([userId, detector]) => [
+          userId,
+          detector.exportData()
+        ])
+      ),
+      teamLoadBearing: Array.from(this.teamLoadBearing.entries()).map(([key, stats]) => ({
+        key,
+        element: stats.element,
+        aggregated: stats.aggregated,
+        userBreakdown: this.getUserBreakdown(stats)
+      }))
+    };
+  }
+
+  /**
+   * Import team data
+   */
+  importTeamData(exported) {
+    // Import team members
+    if (exported.teamMembers) {
+      for (const userId of exported.teamMembers) {
+        this.teamMembers.add(userId);
+      }
+    }
+
+    // Import user detectors
+    if (exported.userDetectors) {
+      for (const [userId, detectorData] of Object.entries(exported.userDetectors)) {
+        const detector = new LoadBearingDetector();
+
+        // Import handoff analysis
+        if (detectorData.handoffAnalysis) {
+          detector.handoffAnalysis = detectorData.handoffAnalysis;
+        }
+
+        // Import context elements
+        if (detectorData.contextElements) {
+          for (const elem of detectorData.contextElements) {
+            detector.contextElements.set(elem.key, elem);
+          }
+        }
+
+        this.userDetectors.set(userId, detector);
+      }
+    }
+
+    // Re-aggregate
+    this.aggregateTeamStatistics();
+  }
+}
+
+module.exports = TeamLoadBearingDetector;

package/src/database/dbOperations.js

@@ -0,0 +1,105 @@
+/**
+ * Rapport v3 - Database Operations
+ *
+ * Provides database query execution following Tim-Combo backend_handler_standards.md
+ * Uses cached single client (NOT connection pools) per Lambda database standards
+ */
+
+const { Client } = require('pg');
+
+// Cached client for connection reuse across warm Lambda invocations
+let cachedClient = null;
+
+/**
+ * Get or create database client
+ *
+ * Follows Lambda database standards:
+ * - NEVER use connection pools (Lambda handles one request at a time)
+ * - Cache single client for reuse across warm invocations
+ * - Use environment variables (NOT runtime SSM fetches)
+ *
+ * @returns {Promise<Client>} PostgreSQL client
+ */
+async function getClient() {
+    if (cachedClient && cachedClient._connected) {
+        return cachedClient;
+    }
+
+    const client = new Client({
+        host: process.env.DB_HOST,
+        port: process.env.DB_PORT || 5432,
+        database: process.env.DB_NAME,
+        user: process.env.DB_USER,
+        password: process.env.DB_PASSWORD,
+        ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+    });
+
+    await client.connect();
+    client._connected = true;
+
+    cachedClient = client;
+    return client;
+}
+
+/**
+ * Execute a database query
+ *
+ * Standard pattern from backend_handler_standards.md
+ *
+ * @param {string} query - SQL query
+ * @param {Array} params - Query parameters
+ * @returns {Promise<Object>} Query result
+ */
+async function executeQuery(query, params = []) {
+    const client = await getClient();
+
+    try {
+        const result = await client.query(query, params);
+        return result;
+    } catch (error) {
+        console.error('[dbOperations] Query error:', {
+            error: error.message,
+            query: query.substring(0, 200),
+            params: params
+        });
+        throw error;
+    }
+}
+
+/**
+ * Execute multiple queries in a transaction
+ *
+ * @param {Function} callback - Async function that receives client
+ * @returns {Promise<any>} Callback result
+ */
+async function executeTransaction(callback) {
+    const client = await getClient();
+
+    try {
+        await client.query('BEGIN');
+        const result = await callback(client);
+        await client.query('COMMIT');
+        return result;
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('[dbOperations] Transaction error:', error);
+        throw error;
+    }
+}
+
+/**
+ * Close database connection (for graceful shutdown)
+ */
+async function closeConnection() {
+    if (cachedClient) {
+        await cachedClient.end();
+        cachedClient = null;
+    }
+}
+
+module.exports = {
+    executeQuery,
+    executeTransaction,
+    closeConnection,
+    getClient
+};

package/src/handlers/activity/activityGetMe.js

@@ -0,0 +1,98 @@
+/**
+ * Activity Get Me Handler
+ * Retrieves current user's activity summary
+ *
+ * GET /api/activity/me
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+exports.handler = wrapHandler(async ({ requestContext }) => {
+    const Request_ID = requestContext.requestId;
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    // Get activity from materialized view
+    const result = await executeQuery(`
+        SELECT
+            email_address,
+            display_name,
+            sessions_30d,
+            sessions_7d,
+            last_session,
+            avg_session_duration_seconds,
+            commits_30d,
+            commits_7d,
+            last_commit,
+            days_since_commit,
+            prs_opened_30d,
+            prs_merged_30d,
+            avg_pr_review_hours,
+            commits_within_24h_of_session,
+            session_to_commit_conversion_pct
+        FROM rapport.mv_developer_activity
+        WHERE email_address = $1
+    `, [email]);
+
+    if (result.rowCount === 0) {
+        // Return empty activity for new users
+        return createSuccessResponse(
+            {
+                Records: [{
+                    email_address: email,
+                    sessions_30d: 0,
+                    sessions_7d: 0,
+                    commits_30d: 0,
+                    commits_7d: 0,
+                    prs_opened_30d: 0,
+                    prs_merged_30d: 0,
+                    session_to_commit_conversion_pct: 0
+                }]
+            },
+            'Activity retrieved (new user)',
+            { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
+        );
+    }
+
+    const activity = result.rows[0];
+
+    return createSuccessResponse(
+        {
+            Records: [{
+                email_address: activity.email_address,
+                display_name: activity.display_name,
+                sessions: {
+                    last_30_days: parseInt(activity.sessions_30d) || 0,
+                    last_7_days: parseInt(activity.sessions_7d) || 0,
+                    last_session: activity.last_session,
+                    avg_duration_minutes: activity.avg_session_duration_seconds
+                        ? Math.round(activity.avg_session_duration_seconds / 60)
+                        : null
+                },
+                commits: {
+                    last_30_days: parseInt(activity.commits_30d) || 0,
+                    last_7_days: parseInt(activity.commits_7d) || 0,
+                    last_commit: activity.last_commit,
+                    days_since_commit: parseInt(activity.days_since_commit) || null
+                },
+                pull_requests: {
+                    opened_30d: parseInt(activity.prs_opened_30d) || 0,
+                    merged_30d: parseInt(activity.prs_merged_30d) || 0,
+                    avg_review_hours: activity.avg_pr_review_hours
+                        ? parseFloat(activity.avg_pr_review_hours).toFixed(1)
+                        : null
+                },
+                value_correlation: {
+                    commits_within_24h_of_session: parseInt(activity.commits_within_24h_of_session) || 0,
+                    session_to_commit_conversion_pct: parseFloat(activity.session_to_commit_conversion_pct) || 0
+                }
+            }]
+        },
+        'Activity retrieved',
+        { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
+    );
+});