@equilateral_ai/mindmeld 3.3.1 → 3.5.0

package/README.md

@@ -209,11 +209,6 @@ npm run test:hooks
 npm run test:session-start
 npm run test:pre-compact
 
-# Test standards parsing (no database)
-node scripts/demo-standards-parsing.js
-
-# Test standards ingestion (requires database)
-node scripts/test-standards-ingestion.js
 ```
 
 ### Prerequisites
@@ -246,11 +241,7 @@ Rapport integrates with `.equilateral-standards/` to provide context-aware stand
 
 **Test it**:
 ```bash
-# Demo parsing (no database required)
-node scripts/demo-standards-parsing.js
-
-# Full ingestion test (requires database)
-node scripts/test-standards-ingestion.js
+node scripts/ingest-standards.js
 ```
 
 ## Value Proposition

package/hooks/pre-compact.js

@@ -66,10 +66,27 @@ async function loadAuthToken() {
 }
 
 /**
- * Load Cognito config from .myworld.json
+ * Load Cognito config
+ * Priority: .mindmeld/config.json → .myworld.json → production defaults
  * @returns {Promise<Object>} Cognito constructor options or empty object
  */
 async function loadCognitoConfig() {
+  // 1. Check .mindmeld/config.json first (always points to prod)
+  try {
+    const mindmeldConfigPath = path.join(process.cwd(), '.mindmeld', 'config.json');
+    const content = await fs.readFile(mindmeldConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    if (config.auth?.cognitoDomain && config.auth?.cognitoClientId) {
+      return {
+        cognitoDomain: config.auth.cognitoDomain,
+        cognitoClientId: config.auth.cognitoClientId
+      };
+    }
+  } catch (error) {
+    // No .mindmeld/config.json or no auth section
+  }
+
+  // 2. Fallback to .myworld.json (may point to dev)
   try {
     const configPath = path.join(process.cwd(), '.myworld.json');
     const content = await fs.readFile(configPath, 'utf-8');
@@ -88,10 +105,24 @@ async function loadCognitoConfig() {
 }
 
 /**
- * Load API configuration from .myworld.json
+ * Load API configuration
+ * Priority: .mindmeld/config.json → .myworld.json → env var → production default
  * @returns {Promise<{apiUrl: string}>}
  */
 async function loadApiConfig() {
+  // 1. Check .mindmeld/config.json first (always points to prod)
+  try {
+    const mindmeldConfigPath = path.join(process.cwd(), '.mindmeld', 'config.json');
+    const content = await fs.readFile(mindmeldConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    if (config.apiUrl) {
+      return { apiUrl: config.apiUrl };
+    }
+  } catch (error) {
+    // No .mindmeld/config.json or no apiUrl
+  }
+
+  // 2. Fallback to .myworld.json (may point to dev)
   try {
     const configPath = path.join(process.cwd(), '.myworld.json');
     const content = await fs.readFile(configPath, 'utf-8');
@@ -134,9 +165,22 @@ async function harvestPatterns(sessionTranscript) {
       apiUrl: apiConfig.apiUrl
     });
 
-    // Extract session metadata
-    const sessionId = sessionTranscript.sessionId || generateSessionId();
-    const userId = sessionTranscript.userId || process.env.USER || 'unknown';
+    // Load project context so reinforcePattern/recordViolation have project_id
+    await mindmeld.detectProject();
+
+    // Load session context persisted by session-start hook
+    let sessionContext = null;
+    try {
+      const sessionContextPath = path.join(process.cwd(), '.mindmeld', 'current-session.json');
+      const content = await fs.readFile(sessionContextPath, 'utf-8');
+      sessionContext = JSON.parse(content);
+    } catch (err) {
+      // Expected: file may not exist if session-start didn't run
+    }
+
+    // Extract session metadata — prefer persisted session context
+    const sessionId = sessionContext?.sessionId || sessionTranscript.sessionId || generateSessionId();
+    const userId = sessionContext?.userEmail || sessionTranscript.userId || process.env.USER || 'unknown';
 
     // 1. Detect patterns from session (LLM-powered or regex fallback)
     let patterns = [];
@@ -216,27 +260,18 @@ async function harvestPatterns(sessionTranscript) {
     // 5. Check for promotion candidates
     const candidates = await checkPromotionCandidates(mindmeld, validationResults.valid);
 
-    // 6. Check README staleness (documentation maintenance)
-    let readmeStatus = null;
+    // 6. Harvest plans from ~/.claude/plans/
+    let harvestedPlans = [];
     try {
-      const { checkReadmeStaleness } = require('../scripts/check-readme-staleness');
-      readmeStatus = await checkReadmeStaleness(process.cwd());
-
-      if (readmeStatus.stale) {
-        console.error(`[MindMeld] 📄 README staleness detected:`);
-        console.error(`[MindMeld]    Changes since last update: ${readmeStatus.changes}`);
-        console.error(`[MindMeld]    Agent changes: ${readmeStatus.analysis.agentChanges}`);
-        console.error(`[MindMeld]    Standards changes: ${readmeStatus.analysis.standardsChanges}`);
-        console.error(`[MindMeld]    Significance: ${readmeStatus.analysis.significance}`);
-
-        if (readmeStatus.shouldTrigger) {
-          console.error(`[MindMeld] 🔧 Critical changes detected - README update recommended`);
-          console.error(`[MindMeld]    Run: node -e "const L=require('./src/agents/specialists/LibrarianAgent');new L().generateProjectReadme({projectRoot:process.cwd()})"`);
+      harvestedPlans = await harvestPlans(sessionTranscript);
+      if (harvestedPlans.length > 0) {
+        console.error(`[MindMeld] Harvested ${harvestedPlans.length} plan(s) from session`);
+        for (const plan of harvestedPlans) {
+          console.error(`  - ${plan.title} (${plan.filename})`);
         }
       }
     } catch (error) {
-      // Non-fatal - don't break pattern harvesting
-      console.error(`[MindMeld] README check skipped:`, error.message);
+      console.error('[MindMeld] Plan harvesting failed (non-fatal):', error.message);
     }
 
     // 7. Log results
@@ -246,8 +281,10 @@ async function harvestPatterns(sessionTranscript) {
       violations: validationResults.violations.length,
       reinforced: validationResults.valid.length,
       promotionCandidates: candidates.length,
-      readmeStale: readmeStatus ? readmeStatus.stale : null,
-      readmeUpdateRecommended: readmeStatus ? readmeStatus.shouldTrigger : false,
+      plansHarvested: harvestedPlans.length,
+      plans: harvestedPlans,
+      readmeStale: null,
+      readmeUpdateRecommended: false,
       llmUsed: useLLM && llmAnalysis?.success,
       llmModel: llmAnalysis?.model || null,
       llmSummary: llmAnalysis?.summary || null,
@@ -279,6 +316,133 @@ async function harvestPatterns(sessionTranscript) {
   }
 }
 
+/**
+ * Harvest plans from ~/.claude/plans/
+ * Scans for plan files modified during this session (within last 4 hours)
+ * Extracts title, project references, and key decisions
+ *
+ * @param {Object} sessionTranscript - Session data (may contain session start time)
+ * @returns {Promise<Array>} Array of harvested plan objects
+ */
+async function harvestPlans(sessionTranscript) {
+  const os = require('os');
+  const plansDir = path.join(os.homedir(), '.claude', 'plans');
+
+  let files;
+  try {
+    files = await fs.readdir(plansDir);
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+
+  const mdFiles = files.filter(f => f.endsWith('.md'));
+  if (mdFiles.length === 0) return [];
+
+  // Plans modified in the last 4 hours are considered session-relevant
+  const cutoff = Date.now() - (4 * 60 * 60 * 1000);
+  const harvested = [];
+
+  for (const filename of mdFiles) {
+    const filePath = path.join(plansDir, filename);
+    const stat = await fs.stat(filePath);
+
+    if (stat.mtimeMs < cutoff) continue;
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    const plan = parsePlanFile(filename, content, stat);
+    if (plan) {
+      harvested.push(plan);
+    }
+  }
+
+  // Sort by most recently modified first
+  harvested.sort((a, b) => b.modifiedAt - a.modifiedAt);
+
+  return harvested;
+}
+
+/**
+ * Parse a plan file into structured data
+ * @param {string} filename - Plan filename
+ * @param {string} content - Raw markdown content
+ * @param {Object} stat - File stat object
+ * @returns {Object|null} Parsed plan or null if empty
+ */
+function parsePlanFile(filename, content, stat) {
+  if (!content || content.trim().length === 0) return null;
+
+  const lines = content.split('\n');
+
+  // Extract title from first heading
+  let title = filename.replace('.md', '');
+  for (const line of lines) {
+    const headingMatch = line.match(/^#\s+(?:Plan:\s*)?(.+)/);
+    if (headingMatch) {
+      title = headingMatch[1].trim();
+      break;
+    }
+  }
+
+  // Extract sections
+  const sections = {};
+  let currentSection = null;
+  let currentContent = [];
+
+  for (const line of lines) {
+    const sectionMatch = line.match(/^##\s+(.+)/);
+    if (sectionMatch) {
+      if (currentSection) {
+        sections[currentSection] = currentContent.join('\n').trim();
+      }
+      currentSection = sectionMatch[1].trim().toLowerCase();
+      currentContent = [];
+    } else if (currentSection) {
+      currentContent.push(line);
+    }
+  }
+  if (currentSection) {
+    sections[currentSection] = currentContent.join('\n').trim();
+  }
+
+  // Extract file paths mentioned (src/..., hooks/..., etc.)
+  const fileRefs = [];
+  const filePattern = /(?:^|\s|`)((?:src|hooks|scripts|frontend|lib|test|tests)\/[\w/./-]+\.\w+)/g;
+  let match;
+  while ((match = filePattern.exec(content)) !== null) {
+    if (!fileRefs.includes(match[1])) {
+      fileRefs.push(match[1]);
+    }
+  }
+
+  // Detect which project this plan relates to
+  const projectHints = [];
+  const projectPatterns = [
+    /rapport/i, /mindmeld/i, /equilateral/i, /jarvis/i,
+    /honeydo/i, /timebridge/i, /powerspec/i
+  ];
+  for (const pp of projectPatterns) {
+    if (pp.test(content)) {
+      projectHints.push(pp.source.replace(/\/i$/, ''));
+    }
+  }
+
+  return {
+    filename: filename,
+    planId: filename.replace('.md', ''),
+    title: title,
+    modifiedAt: stat.mtimeMs,
+    modifiedIso: stat.mtime.toISOString(),
+    sizeBytes: stat.size,
+    lineCount: lines.length,
+    sections: Object.keys(sections),
+    context: sections['context'] || null,
+    filesReferenced: fileRefs.slice(0, 20),
+    projectHints: projectHints,
+    content: content
+  };
+}
+
 /**
  * Check if MindMeld is configured for this project
  */
@@ -405,6 +569,30 @@ async function generatePostCompactContext(summary, llmAnalysis) {
     sections.push('');
   }
 
+  // Include active plans from this session
+  if (summary.plans && summary.plans.length > 0) {
+    sections.push('## Active Plans');
+    for (const plan of summary.plans) {
+      sections.push(`### ${plan.title}`);
+      sections.push(`- **File**: \`~/.claude/plans/${plan.filename}\``);
+      sections.push(`- **Modified**: ${plan.modifiedIso}`);
+      if (plan.projectHints.length > 0) {
+        sections.push(`- **Projects**: ${plan.projectHints.join(', ')}`);
+      }
+      if (plan.filesReferenced.length > 0) {
+        sections.push(`- **Files**: ${plan.filesReferenced.slice(0, 10).join(', ')}`);
+      }
+      if (plan.context) {
+        // Include first 500 chars of context section
+        const contextPreview = plan.context.length > 500
+          ? plan.context.substring(0, 500) + '...'
+          : plan.context;
+        sections.push(`- **Context**: ${contextPreview}`);
+      }
+      sections.push('');
+    }
+  }
+
   // Load relevant standards from .equilateral-standards if available
   const standardsPath = path.join(process.cwd(), '.equilateral-standards');
   try {
@@ -492,4 +680,4 @@ if (require.main === module) {
     });
 }
 
-module.exports = { harvestPatterns, parseSessionTranscript, generatePostCompactContext };
+module.exports = { harvestPatterns, harvestPlans, parseSessionTranscript, generatePostCompactContext };

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
     };