@equilateral_ai/mindmeld 3.3.0 → 3.3.1

package/hooks/session-start.js

@@ -268,7 +268,7 @@ async function fetchRelevantStandardsFromAPI(apiUrl, authToken, characteristics,
           if (res.statusCode >= 400) {
             reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
           } else {
-            resolve(parsed.standards || []);
+            resolve(parsed.data?.standards || parsed.standards || []);
           }
         } catch (e) {
           reject(new Error('Invalid API response'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equilateral_ai/mindmeld",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "Intelligent standards injection for AI coding sessions - context-aware, self-documenting, scales to large codebases",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -310,72 +310,64 @@ class MindmeldClient {
       try {
         const apiUrl = this.config.apiUrl;
 
-        // Build query params
+        // Build query params (no path parameters per standards)
+        // Uses /api/correlations/project which returns pattern effectiveness and team data
         const params = new URLSearchParams();
-        if (userId) params.append('userId', userId);
-        params.append('patternLimit', patternLimit.toString());
-        params.append('learningDays', learningDays.toString());
+        params.append('project_id', projectId);
+        params.append('lookbackDays', learningDays.toString());
 
         const response = await this._makeApiRequest(
-          `${apiUrl}/api/projects/${projectId}/context?${params.toString()}`,
+          `${apiUrl}/api/correlations/project?${params.toString()}`,
           'GET'
         );
 
         if (response.error) {
           console.error('[Rapport] loadProjectContext API error:', response.error);
           // Fall through to local storage
-        } else {
-          // Return normalized context object
+        } else if (response.data) {
+          const data = response.data;
+          // Return normalized context object from correlations endpoint
           return {
-            projectId: response.project_id || projectId,
-            projectName: response.project_name,
-            companyId: response.company_id,
-
-            // Team patterns (validated and reinforced)
-            patterns: (response.patterns || []).map(p => ({
-              patternId: p.pattern_id,
-              intent: p.intent,
-              element: p.element || p.intent,
+            projectId: data.project?.projectId || projectId,
+            projectName: data.project?.projectName,
+            companyId: data.project?.companyId,
+
+            // Team patterns from pattern effectiveness data
+            patterns: (data.patternEffectiveness || []).slice(0, patternLimit).map(p => ({
+              patternId: p.pattern_id || p.patternId,
+              intent: p.intent || p.element,
+              element: p.element,
               maturity: p.maturity,
-              confidence: p.confidence || p.success_rate,
-              usageCount: p.usage_count || p.handoff_count,
+              confidence: p.success_rate || p.correlation || 0,
+              usageCount: p.usage_count || p.usageCount || 0,
               lastUsed: p.last_used
             })),
 
-            // Load-bearing context elements
-            loadBearingElements: (response.load_bearing_elements || []).map(e => ({
-              elementId: e.element_id,
-              type: e.element_type,
-              key: e.element_key,
-              value: e.element_value,
-              correlation: e.team_correlation,
-              confidence: e.confidence,
-              isLoadBearing: e.is_load_bearing
-            })),
-
-            // Recent team learning
-            recentLearning: (response.recent_learning || []).map(l => ({
-              patternId: l.pattern_id,
-              element: l.element,
-              learnedBy: l.discovered_by || l.email_address,
-              learnedAt: l.discovered_at || l.used_at,
-              success: l.success
+            // Recent correlations as learning events
+            recentLearning: (data.recentCorrelations || []).map(c => ({
+              patternId: c.session_id,
+              element: c.commit_message || 'session',
+              learnedBy: c.email,
+              learnedAt: c.session_end || c.commit_time,
+              success: c.correlation_score > 0.5
             })),
 
-            // Collaborators
-            collaborators: (response.collaborators || []).map(c => ({
-              email: c.email_address || c.email,
-              role: c.role,
-              isExternal: c.is_external,
-              lastActive: c.last_active
+            // Developer breakdown as collaborator activity
+            collaborators: (data.developerBreakdown || []).map(d => ({
+              email: d.email,
+              role: 'collaborator',
+              isExternal: false,
+              sessions: d.totalSessions,
+              commits: d.totalCommits,
+              correlation: d.avgCorrelation
             })),
 
-            // Standards applicable to this project
-            applicableStandards: response.applicable_standards || [],
+            // Metrics
+            metrics: data.metrics,
 
             // Metadata
-            lastActive: response.last_active,
-            sessionCount: response.session_count || 0
+            lastActive: null,
+            sessionCount: data.metrics?.totalSessions || 0
           };
         }
       } catch (error) {