@girardmedia/bootspring 1.2.0 → 2.0.3

package/intelligence/cross-project.js

@@ -0,0 +1,1647 @@
+/**
+ * Bootspring Cross-Project Learning
+ *
+ * Enables sharing of anonymized learnings across projects (opt-in).
+ * Aggregates patterns and insights to improve recommendations for all users.
+ *
+ * Features:
+ * - extractAnonymizedLearnings() - Extract learnings without sensitive data
+ * - shareLearnings(learnings) - Upload to shared pool
+ * - fetchCommunityPatterns() - Download community patterns
+ * - applyRelevantPatterns(projectContext) - Apply relevant patterns
+ *
+ * @package bootspring
+ * @module intelligence/cross-project
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Cross-project learning configuration
+ * Can be overridden via bootspring.config.js
+ */
+const CROSS_PROJECT_CONFIG = {
+  enabled: false, // Must be explicitly enabled
+  anonymize: true, // Always anonymize by default
+  sharePatterns: true, // Share learned patterns
+  shareDecisions: true, // Share decision outcomes
+  shareWorkflows: true, // Share workflow completions
+  consentRequired: true, // Require explicit consent
+  // API configuration for central sharing service
+  apiEndpoint: process.env.BOOTSPRING_SHARING_API || 'https://api.bootspring.dev/v1/learnings',
+  apiKey: process.env.BOOTSPRING_SHARING_KEY || null,
+  // Local caching
+  cacheExpiry: 24 * 60 * 60 * 1000, // 24 hours in ms
+  maxCachedPatterns: 500,
+  // Privacy settings
+  stripFilePaths: true,
+  stripUsernames: true,
+  stripProjectNames: true,
+  minPatternOccurrences: 3 // Only share patterns seen at least this many times
+};
+
+/**
+ * Load configuration from bootspring.config.js if available
+ */
+function loadConfig() {
+  const projectRoot = process.cwd();
+  const configPath = path.join(projectRoot, 'bootspring.config.js');
+
+  if (fs.existsSync(configPath)) {
+    try {
+      // Clear require cache to get fresh config
+      delete require.cache[require.resolve(configPath)];
+      const userConfig = require(configPath);
+
+      if (userConfig.crossProject) {
+        return {
+          ...CROSS_PROJECT_CONFIG,
+          ...userConfig.crossProject
+        };
+      }
+    } catch {
+      // Fall through to default config
+    }
+  }
+
+  return CROSS_PROJECT_CONFIG;
+}
+
+/**
+ * Get current configuration
+ */
+function getConfig() {
+  return loadConfig();
+}
+
+/**
+ * Fields to always remove during anonymization
+ */
+const SENSITIVE_FIELDS = [
+  'email', 'password', 'secret', 'key', 'token', 'api_key', 'apiKey',
+  'auth', 'credential', 'private', 'phone', 'address', 'name',
+  'username', 'user', 'account', 'ssn', 'credit', 'payment',
+  'company', 'domain', 'host', 'ip', 'client', 'customer'
+];
+
+/**
+ * Patterns that identify project-specific content to strip
+ */
+const PROJECT_SPECIFIC_PATTERNS = [
+  /\/Users\/[^/]+/g, // macOS user paths
+  /\/home\/[^/]+/g, // Linux user paths
+  /C:\\Users\\[^\\]+/g, // Windows user paths
+  /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, // Email addresses
+  /https?:\/\/[^\s]+/g, // URLs
+  /[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/g, // IP addresses
+  /[a-f0-9]{32,}/gi // Long hex strings (likely tokens/hashes)
+];
+
+/**
+ * Get paths for cross-project learning
+ */
+function getPaths() {
+  const projectRoot = process.cwd();
+  return {
+    projectRoot,
+    learningsDir: path.join(projectRoot, '.bootspring', 'cross-project'),
+    consentPath: path.join(projectRoot, '.bootspring', 'cross-project', 'consent.json'),
+    contributionsPath: path.join(projectRoot, '.bootspring', 'cross-project', 'contributions.json'),
+    receivedPath: path.join(projectRoot, '.bootspring', 'cross-project', 'received.json')
+  };
+}
+
+/**
+ * Ensure cross-project directories exist
+ */
+function ensureDirectories() {
+  const paths = getPaths();
+  if (!fs.existsSync(paths.learningsDir)) {
+    fs.mkdirSync(paths.learningsDir, { recursive: true });
+  }
+}
+
+/**
+ * Generate anonymous project ID
+ * @param {string} projectRoot - Project root path
+ */
+function generateProjectId(projectRoot) {
+  const hash = crypto.createHash('sha256');
+  hash.update(projectRoot);
+  hash.update(Date.now().toString());
+  return `proj_${hash.digest('hex').substring(0, 16)}`;
+}
+
+/**
+ * Load consent status
+ */
+function loadConsent() {
+  const paths = getPaths();
+  if (fs.existsSync(paths.consentPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(paths.consentPath, 'utf8'));
+    } catch {
+      return createDefaultConsent();
+    }
+  }
+  return createDefaultConsent();
+}
+
+/**
+ * Create default consent state
+ */
+function createDefaultConsent() {
+  return {
+    given: false,
+    givenAt: null,
+    projectId: null,
+    sharePatterns: false,
+    shareDecisions: false,
+    shareWorkflows: false,
+    revokedAt: null
+  };
+}
+
+/**
+ * Save consent status
+ */
+function saveConsent(consent) {
+  const paths = getPaths();
+  ensureDirectories();
+  consent.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(paths.consentPath, JSON.stringify(consent, null, 2));
+}
+
+/**
+ * Grant consent for cross-project learning
+ * @param {object} options - Consent options
+ */
+function grantConsent(options = {}) {
+  const paths = getPaths();
+  const consent = loadConsent();
+
+  consent.given = true;
+  consent.givenAt = new Date().toISOString();
+  consent.projectId = consent.projectId || generateProjectId(paths.projectRoot);
+  consent.sharePatterns = options.sharePatterns !== false;
+  consent.shareDecisions = options.shareDecisions !== false;
+  consent.shareWorkflows = options.shareWorkflows !== false;
+  consent.revokedAt = null;
+
+  saveConsent(consent);
+
+  return {
+    success: true,
+    projectId: consent.projectId,
+    sharing: {
+      patterns: consent.sharePatterns,
+      decisions: consent.shareDecisions,
+      workflows: consent.shareWorkflows
+    },
+    message: 'Cross-project learning consent granted'
+  };
+}
+
+/**
+ * Revoke consent for cross-project learning
+ */
+function revokeConsent() {
+  const consent = loadConsent();
+
+  if (!consent.given) {
+    return { success: false, error: 'Consent was not previously granted' };
+  }
+
+  consent.given = false;
+  consent.revokedAt = new Date().toISOString();
+  consent.sharePatterns = false;
+  consent.shareDecisions = false;
+  consent.shareWorkflows = false;
+
+  saveConsent(consent);
+
+  return {
+    success: true,
+    revokedAt: consent.revokedAt,
+    message: 'Cross-project learning consent revoked. Your data will no longer be shared.'
+  };
+}
+
+/**
+ * Check if consent is active
+ */
+function hasConsent() {
+  const consent = loadConsent();
+  return consent.given && !consent.revokedAt;
+}
+
+/**
+ * Get current consent status
+ */
+function getConsentStatus() {
+  const consent = loadConsent();
+  return {
+    active: consent.given && !consent.revokedAt,
+    projectId: consent.given ? consent.projectId : null,
+    givenAt: consent.givenAt,
+    revokedAt: consent.revokedAt,
+    sharing: consent.given ? {
+      patterns: consent.sharePatterns,
+      decisions: consent.shareDecisions,
+      workflows: consent.shareWorkflows
+    } : null
+  };
+}
+
+/**
+ * Anonymize a data object by removing sensitive fields and hashing identifiers
+ * @param {object} data - Data to anonymize
+ */
+function anonymize(data) {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    return data.map(item => anonymize(item));
+  }
+
+  const result = {};
+
+  for (const [key, value] of Object.entries(data)) {
+    const keyLower = key.toLowerCase();
+
+    // Skip sensitive fields
+    if (SENSITIVE_FIELDS.some(field => keyLower.includes(field))) {
+      continue;
+    }
+
+    // Hash identifiable strings that look like paths or names
+    if (typeof value === 'string') {
+      if (value.startsWith('/') && value.includes('/Users/')) {
+        // Anonymize file paths
+        result[key] = hashPath(value);
+      } else if (value.includes('@') || keyLower.includes('id')) {
+        // Hash potential identifiers
+        result[key] = hashString(value);
+      } else {
+        result[key] = value;
+      }
+    } else if (typeof value === 'object' && value !== null) {
+      // Recursively anonymize nested objects
+      result[key] = anonymize(value);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Hash a string for anonymization
+ * @param {string} str - String to hash
+ */
+function hashString(str) {
+  const hash = crypto.createHash('sha256');
+  hash.update(str);
+  return `anon_${hash.digest('hex').substring(0, 12)}`;
+}
+
+/**
+ * Anonymize a file path
+ * @param {string} filePath - File path to anonymize
+ */
+function hashPath(filePath) {
+  // Keep the file extension and relative structure
+  const parts = filePath.split('/');
+  const filename = parts[parts.length - 1];
+  const ext = path.extname(filename);
+  const dir = parts.slice(-2, -1)[0] || 'root';
+
+  return `[PROJECT]/${dir}/${hashString(filename).substring(0, 8)}${ext}`;
+}
+
+/**
+ * Deeply anonymize a string by removing all project-specific content
+ * @param {string} str - String to anonymize
+ * @returns {string} Anonymized string
+ */
+function anonymizeString(str) {
+  if (!str || typeof str !== 'string') return str;
+
+  let result = str;
+
+  // Remove project-specific patterns
+  for (const pattern of PROJECT_SPECIFIC_PATTERNS) {
+    result = result.replace(pattern, '[REDACTED]');
+  }
+
+  return result;
+}
+
+// ============================================================================
+// MAIN CROSS-PROJECT LEARNING FUNCTIONS
+// ============================================================================
+
+/**
+ * Extract anonymized learnings from the current project
+ * Gathers patterns, decisions, and workflow data while stripping sensitive info
+ *
+ * @param {object} options - Extraction options
+ * @param {boolean} options.includePatterns - Include learned patterns (default: true)
+ * @param {boolean} options.includeDecisions - Include decision outcomes (default: true)
+ * @param {boolean} options.includeWorkflows - Include workflow completions (default: true)
+ * @param {number} options.minConfidence - Minimum confidence threshold (default: 0.5)
+ * @param {number} options.minOccurrences - Minimum pattern occurrences (default: 3)
+ * @returns {object} Anonymized learnings ready for sharing
+ */
+function extractAnonymizedLearnings(options = {}) {
+  const config = getConfig();
+  const {
+    includePatterns = config.sharePatterns,
+    includeDecisions = config.shareDecisions,
+    includeWorkflows = config.shareWorkflows,
+    minConfidence = 0.5,
+    minOccurrences = config.minPatternOccurrences || 3
+  } = options;
+
+  const learnings = {
+    version: '1.0.0',
+    extractedAt: new Date().toISOString(),
+    projectId: getAnonymousProjectId(),
+    techStack: extractAnonymizedStack(),
+    patterns: [],
+    decisions: [],
+    workflows: [],
+    aggregates: {}
+  };
+
+  // Extract patterns from decision tracker
+  if (includePatterns) {
+    try {
+      const decisionTracker = require('./memory/decision-tracker');
+      const patterns = decisionTracker.getPatterns() || [];
+
+      learnings.patterns = patterns
+        .filter(p => p.occurrences >= minOccurrences && (p.confidence || 0.5) >= minConfidence)
+        .map(p => anonymizePattern(p));
+    } catch {
+      // Decision tracker not available
+    }
+  }
+
+  // Extract decision outcomes
+  if (includeDecisions) {
+    try {
+      const decisionTracker = require('./memory/decision-tracker');
+      const decisions = decisionTracker.readAllDecisions() || [];
+
+      // Only include completed decisions with outcomes
+      const completedDecisions = decisions.filter(d => d.outcome && d.outcome.status);
+
+      // Aggregate by type for privacy
+      const aggregatedDecisions = aggregateDecisionsByType(completedDecisions);
+      learnings.decisions = aggregatedDecisions;
+
+      // Also include high-impact patterns
+      const impactPatterns = decisionTracker.getImpactBoostedPatterns
+        ? decisionTracker.getImpactBoostedPatterns({ minScore: 3.0, minSuccessRate: 0.6 })
+        : [];
+
+      learnings.aggregates.impactPatterns = impactPatterns.map(p => ({
+        type: p.type,
+        occurrences: p.occurrences,
+        averageImpactScore: p.averageImpactScore,
+        successRate: p.successRate,
+        recommendation: p.recommendation
+      }));
+    } catch {
+      // Decision tracker not available
+    }
+  }
+
+  // Extract workflow completions
+  if (includeWorkflows) {
+    try {
+      const workflowData = extractWorkflowData();
+      learnings.workflows = workflowData;
+    } catch {
+      // Workflow data not available
+    }
+  }
+
+  // Add learning summary
+  learnings.aggregates.summary = {
+    totalPatterns: learnings.patterns.length,
+    totalDecisionTypes: learnings.decisions.length,
+    totalWorkflows: learnings.workflows.length,
+    overallSuccessRate: calculateOverallSuccessRate(learnings.decisions)
+  };
+
+  return learnings;
+}
+
+/**
+ * Get anonymous project identifier (hash of project path)
+ */
+function getAnonymousProjectId() {
+  const consent = loadConsent();
+  return consent.projectId || generateProjectId(process.cwd());
+}
+
+/**
+ * Extract anonymized tech stack information
+ */
+function extractAnonymizedStack() {
+  const projectRoot = process.cwd();
+  const stack = {
+    framework: null,
+    language: null,
+    database: null,
+    testing: null
+  };
+
+  // Detect framework from package.json
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      // Framework detection
+      if (deps.next) stack.framework = 'nextjs';
+      else if (deps.react) stack.framework = 'react';
+      else if (deps.vue) stack.framework = 'vue';
+      else if (deps['@angular/core']) stack.framework = 'angular';
+      else if (deps.express) stack.framework = 'express';
+      else if (deps.fastify) stack.framework = 'fastify';
+
+      // Language detection
+      if (deps.typescript || fs.existsSync(path.join(projectRoot, 'tsconfig.json'))) {
+        stack.language = 'typescript';
+      } else {
+        stack.language = 'javascript';
+      }
+
+      // Database detection
+      if (deps.prisma || deps['@prisma/client']) stack.database = 'prisma';
+      else if (deps.mongoose) stack.database = 'mongodb';
+      else if (deps.pg || deps['node-postgres']) stack.database = 'postgresql';
+      else if (deps.mysql2) stack.database = 'mysql';
+      else if (deps.drizzle) stack.database = 'drizzle';
+
+      // Testing detection
+      if (deps.vitest) stack.testing = 'vitest';
+      else if (deps.jest) stack.testing = 'jest';
+      else if (deps.mocha) stack.testing = 'mocha';
+      else if (deps.playwright) stack.testing = 'playwright';
+    } catch {
+      // Package.json parsing failed
+    }
+  }
+
+  return stack;
+}
+
+/**
+ * Anonymize a single pattern for sharing
+ */
+function anonymizePattern(pattern) {
+  return {
+    type: pattern.type,
+    category: categorizePattern(pattern),
+    successRate: pattern.success_rate,
+    occurrences: pattern.occurrences,
+    confidence: pattern.confidence,
+    recommendation: pattern.recommendation,
+    contextHints: (pattern.context_hints || []).map(h => anonymizeString(h))
+  };
+}
+
+/**
+ * Categorize a pattern for cross-project relevance
+ */
+function categorizePattern(pattern) {
+  const type = (pattern.type || '').toLowerCase();
+  const decision = (pattern.decision || '').toLowerCase();
+
+  if (type.includes('database') || decision.includes('migration') || decision.includes('schema')) {
+    return 'database';
+  }
+  if (type.includes('security') || decision.includes('auth') || decision.includes('security')) {
+    return 'security';
+  }
+  if (type.includes('api') || decision.includes('endpoint') || decision.includes('route')) {
+    return 'api';
+  }
+  if (type.includes('test') || decision.includes('test') || decision.includes('coverage')) {
+    return 'testing';
+  }
+  if (type.includes('deploy') || decision.includes('deploy') || decision.includes('ci')) {
+    return 'deployment';
+  }
+  if (type.includes('perf') || decision.includes('performance') || decision.includes('optimize')) {
+    return 'performance';
+  }
+
+  return 'general';
+}
+
+/**
+ * Aggregate decisions by type for privacy
+ */
+function aggregateDecisionsByType(decisions) {
+  const aggregates = {};
+
+  for (const d of decisions) {
+    const type = d.type || 'unknown';
+    if (!aggregates[type]) {
+      aggregates[type] = {
+        type,
+        count: 0,
+        successCount: 0,
+        partialCount: 0,
+        failureCount: 0,
+        averageConfidence: 0,
+        totalConfidence: 0
+      };
+    }
+
+    aggregates[type].count++;
+    aggregates[type].totalConfidence += (d.confidence || 0.5);
+
+    if (d.outcome.status === 'success') aggregates[type].successCount++;
+    else if (d.outcome.status === 'partial') aggregates[type].partialCount++;
+    else if (d.outcome.status === 'failure') aggregates[type].failureCount++;
+  }
+
+  // Calculate final metrics
+  return Object.values(aggregates).map(a => ({
+    type: a.type,
+    count: a.count,
+    successRate: a.count > 0 ? Math.round((a.successCount / a.count) * 100) / 100 : 0,
+    partialRate: a.count > 0 ? Math.round((a.partialCount / a.count) * 100) / 100 : 0,
+    failureRate: a.count > 0 ? Math.round((a.failureCount / a.count) * 100) / 100 : 0,
+    averageConfidence: a.count > 0 ? Math.round((a.totalConfidence / a.count) * 100) / 100 : 0
+  }));
+}
+
+/**
+ * Extract workflow completion data
+ */
+function extractWorkflowData() {
+  const paths = getPaths();
+  const workflowDataPath = path.join(paths.projectRoot, '.bootspring', 'workflow-history.json');
+
+  if (!fs.existsSync(workflowDataPath)) {
+    return [];
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(workflowDataPath, 'utf8'));
+    const workflows = data.completed || [];
+
+    return workflows.map(w => ({
+      workflowType: w.workflow || w.type || 'unknown',
+      phasesCompleted: w.phasesCompleted || w.completedPhases || 0,
+      totalPhases: w.totalPhases || w.phases?.length || 0,
+      duration: w.duration, // In minutes
+      success: w.success !== false,
+      tier: w.tier || 'free'
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Calculate overall success rate from aggregated decisions
+ */
+function calculateOverallSuccessRate(aggregatedDecisions) {
+  if (!aggregatedDecisions || aggregatedDecisions.length === 0) return 0;
+
+  let totalCount = 0;
+  let totalSuccess = 0;
+
+  for (const d of aggregatedDecisions) {
+    totalCount += d.count;
+    totalSuccess += d.count * d.successRate;
+  }
+
+  return totalCount > 0 ? Math.round((totalSuccess / totalCount) * 100) / 100 : 0;
+}
+
+/**
+ * Share learnings to the central pool
+ * Uploads anonymized learnings to the sharing service (opt-in)
+ *
+ * @param {object} learnings - Learnings to share (from extractAnonymizedLearnings)
+ * @param {object} options - Sharing options
+ * @param {boolean} options.dryRun - If true, validate but don't actually share
+ * @returns {Promise<object>} Sharing result
+ */
+async function shareLearnings(learnings, options = {}) {
+  const { dryRun = false } = options;
+  const config = getConfig();
+
+  // Validate consent
+  if (!hasConsent()) {
+    return {
+      success: false,
+      error: 'Consent not granted for cross-project learning',
+      hint: 'Use grantConsent() to enable sharing'
+    };
+  }
+
+  // Validate config
+  if (!config.enabled) {
+    return {
+      success: false,
+      error: 'Cross-project learning is not enabled',
+      hint: 'Set crossProject.enabled = true in bootspring.config.js'
+    };
+  }
+
+  // Ensure learnings are properly anonymized
+  const sanitizedLearnings = {
+    ...learnings,
+    patterns: learnings.patterns.map(p => anonymize(p)),
+    decisions: learnings.decisions.map(d => anonymize(d)),
+    workflows: learnings.workflows.map(w => anonymize(w))
+  };
+
+  // Record what we're sharing locally
+  const contribution = {
+    id: `contrib_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+    sharedAt: new Date().toISOString(),
+    learningsVersion: sanitizedLearnings.version,
+    patternCount: sanitizedLearnings.patterns.length,
+    decisionTypeCount: sanitizedLearnings.decisions.length,
+    workflowCount: sanitizedLearnings.workflows.length,
+    dryRun
+  };
+
+  if (dryRun) {
+    return {
+      success: true,
+      dryRun: true,
+      contribution,
+      learnings: sanitizedLearnings,
+      message: 'Dry run complete - learnings validated but not shared'
+    };
+  }
+
+  // In a real implementation, this would POST to the API endpoint
+  // For now, we simulate the upload and store locally
+  try {
+    // Simulate API call (in production, this would be actual HTTP request)
+    const apiResult = await simulateApiUpload(sanitizedLearnings, config);
+
+    if (apiResult.success) {
+      // Save contribution record
+      const contributions = loadContributions();
+      contributions.contributions.push(contribution);
+      contributions.count++;
+      saveContributions(contributions);
+    }
+
+    return {
+      success: apiResult.success,
+      contribution,
+      apiResponse: apiResult,
+      message: apiResult.success
+        ? 'Learnings shared successfully'
+        : 'Failed to share learnings'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || 'Failed to share learnings',
+      contribution
+    };
+  }
+}
+
+/**
+ * Simulate API upload (placeholder for real implementation)
+ * In production, this would make an actual HTTP request
+ */
+async function simulateApiUpload(learnings, config) {
+  // Simulate network delay
+  await new Promise(resolve => setTimeout(resolve, 100));
+
+  // Validate learnings structure
+  if (!learnings.projectId || !learnings.extractedAt) {
+    return { success: false, error: 'Invalid learnings structure' };
+  }
+
+  // In production, this would be:
+  // const response = await fetch(config.apiEndpoint, {
+  //   method: 'POST',
+  //   headers: {
+  //     'Content-Type': 'application/json',
+  //     'Authorization': `Bearer ${config.apiKey}`
+  //   },
+  //   body: JSON.stringify(learnings)
+  // });
+
+  return {
+    success: true,
+    received: learnings.patterns.length + learnings.decisions.length + learnings.workflows.length,
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * Fetch community patterns from the shared pool
+ * Downloads aggregated patterns learned from the community
+ *
+ * @param {object} options - Fetch options
+ * @param {string} options.category - Filter by category (database, security, api, etc.)
+ * @param {number} options.minConfidence - Minimum confidence threshold
+ * @param {number} options.limit - Maximum patterns to fetch
+ * @param {boolean} options.useCache - Use cached patterns if available (default: true)
+ * @returns {Promise<object>} Community patterns
+ */
+async function fetchCommunityPatterns(options = {}) {
+  const config = getConfig();
+  const {
+    category = null,
+    minConfidence = 0.5,
+    limit = 100,
+    useCache = true
+  } = options;
+
+  const paths = getPaths();
+  const cachePath = path.join(paths.learningsDir, 'community-patterns-cache.json');
+
+  // Check cache first
+  if (useCache && fs.existsSync(cachePath)) {
+    try {
+      const cached = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      const cacheAge = Date.now() - new Date(cached.fetchedAt).getTime();
+
+      if (cacheAge < config.cacheExpiry) {
+        const filteredPatterns = filterPatterns(cached.patterns, { category, minConfidence, limit });
+        return {
+          success: true,
+          fromCache: true,
+          cacheAge: Math.round(cacheAge / 1000 / 60), // Minutes
+          patterns: filteredPatterns,
+          totalAvailable: cached.patterns.length,
+          fetchedAt: cached.fetchedAt
+        };
+      }
+    } catch {
+      // Cache invalid, fetch fresh
+    }
+  }
+
+  // Fetch fresh patterns
+  try {
+    // In production, this would be:
+    // const response = await fetch(`${config.apiEndpoint}/patterns`, {
+    //   method: 'GET',
+    //   headers: { 'Authorization': `Bearer ${config.apiKey}` }
+    // });
+    // const data = await response.json();
+
+    // For now, combine local community insights with simulated external data
+    const patterns = await fetchPatternsFromSources(config);
+
+    // Cache the results
+    ensureDirectories();
+    const cacheData = {
+      fetchedAt: new Date().toISOString(),
+      patterns
+    };
+    fs.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2));
+
+    const filteredPatterns = filterPatterns(patterns, { category, minConfidence, limit });
+
+    return {
+      success: true,
+      fromCache: false,
+      patterns: filteredPatterns,
+      totalAvailable: patterns.length,
+      fetchedAt: cacheData.fetchedAt
+    };
+  } catch (error) {
+    // Fall back to built-in community insights
+    const filteredInsights = filterPatterns(
+      Object.values(COMMUNITY_INSIGHTS).flat(),
+      { category, minConfidence, limit }
+    );
+
+    return {
+      success: true,
+      fromCache: false,
+      fallback: true,
+      patterns: filteredInsights,
+      totalAvailable: filteredInsights.length,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Fetch patterns from available sources
+ */
+async function fetchPatternsFromSources(config) {
+  const allPatterns = [];
+
+  // Add built-in community insights
+  for (const [source, patterns] of Object.entries(COMMUNITY_INSIGHTS)) {
+    for (const pattern of patterns) {
+      allPatterns.push({
+        ...pattern,
+        source: 'community',
+        sourceType: source
+      });
+    }
+  }
+
+  // In production, fetch from API and merge
+
+  return allPatterns;
+}
+
+/**
+ * Filter patterns based on criteria
+ */
+function filterPatterns(patterns, options) {
+  const { category, minConfidence, limit } = options;
+
+  let filtered = [...patterns];
+
+  if (category) {
+    filtered = filtered.filter(p =>
+      p.category === category ||
+      p.type === category ||
+      p.sourceType === category
+    );
+  }
+
+  if (minConfidence) {
+    filtered = filtered.filter(p => (p.confidence || 0.5) >= minConfidence);
+  }
+
+  // Sort by confidence and sample size
+  filtered.sort((a, b) => {
+    const scoreA = (a.confidence || 0.5) * Math.log10((a.sampleSize || 1) + 1);
+    const scoreB = (b.confidence || 0.5) * Math.log10((b.sampleSize || 1) + 1);
+    return scoreB - scoreA;
+  });
+
+  return filtered.slice(0, limit);
+}
+
+/**
+ * Apply relevant patterns to the current project context
+ * Matches community patterns against project needs and provides recommendations
+ *
+ * @param {object} projectContext - Current project context
+ * @param {string} projectContext.framework - Framework being used
+ * @param {string} projectContext.database - Database being used
+ * @param {string} projectContext.phase - Current project phase
+ * @param {Array<string>} projectContext.features - Features being developed
+ * @param {Array<string>} projectContext.challenges - Current challenges
+ * @param {object} options - Application options
+ * @param {number} options.maxPatterns - Maximum patterns to return (default: 10)
+ * @param {number} options.minRelevance - Minimum relevance score (default: 0.3)
+ * @returns {Promise<object>} Relevant patterns with recommendations
+ */
+async function applyRelevantPatterns(projectContext, options = {}) {
+  const {
+    maxPatterns = 10,
+    minRelevance = 0.3
+  } = options;
+
+  // Fetch community patterns
+  const communityResult = await fetchCommunityPatterns({ useCache: true });
+
+  if (!communityResult.success) {
+    return {
+      success: false,
+      error: 'Failed to fetch community patterns',
+      details: communityResult.error
+    };
+  }
+
+  const patterns = communityResult.patterns;
+
+  // Calculate relevance for each pattern
+  const scoredPatterns = patterns.map(pattern => ({
+    pattern,
+    relevance: calculatePatternRelevance(pattern, projectContext),
+    applicability: determineApplicability(pattern, projectContext)
+  }));
+
+  // Filter and sort by relevance
+  const relevantPatterns = scoredPatterns
+    .filter(sp => sp.relevance >= minRelevance)
+    .sort((a, b) => b.relevance - a.relevance)
+    .slice(0, maxPatterns);
+
+  // Group by category for easier consumption
+  const groupedPatterns = groupPatternsByCategory(relevantPatterns);
+
+  // Generate recommendations based on patterns
+  const recommendations = generatePatternRecommendations(relevantPatterns, projectContext);
+
+  return {
+    success: true,
+    projectContext: {
+      framework: projectContext.framework,
+      database: projectContext.database,
+      phase: projectContext.phase
+    },
+    totalPatternsAnalyzed: patterns.length,
+    relevantPatterns: relevantPatterns.map(sp => ({
+      ...sp.pattern,
+      relevanceScore: Math.round(sp.relevance * 100) / 100,
+      applicability: sp.applicability
+    })),
+    groupedByCategory: groupedPatterns,
+    recommendations,
+    appliedAt: new Date().toISOString()
+  };
+}
+
+/**
+ * Calculate relevance of a pattern to the project context
+ */
+function calculatePatternRelevance(pattern, context) {
+  let score = 0.5; // Base relevance
+
+  // Category/type matching
+  const category = pattern.category || pattern.type || '';
+
+  // Check feature alignment
+  if (context.features) {
+    for (const feature of context.features) {
+      const featureLower = feature.toLowerCase();
+      if (category.includes(featureLower) || (pattern.insight || '').toLowerCase().includes(featureLower)) {
+        score += 0.15;
+      }
+    }
+  }
+
+  // Check challenge alignment
+  if (context.challenges) {
+    for (const challenge of context.challenges) {
+      const challengeLower = challenge.toLowerCase();
+      if ((pattern.insight || '').toLowerCase().includes(challengeLower)) {
+        score += 0.2;
+      }
+    }
+  }
+
+  // Phase relevance
+  if (context.phase) {
+    const phaseRelevance = {
+      planning: ['architecture', 'database', 'api'],
+      development: ['testing', 'api', 'feature'],
+      testing: ['testing', 'security'],
+      deployment: ['deployment', 'security', 'performance'],
+      maintenance: ['performance', 'security', 'testing']
+    };
+
+    const relevantCategories = phaseRelevance[context.phase] || [];
+    if (relevantCategories.some(c => category.includes(c))) {
+      score += 0.15;
+    }
+  }
+
+  // Confidence bonus
+  score += (pattern.confidence || 0.5) * 0.1;
+
+  // Sample size bonus (capped)
+  score += Math.min((pattern.sampleSize || 0) / 10000, 0.1);
+
+  return Math.min(score, 1.0);
+}
+
+/**
+ * Determine how applicable a pattern is to the current context
+ */
+function determineApplicability(pattern, context) {
+  const factors = [];
+
+  // Framework match
+  if (context.framework && pattern.insight) {
+    const insightLower = pattern.insight.toLowerCase();
+    if (insightLower.includes(context.framework.toLowerCase())) {
+      factors.push('framework_match');
+    }
+  }
+
+  // Database match
+  if (context.database && (pattern.category === 'database' || pattern.type === 'database')) {
+    factors.push('database_relevant');
+  }
+
+  // High confidence
+  if ((pattern.confidence || 0) >= 0.85) {
+    factors.push('high_confidence');
+  }
+
+  // Large sample size
+  if ((pattern.sampleSize || 0) >= 500) {
+    factors.push('well_validated');
+  }
+
+  return {
+    score: factors.length / 4, // Normalize to 0-1
+    factors
+  };
+}
+
+/**
+ * Group patterns by category
+ */
+function groupPatternsByCategory(scoredPatterns) {
+  const groups = {};
+
+  for (const sp of scoredPatterns) {
+    const category = sp.pattern.category || sp.pattern.type || 'general';
+    if (!groups[category]) {
+      groups[category] = [];
+    }
+    groups[category].push({
+      insight: sp.pattern.insight,
+      confidence: sp.pattern.confidence,
+      relevance: Math.round(sp.relevance * 100) / 100
+    });
+  }
+
+  return groups;
+}
+
+/**
+ * Generate actionable recommendations from patterns
+ */
+function generatePatternRecommendations(scoredPatterns, context) {
+  const recommendations = [];
+
+  // High priority: High relevance + high confidence patterns
+  const highPriority = scoredPatterns.filter(
+    sp => sp.relevance >= 0.7 && (sp.pattern.confidence || 0) >= 0.85
+  );
+
+  for (const sp of highPriority.slice(0, 3)) {
+    recommendations.push({
+      priority: 'high',
+      category: sp.pattern.category || sp.pattern.type,
+      insight: sp.pattern.insight,
+      confidence: sp.pattern.confidence,
+      action: generateActionFromInsight(sp.pattern, context),
+      source: `Based on ${sp.pattern.sampleSize || 'community'} projects`
+    });
+  }
+
+  // Medium priority: Good relevance patterns
+  const mediumPriority = scoredPatterns.filter(
+    sp => sp.relevance >= 0.5 && sp.relevance < 0.7
+  );
+
+  for (const sp of mediumPriority.slice(0, 3)) {
+    recommendations.push({
+      priority: 'medium',
+      category: sp.pattern.category || sp.pattern.type,
+      insight: sp.pattern.insight,
+      confidence: sp.pattern.confidence,
+      action: generateActionFromInsight(sp.pattern, context)
+    });
+  }
+
+  // Add phase-specific recommendation if available
+  if (context.phase) {
+    const phasePatterns = scoredPatterns.filter(
+      sp => determineApplicability(sp.pattern, context).factors.includes('high_confidence')
+    );
+
+    if (phasePatterns.length > 0) {
+      recommendations.push({
+        priority: 'info',
+        category: 'phase_guidance',
+        insight: `For the ${context.phase} phase, community data suggests focusing on: ${phasePatterns.map(p => p.pattern.category).join(', ')}`,
+        action: 'Review patterns in these categories for your current phase'
+      });
+    }
+  }
+
+  return recommendations;
+}
+
+/**
+ * Generate an actionable suggestion from a pattern insight
+ */
+function generateActionFromInsight(pattern, context) {
+  const insight = pattern.insight || '';
+
+  // Extract percentages and metrics from insights
+  const percentMatch = insight.match(/(\d+(?:\.\d+)?)\s*%/);
+  const metric = percentMatch ? percentMatch[1] : null;
+
+  // Generate action based on category
+  const category = pattern.category || pattern.type || 'general';
+
+  const actionTemplates = {
+    database: metric
+      ? `Consider implementing this pattern to potentially achieve ${metric}% improvement`
+      : 'Review your database practices against this community learning',
+    security: 'Implement this security pattern early in development',
+    testing: 'Add this testing practice to your workflow',
+    performance: 'Apply this optimization during your performance review',
+    deployment: 'Include this in your deployment checklist',
+    api: 'Review your API design against this pattern'
+  };
+
+  return actionTemplates[category] || 'Consider applying this community-learned pattern';
+}
+
+/**
+ * Load contributions (data we've shared)
+ */
+function loadContributions() {
+  const paths = getPaths();
+  if (fs.existsSync(paths.contributionsPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(paths.contributionsPath, 'utf8'));
+    } catch {
+      return { contributions: [], count: 0 };
+    }
+  }
+  return { contributions: [], count: 0 };
+}
+
+/**
+ * Save contributions
+ */
+function saveContributions(contributions) {
+  const paths = getPaths();
+  ensureDirectories();
+  contributions.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(paths.contributionsPath, JSON.stringify(contributions, null, 2));
+}
+
+/**
+ * Contribute a pattern to cross-project learning
+ * @param {object} pattern - Pattern to contribute
+ */
+function contributePattern(pattern) {
+  if (!hasConsent()) {
+    return { success: false, error: 'Consent not granted for cross-project learning' };
+  }
+
+  const consent = loadConsent();
+  if (!consent.sharePatterns) {
+    return { success: false, error: 'Pattern sharing not enabled' };
+  }
+
+  const contributions = loadContributions();
+  const anonymizedPattern = anonymize(pattern);
+
+  const contribution = {
+    id: `pattern_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+    type: 'pattern',
+    projectId: consent.projectId,
+    data: anonymizedPattern,
+    contributedAt: new Date().toISOString()
+  };
+
+  contributions.contributions.push(contribution);
+  contributions.count++;
+  saveContributions(contributions);
+
+  return {
+    success: true,
+    contributionId: contribution.id,
+    type: 'pattern',
+    message: 'Pattern contributed to cross-project learning'
+  };
+}
+
+/**
+ * Contribute a decision outcome to cross-project learning
+ * @param {object} decision - Decision with outcome
+ */
+function contributeDecision(decision) {
+  if (!hasConsent()) {
+    return { success: false, error: 'Consent not granted for cross-project learning' };
+  }
+
+  const consent = loadConsent();
+  if (!consent.shareDecisions) {
+    return { success: false, error: 'Decision sharing not enabled' };
+  }
+
+  const contributions = loadContributions();
+  const anonymizedDecision = anonymize(decision);
+
+  // Extract only relevant learning data
+  const learningData = {
+    type: anonymizedDecision.type,
+    category: anonymizedDecision.category,
+    outcome: anonymizedDecision.outcome,
+    confidence: anonymizedDecision.confidence,
+    impactScore: anonymizedDecision.impactScore,
+    stack: anonymizedDecision.stack
+  };
+
+  const contribution = {
+    id: `decision_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+    type: 'decision',
+    projectId: consent.projectId,
+    data: learningData,
+    contributedAt: new Date().toISOString()
+  };
+
+  contributions.contributions.push(contribution);
+  contributions.count++;
+  saveContributions(contributions);
+
+  return {
+    success: true,
+    contributionId: contribution.id,
+    type: 'decision',
+    message: 'Decision outcome contributed to cross-project learning'
+  };
+}
+
+/**
+ * Contribute workflow completion to cross-project learning
+ * @param {object} workflow - Completed workflow data
+ */
+function contributeWorkflow(workflow) {
+  if (!hasConsent()) {
+    return { success: false, error: 'Consent not granted for cross-project learning' };
+  }
+
+  const consent = loadConsent();
+  if (!consent.shareWorkflows) {
+    return { success: false, error: 'Workflow sharing not enabled' };
+  }
+
+  const contributions = loadContributions();
+
+  // Extract only relevant workflow data
+  const workflowData = {
+    workflowName: workflow.name,
+    phases: workflow.phases?.length,
+    completedPhases: workflow.completedPhases,
+    duration: workflow.duration,
+    signalsCompleted: workflow.signalsCompleted,
+    tier: workflow.tier,
+    success: workflow.success
+  };
+
+  const contribution = {
+    id: `workflow_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+    type: 'workflow',
+    projectId: consent.projectId,
+    data: workflowData,
+    contributedAt: new Date().toISOString()
+  };
+
+  contributions.contributions.push(contribution);
+  contributions.count++;
+  saveContributions(contributions);
+
+  return {
+    success: true,
+    contributionId: contribution.id,
+    type: 'workflow',
+    message: 'Workflow completion contributed to cross-project learning'
+  };
+}
+
+/**
+ * Get contribution statistics
+ */
+function getContributionStats() {
+  const contributions = loadContributions();
+
+  const byType = contributions.contributions.reduce((acc, c) => {
+    acc[c.type] = (acc[c.type] || 0) + 1;
+    return acc;
+  }, {});
+
+  return {
+    totalContributions: contributions.count,
+    byType,
+    lastContribution: contributions.contributions[contributions.contributions.length - 1]?.contributedAt || null
+  };
+}
+
+/**
+ * Load received community learnings
+ */
+function loadReceived() {
+  const paths = getPaths();
+  if (fs.existsSync(paths.receivedPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(paths.receivedPath, 'utf8'));
+    } catch {
+      return { learnings: [], lastFetch: null };
+    }
+  }
+  return { learnings: [], lastFetch: null };
+}
+
+/**
+ * Save received learnings
+ */
+function saveReceived(received) {
+  const paths = getPaths();
+  ensureDirectories();
+  received.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(paths.receivedPath, JSON.stringify(received, null, 2));
+}
+
+/**
+ * Aggregated community insights (simulated)
+ * In a full implementation, this would come from a central service
+ */
+const COMMUNITY_INSIGHTS = {
+  patterns: [
+    {
+      id: 'insight_001',
+      type: 'pattern',
+      category: 'database',
+      insight: 'Using database migrations reduces schema-related deployment failures by 85%',
+      confidence: 0.92,
+      sampleSize: 1250,
+      updatedAt: '2026-02-01'
+    },
+    {
+      id: 'insight_002',
+      type: 'pattern',
+      category: 'testing',
+      insight: 'Projects with >80% test coverage have 60% fewer production bugs',
+      confidence: 0.88,
+      sampleSize: 890,
+      updatedAt: '2026-02-01'
+    },
+    {
+      id: 'insight_003',
+      type: 'pattern',
+      category: 'security',
+      insight: 'Early security audits catch 3x more vulnerabilities than pre-launch audits',
+      confidence: 0.95,
+      sampleSize: 560,
+      updatedAt: '2026-02-01'
+    }
+  ],
+  decisions: [
+    {
+      id: 'insight_004',
+      type: 'decision',
+      category: 'auth',
+      insight: 'OAuth providers reduce auth-related support tickets by 70%',
+      confidence: 0.85,
+      sampleSize: 720,
+      updatedAt: '2026-02-01'
+    },
+    {
+      id: 'insight_005',
+      type: 'decision',
+      category: 'payments',
+      insight: 'Stripe integration with webhooks has 99.2% success rate',
+      confidence: 0.94,
+      sampleSize: 450,
+      updatedAt: '2026-02-01'
+    }
+  ],
+  workflows: [
+    {
+      id: 'insight_006',
+      type: 'workflow',
+      workflow: 'feature-development',
+      insight: 'Feature development workflow average completion: 4.2 days',
+      confidence: 0.90,
+      sampleSize: 1800,
+      updatedAt: '2026-02-01'
+    },
+    {
+      id: 'insight_007',
+      type: 'workflow',
+      workflow: 'security-audit',
+      insight: 'Security audits find average 2.3 vulnerabilities per project',
+      confidence: 0.87,
+      sampleSize: 340,
+      updatedAt: '2026-02-01'
+    }
+  ]
+};
+
+/**
+ * Fetch community insights
+ * In a full implementation, this would call a central service
+ */
+function fetchCommunityInsights() {
+  if (!hasConsent()) {
+    // Still allow viewing public insights without contributing
+    return {
+      success: true,
+      insights: COMMUNITY_INSIGHTS,
+      message: 'Viewing public insights (enable sharing to contribute)'
+    };
+  }
+
+  const received = loadReceived();
+  received.learnings = COMMUNITY_INSIGHTS;
+  received.lastFetch = new Date().toISOString();
+  saveReceived(received);
+
+  return {
+    success: true,
+    insights: COMMUNITY_INSIGHTS,
+    totalInsights: Object.values(COMMUNITY_INSIGHTS).flat().length,
+    message: 'Community insights fetched'
+  };
+}
+
+/**
+ * Get insights relevant to a specific category or context
+ * @param {string} category - Category to filter by
+ */
+function getRelevantInsights(category) {
+  const allInsights = [
+    ...COMMUNITY_INSIGHTS.patterns,
+    ...COMMUNITY_INSIGHTS.decisions,
+    ...COMMUNITY_INSIGHTS.workflows
+  ];
+
+  if (!category) {
+    return allInsights;
+  }
+
+  return allInsights.filter(insight =>
+    insight.category === category ||
+    insight.workflow === category ||
+    insight.type === category
+  );
+}
+
+/**
+ * Apply community insights to local recommendations
+ * @param {object} recommendation - Local recommendation
+ */
+function enhanceWithCommunityInsights(recommendation) {
+  if (!recommendation || !recommendation.type) {
+    return recommendation;
+  }
+
+  const relevantInsights = getRelevantInsights(recommendation.type);
+
+  if (relevantInsights.length === 0) {
+    return recommendation;
+  }
+
+  // Add community context to recommendation
+  return {
+    ...recommendation,
+    communityInsights: relevantInsights.slice(0, 3),
+    communityConfidence: relevantInsights.reduce((sum, i) => sum + i.confidence, 0) / relevantInsights.length
+  };
+}
+
+/**
+ * Get cross-project learning status
+ */
+function getStatus() {
+  const consent = getConsentStatus();
+  const contributions = getContributionStats();
+
+  return {
+    enabled: consent.active,
+    consent,
+    contributions: consent.active ? contributions : null,
+    communityInsights: Object.values(COMMUNITY_INSIGHTS).flat().length
+  };
+}
+
+/**
+ * Export data for transparency
+ * Returns all data that would be/has been shared
+ */
+function exportMyData() {
+  const consent = loadConsent();
+  const contributions = loadContributions();
+
+  return {
+    consent: {
+      projectId: consent.projectId,
+      givenAt: consent.givenAt,
+      sharing: {
+        patterns: consent.sharePatterns,
+        decisions: consent.shareDecisions,
+        workflows: consent.shareWorkflows
+      }
+    },
+    contributions: contributions.contributions.map(c => ({
+      id: c.id,
+      type: c.type,
+      contributedAt: c.contributedAt,
+      data: c.data
+    })),
+    totalContributions: contributions.count
+  };
+}
+
+/**
+ * Delete all shared data (right to be forgotten)
+ */
+function deleteMyData() {
+  const paths = getPaths();
+
+  // Revoke consent
+  revokeConsent();
+
+  // Clear local contribution records
+  if (fs.existsSync(paths.contributionsPath)) {
+    fs.unlinkSync(paths.contributionsPath);
+  }
+
+  // In a full implementation, this would also:
+  // 1. Call the central service to delete server-side data
+  // 2. Request removal from aggregated statistics
+
+  return {
+    success: true,
+    message: 'All cross-project learning data deleted. Consent revoked.',
+    note: 'Your contributions have been removed from local storage.'
+  };
+}
+
+module.exports = {
+  // ============================================================================
+  // MAIN CROSS-PROJECT LEARNING API
+  // ============================================================================
+
+  // Core learning functions (the 4 main APIs)
+  extractAnonymizedLearnings,  // Extract learnings without sensitive data
+  shareLearnings,              // Upload to shared pool (async)
+  fetchCommunityPatterns,      // Download community patterns (async)
+  applyRelevantPatterns,       // Apply relevant patterns to project context (async)
+
+  // ============================================================================
+  // CONSENT & CONFIGURATION
+  // ============================================================================
+
+  // Consent management
+  grantConsent,
+  revokeConsent,
+  hasConsent,
+  getConsentStatus,
+
+  // Configuration
+  getConfig,
+  loadConfig,
+
+  // ============================================================================
+  // DATA HANDLING
+  // ============================================================================
+
+  // Data anonymization
+  anonymize,
+  anonymizeString,
+
+  // Contributing individual items
+  contributePattern,
+  contributeDecision,
+  contributeWorkflow,
+  getContributionStats,
+
+  // ============================================================================
+  // COMMUNITY INSIGHTS
+  // ============================================================================
+
+  // Receiving insights (legacy API, prefer fetchCommunityPatterns)
+  fetchCommunityInsights,
+  getRelevantInsights,
+  enhanceWithCommunityInsights,
+
+  // ============================================================================
+  // STATUS & TRANSPARENCY
+  // ============================================================================
+
+  // Status and data management
+  getStatus,
+  exportMyData,
+  deleteMyData,
+
+  // ============================================================================
+  // CONSTANTS
+  // ============================================================================
+
+  CROSS_PROJECT_CONFIG,
+  COMMUNITY_INSIGHTS,
+  SENSITIVE_FIELDS,
+  PROJECT_SPECIFIC_PATTERNS
+};