@equilateral_ai/mindmeld 3.5.3 → 4.0.2

package/scripts/inject.js

@@ -1,409 +0,0 @@
-#!/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 (error) {
-      // Expected: file doesn't exist
-      if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-        console.error(`Unexpected error checking ${check.file}:`, error.message);
-      }
-    }
-  }
-
-  // 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 (error) {
-    // Expected: no package.json or invalid JSON
-    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
-      console.error('Unexpected error reading package.json:', error.message);
-    }
-  }
-
-  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 (error) {
-    // Expected: standards dir doesn't exist
-    if (error.code !== 'ENOENT') {
-      console.error('Unexpected error accessing standards:', error.message);
-    }
-    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 (error) {
-          // Expected: file not readable
-          if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-            console.error(`Unexpected error reading ${fullPath}:`, error.message);
-          }
-        }
-      }
-    }
-  }
-
-  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 (error) {
-    // Expected: config doesn't exist or invalid JSON
-    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
-      console.error('Unexpected error loading team patterns:', error.message);
-    }
-    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 (error) {
-        // Expected: module not found in standalone mode
-        if (error.code !== 'MODULE_NOT_FOUND') {
-          console.error('Unexpected error with claude format:', error.message);
-        }
-        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 };

package/scripts/mcp-bridge.js

@@ -1,220 +0,0 @@
-/**
- * MindMeld MCP Bridge - Stdio-to-HTTP proxy for MCP clients
- *
- * Bridges stdio MCP transport to the remote MindMeld MCP server.
- * For clients that don't support URL transport natively
- * (Cline, Cursor, Windsurf, etc.)
- *
- * Usage:
- *   MINDMELD_TOKEN=mm_live_xxx mindmeld mcp
- *   mindmeld mcp --token mm_live_xxx
- */
-
-const https = require('https');
-const os = require('os');
-const fs = require('fs');
-const path = require('path');
-
-const MCP_HOST = 'api.mindmeld.dev';
-const MCP_PATH = '/api/mcp/mindmeld';
-const REQUEST_TIMEOUT = 30000;
-
-/**
- * Resolve API token from env var, CLI arg, or stored file
- */
-function resolveToken(cliToken) {
-    if (process.env.MINDMELD_TOKEN) {
-        return process.env.MINDMELD_TOKEN;
-    }
-    if (cliToken) {
-        return cliToken;
-    }
-    try {
-        const tokenPath = path.join(os.homedir(), '.mindmeld', 'api-token');
-        return fs.readFileSync(tokenPath, 'utf-8').trim();
-    } catch (err) {
-        return null;
-    }
-}
-
-/**
- * Forward a JSON-RPC message to the remote MCP server
- */
-function forwardToServer(message, token) {
-    return new Promise((resolve, reject) => {
-        const body = JSON.stringify(message);
-        const req = https.request({
-            method: 'POST',
-            hostname: MCP_HOST,
-            path: MCP_PATH,
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json',
-                'X-MindMeld-Token': token
-            },
-            timeout: REQUEST_TIMEOUT
-        }, (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                if (res.statusCode === 202 || !data.trim()) {
-                    resolve(null);
-                    return;
-                }
-                try {
-                    resolve(JSON.parse(data));
-                } catch (e) {
-                    reject(new Error(`Invalid JSON from server: ${data.substring(0, 200)}`));
-                }
-            });
-        });
-
-        req.on('timeout', () => {
-            req.destroy();
-            reject(new Error('Request timed out'));
-        });
-
-        req.on('error', (e) => {
-            reject(new Error(`Connection failed: ${e.message}`));
-        });
-
-        req.write(body);
-        req.end();
-    });
-}
-
-/**
- * Process a single JSON-RPC message from stdin
- */
-async function processMessage(line, token) {
-    let message;
-    try {
-        message = JSON.parse(line);
-    } catch (e) {
-        process.stdout.write(JSON.stringify({
-            jsonrpc: '2.0',
-            error: { code: -32700, message: 'Parse error: invalid JSON' },
-            id: null
-        }) + '\n');
-        return;
-    }
-
-    const isNotification = !('id' in message);
-
-    try {
-        const response = await forwardToServer(message, token);
-
-        if (response === null || isNotification) {
-            return;
-        }
-
-        process.stdout.write(JSON.stringify(response) + '\n');
-    } catch (error) {
-        process.stderr.write(`[MindMeld] ${error.message}\n`);
-
-        if (!isNotification && message.id !== undefined) {
-            process.stdout.write(JSON.stringify({
-                jsonrpc: '2.0',
-                error: { code: -32603, message: error.message },
-                id: message.id
-            }) + '\n');
-        }
-    }
-}
-
-/**
- * Start the stdio bridge — long-lived, runs until stdin closes
- */
-function startBridge(token) {
-    process.stderr.write(`[MindMeld] MCP bridge started (pid ${process.pid})\n`);
-    process.stderr.write(`[MindMeld] Proxying to https://${MCP_HOST}${MCP_PATH}\n`);
-
-    let buffer = '';
-    let pending = 0;
-    let stdinClosed = false;
-
-    function maybeExit() {
-        if (stdinClosed && pending === 0) {
-            process.stderr.write('[MindMeld] All requests complete, shutting down\n');
-            process.exit(0);
-        }
-    }
-
-    function trackMessage(line) {
-        pending++;
-        processMessage(line, token).finally(() => {
-            pending--;
-            maybeExit();
-        });
-    }
-
-    process.stdin.setEncoding('utf-8');
-
-    process.stdin.on('data', (chunk) => {
-        buffer += chunk;
-        const lines = buffer.split('\n');
-        buffer = lines.pop();
-
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed) continue;
-            trackMessage(trimmed);
-        }
-    });
-
-    process.stdin.on('end', () => {
-        process.stderr.write('[MindMeld] stdin closed\n');
-        stdinClosed = true;
-        maybeExit();
-    });
-
-    process.stdin.on('error', (err) => {
-        process.stderr.write(`[MindMeld] stdin error: ${err.message}\n`);
-        process.exit(1);
-    });
-}
-
-function showMcpHelp() {
-    console.log(`
-MindMeld MCP Bridge - Stdio-to-HTTP proxy for MCP clients
-
-Usage:
-  mindmeld mcp [options]
-
-Options:
-  --token <token>  MindMeld API token (or set MINDMELD_TOKEN env var)
-  --help, -h       Show this help
-
-Token Resolution (in priority order):
-  1. MINDMELD_TOKEN environment variable
-  2. --token CLI argument
-  3. ~/.mindmeld/api-token file
-
-Create a token at: https://app.mindmeld.dev/api-tokens
-
-Client Configuration:
-  Cline / Cursor / Windsurf:
-    {
-      "mcpServers": {
-        "mindmeld": {
-          "command": "mindmeld",
-          "args": ["mcp"],
-          "env": { "MINDMELD_TOKEN": "mm_live_xxx" }
-        }
-      }
-    }
-
-  Claude Code (use URL transport instead — no bridge needed):
-    {
-      "mcpServers": {
-        "mindmeld": {
-          "type": "url",
-          "url": "https://api.mindmeld.dev/api/mcp/mindmeld",
-          "headers": { "X-MindMeld-Token": "mm_live_xxx" }
-        }
-      }
-    }
-`);
-}
-
-module.exports = { startBridge, resolveToken, showMcpHelp };