arcvision 0.2.14 → 0.2.16

package/src/core/dependency-manager.js

@@ -0,0 +1,134 @@
+/**
+ * Third-party Dependency Manager
+ * Provides resilient error handling for external dependencies
+ */
+
+class DependencyManager {
+  constructor() {
+    this.cache = new Map();
+    this.failedImports = new Set();
+  }
+
+  /**
+   * Safely import a module with fallbacks
+   */
+  safeImport(moduleName, fallbackValue = null, options = {}) {
+    const cacheKey = `${moduleName}_${!!options.useCache}`;
+    
+    // Return cached value if available and caching is enabled
+    if (options.useCache && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    
+    // Skip if module previously failed to import
+    if (this.failedImports.has(moduleName)) {
+      return fallbackValue;
+    }
+    
+    try {
+      const module = require(moduleName);
+      
+      // Cache successful imports
+      if (options.useCache) {
+        this.cache.set(cacheKey, module);
+      }
+      
+      return module;
+    } catch (error) {
+      console.warn(`⚠️  Failed to import module "${moduleName}":`, error.message);
+      
+      // Mark as failed to avoid repeated attempts
+      this.failedImports.add(moduleName);
+      
+      return fallbackValue;
+    }
+  }
+
+  /**
+   * Execute a function with dependency fallbacks
+   */
+  withDependency(moduleName, executor, fallbackExecutor, options = {}) {
+    const module = this.safeImport(moduleName, null, options);
+    
+    if (module) {
+      try {
+        return executor(module);
+      } catch (error) {
+        console.warn(`⚠️  Error executing with ${moduleName}:`, error.message);
+        if (fallbackExecutor) {
+          return fallbackExecutor(error);
+        }
+      }
+    } else {
+      if (fallbackExecutor) {
+        return fallbackExecutor(new Error(`Module ${moduleName} not available`));
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Async version of withDependency
+   */
+  async withDependencyAsync(moduleName, executor, fallbackExecutor, options = {}) {
+    const module = this.safeImport(moduleName, null, options);
+    
+    if (module) {
+      try {
+        return await executor(module);
+      } catch (error) {
+        console.warn(`⚠️  Error executing with ${moduleName}:`, error.message);
+        if (fallbackExecutor) {
+          return await fallbackExecutor(error);
+        }
+      }
+    } else {
+      if (fallbackExecutor) {
+        return await fallbackExecutor(new Error(`Module ${moduleName} not available`));
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Safe method call with fallback
+   */
+  safeCall(obj, methodName, args = [], fallbackValue = null) {
+    if (!obj || typeof obj[methodName] !== 'function') {
+      return fallbackValue;
+    }
+    
+    try {
+      return obj[methodName](...args);
+    } catch (error) {
+      console.warn(`⚠️  Error calling ${methodName}:`, error.message);
+      return fallbackValue;
+    }
+  }
+
+  /**
+   * Clear caches (for testing or refresh)
+   */
+  clearCache() {
+    this.cache.clear();
+    this.failedImports.clear();
+  }
+
+  /**
+   * Get diagnostic information
+   */
+  getDiagnostics() {
+    return {
+      cachedModules: Array.from(this.cache.keys()),
+      failedImports: Array.from(this.failedImports),
+      cacheSize: this.cache.size
+    };
+  }
+}
+
+// Singleton instance
+const dependencyManager = new DependencyManager();
+
+module.exports = { DependencyManager, dependencyManager };

package/src/core/di-detector.js

@@ -0,0 +1,202 @@
+/**
+ * Dependency Injection Detector
+ * 
+ * Detects various dependency injection patterns including:
+ * - Constructor injection
+ * - React Context usage (useContext, Provider, Consumer)
+ * - Custom hook dependencies
+ * - Service locator patterns
+ */
+
+const traverse = require('@babel/traverse').default;
+
+/**
+ * Detect constructor injection patterns
+ * @param {Object} ast - Babel AST
+ * @returns {Array} Array of constructor injection dependencies
+ */
+function detectConstructorInjection(ast) {
+    const injections = [];
+
+    traverse(ast, {
+        ClassDeclaration(path) {
+            const className = path.node.id ? path.node.id.name : 'Anonymous';
+
+            // Find constructor
+            const constructor = path.node.body.body.find(
+                member => member.kind === 'constructor'
+            );
+
+            if (constructor && constructor.params) {
+                constructor.params.forEach(param => {
+                    let paramName = null;
+                    let paramType = null;
+
+                    // Handle TypeScript parameter properties
+                    if (param.type === 'TSParameterProperty') {
+                        if (param.parameter.type === 'Identifier') {
+                            paramName = param.parameter.name;
+                            if (param.parameter.typeAnnotation) {
+                                paramType = extractTypeName(param.parameter.typeAnnotation);
+                            }
+                        }
+                    } else if (param.type === 'Identifier') {
+                        paramName = param.name;
+                        if (param.typeAnnotation) {
+                            paramType = extractTypeName(param.typeAnnotation);
+                        }
+                    }
+
+                    if (paramName) {
+                        injections.push({
+                            className,
+                            paramName,
+                            paramType,
+                            pattern: 'constructor_injection',
+                            loc: constructor.loc
+                        });
+                    }
+                });
+            }
+        }
+    });
+
+    return injections;
+}
+
+/**
+ * Detect React Context usage patterns
+ * @param {Object} ast - Babel AST
+ * @returns {Array} Array of context dependencies
+ */
+function detectReactContextUsage(ast) {
+    const contextUsages = [];
+
+    traverse(ast, {
+        // Detect useContext hook calls
+        CallExpression(path) {
+            if (path.node.callee.name === 'useContext' && path.node.arguments.length > 0) {
+                const contextArg = path.node.arguments[0];
+                let contextName = null;
+
+                if (contextArg.type === 'Identifier') {
+                    contextName = contextArg.name;
+                } else if (contextArg.type === 'MemberExpression') {
+                    contextName = extractMemberExpressionName(contextArg);
+                }
+
+                if (contextName) {
+                    contextUsages.push({
+                        type: 'useContext',
+                        contextName,
+                        pattern: 'context_consumer',
+                        loc: path.node.loc
+                    });
+                }
+            }
+        },
+
+        // Detect Context.Provider usage in JSX
+        JSXElement(path) {
+            const openingElement = path.node.openingElement;
+            if (openingElement.name.type === 'JSXMemberExpression') {
+                const objectName = openingElement.name.object.name;
+                const propertyName = openingElement.name.property.name;
+
+                if (propertyName === 'Provider' || propertyName === 'Consumer') {
+                    contextUsages.push({
+                        type: 'JSXProvider',
+                        contextName: objectName,
+                        pattern: propertyName === 'Provider' ? 'context_provider' : 'context_consumer',
+                        loc: path.node.loc
+                    });
+                }
+            }
+        }
+    });
+
+    return contextUsages;
+}
+
+/**
+ * Detect custom hook dependencies
+ * @param {Object} ast - Babel AST
+ * @returns {Array} Array of hook dependencies
+ */
+function detectHookDependencies(ast) {
+    const hookDeps = [];
+
+    traverse(ast, {
+        CallExpression(path) {
+            const calleeName = path.node.callee.name;
+
+            // Check if it's a custom hook (starts with 'use')
+            if (calleeName && calleeName.startsWith('use') && calleeName !== 'useContext') {
+                hookDeps.push({
+                    hookName: calleeName,
+                    pattern: 'custom_hook',
+                    loc: path.node.loc
+                });
+            }
+        }
+    });
+
+    return hookDeps;
+}
+
+/**
+ * Detect all DI patterns in a file
+ * @param {Object} ast - Babel AST
+ * @returns {Object} All detected DI patterns
+ */
+function detectDependencyInjection(ast) {
+    if (!ast) {
+        return {
+            constructorInjections: [],
+            contextUsages: [],
+            hookDependencies: []
+        };
+    }
+
+    return {
+        constructorInjections: detectConstructorInjection(ast),
+        contextUsages: detectReactContextUsage(ast),
+        hookDependencies: detectHookDependencies(ast)
+    };
+}
+
+/**
+ * Helper: Extract type name from TypeScript type annotation
+ */
+function extractTypeName(typeAnnotation) {
+    if (!typeAnnotation) return null;
+
+    const annotation = typeAnnotation.typeAnnotation || typeAnnotation;
+
+    if (annotation.type === 'TSTypeReference' && annotation.typeName) {
+        if (annotation.typeName.type === 'Identifier') {
+            return annotation.typeName.name;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Helper: Extract name from member expression
+ */
+function extractMemberExpressionName(node) {
+    if (node.type === 'MemberExpression') {
+        const object = node.object.name || '';
+        const property = node.property.name || '';
+        return object + '.' + property;
+    }
+    return null;
+}
+
+module.exports = {
+    detectConstructorInjection,
+    detectReactContextUsage,
+    detectHookDependencies,
+    detectDependencyInjection
+};

package/src/core/diff-analyzer.js

@@ -0,0 +1,76 @@
+/**
+ * Compare two context artifacts and generate a structural diff summary
+ * @param {Object} oldContext - Previous context artifact
+ * @param {Object} newContext - New context artifact
+ * @returns {Object} Diff summary with node/edge/role changes
+ */
+function generateDiffSummary(oldContext, newContext) {
+    const diffSummary = {
+        nodes_added: 0,
+        nodes_removed: 0,
+        edges_added: 0,
+        edges_removed: 0,
+        roles_changed: 0,
+        blast_radius_changes: 0
+    };
+    
+    // Compare nodes
+    const oldNodeMap = new Map(oldContext.nodes.map(node => [node.path, node]));
+    const newNodeMap = new Map(newContext.nodes.map(node => [node.path, node]));
+    
+    // Count added and removed nodes
+    for (const [path, node] of newNodeMap) {
+        if (!oldNodeMap.has(path)) {
+            diffSummary.nodes_added++;
+        }
+    }
+    
+    for (const [path, node] of oldNodeMap) {
+        if (!newNodeMap.has(path)) {
+            diffSummary.nodes_removed++;
+        }
+    }
+    
+    // Compare edges
+    const oldEdgeMap = new Map(
+        oldContext.edges.map(edge => [`${edge.from}::${edge.to}::${edge.relation}`, edge])
+    );
+    const newEdgeMap = new Map(
+        newContext.edges.map(edge => [`${edge.from}::${edge.to}::${edge.relation}`, edge])
+    );
+    
+    // Count added and removed edges
+    for (const [key, edge] of newEdgeMap) {
+        if (!oldEdgeMap.has(key)) {
+            diffSummary.edges_added++;
+        }
+    }
+    
+    for (const [key, edge] of oldEdgeMap) {
+        if (!newEdgeMap.has(key)) {
+            diffSummary.edges_removed++;
+        }
+    }
+    
+    // Compare roles
+    for (const newNode of newContext.nodes) {
+        const oldNode = oldNodeMap.get(newNode.path);
+        if (oldNode && oldNode.role !== newNode.role) {
+            diffSummary.roles_changed++;
+        }
+    }
+    
+    // Compare blast radius values
+    for (const newNode of newContext.nodes) {
+        const oldNode = oldNodeMap.get(newNode.path);
+        if (oldNode && oldNode.blast_radius !== newNode.blast_radius) {
+            diffSummary.blast_radius_changes++;
+        }
+    }
+    
+    return {
+        diff_summary: diffSummary
+    };
+}
+
+module.exports = { generateDiffSummary };

package/src/core/example-invariants.js

@@ -0,0 +1,135 @@
+/**
+ * Example Invariants - Demonstrates the invariant system
+ * These represent realistic architectural constraints for ArcVision
+ */
+
+const { invariantRegistry } = require('./invariant-registry');
+
+// Example 1: Critical Path Invariant - Context Schema Validation
+// Ensures that all context objects conform to the defined schema
+const CONTEXT_SCHEMA_INVARIANT = {
+  id: 'context-schema-conformance',
+  description: 'All context objects must conform to the defined schema to ensure predictable system behavior',
+  scope: 'system',
+  critical_path: true,  // Violating this could cause unpredictable behavior across the system
+  assertion: function(context) {
+    // Check that context has required top-level properties
+    if (!context || typeof context !== 'object') {
+      return false;
+    }
+    
+    // Check for required schema properties
+    const requiredProps = ['nodes', 'edges', 'metadata'];
+    return requiredProps.every(prop => context.hasOwnProperty(prop));
+  },
+  on_violation: function(violationEvent) {
+    console.error('Context schema violation detected - this will affect system reliability');
+    // Could log to monitoring system, send alerts, etc.
+  }
+};
+
+// Example 2: Boundary Invariant - File Path Resolution
+// Ensures file paths are properly resolved and don't escape allowed boundaries
+const FILE_PATH_BOUNDARY_INVARIANT = {
+  id: 'file-path-boundary',
+  description: 'File paths must be properly resolved and not escape the project boundary',
+  scope: 'boundary',
+  critical_path: true,  // Security risk if violated
+  assertion: function(context) {
+    if (!context.filePath) return true;
+    
+    const path = context.filePath;
+    const normalizedPath = require('path').normalize(path);
+    
+    // Ensure path doesn't escape project root (no ../.. patterns leading outside)
+    return !normalizedPath.includes('..') || 
+           !normalizedPath.startsWith('../') || 
+           !normalizedPath.startsWith('..\\');
+  },
+  on_violation: function(violationEvent) {
+    console.error('Potential security violation: File path escapes allowed boundary');
+  }
+};
+
+// Example 3: Module Invariant - Dependency Consistency
+// Ensures that when a module declares dependencies, they exist in the system
+const DEPENDENCY_CONSISTENCY_INVARIANT = {
+  id: 'dependency-consistency',
+  description: 'Module dependencies must exist in the system to maintain integrity',
+  scope: 'module',
+  critical_path: false,  // Non-critical but important for maintainability
+  assertion: function(context) {
+    if (!context.dependencies || !Array.isArray(context.dependencies)) {
+      return true; // Nothing to validate
+    }
+    
+    if (!context.availableModules || !Array.isArray(context.availableModules)) {
+      return true; // Can't validate without available modules
+    }
+    
+    // Check that all declared dependencies exist in available modules
+    return context.dependencies.every(dep => 
+      context.availableModules.some(module => module.name === dep.name)
+    );
+  },
+  on_violation: function(violationEvent) {
+    console.warn('Detected missing dependencies:', violationEvent.context.dependencies);
+  }
+};
+
+// Example 4: System Invariant - Parser State Integrity
+// Ensures parser state maintains consistency during processing
+const PARSER_STATE_INTEGRITY_INVARIANT = {
+  id: 'parser-state-integrity',
+  description: 'Parser state must maintain consistency during AST processing to prevent corruption',
+  scope: 'system',
+  critical_path: true,  // Parser corruption affects the entire system
+  assertion: function(context) {
+    // Check that parser state is valid
+    if (!context.parserState) return true;
+    
+    // Ensure parser state has required properties
+    const requiredStateProps = ['currentFile', 'dependencies', 'ast'];
+    const hasRequiredProps = requiredStateProps.every(prop => 
+      context.parserState.hasOwnProperty(prop)
+    );
+    
+    if (!hasRequiredProps) return false;
+    
+    // Ensure current file is valid
+    if (context.parserState.currentFile && 
+        (typeof context.parserState.currentFile !== 'string' || 
+         context.parserState.currentFile.trim() === '')) {
+      return false;
+    }
+    
+    // Ensure dependencies is an array
+    if (!Array.isArray(context.parserState.dependencies)) {
+      return false;
+    }
+    
+    return true;
+  },
+  on_violation: function(violationEvent) {
+    console.error('Parser state corruption detected - stopping processing to prevent system damage');
+  }
+};
+
+// Register all example invariants
+function registerExampleInvariants() {
+  invariantRegistry.register(CONTEXT_SCHEMA_INVARIANT);
+  invariantRegistry.register(FILE_PATH_BOUNDARY_INVARIANT);
+  invariantRegistry.register(DEPENDENCY_CONSISTENCY_INVARIANT);
+  invariantRegistry.register(PARSER_STATE_INTEGRITY_INVARIANT);
+  
+  console.log(`${invariantRegistry.getAll().length} invariants registered successfully`);
+}
+
+// Export individual invariants and registration function
+module.exports = {
+  CONTEXT_SCHEMA_INVARIANT,
+  FILE_PATH_BOUNDARY_INVARIANT,
+  DEPENDENCY_CONSISTENCY_INVARIANT,
+  PARSER_STATE_INTEGRITY_INVARIANT,
+  registerExampleInvariants
+};