@equilateral_ai/mindmeld 3.0.0

package/scripts/init-project.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+/**
+ * MindMeld CLI - Initialize project for intelligent standards injection
+ *
+ * Usage:
+ *   mindmeld init              # Initialize for solo/private use
+ *   mindmeld init --team       # Initialize with team collaboration
+ *   mindmeld init /path/to/project
+ *
+ * @equilateral_ai/mindmeld v3.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+// Parse CLI arguments
+function parseArgs(args) {
+  const parsed = {
+    command: null,
+    projectPath: null,
+    team: false,
+    format: 'raw',
+    since: '7d',
+    commits: 10,
+    dryRun: false,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--team') parsed.team = true;
+    else if (arg === '--dry-run') parsed.dryRun = true;
+    else if (arg === '--help' || arg === '-h') parsed.help = true;
+    else if (arg === '--format' && args[i + 1]) { parsed.format = args[++i]; }
+    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 (['init', 'inject', 'harvest'].includes(arg)) parsed.command = arg;
+    else if (!arg.startsWith('-') && !parsed.command) parsed.command = arg;
+    else if (!arg.startsWith('-') && !parsed.projectPath) parsed.projectPath = arg;
+  }
+
+  // Default command is 'init'
+  if (!parsed.command) parsed.command = 'init';
+
+  return parsed;
+}
+
+function showHelp() {
+  console.log(`
+MindMeld - Intelligent Standards Injection for AI Coding Tools
+
+Usage:
+  mindmeld <command> [options]
+
+Commands:
+  init [path]     Initialize project for MindMeld
+  inject          Generate context-aware standards for any AI tool
+  harvest         Manually capture patterns from recent git history
+
+Options:
+  --team          Enable team collaboration (init only)
+  --format <type> Output format: raw, cursorrules, windsurfrules, aider, claude
+  --path <dir>    Project path (default: current directory)
+  --help, -h      Show this help message
+
+Examples:
+  mindmeld init --team                         # Init with team collaboration
+  mindmeld inject --format cursorrules         # Update .cursorrules
+  mindmeld inject --format windsurfrules       # Update .windsurfrules
+  mindmeld inject --format aider              # Update aider conventions
+  mindmeld inject                              # Raw markdown to stdout
+  mindmeld inject | ollama run qwen3-coder     # Pipe to local model
+  mindmeld harvest                             # Capture patterns from git diff
+
+Works with: Claude Code, Cursor, Windsurf, Codex CLI, Aider, Ollama, LM Studio
+
+Learn more: https://mindmeld.dev
+`);
+}
+
+async function initProject(projectPath, options = {}) {
+  projectPath = projectPath || process.cwd();
+
+  console.log(`\n🎯 Initializing MindMeld for: ${projectPath}\n`);
+
+  if (options.team) {
+    console.log('   Mode: Team collaboration\n');
+  } else {
+    console.log('   Mode: Private (solo)\n');
+  }
+
+  // 1. Check if already initialized
+  const mindmeldDir = path.join(projectPath, '.mindmeld');
+  const configPath = path.join(mindmeldDir, 'config.json');
+
+  try {
+    await fs.access(configPath);
+    console.log('⚠️  Project already initialized!');
+    console.log(`   Config exists at: ${configPath}\n`);
+
+    const answer = await promptYesNo('Reinitialize? (y/n): ');
+    if (!answer) {
+      console.log('Aborted.');
+      process.exit(0);
+    }
+  } catch {
+    // Not initialized, continue
+  }
+
+  // 2. Get project name
+  const projectName = path.basename(projectPath);
+  const projectId = projectName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+
+  // 3. Discover collaborators from git
+  let collaborators = [];
+
+  try {
+    const { stdout } = await execAsync(
+      'git log --format="%an|%ae" | sort | uniq -c | sort -rn | head -10',
+      { cwd: projectPath }
+    );
+
+    const lines = stdout.trim().split('\n');
+    for (const line of lines) {
+      const match = line.trim().match(/^\s*(\d+)\s+(.+)\|(.+)$/);
+      if (match) {
+        const [, commits, name, email] = match;
+        if (parseInt(commits) >= 3) {
+          collaborators.push({
+            userId: email.split('@')[0].toLowerCase().replace(/[^a-z0-9]/g, ''),
+            name: name.trim(),
+            email: email.trim(),
+            role: 'collaborator',
+            source: 'git',
+            commits: parseInt(commits)
+          });
+        }
+      }
+    }
+
+    if (collaborators.length > 0) {
+      console.log('📋 Discovered collaborators from git history:\n');
+      collaborators.forEach((c, i) => {
+        console.log(`   ${i + 1}. ${c.name} <${c.email}> (${c.commits} commits)`);
+      });
+      console.log('');
+    }
+  } catch (error) {
+    console.log('ℹ️  No git history found (not a git repo or no commits)\n');
+  }
+
+  // 4. Create .mindmeld directory
+  await fs.mkdir(mindmeldDir, { recursive: true });
+
+  // 5. Create config.json
+  const config = {
+    projectId,
+    projectName,
+    created: new Date().toISOString(),
+    collaborators,
+    private: !options.team,
+    team: options.team,
+    externalUsersAllowed: false,
+    mindmeldVersion: '3.0.0'
+  };
+
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+  console.log('✅ MindMeld initialized!\n');
+  console.log(`   Config: ${configPath}`);
+  console.log(`   Project ID: ${projectId}`);
+  console.log(`   Mode: ${options.team ? 'Team' : 'Private'}`);
+  console.log(`   Collaborators: ${collaborators.length}`);
+  console.log('');
+
+  // 6. Check for community standards
+  const standardsDir = path.join(projectPath, '.equilateral-standards');
+
+  try {
+    await fs.access(standardsDir);
+    console.log('ℹ️  Community standards (.equilateral-standards) available');
+  } catch {
+    // Try to clone the community standards repo
+    try {
+      await execAsync(
+        'git clone https://github.com/Equilateral-AI/EquilateralAgents-Community-Standards.git .equilateral-standards',
+        { cwd: projectPath }
+      );
+      console.log('✅ Cloned community standards repo');
+    } catch {
+      console.log('ℹ️  Community standards not available (clone from:');
+      console.log('   https://github.com/Equilateral-AI/EquilateralAgents-Community-Standards)');
+      console.log('   Local patterns will still be captured in .mindmeld/');
+    }
+  }
+
+  // 7. Bootstrap: harvest patterns from git history and promote to standards
+  await bootstrapFromHistory(projectPath, { team: options.team });
+
+  // 8. Configure Claude Code hooks
+  await configureClaudeHooks(projectPath);
+
+  // 9. Register with API if team mode
+  if (options.team) {
+    console.log('\n📡 Team mode enabled.');
+    console.log('   Sign in at https://app.mindmeld.dev to connect this project.');
+    console.log('   Your coding sessions will contribute to team-wide standards.\n');
+  }
+
+  // 10. Summary
+  console.log('\n🚀 Next steps:');
+  console.log('   1. Start a Claude Code session in this project');
+  console.log('   2. MindMeld hooks will inject relevant standards automatically');
+  console.log('   3. Patterns from your sessions will be harvested and validated');
+  if (options.team) {
+    console.log('   4. Sign in at https://app.mindmeld.dev to manage team standards');
+  }
+  console.log('');
+}
+
+/**
+ * Bootstrap: scan 90 days of git history, detect patterns, promote to standards
+ */
+async function bootstrapFromHistory(projectPath, options = {}) {
+  console.log('\n📊 Bootstrapping from git history...\n');
+
+  try {
+    const { getGitHistory, detectPatterns, savePatterns, promotePatterns, harvestPlans, promoteDecisions } = require('./harvest');
+
+    // Get extended git history
+    const gitHistory = await getGitHistory(projectPath, { since: '90d', commits: 50 });
+    const patterns = detectPatterns(gitHistory);
+
+    if (patterns.length === 0) {
+      console.log('   No patterns detected in git history.');
+      console.log('   Standards will be populated as you code.\n');
+      return;
+    }
+
+    // Save raw patterns
+    await savePatterns(projectPath, patterns);
+
+    // Promote high-confidence patterns to provisional standards
+    const promoted = await promotePatterns(projectPath, patterns, { threshold: 0.5 });
+
+    console.log(`   Detected ${patterns.length} pattern(s) from git history`);
+    if (promoted.length > 0) {
+      console.log(`   Promoted ${promoted.length} to provisional standards:`);
+      for (const p of promoted) {
+        console.log(`     - ${p.pattern.element} (${(p.pattern.confidence * 100).toFixed(0)}% confidence)`);
+      }
+    }
+
+    // Harvest decisions from Claude Code plan files
+    const planDecisions = await harvestPlans(projectPath);
+    if (planDecisions.length > 0) {
+      const promotedDecisions = await promoteDecisions(projectPath, planDecisions);
+      console.log(`   Found ${planDecisions.length} decision(s) from session plans`);
+      if (promotedDecisions.length > 0) {
+        console.log(`   Promoted ${promotedDecisions.length} to .mindmeld/decisions/:`);
+        for (const d of promotedDecisions) {
+          console.log(`     - ${d.decision.element}`);
+        }
+      }
+    }
+
+    console.log('');
+  } catch (error) {
+    if (error.message && error.message.includes('not a git repository')) {
+      console.log('   No git history available (not a git repo).\n');
+    } else {
+      console.log(`   Bootstrap skipped: ${error.message}\n`);
+    }
+  }
+}
+
+/**
+ * Configure Claude Code hooks in .claude/settings.json
+ * This wires up MindMeld's session-start and pre-compact hooks
+ */
+async function configureClaudeHooks(projectPath) {
+  const claudeDir = path.join(projectPath, '.claude');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  // Resolve hook paths from installed package location
+  const packageRoot = path.resolve(__dirname, '..');
+  const sessionStartHook = path.join(packageRoot, 'hooks', 'session-start.js');
+  const preCompactHook = path.join(packageRoot, 'hooks', 'pre-compact.js');
+
+  // Verify hooks exist
+  try {
+    await fs.access(sessionStartHook);
+    await fs.access(preCompactHook);
+  } catch {
+    console.log('⚠️  Hook scripts not found in package. Skipping hook configuration.');
+    console.log(`   Expected at: ${packageRoot}/hooks/`);
+    return;
+  }
+
+  // MindMeld hook definitions
+  const mindmeldHooks = {
+    SessionStart: [
+      {
+        hooks: [
+          {
+            type: 'command',
+            command: `node "${sessionStartHook}"`,
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    PreCompact: [
+      {
+        hooks: [
+          {
+            type: 'command',
+            command: `node "${preCompactHook}"`,
+            timeout: 30
+          }
+        ]
+      }
+    ]
+  };
+
+  // Create .claude directory
+  await fs.mkdir(claudeDir, { recursive: true });
+
+  // Load existing settings if present
+  let settings = {};
+  try {
+    const existing = await fs.readFile(settingsPath, 'utf-8');
+    settings = JSON.parse(existing);
+  } catch {
+    // No existing settings, start fresh
+  }
+
+  // Merge hooks (preserve existing non-MindMeld hooks)
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // Check if MindMeld hooks already configured
+  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'))
+  );
+
+  if (hasSessionStart && hasPreCompact) {
+    console.log('ℹ️  Claude Code hooks already configured');
+    return;
+  }
+
+  // Add MindMeld hooks (append to existing, don't replace)
+  if (!hasSessionStart) {
+    settings.hooks.SessionStart = [
+      ...(settings.hooks.SessionStart || []),
+      ...mindmeldHooks.SessionStart
+    ];
+  }
+  if (!hasPreCompact) {
+    settings.hooks.PreCompact = [
+      ...(settings.hooks.PreCompact || []),
+      ...mindmeldHooks.PreCompact
+    ];
+  }
+
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+
+  console.log('✅ Claude Code hooks configured');
+  console.log(`   SessionStart: ${sessionStartHook}`);
+  console.log(`   PreCompact: ${preCompactHook}`);
+}
+
+async function promptYesNo(question) {
+  process.stdout.write(question);
+
+  return new Promise((resolve) => {
+    process.stdin.once('data', (data) => {
+      const answer = data.toString().trim().toLowerCase();
+      resolve(answer === 'y' || answer === 'yes');
+    });
+  });
+}
+
+// Main
+const args = parseArgs(process.argv.slice(2));
+
+if (args.help && !args.command) {
+  showHelp();
+  process.exit(0);
+}
+
+if (args.command === 'init') {
+  if (args.help) { showHelp(); process.exit(0); }
+  initProject(args.projectPath, { team: args.team })
+    .then(() => process.exit(0))
+    .catch(error => {
+      console.error('\n❌ Error:', error.message);
+      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);
+    });
+} else if (args.command === 'harvest') {
+  const { harvest, showHarvestHelp } = require('./harvest');
+  if (args.help) {
+    showHarvestHelp();
+    process.exit(0);
+  }
+  harvest({ path: args.projectPath, since: args.since, commits: args.commits, dryRun: args.dryRun })
+    .then(() => process.exit(0))
+    .catch(error => {
+      console.error('\n❌ Error:', error.message);
+      process.exit(1);
+    });
+} else {
+  console.error(`Unknown command: ${args.command}`);
+  console.error('Run "mindmeld --help" for usage.');
+  process.exit(1);
+}