arcvision 0.2.12 → 0.2.15

package/src/core/method-tracker.js

@@ -0,0 +1,170 @@
+/**
+ * Method Call Tracker
+ * 
+ * Tracks method and function calls to build a call graph.
+ * This helps identify which files actually USE functions from other files,
+ * not just import them.
+ */
+
+const traverse = require('@babel/traverse').default;
+
+/**
+ * Track all method and function calls in an AST
+ * @param {Object} ast - Babel AST
+ * @param {Array} imports - Import metadata from parser
+ * @returns {Object} Method call metadata
+ */
+function trackMethodCalls(ast, imports = []) {
+    const functionCalls = [];
+    const methodCalls = [];
+    const constructorCalls = [];
+
+    if (!ast) {
+        return { functionCalls, methodCalls, constructorCalls };
+    }
+
+    // Build a map of imported symbols for quick lookup
+    const importedSymbols = new Set();
+    imports.forEach(imp => {
+        if (imp.specifiers && Array.isArray(imp.specifiers)) {
+            imp.specifiers.forEach(spec => {
+                const localName = spec.local || spec.imported || spec;
+                if (typeof localName === 'string') {
+                    importedSymbols.add(localName);
+                }
+            });
+        }
+    });
+
+    traverse(ast, {
+        CallExpression(path) {
+            const callee = path.node.callee;
+
+            // Simple function call: functionName()
+            if (callee.type === 'Identifier') {
+                const functionName = callee.name;
+
+                // Track all identifier calls - let CallResolver handle resolution
+                functionCalls.push({
+                    name: functionName,
+                    type: 'function_call',
+                    loc: path.node.loc
+                });
+            }
+
+            // Method call: object.method()
+            else if (callee.type === 'MemberExpression') {
+                const objectName = extractObjectName(callee.object);
+                const methodName = callee.property.name || callee.property.value;
+
+                if (objectName && methodName) {
+                    methodCalls.push({
+                        object: objectName,
+                        method: methodName,
+                        type: 'method_call',
+                        loc: path.node.loc
+                    });
+                }
+            }
+        },
+
+        // Track constructor calls: new ClassName()
+        NewExpression(path) {
+            const callee = path.node.callee;
+
+            if (callee.type === 'Identifier') {
+                const className = callee.name;
+
+                // Track all constructor calls
+                constructorCalls.push({
+                    className,
+                    type: 'constructor_call',
+                    loc: path.node.loc
+                });
+            }
+        }
+    });
+
+    return {
+        functionCalls,
+        methodCalls,
+        constructorCalls
+    };
+}
+
+/**
+ * Build a call graph from all nodes
+ * @param {Array} nodes - All scanned file nodes with metadata
+ * @returns {Array} Call graph edges
+ */
+function buildCallGraph(nodes) {
+    const callEdges = [];
+
+    nodes.forEach(node => {
+        const filePath = node.id;
+        const metadata = node.metadata;
+
+        if (!metadata) return;
+
+        // Create edges for function calls
+        if (metadata.functionCalls && Array.isArray(metadata.functionCalls)) {
+            metadata.functionCalls.forEach(call => {
+                // We'll need to resolve which file this function comes from
+                // This is done in the semantic analyzer
+                callEdges.push({
+                    source: filePath,
+                    callType: 'function',
+                    calledSymbol: call.name,
+                    loc: call.loc
+                });
+            });
+        }
+
+        // Create edges for constructor calls
+        if (metadata.constructorCalls && Array.isArray(metadata.constructorCalls)) {
+            metadata.constructorCalls.forEach(call => {
+                callEdges.push({
+                    source: filePath,
+                    callType: 'constructor',
+                    calledSymbol: call.className,
+                    loc: call.loc
+                });
+            });
+        }
+
+        // Create edges for method calls
+        if (metadata.methodCalls && Array.isArray(metadata.methodCalls)) {
+            metadata.methodCalls.forEach(call => {
+                callEdges.push({
+                    source: filePath,
+                    callType: 'method',
+                    calledSymbol: `${call.object}.${call.method}`,
+                    loc: call.loc
+                });
+            });
+        }
+    });
+
+    return callEdges;
+}
+
+/**
+ * Helper: Extract object name from various node types
+ */
+function extractObjectName(node) {
+    if (node.type === 'Identifier') {
+        return node.name;
+    } else if (node.type === 'ThisExpression') {
+        return 'this';
+    } else if (node.type === 'MemberExpression') {
+        const object = extractObjectName(node.object);
+        const property = node.property.name || node.property.value;
+        return object && property ? `${object}.${property}` : object;
+    }
+    return null;
+}
+
+module.exports = {
+    trackMethodCalls,
+    buildCallGraph
+};

package/src/core/override-handler.js

@@ -0,0 +1,304 @@
+/**
+ * Override Handler - Controlled bypass mechanism for Authoritative Gate
+ * Implements explicit override with permanent trace requirements
+ */
+
+const { authorityLedger } = require('./authority-ledger');
+const { invariantRegistry } = require('./invariant-registry');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+class OverrideHandler {
+  constructor() {
+    this.overrideHistory = new Map(); // In-memory cache of recent overrides
+  }
+
+  /**
+   * Process override request for a blocked evaluation
+   */
+  async processOverride(options) {
+    const { eventId, reason, owner, commit, branch } = options;
+
+    // Validate required parameters
+    if (!eventId) {
+      throw new Error('Event ID is required for override');
+    }
+
+    const minReasonLength = parseInt(process.env.OVERRIDE_MIN_REASON_LENGTH) || 10;
+    if (!reason || reason.trim().length < minReasonLength) {
+      throw new Error(`Reason must be at least ${minReasonLength} characters long`);
+    }
+
+    if (!owner || owner.trim().length === 0) {
+      throw new Error('Owner is required for override');
+    }
+
+    try {
+      // Verify the event exists and was BLOCKED
+      const ledger = authorityLedger.readLedger();
+      const blockedEvent = ledger.ledger.find(e => 
+        e.event_id === eventId && e.decision === 'BLOCKED'
+      );
+
+      if (!blockedEvent) {
+        throw new Error(`No BLOCKED event found with ID: ${eventId}`);
+      }
+
+      // Check if already overridden
+      const isAlreadyOverridden = ledger.ledger.some(e => 
+        e.decision === 'OVERRIDDEN' && 
+        e.original_blocked_event === eventId
+      );
+
+      if (isAlreadyOverridden) {
+        throw new Error(`Event ${eventId} has already been overridden`);
+      }
+
+      // Record the override in authority ledger
+      const overrideEventId = authorityLedger.recordOverride(
+        eventId, 
+        reason.trim(), 
+        owner.trim(), 
+        { commit, branch, author: owner.trim() }
+      );
+
+      // Store in memory cache for immediate access
+      this.overrideHistory.set(eventId, {
+        overrideEventId,
+        reason: reason.trim(),
+        owner: owner.trim(),
+        timestamp: new Date().toISOString(),
+        commit,
+        branch
+      });
+
+      console.log(chalk.green('✅ Override recorded successfully'));
+      console.log(chalk.green(`📝 Override ID: ${overrideEventId}`));
+      console.log(chalk.yellow(`⚠️  Permanent scar created for commit: ${commit || 'unknown'}`));
+      
+      return {
+        success: true,
+        overrideEventId,
+        blockedEventId: eventId,
+        reason: reason.trim(),
+        owner: owner.trim()
+      };
+
+    } catch (error) {
+      console.error(chalk.red('❌ Override failed:'), error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if an evaluation can be overridden
+   */
+  canOverride(evaluation, context = {}) {
+    // Only BLOCKED decisions can be overridden
+    if (evaluation.decision !== 'BLOCKED') {
+      return {
+        allowed: false,
+        reason: `Cannot override ${evaluation.decision} decisions`
+      };
+    }
+
+    // Must have violations to override
+    if (!evaluation.violations || evaluation.violations.length === 0) {
+      return {
+        allowed: false,
+        reason: 'No violations to override'
+      };
+    }
+
+    return {
+      allowed: true,
+      violations: evaluation.violations
+    };
+  }
+
+  /**
+   * Generate override instructions for BLOCKED evaluation
+   */
+  generateOverrideInstructions(evaluation, eventId, context = {}) {
+    const instructions = [
+      chalk.red.bold('\n🚨 CHANGE BLOCKED - Architectural Risk Detected'),
+      chalk.red('=' .repeat(60)),
+      '',
+      chalk.red('The following invariants were violated:'),
+      ...evaluation.violations.map((violation, index) => 
+        chalk.red(`${index + 1}. ${violation.description}`)
+      ),
+      '',
+      chalk.yellow('To override this BLOCKED decision, run:'),
+      chalk.cyan(process.env.OVERRIDE_COMMAND_FORMAT || `arcvision override --event-id ${eventId}`),
+      chalk.cyan(process.env.OVERRIDE_REASON_PLACEHOLDER || '  --reason "<detailed explanation>"'),
+      chalk.cyan(process.env.OVERRIDE_OWNER_PLACEHOLDER || '  --owner "<responsible person>"'),
+      '',
+      chalk.yellow(process.env.OVERRIDE_REQUIREMENTS_HEADER || 'Requirements:'),
+      chalk.yellow(process.env.OVERRIDE_REASON_REQUIREMENT || `• Reason must be detailed (minimum ${minReasonLength} characters)`),
+      chalk.yellow(process.env.OVERRIDE_OWNER_REQUIREMENT || '• Owner must be identified'),
+      chalk.yellow(process.env.OVERRIDE_RECORDING_REQUIREMENT || '• Override is permanently recorded'),
+      chalk.yellow(process.env.OVERRIDE_FUTURE_SCRUTINY || '• Future violations will face increased scrutiny'),
+      '',
+      chalk.red('⚠️  WARNING: This creates a permanent architectural scar')
+    ];
+
+    return instructions.join('\n');
+  }
+
+  /**
+   * Apply override to convert BLOCKED to ALLOWED
+   */
+  applyOverride(evaluation, overrideInfo) {
+    if (evaluation.decision !== 'BLOCKED') {
+      return evaluation;
+    }
+
+    // Convert to ALLOWED with override annotation
+    return {
+      ...evaluation,
+      decision: 'ALLOWED',
+      overrideApplied: true,
+      overrideInfo: {
+        eventId: overrideInfo.blockedEventId,
+        overrideEventId: overrideInfo.overrideEventId,
+        reason: overrideInfo.reason,
+        owner: overrideInfo.owner,
+        timestamp: new Date().toISOString()
+      },
+      reasons: [
+        ...evaluation.reasons,
+        `OVERRIDE APPLIED: ${overrideInfo.reason}`,
+        `Override owner: ${overrideInfo.owner}`
+      ]
+    };
+  }
+
+  /**
+   * Get override history for a commit
+   */
+  getOverrideHistory(commitHash) {
+    try {
+      const events = authorityLedger.getEventsForCommit(commitHash);
+      const overrides = events.filter(e => e.decision === 'OVERRIDDEN');
+      
+      return overrides.map(override => ({
+        eventId: override.event_id,
+        timestamp: override.timestamp,
+        owner: override.override.owner,
+        reason: override.override.reason,
+        originalEventId: override.original_blocked_event
+      }));
+    } catch (error) {
+      console.warn('Could not retrieve override history:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Check if current context has recent overrides (increased scrutiny)
+   */
+  hasRecentOverrides(limitDays = 30) {
+    try {
+      const ledger = authorityLedger.readLedger();
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - limitDays);
+      
+      const recentOverrides = ledger.ledger.filter(event => {
+        if (event.decision !== 'OVERRIDDEN') return false;
+        const eventDate = new Date(event.timestamp);
+        return eventDate >= cutoffDate;
+      });
+      
+      return recentOverrides.length > 0;
+    } catch (error) {
+      console.warn('Could not check recent overrides:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Generate override report
+   */
+  generateOverrideReport(format = 'summary') {
+    try {
+      const ledger = authorityLedger.readLedger();
+      const overrides = ledger.ledger.filter(e => e.decision === 'OVERRIDDEN');
+      
+      switch (format) {
+        case 'summary':
+          return this.generateSummaryReport(overrides, ledger);
+        case 'detailed':
+          return this.generateDetailedReport(overrides, ledger);
+        default:
+          throw new Error(`Unsupported report format: ${format}`);
+      }
+    } catch (error) {
+      console.error('Failed to generate override report:', error.message);
+      throw error;
+    }
+  }
+
+  generateSummaryReport(overrides, ledger) {
+    const blockedEvents = ledger.ledger.filter(e => e.decision === 'BLOCKED');
+    const uniqueCommits = [...new Set(overrides.map(o => o.commit))];
+    
+    return {
+      total_overrides: overrides.length,
+      total_blocked_events: blockedEvents.length,
+      unique_commits_with_overrides: uniqueCommits.length,
+      most_common_owner: this.getMostCommonValue(overrides, 'author'),
+      recent_overrides: overrides.slice(-5).map(o => ({
+        commit: o.commit,
+        owner: o.author,
+        reason: o.override.reason.substring(0, 50) + '...'
+      }))
+    };
+  }
+
+  generateDetailedReport(overrides, ledger) {
+    return {
+      report_generated: new Date().toISOString(),
+      statistics: this.generateSummaryReport(overrides, ledger),
+      all_overrides: overrides.map(override => ({
+        event_id: override.event_id,
+        timestamp: override.timestamp,
+        commit: override.commit,
+        owner: override.author,
+        reason: override.override.reason,
+        original_violations: this.getOriginalViolations(override.original_blocked_event, ledger)
+      }))
+    };
+  }
+
+  getMostCommonValue(array, key) {
+    const counts = {};
+    array.forEach(item => {
+      const value = item[key];
+      counts[value] = (counts[value] || 0) + 1;
+    });
+    
+    let maxCount = 0;
+    let mostCommon = null;
+    
+    for (const [value, count] of Object.entries(counts)) {
+      if (count > maxCount) {
+        maxCount = count;
+        mostCommon = value;
+      }
+    }
+    
+    return mostCommon;
+  }
+
+  getOriginalViolations(eventId, ledger) {
+    const blockedEvent = ledger.ledger.find(e => e.event_id === eventId);
+    return blockedEvent?.violations || [];
+  }
+}
+
+// Export singleton instance
+const overrideHandler = new OverrideHandler();
+
+module.exports = { OverrideHandler, overrideHandler };

package/src/core/ownership-resolver.js

@@ -0,0 +1,227 @@
+/**
+ * Ownership Resolver - Resolves ownership of system concepts
+ * Establishes single source of truth for each concept in the system
+ */
+
+class OwnershipResolver {
+  constructor() {
+    this.ownershipMap = {};
+  }
+
+  /**
+   * Resolve ownership for concepts in the architecture map
+   * @param {Object} architectureMap - The architecture map with nodes and edges
+   * @returns {Object} Ownership map showing source of truth, derivations, and consumers
+   */
+  resolveOwnership(architectureMap) {
+    const { nodes, edges } = architectureMap;
+    this.ownershipMap = {};
+
+    // Group nodes by concept (based on file names, roles, etc.)
+    const conceptGroups = this.groupNodesByConcept(nodes);
+
+    // For each concept group, determine ownership
+    for (const [concept, conceptNodes] of Object.entries(conceptGroups)) {
+      const ownershipInfo = this.determineOwnershipForConcept(concept, conceptNodes, edges);
+      if (ownershipInfo) {
+        this.ownershipMap[concept] = ownershipInfo;
+      }
+    }
+
+    return this.ownershipMap;
+  }
+
+  /**
+   * Group nodes by concept based on naming patterns and roles
+   */
+  groupNodesByConcept(nodes) {
+    const groups = {};
+
+    for (const node of nodes) {
+      // Extract concept from filename or path
+      const concept = this.extractConceptFromPath(node.path || node.id);
+      
+      if (!groups[concept]) {
+        groups[concept] = [];
+      }
+      
+      groups[concept].push(node);
+    }
+
+    return groups;
+  }
+
+  /**
+   * Extract concept from file path
+   */
+  extractConceptFromPath(filePath) {
+    if (!filePath) return 'unknown';
+    
+    // Remove file extension and extract base concept
+    const baseName = filePath.replace(/\.[^/.]+$/, '');
+    const parts = baseName.split(/[\/\\]/);
+    const fileName = parts[parts.length - 1];
+    
+    // Normalize common patterns
+    return fileName.toLowerCase()
+      .replace(/controller|service|handler|manager|store|provider|hook/g, '')
+      .replace(/_/g, '')
+      .replace(/-/g, '');
+  }
+
+  /**
+   * Determine ownership for a specific concept
+   */
+  determineOwnershipForConcept(concept, conceptNodes, edges) {
+    // Sort nodes by authority indicators (blast radius, criticality, etc.)
+    const sortedNodes = [...conceptNodes].sort((a, b) => {
+      const aScore = this.calculateOwnershipScore(a);
+      const bScore = this.calculateOwnershipScore(b);
+      return bScore - aScore;
+    });
+
+    if (sortedNodes.length === 0) {
+      return null;
+    }
+
+    // Pick the highest authority node as the source of truth
+    const sourceOfTruth = sortedNodes[0];
+
+    // Find derived nodes and consumers
+    const derivedNodes = [];
+    const consumers = [];
+    const invalidators = [];
+
+    // Analyze edges to determine relationships
+    for (const edge of edges) {
+      if (edge.from === sourceOfTruth.id) {
+        const targetNode = conceptNodes.find(n => n.id === edge.target);
+        if (targetNode && targetNode.id !== sourceOfTruth.id) {
+          if (edge.relation === 'imports' || edge.relation === 'depends_on') {
+            consumers.push(targetNode.path || targetNode.id);
+          } else if (edge.relation === 'calls') {
+            consumers.push(targetNode.path || targetNode.id);
+          }
+        }
+      }
+
+      // Check if other nodes modify the source of truth
+      if (edge.to === sourceOfTruth.id && edge.relation === 'calls') {
+        const sourceNode = conceptNodes.find(n => n.id === edge.from);
+        if (sourceNode && sourceNode.id !== sourceOfTruth.id) {
+          invalidators.push(sourceNode.path || sourceNode.id);
+        }
+      }
+    }
+
+    // Find derived nodes based on analysis
+    for (const node of conceptNodes) {
+      if (node.id !== sourceOfTruth.id) {
+        const derived = this.isDerivedNode(node, sourceOfTruth, edges);
+        if (derived) {
+          derivedNodes.push(node.path || node.id);
+        }
+      }
+    }
+
+    // Enhance with additional ownership analysis
+    const enhancedOwnership = {
+      source_of_truth: sourceOfTruth.path || sourceOfTruth.id,
+      derived_in: derivedNodes,
+      consumers: [...new Set(consumers)], // Remove duplicates
+      invalidators: [...new Set(invalidators)] // Remove duplicates
+    };
+
+    // Add additional ownership indicators
+    enhancedOwnership.ownership_strength = this.calculateOwnershipStrength(sourceOfTruth, conceptNodes);
+    enhancedOwnership.confidence = this.calculateOwnershipConfidence(enhancedOwnership);
+
+    return enhancedOwnership;
+  }
+
+  /**
+   * Calculate ownership strength for a node
+   */
+  calculateOwnershipStrength(sourceNode, allNodes) {
+    const signals = sourceNode.signals || {};
+    const intelligence = sourceNode.intelligence || {};
+
+    // Calculate based on various factors
+    return {
+      blast_radius_factor: (signals.blast_radius || 0) / 10,
+      criticality_factor: (signals.criticality || 0) / 10,
+      incoming_deps_factor: (signals.incoming_deps || 0) / 5,
+      function_count: intelligence.functions ? intelligence.functions.length : 0,
+      export_count: intelligence.exports ? intelligence.exports.length : 0,
+      total_score: this.calculateOwnershipScore(sourceNode)
+    };
+  }
+
+  /**
+   * Calculate confidence in ownership assignment
+   */
+  calculateOwnershipConfidence(ownershipInfo) {
+    // Base confidence on the strength of the source of truth
+    let confidence = 0.7; // Base confidence
+
+    // Increase confidence based on number of consumers
+    if (ownershipInfo.consumers && ownershipInfo.consumers.length > 0) {
+      confidence += Math.min(ownershipInfo.consumers.length * 0.05, 0.2);
+    }
+
+    // Increase confidence based on presence of invalidators
+    if (ownershipInfo.invalidators && ownershipInfo.invalidators.length > 0) {
+      confidence += Math.min(ownershipInfo.invalidators.length * 0.05, 0.15);
+    }
+
+    // Increase confidence based on derived nodes
+    if (ownershipInfo.derived_in && ownershipInfo.derived_in.length > 0) {
+      confidence += Math.min(ownershipInfo.derived_in.length * 0.03, 0.1);
+    }
+
+    // Cap confidence at 0.95
+    return Math.min(confidence, 0.95);
+  }
+
+  /**
+   * Calculate ownership score for a node
+   */
+  calculateOwnershipScore(node) {
+    const signals = node.signals || {};
+    const intelligence = node.intelligence || {};
+
+    // Factors that contribute to ownership:
+    // - High blast radius indicates wide influence
+    // - High criticality indicates importance
+    // - Many incoming deps indicate central role
+    // - Functions/exports indicate active role
+    return (
+      (signals.blast_radius || 0) * 2 +
+      (signals.criticality || 0) * 1.5 +
+      (signals.incoming_deps || 0) * 0.5 +
+      (intelligence.functions ? intelligence.functions.length : 0) * 0.3 +
+      (intelligence.exports ? intelligence.exports.length : 0) * 0.2
+    );
+  }
+
+  /**
+   * Determine if a node is derived from another
+   */
+  isDerivedNode(node, sourceOfTruth, edges) {
+    // Check if this node imports from or depends on the source of truth
+    const hasImportEdge = edges.some(edge => 
+      edge.to === node.id && edge.from === sourceOfTruth.id &&
+      (edge.relation === 'imports' || edge.relation === 'depends_on')
+    );
+
+    // Check if this node uses data from the source of truth
+    const hasCallEdge = edges.some(edge => 
+      edge.to === node.id && edge.from === sourceOfTruth.id &&
+      edge.relation === 'calls'
+    );
+
+    return hasImportEdge || hasCallEdge;
+  }
+}
+
+module.exports = { OwnershipResolver };