@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/core/StandardsIngestion.js

@@ -1,991 +0,0 @@
-/**
- * StandardsIngestion.js - Phase 1 of Rapport Standards Integration
- *
- * Parses and ingests .equilateral-standards/ YAML files into Rapport database
- * Creates standards_patterns from rules, anti-patterns, examples, and cost impacts
- *
- * YAML Schema (equilateral-standards-yaml):
- *   id, category, priority (10/20/30), updated
- *   rules: [{ action: ALWAYS|NEVER|USE|PREFER|AVOID, rule: string, applies_to: [globs] }]
- *   anti_patterns: [strings]
- *   examples: { name: code }
- *   cost_impact: { pattern: impact }
- *   tags: [strings]
- *
- * Reference: /Users/jamesford/Source/rapport/docs/RAPPORT_STANDARDS_INTEGRATION_DESIGN.md
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const yaml = require('js-yaml');
-const { executeQuery } = require('../handlers/helpers/dbOperations');
-
-class StandardsIngestion {
-  constructor(options = {}) {
-    this.standardsPath = options.standardsPath || path.join(process.cwd(), '.equilateral-standards');
-    this.verbose = options.verbose || false;
-  }
-
-  /**
-   * Main ingestion entry point
-   * Discovers and parses all .equilateral-standards/ YAML files (with markdown fallback)
-   */
-  async ingestEquilateralStandards() {
-    console.log(`[StandardsIngestion] Starting ingestion from ${this.standardsPath}`);
-
-    const startTime = Date.now();
-    const patterns = [];
-
-    // Define standard categories
-    const categories = [
-      'serverless-saas-aws',
-      'multi-agent-orchestration',
-      'compliance-security',
-      'database',
-      'frontend-development',
-      'cost-optimization',
-      'backend',
-      'deployment',
-      'real-time-systems',
-      'testing',
-      'well-architected'
-    ];
-
-    // Discover and parse all standards files
-    for (const category of categories) {
-      const categoryPath = path.join(this.standardsPath, category);
-
-      try {
-        const files = await this.discoverStandardFiles(categoryPath);
-
-        for (const file of files) {
-          try {
-            const standard = await this.parseStandard(file, category);
-
-            if (standard && standard.patterns.length > 0) {
-              patterns.push(...standard.patterns);
-
-              if (this.verbose) {
-                console.log(`  ✓ Parsed ${path.basename(file)}: ${standard.patterns.length} patterns`);
-              }
-            }
-          } catch (parseError) {
-            console.warn(`  ⚠ Failed to parse ${path.basename(file)}:`, parseError.message);
-          }
-        }
-      } catch (categoryError) {
-        if (categoryError.code !== 'ENOENT') {
-          console.warn(`  ⚠ Failed to process category ${category}:`, categoryError.message);
-        }
-      }
-    }
-
-    // Store in database
-    const ingestedCount = await this.seedPatternDatabase(patterns);
-
-    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
-
-    return {
-      patternsIngested: ingestedCount,
-      totalPatternsFound: patterns.length,
-      categories: categories.length,
-      timestamp: new Date().toISOString(),
-      duration: `${duration}s`
-    };
-  }
-
-  /**
-   * Parse all standards from YAML files without storing in database.
-   * Used as a fallback when the database is unavailable (e.g., local dev).
-   * @returns {Promise<Array>} Parsed patterns array
-   */
-  async parseAllStandards() {
-    const patterns = [];
-
-    const categories = [
-      'serverless-saas-aws',
-      'multi-agent-orchestration',
-      'compliance-security',
-      'database',
-      'frontend-development',
-      'cost-optimization',
-      'backend',
-      'deployment',
-      'real-time-systems',
-      'testing',
-      'well-architected'
-    ];
-
-    for (const category of categories) {
-      const categoryPath = path.join(this.standardsPath, category);
-
-      try {
-        const files = await this.discoverStandardFiles(categoryPath);
-
-        for (const file of files) {
-          try {
-            const standard = await this.parseStandard(file, category);
-            if (standard && standard.patterns.length > 0) {
-              patterns.push(...standard.patterns);
-            }
-          } catch (parseError) {
-            // Skip unparseable files
-          }
-        }
-      } catch (categoryError) {
-        if (categoryError.code !== 'ENOENT') {
-          // Skip missing categories silently
-        }
-      }
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Discover all standard files in a category directory
-   * Prefers YAML files over markdown - if both exist for the same base name, only YAML is returned
-   */
-  async discoverStandardFiles(categoryPath) {
-    try {
-      const entries = await fs.readdir(categoryPath, { withFileTypes: true });
-      const fileMap = new Map(); // baseName -> { yaml: path, md: path }
-
-      for (const entry of entries) {
-        const fullPath = path.join(categoryPath, entry.name);
-
-        if (entry.isDirectory()) {
-          // Recursively search subdirectories
-          const subFiles = await this.discoverStandardFiles(fullPath);
-          // Add subdirectory files directly (they've already been deduplicated)
-          for (const subFile of subFiles) {
-            const subBaseName = path.basename(subFile).replace(/\.(yaml|yml|md)$/, '');
-            const subKey = `${path.dirname(subFile)}/${subBaseName}`;
-            if (!fileMap.has(subKey)) {
-              fileMap.set(subKey, {});
-            }
-            if (subFile.endsWith('.yaml') || subFile.endsWith('.yml')) {
-              fileMap.get(subKey).yaml = subFile;
-            } else if (subFile.endsWith('.md')) {
-              fileMap.get(subKey).md = subFile;
-            }
-          }
-        } else if (entry.isFile()) {
-          const isYaml = entry.name.endsWith('.yaml') || entry.name.endsWith('.yml');
-          const isMd = entry.name.endsWith('.md');
-
-          if (isYaml || isMd) {
-            const baseName = entry.name.replace(/\.(yaml|yml|md)$/, '');
-            const key = `${categoryPath}/${baseName}`;
-
-            if (!fileMap.has(key)) {
-              fileMap.set(key, {});
-            }
-
-            if (isYaml) {
-              fileMap.get(key).yaml = fullPath;
-            } else {
-              fileMap.get(key).md = fullPath;
-            }
-          }
-        }
-      }
-
-      // Build final list, preferring YAML over markdown
-      const files = [];
-      for (const paths of fileMap.values()) {
-        if (paths.yaml) {
-          files.push(paths.yaml);
-        } else if (paths.md) {
-          files.push(paths.md);
-        }
-      }
-
-      return files;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        // Category doesn't exist - not an error
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Parse a standards file into Rapport pattern format
-   * Detects file type and routes to appropriate parser
-   */
-  async parseStandard(filepath, category) {
-    const isYaml = filepath.endsWith('.yaml') || filepath.endsWith('.yml');
-
-    if (isYaml) {
-      return this.parseYamlStandard(filepath, category);
-    }
-
-    return this.parseMarkdownStandard(filepath, category);
-  }
-
-  /**
-   * Parse a YAML standards file into Rapport pattern format
-   * Supports both type: standard (v2.0) and type: workflow (v3.0)
-   *
-   * YAML format (standard):
-   *   id, category, priority, rules[], anti_patterns[]
-   *
-   * YAML format (workflow):
-   *   id, category, priority, type: workflow, trigger, steps[], preconditions[], anti_patterns[]
-   */
-  async parseYamlStandard(filepath, category) {
-    const content = await fs.readFile(filepath, 'utf-8');
-    const ext = filepath.endsWith('.yml') ? '.yml' : '.yaml';
-    const filename = path.basename(filepath, ext);
-
-    let doc;
-    try {
-      doc = yaml.load(content);
-    } catch (parseError) {
-      throw new Error(`YAML parse error: ${parseError.message}`);
-    }
-
-    if (!doc || typeof doc !== 'object') {
-      throw new Error('Invalid YAML structure: expected an object');
-    }
-
-    // Route to workflow parser if type: workflow
-    if (doc.type === 'workflow') {
-      return this.parseYamlWorkflow(doc, filepath, filename, category);
-    }
-
-    const patterns = [];
-    const standardId = doc.id || filename;
-    const standardCategory = doc.category || category;
-    const standardPriority = doc.priority || 30;
-
-    // Extract anti-patterns as simple strings
-    const antiPatterns = Array.isArray(doc.anti_patterns)
-      ? doc.anti_patterns.map(ap => ({
-          description: typeof ap === 'string' ? ap : ap.description || 'Anti-pattern to avoid',
-          code: typeof ap === 'object' ? ap.code : null,
-          language: typeof ap === 'object' ? ap.language : null
-        }))
-      : [];
-
-    // Extract examples - handles both array of strings and named object formats
-    const examples = [];
-    if (doc.examples) {
-      if (Array.isArray(doc.examples)) {
-        // Array format: ["code example 1", "code example 2"]
-        for (const example of doc.examples) {
-          if (typeof example === 'string') {
-            examples.push({
-              description: 'Example',
-              code: example.trim(),
-              language: this.inferLanguageFromCode(example)
-            });
-          } else if (typeof example === 'object' && example !== null) {
-            // Object in array: { description: "...", code: "..." }
-            examples.push({
-              description: example.description || 'Example',
-              code: (example.code || '').trim(),
-              language: example.language || this.inferLanguageFromCode(example.code || '')
-            });
-          }
-        }
-      } else if (typeof doc.examples === 'object') {
-        // Named object format: { example_name: "code here" }
-        for (const [name, code] of Object.entries(doc.examples)) {
-          examples.push({
-            description: name.replace(/_/g, ' '),
-            code: typeof code === 'string' ? code.trim() : String(code),
-            language: this.inferLanguageFromCode(code)
-          });
-        }
-      }
-    }
-
-    // Extract cost_impact - now a structured object in YAML format
-    const costImpact = doc.cost_impact && typeof doc.cost_impact === 'object'
-      ? doc.cost_impact
-      : (typeof doc.cost_impact === 'string' ? { description: doc.cost_impact } : null);
-
-    // Extract tags for metadata
-    const tags = Array.isArray(doc.tags) ? doc.tags : [];
-
-    // Process each rule
-    const rules = Array.isArray(doc.rules) ? doc.rules : [];
-
-    for (let ruleIndex = 0; ruleIndex < rules.length; ruleIndex++) {
-      const rule = rules[ruleIndex];
-      if (!rule || typeof rule !== 'object') continue;
-
-      const action = rule.action || 'USE';
-      const ruleText = rule.rule || '';
-      const appliesTo = Array.isArray(rule.applies_to) ? rule.applies_to : [];
-
-      // Construct element name from action and first few words
-      const element = this.extractElement(`${action} ${ruleText}`);
-
-      // Construct full rule statement
-      const fullRule = `${action}: ${ruleText}`;
-
-      const patternId = this.generatePatternId(standardCategory, standardId, element, ruleIndex);
-
-      // Map action to maturity
-      const actionMaturityMap = {
-        'ALWAYS': 'enforced',
-        'NEVER': 'enforced',
-        'USE': 'validated',
-        'PREFER': 'validated',
-        'AVOID': 'validated'
-      };
-      const maturity = actionMaturityMap[action] || 'validated';
-
-      patterns.push({
-        pattern_id: patternId,
-        file_name: filename,
-        element: element,
-        rule: fullRule,
-        priority: standardPriority,
-        correlation: 1.0,
-        source: 'equilateral-standards',
-        maturity: maturity,
-        scope: 'organization',
-        category: standardCategory,
-        applicable_files: appliesTo.length > 0 ? appliesTo : this.extractApplicableFiles('', standardCategory),
-        anti_patterns: antiPatterns,
-        examples: examples,
-        cost_impact: costImpact,
-        tags: tags,
-        source_file: filepath,
-        title: standardId
-      });
-    }
-
-    // If no rules found but document exists, create a single pattern from the document
-    if (patterns.length === 0 && doc.id) {
-      const patternId = this.generatePatternId(standardCategory, standardId, 'standard_pattern');
-
-      patterns.push({
-        pattern_id: patternId,
-        file_name: filename,
-        element: 'Standard Pattern',
-        rule: `Standard: ${standardId}`,
-        priority: standardPriority,
-        correlation: 1.0,
-        source: 'equilateral-standards',
-        maturity: 'validated',
-        scope: 'organization',
-        category: standardCategory,
-        applicable_files: this.extractApplicableFiles('', standardCategory),
-        anti_patterns: antiPatterns,
-        examples: examples,
-        cost_impact: costImpact,
-        tags: tags,
-        source_file: filepath,
-        title: standardId
-      });
-    }
-
-    return { patterns };
-  }
-
-  /**
-   * Parse a workflow YAML file into a single Rapport pattern with workflow metadata
-   * Workflows are stored as one pattern (not exploded into per-rule patterns)
-   * so the injection system can render them as ordered procedures.
-   */
-  parseYamlWorkflow(doc, filepath, filename, category) {
-    const standardId = doc.id || filename;
-    const standardCategory = doc.category || category;
-    const standardPriority = doc.priority || 10; // Workflows default to high priority
-
-    const antiPatterns = Array.isArray(doc.anti_patterns)
-      ? doc.anti_patterns.map(ap => ({
-          description: typeof ap === 'string' ? ap : ap.description || 'Anti-pattern to avoid',
-          code: typeof ap === 'object' ? ap.code : null,
-          language: typeof ap === 'object' ? ap.language : null
-        }))
-      : [];
-
-    const tags = Array.isArray(doc.tags) ? doc.tags : [];
-    const costImpact = doc.cost_impact && typeof doc.cost_impact === 'object'
-      ? doc.cost_impact
-      : (typeof doc.cost_impact === 'string' ? { description: doc.cost_impact } : null);
-
-    const steps = Array.isArray(doc.steps) ? doc.steps : [];
-    const preconditions = Array.isArray(doc.preconditions) ? doc.preconditions : [];
-    const trigger = doc.trigger || '';
-    const related = Array.isArray(doc.related) ? doc.related : [];
-
-    const patternId = this.generatePatternId(standardCategory, standardId, 'workflow');
-
-    // Build a readable element name from the id
-    const element = standardId.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
-
-    // The rule field contains the trigger for search/matching
-    const rule = `WORKFLOW: ${trigger}`;
-
-    // Store workflow structure in examples field (JSON-serializable)
-    // This preserves the full workflow for the injection formatter
-    const workflowData = {
-      type: 'workflow',
-      trigger: trigger,
-      preconditions: preconditions,
-      steps: steps.map((step, i) => ({
-        index: i + 1,
-        name: step.name || `Step ${i + 1}`,
-        description: step.description || '',
-        command: step.command || null,
-        validation: step.validation || null,
-        standards: Array.isArray(step.standards) ? step.standards : [],
-        gate: step.gate === true
-      })),
-      related: related
-    };
-
-    return {
-      patterns: [{
-        pattern_id: patternId,
-        file_name: filename,
-        element: element,
-        rule: rule,
-        priority: standardPriority,
-        correlation: 1.0,
-        source: 'equilateral-standards',
-        maturity: 'enforced',
-        scope: 'organization',
-        category: standardCategory,
-        applicable_files: this.extractApplicableFiles('', standardCategory),
-        anti_patterns: antiPatterns,
-        examples: [workflowData], // Workflow data stored as first example
-        cost_impact: costImpact,
-        tags: [...tags, 'workflow'],
-        source_file: filepath,
-        title: standardId,
-        type: 'workflow' // Flag for injection formatter
-      }]
-    };
-  }
-
-  /**
-   * Parse a markdown standards file into Rapport pattern format
-   */
-  async parseMarkdownStandard(filepath, category) {
-    const content = await fs.readFile(filepath, 'utf-8');
-    const filename = path.basename(filepath, '.md');
-
-    // Extract standard metadata from markdown
-    const title = this.extractTitle(content);
-    const enforcementRules = this.extractEnforcementRules(content);
-    const antiPatterns = this.extractAntiPatterns(content);
-    const examples = this.extractExamples(content);
-    const costImpact = this.extractCostImpact(content);
-    const applicableFiles = this.extractApplicableFiles(content, category);
-
-    const patterns = [];
-
-    // Create pattern for each enforcement rule
-    for (const rule of enforcementRules) {
-      const patternId = this.generatePatternId(category, filename, rule.element);
-
-      // Map severity to priority (10=high, 20=medium, 30=low per DB constraint)
-      const priorityMap = {
-        'CRITICAL': 10,
-        'MANDATORY': 10,
-        'ENFORCED': 20,
-        'VALIDATED': 30
-      };
-      const priority = priorityMap[rule.severity] || 30;
-
-      patterns.push({
-        pattern_id: patternId,
-        file_name: filename, // Source markdown file name (without .md)
-        element: rule.element,
-        rule: rule.rule,
-        priority: priority,
-        correlation: 1.0, // Standards are mandatory
-        source: 'equilateral-standards',
-        maturity: rule.severity === 'MANDATORY' || rule.severity === 'CRITICAL' ? 'enforced' : 'validated',
-        scope: 'organization',
-        category: category,
-        applicable_files: applicableFiles,
-        anti_patterns: antiPatterns,
-        examples: examples,
-        cost_impact: costImpact,
-        source_file: filepath,
-        title: title
-      });
-    }
-
-    return { patterns };
-  }
-
-  /**
-   * Extract title from markdown (first H1)
-   */
-  extractTitle(content) {
-    const match = content.match(/^#\s+(.+)$/m);
-    return match ? match[1].trim() : 'Untitled Standard';
-  }
-
-  /**
-   * Extract enforcement rules from markdown
-   * Looks for sections like "MANDATORY PATTERNS", "Core Principles", etc.
-   */
-  extractEnforcementRules(content) {
-    const rules = [];
-
-    // Pattern 1: MANDATORY/CRITICAL sections
-    const mandatorySection = content.match(/##?\s*⚠?️?\s*(MANDATORY|CRITICAL)[^#]*/gi);
-    if (mandatorySection) {
-      for (const section of mandatorySection) {
-        const sectionRules = this.extractRulesFromSection(section, 'MANDATORY');
-        rules.push(...sectionRules);
-      }
-    }
-
-    // Pattern 2: "ALWAYS" and "NEVER" statements
-    const alwaysNever = content.match(/(?:ALWAYS|NEVER)\s+([^.\n]+)/g);
-    if (alwaysNever) {
-      for (const statement of alwaysNever) {
-        rules.push({
-          element: this.extractElement(statement),
-          rule: statement.trim(),
-          severity: 'MANDATORY'
-        });
-      }
-    }
-
-    // Pattern 3: Core Principles
-    const principleMatch = content.match(/##?\s*Core Principle[s]?[:\s]+([^#]+)/i);
-    if (principleMatch) {
-      rules.push({
-        element: 'Core Principle',
-        rule: principleMatch[1].trim(),
-        severity: 'ENFORCED'
-      });
-    }
-
-    return rules.length > 0 ? rules : [{
-      element: 'Standard Pattern',
-      rule: this.extractFirstParagraph(content),
-      severity: 'VALIDATED'
-    }];
-  }
-
-  /**
-   * Extract rules from a section of content
-   */
-  extractRulesFromSection(section, severity) {
-    const rules = [];
-
-    // Look for numbered or bulleted lists
-    const listItems = section.match(/^[\s]*[-*\d]+\.?\s+(.+)$/gm);
-    if (listItems) {
-      for (const item of listItems) {
-        const cleaned = item.replace(/^[\s]*[-*\d]+\.?\s+/, '').trim();
-        if (cleaned.length > 10) { // Filter out very short items
-          rules.push({
-            element: this.extractElement(cleaned),
-            rule: cleaned,
-            severity: severity
-          });
-        }
-      }
-    }
-
-    // Look for bold statements
-    const boldStatements = section.match(/\*\*(.+?)\*\*/g);
-    if (boldStatements && rules.length === 0) {
-      for (const statement of boldStatements) {
-        const cleaned = statement.replace(/\*\*/g, '').trim();
-        if (cleaned.length > 10 && !cleaned.match(/^(MANDATORY|CRITICAL|NOTE|IMPORTANT)/i)) {
-          rules.push({
-            element: this.extractElement(cleaned),
-            rule: cleaned,
-            severity: severity
-          });
-        }
-      }
-    }
-
-    return rules;
-  }
-
-  /**
-   * Extract anti-patterns from markdown
-   * Looks for ❌ WRONG, NEVER DO THIS, Anti-Pattern sections
-   */
-  extractAntiPatterns(content) {
-    const antiPatterns = [];
-
-    // Pattern 1: ❌ markers
-    const wrongPatterns = content.match(/❌[^```]*?```[^`]+```/gs);
-    if (wrongPatterns) {
-      for (const pattern of wrongPatterns) {
-        const description = pattern.match(/❌\s*([^\n`]+)/);
-        const code = pattern.match(/```(\w+)?\n([\s\S]+?)```/);
-
-        if (description && code) {
-          antiPatterns.push({
-            description: description[1].trim(),
-            code: code[2].trim(),
-            language: code[1] || 'javascript'
-          });
-        }
-      }
-    }
-
-    // Pattern 2: Anti-Pattern sections
-    const antiPatternSection = content.match(/##?\s*Anti-Pattern[s]?[^#]*/gi);
-    if (antiPatternSection) {
-      for (const section of antiPatternSection) {
-        const sectionPatterns = this.extractCodeBlocksFromSection(section);
-        antiPatterns.push(...sectionPatterns.map(p => ({
-          description: p.description || 'Anti-pattern to avoid',
-          code: p.code,
-          language: p.language
-        })));
-      }
-    }
-
-    return antiPatterns;
-  }
-
-  /**
-   * Extract examples from markdown
-   * Looks for ✅ CORRECT, Example sections
-   */
-  extractExamples(content) {
-    const examples = [];
-
-    // Pattern 1: ✅ markers
-    const correctPatterns = content.match(/✅[^```]*?```[^`]+```/gs);
-    if (correctPatterns) {
-      for (const pattern of correctPatterns) {
-        const description = pattern.match(/✅\s*([^\n`]+)/);
-        const code = pattern.match(/```(\w+)?\n([\s\S]+?)```/);
-
-        if (description && code) {
-          examples.push({
-            description: description[1].trim(),
-            code: code[2].trim(),
-            language: code[1] || 'javascript'
-          });
-        }
-      }
-    }
-
-    // Pattern 2: Example sections
-    const exampleSection = content.match(/##?\s*Example[s]?[^#]*/gi);
-    if (exampleSection) {
-      for (const section of exampleSection) {
-        const sectionExamples = this.extractCodeBlocksFromSection(section);
-        examples.push(...sectionExamples.map(p => ({
-          description: p.description || 'Example implementation',
-          code: p.code,
-          language: p.language
-        })));
-      }
-    }
-
-    return examples;
-  }
-
-  /**
-   * Extract cost impact information
-   */
-  extractCostImpact(content) {
-    const costImpact = {};
-
-    // Look for cost comparison tables
-    const costTable = content.match(/\|[^|]*Cost[^|]*\|[\s\S]*?\n\n/i);
-    if (costTable) {
-      costImpact.hasTable = true;
-      costImpact.details = costTable[0].trim();
-    }
-
-    // Look for specific cost mentions
-    const costMentions = content.match(/\$\d+[^.\n]*/g);
-    if (costMentions) {
-      costImpact.mentions = costMentions.map(m => m.trim());
-    }
-
-    // Look for "Cost Impact" sections
-    const costSection = content.match(/##?\s*Cost Impact[^#]*/i);
-    if (costSection) {
-      costImpact.section = costSection[0].trim();
-    }
-
-    return Object.keys(costImpact).length > 0 ? costImpact : null;
-  }
-
-  /**
-   * Determine applicable file patterns based on category and content
-   */
-  extractApplicableFiles(content, category) {
-    const patterns = [];
-
-    // Category-based patterns
-    const categoryPatterns = {
-      'serverless-saas-aws': ['**/*.js', '**/template.yaml', '**/handlers/**/*.js'],
-      'frontend-development': ['**/*.tsx', '**/*.jsx', '**/*.ts', 'src/frontend/**/*'],
-      'database': ['**/*.sql', '**/dbOperations.js', '**/migrations/**/*'],
-      'backend': ['src/backend/**/*.js', 'src/handlers/**/*.js'],
-      'multi-agent-orchestration': ['src/agents/**/*.js', 'src/core/**/*.js']
-    };
-
-    if (categoryPatterns[category]) {
-      patterns.push(...categoryPatterns[category]);
-    }
-
-    // Content-based patterns
-    if (content.includes('Lambda') || content.includes('handler')) {
-      patterns.push('src/handlers/**/*.js');
-    }
-    if (content.includes('React') || content.includes('component')) {
-      patterns.push('src/frontend/**/*.tsx', 'src/frontend/**/*.jsx');
-    }
-    if (content.includes('PostgreSQL') || content.includes('database')) {
-      patterns.push('**/*dbOperations.js', '**/*.sql');
-    }
-
-    return [...new Set(patterns)]; // Remove duplicates
-  }
-
-  /**
-   * Extract code blocks from a section
-   */
-  extractCodeBlocksFromSection(section) {
-    const blocks = [];
-    const codeBlocks = section.match(/```(\w+)?\n([\s\S]+?)```/g);
-
-    if (codeBlocks) {
-      for (const block of codeBlocks) {
-        const match = block.match(/```(\w+)?\n([\s\S]+?)```/);
-        if (match) {
-          // Look for description before code block
-          const beforeBlock = section.substring(0, section.indexOf(block));
-          const descMatch = beforeBlock.match(/([^\n]+)\n*$/);
-
-          blocks.push({
-            description: descMatch ? descMatch[1].trim() : null,
-            code: match[2].trim(),
-            language: match[1] || 'javascript'
-          });
-        }
-      }
-    }
-
-    return blocks;
-  }
-
-  /**
-   * Infer programming language from code content
-   */
-  inferLanguageFromCode(code) {
-    if (typeof code !== 'string') return 'text';
-
-    // YAML/SAM template patterns
-    if (code.includes('{{resolve:ssm:') || code.match(/^\s*(Environment|Resources|Properties):/m)) {
-      return 'yaml';
-    }
-    // JavaScript patterns
-    if (code.includes('async ') || code.includes('await ') || code.includes('const ') ||
-        code.includes('function ') || code.includes('=>') || code.includes('require(')) {
-      return 'javascript';
-    }
-    // SQL patterns
-    if (code.match(/\b(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER)\b/i)) {
-      return 'sql';
-    }
-    // Python patterns
-    if (code.includes('def ') || code.includes('import ') || code.match(/^\s*class\s+\w+:/m)) {
-      return 'python';
-    }
-
-    return 'text';
-  }
-
-  /**
-   * Extract element name from a rule statement
-   * Goal: Create a descriptive, unique element name from the rule
-   */
-  extractElement(statement) {
-    // Remove action prefix (ALWAYS, NEVER, USE, etc.)
-    let cleaned = statement.replace(/^(ALWAYS|NEVER|USE|PREFER|AVOID|DO NOT|DON'T)[:\s]+/i, '').trim();
-
-    // Extract key technical terms for better element names
-    // Pattern: "verb + object" -> extract the object/concept being acted upon
-    // Allow method calls like "client.end()" by not stopping at dots within identifiers
-    const verbObjectMatch = cleaned.match(/^(?:Use|Implement|Apply|Follow|Add|Create|Set|Cache|Validate|Configure|Enable|Disable|Fetch|Call)\s+(.+?)(?:\s+-\s+|,|$)/i);
-    if (verbObjectMatch) {
-      let object = verbObjectMatch[1].trim();
-      // Clean up trailing punctuation but keep method calls
-      object = object.replace(/\s*[-–].*$/, ''); // Remove explanatory text after dash
-      return object.substring(0, 50);
-    }
-
-    // For statements starting with a noun phrase, extract more context
-    const nounPhraseMatch = cleaned.match(/^([A-Za-z][a-z]+(?:[\s.][a-z()]+){0,5})/i);
-    if (nounPhraseMatch) {
-      let phrase = nounPhraseMatch[1].trim();
-      phrase = phrase.replace(/\s*[-–].*$/, ''); // Remove explanatory text
-      return phrase.substring(0, 50);
-    }
-
-    // Fallback: first meaningful words
-    const words = cleaned.split(/\s+/).slice(0, 4);
-    return words.join(' ').substring(0, 50);
-  }
-
-  /**
-   * Extract first paragraph from content
-   */
-  extractFirstParagraph(content) {
-    const paragraphs = content.split(/\n\n+/);
-    for (const para of paragraphs) {
-      const cleaned = para.replace(/^#+\s+/, '').trim();
-      if (cleaned.length > 20 && !cleaned.startsWith('**')) {
-        return cleaned;
-      }
-    }
-    return 'Standard pattern';
-  }
-
-  /**
-   * Generate unique pattern ID
-   * @param {string} category - Category name
-   * @param {string} filename - Source filename
-   * @param {string} element - Element description
-   * @param {number} index - Rule index for uniqueness
-   */
-  generatePatternId(category, filename, element, index = 0) {
-    const categorySlug = category.replace(/[^a-z0-9]/gi, '_');
-    const fileSlug = filename.replace(/[^a-z0-9]/gi, '_');
-    const elementSlug = element.replace(/[^a-z0-9]/gi, '_').toLowerCase().substring(0, 40);
-
-    // Include index for uniqueness when elements might collide
-    const suffix = index > 0 ? `_${index}` : '';
-
-    return `${categorySlug}_${fileSlug}_${elementSlug}${suffix}`.toLowerCase();
-  }
-
-  /**
-   * Store patterns in database
-   */
-  async seedPatternDatabase(patterns) {
-    if (patterns.length === 0) {
-      console.log('[StandardsIngestion] No patterns to ingest');
-      return 0;
-    }
-
-    console.log(`[StandardsIngestion] Storing ${patterns.length} patterns in database...`);
-
-    let successCount = 0;
-
-    for (const pattern of patterns) {
-      try {
-        await executeQuery(`
-          INSERT INTO rapport.standards_patterns (
-            pattern_id,
-            file_name,
-            element,
-            rule,
-            priority,
-            correlation,
-            source,
-            maturity,
-            scope,
-            category,
-            applicable_files,
-            anti_patterns,
-            examples,
-            cost_impact,
-            keywords,
-            created_at,
-            last_updated
-          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, NOW(), NOW())
-          ON CONFLICT (pattern_id)
-          DO UPDATE SET
-            file_name = EXCLUDED.file_name,
-            element = EXCLUDED.element,
-            rule = EXCLUDED.rule,
-            priority = EXCLUDED.priority,
-            correlation = EXCLUDED.correlation,
-            maturity = EXCLUDED.maturity,
-            scope = EXCLUDED.scope,
-            category = EXCLUDED.category,
-            applicable_files = EXCLUDED.applicable_files,
-            anti_patterns = EXCLUDED.anti_patterns,
-            examples = EXCLUDED.examples,
-            cost_impact = EXCLUDED.cost_impact,
-            keywords = EXCLUDED.keywords,
-            last_updated = NOW(),
-            last_seen_at = NOW(),
-            occurrence_count = COALESCE(rapport.standards_patterns.occurrence_count, 0) + 1
-        `, [
-          pattern.pattern_id,
-          pattern.file_name,
-          pattern.element,
-          pattern.rule,
-          pattern.priority,
-          pattern.correlation,
-          pattern.source,
-          pattern.maturity,
-          pattern.scope,
-          pattern.category,
-          pattern.applicable_files,
-          JSON.stringify(pattern.anti_patterns),
-          JSON.stringify(pattern.examples),
-          pattern.cost_impact ? JSON.stringify(pattern.cost_impact) : null,
-          pattern.tags || []
-        ]);
-
-        successCount++;
-
-        if (this.verbose && successCount % 10 === 0) {
-          console.log(`  Stored ${successCount}/${patterns.length} patterns...`);
-        }
-      } catch (error) {
-        console.error(`  ✗ Failed to store pattern ${pattern.pattern_id}:`, error.message);
-      }
-    }
-
-    console.log(`[StandardsIngestion] ✓ Successfully stored ${successCount} patterns`);
-    return successCount;
-  }
-
-  /**
-   * Check if standards need re-ingestion (for performance)
-   */
-  async needsIngestion() {
-    try {
-      const result = await executeQuery(`
-        SELECT COUNT(*) as count, MAX(last_updated) as last_updated
-        FROM rapport.standards_patterns
-        WHERE source = 'equilateral-standards'
-      `);
-
-      const row = result.rows[0];
-
-      // Re-ingest if no patterns exist or haven't been updated in 7 days
-      if (row.count === '0') {
-        return { needed: true, reason: 'No standards ingested yet' };
-      }
-
-      const lastUpdated = new Date(row.last_updated);
-      const daysSince = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
-
-      if (daysSince > 7) {
-        return { needed: true, reason: `Last updated ${daysSince.toFixed(0)} days ago` };
-      }
-
-      return { needed: false, count: row.count };
-    } catch (error) {
-      return { needed: true, reason: 'Database check failed' };
-    }
-  }
-}
-
-module.exports = { StandardsIngestion };