@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/hooks/session-watcher.js

@@ -0,0 +1,585 @@
+#!/usr/bin/env node
+/**
+ * MindMeld - Background Pattern Watcher
+ *
+ * Long-lived background process that monitors the JSONL session transcript
+ * and harvests patterns on resolution detection rather than a dumb timer.
+ *
+ * With 1M context windows, pre-compact may never fire. This watcher ensures
+ * patterns are harvested continuously throughout long sessions.
+ *
+ * Lifecycle:
+ *   1. SessionStart spawns watcher (or watcher detects breadcrumb update)
+ *   2. Polls transcript every 10s, buffers new content
+ *   3. Detects resolution signals (test runs, completions, task done)
+ *   4. Extracts patterns after 60s cooldown post-resolution
+ *   5. Survives /clear via breadcrumb transcript switch
+ *   6. Stops on: parent death, stop file, or 2h idle
+ *
+ * Args:
+ *   argv[2] - project cwd
+ *   argv[3] - parent PID (terminal process to monitor)
+ *
+ * @equilateral_ai/mindmeld v3.5.3
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const os = require('os');
+
+process.title = 'mindmeld-watcher';
+
+// Import harvest pipeline from pre-compact
+let harvestPatterns = null;
+try {
+  const preCompact = require('./pre-compact');
+  harvestPatterns = preCompact.harvestPatterns;
+} catch (error) {
+  console.error(`[MindMeld:Watcher] Cannot load pre-compact module: ${error.message}`);
+  process.exit(0);
+}
+
+const PROJECT_CWD = process.argv[2];
+const PARENT_PID = parseInt(process.argv[3], 10);
+
+if (!PROJECT_CWD) {
+  console.error('[MindMeld:Watcher] No project cwd provided');
+  process.exit(0);
+}
+
+// ── Timing constants ──────────────────────────────────────────────────────────
+const POLL_MS = 10 * 1000;                // 10s transcript poll
+const COOLDOWN_MS = 60 * 1000;            // 60s after resolution before extracting
+const IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000; // 2h no transcript activity → exit
+const PARENT_CHECK_MS = 10 * 1000;        // 10s parent liveness check
+const FALLBACK_HARVEST_MS = 5 * 60 * 1000; // 5 min safety net if no resolution detected
+const MIN_BUFFER_CHARS = 500;             // skip trivial buffers
+const MAX_DELTA_BYTES = 200 * 1024;       // 200KB cap per read
+const STARTUP_RETRY_MS = 10 * 1000;
+const STARTUP_MAX_RETRIES = 12;
+
+// ── Resolution signal patterns ────────────────────────────────────────────────
+// Bash tool calls that indicate work completion
+const RESOLUTION_COMMANDS = [
+  /npm\s+test/,
+  /npm\s+run\s+test/,
+  /jest/,
+  /pytest/,
+  /ruff\s+check/,
+  /eslint/,
+  /tsc\s+--noEmit/,
+  /go\s+test/,
+  /cargo\s+test/,
+  /make\s+test/,
+  /sam\s+build/,
+  /sam\s+deploy/,
+  /npm\s+run\s+build/,
+  /npm\s+run\s+deploy/,
+];
+
+// Completion phrases in assistant messages
+const COMPLETION_PHRASES = [
+  /all\s+(?:tests?\s+)?pass/i,
+  /successfully\s+(?:deployed|built|completed|created|updated)/i,
+  /changes?\s+(?:look|are)\s+good/i,
+  /(?:done|finished|completed)[.!]\s*$/im,
+  /ready\s+(?:to\s+)?(?:commit|deploy|merge|push|review)/i,
+  /implementation\s+is\s+(?:complete|done|ready)/i,
+  /that\s+(?:should\s+)?fix/i,
+];
+
+// ── State ─────────────────────────────────────────────────────────────────────
+let byteOffset = 0;
+let jsonlPath = null;
+let sessionId = null;
+let buffer = '';                           // accumulated unparsed transcript text
+let pollHandle = null;
+let parentCheckHandle = null;
+let cooldownTimer = null;
+let lastHarvestTime = Date.now();
+let lastActivityTime = Date.now();
+let resolutionDetected = false;
+
+// ── Breadcrumb ────────────────────────────────────────────────────────────────
+
+/**
+ * Path to the breadcrumb file written by session-start.
+ * Contains session_id and transcript_path, updated on /clear.
+ */
+function breadcrumbPath() {
+  return path.join(PROJECT_CWD, '.mindmeld', 'current-session.json');
+}
+
+/**
+ * Read the breadcrumb to get current session info and transcript path.
+ */
+async function readBreadcrumb() {
+  try {
+    const content = await fs.readFile(breadcrumbPath(), 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    return null;
+  }
+}
+
+// ── Transcript discovery ──────────────────────────────────────────────────────
+
+function encodeProjectDir(cwd) {
+  return cwd.replace(/\//g, '-');
+}
+
+/**
+ * Find the active JSONL session file.
+ * Priority: breadcrumb transcript_path → most recently modified .jsonl
+ */
+async function findSessionFile() {
+  // Check breadcrumb first
+  const crumb = await readBreadcrumb();
+  if (crumb?.transcriptPath) {
+    try {
+      await fs.access(crumb.transcriptPath);
+      sessionId = crumb.sessionId || sessionId;
+      return crumb.transcriptPath;
+    } catch (err) {
+      // Breadcrumb points to missing file, fall through
+    }
+  }
+
+  if (crumb?.sessionId) {
+    sessionId = crumb.sessionId;
+  }
+
+  // Fall back to most recently modified JSONL
+  const projectDir = path.join(os.homedir(), '.claude', 'projects', encodeProjectDir(PROJECT_CWD));
+  let files;
+  try {
+    files = await fs.readdir(projectDir);
+  } catch (err) {
+    return null;
+  }
+
+  const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+  if (jsonlFiles.length === 0) return null;
+
+  let newest = null;
+  let newestMtime = 0;
+  for (const file of jsonlFiles) {
+    const fullPath = path.join(projectDir, file);
+    try {
+      const stat = await fs.stat(fullPath);
+      if (stat.mtimeMs > newestMtime) {
+        newestMtime = stat.mtimeMs;
+        newest = fullPath;
+      }
+    } catch (err) {
+      // Skip
+    }
+  }
+
+  return newest;
+}
+
+// ── JSONL parsing ─────────────────────────────────────────────────────────────
+
+/**
+ * Parse JSONL entries from raw text. Returns array of parsed entry objects
+ * for resolution detection, plus accumulated transcript text.
+ */
+function parseJsonlEntries(rawText) {
+  const lines = rawText.split('\n').filter(l => l.trim());
+  const entries = [];
+  const textParts = [];
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      entries.push(entry);
+
+      const content = entry.message?.content || entry.content;
+      if (!content) continue;
+
+      if (typeof content === 'string') {
+        textParts.push(content);
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text' && block.text) {
+            textParts.push(block.text);
+          }
+          // Also capture tool_use for resolution detection
+          if (block.type === 'tool_use' && block.input) {
+            const input = typeof block.input === 'string' ? block.input : JSON.stringify(block.input);
+            textParts.push(input);
+          }
+        }
+      }
+    } catch (e) {
+      // Skip partial lines
+    }
+  }
+
+  return { entries, transcript: textParts.join('\n\n') };
+}
+
+// ── Delta reading ─────────────────────────────────────────────────────────────
+
+async function readDelta() {
+  if (!jsonlPath) return null;
+
+  let stat;
+  try {
+    stat = await fs.stat(jsonlPath);
+  } catch (err) {
+    return null;
+  }
+
+  if (stat.size <= byteOffset) return null;
+  lastActivityTime = Date.now();
+
+  const readSize = Math.min(stat.size - byteOffset, MAX_DELTA_BYTES);
+  const buf = Buffer.alloc(readSize);
+
+  const fh = await fs.open(jsonlPath, 'r');
+  try {
+    await fh.read(buf, 0, readSize, byteOffset);
+  } finally {
+    await fh.close();
+  }
+
+  const raw = buf.toString('utf-8');
+
+  // Skip partial first line if mid-file
+  let usable = raw;
+  if (byteOffset > 0) {
+    const firstNewline = raw.indexOf('\n');
+    if (firstNewline > 0) {
+      usable = raw.substring(firstNewline + 1);
+    }
+  }
+
+  // Advance to end of last complete line
+  const lastNewline = raw.lastIndexOf('\n');
+  if (lastNewline >= 0) {
+    byteOffset += lastNewline + 1;
+  } else {
+    return null;
+  }
+
+  return usable;
+}
+
+// ── Resolution detection ──────────────────────────────────────────────────────
+
+/**
+ * Scan entries for signals that the agent just finished a unit of work.
+ */
+function detectResolution(entries, transcriptText) {
+  // Check for resolution command patterns in tool calls
+  for (const entry of entries) {
+    const content = entry.message?.content || entry.content;
+    if (!Array.isArray(content)) continue;
+
+    for (const block of content) {
+      if (block.type === 'tool_use' && block.name === 'Bash') {
+        const cmd = block.input?.command || '';
+        for (const pattern of RESOLUTION_COMMANDS) {
+          if (pattern.test(cmd)) {
+            return { type: 'command', signal: cmd.substring(0, 80) };
+          }
+        }
+      }
+      // TaskUpdate with status "completed"
+      if (block.type === 'tool_use' && block.name === 'TaskUpdate') {
+        const status = block.input?.status;
+        if (status === 'completed') {
+          return { type: 'task_complete', signal: block.input?.id || 'unknown' };
+        }
+      }
+    }
+  }
+
+  // Check for completion phrases in recent text
+  for (const phrase of COMPLETION_PHRASES) {
+    if (phrase.test(transcriptText)) {
+      return { type: 'phrase', signal: transcriptText.match(phrase)?.[0] || '' };
+    }
+  }
+
+  return null;
+}
+
+// ── Harvest ───────────────────────────────────────────────────────────────────
+
+async function extract() {
+  if (!buffer || buffer.length < MIN_BUFFER_CHARS) {
+    buffer = '';
+    resolutionDetected = false;
+    return;
+  }
+
+  const harvestText = buffer.length > MAX_DELTA_BYTES
+    ? buffer.substring(buffer.length - MAX_DELTA_BYTES)
+    : buffer;
+
+  console.error(`[MindMeld:Watcher] Extracting patterns (${harvestText.length} chars)`);
+
+  try {
+    const result = await harvestPatterns({
+      sessionId: sessionId || 'unknown',
+      transcript: harvestText,
+      source: 'watcher'
+    });
+
+    if (result && !result.skipped) {
+      console.error(`[MindMeld:Watcher] Harvest: ${result.patternsDetected || 0} patterns, ${result.violations || 0} violations, ${result.reinforced || 0} reinforced`);
+    }
+  } catch (err) {
+    console.error(`[MindMeld:Watcher] Harvest error (non-fatal): ${err.message}`);
+  }
+
+  buffer = '';
+  resolutionDetected = false;
+  lastHarvestTime = Date.now();
+}
+
+// ── Transcript switch (clear detection) ───────────────────────────────────────
+
+/**
+ * Check if the breadcrumb has been updated with a new transcript path.
+ * This happens when session-start fires again after /clear.
+ */
+async function checkTranscriptSwitch() {
+  const crumb = await readBreadcrumb();
+  if (!crumb?.transcriptPath) return false;
+
+  // No current path yet — initial setup, not a switch
+  if (!jsonlPath) return false;
+
+  // Normalize for comparison
+  const currentBasename = path.basename(jsonlPath);
+  const crumbBasename = path.basename(crumb.transcriptPath);
+
+  if (currentBasename !== crumbBasename) {
+    console.error(`[MindMeld:Watcher] Transcript switch detected: ${currentBasename} → ${crumbBasename}`);
+
+    // Flush remaining buffer from old transcript
+    if (buffer.length >= MIN_BUFFER_CHARS) {
+      console.error('[MindMeld:Watcher] Flushing buffer from previous transcript');
+      await extract();
+    }
+
+    // Reset state for new transcript
+    try {
+      await fs.access(crumb.transcriptPath);
+      jsonlPath = crumb.transcriptPath;
+      sessionId = crumb.sessionId || sessionId;
+      byteOffset = 0; // Read from start of new transcript
+      buffer = '';
+      resolutionDetected = false;
+
+      // Set offset to current size if we don't want pre-existing content
+      const stat = await fs.stat(jsonlPath);
+      byteOffset = stat.size;
+
+      console.error(`[MindMeld:Watcher] Now watching: ${path.basename(jsonlPath)}`);
+      return true;
+    } catch (err) {
+      console.error(`[MindMeld:Watcher] New transcript not accessible: ${err.message}`);
+      return false;
+    }
+  }
+
+  return false;
+}
+
+// ── Parent process liveness ───────────────────────────────────────────────────
+
+function isParentAlive() {
+  if (!PARENT_PID || isNaN(PARENT_PID)) return true; // Can't check, assume alive
+  try {
+    process.kill(PARENT_PID, 0); // Signal 0 = existence check
+    return true;
+  } catch (err) {
+    return false; // ESRCH = process gone
+  }
+}
+
+// ── Stop file detection ───────────────────────────────────────────────────────
+
+function stopFilePath() {
+  return path.join(PROJECT_CWD, '.mindmeld', 'watcher.stop');
+}
+
+async function checkStopFile() {
+  try {
+    await fs.access(stopFilePath());
+    await fs.unlink(stopFilePath()).catch(() => {});
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+// ── PID file ──────────────────────────────────────────────────────────────────
+
+async function writePidFile() {
+  try {
+    const pidPath = path.join(PROJECT_CWD, '.mindmeld', 'watcher.pid');
+    await fs.writeFile(pidPath, String(process.pid));
+  } catch (err) {
+    console.error(`[MindMeld:Watcher] Could not write PID file: ${err.message}`);
+  }
+}
+
+// ── Poll tick ─────────────────────────────────────────────────────────────────
+
+async function poll() {
+  try {
+    // Check for transcript switch (breadcrumb updated by session-start after /clear)
+    await checkTranscriptSwitch();
+
+    // Read new lines from transcript
+    const delta = await readDelta();
+    if (delta) {
+      const { entries, transcript } = parseJsonlEntries(delta);
+      if (transcript) {
+        buffer += transcript + '\n\n';
+      }
+
+      // Check for resolution signals in new entries
+      if (!resolutionDetected) {
+        const resolution = detectResolution(entries, transcript);
+        if (resolution) {
+          resolutionDetected = true;
+          console.error(`[MindMeld:Watcher] Resolution detected (${resolution.type}): ${resolution.signal}`);
+
+          // Start cooldown — extract after 60s
+          if (cooldownTimer) clearTimeout(cooldownTimer);
+          cooldownTimer = setTimeout(() => {
+            cooldownTimer = null;
+            extract();
+          }, COOLDOWN_MS);
+        }
+      }
+    }
+
+    // Fallback: if no resolution detected but buffer is accumulating, harvest on timer
+    if (!resolutionDetected && !cooldownTimer && buffer.length >= MIN_BUFFER_CHARS) {
+      const sinceLastHarvest = Date.now() - lastHarvestTime;
+      if (sinceLastHarvest >= FALLBACK_HARVEST_MS) {
+        console.error('[MindMeld:Watcher] Fallback harvest (no resolution signal)');
+        await extract();
+      }
+    }
+  } catch (err) {
+    console.error(`[MindMeld:Watcher] Poll error (non-fatal): ${err.message}`);
+  }
+}
+
+/**
+ * Parent liveness + idle + stop file checks.
+ */
+async function livenessCheck() {
+  // Parent process died (terminal closed)
+  if (!isParentAlive()) {
+    console.error('[MindMeld:Watcher] Parent process gone, extracting and exiting');
+    await extract();
+    cleanup();
+    return;
+  }
+
+  // Stop file written by session-end
+  if (await checkStopFile()) {
+    console.error('[MindMeld:Watcher] Stop file detected, extracting and exiting');
+    await extract();
+    cleanup();
+    return;
+  }
+
+  // Idle timeout
+  if (Date.now() - lastActivityTime > IDLE_TIMEOUT_MS) {
+    console.error('[MindMeld:Watcher] Idle for 2h, extracting and exiting');
+    await extract();
+    cleanup();
+    return;
+  }
+}
+
+// ── Cleanup ───────────────────────────────────────────────────────────────────
+
+function cleanup() {
+  if (pollHandle) {
+    clearInterval(pollHandle);
+    pollHandle = null;
+  }
+  if (parentCheckHandle) {
+    clearInterval(parentCheckHandle);
+    parentCheckHandle = null;
+  }
+  if (cooldownTimer) {
+    clearTimeout(cooldownTimer);
+    cooldownTimer = null;
+  }
+
+  // Remove PID file
+  try {
+    fsSync.unlinkSync(path.join(PROJECT_CWD, '.mindmeld', 'watcher.pid'));
+  } catch (err) {
+    // Already gone
+  }
+
+  process.exit(0);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.error(`[MindMeld:Watcher] Starting for ${path.basename(PROJECT_CWD)} (parent PID: ${PARENT_PID || 'unknown'})`);
+
+  await writePidFile();
+
+  // Find the JSONL file, retrying if it doesn't exist yet
+  for (let attempt = 0; attempt < STARTUP_MAX_RETRIES; attempt++) {
+    jsonlPath = await findSessionFile();
+    if (jsonlPath) break;
+    await new Promise(r => setTimeout(r, STARTUP_RETRY_MS));
+  }
+
+  if (!jsonlPath) {
+    console.error('[MindMeld:Watcher] Could not find session JSONL file after retries, exiting');
+    cleanup();
+    return;
+  }
+
+  // Read session ID from breadcrumb if not set
+  if (!sessionId) {
+    const crumb = await readBreadcrumb();
+    sessionId = crumb?.sessionId || 'unknown';
+  }
+
+  console.error(`[MindMeld:Watcher] Watching: ${path.basename(jsonlPath)} (session: ${sessionId})`);
+
+  // Start offset at current file size — only capture new activity
+  try {
+    const stat = await fs.stat(jsonlPath);
+    byteOffset = stat.size;
+  } catch (err) {
+    byteOffset = 0;
+  }
+
+  // Start polling
+  pollHandle = setInterval(poll, POLL_MS);
+  parentCheckHandle = setInterval(livenessCheck, PARENT_CHECK_MS);
+}
+
+process.on('SIGTERM', async () => {
+  console.error('[MindMeld:Watcher] SIGTERM received, extracting and exiting');
+  await extract();
+  cleanup();
+});
+process.on('SIGINT', cleanup);
+
+main().catch(err => {
+  console.error(`[MindMeld:Watcher] Fatal: ${err.message}`);
+  cleanup();
+});

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@equilateral_ai/mindmeld",
-  "version": "3.5.2",
+  "version": "4.0.1",
   "description": "Intelligent standards injection for AI coding sessions - context-aware, self-documenting, scales to large codebases",
   "main": "src/index.js",
   "bin": {
-    "mindmeld": "./scripts/init-project.js"
+    "mindmeld": "scripts/init-project.js"
   },
   "files": [
-    "src/",
+    "src/index.js",
+    "src/core/AuthManager.js",
+    "src/core/PatternValidator.js",
+    "src/core/LLMPatternDetector.js",
+    "src/client/dbShim.js",
+    "src/handlers/helpers/dbOperations.js",
+    "src/utils/piiMask.js",
     "hooks/",
     "scripts/init-project.js",
     "scripts/auth-login.js",
-    "scripts/inject.js",
-    "scripts/harvest.js",
-    "scripts/repo-analyzer.js",
-    "scripts/mcp-bridge.js",
     "README.md"
   ],
   "publishConfig": {
@@ -43,7 +45,9 @@
     "test:benchmark": "node scripts/test-claude-hooks.js --benchmark",
     "test:smoke": "jest --selectProjects smoke --testTimeout=15000",
     "test:e2e": "cd e2e && npx playwright test",
-    "test:e2e:admin": "cd frontend/admin && npx playwright test"
+    "test:e2e:admin": "cd frontend/admin && npx playwright test",
+    "prepack": "mkdir -p src/handlers/helpers && cp src/client/dbShim.js src/handlers/helpers/dbOperations.js",
+    "postpack": "git checkout -- src/handlers/helpers/dbOperations.js"
   },
   "claudeCode": {
     "hooks": {
@@ -79,15 +83,17 @@
   },
   "homepage": "https://mindmeld.dev",
   "dependencies": {
-    "@aws-sdk/client-bedrock-runtime": "^3.460.0",
-    "@aws-sdk/client-ssm": "^3.985.0",
-    "js-yaml": "^4.1.1",
-    "pg": "^8.18.0"
+    "js-yaml": "^4.1.1"
+  },
+  "optionalDependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.460.0"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.460.0",
     "@aws-sdk/client-ses": "^3.985.0",
-    "jest": "^29.7.0"
+    "dotenv": "^17.4.2",
+    "jest": "^29.7.0",
+    "pg": "^8.18.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/init-project.js

@@ -702,14 +702,9 @@ if (args.command === 'init') {
       process.exit(1);
     });
 } else if (args.command === 'inject') {
-  const { inject, showInjectHelp } = require('./inject');
-  if (args.help) { showInjectHelp(); process.exit(0); }
-  inject({ format: args.format, path: args.projectPath })
-    .then(() => process.exit(0))
-    .catch(error => {
-      console.error('\n❌ Error:', error.message);
-      process.exit(1);
-    });
+  console.error('The inject subcommand has been removed in v4.0.0.');
+  console.error('Standards injection is now handled automatically by the session-start hook via the MindMeld API.');
+  process.exit(1);
 } else if (args.command === 'harvest') {
   const { harvest, showHarvestHelp } = require('./harvest');
   if (args.help) { showHarvestHelp(); process.exit(0); }
@@ -741,8 +736,9 @@ if (args.command === 'init') {
       process.exit(1);
     });
 } else if (args.command === 'standards') {
-  // Delegate to standards.js
-  require('./standards');
+  console.error('The standards subcommand has been removed in v4.0.0.');
+  console.error('Configure standards at https://app.mindmeld.dev');
+  process.exit(1);
 } else if (args.command === 'open') {
   openWebApp(args.projectPath || 'dashboard')
     .then(() => process.exit(0))
@@ -751,19 +747,9 @@ if (args.command === 'init') {
       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);
+  console.error('The mcp subcommand has been removed in v4.0.0.');
+  console.error('Use the MindMeld MCP server directly via Claude Code settings.');
+  process.exit(1);
 } else {
   console.error(`Unknown command: ${args.command}`);
   console.error('Run "mindmeld --help" for usage.');