@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/scripts/harvest.js

@@ -1,601 +0,0 @@
-#!/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: 10 * 1024 * 1024 }
-    );
-
-    // For large repos, limit diff output to avoid buffer overflow
-    let diff = '';
-    try {
-      const { stdout } = await execAsync(
-        `git log --since="${since}" -n ${maxCommits} -p --diff-filter=M -- '*.js' '*.ts' '*.py' '*.java' '*.go' '*.rs'`,
-        { cwd: projectPath, maxBuffer: 20 * 1024 * 1024 }
-      );
-      diff = stdout;
-    } catch (diffError) {
-      // If diff is too large, try with fewer commits
-      if (diffError.message.includes('maxBuffer')) {
-        const { stdout } = await execAsync(
-          `git log --since="${since}" -n 10 -p --diff-filter=M -- '*.js' '*.ts'`,
-          { cwd: projectPath, maxBuffer: 10 * 1024 * 1024 }
-        );
-        diff = stdout;
-      }
-    }
-
-    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 (error) {
-    // Expected: LLM module not available
-    if (error.code !== 'MODULE_NOT_FOUND') {
-      console.error('Unexpected error loading LLM module:', error.message);
-    }
-  }
-}
-
-/**
- * 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 (error) {
-      // Expected: file doesn't exist, safe to create
-      if (error.code !== 'ENOENT') {
-        console.error(`Unexpected error checking ${filePath}:`, error.message);
-      }
-    }
-
-    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 (error) {
-    // Expected: no sessions file
-    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
-      console.error('Unexpected error reading sessions:', error.message);
-    }
-    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 (error) {
-    // Expected: no plans directory
-    if (error.code !== 'ENOENT') {
-      console.error('Unexpected error reading plans:', error.message);
-    }
-    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 (error) {
-          // Expected: file doesn't exist here
-          if (error.code !== 'ENOENT') {
-            console.error(`Unexpected error checking ${cleanRef}:`, error.message);
-          }
-        }
-      }
-
-      // Check for project-specific paths
-      if (content.includes(projectPath)) relevance += 10;
-
-      if (relevance >= 3) {
-        planFile.relevance = relevance;
-        planFile.content = content;
-        relevantPlans.push(planFile);
-      }
-    } catch (error) {
-      // Expected: file not readable
-      if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-        console.error(`Unexpected error reading plan ${planFile.path}:`, error.message);
-      }
-    }
-  }
-
-  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 (error) {
-      // Expected: file not readable
-      if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-        console.error(`Unexpected error processing plan:`, error.message);
-      }
-    }
-  }
-
-  // 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 (error) {
-      // Expected: file doesn't exist, safe to create
-      if (error.code !== 'ENOENT') {
-        console.error(`Unexpected error checking ${filePath}:`, error.message);
-      }
-    }
-
-    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 };