arcvision 0.2.16 → 0.2.20

package/.arcvision/logs/errors.log

@@ -0,0 +1,5 @@
+{"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)"}

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.16",
+  "version": "0.2.20",
   "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/core/artifact-manager.js

@@ -0,0 +1,143 @@
+const fs = require('fs');
+const path = require('path');
+
+class ArtifactManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.requiredDirs = ['.arcvision', 'arcvision_context'];
+    this.requiredFiles = {
+      context: 'arcvision_context/arcvision.context.json',
+      ledger: 'arcvision_context/architecture.authority.ledger.json',
+      invariants: '.arcvision/invariants.json'
+    };
+  }
+
+  /**
+   * 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 invariants file if missing
+    const invariantsPath = path.join(this.projectRoot, this.requiredFiles.invariants);
+    if (!fs.existsSync(invariantsPath)) {
+      const defaultInvariants = {
+        version: '1.0',
+        project_specific_invariants: [],
+        generated_at: new Date().toISOString()
+      };
+      
+      fs.writeFileSync(invariantsPath, JSON.stringify(defaultInvariants, null, 2));
+      this.logCreation(this.requiredFiles.invariants);
+    }
+
+    // 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,199 @@
+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'),
+      path.join(projectPath, '.arcvision')
+    ];
+    
+    const optionalPaths = [
+      path.join(projectPath, 'arcvision_context', 'arcvision.context.json'),
+      path.join(projectPath, '.arcvision', 'invariants.json'),
+      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
+    };
+    
+    // Validate invariants file if it exists
+    const invariantsPath = path.join(projectPath, '.arcvision', 'invariants.json');
+    if (fs.existsSync(invariantsPath)) {
+      configValidation.invariantsFile = this.validateInvariantsFile(invariantsPath);
+      if (!configValidation.invariantsFile.isValid) {
+        configValidation.isValid = false;
+      }
+    }
+    
+    // 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/error-handler.js

@@ -0,0 +1,106 @@
+class ArcVisionError extends Error {
+  constructor(type, message, recoveryStrategy, context) {
+    super(message);
+    this.name = 'ArcVisionError';
+    this.type = type; // FATAL, RECOVERABLE, WARNING
+    this.recoveryStrategy = recoveryStrategy; // CONTINUE, SKIP, ABORT
+    this.context = context;
+  }
+}
+
+class ErrorHandler {
+  static handle(error, operation = '') {
+    // If it's already an ArcVisionError, use its strategy
+    if (error instanceof ArcVisionError) {
+      return this.executeRecoveryStrategy(error);
+    }
+    
+    // For regular errors, classify them based on error type
+    const classifiedError = this.classifyError(error, operation);
+    return this.executeRecoveryStrategy(classifiedError);
+  }
+
+  static classifyError(error, operation) {
+    // Classify based on error type and message
+    const message = error.message || String(error);
+    
+    // Check for specific error patterns
+    if (message.includes('Cannot read properties of undefined') || 
+        message.includes('reading')) {
+      return new ArcVisionError(
+        'RECOVERABLE',
+        `Property access error during ${operation}: ${message}`,
+        'SKIP',
+        { operation, errorType: 'PROPERTY_ACCESS_ERROR' }
+      );
+    }
+    
+    if (message.includes('ENOENT') || message.includes('no such file')) {
+      return new ArcVisionError(
+        'RECOVERABLE',
+        `File not found during ${operation}: ${message}`,
+        'SKIP',
+        { operation, errorType: 'FILE_NOT_FOUND' }
+      );
+    }
+    
+    if (message.includes('EACCES') || message.includes('permission denied')) {
+      return new ArcVisionError(
+        'FATAL',
+        `Permission error during ${operation}: ${message}`,
+        'ABORT',
+        { operation, errorType: 'PERMISSION_ERROR' }
+      );
+    }
+    
+    // Default classification for unknown errors
+    return new ArcVisionError(
+      'FATAL',
+      `Unexpected error during ${operation}: ${message}`,
+      'ABORT',
+      { operation, errorType: 'UNKNOWN_ERROR', originalError: error }
+    );
+  }
+
+  static executeRecoveryStrategy(error) {
+    const strategy = error.recoveryStrategy || 'ABORT';
+    
+    switch(strategy) {
+      case 'CONTINUE':
+        console.warn(`⚠️  ${error.message}`);
+        return { 
+          success: true, 
+          result: null, 
+          error: error,
+          shouldContinue: true 
+        };
+        
+      case 'SKIP':
+        console.warn(`⏭️  Skipping due to: ${error.message}`);
+        return { 
+          success: true, 
+          result: 'skipped', 
+          error: error,
+          shouldContinue: true 
+        };
+        
+      case 'ABORT':
+      default:
+        console.error(`💥 ${error.message}`);
+        console.error(`Context:`, error.context);
+        process.exit(1);
+    }
+  }
+
+  static createError(type, message, recoveryStrategy = 'ABORT', context = {}) {
+    return new ArcVisionError(type, message, recoveryStrategy, context);
+  }
+
+  static handleAsync(promise, operation = '') {
+    return promise.catch(error => {
+      return this.handle(error, operation);
+    });
+  }
+}
+
+module.exports = { ErrorHandler, ArcVisionError };