arcvision 0.2.25 → 0.2.26

package/src/core/invariant-detector.js

@@ -21,17 +21,17 @@ class InvariantDetector {
    */
   async detectInvariants(scanResult, directory) {
     this.detectedInvariants = [];
-    
+
     try {
       // Analyze the structural context for potential invariants
       await this.analyzeNodesForInvariants(scanResult.nodes, directory);
       await this.analyzeEdgesForInvariants(scanResult.edges);
       await this.analyzeCodeFilesForInvariants(directory);
       await this.analyzeStructuralPatterns(scanResult.nodes, scanResult.edges, directory);
-      
+
       console.log(`\n🛡️  Invariant Detection Complete`);
       console.log(`   Found ${this.detectedInvariants.length} potential system invariants`);
-      
+
       return this.detectedInvariants;
     } catch (error) {
       console.error('Invariant detection failed:', error.message);
@@ -44,20 +44,24 @@ class InvariantDetector {
    */
   async analyzeNodesForInvariants(nodes, directory) {
     for (const node of nodes) {
-      if (!node.path) continue;
-      
+      const nodePath = node.path || node.id;
+      if (!nodePath) continue;
+
       try {
-        const filePath = path.join(directory, node.path);
+        const filePath = path.join(directory, nodePath);
         if (await this.isFileAccessible(filePath)) {
           const content = await fs.readFile(filePath, 'utf8');
-          
+
           // Look for validation/assertion patterns in the file
-          const fileInvariants = this.extractInvariantsFromFile(content, node.path);
-          
+          const fileInvariants = this.extractInvariantsFromFile(content, nodePath);
+
           for (const invariant of fileInvariants) {
-            const nodeId = node.path || node.id || 'unknown';
+            const nodeId = nodePath || 'unknown';
+            // Use position in ID to avoid collisions for multiple instances in same file
+            const invariantId = this.generateInvariantId(invariant.pattern, nodeId, invariant.position);
+
             this.detectedInvariants.push({
-              id: this.generateInvariantId(invariant.pattern, nodeId),
+              id: invariantId,
               system: 'automatic',
               statement: invariant.description,
               description: invariant.description,
@@ -74,6 +78,7 @@ class InvariantDetector {
                 condition: { pattern: invariant.pattern }
               },
               source_file: nodeId,
+              position: invariant.position,
               detected_at: new Date().toISOString()
             });
           }
@@ -91,7 +96,7 @@ class InvariantDetector {
   async analyzeEdgesForInvariants(edges) {
     // Look for dependency patterns that suggest invariants
     const dependencyConstraints = this.identifyDependencyInvariants(edges);
-    
+
     for (const constraint of dependencyConstraints) {
       this.detectedInvariants.push({
         id: this.generateInvariantId('dependency_constraint', constraint.from + '_' + constraint.to),
@@ -126,18 +131,19 @@ class InvariantDetector {
    */
   async analyzeCodeFilesForInvariants(directory) {
     const invariantFiles = await this.findInvariantRelatedFiles(directory);
-    
+
     for (const filePath of invariantFiles) {
       try {
         const content = await fs.readFile(filePath, 'utf8');
         const relativePath = path.relative(directory, filePath);
-        
+
         // Look for common invariant implementation patterns
         const patterns = this.searchForInvariantPatterns(content);
-        
-        for (const pattern of patterns) {
+
+        for (let i = 0; i < patterns.length; i++) {
+          const pattern = patterns[i];
           this.detectedInvariants.push({
-            id: this.generateInvariantId(pattern.type, relativePath),
+            id: this.generateInvariantId(pattern.type, relativePath, i),
             system: 'automatic',
             statement: `System invariant implemented in ${relativePath}: ${pattern.description}`,
             description: `System invariant implemented in ${relativePath}: ${pattern.description}`,
@@ -170,7 +176,7 @@ class InvariantDetector {
    */
   extractInvariantsFromFile(content, filePath) {
     const invariants = [];
-    
+
     // Check for validation function patterns
     const validationPatterns = [
       /function\s+validate\w+/gi,
@@ -181,7 +187,7 @@ class InvariantDetector {
       /function\s+assert\w+/gi,
       /function\s+enforce\w+/gi
     ];
-    
+
     for (const pattern of validationPatterns) {
       const matches = content.match(pattern);
       if (matches) {
@@ -192,7 +198,7 @@ class InvariantDetector {
         });
       }
     }
-    
+
     // Check for error handling patterns that suggest invariant enforcement
     const errorHandlingPatterns = [
       /try\s*\{/gi,
@@ -201,7 +207,7 @@ class InvariantDetector {
       /if\s*\([^)]+\)\s*throw/gi,
       /error\.message/gi
     ];
-    
+
     for (const pattern of errorHandlingPatterns) {
       const match = content.match(pattern);
       if (match) {
@@ -212,7 +218,7 @@ class InvariantDetector {
         });
       }
     }
-    
+
     // Check for state management patterns
     const stateManagementPatterns = [
       /setState\s*\(/gi,
@@ -223,7 +229,7 @@ class InvariantDetector {
       /state\./gi,
       /state\s*=\s*/gi
     ];
-    
+
     for (const pattern of stateManagementPatterns) {
       const match = content.match(pattern);
       if (match) {
@@ -234,7 +240,7 @@ class InvariantDetector {
         });
       }
     }
-    
+
     // Check for boundary enforcement patterns
     const boundaryCheckPatterns = [
       /boundary\s*check/gi,
@@ -246,7 +252,7 @@ class InvariantDetector {
       /validate\s*input/gi,
       /sanitiz/gi
     ];
-    
+
     for (const pattern of boundaryCheckPatterns) {
       const match = content.match(pattern);
       if (match) {
@@ -257,22 +263,22 @@ class InvariantDetector {
         });
       }
     }
-    
+
     // Check for invariant indicators from pass 1
     const invariantIndicators = this.extractDetailedInvariantIndicators(content, filePath);
     for (const indicator of invariantIndicators) {
       invariants.push(indicator);
     }
-    
+
     return invariants;
   }
-  
+
   /**
    * Extract detailed invariant indicators from content
    */
   extractDetailedInvariantIndicators(content, filePath) {
     const indicators = [];
-    
+
     // Look for common invariant/pattern validation patterns
     const patterns = [
       // Assertion and validation patterns
@@ -284,13 +290,14 @@ class InvariantDetector {
       { pattern: /guard[A-Z]/gi, description: 'Guard function pattern', critical: true },
       { pattern: /verify[A-Z]/gi, description: 'Verify function pattern', critical: false },
       { pattern: /validate\(/gi, description: 'Validation function call', critical: false },
-      
+
       // Constraint and invariant mentions
       { pattern: /Invariant/gi, description: 'Invariant mention', critical: true },
       { pattern: /constraint/gi, description: 'Constraint mention', critical: true },
-      { pattern: /require\(/gi, description: 'Requirement assertion', critical: true },
+      { pattern: /VIOLATION/gi, description: 'Explicit violation marker', critical: true },
+      { pattern: /BLOCKED/gi, description: 'Blocking architectural pattern', critical: true },
       { pattern: /enforce/gi, description: 'Enforcement pattern', critical: true },
-      
+
       // Conditional guard patterns
       { pattern: /must.*be/gi, description: 'Must-be pattern', critical: true },
       { pattern: /should.*be/gi, description: 'Should-be pattern', critical: false },
@@ -298,39 +305,39 @@ class InvariantDetector {
       { pattern: /if.*!\s*[^\s]+\s*throw/gi, description: 'Guard clause pattern', critical: true },
       { pattern: /if.*!\s*[^\s]+\s*reject/gi, description: 'Promise rejection guard', critical: true },
       { pattern: /throw.*Error/gi, description: 'Error throwing pattern', critical: true },
-      
+
       // Boundary and validation patterns
       { pattern: /boundary.*check/gi, description: 'Boundary check', critical: true },
       { pattern: /range.*check/gi, description: 'Range check', critical: true },
       { pattern: /within.*bounds/gi, description: 'Bounds check', critical: true },
       { pattern: /validat(e|ion)/gi, description: 'Validation pattern', critical: false },
       { pattern: /guard/i, description: 'Guard pattern', critical: true },
-      
+
       // Access control and security patterns
       { pattern: /access.*control/gi, description: 'Access control', critical: true },
       { pattern: /permission.*check/gi, description: 'Permission check', critical: true },
       { pattern: /auth(?:oriz|enticat)/gi, description: 'Authorization/authentication', critical: true },
       { pattern: /acl/gi, description: 'Access Control List', critical: true },
-      
+
       // State management patterns
       { pattern: /state.*transition/gi, description: 'State transition', critical: true },
       { pattern: /setState/gi, description: 'State setter', critical: true },
       { pattern: /update.*state/gi, description: 'State updater', critical: true },
       { pattern: /transition/gi, description: 'Transition pattern', critical: true },
       { pattern: /immutable/gi, description: 'Immutability pattern', critical: true },
-      
+
       // Type and schema validation patterns
       { pattern: /zod/gi, description: 'Zod validation schema', critical: false },
       { pattern: /joi/gi, description: 'Joi validation schema', critical: false },
       { pattern: /yup/gi, description: 'Yup validation schema', critical: false },
       { pattern: /ajv/gi, description: 'Ajv validation schema', critical: false },
       { pattern: /schema/gi, description: 'Schema definition', critical: false },
-      
+
       // Configuration patterns
       { pattern: /config.*environ/gi, description: 'Environment configuration', critical: true },
       { pattern: /env.*validation/gi, description: 'Environment validation', critical: true }
     ];
-    
+
     for (const item of patterns) {
       if (!item.pattern || !content) continue; // Skip if pattern or content is undefined
       let match;
@@ -338,13 +345,14 @@ class InvariantDetector {
         while ((match = item.pattern.exec(content)) !== null) {
           // Avoid duplicate matches by position
           const position = item.pattern.lastIndex;
-          const prevMatch = indicators.find(ind => ind.pattern === item.pattern.source && 
-                                           ind.description.includes(match[0]));
+          const prevMatch = indicators.find(ind => ind.pattern === item.pattern.source &&
+            ind.description.includes(match[0]));
           if (!prevMatch) {
             indicators.push({
               pattern: item.pattern.source,
               description: `${item.description} found in ${filePath}: '${match[0]}' at position ${position}`,
-              isCritical: item.critical
+              isCritical: item.critical,
+              position: position
             });
           }
         }
@@ -353,7 +361,7 @@ class InvariantDetector {
         continue;
       }
     }
-    
+
     return indicators;
   }
 
@@ -362,11 +370,11 @@ class InvariantDetector {
    */
   identifyDependencyInvariants(edges) {
     const constraints = [];
-    
+
     // Look for patterns like core modules that should not depend on peripheral modules
     const coreModules = new Set();
     const peripheralModules = new Set();
-    
+
     for (const edge of edges) {
       // Identify potential architectural layers based on file paths
       if (this.isCoreLayer(edge.from) && this.isPeripheralLayer(edge.to)) {
@@ -379,7 +387,7 @@ class InvariantDetector {
         });
       }
     }
-    
+
     return constraints;
   }
 
@@ -388,19 +396,19 @@ class InvariantDetector {
    */
   async findInvariantRelatedFiles(directory) {
     const invariantFiles = [];
-    
+
     const walk = async (dir) => {
       try {
         const entries = await fs.readdir(dir, { withFileTypes: true });
-        
+
         for (const entry of entries) {
           const fullPath = path.join(dir, entry.name);
-          
+
           if (entry.isDirectory()) {
             await walk(fullPath);
           } else if (entry.isFile()) {
             const fileName = entry.name.toLowerCase();
-            
+
             // Look for files that commonly contain invariants
             if (
               fileName.includes('invariant') ||
@@ -420,7 +428,7 @@ class InvariantDetector {
         // Skip directories we can't access
       }
     };
-    
+
     await walk(directory);
     return invariantFiles;
   }
@@ -430,7 +438,7 @@ class InvariantDetector {
    */
   searchForInvariantPatterns(content) {
     const patterns = [];
-    
+
     // Look for assertion/verification patterns
     if (content.includes('assert(') || content.includes('AssertionError')) {
       patterns.push({
@@ -439,7 +447,7 @@ class InvariantDetector {
         assertion: 'Code contains assert() calls for invariant enforcement'
       });
     }
-    
+
     // Look for validation patterns
     if (content.includes('validate(') || content.includes('isValid') || content.includes('checkValid')) {
       patterns.push({
@@ -448,7 +456,7 @@ class InvariantDetector {
         assertion: 'Code contains validation functions for invariant enforcement'
       });
     }
-    
+
     // Look for guard clauses
     if (content.includes('if (!condition) throw') || content.includes('guard clause')) {
       patterns.push({
@@ -457,7 +465,7 @@ class InvariantDetector {
         assertion: 'Code contains early-exit guard clauses for invariant enforcement'
       });
     }
-    
+
     // Look for state machine patterns
     if (content.includes('state') && (content.includes('transition') || content.includes('transitions'))) {
       patterns.push({
@@ -466,7 +474,7 @@ class InvariantDetector {
         assertion: 'Code implements state machine with transition constraints'
       });
     }
-    
+
     return patterns;
   }
 
@@ -501,11 +509,11 @@ class InvariantDetector {
    */
   isCoreLayer(filePath) {
     if (!filePath) return false;
-    return filePath.includes('/core/') || 
-           filePath.includes('/lib/') || 
-           filePath.includes('/shared/') ||
-           filePath.includes('config') ||
-           filePath.includes('auth');
+    return filePath.includes('/core/') ||
+      filePath.includes('/lib/') ||
+      filePath.includes('/shared/') ||
+      filePath.includes('config') ||
+      filePath.includes('auth');
   }
 
   /**
@@ -513,41 +521,41 @@ class InvariantDetector {
    */
   isPeripheralLayer(filePath) {
     if (!filePath) return false;
-    return filePath.includes('/views/') || 
-           filePath.includes('/templates/') || 
-           filePath.includes('/ui/') ||
-           filePath.includes('/tests/') ||
-           filePath.includes('/mocks/');
+    return filePath.includes('/views/') ||
+      filePath.includes('/templates/') ||
+      filePath.includes('/ui/') ||
+      filePath.includes('/tests/') ||
+      filePath.includes('/mocks/');
   }
 
   /**
    * Generate unique invariant ID
    */
-  generateInvariantId(pattern, context) {
-    const baseId = `${pattern}_${context}`.replace(/[^a-zA-Z0-9_-]/g, '_');
+  generateInvariantId(pattern, context, discriminator = '') {
+    const baseId = `${pattern}_${context}_${discriminator}`.replace(/[^a-zA-Z0-9_-]/g, '_');
     return baseId.substring(0, 100); // Limit length
   }
-  
+
   /**
    * Calculate confidence score for an invariant based on various factors
    */
   calculateConfidenceScore(pattern, context, content = '') {
     let score = 0.5; // Base confidence
-    
+
     // Increase confidence based on pattern type
     if (pattern.includes('assert') || pattern.includes('validate') || pattern.includes('guard')) {
       score += 0.2;
     }
-    
+
     if (pattern.includes('state') || pattern.includes('mutation') || pattern.includes('setState')) {
       score += 0.15;
     }
-    
+
     // Increase confidence if context suggests critical file
     if (context.includes('core') || context.includes('lib') || context.includes('shared')) {
       score += 0.1;
     }
-    
+
     // Increase confidence based on frequency of pattern in content
     if (content && typeof content === 'string') {
       const matches = content.match(new RegExp(pattern, 'gi'));
@@ -555,50 +563,50 @@ class InvariantDetector {
         score += Math.min(matches.length * 0.05, 0.2); // Up to 0.2 for multiple matches
       }
     }
-    
+
     // Ensure score stays within bounds
     return Math.min(Math.max(score, 0.1), 1.0);
   }
-  
+
   /**
    * Determine the owner of an invariant based on the source file
    */
   determineOwnerFromPath(filePath) {
     if (!filePath) return 'unknown';
-    
+
     // Extract function or module name from file path
     const parts = filePath.split(/[\/]/);
     const fileName = parts[parts.length - 1];
     const baseName = fileName.replace(/\.[^/.]+$/, ''); // Remove extension
-    
+
     return baseName;
   }
-  
+
   /**
    * Analyze structural patterns in the codebase and generate architectural invariants
    */
   async analyzeStructuralPatterns(nodes, edges, directory) {
     // Generate layer-based architectural invariants
     await this.generateLayerInvariants(nodes, edges);
-    
+
     // Generate dependency-based architectural invariants
     await this.generateDependencyInvariants(nodes, edges);
-    
+
     // Generate coupling-based architectural invariants
     await this.generateCouplingInvariants(nodes, edges);
   }
-  
+
   /**
    * Generate layer-based architectural invariants
    */
   async generateLayerInvariants(nodes, edges) {
     const layerMap = new Map();
-    
+
     // Classify nodes by layer based on path patterns
     for (const node of nodes) {
       const filePath = node.path || node.id;
       if (!filePath) continue;
-      
+
       let layer = 'general';
       if (filePath.includes('/controllers/') || filePath.includes('/handlers/')) {
         layer = 'controllers';
@@ -613,31 +621,31 @@ class InvariantDetector {
       } else if (filePath.includes('/views/') || filePath.includes('/components/') || filePath.includes('/ui/')) {
         layer = 'presentation';
       }
-      
+
       if (!layerMap.has(layer)) {
         layerMap.set(layer, []);
       }
       layerMap.get(layer).push(filePath);
     }
-    
+
     // Generate invariants based on layer dependencies (e.g., models shouldn't depend on controllers)
     const layerDependencies = new Map();
     for (const edge of edges) {
       const fromNode = nodes.find(n => n.id === edge.from || n.path === edge.from);
       const toNode = nodes.find(n => n.id === edge.to || n.path === edge.to);
-      
+
       if (fromNode && toNode) {
         const fromPath = fromNode.path || fromNode.id;
         const toPath = toNode.path || toNode.id;
-        
+
         let fromLayer = 'general';
         let toLayer = 'general';
-        
+
         for (const [layer, paths] of layerMap.entries()) {
           if (paths.includes(fromPath)) fromLayer = layer;
           if (paths.includes(toPath)) toLayer = layer;
         }
-        
+
         if (fromLayer !== toLayer) {
           const depKey = `${fromLayer}->${toLayer}`;
           if (!layerDependencies.has(depKey)) {
@@ -647,23 +655,23 @@ class InvariantDetector {
         }
       }
     }
-    
+
     // Create invariants for problematic layer dependencies
     for (const [depKey, dependencies] of layerDependencies.entries()) {
       const [fromLayer, toLayer] = depKey.split('->');
-      
+
       // Define architectural rules (e.g., models should not depend on controllers)
       const forbiddenLayerDeps = [
         { from: 'models', to: 'controllers' },
-        { from: 'models', to: 'services' }, 
+        { from: 'models', to: 'services' },
         { from: 'controllers', to: 'models' },
         { from: 'presentation', to: 'models' }
       ];
-      
-      const isForbidden = forbiddenLayerDeps.some(rule => 
+
+      const isForbidden = forbiddenLayerDeps.some(rule =>
         rule.from === fromLayer && rule.to === toLayer
       );
-      
+
       if (isForbidden) {
         this.detectedInvariants.push({
           id: this.generateInvariantId(`layer_${fromLayer}_not_depend_${toLayer}`, `${fromLayer}_${toLayer}`),
@@ -692,14 +700,14 @@ class InvariantDetector {
       }
     }
   }
-  
+
   /**
    * Generate dependency-based architectural invariants
    */
   async generateDependencyInvariants(nodes, edges) {
     // Identify high-degree nodes that might indicate architectural hubs
     const nodeDegrees = new Map();
-    
+
     for (const edge of edges) {
       // Count incoming edges (dependencies on this node)
       if (!nodeDegrees.has(edge.to)) {
@@ -708,11 +716,11 @@ class InvariantDetector {
       if (!nodeDegrees.has(edge.from)) {
         nodeDegrees.set(edge.from, { incoming: 0, outgoing: 0 });
       }
-      
+
       nodeDegrees.get(edge.to).incoming++;
       nodeDegrees.get(edge.from).outgoing++;
     }
-    
+
     // Identify potential architectural bottlenecks
     for (const [nodeId, degrees] of nodeDegrees.entries()) {
       // Make sure nodeId is valid before creating invariant
@@ -743,18 +751,18 @@ class InvariantDetector {
       }
     }
   }
-  
+
   /**
    * Generate coupling-based architectural invariants
    */
   async generateCouplingInvariants(nodes, edges) {
     // Identify tightly coupled components
     const couplingMap = new Map();
-    
+
     for (const edge of edges) {
       // Look for mutual dependencies indicating tight coupling
       const reverseEdge = edges.find(e => e.from === edge.to && e.to === edge.from);
-      
+
       if (reverseEdge) {
         const coupleKey = [edge.from, edge.to].sort().join('|');
         if (!couplingMap.has(coupleKey)) {
@@ -763,11 +771,11 @@ class InvariantDetector {
         couplingMap.get(coupleKey).push(edge);
       }
     }
-    
+
     // Create invariants for tightly coupled components
     for (const [coupleKey, edgesList] of couplingMap.entries()) {
       const [nodeA, nodeB] = coupleKey.split('|');
-      
+
       // Only create the invariant if both node names are valid and non-empty
       if (nodeA && nodeA.trim() !== '' && nodeB && nodeB.trim() !== '') {
         this.detectedInvariants.push({
@@ -794,6 +802,18 @@ class InvariantDetector {
       }
     }
   }
+
+  /**
+   * Check if a file is accessible and readable
+   */
+  async isFileAccessible(filePath) {
+    try {
+      await fs.access(filePath, require('fs').constants.R_OK);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
 }
 
 module.exports = { InvariantDetector };