@equilateral_ai/mindmeld 3.4.0 → 3.5.0

package/hooks/session-end.js

@@ -5,16 +5,29 @@
  * Records session completion and outcomes when a Claude Code session ends.
  * Calls POST /api/sessions/end with session metadata.
  *
+ * When reason === "clear" (user cleared context to continue), also harvests
+ * patterns from the transcript before context is lost. This covers the gap
+ * where PreCompact doesn't fire on /clear — only on compaction.
+ *
  * Input (stdin JSON from Claude Code):
  *   { session_id, transcript_path, cwd, reason, hook_event_name }
  *
- * @equilateral_ai/mindmeld v3.3.0
+ * @equilateral_ai/mindmeld v3.5.0
  */
 
 const path = require('path');
 const fs = require('fs').promises;
 const { execSync } = require('child_process');
 
+// Import pattern harvesting from pre-compact hook
+let harvestPatterns = null;
+try {
+    const preCompact = require('./pre-compact');
+    harvestPatterns = preCompact.harvestPatterns;
+} catch (error) {
+    // pre-compact module not available — pattern harvesting on clear will be skipped
+}
+
 /**
  * Load auth token for API calls
  * Priority: env var → project credentials.json → global ~/.mindmeld/auth.json
@@ -166,9 +179,94 @@ function readStdin() {
   });
 }
 
+/**
+ * Harvest patterns from transcript on clear events.
+ * Reads the JSONL transcript, extracts conversation text,
+ * and delegates to pre-compact's harvestPatterns.
+ *
+ * @param {string} transcriptPath - Path to the JSONL transcript file
+ * @param {string} sessionId - Current session ID
+ * @returns {Promise<Object|null>} Harvest results or null
+ */
+async function harvestPatternsOnClear(transcriptPath, sessionId) {
+  try {
+    console.error('[MindMeld] Clear detected — harvesting patterns before context is lost');
+
+    // Read transcript JSONL (cap at 200KB to keep processing fast)
+    const stat = await fs.stat(transcriptPath);
+    let transcriptContent;
+
+    if (stat.size > 200 * 1024) {
+      // Read last 200KB — most recent context is most valuable
+      const fd = await fs.open(transcriptPath, 'r');
+      const buffer = Buffer.alloc(200 * 1024);
+      await fd.read(buffer, 0, buffer.length, stat.size - buffer.length);
+      await fd.close();
+      transcriptContent = buffer.toString('utf-8');
+      // Skip partial first line
+      const firstNewline = transcriptContent.indexOf('\n');
+      if (firstNewline > 0) {
+        transcriptContent = transcriptContent.substring(firstNewline + 1);
+      }
+    } else {
+      transcriptContent = await fs.readFile(transcriptPath, 'utf-8');
+    }
+
+    // Parse JSONL — extract assistant message text for pattern detection
+    const lines = transcriptContent.split('\n').filter(l => l.trim());
+    const textParts = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        // Claude Code transcript entries have varied formats
+        const content = entry.message?.content || entry.content;
+        if (!content) continue;
+
+        if (typeof content === 'string') {
+          textParts.push(content);
+        } else if (Array.isArray(content)) {
+          // Content blocks — extract text blocks
+          for (const block of content) {
+            if (block.type === 'text' && block.text) {
+              textParts.push(block.text);
+            }
+          }
+        }
+      } catch (e) {
+        // Skip unparseable lines
+      }
+    }
+
+    const transcriptText = textParts.join('\n\n');
+
+    if (transcriptText.length < 100) {
+      console.error('[MindMeld] Transcript too short for pattern detection, skipping');
+      return null;
+    }
+
+    // Delegate to pre-compact's full harvesting pipeline
+    const result = await harvestPatterns({
+      sessionId: sessionId,
+      userId: process.env.USER || 'unknown',
+      transcript: transcriptText
+    });
+
+    console.error(`[MindMeld] Clear-event harvest: ${result.patternsDetected || 0} patterns, ` +
+      `${result.violations || 0} violations, ${result.reinforced || 0} reinforced` +
+      (result.plansHarvested ? `, ${result.plansHarvested} plans` : ''));
+
+    return result;
+  } catch (error) {
+    console.error(`[MindMeld] Clear-event harvest failed (non-fatal): ${error.message}`);
+    return null;
+  }
+}
+
 /**
  * Main hook execution
  * Records session end via API call (fire-and-forget)
+ * On clear events, also harvests patterns from the transcript
  */
 async function recordSessionEnd() {
   const startTime = Date.now();
@@ -217,7 +315,7 @@ async function recordSessionEnd() {
       git_branch: gitBranch,
       session_data: {
         end_reason: reason,
-        hook_version: '3.3.0'
+        hook_version: '3.5.0'
       }
     };
 
@@ -238,7 +336,7 @@ async function recordSessionEnd() {
       timeout: 3000
     };
 
-    await new Promise((resolve) => {
+    const metadataPromise = new Promise((resolve) => {
       const req = http.request(options, (res) => {
         let body = '';
         res.on('data', (chunk) => { body += chunk; });
@@ -268,10 +366,21 @@ async function recordSessionEnd() {
       req.end();
     });
 
+    // Pattern harvesting on clear — PreCompact doesn't fire on /clear,
+    // so we harvest here before context is lost
+    let harvestResult = null;
+    const harvestPromise = (reason === 'clear' && transcriptPath && harvestPatterns)
+      ? harvestPatternsOnClear(transcriptPath, sessionId)
+      : Promise.resolve(null);
+
+    // Run metadata recording and pattern harvesting in parallel
+    [, harvestResult] = await Promise.all([metadataPromise, harvestPromise]);
+
     return {
       sessionId,
       reason,
       duration,
+      harvest: harvestResult,
       elapsed: Date.now() - startTime
     };
 

package/package.json

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