arcvision 0.2.17 → 0.2.20

package/src/core/invariant-detector.js

@@ -27,6 +27,7 @@ class InvariantDetector {
       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`);
@@ -57,11 +58,17 @@ class InvariantDetector {
             const nodeId = node.path || node.id || 'unknown';
             this.detectedInvariants.push({
               id: this.generateInvariantId(invariant.pattern, nodeId),
+              system: 'automatic',
               statement: invariant.description,
               description: invariant.description,
-              scope: this.determineScopeFromPath(nodeId),
+              severity: invariant.isCritical ? 'block' : 'risk',
+              scope: { files: [nodeId] },
               critical_path: invariant.isCritical,
               assertion: `Pattern: ${invariant.pattern}`,
+              rule: {
+                type: 'pattern',
+                condition: { pattern: invariant.pattern }
+              },
               status: 'suspected',
               confidence: this.calculateConfidenceScore(invariant.pattern, nodeId, content),
               source_file: nodeId,
@@ -86,11 +93,22 @@ class InvariantDetector {
     for (const constraint of dependencyConstraints) {
       this.detectedInvariants.push({
         id: this.generateInvariantId('dependency_constraint', constraint.from + '_' + constraint.to),
+        system: 'automatic',
         statement: constraint.description,
         description: constraint.description,
-        scope: 'boundary',
+        severity: constraint.critical ? 'block' : 'risk',
+        scope: { files: [constraint.from, constraint.to] },
         critical_path: constraint.critical,
         assertion: `Dependency constraint: ${constraint.from} -> ${constraint.to}`,
+        rule: {
+          type: 'dependency',
+          condition: {
+            forbiddenDependency: {
+              from: constraint.from,
+              to: constraint.to
+            }
+          }
+        },
         status: 'suspected',
         confidence: this.calculateConfidenceScore('dependency_constraint', constraint.from, ''),
         source_relationship: `${constraint.from} -> ${constraint.to}`,
@@ -116,11 +134,17 @@ class InvariantDetector {
         for (const pattern of patterns) {
           this.detectedInvariants.push({
             id: this.generateInvariantId(pattern.type, relativePath),
+            system: 'automatic',
             statement: `System invariant implemented in ${relativePath}: ${pattern.description}`,
             description: `System invariant implemented in ${relativePath}: ${pattern.description}`,
-            scope: 'system',
+            severity: 'risk',
+            scope: { files: [relativePath] },
             critical_path: true,  // File specifically for invariants is likely critical
             assertion: pattern.assertion,
+            rule: {
+              type: 'pattern',
+              condition: { pattern: pattern.type }
+            },
             status: 'suspected',
             confidence: this.calculateConfidenceScore(pattern.type, relativePath, content),
             source_file: relativePath,
@@ -543,6 +567,215 @@ class InvariantDetector {
     
     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';
+      } else if (filePath.includes('/services/') || filePath.includes('/business/')) {
+        layer = 'services';
+      } else if (filePath.includes('/models/') || filePath.includes('/entities/') || filePath.includes('/schemas/')) {
+        layer = 'models';
+      } else if (filePath.includes('/utils/') || filePath.includes('/helpers/') || filePath.includes('/lib/')) {
+        layer = 'utilities';
+      } else if (filePath.includes('/config/') || filePath.includes('/constants/')) {
+        layer = 'configuration';
+      } 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)) {
+            layerDependencies.set(depKey, []);
+          }
+          layerDependencies.get(depKey).push({ from: fromPath, to: toPath });
+        }
+      }
+    }
+    
+    // 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: 'controllers', to: 'models' },
+        { from: 'presentation', to: 'models' }
+      ];
+      
+      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}`),
+          system: 'architectural',
+          statement: `Layer dependency rule: ${fromLayer} components should not depend on ${toLayer} components`,
+          description: `Prevent ${fromLayer} layer from depending on ${toLayer} layer to maintain separation of concerns`,
+          severity: 'block',
+          scope: { files: dependencies.map(d => d.from) },
+          critical_path: true,
+          assertion: `Layer dependency rule: ${fromLayer} -> ${toLayer} is forbidden`,
+          rule: {
+            type: 'dependency',
+            condition: {
+              forbiddenDependency: {
+                from: `**/${fromLayer}/**`,
+                to: `**/${toLayer}/**`
+              }
+            }
+          },
+          status: 'detected',
+          confidence: 0.9,
+          detected_at: new Date().toISOString()
+        });
+      }
+    }
+  }
+  
+  /**
+   * 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)) {
+        nodeDegrees.set(edge.to, { incoming: 0, outgoing: 0 });
+      }
+      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()) {
+      if (degrees.incoming > 10) { // High incoming degree indicates hub
+        this.detectedInvariants.push({
+          id: this.generateInvariantId(`hub_protection_${nodeId}`, 'high_degree'),
+          system: 'architectural',
+          statement: `Protect high-degree node ${nodeId} from unauthorized modifications`,
+          description: `Node ${nodeId} has ${degrees.incoming} incoming dependencies, changes here affect many components`,
+          severity: 'risk',
+          scope: { files: [nodeId] },
+          critical_path: true,
+          assertion: `High-degree node protection: ${nodeId} has ${degrees.incoming} dependencies`,
+          rule: {
+            type: 'access_control',
+            condition: {
+              mustBeReviewed: true
+            }
+          },
+          status: 'detected',
+          confidence: 0.8,
+          detected_at: new Date().toISOString()
+        });
+      }
+    }
+  }
+  
+  /**
+   * 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)) {
+          couplingMap.set(coupleKey, []);
+        }
+        couplingMap.get(coupleKey).push(edge);
+      }
+    }
+    
+    // Create invariants for tightly coupled components
+    for (const [coupleKey, edgesList] of couplingMap.entries()) {
+      const [nodeA, nodeB] = coupleKey.split('|');
+      
+      this.detectedInvariants.push({
+        id: this.generateInvariantId(`tight_coupling_${nodeA}_${nodeB}`, 'bidirectional'),
+        system: 'architectural',
+        statement: `Prevent tight coupling between ${nodeA} and ${nodeB}`,
+        description: `Bidirectional dependency detected between ${nodeA} and ${nodeB}, indicating tight coupling`,
+        severity: 'risk',
+        scope: { files: [nodeA, nodeB] },
+        critical_path: false,
+        assertion: `Bidirectional dependency: ${nodeA} <-> ${nodeB}`,
+        rule: {
+          type: 'dependency',
+          condition: {
+            shouldAvoidBidirectional: true
+          }
+        },
+        status: 'detected',
+        confidence: 0.7,
+        detected_at: new Date().toISOString()
+      });
+    }
+  }
 }
 
 module.exports = { InvariantDetector };

package/src/core/parser.js

@@ -220,7 +220,13 @@ function parseFile(filePath) {
         classes: [],
         variables: [],
         types: [],
-        dependencies: []
+        dependencies: [],
+        functionCalls: [],
+        methodCalls: [],
+        constructorCalls: [],
+        typeImports: [],
+        interfaceDependencies: [],
+        genericDependencies: []
     };
 
     traverse(ast, {
@@ -421,6 +427,55 @@ function parseFile(filePath) {
                     loc: node.loc
                 });
             }
+            
+            // Track type imports/usage for dependency analysis
+            if (node.typeParameters && node.typeParameters.params) {
+                node.typeParameters.params.forEach(param => {
+                    if (param.constraint) {
+                        metadata.genericDependencies = metadata.genericDependencies || [];
+                        metadata.genericDependencies.push({
+                            name: param.name,
+                            constraint: param.constraint,
+                            loc: param.loc
+                        });
+                    }
+                });
+            }
+        },
+        
+        TSInterfaceDeclaration({ node }) {
+            if (node.id && node.id.name) {
+                metadata.types.push({
+                    name: node.id.name,
+                    kind: 'interface',
+                    loc: node.loc
+                });
+            }
+            
+            // Track interface inheritance for dependency analysis
+            if (node.extends) {
+                metadata.interfaceDependencies = metadata.interfaceDependencies || [];
+                node.extends.forEach(extend => {
+                    if (extend.expression && extend.expression.name) {
+                        metadata.interfaceDependencies.push({
+                            name: extend.expression.name,
+                            type: 'extends',
+                            loc: extend.loc
+                        });
+                    }
+                });
+            }
+        },
+        
+        TSImportType({ node }) {
+            // Track TypeScript import types
+            metadata.typeImports = metadata.typeImports || [];
+            if (node.argument && node.argument.value) {
+                metadata.typeImports.push({
+                    source: node.argument.value,
+                    loc: node.loc
+                });
+            }
         },
         VariableDeclaration({ node }) {
             node.declarations.forEach(decl => {
@@ -513,6 +568,35 @@ function parseFile(filePath) {
                     });
                 }
             }
+            
+            // Enhanced call detection for better structural relationship mapping
+            if (node.callee.type === 'Identifier') {
+                // Track function calls for dependency analysis
+                metadata.functionCalls = metadata.functionCalls || [];
+                metadata.functionCalls.push({
+                    name: node.callee.name,
+                    loc: node.loc
+                });
+            } else if (node.callee.type === 'MemberExpression') {
+                // Track method calls
+                metadata.methodCalls = metadata.methodCalls || [];
+                const objectName = node.callee.object.name || (node.callee.object.property ? node.callee.object.property.name : 'unknown');
+                const methodName = node.callee.property.name || 'unknown';
+                metadata.methodCalls.push({
+                    object: objectName,
+                    method: methodName,
+                    loc: node.loc
+                });
+            }
+            
+            // Track constructor calls
+            if (node.callee.type === 'Identifier' && node.callee.name && /^[A-Z]/.test(node.callee.name)) {
+                metadata.constructorCalls = metadata.constructorCalls || [];
+                metadata.constructorCalls.push({
+                    constructor: node.callee.name,
+                    loc: node.loc
+                });
+            }
         },
 
         VariableDeclarator({ node }) {

package/src/core/scanner.js

@@ -148,10 +148,20 @@ async function scan(directory) {
             });
             
             // Assess architectural health based on invariants
-            architecturalHealth = invariantAnalyzer.assessArchitecturalHealth(detectedInvariants, {
-                directory,
-                projectName: path.basename(directory)
-            });
+            try {
+                architecturalHealth = invariantAnalyzer.assessArchitecturalHealth(detectedInvariants, {
+                    directory,
+                    projectName: path.basename(directory)
+                });
+            } catch (healthError) {
+                console.warn(`⚠️  Could not assess architectural health: ${healthError.message}`);
+                // Provide a default health assessment
+                architecturalHealth = {
+                    score: 0,
+                    level: 'unknown',
+                    assessment: 'Could not assess architectural health due to analysis error'
+                };
+            }
         } else {
             // Even if no invariants are detected, create a baseline analysis
             const invariantAnalyzer = new InvariantAnalyzer();
@@ -186,7 +196,7 @@ async function scan(directory) {
             structuralInvariants,
             authoritativeContext,
             // Include detected invariants
-            detectedInvariants,
+            autoDetectedInvariants: detectedInvariants,
             // Include invariant analysis results
             invariantAnalysis,
             // Include architectural health assessment
@@ -227,7 +237,7 @@ async function scan(directory) {
         }
         
         // Build context and ensure archetype is properly set
-        let context = buildContext(nodes, edges, finalContextOptions);
+        let context = buildContext(nodes, edges, symbols, finalContextOptions);
         
         // Make sure archetype is set properly in the system section
         if (!context.system.archetype || context.system.archetype === null) {
@@ -250,6 +260,8 @@ async function scan(directory) {
             console.warn('   ⚠️  Proceeding despite validation issues to see results');
             // Continue processing instead of throwing error
             // throw new Error("Context validation failed");
+        } else {
+            console.log('   ✅ Context validation passed');
         }
 
         // Deterministic sort for consistent hashing/snapshots

package/src/engine/context_builder.js

@@ -257,9 +257,27 @@ function buildContext(files, edges, options = {}) {
     context.metrics.files_with_high_blast_radius = nodes.filter(n => n.blast_radius > 5).length;
     context.metrics.total_dependencies = schemaEdges.length;
     
-    // Add new canonical sections if provided in options
-    if (options.invariants !== undefined) {
-        context.invariants = options.invariants;
+    // Include automatically detected invariants in the context first
+    if (options.autoDetectedInvariants !== undefined && Array.isArray(options.autoDetectedInvariants) && options.autoDetectedInvariants.length > 0) {
+        context.auto_detected_invariants = options.autoDetectedInvariants;
+        
+        // Initialize context.invariants with auto-detected invariants if not already set
+        if (!context.invariants || !Array.isArray(context.invariants)) {
+            context.invariants = [...options.autoDetectedInvariants];
+        } else {
+            // Merge with existing invariants if they exist
+            context.invariants = [...context.invariants, ...options.autoDetectedInvariants];
+        }
+    }
+    
+    // Add new canonical sections if provided in options - this will add Pass 4 invariants if they exist
+    if (options.invariants !== undefined && Array.isArray(options.invariants) && options.invariants.length > 0) {
+        if (!context.invariants) {
+            context.invariants = options.invariants;
+        } else if (Array.isArray(context.invariants)) {
+            // Merge with existing invariants (could be from autoDetectedInvariants)
+            context.invariants = [...context.invariants, ...options.invariants];
+        }
     }
     
     if (options.ownership !== undefined) {

package/src/engine/context_validator.js

@@ -2,8 +2,14 @@ const fs = require('fs');
 const path = require('path');
 const Ajv = require('ajv');
 
+// Import format validators
+const addFormats = require('ajv-formats');
+
 // Create AJV instance with options for detailed error reporting
-const ajv = new Ajv({ allErrors: true, strict: false });
+const ajv = new Ajv({ allErrors: true, strict: false, validateFormats: false, logger: false });
+
+// Add standard formats including date-time
+addFormats(ajv);
 
 /**
  * Validate the context object against the Arcvision schema and invariants using AJV

package/src/engine/pass1_facts.js

@@ -38,7 +38,7 @@ async function executePass1(directory, options = {}) {
     }
 
     // Find all relevant code files for structural analysis
-    const files = await glob('**/*.{js,jsx,ts,tsx,cjs,mjs,json,lua}', {
+    const files = glob.sync('**/*.{js,jsx,ts,tsx,cjs,mjs,json,lua}', {
         ...scanOptions,
         ignore: [...scanOptions.ignore, 
             '**/*.d.ts', 
@@ -68,7 +68,7 @@ async function executePass1(directory, options = {}) {
     });
     
     // Use only code files for analysis
-    const allFiles = files;
+    const allFiles = Array.isArray(files) ? files : [];
     
     console.log(`   Identified ${allFiles.length} files for analysis`);
 

package/src/index.js

@@ -16,7 +16,7 @@ const RetryHandler = require('./core/retry-handler');
 const { invariantRegistry } = require('./core/invariant-registry');
 const { evaluateChange } = require('./core/change-evaluator');
 // Import authority gate components
-const { authorityLedger } = require('./core/authority-ledger');
+const { AuthorityLedger } = require('./core/authority-ledger');
 const { overrideHandler } = require('./core/override-handler');
 // Import robust validation and error handling
 const { cliValidator } = require('./core/cli-validator');
@@ -307,6 +307,9 @@ async function uploadToDatabase(jsonData) {
             controller.abort();
             clearTimeout(progress30s);
             clearTimeout(progress60s);
+            console.error(chalk.red('\n❌ Upload timeout after 120 seconds')); 
+            console.error(chalk.red('This may indicate network issues or server problems'));
+            console.error(chalk.yellow('Try again later or check your internet connection'));
           }, 120000); // 120 second timeout
           
           const response = await fetch(`${API_URL}/api/upload`, {
@@ -319,6 +322,14 @@ async function uploadToDatabase(jsonData) {
               graph: jsonData
             }),
             signal: controller.signal
+          }).catch(error => {
+            if (error.name === 'AbortError') {
+              throw new Error('Upload cancelled due to timeout');
+            }
+            if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+              throw new Error(`Cannot connect to ${API_URL} - check your internet connection and that the server is running`);
+            }
+            throw error;
           });
           
           // Clear all timeouts
@@ -405,6 +416,13 @@ program
         directory: targetDir
       });
 
+      // Initialize Artifact Manager
+      const { ArtifactManager } = require('./core/artifact-manager');
+      const artifactManager = new ArtifactManager(targetDir);
+          
+      // Ensure all required artifacts exist
+      artifactManager.ensureArtifacts();
+          
       console.log(chalk.blue(`Scanning directory: ${targetDir}`));
 
       const map = await scanner.scan(targetDir);
@@ -413,7 +431,7 @@ program
       // Analyze and print blast radius insight
       const blastRadiusAnalysis = analyzeBlastRadius(map);
       if (blastRadiusAnalysis && blastRadiusAnalysis.topFiles && blastRadiusAnalysis.topFiles.length > 0) {
-        console.log('\n⚠️  Top Structural Context Hubs Detected:\n');
+        console.log('\n🔍 STRUCTURAL ANALYSIS RESULTS:\n');
 
         blastRadiusAnalysis.topFiles.forEach((item, index) => {
           let warningMessage = '';
@@ -425,12 +443,12 @@ program
             warningMessage = 'Modifications can cause widespread inconsistencies.';
           }
 
-          console.log(`${index + 1}. ${item.file}`);
-          console.log(`   Blast Radius: ${item.blastRadius} files (${item.percentOfGraph}%)`);
-          console.log(`   Warning: ${warningMessage}\n`);
+          console.log(`${index + 1}. 📁 ${item.file}`);
+          console.log(`   🎯 Blast Radius: ${item.blastRadius} files (${item.percentOfGraph}%)`);
+          console.log(`   ⚠️  Risk: ${warningMessage}\n`);
         });
       } else {
-        console.log('\nNo high-structure files detected based on import dependencies.');
+        console.log('\n✅ No high-impact structural hubs detected in this codebase.');
       }
 
       // Validate the map before saving or uploading
@@ -554,18 +572,28 @@ program
         contextFile: options.contextFile,
         invariantsFile: options.invariantsFile
       });
-
+    
+      // Initialize Artifact Manager
+      const { ArtifactManager } = require('./core/artifact-manager');
+      const artifactManager = new ArtifactManager(targetDir);
+          
+      // Ensure all required artifacts exist
+      artifactManager.ensureArtifacts();
+      
+      // Initialize Authority Ledger with target directory
+      const authorityLedger = new AuthorityLedger(path.join(targetDir, 'arcvision_context', 'architecture.authority.ledger.json'));
+          
       console.log(chalk.blue('🔒 Authoritative Change Impact Gate (ACIG)'));
       console.log(chalk.blue('Evaluating changes against canonical system invariants...\n'));
-
+    
       // Load current context from arcvision_context directory
       const contextFile = options.contextFile || path.join(targetDir, 'arcvision_context', 'arcvision.context.json');
       if (!fs.existsSync(contextFile)) {
         console.error(chalk.red(`❌ Context file not found: ${contextFile}`));
-        console.error(chalk.yellow('Run `arcvision scan` first to generate context file'));
+        console.error(chalk.yellow('Run \`arcvision scan\` first to generate context file'));
         process.exit(1);
       }
-      
+          
       let context;
       try {
         const contextContent = fs.readFileSync(contextFile, 'utf8');
@@ -574,13 +602,13 @@ program
         console.error(chalk.red(`❌ Failed to parse context file: ${parseError.message}`));
         process.exit(1);
       }
-      
+          
       console.log(chalk.green(`✅ Loaded context from: ${contextFile}`));
-
+    
       // Load invariants
       const invariantsFile = options.invariantsFile || path.join(targetDir, '.arcvision', 'invariants.json');
       let loadSuccess = false;
-      
+          
       if (fs.existsSync(invariantsFile)) {
         loadSuccess = invariantRegistry.loadFromFile(invariantsFile);
         if (loadSuccess) {

package/test-block-functionality.js

@@ -0,0 +1,40 @@
+const { evaluateChange } = require('./src/core/change-evaluator');
+
+// Create a test that should definitely trigger a BLOCK
+const mockContext = {
+  nodes: [
+    { 
+      path: 'src/ui/user-profile.js',
+      content: 'import { fetchData } from "../core/data-service";'
+    }
+  ]
+};
+
+const testInvariant = {
+  id: 'block-all-ui-files',
+  system: 'test',
+  description: 'Block all UI files for testing',
+  severity: 'block',
+  scope: {
+    files: ['**/ui/**/*']
+  },
+  rule: {
+    type: 'existence',
+    condition: {
+      mustNotExist: 'src/ui/user-profile.js'
+    }
+  }
+};
+
+const result = evaluateChange({
+  changedFiles: ['src/ui/user-profile.js'],
+  dependencyGraph: mockContext,
+  invariants: [testInvariant],
+  context: {}
+});
+
+console.log('Test result:', result.decision);
+console.log('Violations:', result.violations.length);
+if (result.violations.length > 0) {
+  console.log('Violation details:', result.violations[0].description);
+}