@equilateral_ai/mindmeld 3.0.0

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@equilateral_ai/mindmeld",
+  "version": "3.0.0",
+  "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"
+  },
+  "files": [
+    "src/",
+    "hooks/",
+    "scripts/init-project.js",
+    "scripts/inject.js",
+    "scripts/harvest.js",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest --selectProjects unit",
+    "test:integration": "jest --selectProjects integration",
+    "test:integration:hooks": "jest test/integration/hooks.integration.test.js",
+    "test:integration:database": "jest test/integration/database.integration.test.js",
+    "test:integration:multiagent": "jest test/integration/multiAgent.integration.test.js",
+    "test:integration:performance": "jest test/integration/performance.integration.test.js --testTimeout=120000",
+    "test:integration:all": "jest test/integration/ --runInBand",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --runInBand",
+    "build": "./scripts/build-handlers.sh",
+    "deploy:dev": "./scripts/deploy-dev.sh",
+    "deploy:prod": "./scripts/deploy-prod.sh",
+    "verify:dev": "./scripts/verify-deployment.sh dev",
+    "verify:prod": "./scripts/verify-deployment.sh prod",
+    "agents": "node scripts/rapport-agents-cli.js",
+    "test:hooks": "node scripts/test-claude-hooks.js",
+    "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"
+  },
+  "claudeCode": {
+    "hooks": {
+      "sessionStart": "hooks/session-start.js",
+      "preCompact": "hooks/pre-compact.js"
+    },
+    "config": {
+      "standardsPath": ".equilateral-standards",
+      "maxContextLength": 50000,
+      "maxStandards": 10,
+      "sessionStartTimeout": 500
+    }
+  },
+  "keywords": [
+    "equilateral",
+    "mindmeld",
+    "collaboration",
+    "memory",
+    "context",
+    "team-learning",
+    "knowledge-management",
+    "ai-context",
+    "claude-code",
+    "standards",
+    "patterns"
+  ],
+  "author": "Jim Ford <jim@equilateral.ai>",
+  "license": "PROPRIETARY",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jamesfordhq/rapport.git"
+  },
+  "homepage": "https://mindmeld.dev",
+  "dependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.460.0",
+    "pg": "^8.11.3"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "^3.460.0",
+    "@aws-sdk/client-ses": "^3.968.0",
+    "jest": "^29.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/harvest.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+/**
+ * MindMeld CLI - Manually harvest patterns from recent git history
+ *
+ * For non-Claude-Code tools (Cursor, Aider, Ollama, etc.) that don't have
+ * a pre-compact hook. Analyzes recent commits to detect patterns.
+ *
+ * Usage:
+ *   mindmeld harvest                # Analyze last 10 commits
+ *   mindmeld harvest --since 7d     # Last 7 days
+ *   mindmeld harvest --commits 20   # Last 20 commits
+ *
+ * @equilateral_ai/mindmeld v3.0.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+function showHarvestHelp() {
+  console.log(`
+MindMeld harvest - Capture patterns from recent git history
+
+Usage:
+  mindmeld harvest [options]
+
+Options:
+  --since <period>   Time period: 1d, 7d, 30d (default: 7d)
+  --commits <n>      Number of commits to analyze (default: 10)
+  --path <dir>       Project path (default: current directory)
+  --dry-run          Show what would be captured without saving
+  --help, -h         Show this help
+
+Examples:
+  mindmeld harvest                     # Analyze last 7 days
+  mindmeld harvest --since 1d          # Just today's commits
+  mindmeld harvest --commits 20        # Last 20 commits
+  mindmeld harvest --dry-run           # Preview without saving
+
+What it does:
+  1. Reads recent git diffs and commit messages
+  2. Detects repeated patterns (file types, naming, structure)
+  3. Identifies correction patterns (reverts, fixes, amendments)
+  4. Records detected patterns in .mindmeld/patterns/
+  5. Patterns with enough repetition get promoted to standards
+`);
+}
+
+/**
+ * Convert shorthand period (7d, 30d, 2w) to git-compatible format
+ */
+function parseGitSince(since) {
+  const match = since.match(/^(\d+)(d|w|m)$/);
+  if (!match) return since; // pass through if already in git format
+  const [, num, unit] = match;
+  const units = { d: 'days', w: 'weeks', m: 'months' };
+  return `${num} ${units[unit] || 'days'} ago`;
+}
+
+/**
+ * Get recent git activity
+ */
+async function getGitHistory(projectPath, options = {}) {
+  const since = parseGitSince(options.since || '7d');
+  const maxCommits = options.commits || 10;
+
+  // Get commit log with diffs
+  try {
+    const { stdout: log } = await execAsync(
+      `git log --since="${since}" -n ${maxCommits} --format="%H|%s|%an|%ai" --stat`,
+      { cwd: projectPath, maxBuffer: 1024 * 1024 }
+    );
+
+    const { stdout: diff } = await execAsync(
+      `git log --since="${since}" -n ${maxCommits} -p --diff-filter=M`,
+      { cwd: projectPath, maxBuffer: 5 * 1024 * 1024 }
+    );
+
+    return { log, diff };
+  } catch (error) {
+    if (error.message.includes('not a git repository')) {
+      throw new Error('not a git repository');
+    }
+    throw error;
+  }
+}
+
+/**
+ * Detect patterns from git history using regex analysis
+ */
+function detectPatterns(gitHistory) {
+  const patterns = [];
+  const { log, diff } = gitHistory;
+
+  // 1. Detect fix/correction patterns (commits that fix previous work)
+  const fixPatterns = log.match(/fix[:\s]|correct[:\s]|revert[:\s]|wrong|mistake|should be|instead of/gi) || [];
+  if (fixPatterns.length >= 2) {
+    patterns.push({
+      type: 'correction',
+      element: 'Repeated corrections detected',
+      evidence: `${fixPatterns.length} fix/correction commits in recent history`,
+      confidence: Math.min(0.9, fixPatterns.length * 0.15),
+      category: 'workflow'
+    });
+  }
+
+  // 2. Detect file type patterns (what's being edited most)
+  const fileExtensions = {};
+  const fileMatches = log.match(/\S+\.\w+/g) || [];
+  for (const file of fileMatches) {
+    const ext = path.extname(file);
+    if (ext && ext.length < 6) {
+      fileExtensions[ext] = (fileExtensions[ext] || 0) + 1;
+    }
+  }
+
+  // 3. Detect code patterns from diffs
+  const codePatterns = [];
+
+  // Connection pool vs single client
+  if (diff.includes('createPool') || diff.includes('Pool(')) {
+    codePatterns.push({
+      type: 'anti-pattern',
+      element: 'Connection pool usage detected',
+      evidence: 'createPool or Pool() found in diffs',
+      confidence: 0.7,
+      category: 'database'
+    });
+  }
+
+  // Console.log removal (cleanup pattern)
+  const consoleAdds = (diff.match(/^\+.*console\.log/gm) || []).length;
+  const consoleRemoves = (diff.match(/^-.*console\.log/gm) || []).length;
+  if (consoleRemoves > consoleAdds && consoleRemoves >= 3) {
+    codePatterns.push({
+      type: 'pattern',
+      element: 'Console.log cleanup pattern',
+      evidence: `${consoleRemoves} console.log removals vs ${consoleAdds} additions`,
+      confidence: 0.6,
+      category: 'code-quality'
+    });
+  }
+
+  // Error handling patterns
+  const tryCatchAdds = (diff.match(/^\+.*try\s*\{/gm) || []).length;
+  if (tryCatchAdds >= 3) {
+    codePatterns.push({
+      type: 'pattern',
+      element: 'Error handling additions',
+      evidence: `${tryCatchAdds} try/catch blocks added`,
+      confidence: 0.5,
+      category: 'error-handling'
+    });
+  }
+
+  // Type annotation additions (TypeScript patterns)
+  const typeAnnotations = (diff.match(/^\+.*:\s*(string|number|boolean|any|void|Promise|Array)/gm) || []).length;
+  if (typeAnnotations >= 5) {
+    codePatterns.push({
+      type: 'pattern',
+      element: 'Type annotations being added',
+      evidence: `${typeAnnotations} type annotations in recent diffs`,
+      confidence: 0.6,
+      category: 'typescript'
+    });
+  }
+
+  // Import organization patterns
+  const importChanges = (diff.match(/^\+\s*import\s/gm) || []).length;
+  if (importChanges >= 5) {
+    codePatterns.push({
+      type: 'pattern',
+      element: 'Import reorganization',
+      evidence: `${importChanges} import statements modified`,
+      confidence: 0.4,
+      category: 'code-organization'
+    });
+  }
+
+  patterns.push(...codePatterns);
+
+  return patterns;
+}
+
+/**
+ * Save detected patterns to .mindmeld/patterns/
+ */
+async function savePatterns(projectPath, patterns) {
+  const patternsDir = path.join(projectPath, '.mindmeld', 'patterns');
+  await fs.mkdir(patternsDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const harvestFile = path.join(patternsDir, `harvest-${timestamp}.json`);
+
+  const harvest = {
+    timestamp: new Date().toISOString(),
+    source: 'manual-harvest',
+    patterns: patterns,
+    projectPath: projectPath,
+    projectName: path.basename(projectPath)
+  };
+
+  await fs.writeFile(harvestFile, JSON.stringify(harvest, null, 2));
+  return harvestFile;
+}
+
+/**
+ * Main harvest execution
+ */
+async function harvest(options = {}) {
+  const projectPath = options.path || process.cwd();
+  const dryRun = options.dryRun || false;
+
+  console.error(`[MindMeld] Harvesting patterns from: ${projectPath}`);
+  console.error(`[MindMeld] Period: last ${options.since || '7d'}, max ${options.commits || 10} commits`);
+  console.error('');
+
+  // 1. Get git history
+  let gitHistory;
+  try {
+    gitHistory = await getGitHistory(projectPath, {
+      since: options.since || '7d',
+      commits: options.commits || 10
+    });
+  } catch (error) {
+    if (error.message === 'not a git repository') {
+      console.error('[MindMeld] Not a git repository. Harvest requires git history.');
+      process.exit(1);
+    }
+    throw error;
+  }
+
+  // 2. Detect patterns
+  const patterns = detectPatterns(gitHistory);
+
+  if (patterns.length === 0) {
+    console.error('[MindMeld] No patterns detected in recent history.');
+    console.error('[MindMeld] Try a longer period: mindmeld harvest --since 30d');
+    return;
+  }
+
+  // 3. Display results
+  console.error(`[MindMeld] Detected ${patterns.length} pattern(s):\n`);
+  for (const pattern of patterns) {
+    const confidence = (pattern.confidence * 100).toFixed(0);
+    console.error(`  [${pattern.type}] ${pattern.element}`);
+    console.error(`    Category: ${pattern.category} | Confidence: ${confidence}%`);
+    console.error(`    Evidence: ${pattern.evidence}`);
+    console.error('');
+  }
+
+  // 4. Save (unless dry-run)
+  if (!dryRun) {
+    const savedPath = await savePatterns(projectPath, patterns);
+    console.error(`[MindMeld] Patterns saved to: ${path.relative(projectPath, savedPath)}`);
+    console.error(`[MindMeld] Patterns with 5+ detections will be promoted to provisional standards.`);
+  } else {
+    console.error('[MindMeld] Dry run - no patterns saved.');
+  }
+
+  // 5. Try LLM-powered detection if available
+  try {
+    const llmModule = require('../src/core/LLMPatternDetector');
+    if (llmModule && process.env.MINDMELD_USE_LLM !== 'false') {
+      console.error('\n[MindMeld] LLM-powered detection available for deeper analysis.');
+      console.error('[MindMeld] Set MINDMELD_USE_LLM=true for semantic pattern detection.');
+    }
+  } catch {
+    // LLM module not available
+  }
+}
+
+/**
+ * Promote high-confidence patterns to local staging
+ * Writes to .mindmeld/patterns/{category}/ (local, never directly to community repo)
+ * Community promotion happens via API → PR to EquilateralAgents-Community-Standards
+ */
+async function promotePatterns(projectPath, patterns, options = {}) {
+  const threshold = options.threshold || 0.5;
+  const standardsDir = path.join(projectPath, '.mindmeld', 'patterns');
+
+  const eligible = patterns.filter(p => p.confidence >= threshold);
+  if (eligible.length === 0) return [];
+
+  await fs.mkdir(standardsDir, { recursive: true });
+
+  const promoted = [];
+
+  for (const pattern of eligible) {
+    const categoryDir = path.join(standardsDir, pattern.category);
+    await fs.mkdir(categoryDir, { recursive: true });
+
+    const filename = pattern.element
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '_')
+      .replace(/^_|_$/g, '') + '.md';
+
+    const filePath = path.join(categoryDir, filename);
+
+    // Don't overwrite existing standards
+    try {
+      await fs.access(filePath);
+      continue;
+    } catch {
+      // File doesn't exist, safe to create
+    }
+
+    const content = [
+      `# ${pattern.element}`,
+      '',
+      `**Status**: provisional`,
+      `**Category**: ${pattern.category}`,
+      `**Confidence**: ${(pattern.confidence * 100).toFixed(0)}%`,
+      `**Source**: git-harvest`,
+      `**Detected**: ${new Date().toISOString().split('T')[0]}`,
+      '',
+      '## Evidence',
+      '',
+      `- ${pattern.evidence}`,
+      '',
+      '## Guidance',
+      '',
+      pattern.type === 'anti-pattern'
+        ? `- Avoid: ${pattern.element}`
+        : `- Follow: ${pattern.element}`,
+      '',
+      '---',
+      '*Provisional standard - will be promoted to solidified after 5+ consistent detections.*'
+    ].join('\n');
+
+    await fs.writeFile(filePath, content);
+    promoted.push({ pattern, path: filePath });
+  }
+
+  return promoted;
+}
+
+/**
+ * Harvest decisions from Claude Code plan files
+ * Matches plans to project by correlating session timestamps with plan file mtimes
+ */
+async function harvestPlans(projectPath) {
+  const os = require('os');
+  const homeDir = os.homedir();
+  const plansDir = path.join(homeDir, '.claude', 'plans');
+  const projectsDir = path.join(homeDir, '.claude', 'projects');
+
+  // Encode project path the same way Claude Code does
+  const encodedPath = projectPath.replace(/\//g, '-');
+  const sessionIndexPath = path.join(projectsDir, encodedPath, 'sessions-index.json');
+
+  // 1. Load sessions for this project
+  let sessions;
+  try {
+    const indexContent = await fs.readFile(sessionIndexPath, 'utf-8');
+    const index = JSON.parse(indexContent);
+    sessions = index.entries || [];
+  } catch {
+    return []; // No sessions found for this project
+  }
+
+  if (sessions.length === 0) return [];
+
+  // 2. Get time window from sessions (earliest created → now, since current session may not be indexed)
+  const sessionTimes = sessions.map(s => new Date(s.created).getTime());
+  const windowStart = Math.min(...sessionTimes);
+  const windowEnd = Date.now();
+
+  // 3. Find plan files within the session time window
+  let planFiles;
+  try {
+    const entries = await fs.readdir(plansDir);
+    planFiles = [];
+    for (const entry of entries) {
+      if (!entry.endsWith('.md')) continue;
+      const filePath = path.join(plansDir, entry);
+      const stat = await fs.stat(filePath);
+      const mtime = stat.mtimeMs;
+      if (mtime >= windowStart && mtime <= windowEnd) {
+        planFiles.push({ path: filePath, name: entry, mtime });
+      }
+    }
+  } catch {
+    return []; // No plans directory
+  }
+
+  // 4. Content-match: only keep plans that reference files/terms from this project
+  const projectName = path.basename(projectPath).toLowerCase();
+  const relevantPlans = [];
+
+  for (const planFile of planFiles) {
+    try {
+      const content = await fs.readFile(planFile.path, 'utf-8');
+      const contentLower = content.toLowerCase();
+
+      // Score relevance by checking project indicators
+      let relevance = 0;
+
+      // Project name match (strongest signal)
+      if (contentLower.includes(projectName)) relevance += 5;
+
+      // Check if plan mentions files that exist in this project
+      const fileRefs = content.match(/`([^`]+\.(js|ts|json|yaml|yml|py|sql))`/g) || [];
+      for (const ref of fileRefs.slice(0, 10)) {
+        const cleanRef = ref.replace(/`/g, '');
+        try {
+          await fs.access(path.join(projectPath, cleanRef));
+          relevance += 3; // File exists in this project
+        } catch {
+          // File doesn't exist here
+        }
+      }
+
+      // Check for project-specific paths
+      if (content.includes(projectPath)) relevance += 10;
+
+      if (relevance >= 3) {
+        planFile.relevance = relevance;
+        planFile.content = content;
+        relevantPlans.push(planFile);
+      }
+    } catch {
+      // Skip unreadable
+    }
+  }
+
+  planFiles = relevantPlans;
+
+  if (planFiles.length === 0) return [];
+
+  // 5. Extract decisions from matched plan files
+  const decisions = [];
+
+  for (const planFile of planFiles) {
+    try {
+      const content = planFile.content || await fs.readFile(planFile.path, 'utf-8');
+
+      // Extract "Decisions" sections
+      const decisionPatterns = [
+        /## Decisions?\s*(?:Confirmed|Made)?\s*\n([\s\S]*?)(?=\n## |\n---|\Z)/gi,
+        /\| Decision \|[\s\S]*?\n((?:\|[^\n]+\n)+)/gi
+      ];
+
+      for (const pattern of decisionPatterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+          const section = match[1] || match[0];
+          // Parse table rows or bullet points
+          const lines = section.split('\n').filter(l =>
+            l.includes('|') && !l.includes('---') && !l.includes('Decision') && l.trim().length > 5
+          );
+
+          for (const line of lines) {
+            const cells = line.split('|').map(c => c.trim()).filter(c => c.length > 0);
+            if (cells.length >= 2) {
+              decisions.push({
+                type: 'decision',
+                element: cells[0].replace(/\*\*/g, ''),
+                evidence: cells[1].replace(/\*\*/g, ''),
+                confidence: 0.8,
+                category: 'architecture',
+                source: planFile.name
+              });
+            }
+          }
+        }
+      }
+
+      // Extract "Recommendation:" lines
+      const recommendations = content.match(/\*\*Recommendation:?\*\*:?\s*(.+)/gi) || [];
+      for (const rec of recommendations) {
+        const cleaned = rec.replace(/\*\*Recommendation:?\*\*:?\s*/i, '').trim();
+        if (cleaned.length > 10) {
+          decisions.push({
+            type: 'decision',
+            element: cleaned,
+            evidence: `From plan: ${planFile.name}`,
+            confidence: 0.7,
+            category: 'architecture',
+            source: planFile.name
+          });
+        }
+      }
+    } catch {
+      // Skip unreadable plans
+    }
+  }
+
+  // Deduplicate by element name (keep longest evidence)
+  const unique = {};
+  for (const d of decisions) {
+    if (!unique[d.element] || d.evidence.length > unique[d.element].evidence.length) {
+      unique[d.element] = d;
+    }
+  }
+
+  return Object.values(unique);
+}
+
+/**
+ * Promote plan decisions to standards
+ * Always writes to .mindmeld/decisions/ (local staging)
+ * Community promotion happens via API → PR to EquilateralAgents-Community-Standards
+ */
+async function promoteDecisions(projectPath, decisions, options = {}) {
+  if (decisions.length === 0) return [];
+
+  const decisionsDir = path.join(projectPath, '.mindmeld', 'decisions');
+  await fs.mkdir(decisionsDir, { recursive: true });
+
+  const promoted = [];
+
+  for (const decision of decisions) {
+    const filename = decision.element
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '_')
+      .replace(/^_|_$/g, '')
+      .substring(0, 50) + '.md';
+
+    const filePath = path.join(decisionsDir, filename);
+
+    // Don't overwrite existing
+    try {
+      await fs.access(filePath);
+      continue;
+    } catch {
+      // Safe to create
+    }
+
+    const content = [
+      `# ${decision.element}`,
+      '',
+      `**Status**: solidified`,
+      `**Category**: ${decision.category}`,
+      `**Confidence**: ${(decision.confidence * 100).toFixed(0)}%`,
+      `**Source**: plan-harvest`,
+      `**Detected**: ${new Date().toISOString().split('T')[0]}`,
+      '',
+      '## Decision',
+      '',
+      `- ${decision.evidence}`,
+      '',
+      '## Context',
+      '',
+      `Extracted from: ${decision.source}`,
+      '',
+      '---',
+      '*Architectural decision - do not revisit without explicit discussion.*'
+    ].join('\n');
+
+    await fs.writeFile(filePath, content);
+    promoted.push({ decision, path: filePath });
+  }
+
+  return promoted;
+}
+
+module.exports = { harvest, promotePatterns, promoteDecisions, harvestPlans, getGitHistory, detectPatterns, savePatterns, showHarvestHelp };