arcvision 0.2.17 → 0.2.21

package/.arcvision/logs/errors.log

@@ -0,0 +1,7 @@
+{"timestamp":"2026-01-25T01:45:35.206Z","error":{"category":"UNKNOWN","message":"Missing required artifacts: arcvision_context/arcvision.context.json","code":null,"type":"Error"},"context":{"operation":"scan","directory":"C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\test-dev-project"},"stack":"Error: Missing required artifacts: arcvision_context/arcvision.context.json\n    at ArtifactManager.validateArtifacts (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\artifact-manager.js:87:13)\n    at ArtifactManager.ensureArtifacts (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\artifact-manager.js:26:10)\n    at Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:413:23)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)"}
+{"timestamp":"2026-01-25T01:53:22.074Z","error":{"category":"UNKNOWN","message":"Missing required artifacts: arcvision_context/arcvision.context.json","code":null,"type":"Error"},"context":{"operation":"scan","directory":"C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\test-dev-project"},"stack":"Error: Missing required artifacts: arcvision_context/arcvision.context.json\n    at ArtifactManager.validateArtifacts (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\artifact-manager.js:87:13)\n    at ArtifactManager.ensureArtifacts (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\artifact-manager.js:26:10)\n    at Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:413:23)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)"}
+{"timestamp":"2026-01-25T02:04:57.719Z","error":{"category":"UNKNOWN","message":"Invalid ledger structure","code":null,"type":"Error"},"context":{"operation":"evaluate","directory":"C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\test-dev-project"},"stack":"Error: Invalid ledger structure\n    at AuthorityLedger.readLedger (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:203:15)\n    at AuthorityLedger.appendEvent (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:176:27)\n    at AuthorityLedger.recordBlocked (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:81:10)\n    at Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:662:35)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)"}
+{"timestamp":"2026-01-25T02:05:38.566Z","error":{"category":"UNKNOWN","message":"Invalid ledger structure","code":null,"type":"Error"},"context":{"operation":"evaluate","directory":"C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\test-dev-project"},"stack":"Error: Invalid ledger structure\n    at AuthorityLedger.readLedger (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:203:15)\n    at AuthorityLedger.appendEvent (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:176:27)\n    at AuthorityLedger.recordBlocked (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:81:10)\n    at Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:662:35)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)"}
+{"timestamp":"2026-01-25T03:16:17.596Z","error":{"category":"CONFIGURATION","message":"Invalid or revoked token","code":null,"type":"Error"},"context":{"operation":"standard_upload"},"stack":"Error: Invalid or revoked token\n    at C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:330:19\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at async RetryHandler.executeWithRetry (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\retry-handler.js:23:24)\n    at async uploadToDatabase (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:294:24)\n    at async Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:462:9)"}
+{"timestamp":"2026-01-25T10:28:14.750Z","error":{"category":"UNKNOWN","message":"Failed to initiate upload session","code":null,"type":"Error"},"context":{"operation":"chunked_upload"},"stack":"Error: Failed to initiate upload session\n    at ChunkedUploader.uploadInChunks (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\chunked-uploader.js:58:13)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at async C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:177:18\n    at async RetryHandler.executeWithRetry (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\retry-handler.js:23:24)\n    at async uploadToDatabase (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:176:24)\n    at async Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:473:9)"}
+{"timestamp":"2026-01-25T14:09:23.628Z","error":{"category":"CONFIGURATION","message":"Invalid or revoked token","code":null,"type":"Error"},"context":{"operation":"standard_upload"},"stack":"Error: Invalid or revoked token\n    at C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:341:19\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at async RetryHandler.executeWithRetry (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\retry-handler.js:23:24)\n    at async uploadToDatabase (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:294:24)\n    at async Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:473:9)"}

package/arcvision_context/architecture.authority.ledger.json

@@ -1,77 +1,20 @@
 {
   "schema_version": "1.0",
   "system_id": "cli",
-  "created_at": "2026-01-21T10:36:12.455Z",
+  "created_at": "2026-01-25T01:42:21.875Z",
   "ledger": [
     {
-      "event_id": "evt_1769063005574_7anyjl7bo",
-      "timestamp": "2026-01-22T06:23:25.574Z",
+      "event_id": "evt_1769306597736_165d6ogio",
+      "timestamp": "2026-01-25T02:03:17.736Z",
       "decision": "BLOCKED",
       "commit": "HEAD",
       "branch": "unknown",
       "author": "unknown",
       "violations": [
         {
-          "id": "no-circular-dependencies",
-          "description": "Circular dependencies between modules are forbidden",
-          "system": "blocked-legacy-monolith",
-          "severity": "block"
-        }
-      ],
-      "blast_radius": 0,
-      "affected_nodes": 0,
-      "override": false
-    },
-    {
-      "event_id": "evt_1769074540287_n0z3a3fy3",
-      "timestamp": "2026-01-22T09:35:40.287Z",
-      "decision": "BLOCKED",
-      "commit": "HEAD",
-      "branch": "unknown",
-      "author": "unknown",
-      "violations": [
-        {
-          "id": "no-circular-dependencies",
-          "description": "Circular dependencies between modules are forbidden",
-          "system": "blocked-legacy-monolith",
-          "severity": "block"
-        }
-      ],
-      "blast_radius": 0,
-      "affected_nodes": 0,
-      "override": false
-    },
-    {
-      "event_id": "evt_1769074680315_phm7zyzp4",
-      "timestamp": "2026-01-22T09:38:00.315Z",
-      "decision": "BLOCKED",
-      "commit": "HEAD",
-      "branch": "unknown",
-      "author": "unknown",
-      "violations": [
-        {
-          "id": "no-circular-dependencies",
-          "description": "Circular dependencies between modules are forbidden",
-          "system": "blocked-legacy-monolith",
-          "severity": "block"
-        }
-      ],
-      "blast_radius": 0,
-      "affected_nodes": 0,
-      "override": false
-    },
-    {
-      "event_id": "evt_1769089584032_49cj329l0",
-      "timestamp": "2026-01-22T13:46:24.032Z",
-      "decision": "BLOCKED",
-      "commit": "HEAD",
-      "branch": "unknown",
-      "author": "unknown",
-      "violations": [
-        {
-          "id": "no-circular-dependencies",
-          "description": "Circular dependencies between modules are forbidden",
-          "system": "blocked-legacy-monolith",
+          "id": "no-ui-imports-core",
+          "description": "UI components should not import from core modules",
+          "system": "layering",
           "severity": "block"
         }
       ],

package/bin/arcvision.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+// ArcVision CLI Entry Point
+// This file serves as the executable binary for the ArcVision CLI
+
+try {
+  // Require the main CLI module
+  require('../src/index.js');
+} catch (error) {
+  console.error('Failed to start ArcVision CLI:', error.message);
+  process.exit(1);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "arcvision",
-  "version": "0.2.17",
+  "version": "0.2.21",
   "description": "ArcVision CLI - Architectural Governance and Invariant Detection Tool",
   "main": "src/index.js",
   "bin": {
-    "arcvision": "src/index.js"
+    "arcvision": "./bin/arcvision.js"
   },
   "scripts": {
     "start": "node src/index.js",
@@ -28,6 +28,7 @@
     "@babel/parser": "^7.24.0",
     "@babel/traverse": "^7.24.0",
     "ajv": "^8.12.0",
+    "ajv-formats": "^3.0.1",
     "chalk": "^4.1.2",
     "commander": "^9.4.1",
     "fast-glob": "^3.2.12",

package/src/arcvision-guard.js

@@ -206,11 +206,17 @@ program
       fs.mkdirSync(tokensDir, { recursive: true });
     }
     
-    // Copy configuration templates
-    const templateDir = path.join(__dirname, '..', '.arcvision');
-    if (fs.existsSync(templateDir)) {
-      copyFile(path.join(templateDir, 'config.json'), path.join(arcDir, 'config.json'));
-      copyFile(path.join(templateDir, 'invariants.json'), path.join(arcDir, 'invariants.json'));
+    // Create default configuration (no longer using separate invariants file as they're stored in context)
+    const configPath = path.join(arcDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+      const defaultConfig = {
+        guard_rules: {
+          blast_radius: {
+            critical_threshold: 50
+          }
+        }
+      };
+      fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
       console.log(chalk.green('✅ Configuration files created'));
     }
     
@@ -223,7 +229,7 @@ program
     console.log(chalk.green('\n🎉 ArcVision Impact Guard initialized successfully!'));
     console.log(chalk.yellow('\nNext steps:'));
     console.log(chalk.yellow('1. Review .arcvision/config.json for project settings'));
-    console.log(chalk.yellow('2. Customize .arcvision/invariants.json with your architectural rules'));
+    console.log(chalk.yellow('2. Auto-detect architectural invariants by running: arcvision scan'));
     console.log(chalk.yellow('3. Run: arcvision-guard check'));
     console.log(chalk.yellow('4. For critical changes: arcvision-guard bypass-request --reason "your reason"'));
   });
@@ -246,17 +252,11 @@ program
       remediation: "Define appropriate remediation steps"
     };
     
-    const invariantsPath = path.join('.arcvision', 'invariants.json');
-    if (!fs.existsSync(invariantsPath)) {
-      console.log(chalk.red('❌ ArcVision not initialized. Run "arcvision-guard setup" first.'));
-      process.exit(1);
-    }
-    
-    const invariants = JSON.parse(fs.readFileSync(invariantsPath, 'utf8'));
-    invariants.project_specific_invariants.push(invariant);
-    
-    fs.writeFileSync(invariantsPath, JSON.stringify(invariants, null, 2));
-    console.log(chalk.green(`✅ Added invariant: ${name}`));
+    // Note: Invariants are now automatically detected by scanning and stored in arcvision.context.json
+    console.log(chalk.red('❌ Custom invariants are now managed differently.'));
+    console.log(chalk.yellow('💡 Run "arcvision scan" to auto-detect invariants from your codebase.'));
+    console.log(chalk.yellow('💡 Or manually edit the invariants section in arcvision_context/arcvision.context.json if needed.'));
+    process.exit(1);
   });
 
 // Helper functions

package/src/core/artifact-manager.js

@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+
+class ArtifactManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    // Remove .arcvision directory as invariants should be in main context file only
+    this.requiredDirs = ['arcvision_context'];
+    this.requiredFiles = {
+      context: 'arcvision_context/arcvision.context.json',
+      ledger: 'arcvision_context/architecture.authority.ledger.json'
+      // Remove invariants from separate file as they should be in main context per schema
+    };
+  }
+
+  /**
+   * Ensures all required artifacts exist with proper structure
+   */
+  ensureArtifacts() {
+    // Create required directories
+    this.createDirectories();
+    
+    // Create required files with defaults if missing
+    this.createMissingFiles();
+    
+    // Validate artifact integrity (excluding context file which is created by scanner)
+    this.validateArtifactsExceptContext();
+  }
+
+  /**
+   * Creates required directories if they don't exist
+   */
+  createDirectories() {
+    this.requiredDirs.forEach(dir => {
+      const fullPath = path.join(this.projectRoot, dir);
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        this.logCreation(dir);
+      }
+    });
+  }
+
+  /**
+   * Creates missing files with default content
+   */
+  createMissingFiles() {
+    // Create default ledger if missing
+    const ledgerPath = path.join(this.projectRoot, this.requiredFiles.ledger);
+    if (!fs.existsSync(ledgerPath)) {
+      const defaultLedger = {
+        schema_version: '1.0',
+        system_id: path.basename(this.projectRoot),
+        created_at: new Date().toISOString(),
+        ledger: []
+      };
+      
+      fs.writeFileSync(ledgerPath, JSON.stringify(defaultLedger, null, 2));
+      this.logCreation(this.requiredFiles.ledger);
+    }
+  }
+
+  /**
+   * Validates that all required artifacts exist and are accessible
+   */
+  validateArtifacts() {
+    const missingArtifacts = [];
+    
+    Object.entries(this.requiredFiles).forEach(([name, relativePath]) => {
+      const fullPath = path.join(this.projectRoot, relativePath);
+      if (!fs.existsSync(fullPath)) {
+        missingArtifacts.push(relativePath);
+      }
+    });
+
+    if (missingArtifacts.length > 0) {
+      throw new Error(`Missing required artifacts: ${missingArtifacts.join(', ')}`);
+    }
+  }
+
+  /**
+   * Validates artifacts except context file (which is created by scanner)
+   */
+  validateArtifactsExceptContext() {
+    const missingArtifacts = [];
+    
+    Object.entries(this.requiredFiles).forEach(([name, relativePath]) => {
+      // Skip context file validation as it's created by scanner
+      if (name === 'context') return;
+      
+      const fullPath = path.join(this.projectRoot, relativePath);
+      if (!fs.existsSync(fullPath)) {
+        missingArtifacts.push(relativePath);
+      }
+    });
+
+    if (missingArtifacts.length > 0) {
+      throw new Error(`Missing required artifacts: ${missingArtifacts.join(', ')}`);
+    }
+  }
+
+  /**
+   * Checks if artifacts exist
+   */
+  artifactsExist() {
+    try {
+      this.validateArtifacts();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Gets the path for a specific artifact
+   */
+  getArtifactPath(artifactName) {
+    if (this.requiredFiles[artifactName]) {
+      return path.join(this.projectRoot, this.requiredFiles[artifactName]);
+    }
+    throw new Error(`Unknown artifact: ${artifactName}`);
+  }
+
+  /**
+   * Logs artifact creation
+   */
+  logCreation(artifact) {
+    console.log(`📁 Created required artifact: ${artifact}`);
+  }
+}
+
+module.exports = { ArtifactManager };

package/src/core/command-base.js

@@ -0,0 +1,107 @@
+const path = require('path');
+
+class ArcVisionCommand {
+  constructor(options) {
+    this.options = options || {};
+    this.projectRoot = options.projectRoot || '.';
+    this.operation = options.operation || 'unknown';
+    
+    // Initialize core components
+    const { ArtifactManager } = require('./artifact-manager');
+    const { ErrorHandler } = require('./error-handler');
+    const { ConfigValidator } = require('./config-validator');
+    const { FeatureManager } = require('./feature-manager');
+    const { FeedbackGenerator } = require('./feedback-generator');
+    
+    this.artifactManager = new ArtifactManager(this.projectRoot);
+    this.errorHandler = ErrorHandler;
+    this.validator = ConfigValidator;
+    this.featureManager = FeatureManager;
+    this.feedbackGenerator = FeedbackGenerator;
+  }
+  
+  /**
+   * Execute the command with standardized flow
+   */
+  async execute() {
+    try {
+      // Pre-execution validation
+      await this.validate();
+      
+      // Ensure required artifacts exist
+      this.artifactManager.ensureArtifacts();
+      
+      // Execute command-specific logic
+      const result = await this.run();
+      
+      // Generate feedback based on result
+      const feedback = this.generateFeedback(result);
+      
+      // Return comprehensive result
+      return {
+        success: true,
+        result,
+        feedback,
+        operation: this.operation
+      };
+      
+    } catch (error) {
+      // Handle error with standardized approach
+      return this.errorHandler.handle(error, this.operation);
+    }
+  }
+  
+  /**
+   * Validate command-specific requirements
+   */
+  async validate() {
+    // Command-specific validation - to be implemented by subclasses
+    throw new Error('Must implement validate() method');
+  }
+  
+  /**
+   * Execute command-specific logic
+   */
+  async run() {
+    // Command-specific execution - to be implemented by subclasses
+    throw new Error('Must implement run() method');
+  }
+  
+  /**
+   * Generate command-specific feedback
+   */
+  generateFeedback(result) {
+    // Command-specific feedback generation - to be implemented by subclasses
+    throw new Error('Must implement generateFeedback() method');
+  }
+  
+  /**
+   * Get current feature availability
+   */
+  getAvailableFeatures() {
+    return this.featureManager.getAvailableFeatures(this.projectRoot);
+  }
+  
+  /**
+   * Get recommendations for this project
+   */
+  getRecommendations() {
+    return this.featureManager.getRecommendations(this.projectRoot);
+  }
+  
+  /**
+   * Get next steps for this project
+   */
+  getNextSteps() {
+    return this.featureManager.getNextSteps(this.projectRoot);
+  }
+  
+  /**
+   * Generate user report
+   */
+  generateUserReport() {
+    return this.featureManager.generateUserReport(this.projectRoot);
+  }
+}
+
+module.exports = { ArcVisionCommand };

package/src/core/config-validator.js

@@ -0,0 +1,192 @@
+const fs = require('fs');
+const path = require('path');
+
+class ConfigValidator {
+  /**
+   * Validates that the project has the required ArcVision artifacts
+   */
+  static validateProjectStructure(projectPath) {
+    const requiredPaths = [
+      path.join(projectPath, 'arcvision_context')
+      // Removed .arcvision as invariants are now stored in main context file
+    ];
+    
+    const optionalPaths = [
+      path.join(projectPath, 'arcvision_context', 'arcvision.context.json'),
+      // Removed .arcvision/invariants.json as invariants are now stored in main context file
+      path.join(projectPath, 'arcvision_context', 'architecture.authority.ledger.json')
+    ];
+    
+    const validation = {
+      isValid: true,
+      errors: [],
+      warnings: [],
+      requiredPaths: {},
+      optionalPaths: {}
+    };
+    
+    // Validate required paths exist
+    requiredPaths.forEach(requiredPath => {
+      const exists = fs.existsSync(requiredPath);
+      validation.requiredPaths[requiredPath] = exists;
+      if (!exists) {
+        validation.isValid = false;
+        validation.errors.push(`Required path does not exist: ${requiredPath}`);
+      }
+    });
+    
+    // Check optional paths
+    optionalPaths.forEach(optionalPath => {
+      const exists = fs.existsSync(optionalPath);
+      validation.optionalPaths[optionalPath] = exists;
+      if (!exists) {
+        validation.warnings.push(`Optional path does not exist: ${optionalPath}`);
+      }
+    });
+    
+    return validation;
+  }
+
+  /**
+   * Validates invariant file structure
+   */
+  static validateInvariantsFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return {
+        isValid: false,
+        error: 'File does not exist'
+      };
+    }
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const data = JSON.parse(content);
+      
+      const validation = {
+        isValid: true,
+        errors: []
+      };
+      
+      // Check for required structure
+      if (!data.project_specific_invariants) {
+        validation.isValid = false;
+        validation.errors.push('Missing project_specific_invariants array');
+      } else if (!Array.isArray(data.project_specific_invariants)) {
+        validation.isValid = false;
+        validation.errors.push('project_specific_invariants must be an array');
+      } else {
+        // Validate each invariant
+        data.project_specific_invariants.forEach((invariant, index) => {
+          if (!invariant.id) {
+            validation.errors.push(`Invariant at index ${index} missing id`);
+          }
+          if (!invariant.system) {
+            validation.errors.push(`Invariant at index ${index} missing system`);
+          }
+          if (!invariant.description) {
+            validation.errors.push(`Invariant at index ${index} missing description`);
+          }
+          if (!invariant.severity || !['block', 'risk'].includes(invariant.severity)) {
+            validation.errors.push(`Invariant at index ${index} has invalid severity (must be 'block' or 'risk')`);
+          }
+          if (!invariant.scope) {
+            validation.errors.push(`Invariant at index ${index} missing scope`);
+          }
+          if (!invariant.rule) {
+            validation.errors.push(`Invariant at index ${index} missing rule`);
+          }
+        });
+      }
+      
+      if (validation.errors.length > 0) {
+        validation.isValid = false;
+      }
+      
+      return validation;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `Invalid JSON: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Validates context file structure
+   */
+  static validateContextFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return {
+        isValid: false,
+        error: 'File does not exist'
+      };
+    }
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const data = JSON.parse(content);
+      
+      const validation = {
+        isValid: true,
+        errors: []
+      };
+      
+      // Basic structure validation
+      if (!data.schema_version) {
+        validation.errors.push('Missing schema_version');
+      }
+      if (!data.nodes) {
+        validation.errors.push('Missing nodes array');
+      }
+      if (!Array.isArray(data.nodes)) {
+        validation.errors.push('nodes must be an array');
+      }
+      if (!data.edges) {
+        validation.errors.push('Missing edges array');
+      }
+      if (!Array.isArray(data.edges)) {
+        validation.errors.push('edges must be an array');
+      }
+      
+      if (validation.errors.length > 0) {
+        validation.isValid = false;
+      }
+      
+      return validation;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `Invalid JSON: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Validates the entire ArcVision configuration
+   */
+  static validateConfiguration(projectPath) {
+    const projectValidation = this.validateProjectStructure(projectPath);
+    
+    const configValidation = {
+      projectStructure: projectValidation,
+      invariantsFile: null,
+      contextFile: null,
+      isValid: projectValidation.isValid
+    };
+    
+    // No longer validating separate invariants file as they are stored in main context file
+    
+    // Validate context file if it exists
+    const contextPath = path.join(projectPath, 'arcvision_context', 'arcvision.context.json');
+    if (fs.existsSync(contextPath)) {
+      configValidation.contextFile = this.validateContextFile(contextPath);
+      if (!configValidation.contextFile.isValid) {
+        configValidation.isValid = false;
+      }
+    }
+    
+    return configValidation;
+  }
+}
+
+module.exports = { ConfigValidator };

package/src/core/context_builder.js

@@ -190,8 +190,9 @@ function buildContext(fileNodes, edges, symbols, options = {}) {
         structural_hubs: options.structuralHubs || [],
         architectural_boundaries: options.architecturalBoundaries || {},
         structural_invariants: options.structuralInvariants || [],
-        // Include detected invariants from the current scan
-        invariants: options.detectedInvariants || [],
+        // Include detected invariants from the current scan - these should conform to the schema specification
+        invariants: Array.isArray(options.autoDetectedInvariants) ? options.autoDetectedInvariants : 
+                   Array.isArray(options.detectedInvariants) ? options.detectedInvariants : [],
         // Include invariant analysis results
         invariant_analysis: options.invariantAnalysis || null,
         // Include architectural health assessment