@equilateral_ai/mindmeld 3.1.2 → 3.3.0

package/README.md

@@ -58,8 +58,8 @@ open https://mindmeld.dev/login
 - < 500ms hook execution target
 
 ### 2. Standards Ingestion (Phase 1)
-- Ingests 100+ patterns from .equilateral-standards/
-- Extracts enforcement rules, anti-patterns, examples, cost impacts
+- Ingests 100+ patterns from .equilateral-standards/ (YAML format)
+- Parses structured rules, anti-patterns, examples, cost impacts
 - Stores in `rapport.standards_patterns` database table
 - Enables intelligent context injection (only relevant standards)
 
@@ -239,8 +239,8 @@ NODE_ENV, APP_URL
 Rapport integrates with `.equilateral-standards/` to provide context-aware standards injection:
 
 **What it does**:
-- Ingests 100+ patterns from .equilateral-standards/ markdown files
-- Extracts enforcement rules, anti-patterns, examples, cost impacts
+- Ingests 100+ patterns from .equilateral-standards/ YAML files
+- Parses structured rules (ALWAYS/NEVER/USE/PREFER/AVOID), anti-patterns, examples, cost impacts
 - Stores in `rapport.standards_patterns` database table
 - Enables intelligent context injection (only relevant standards)
 

package/hooks/README.md

@@ -74,6 +74,31 @@ npm run test:pre-compact
 }
 ```
 
+### 3. `session-end.js` - Session Completion
+
+**Purpose**: Record session completion and outcomes when Claude Code exits
+
+**Execution**: Called when Claude Code session terminates (exit command, logout, clear)
+
+**Input** (stdin JSON from Claude Code):
+- `session_id` - Session identifier
+- `transcript_path` - Path to conversation JSONL
+- `cwd` - Working directory
+- `reason` - Exit reason (clear, logout, prompt_input_exit, other)
+
+**Output**: API call to POST /api/sessions/end with session metadata
+
+**Configuration**:
+```json
+{
+  "claudeCode": {
+    "hooks": {
+      "sessionEnd": "hooks/session-end.js"
+    }
+  }
+}
+```
+
 ---
 
 ## How Hooks Work
@@ -110,6 +135,20 @@ npm run test:pre-compact
 5. Return summary to Claude Code
 ```
 
+### SessionEnd Flow
+
+```
+1. Claude Code sends session metadata via stdin
+2. Hook checks if Rapport configured
+3. If not configured → exit immediately
+4. If configured:
+   a. Load auth token
+   b. Get project ID, git branch, session duration
+   c. POST /api/sessions/end (fire-and-forget, 3s timeout)
+   d. API records session completion and calculates compliance
+5. Exit (never blocks session termination)
+```
+
 ---
 
 ## Performance Characteristics
@@ -392,10 +431,13 @@ hooks/
 │   ├── checkRapportConfiguration()
 │   └── formatContextInjection()
 │
-└── pre-compact.js
-    ├── harvestPatterns()
-    ├── validatePatterns()
-    └── checkPromotionCandidates()
+├── pre-compact.js
+│   ├── harvestPatterns()
+│   ├── validatePatterns()
+│   └── checkPromotionCandidates()
+│
+└── session-end.js
+    └── recordSessionEnd()
 
 ↓ Uses ↓
 

package/hooks/pre-compact.js

@@ -16,6 +16,7 @@
 
 const path = require('path');
 const fs = require('fs').promises;
+const crypto = require('crypto');
 
 // LLM Pattern Detection (optional - requires ANTHROPIC_API_KEY)
 let LLMPatternDetector = null;
@@ -26,6 +27,86 @@ try {
     // LLM module not available - will use regex fallback
 }
 
+/**
+ * Load auth token for API calls
+ * Priority: env var → project credentials.json → global ~/.mindmeld/auth.json
+ * @returns {Promise<string|null>} Auth token or null
+ */
+async function loadAuthToken() {
+  // 1. Env var (highest priority)
+  if (process.env.MINDMELD_AUTH_TOKEN) {
+    return process.env.MINDMELD_AUTH_TOKEN;
+  }
+
+  // 2. Project-level credentials.json
+  try {
+    const credPath = path.join(process.cwd(), '.mindmeld', 'credentials.json');
+    const content = await fs.readFile(credPath, 'utf-8');
+    const creds = JSON.parse(content);
+    if (creds.auth_token || creds.token) {
+      return creds.auth_token || creds.token;
+    }
+  } catch (error) {
+    // No project-level credentials
+  }
+
+  // 3. Global ~/.mindmeld/auth.json (from browser login / mindmeld CLI)
+  try {
+    const { AuthManager } = require('../src/core/AuthManager');
+    const cognitoConfig = await loadCognitoConfig();
+    const authManager = new AuthManager(cognitoConfig);
+    const token = await authManager.getValidToken();
+    if (token) {
+      return token;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load Cognito config from .myworld.json
+ * @returns {Promise<Object>} Cognito constructor options or empty object
+ */
+async function loadCognitoConfig() {
+  try {
+    const configPath = path.join(process.cwd(), '.myworld.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    const auth = config.deployments?.backend?.auth;
+    if (auth?.domain && auth?.client_id) {
+      return {
+        cognitoDomain: `${auth.domain}.auth.us-east-2.amazoncognito.com`,
+        cognitoClientId: auth.client_id
+      };
+    }
+  } catch (error) {
+    // No .myworld.json — use production defaults
+  }
+  return {};
+}
+
+/**
+ * Load API configuration from .myworld.json
+ * @returns {Promise<{apiUrl: string}>}
+ */
+async function loadApiConfig() {
+  try {
+    const configPath = path.join(process.cwd(), '.myworld.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    const backend = config.deployments?.backend;
+    return {
+      apiUrl: backend?.api?.base_url || 'https://api.mindmeld.dev'
+    };
+  } catch (error) {
+    return {
+      apiUrl: process.env.MINDMELD_API_URL || 'https://api.mindmeld.dev'
+    };
+  }
+}
+
 /**
  * Main hook execution
  * @param {Object} sessionTranscript - Claude Code session data
@@ -40,11 +121,17 @@ async function harvestPatterns(sessionTranscript) {
       return { skipped: true, reason: 'No MindMeld configuration' };
     }
 
+    // Load auth token and API config for authenticated API calls
+    const authToken = await loadAuthToken();
+    const apiConfig = await loadApiConfig();
+
     // Load MindmeldClient with graceful degradation
     const { MindmeldClient } = require('../src/index');
 
     const mindmeld = new MindmeldClient({
-      projectPath: process.cwd()
+      projectPath: process.cwd(),
+      authToken: authToken,
+      apiUrl: apiConfig.apiUrl
     });
 
     // Extract session metadata
@@ -200,7 +287,11 @@ async function checkMindmeldConfiguration() {
     const mindmeldConfig = path.join(process.cwd(), '.mindmeld', 'config.json');
     await fs.access(mindmeldConfig);
     return true;
-  } catch {
+  } catch (error) {
+    // Expected: config doesn't exist
+    if (error.code !== 'ENOENT') {
+      console.error('Unexpected error checking MindMeld config:', error.message);
+    }
     return false;
   }
 }
@@ -248,10 +339,10 @@ async function checkPromotionCandidates(mindmeld, validPatterns) {
 }
 
 /**
- * Generate session ID
+ * Generate session ID using crypto for consistency
  */
 function generateSessionId() {
-  return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  return `session_${Date.now()}_${crypto.randomBytes(6).toString('hex')}`;
 }
 
 /**
@@ -261,8 +352,11 @@ function parseSessionTranscript(input) {
   if (typeof input === 'string') {
     try {
       return JSON.parse(input);
-    } catch {
-      // Treat as raw transcript text
+    } catch (error) {
+      // Expected: not valid JSON, treat as raw transcript text
+      if (!(error instanceof SyntaxError)) {
+        console.error('Unexpected error parsing transcript:', error.message);
+      }
       return {
         transcript: input,
         sessionId: generateSessionId()
@@ -329,11 +423,17 @@ async function generatePostCompactContext(summary, llmAnalysis) {
         }
         sections.push('');
       }
-    } catch {
-      // No index file - that's OK
+    } catch (error) {
+      // Expected: no index file
+      if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
+        console.error('Unexpected error reading standards index:', error.message);
+      }
+    }
+  } catch (error) {
+    // Expected: no standards directory
+    if (error.code !== 'ENOENT') {
+      console.error('Unexpected error accessing standards:', error.message);
     }
-  } catch {
-    // No standards directory - that's OK
   }
 
   // Load project-specific patterns from .mindmeld if available
@@ -349,8 +449,11 @@ async function generatePostCompactContext(summary, llmAnalysis) {
       sections.push('**Team**: ' + config.team.map(t => t.name || t.email).join(', '));
     }
     sections.push('');
-  } catch {
-    // No mindmeld config - that's OK
+  } catch (error) {
+    // Expected: no mindmeld config
+    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
+      console.error('Unexpected error reading mindmeld config:', error.message);
+    }
   }
 
   sections.push('---');

package/hooks/session-end.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+/**
+ * MindMeld - Claude Code Session End Hook
+ *
+ * Records session completion and outcomes when a Claude Code session ends.
+ * Calls POST /api/sessions/end with session metadata.
+ *
+ * Input (stdin JSON from Claude Code):
+ *   { session_id, transcript_path, cwd, reason, hook_event_name }
+ *
+ * @equilateral_ai/mindmeld v3.3.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const { execSync } = require('child_process');
+
+/**
+ * Load auth token for API calls
+ * Priority: env var → project credentials.json → global ~/.mindmeld/auth.json
+ * @returns {Promise<string|null>} Auth token or null
+ */
+async function loadAuthToken() {
+  // 1. Env var (highest priority)
+  if (process.env.MINDMELD_AUTH_TOKEN) {
+    return process.env.MINDMELD_AUTH_TOKEN;
+  }
+
+  // 2. Project-level credentials.json
+  try {
+    const credPath = path.join(process.cwd(), '.mindmeld', 'credentials.json');
+    const content = await fs.readFile(credPath, 'utf-8');
+    const creds = JSON.parse(content);
+    if (creds.auth_token || creds.token) {
+      return creds.auth_token || creds.token;
+    }
+  } catch (error) {
+    // No project-level credentials
+  }
+
+  // 3. Global ~/.mindmeld/auth.json (from browser login / mindmeld CLI)
+  try {
+    const { AuthManager } = require('../src/core/AuthManager');
+    const cognitoConfig = await loadCognitoConfig();
+    const authManager = new AuthManager(cognitoConfig);
+    const token = await authManager.getValidToken();
+    if (token) {
+      return token;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load Cognito config from .myworld.json
+ * @returns {Promise<Object>} Cognito constructor options or empty object
+ */
+async function loadCognitoConfig() {
+  try {
+    const configPath = path.join(process.cwd(), '.myworld.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    const auth = config.deployments?.backend?.auth;
+    if (auth?.domain && auth?.client_id) {
+      return {
+        cognitoDomain: `${auth.domain}.auth.us-east-2.amazoncognito.com`,
+        cognitoClientId: auth.client_id
+      };
+    }
+  } catch (error) {
+    // No .myworld.json — use production defaults
+  }
+  return {};
+}
+
+/**
+ * Load API configuration from .myworld.json
+ * @returns {Promise<{apiUrl: string}>}
+ */
+async function loadApiConfig() {
+  try {
+    const configPath = path.join(process.cwd(), '.myworld.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    const backend = config.deployments?.backend;
+    return {
+      apiUrl: backend?.api?.base_url || 'https://api.mindmeld.dev'
+    };
+  } catch (error) {
+    return {
+      apiUrl: process.env.MINDMELD_API_URL || 'https://api.mindmeld.dev'
+    };
+  }
+}
+
+/**
+ * Get current git branch
+ * @param {string} cwd - Working directory
+ * @returns {string|null} Branch name or null
+ */
+function getGitBranch(cwd) {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd,
+      encoding: 'utf-8',
+      timeout: 2000
+    }).trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Estimate session duration from transcript file creation time
+ * @param {string} transcriptPath - Path to session transcript
+ * @returns {Promise<number|null>} Duration in seconds or null
+ */
+async function estimateSessionDuration(transcriptPath) {
+  if (!transcriptPath) return null;
+  try {
+    const stat = await fs.stat(transcriptPath);
+    const createdAt = stat.birthtime || stat.ctime;
+    return Math.round((Date.now() - createdAt.getTime()) / 1000);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load project ID from .mindmeld/config.json
+ * @returns {Promise<string|null>} Project ID or null
+ */
+async function loadProjectId() {
+  try {
+    const configPath = path.join(process.cwd(), '.mindmeld', 'config.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    return config.projectId || config.project_id || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Read hook input from stdin
+ * @returns {Promise<Object>} Parsed JSON input
+ */
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch (error) {
+        resolve({});
+      }
+    });
+    // If stdin is not piped, resolve immediately
+    if (process.stdin.isTTY) {
+      resolve({});
+    }
+  });
+}
+
+/**
+ * Main hook execution
+ * Records session end via API call (fire-and-forget)
+ */
+async function recordSessionEnd() {
+  const startTime = Date.now();
+
+  try {
+    // Fast bail if MindMeld not configured
+    try {
+      await fs.access(path.join(process.cwd(), '.mindmeld', 'config.json'));
+    } catch (error) {
+      return { skipped: true, reason: 'No MindMeld configuration' };
+    }
+
+    // Read hook input from stdin
+    const input = await readStdin();
+    const sessionId = input.session_id;
+    const transcriptPath = input.transcript_path;
+    const cwd = input.cwd || process.cwd();
+    const reason = input.reason;
+
+    if (!sessionId) {
+      console.error('[MindMeld] session-end: No session_id provided');
+      return { skipped: true, reason: 'No session_id' };
+    }
+
+    // Load auth and config in parallel
+    const [authToken, apiConfig, projectId, duration, gitBranch] = await Promise.all([
+      loadAuthToken(),
+      loadApiConfig(),
+      loadProjectId(),
+      estimateSessionDuration(transcriptPath),
+      Promise.resolve(getGitBranch(cwd))
+    ]);
+
+    if (!authToken) {
+      console.error('[MindMeld] session-end: No auth token available, skipping');
+      return { skipped: true, reason: 'No auth token' };
+    }
+
+    // Build request payload
+    const payload = {
+      session_id: sessionId,
+      project_id: projectId,
+      user_id: process.env.USER || 'unknown',
+      duration_seconds: duration,
+      working_directory: cwd,
+      git_branch: gitBranch,
+      session_data: {
+        end_reason: reason,
+        hook_version: '3.3.0'
+      }
+    };
+
+    // Fire-and-forget API call with timeout
+    const url = `${apiConfig.apiUrl}/api/sessions/end`;
+    const http = require(url.startsWith('https') ? 'https' : 'http');
+    const urlObj = new URL(url);
+
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      timeout: 3000
+    };
+
+    await new Promise((resolve) => {
+      const req = http.request(options, (res) => {
+        let body = '';
+        res.on('data', (chunk) => { body += chunk; });
+        res.on('end', () => {
+          const elapsed = Date.now() - startTime;
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            console.error(`[MindMeld] Session end recorded in ${elapsed}ms (session: ${sessionId}, reason: ${reason})`);
+          } else {
+            console.error(`[MindMeld] Session end API returned ${res.statusCode}: ${body}`);
+          }
+          resolve();
+        });
+      });
+
+      req.on('error', (err) => {
+        console.error(`[MindMeld] Session end API error (non-fatal): ${err.message}`);
+        resolve(); // Never block exit
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        console.error('[MindMeld] Session end API timeout (non-fatal)');
+        resolve(); // Never block exit
+      });
+
+      req.write(JSON.stringify(payload));
+      req.end();
+    });
+
+    return {
+      sessionId,
+      reason,
+      duration,
+      elapsed: Date.now() - startTime
+    };
+
+  } catch (error) {
+    // Graceful degradation - never block session exit
+    console.error('[MindMeld] session-end hook error (non-fatal):', error.message);
+    return { error: error.message };
+  }
+}
+
+// Execute if called directly
+if (require.main === module) {
+  recordSessionEnd()
+    .then(() => process.exit(0))
+    .catch(() => process.exit(0)); // Never block exit
+}
+
+module.exports = { recordSessionEnd };