@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/hooks/subagent-start.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * MindMeld - Claude Code SubagentStart Hook
+ *
+ * Injects cached standards context into subagents so they follow
+ * the same standards as the main session. Reads from the cache
+ * written by session-start.js — no API calls, < 50ms.
+ *
+ * @equilateral_ai/mindmeld v3.0.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+
+async function injectSubagentContext() {
+  try {
+    // Read hook input from stdin
+    let input = {};
+    try {
+      const stdin = await readStdin();
+      if (stdin) {
+        input = JSON.parse(stdin);
+      }
+    } catch (e) {
+      // No stdin or invalid JSON — continue with defaults
+    }
+
+    const agentType = input.agent_type || 'unknown';
+    const cwd = input.cwd || process.cwd();
+
+    // Read cached subagent context from the project's .mindmeld dir
+    const cachePath = path.join(cwd, '.mindmeld', 'subagent-context.md');
+
+    let context;
+    try {
+      context = await fs.readFile(cachePath, 'utf-8');
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // No cached context — session-start hasn't run or project not init'd
+        console.error('[MindMeld] No subagent context cache found');
+        return;
+      }
+      throw error;
+    }
+
+    // Check cache freshness — skip if older than 8 hours
+    const stat = await fs.stat(cachePath);
+    const ageHours = (Date.now() - stat.mtimeMs) / (1000 * 60 * 60);
+    if (ageHours > 8) {
+      console.error(`[MindMeld] Subagent context cache stale (${ageHours.toFixed(1)}h old), skipping`);
+      return;
+    }
+
+    // Check for active plan and append reference
+    const planRef = await getActivePlanRef(cwd);
+    if (planRef) {
+      context += '\n' + planRef;
+    }
+
+    // Output JSON with additionalContext for injection into the subagent
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'SubagentStart',
+        additionalContext: context
+      }
+    };
+
+    console.log(JSON.stringify(output));
+    console.error(`[MindMeld] Injected context into ${agentType} subagent (${context.length} chars)`);
+
+  } catch (error) {
+    console.error('[MindMeld] SubagentStart hook error (non-fatal):', error.message);
+    // Don't block subagent creation
+  }
+}
+
+/**
+ * Check for an active plan file and return a reference
+ * Looks for plan files modified in the last 2 hours
+ */
+async function getActivePlanRef(cwd) {
+  const os = require('os');
+  const plansDir = path.join(os.homedir(), '.claude', 'plans');
+
+  try {
+    const files = await fs.readdir(plansDir);
+    const mdFiles = files.filter(f => f.endsWith('.md'));
+    const cutoff = Date.now() - (2 * 60 * 60 * 1000);
+
+    let mostRecent = null;
+    let mostRecentTime = 0;
+
+    for (const filename of mdFiles) {
+      const filePath = path.join(plansDir, filename);
+      const stat = await fs.stat(filePath);
+      if (stat.mtimeMs > cutoff && stat.mtimeMs > mostRecentTime) {
+        mostRecentTime = stat.mtimeMs;
+        mostRecent = { filename, filePath };
+      }
+    }
+
+    if (!mostRecent) return null;
+
+    // Read just the title
+    const content = await fs.readFile(mostRecent.filePath, 'utf-8');
+    const titleMatch = content.match(/^#\s+(?:Plan:\s*)?(.+)/m);
+    const title = titleMatch ? titleMatch[1].trim() : mostRecent.filename;
+
+    return `\n## Active Plan\nThere is an active plan: **${title}** (\`~/.claude/plans/${mostRecent.filename}\`). If your work relates to this plan, follow its guidance.`;
+
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Read stdin with timeout
+ */
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    const timeout = setTimeout(() => resolve(data), 500);
+
+    if (process.stdin.isTTY) {
+      clearTimeout(timeout);
+      resolve('');
+      return;
+    }
+
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timeout);
+      resolve('');
+    });
+    process.stdin.resume();
+  });
+}
+
+// Execute
+injectSubagentContext()
+  .then(() => process.exit(0))
+  .catch(error => {
+    console.error('[MindMeld] Fatal error:', error);
+    process.exit(0); // Don't block subagent
+  });

package/hooks/subagent-stop.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+/**
+ * MindMeld - Claude Code SubagentStop Hook
+ *
+ * Lightweight pattern harvesting from subagent transcripts.
+ * Records what standards-relevant work subagents performed.
+ *
+ * @equilateral_ai/mindmeld v3.0.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+
+async function onSubagentStop() {
+  try {
+    // Read hook input from stdin
+    let input = {};
+    try {
+      const stdin = await readStdin();
+      if (stdin) {
+        input = JSON.parse(stdin);
+      }
+    } catch (e) {
+      return; // No input, nothing to do
+    }
+
+    const agentType = input.agent_type || 'unknown';
+    const agentTranscriptPath = input.agent_transcript_path;
+    const cwd = input.cwd || process.cwd();
+
+    // Only harvest from code-writing agents, not explore/research
+    if (agentType === 'Explore') {
+      console.error('[MindMeld] Skipping harvest for Explore subagent');
+      return;
+    }
+
+    // Check if MindMeld is configured
+    try {
+      await fs.access(path.join(cwd, '.mindmeld', 'config.json'));
+    } catch (e) {
+      return; // Not a MindMeld project
+    }
+
+    // If we have a transcript path, scan for patterns
+    if (agentTranscriptPath) {
+      try {
+        const stat = await fs.stat(agentTranscriptPath);
+        // Only process transcripts under 500KB to stay fast
+        if (stat.size > 500 * 1024) {
+          console.error(`[MindMeld] Subagent transcript too large (${(stat.size / 1024).toFixed(0)}KB), skipping`);
+          return;
+        }
+
+        const transcript = await fs.readFile(agentTranscriptPath, 'utf-8');
+        const signals = extractSignals(transcript);
+
+        if (signals.length > 0) {
+          // Append signals to a local log for the pre-compact hook to pick up
+          const signalsPath = path.join(cwd, '.mindmeld', 'subagent-signals.jsonl');
+          const entries = signals.map(s => JSON.stringify({
+            ...s,
+            agent_type: agentType,
+            timestamp: new Date().toISOString()
+          }));
+          await fs.appendFile(signalsPath, entries.join('\n') + '\n');
+          console.error(`[MindMeld] Captured ${signals.length} signal(s) from ${agentType} subagent`);
+        }
+      } catch (error) {
+        console.error('[MindMeld] Transcript read failed:', error.message);
+      }
+    }
+
+  } catch (error) {
+    console.error('[MindMeld] SubagentStop hook error (non-fatal):', error.message);
+  }
+}
+
+/**
+ * Extract lightweight signals from subagent transcript
+ * Looks for file edits, patterns used, and standards-relevant keywords
+ */
+function extractSignals(transcript) {
+  const signals = [];
+
+  // Detect file modifications (Write/Edit tool calls)
+  const fileEdits = transcript.match(/(?:Write|Edit).*?file_path['":\s]+([^\s'"}\]]+)/g);
+  if (fileEdits) {
+    const paths = [...new Set(fileEdits.map(m => {
+      const match = m.match(/file_path['":\s]+([^\s'"}\]]+)/);
+      return match ? match[1] : null;
+    }).filter(Boolean))];
+
+    if (paths.length > 0) {
+      signals.push({
+        type: 'files_modified',
+        files: paths.slice(0, 20)
+      });
+    }
+  }
+
+  // Detect pattern keywords
+  const patternKeywords = [
+    'wrapHandler', 'executeQuery', 'createSuccessResponse', 'createErrorResponse',
+    'rapport\\.', 'equilateral-standards', 'mindmeld'
+  ];
+
+  const detectedPatterns = [];
+  for (const keyword of patternKeywords) {
+    const regex = new RegExp(keyword, 'g');
+    const count = (transcript.match(regex) || []).length;
+    if (count > 0) {
+      detectedPatterns.push({ pattern: keyword, count });
+    }
+  }
+
+  if (detectedPatterns.length > 0) {
+    signals.push({
+      type: 'patterns_detected',
+      patterns: detectedPatterns
+    });
+  }
+
+  // Detect potential violations (anti-pattern keywords)
+  const antiPatterns = [
+    { pattern: 'mock\\s*data|mockData|fallback.*data', name: 'mock_data' },
+    { pattern: 'DefaultAuthorizer', name: 'default_authorizer' },
+    { pattern: 'getParameter|SSM.*runtime', name: 'ssm_runtime' },
+    { pattern: ':\\s*any\\b|:\\s*unknown\\b', name: 'weak_types' }
+  ];
+
+  const detectedAntiPatterns = [];
+  for (const ap of antiPatterns) {
+    const regex = new RegExp(ap.pattern, 'gi');
+    const count = (transcript.match(regex) || []).length;
+    if (count > 0) {
+      detectedAntiPatterns.push({ pattern: ap.name, count });
+    }
+  }
+
+  if (detectedAntiPatterns.length > 0) {
+    signals.push({
+      type: 'anti_patterns_detected',
+      anti_patterns: detectedAntiPatterns
+    });
+  }
+
+  return signals;
+}
+
+/**
+ * Read stdin with timeout
+ */
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    const timeout = setTimeout(() => resolve(data), 500);
+
+    if (process.stdin.isTTY) {
+      clearTimeout(timeout);
+      resolve('');
+      return;
+    }
+
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timeout);
+      resolve('');
+    });
+    process.stdin.resume();
+  });
+}
+
+// Execute
+onSubagentStop()
+  .then(() => process.exit(0))
+  .catch(error => {
+    console.error('[MindMeld] Fatal error:', error);
+    process.exit(0); // Don't block
+  });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equilateral_ai/mindmeld",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Intelligent standards injection for AI coding sessions - context-aware, self-documenting, scales to large codebases",
   "main": "src/index.js",
   "bin": {
@@ -14,6 +14,7 @@
     "scripts/inject.js",
     "scripts/harvest.js",
     "scripts/repo-analyzer.js",
+    "scripts/mcp-bridge.js",
     "README.md"
   ],
   "publishConfig": {
@@ -40,10 +41,9 @@
     "test:session-start": "node scripts/test-claude-hooks.js --session-start",
     "test:pre-compact": "node scripts/test-claude-hooks.js --pre-compact",
     "test:benchmark": "node scripts/test-claude-hooks.js --benchmark",
-    "test:relevance": "node scripts/test-relevance-detection.js",
-    "test:curation": "node scripts/test-curation-engine.js",
-    "test:validation": "node scripts/test-pattern-validation.js",
-    "test:orchestrator": "node scripts/test-orchestrator.js"
+    "test:smoke": "jest --selectProjects smoke --testTimeout=15000",
+    "test:e2e": "cd e2e && npx playwright test",
+    "test:e2e:admin": "cd frontend/admin && npx playwright test"
   },
   "claudeCode": {
     "hooks": {
@@ -80,11 +80,12 @@
   "homepage": "https://mindmeld.dev",
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.460.0",
-    "pg": "^8.11.3"
+    "@aws-sdk/client-ssm": "^3.985.0",
+    "pg": "^8.18.0"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.460.0",
-    "@aws-sdk/client-ses": "^3.968.0",
+    "@aws-sdk/client-ses": "^3.985.0",
     "jest": "^29.7.0"
   },
   "engines": {

package/scripts/init-project.js

@@ -126,7 +126,8 @@ function parseArgs(args) {
     since: '7d',
     commits: 10,
     dryRun: false,
-    help: false
+    help: false,
+    token: null
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -137,7 +138,8 @@ function parseArgs(args) {
     else if (arg === '--path' && args[i + 1]) { parsed.projectPath = args[++i]; }
     else if (arg === '--since' && args[i + 1]) { parsed.since = args[++i]; }
     else if (arg === '--commits' && args[i + 1]) { parsed.commits = parseInt(args[++i]); }
-    else if (!parsed.command && ['init', 'inject', 'harvest', 'logout', 'login', 'status', 'standards', 'open'].includes(arg)) parsed.command = arg;
+    else if (arg === '--token' && args[i + 1]) { parsed.token = args[++i]; }
+    else if (!parsed.command && ['init', 'inject', 'harvest', 'logout', 'login', 'status', 'standards', 'open', 'mcp'].includes(arg)) parsed.command = arg;
     else if (!arg.startsWith('-') && !parsed.command) parsed.command = arg;
     else if (!arg.startsWith('-') && !parsed.projectPath) parsed.projectPath = arg;
   }
@@ -163,10 +165,12 @@ Commands:
   login           Authenticate with MindMeld
   logout          Clear stored authentication
   status          Show current authentication status
+  mcp             Start MCP stdio bridge for Cline, Cursor, Windsurf
 
 Options:
   --format <type> Output format: raw, cursorrules, windsurfrules, aider, claude
   --path <dir>    Project path (default: current directory)
+  --token <tok>   MindMeld API token for MCP bridge (or set MINDMELD_TOKEN)
   --help, -h      Show this help message
 
 Examples:
@@ -176,6 +180,7 @@ Examples:
   mindmeld inject                            # Raw markdown to stdout
   mindmeld harvest                           # Capture patterns from git diff
   mindmeld status                            # Check auth status
+  MINDMELD_TOKEN=xxx mindmeld mcp            # Start MCP bridge
 
 Works with: Claude Code, Cursor, Windsurf, Codex CLI, Aider, Ollama, LM Studio
 
@@ -488,18 +493,25 @@ async function bootstrapFromHistory(projectPath) {
 }
 
 async function configureClaudeHooks(projectPath) {
-  const claudeDir = path.join(projectPath, '.claude');
+  // Register hooks globally (~/.claude/settings.json) so they run for ALL projects.
+  // The hook itself checks for .mindmeld/config.json and silently exits if not present.
+  const homeDir = require('os').homedir();
+  const claudeDir = path.join(homeDir, '.claude');
   const settingsPath = path.join(claudeDir, 'settings.json');
 
   const packageRoot = path.resolve(__dirname, '..');
   const sessionStartHook = path.join(packageRoot, 'hooks', 'session-start.js');
   const preCompactHook = path.join(packageRoot, 'hooks', 'pre-compact.js');
   const sessionEndHook = path.join(packageRoot, 'hooks', 'session-end.js');
+  const subagentStartHook = path.join(packageRoot, 'hooks', 'subagent-start.js');
+  const subagentStopHook = path.join(packageRoot, 'hooks', 'subagent-stop.js');
 
   try {
     await fs.access(sessionStartHook);
     await fs.access(preCompactHook);
     await fs.access(sessionEndHook);
+    await fs.access(subagentStartHook);
+    await fs.access(subagentStopHook);
   } catch (error) {
     // Expected: hooks not found in package
     if (error.code !== 'ENOENT') {
@@ -510,25 +522,43 @@ async function configureClaudeHooks(projectPath) {
     return;
   }
 
+  // Use the absolute path to the current node binary so hooks work
+  // even when Claude Code's subprocess doesn't have node on PATH
+  const nodeBin = process.execPath;
+
   const mindmeldHooks = {
     SessionStart: [{
       hooks: [{
         type: 'command',
-        command: `node "${sessionStartHook}"`,
+        command: `${nodeBin} "${sessionStartHook}"`,
         timeout: 5
       }]
     }],
     PreCompact: [{
       hooks: [{
         type: 'command',
-        command: `node "${preCompactHook}"`,
+        command: `${nodeBin} "${preCompactHook}"`,
         timeout: 30
       }]
     }],
+    SubagentStart: [{
+      hooks: [{
+        type: 'command',
+        command: `${nodeBin} "${subagentStartHook}"`,
+        timeout: 2
+      }]
+    }],
+    SubagentStop: [{
+      hooks: [{
+        type: 'command',
+        command: `${nodeBin} "${subagentStopHook}"`,
+        timeout: 5
+      }]
+    }],
     SessionEnd: [{
       hooks: [{
         type: 'command',
-        command: `node "${sessionEndHook}"`,
+        command: `${nodeBin} "${sessionEndHook}"`,
         timeout: 5
       }]
     }]
@@ -552,45 +582,42 @@ async function configureClaudeHooks(projectPath) {
     settings.hooks = {};
   }
 
-  const hasSessionStart = (settings.hooks.SessionStart || []).some(h =>
-    h.hooks?.some(hk => hk.command?.includes('mindmeld') || hk.command?.includes('session-start'))
-  );
-  const hasPreCompact = (settings.hooks.PreCompact || []).some(h =>
-    h.hooks?.some(hk => hk.command?.includes('mindmeld') || hk.command?.includes('pre-compact'))
-  );
-  const hasSessionEnd = (settings.hooks.SessionEnd || []).some(h =>
-    h.hooks?.some(hk => hk.command?.includes('mindmeld') || hk.command?.includes('session-end'))
+  const hookCheck = (event, keyword) => (settings.hooks[event] || []).some(h =>
+    h.hooks?.some(hk => hk.command?.includes('mindmeld') || hk.command?.includes(keyword))
   );
 
-  if (hasSessionStart && hasPreCompact && hasSessionEnd) {
+  const hasSessionStart = hookCheck('SessionStart', 'session-start');
+  const hasPreCompact = hookCheck('PreCompact', 'pre-compact');
+  const hasSessionEnd = hookCheck('SessionEnd', 'session-end');
+  const hasSubagentStart = hookCheck('SubagentStart', 'subagent-start');
+  const hasSubagentStop = hookCheck('SubagentStop', 'subagent-stop');
+
+  const allConfigured = hasSessionStart && hasPreCompact && hasSessionEnd
+    && hasSubagentStart && hasSubagentStop;
+
+  if (allConfigured) {
     console.log('ℹ️  Claude Code hooks already configured');
     return;
   }
 
-  if (!hasSessionStart) {
-    settings.hooks.SessionStart = [
-      ...(settings.hooks.SessionStart || []),
-      ...mindmeldHooks.SessionStart
-    ];
-  }
-  if (!hasPreCompact) {
-    settings.hooks.PreCompact = [
-      ...(settings.hooks.PreCompact || []),
-      ...mindmeldHooks.PreCompact
-    ];
-  }
-  if (!hasSessionEnd) {
-    settings.hooks.SessionEnd = [
-      ...(settings.hooks.SessionEnd || []),
-      ...mindmeldHooks.SessionEnd
-    ];
+  // Add missing hooks
+  for (const [event, hooks] of Object.entries(mindmeldHooks)) {
+    const has = hookCheck(event, event.replace(/([A-Z])/g, '-$1').toLowerCase().slice(1));
+    if (!has) {
+      settings.hooks[event] = [
+        ...(settings.hooks[event] || []),
+        ...hooks
+      ];
+    }
   }
 
   await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 
-  console.log('✅ Claude Code hooks configured');
+  console.log('✅ Claude Code hooks configured (global ~/.claude/settings.json)');
   console.log(`   SessionStart: ${sessionStartHook}`);
   console.log(`   PreCompact: ${preCompactHook}`);
+  console.log(`   SubagentStart: ${subagentStartHook}`);
+  console.log(`   SubagentStop: ${subagentStopHook}`);
   console.log(`   SessionEnd: ${sessionEndHook}`);
 }
 
@@ -723,6 +750,20 @@ if (args.command === 'init') {
       console.error('\n❌ Error:', error.message);
       process.exit(1);
     });
+} else if (args.command === 'mcp') {
+  const { startBridge, resolveToken, showMcpHelp } = require('./mcp-bridge');
+  if (args.help) { showMcpHelp(); process.exit(0); }
+  const token = resolveToken(args.token);
+  if (!token) {
+    console.error('\nMindMeld MCP bridge requires an API token.\n');
+    console.error('Set one of:');
+    console.error('  1. MINDMELD_TOKEN environment variable');
+    console.error('  2. --token CLI argument');
+    console.error('  3. Save to ~/.mindmeld/api-token\n');
+    console.error('Create a token at: https://app.mindmeld.dev/api-tokens\n');
+    process.exit(1);
+  }
+  startBridge(token);
 } else {
   console.error(`Unknown command: ${args.command}`);
   console.error('Run "mindmeld --help" for usage.');