@equilateral_ai/mindmeld 3.0.0

package/src/index.js

@@ -0,0 +1,969 @@
+/**
+ * MindMeld - mindmeld.dev
+ *
+ * Intelligent standards injection for AI coding sessions.
+ */
+
+const TeamLoadBearingDetector = require('./core/TeamLoadBearingDetector');
+const CollaborationPrompt = require('./collaboration/CollaborationPrompt');
+const { RelevanceDetector } = require('./core/RelevanceDetector');
+const { PatternValidator } = require('./core/PatternValidator');
+const { StandardsIngestion } = require('./core/StandardsIngestion');
+
+class MindmeldClient {
+  constructor(config = {}) {
+    this.config = {
+      projectPath: config.projectPath || process.cwd(),
+      userId: config.userId || process.env.USER || 'unknown',
+      apiUrl: config.apiUrl || process.env.MINDMELD_API_URL || 'https://api.mindmeld.dev',
+      authToken: config.authToken || process.env.MINDMELD_AUTH_TOKEN || null,
+      companyId: config.companyId || process.env.MINDMELD_COMPANY_ID || null,
+      standardsPath: config.standardsPath || null,
+      ...config
+    };
+
+    // Initialize components
+    this.teamDetector = new TeamLoadBearingDetector();
+    this.collaborationPrompt = new CollaborationPrompt();
+
+    // Phase 2-5 components (Claude Code integration)
+    this.relevanceDetector = new RelevanceDetector({
+      workingDirectory: this.config.projectPath,
+      standardsPath: this.config.standardsPath
+    });
+    this.patternValidator = new PatternValidator();
+    this.standardsIngestion = new StandardsIngestion({
+      standardsPath: this.config.standardsPath
+    });
+
+    // Project context
+    this.currentProject = null;
+  }
+
+  /**
+   * Detect and initialize project
+   */
+  async detectProject() {
+    const projectName = this.getProjectName();
+
+    // Check if project already registered
+    const existing = await this.getProject(projectName);
+
+    if (existing) {
+      this.currentProject = existing;
+      return existing;
+    }
+
+    // New project - prompt for collaboration
+    const result = await this.collaborationPrompt.prompt(
+      this.config.projectPath,
+      projectName
+    );
+
+    if (result.collaborate) {
+      // Initialize collaborative project
+      this.currentProject = await this.initializeProject(projectName, {
+        collaborators: result.collaborators,
+        private: result.private
+      });
+    } else {
+      // Initialize solo project
+      this.currentProject = await this.initializeProject(projectName, {
+        collaborators: [],
+        private: true
+      });
+    }
+
+    return this.currentProject;
+  }
+
+  /**
+   * Get project name from directory
+   */
+  getProjectName() {
+    const path = require('path');
+    return path.basename(this.config.projectPath);
+  }
+
+  /**
+   * Get existing project by name or ID
+   * Fetches project from API if authenticated, falls back to local storage
+   * @param {string} projectNameOrId - Project name or project ID
+   * @returns {Promise<Object|null>} Project object or null if not found
+   */
+  async getProject(projectNameOrId) {
+    // Try API first if authenticated
+    if (this.config.authToken) {
+      try {
+        const apiUrl = this.config.apiUrl;
+        const companyId = this.config.companyId;
+
+        // Build query params
+        const params = new URLSearchParams();
+        if (companyId) {
+          params.append('Company_ID', companyId);
+        }
+
+        const response = await this._makeApiRequest(
+          `${apiUrl}/api/projects?${params.toString()}`,
+          'GET'
+        );
+
+        if (response.error) {
+          console.error('[Rapport] getProject API error:', response.error);
+          // Fall through to local storage
+        } else if (response.Records) {
+          // Search for project by name or ID
+          const project = response.Records.find(
+            p => p.project_name === projectNameOrId || p.project_id === projectNameOrId
+          );
+
+          if (project) {
+            return {
+              projectId: project.project_id,
+              projectName: project.project_name,
+              companyId: project.company_id,
+              description: project.description,
+              private: project.private,
+              collaborators: project.collaborators || [],
+              createdAt: project.created_at,
+              lastActive: project.last_active
+            };
+          }
+        }
+      } catch (error) {
+        console.error('[Rapport] getProject API call failed:', error.message);
+        // Fall through to local storage
+      }
+    }
+
+    // Fallback: check local storage
+    const fs = require('fs').promises;
+    const path = require('path');
+
+    try {
+      // Try to find project in local projects directory
+      const projectsDir = path.join(__dirname, '../projects');
+      const dirs = await fs.readdir(projectsDir).catch(() => []);
+
+      for (const dir of dirs) {
+        const configPath = path.join(projectsDir, dir, 'config.json');
+        try {
+          const content = await fs.readFile(configPath, 'utf-8');
+          const project = JSON.parse(content);
+          if (project.projectName === projectNameOrId || project.projectId === projectNameOrId) {
+            return project;
+          }
+        } catch (e) {
+          // Skip invalid config files
+        }
+      }
+    } catch (error) {
+      // Local storage not available
+    }
+
+    return null;
+  }
+
+  /**
+   * Initialize new project
+   * Creates project via API if authenticated, stores locally as fallback
+   * @param {string} projectName - Name of the project
+   * @param {Object} options - Project options
+   * @param {Array} options.collaborators - List of collaborator emails
+   * @param {boolean} options.private - Whether project is private
+   * @param {string} options.description - Project description
+   * @param {string} options.repoUrl - Repository URL
+   * @returns {Promise<Object>} Created project object
+   */
+  async initializeProject(projectName, options = {}) {
+    const project = this.collaborationPrompt.createProjectConfig(
+      projectName,
+      options.collaborators || [],
+      {
+        private: options.private || false
+      }
+    );
+
+    // Try API first if authenticated
+    if (this.config.authToken && this.config.companyId) {
+      try {
+        const apiUrl = this.config.apiUrl;
+
+        // Build request payload matching projectCreate handler
+        const payload = {
+          Company_ID: this.config.companyId,
+          project_name: projectName,
+          description: options.description || `Project for ${projectName}`,
+          private: options.private || false,
+          repo_url: options.repoUrl || null
+        };
+
+        const response = await this._makeApiRequest(
+          `${apiUrl}/api/projects`,
+          'POST',
+          payload
+        );
+
+        if (response.error) {
+          // Handle specific error cases
+          if (response.status === 409) {
+            console.log('[Rapport] Project already exists, fetching existing...');
+            const existing = await this.getProject(projectName);
+            if (existing) return existing;
+          }
+          console.error('[Rapport] initializeProject API error:', response.error);
+          // Fall through to local storage
+        } else if (response.Records && response.Records.length > 0) {
+          const created = response.Records[0];
+
+          // Add collaborators if specified
+          if (options.collaborators && options.collaborators.length > 0) {
+            for (const email of options.collaborators) {
+              await this._addCollaborator(created.project_id, email);
+            }
+          }
+
+          return {
+            projectId: created.project_id,
+            projectName: created.project_name,
+            companyId: created.company_id,
+            description: created.description,
+            private: created.private,
+            collaborators: options.collaborators || [],
+            createdAt: created.created_at
+          };
+        }
+      } catch (error) {
+        console.error('[Rapport] initializeProject API call failed:', error.message);
+        // Fall through to local storage
+      }
+    }
+
+    // Fallback: store locally
+    await this.storeProjectLocally(project);
+    return project;
+  }
+
+  /**
+   * Add collaborator to project (internal helper)
+   * @private
+   */
+  async _addCollaborator(projectId, email, role = 'collaborator') {
+    try {
+      const apiUrl = this.config.apiUrl;
+      await this._makeApiRequest(
+        `${apiUrl}/api/projects/${projectId}/collaborators`,
+        'POST',
+        { email, role }
+      );
+    } catch (error) {
+      console.error(`[Rapport] Failed to add collaborator ${email}:`, error.message);
+    }
+  }
+
+  /**
+   * Store project configuration locally
+   */
+  async storeProjectLocally(project) {
+    const fs = require('fs').promises;
+    const path = require('path');
+
+    const projectDir = path.join(__dirname, '../projects', project.projectId);
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const configPath = path.join(projectDir, 'config.json');
+    await fs.writeFile(configPath, JSON.stringify(project, null, 2));
+
+    // Create collaborators file
+    const collabPath = path.join(projectDir, 'collaborators.json');
+    await fs.writeFile(collabPath, JSON.stringify({
+      projectId: project.projectId,
+      collaborators: project.collaborators,
+      updated: new Date().toISOString()
+    }, null, 2));
+
+    // Create sessions directory
+    const sessionsDir = path.join(projectDir, 'sessions');
+    await fs.mkdir(sessionsDir, { recursive: true });
+  }
+
+  /**
+   * Load project context including team patterns, load-bearing elements, and recent learning
+   * Fetches from API if authenticated, falls back to local storage
+   * @param {string} projectId - Project ID to load context for
+   * @param {Object} options - Context loading options
+   * @param {string} options.userId - User ID for personalized context
+   * @param {number} options.patternLimit - Max patterns to return (default 20)
+   * @param {number} options.learningDays - Days of recent learning to include (default 7)
+   * @returns {Promise<Object|null>} Project context or null if not found
+   */
+  async loadProjectContext(projectId, options = {}) {
+    const userId = options.userId || this.config.userId;
+    const patternLimit = options.patternLimit || 20;
+    const learningDays = options.learningDays || 7;
+
+    // Try API first if authenticated
+    if (this.config.authToken) {
+      try {
+        const apiUrl = this.config.apiUrl;
+
+        // Build query params
+        const params = new URLSearchParams();
+        if (userId) params.append('userId', userId);
+        params.append('patternLimit', patternLimit.toString());
+        params.append('learningDays', learningDays.toString());
+
+        const response = await this._makeApiRequest(
+          `${apiUrl}/api/projects/${projectId}/context?${params.toString()}`,
+          'GET'
+        );
+
+        if (response.error) {
+          console.error('[Rapport] loadProjectContext API error:', response.error);
+          // Fall through to local storage
+        } else {
+          // Return normalized context object
+          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,
+              maturity: p.maturity,
+              confidence: p.confidence || p.success_rate,
+              usageCount: p.usage_count || p.handoff_count,
+              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
+            })),
+
+            // Collaborators
+            collaborators: (response.collaborators || []).map(c => ({
+              email: c.email_address || c.email,
+              role: c.role,
+              isExternal: c.is_external,
+              lastActive: c.last_active
+            })),
+
+            // Standards applicable to this project
+            applicableStandards: response.applicable_standards || [],
+
+            // Metadata
+            lastActive: response.last_active,
+            sessionCount: response.session_count || 0
+          };
+        }
+      } catch (error) {
+        console.error('[Rapport] loadProjectContext API call failed:', error.message);
+        // Fall through to local storage
+      }
+    }
+
+    // Fallback: load from local storage
+    const fs = require('fs').promises;
+    const path = require('path');
+
+    const configPath = path.join(__dirname, '../projects', projectId, 'config.json');
+
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      const localProject = JSON.parse(content);
+
+      // Return minimal local context
+      return {
+        projectId: localProject.projectId,
+        projectName: localProject.projectName,
+        companyId: localProject.companyId || null,
+        patterns: [],
+        loadBearingElements: [],
+        recentLearning: [],
+        collaborators: localProject.collaborators || [],
+        applicableStandards: [],
+        lastActive: localProject.lastActive || null,
+        sessionCount: 0
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Analyze handoff (team-wide)
+   */
+  async analyzeHandoff(handoff, outcome) {
+    if (!this.currentProject) {
+      throw new Error('No project initialized. Call detectProject() first.');
+    }
+
+    return this.teamDetector.analyzeHandoff(
+      this.config.userId,
+      handoff,
+      outcome
+    );
+  }
+
+  /**
+   * Get team load-bearing elements
+   */
+  getTeamLoadBearing() {
+    return this.teamDetector.getTeamLoadBearing();
+  }
+
+  /**
+   * Get team summary
+   */
+  getTeamSummary() {
+    return this.teamDetector.getTeamSummary();
+  }
+
+  // ============================================================================
+  // Phase 5: Claude Code Hook Methods
+  // ============================================================================
+
+  /**
+   * Ensure standards are ingested (cached check)
+   * Fast execution for session-start hook
+   */
+  async ensureStandardsIngested() {
+    try {
+      const check = await this.standardsIngestion.needsIngestion();
+
+      if (check.needed) {
+        console.log(`[Rapport] Standards ingestion needed: ${check.reason}`);
+        await this.standardsIngestion.ingestEquilateralStandards();
+      }
+
+      return check;
+    } catch (error) {
+      console.error('[Rapport] ensureStandardsIngested error:', error.message);
+      return { needed: false, error: error.message };
+    }
+  }
+
+  /**
+   * Get relevant standards for current project context
+   * Used by session-start hook
+   */
+  async getRelevantStandards(projectContext) {
+    try {
+      const context = {
+        workingDirectory: projectContext.workingDirectory || this.config.projectPath,
+        currentFile: projectContext.currentFile || null,
+        recentFiles: projectContext.recentFiles || [],
+        gitHistory: projectContext.gitHistory || null
+      };
+
+      return await this.relevanceDetector.detectRelevantStandards(context);
+    } catch (error) {
+      console.error('[Rapport] getRelevantStandards error:', error.message);
+      return { standards: [], characteristics: {}, categories: [] };
+    }
+  }
+
+  /**
+   * Get recent learning for project (last N days)
+   */
+  async getRecentLearning(projectId, days = 7) {
+    try {
+      // TODO: Implement when pattern_usage table is populated
+      // For now return empty array
+      return [];
+    } catch (error) {
+      console.error('[Rapport] getRecentLearning error:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Detect patterns from Claude Code session transcript
+   * Used by pre-compact hook
+   */
+  async detectPatternsFromSession(sessionTranscript) {
+    try {
+      const patterns = [];
+
+      // Extract file changes from transcript
+      const files = this.extractFileChanges(sessionTranscript);
+
+      // Analyze each file for patterns
+      for (const file of files) {
+        const filePatterns = await this.extractPatternsFromFile(file);
+        patterns.push(...filePatterns);
+      }
+
+      return patterns;
+    } catch (error) {
+      console.error('[Rapport] detectPatternsFromSession error:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Validate pattern against standards
+   * Used by pre-compact hook
+   */
+  async validatePattern(pattern) {
+    try {
+      return await this.patternValidator.validatePattern(pattern);
+    } catch (error) {
+      console.error('[Rapport] validatePattern error:', error.message);
+      return { valid: true }; // Graceful degradation
+    }
+  }
+
+  /**
+   * Record standards violation
+   * Stores violations in database for team learning and compliance tracking
+   * @param {Object} violationData - Violation data
+   * @param {Object} violationData.pattern - The pattern that violated standards
+   * @param {Array} violationData.violations - Array of violation details
+   * @param {string} violationData.sessionId - Session identifier
+   * @param {string} violationData.userId - User identifier
+   * @returns {Promise<Object>} Result indicating if violation was recorded
+   */
+  async recordViolation(violationData) {
+    try {
+      const apiUrl = this.config.apiUrl;
+
+      // Build request payload
+      const payload = {
+        pattern: {
+          element: violationData.pattern.element,
+          type: violationData.pattern.type,
+          intent: violationData.pattern.intent || violationData.pattern.element,
+          file: violationData.pattern.file,
+          category: violationData.pattern.category
+        },
+        violations: violationData.violations.map(v => ({
+          standard_id: v.standardId || v.standard_id,
+          rule: v.rule,
+          description: v.description || v.reason
+        })),
+        session_id: violationData.sessionId,
+        user_id: violationData.userId,
+        project_id: this.currentProject?.projectId,
+        timestamp: new Date().toISOString()
+      };
+
+      const response = await this._makeApiRequest(
+        `${apiUrl}/api/patterns/violations`,
+        'POST',
+        payload
+      );
+
+      if (response.error) {
+        console.error('[Rapport] Violation recording failed:', response.error);
+        return { recorded: false, error: response.error };
+      }
+
+      console.log('[Rapport] Violation recorded:', violationData.pattern.element);
+      return { recorded: true, violation_id: response.violation_id };
+    } catch (error) {
+      console.error('[Rapport] recordViolation error:', error.message);
+      return { recorded: false, error: error.message };
+    }
+  }
+
+  /**
+   * Reinforce valid pattern
+   * Increments usage count in database for pattern validation tracking
+   * @param {Object} patternData - Pattern data
+   * @param {Object} patternData.pattern - The pattern to reinforce
+   * @param {string} patternData.sessionId - Session identifier
+   * @param {string} patternData.userId - User identifier
+   * @returns {Promise<Object>} Result indicating if pattern was reinforced
+   */
+  async reinforcePattern(patternData) {
+    try {
+      const apiUrl = this.config.apiUrl;
+
+      // Build request payload
+      const payload = {
+        pattern: {
+          element: patternData.pattern.element,
+          type: patternData.pattern.type,
+          intent: patternData.pattern.intent || patternData.pattern.element,
+          file: patternData.pattern.file,
+          category: patternData.pattern.category,
+          confidence: patternData.pattern.confidence || 1.0,
+          evidence: patternData.pattern.evidence
+        },
+        session_id: patternData.sessionId,
+        user_id: patternData.userId,
+        project_id: this.currentProject?.projectId,
+        success: true,
+        context: {
+          working_directory: this.config.projectPath,
+          source: patternData.pattern.source || 'regex'
+        },
+        timestamp: new Date().toISOString()
+      };
+
+      const response = await this._makeApiRequest(
+        `${apiUrl}/api/patterns/usage`,
+        'POST',
+        payload
+      );
+
+      if (response.error) {
+        console.error('[Rapport] Pattern reinforcement failed:', response.error);
+        return { reinforced: false, error: response.error };
+      }
+
+      console.log('[Rapport] Pattern reinforced:', patternData.pattern.element);
+      return {
+        reinforced: true,
+        usage_id: response.usage_id,
+        usage_count: response.usage_count,
+        maturity: response.maturity
+      };
+    } catch (error) {
+      console.error('[Rapport] reinforcePattern error:', error.message);
+      return { reinforced: false, error: error.message };
+    }
+  }
+
+  /**
+   * Evaluate pattern for promotion to standards
+   * Calls CurationEngine promotion logic via API
+   *
+   * Promotion Criteria (from CurationEngine):
+   * - correlation >= 0.90 (90% success rate)
+   * - projectCount >= 5 (proven across 5+ projects)
+   * - developerCount >= 3 (used by 3+ developers)
+   * - sessionCount >= 10 (reinforced 10+ times)
+   *
+   * @param {Object} pattern - Pattern to evaluate
+   * @returns {Promise<Object|null>} Curation candidate if eligible, null otherwise
+   */
+  async evaluateForPromotion(pattern) {
+    try {
+      const apiUrl = this.config.apiUrl;
+
+      // Build request payload
+      const payload = {
+        pattern: {
+          element: pattern.element,
+          type: pattern.type,
+          intent: pattern.intent || pattern.element,
+          category: pattern.category,
+          file: pattern.file
+        },
+        project_id: this.currentProject?.projectId,
+        evaluate_only: true // Just check eligibility, don't create candidate yet
+      };
+
+      const response = await this._makeApiRequest(
+        `${apiUrl}/api/patterns/evaluate-promotion`,
+        'POST',
+        payload
+      );
+
+      if (response.error) {
+        // Not an error for promotion - pattern just doesn't meet criteria
+        if (response.status === 404 || response.reason === 'not_eligible') {
+          return null;
+        }
+        console.error('[Rapport] Pattern promotion evaluation failed:', response.error);
+        return null;
+      }
+
+      // Pattern is eligible for promotion
+      if (response.eligible) {
+        console.log(`[Rapport] Pattern eligible for promotion: ${pattern.element}`);
+        return {
+          element: pattern.element,
+          patternId: response.pattern_id,
+          correlation: response.metrics?.success_correlation || response.correlation,
+          projectCount: response.metrics?.project_count,
+          developerCount: response.metrics?.developer_count,
+          sessionCount: response.metrics?.session_count,
+          category: response.proposed_category || pattern.category,
+          candidateId: response.candidate_id
+        };
+      }
+
+      return null;
+    } catch (error) {
+      console.error('[Rapport] evaluateForPromotion error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Record standards shown during session (Phase 7)
+   * Fire-and-forget to avoid blocking session-start hook
+   * @param {string} sessionId - Session identifier
+   * @param {Array} standards - Array of standards that were injected
+   */
+  recordStandardsShown(sessionId, standards) {
+    // Fire and forget - don't await to keep hook fast
+    this._recordStandardsAsync(sessionId, standards).catch(err => {
+      console.error('[Rapport] recordStandardsShown error:', err.message);
+    });
+  }
+
+  async _recordStandardsAsync(sessionId, standards) {
+    if (!standards || standards.length === 0) return;
+
+    const apiUrl = this.config.apiUrl;
+    const https = require('https');
+    const url = require('url');
+
+    // Prepare payload
+    const payload = JSON.stringify({
+      session_id: sessionId,
+      standards: standards.map(s => ({
+        pattern_id: s.pattern_id || s.element,
+        relevance_score: s.score || 0
+      }))
+    });
+
+    // Non-blocking HTTP request
+    const parsedUrl = url.parse(`${apiUrl}/api/sessions/standards`);
+
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || 443,
+      path: parsedUrl.path,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      },
+      timeout: 2000 // 2s timeout
+    };
+
+    return new Promise((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        resolve({ statusCode: res.statusCode });
+      });
+
+      req.on('error', (err) => {
+        // Log but don't fail - graceful degradation
+        console.error('[Rapport] API call failed:', err.message);
+        resolve({ error: err.message });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ error: 'timeout' });
+      });
+
+      req.write(payload);
+      req.end();
+    });
+  }
+
+  /**
+   * Generate session ID for tracking
+   */
+  generateSessionId() {
+    const crypto = require('crypto');
+    const timestamp = Date.now().toString(36);
+    const random = crypto.randomBytes(4).toString('hex');
+    return `ses_${timestamp}_${random}`;
+  }
+
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+
+  /**
+   * Make authenticated API request
+   * @private
+   * @param {string} url - Full URL to request
+   * @param {string} method - HTTP method (GET, POST, PUT, DELETE)
+   * @param {Object} body - Request body (for POST/PUT)
+   * @param {number} timeout - Request timeout in milliseconds
+   * @returns {Promise<Object>} Parsed JSON response or error object
+   */
+  async _makeApiRequest(url, method = 'GET', body = null, timeout = 10000) {
+    const https = require('https');
+    const http = require('http');
+    const urlModule = require('url');
+
+    const parsedUrl = urlModule.parse(url);
+    const isHttps = parsedUrl.protocol === 'https:';
+    const httpModule = isHttps ? https : http;
+
+    const payload = body ? JSON.stringify(body) : null;
+
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.path,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      },
+      timeout: timeout
+    };
+
+    // Add auth header if token is available
+    if (this.config.authToken) {
+      options.headers['Authorization'] = `Bearer ${this.config.authToken}`;
+    }
+
+    // Add content length for POST/PUT
+    if (payload) {
+      options.headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+
+    return new Promise((resolve) => {
+      const req = httpModule.request(options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+
+            // Check for error status codes
+            if (res.statusCode >= 400) {
+              resolve({
+                error: parsed.message || parsed.error || `HTTP ${res.statusCode}`,
+                status: res.statusCode,
+                ...parsed
+              });
+            } else {
+              resolve(parsed);
+            }
+          } catch (e) {
+            // Non-JSON response
+            if (res.statusCode >= 400) {
+              resolve({
+                error: `HTTP ${res.statusCode}: ${data}`,
+                status: res.statusCode
+              });
+            } else {
+              resolve({ data: data, status: res.statusCode });
+            }
+          }
+        });
+      });
+
+      req.on('error', (err) => {
+        console.error('[Rapport] API request error:', err.message);
+        resolve({ error: err.message });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ error: 'Request timeout' });
+      });
+
+      if (payload) {
+        req.write(payload);
+      }
+
+      req.end();
+    });
+  }
+
+  /**
+   * Extract file changes from session transcript
+   */
+  extractFileChanges(sessionTranscript) {
+    const files = [];
+
+    // Simple extraction - look for common patterns
+    if (sessionTranscript.transcript) {
+      const matches = sessionTranscript.transcript.match(/(?:created|modified|updated)\s+([^\s]+\.(?:js|ts|tsx|jsx|sql|yaml))/gi);
+      if (matches) {
+        matches.forEach(match => {
+          const file = match.match(/([^\s]+\.(?:js|ts|tsx|jsx|sql|yaml))/i);
+          if (file) {
+            files.push(file[1]);
+          }
+        });
+      }
+    }
+
+    return [...new Set(files)]; // Deduplicate
+  }
+
+  /**
+   * Extract patterns from a file
+   */
+  async extractPatternsFromFile(filePath) {
+    try {
+      const fs = require('fs').promises;
+      const path = require('path');
+
+      const fullPath = path.join(this.config.projectPath, filePath);
+      const content = await fs.readFile(fullPath, 'utf-8');
+
+      const patterns = [];
+
+      // Detect common patterns
+      if (content.includes('wrapHandler')) {
+        patterns.push({
+          element: 'Lambda Handler Pattern',
+          rule: 'Use wrapHandler for Lambda functions',
+          file: filePath
+        });
+      }
+
+      if (content.includes('executeQuery')) {
+        patterns.push({
+          element: 'Database Query Pattern',
+          rule: 'Use executeQuery helper',
+          file: filePath
+        });
+      }
+
+      if (content.includes('createSuccessResponse')) {
+        patterns.push({
+          element: 'API Response Pattern',
+          rule: 'Use createSuccessResponse helper',
+          file: filePath
+        });
+      }
+
+      return patterns;
+    } catch (error) {
+      return [];
+    }
+  }
+}
+
+// Backward compatibility alias
+const RapportClient = MindmeldClient;
+
+module.exports = {
+  MindmeldClient,
+  RapportClient,
+  TeamLoadBearingDetector,
+  CollaborationPrompt,
+  RelevanceDetector,
+  PatternValidator,
+  StandardsIngestion
+};