@equilateral_ai/mindmeld 3.0.0

package/scripts/inject.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+/**
+ * MindMeld CLI - Inject relevant standards into AI coding tool config
+ *
+ * Usage:
+ *   mindmeld inject                     # stdout (raw markdown)
+ *   mindmeld inject --format cursorrules
+ *   mindmeld inject --format windsurfrules
+ *   mindmeld inject --format aider
+ *   mindmeld inject --format claude     # Claude Code hook format
+ *
+ * @equilateral_ai/mindmeld v3.0.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+
+const FORMATS = {
+  raw: { file: null, description: 'Raw markdown to stdout' },
+  cursorrules: { file: '.cursorrules', description: 'Cursor rules file' },
+  windsurfrules: { file: '.windsurfrules', description: 'Windsurf rules file' },
+  aider: { file: '.aider.conventions.md', description: 'Aider conventions file' },
+  claude: { file: null, description: 'Claude Code hook format (stdout)' }
+};
+
+function showInjectHelp() {
+  console.log(`
+MindMeld inject - Generate context-aware standards for any AI coding tool
+
+Usage:
+  mindmeld inject [options]
+
+Options:
+  --format <type>  Output format (default: raw)
+  --path <dir>     Project path (default: current directory)
+  --help, -h       Show this help
+
+Formats:
+  raw              Plain markdown to stdout (pipe anywhere)
+  cursorrules      Write .cursorrules file
+  windsurfrules    Write .windsurfrules file
+  aider            Write .aider.conventions.md file
+  claude           Claude Code hook format (stdout)
+
+Examples:
+  mindmeld inject                              # Print standards to stdout
+  mindmeld inject --format cursorrules         # Update .cursorrules
+  mindmeld inject --format aider               # Update aider conventions
+  mindmeld inject | ollama run qwen3-coder     # Pipe to local model
+  mindmeld inject --format raw >> system.txt   # Append to system prompt
+`);
+}
+
+/**
+ * Detect project context by scanning files in the working directory
+ */
+async function detectProjectContext(projectPath) {
+  const context = {
+    projectName: path.basename(projectPath),
+    languages: [],
+    frameworks: [],
+    files: []
+  };
+
+  // Check for common project indicators
+  const checks = [
+    { file: 'package.json', language: 'javascript', frameworks: ['node'] },
+    { file: 'tsconfig.json', language: 'typescript', frameworks: ['node'] },
+    { file: 'template.yaml', language: 'yaml', frameworks: ['aws-sam'] },
+    { file: 'serverless.yml', language: 'yaml', frameworks: ['serverless'] },
+    { file: 'Dockerfile', language: 'docker', frameworks: ['docker'] },
+    { file: 'requirements.txt', language: 'python', frameworks: [] },
+    { file: 'go.mod', language: 'go', frameworks: [] },
+    { file: 'Cargo.toml', language: 'rust', frameworks: [] },
+    { file: '.terraform', language: 'hcl', frameworks: ['terraform'] }
+  ];
+
+  for (const check of checks) {
+    try {
+      await fs.access(path.join(projectPath, check.file));
+      if (!context.languages.includes(check.language)) {
+        context.languages.push(check.language);
+      }
+      context.frameworks.push(...check.frameworks);
+      context.files.push(check.file);
+    } catch {
+      // File doesn't exist
+    }
+  }
+
+  // Check for specific patterns in package.json
+  try {
+    const pkg = JSON.parse(await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps['react'] || deps['next']) context.frameworks.push('react');
+    if (deps['express'] || deps['fastify']) context.frameworks.push('api');
+    if (deps['@aws-sdk']) context.frameworks.push('aws');
+    if (deps['pg'] || deps['mysql2'] || deps['mongoose']) context.frameworks.push('database');
+  } catch {
+    // No package.json or can't parse
+  }
+
+  return context;
+}
+
+/**
+ * Load and score standards from .equilateral-standards
+ */
+async function getRelevantStandards(projectPath, context) {
+  const standardsDir = path.join(projectPath, '.equilateral-standards');
+  const standards = [];
+
+  try {
+    await fs.access(standardsDir);
+  } catch {
+    return [];
+  }
+
+  // Recursively find all .md standard files from community repo
+  async function scanDir(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scanDir(fullPath);
+      } else if (entry.name.endsWith('.md') && entry.name !== 'README.md') {
+        try {
+          const content = await fs.readFile(fullPath, 'utf-8');
+          const relativePath = path.relative(standardsDir, fullPath);
+          const category = path.dirname(relativePath).replace(/\//g, '/');
+          standards.push({
+            element: entry.name.replace('.md', '').replace(/_/g, ' '),
+            category: category === '.' ? 'general' : category,
+            content: content,
+            path: relativePath,
+            score: 0
+          });
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  await scanDir(standardsDir);
+
+  // Score relevance based on project context
+  for (const standard of standards) {
+    let score = 0;
+    const contentLower = standard.content.toLowerCase();
+    const categoryLower = standard.category.toLowerCase();
+
+    // Language match
+    for (const lang of context.languages) {
+      if (contentLower.includes(lang) || categoryLower.includes(lang)) {
+        score += 3;
+      }
+    }
+
+    // Framework match
+    for (const fw of context.frameworks) {
+      if (contentLower.includes(fw) || categoryLower.includes(fw)) {
+        score += 5;
+      }
+    }
+
+    // Category relevance boost
+    if (categoryLower.includes('serverless') && context.frameworks.includes('aws-sam')) score += 4;
+    if (categoryLower.includes('api') && context.frameworks.includes('api')) score += 4;
+    if (categoryLower.includes('database') && context.frameworks.includes('database')) score += 4;
+    if (categoryLower.includes('react') && context.frameworks.includes('react')) score += 4;
+    if (categoryLower.includes('cost') && context.frameworks.includes('aws')) score += 3;
+
+    // Base score for all standards (everyone gets some relevance)
+    score += 1;
+
+    standard.score = score;
+  }
+
+  // Sort by relevance, return top 10
+  standards.sort((a, b) => b.score - a.score);
+  return standards.slice(0, 10);
+}
+
+/**
+ * Load team patterns from .mindmeld config
+ */
+async function loadTeamPatterns(projectPath) {
+  try {
+    const configPath = path.join(projectPath, '.mindmeld', 'config.json');
+    const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+    return {
+      projectName: config.projectName || path.basename(projectPath),
+      collaborators: config.collaborators || [],
+      team: config.team || false
+    };
+  } catch {
+    return {
+      projectName: path.basename(projectPath),
+      collaborators: [],
+      team: false
+    };
+  }
+}
+
+/**
+ * Format standards as raw markdown
+ */
+function formatRaw(standards, projectInfo, context) {
+  const sections = [];
+
+  sections.push(`# Standards for ${projectInfo.projectName}`);
+  sections.push(`<!-- Generated by MindMeld | ${new Date().toISOString()} -->`);
+  sections.push(`<!-- Context: ${context.languages.join(', ')} | ${context.frameworks.join(', ')} -->`);
+  sections.push('');
+
+  if (standards.length === 0) {
+    sections.push('No standards found. Run `mindmeld init` to set up your project.');
+    return sections.join('\n');
+  }
+
+  sections.push(`Injecting ${standards.length} relevant standards (of ${standards.length} scored):`);
+  sections.push('');
+
+  for (const standard of standards) {
+    sections.push(`## ${standard.element}`);
+    sections.push(`**Category**: ${standard.category} | **Relevance**: ${standard.score}`);
+    sections.push('');
+    // Truncate content to keep injection lean
+    const lines = standard.content.split('\n');
+    const truncated = lines.slice(0, 30).join('\n');
+    sections.push(truncated);
+    if (lines.length > 30) {
+      sections.push('...');
+    }
+    sections.push('');
+  }
+
+  sections.push('---');
+  sections.push('*Generated by MindMeld - mindmeld.dev*');
+
+  return sections.join('\n');
+}
+
+/**
+ * Format for .cursorrules / .windsurfrules (compact rules format)
+ */
+function formatRulesFile(standards, projectInfo, context) {
+  const sections = [];
+
+  sections.push(`# Project Standards - ${projectInfo.projectName}`);
+  sections.push(`# Auto-generated by MindMeld (mindmeld.dev)`);
+  sections.push(`# Context: ${context.frameworks.join(', ') || context.languages.join(', ')}`);
+  sections.push(`# Run \`mindmeld inject --format ${context._format}\` to regenerate`);
+  sections.push('');
+
+  for (const standard of standards) {
+    sections.push(`## ${standard.element}`);
+    // Extract just the key rules, not full prose
+    const lines = standard.content.split('\n');
+    const ruleLines = lines.filter(l =>
+      l.startsWith('- ') || l.startsWith('* ') ||
+      l.startsWith('  - ') || l.startsWith('> ') ||
+      l.match(/^#{1,4}\s/) || l.match(/^\*\*[^*]+\*\*:/)
+    ).slice(0, 10);
+
+    if (ruleLines.length > 0) {
+      sections.push(ruleLines.join('\n'));
+    } else {
+      // Fallback: first meaningful paragraph
+      const meaningful = lines.filter(l => l.trim().length > 20 && !l.startsWith('#')).slice(0, 3);
+      sections.push(meaningful.join('\n'));
+    }
+    sections.push('');
+  }
+
+  return sections.join('\n');
+}
+
+/**
+ * Format for aider conventions
+ */
+function formatAider(standards, projectInfo, context) {
+  const sections = [];
+
+  sections.push(`# Coding Conventions - ${projectInfo.projectName}`);
+  sections.push('');
+  sections.push(`> Auto-generated by MindMeld (mindmeld.dev)`);
+  sections.push(`> Run \`mindmeld inject --format aider\` to regenerate`);
+  sections.push('');
+
+  for (const standard of standards) {
+    sections.push(`## ${standard.element}`);
+    sections.push('');
+    // Aider conventions prefer concise bullet points
+    const lines = standard.content.split('\n');
+    const bullets = lines.filter(l =>
+      l.startsWith('- ') || l.startsWith('* ') || l.match(/^\*\*[^*]+\*\*:/)
+    ).slice(0, 8);
+
+    if (bullets.length > 0) {
+      sections.push(bullets.join('\n'));
+    } else {
+      const meaningful = lines.filter(l => l.trim().length > 10 && !l.startsWith('#')).slice(0, 4);
+      sections.push(meaningful.join('\n'));
+    }
+    sections.push('');
+  }
+
+  return sections.join('\n');
+}
+
+/**
+ * Main inject execution
+ */
+async function inject(options = {}) {
+  const format = options.format || 'raw';
+  const projectPath = options.path || process.cwd();
+
+  if (!FORMATS[format]) {
+    console.error(`Unknown format: ${format}`);
+    console.error(`Available: ${Object.keys(FORMATS).join(', ')}`);
+    process.exit(1);
+  }
+
+  // Standalone detection (no database, no prompts, works everywhere)
+  let standards = [];
+  let projectInfo = {};
+  let context = {};
+
+  context = await detectProjectContext(projectPath);
+  standards = await getRelevantStandards(projectPath, context);
+  projectInfo = await loadTeamPatterns(projectPath);
+
+  context._format = format;
+
+  // 2. Format output
+  let output;
+  switch (format) {
+    case 'cursorrules':
+    case 'windsurfrules':
+      output = formatRulesFile(standards, projectInfo, context);
+      break;
+    case 'aider':
+      output = formatAider(standards, projectInfo, context);
+      break;
+    case 'claude':
+      // Use the session-start formatter with mapped fields
+      try {
+        const { formatContextInjection } = require('../hooks/session-start');
+        const mappedStandards = standards.map(s => ({
+          element: s.element,
+          category: s.category,
+          rule: s.content.split('\n').find(l => l.trim().length > 10 && !l.startsWith('#')) || s.element
+        }));
+        output = formatContextInjection({
+          project: projectInfo.projectName,
+          relevantStandards: mappedStandards,
+          teamPatterns: [],
+          recentLearning: [],
+          collaborators: projectInfo.collaborators || []
+        });
+      } catch {
+        output = formatRaw(standards, projectInfo, context);
+      }
+      break;
+    case 'raw':
+    default:
+      output = formatRaw(standards, projectInfo, context);
+      break;
+  }
+
+  // 3. Write to file or stdout
+  const targetFile = FORMATS[format].file;
+
+  if (targetFile) {
+    const targetPath = path.join(projectPath, targetFile);
+    await fs.writeFile(targetPath, output);
+    console.error(`[MindMeld] Written ${standards.length} standards to ${targetFile}`);
+    console.error(`[MindMeld] Context: ${context.languages ? context.languages.join(', ') : 'unknown'} | ${context.frameworks ? context.frameworks.join(', ') : ''}`);
+    console.error(`[MindMeld] Regenerate anytime: mindmeld inject --format ${format}`);
+  } else {
+    // Output to stdout (for piping)
+    console.log(output);
+  }
+}
+
+module.exports = { inject, showInjectHelp, FORMATS };