arcvision 0.2.26 → 0.2.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcvision",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "ArcVision CLI - Architectural Governance and Invariant Detection Tool",
   "main": "src/index.js",
   "bin": {

package/src/core/artifact-manager.js

@@ -33,9 +33,22 @@ class ArtifactManager {
   createDirectories() {
     this.requiredDirs.forEach(dir => {
       const fullPath = path.join(this.projectRoot, dir);
-      if (!fs.existsSync(fullPath)) {
-        fs.mkdirSync(fullPath, { recursive: true });
-        this.logCreation(dir);
+      try {
+        if (!fs.existsSync(fullPath)) {
+          fs.mkdirSync(fullPath, { recursive: true });
+          this.logCreation(dir);
+          // Verify directory was created
+          if (fs.existsSync(fullPath)) {
+            console.log(`✅ Verified directory creation: ${fullPath}`);
+          } else {
+            console.warn(`⚠️  Directory may not have been created: ${fullPath}`);
+          }
+        } else {
+          console.log(`✅ Directory already exists: ${fullPath}`);
+        }
+      } catch (error) {
+        console.error(`❌ Failed to create directory ${fullPath}: ${error.message}`);
+        throw error;
       }
     });
   }
@@ -46,16 +59,32 @@ class ArtifactManager {
   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);
+    try {
+      if (!fs.existsSync(ledgerPath)) {
+        console.log(`🔍 Creating ledger file: ${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);
+        
+        // Verify file was created
+        if (fs.existsSync(ledgerPath)) {
+          const stats = fs.statSync(ledgerPath);
+          console.log(`✅ Verified ledger file creation: ${ledgerPath} (${stats.size} bytes)`);
+        } else {
+          console.warn(`⚠️  Ledger file may not have been created: ${ledgerPath}`);
+        }
+      } else {
+        console.log(`✅ Ledger file already exists: ${ledgerPath}`);
+      }
+    } catch (error) {
+      console.error(`❌ Failed to create ledger file ${ledgerPath}: ${error.message}`);
+      throw error;
     }
   }
 

package/src/core/failure-mode-synthesizer.js

@@ -68,21 +68,35 @@ class FailureModeSynthesizer {
   }
 
   /**
-   * Get default symptom for an invariant
+   * Get default symptom for an invariant based on its statement
    */
   getDefaultSymptom(invariant) {
-    if (invariant.statement.toLowerCase().includes('availability')) {
-      return 'UI does not update';
-    } else if (invariant.statement.toLowerCase().includes('state')) {
-      return 'Stale data presented to user';
-    } else if (invariant.statement.toLowerCase().includes('sync') || 
-               invariant.statement.toLowerCase().includes('synchronize')) {
+    if (!invariant) {
+      return 'System behavior deviates from expected requirements';
+    }
+    
+    // Handle cases where invariant might have description but no statement
+    const statementText = invariant.statement || invariant.description || invariant.id || '';
+    if (!statementText) {
+      return 'System behavior deviates from expected requirements';
+    }
+
+    // Ensure we have a string before calling toLowerCase
+    const statementStr = String(statementText);
+    const statement = statementStr.toLowerCase();
+
+    if (statement.includes('availability')) {
+      return 'UI does not update or service unreachable';
+    } else if (statement.includes('state')) {
+      return 'Stale or inconsistent data presented to user';
+    } else if (statement.includes('sync') || statement.includes('synchronize')) {
       return 'Data inconsistency between components';
-    } else if (invariant.statement.toLowerCase().includes('permission') ||
-               invariant.statement.toLowerCase().includes('auth')) {
+    } else if (statement.includes('permission') || statement.includes('auth')) {
       return 'Unauthorized access or denied permissions';
+    } else if (statement.includes('performance') || statement.includes('latency')) {
+      return 'System response time exceeds threshold';
     } else {
-      return 'Unexpected behavior or incorrect output';
+      return 'Unexpected behavior or incorrect logical output';
     }
   }
 
@@ -90,17 +104,34 @@ class FailureModeSynthesizer {
    * Get blast radius for an invariant based on related nodes
    */
   getInvariantBlastRadius(invariant, architectureMap) {
+    if (!invariant) {
+      return ['unknown'];
+    }
+    
+    // Handle cases where invariant might have description but no statement
+    const statementText = invariant.statement || invariant.description || invariant.id || '';
+    if (!statementText) {
+      return ['unknown'];
+    }
+    
     const { nodes } = architectureMap;
     const blastRadius = [];
+    // Ensure we have a string before calling toLowerCase
+    const statementStr = String(statementText);
+    const statement = statementStr.toLowerCase();
 
     // Look for nodes that are related to the invariant
     for (const node of nodes) {
-      if (node.path && invariant.statement.toLowerCase().includes(node.path.toLowerCase())) {
-        blastRadius.push(node.path);
-      }
-      
-      if (node.id && invariant.statement.toLowerCase().includes(node.id.toLowerCase())) {
-        blastRadius.push(node.id);
+      try {
+        if (node.path && statement.includes(node.path.toLowerCase())) {
+          blastRadius.push(node.path);
+        }
+
+        if (node.id && statement.includes(node.id.toLowerCase())) {
+          blastRadius.push(node.id);
+        }
+      } catch (e) {
+        // Ignore errors
       }
     }
 
@@ -229,16 +260,19 @@ class FailureModeSynthesizer {
    */
   isRelevantToInvariant(source, invariant) {
     // Check if the source location is mentioned in the invariant
-    if (invariant.owner && source.location && 
-        invariant.owner.toLowerCase().includes(source.location.toLowerCase())) {
+    if (invariant.owner && source.location &&
+      invariant.owner.toLowerCase().includes(source.location.toLowerCase())) {
       return true;
     }
 
-    // Check if the invariant statement mentions similar concepts
-    if (invariant.statement && source.location) {
-      const invariantWords = invariant.statement.toLowerCase().split(/\W+/);
+    // Check if the invariant statement/description mentions similar concepts
+    const statementText = invariant.statement || invariant.description || invariant.id || '';
+    if (statementText && source.location) {
+      // Ensure we have a string before calling toLowerCase
+      const statementStr = String(statementText);
+      const invariantWords = statementStr.toLowerCase().split(/\W+/);
       const locationWords = source.location.toLowerCase().split(/[\/\\.-_]+/);
-      
+
       // Check for overlapping terms
       for (const word of invariantWords) {
         if (word.length > 3 && locationWords.includes(word)) {
@@ -254,16 +288,25 @@ class FailureModeSynthesizer {
    * Predict symptoms based on invariant and trigger
    */
   predictSymptom(invariant, trigger) {
+    // Handle cases where invariant might have description but no statement
+    const statementText = invariant.statement || invariant.description || invariant.id || '';
+    if (!statementText) {
+      return 'Unexpected behavior or incorrect output';
+    }
+    
+    // Ensure we have a string before calling toLowerCase
+    const statementStr = String(statementText);
+    
     // Default symptom prediction based on invariant type
-    if (invariant.statement.toLowerCase().includes('availability')) {
+    if (statementStr.toLowerCase().includes('availability')) {
       return 'UI does not update';
-    } else if (invariant.statement.toLowerCase().includes('state')) {
+    } else if (statementStr.toLowerCase().includes('state')) {
       return 'Stale data presented to user';
-    } else if (invariant.statement.toLowerCase().includes('sync') || 
-               invariant.statement.toLowerCase().includes('synchronize')) {
+    } else if (statementStr.toLowerCase().includes('sync') ||
+      statementStr.toLowerCase().includes('synchronize')) {
       return 'Data inconsistency between components';
-    } else if (invariant.statement.toLowerCase().includes('permission') ||
-               invariant.statement.toLowerCase().includes('auth')) {
+    } else if (statementStr.toLowerCase().includes('permission') ||
+      statementStr.toLowerCase().includes('auth')) {
       return 'Unauthorized access or denied permissions';
     } else {
       return 'Unexpected behavior or incorrect output';
@@ -325,16 +368,16 @@ class FailureModeSynthesizer {
    */
   containsMutationPattern(func) {
     if (!func.name) return false;
-    
+
     const name = func.name.toLowerCase();
-    return name.includes('set') || 
-           name.includes('update') || 
-           name.includes('modify') || 
-           name.includes('change') || 
-           name.includes('mutate') ||
-           name.includes('assign') ||
-           name.includes('put') ||
-           name.includes('post');
+    return name.includes('set') ||
+      name.includes('update') ||
+      name.includes('modify') ||
+      name.includes('change') ||
+      name.includes('mutate') ||
+      name.includes('assign') ||
+      name.includes('put') ||
+      name.includes('post');
   }
 }
 

package/src/core/invariant-detector.js

@@ -23,18 +23,45 @@ class InvariantDetector {
     this.detectedInvariants = [];
 
     try {
+      // Validate inputs
+      if (!scanResult || !scanResult.nodes || !scanResult.edges) {
+        console.warn('⚠️  Invalid scan result provided to invariant detector');
+        return [];
+      }
+
+      console.log('\n🔍 Starting Invariant Detection Analysis');
+      console.log(`   Analyzing ${scanResult.nodes.length} nodes and ${scanResult.edges.length} relationships`);
+      
       // Analyze the structural context for potential invariants
       await this.analyzeNodesForInvariants(scanResult.nodes, directory);
       await this.analyzeEdgesForInvariants(scanResult.edges);
       await this.analyzeCodeFilesForInvariants(directory);
       await this.analyzeStructuralPatterns(scanResult.nodes, scanResult.edges, directory);
 
+      // Filter out any invariants without proper statements
+      this.detectedInvariants = this.detectedInvariants.filter(inv => {
+        if (!inv.statement || inv.statement.trim() === '') {
+          console.warn(`⚠️  Removing invariant ${inv.id} due to missing statement`);
+          return false;
+        }
+        return true;
+      });
+
       console.log(`\n🛡️  Invariant Detection Complete`);
       console.log(`   Found ${this.detectedInvariants.length} potential system invariants`);
+      
+      // Log summary of invariant types
+      const typeCounts = {};
+      this.detectedInvariants.forEach(inv => {
+        const type = inv.system || 'unknown';
+        typeCounts[type] = (typeCounts[type] || 0) + 1;
+      });
+      console.log(`   Types: ${JSON.stringify(typeCounts)}`);
 
       return this.detectedInvariants;
     } catch (error) {
       console.error('Invariant detection failed:', error.message);
+      console.error('Stack trace:', error.stack);
       return [];
     }
   }
@@ -63,7 +90,7 @@ class InvariantDetector {
             this.detectedInvariants.push({
               id: invariantId,
               system: 'automatic',
-              statement: invariant.description,
+              statement: invariant.description || `Invariant detected in ${nodeId}`,  // Ensure statement exists
               description: invariant.description,
               scope: { files: [nodeId] },
               critical_path: invariant.isCritical,
@@ -101,7 +128,7 @@ class InvariantDetector {
       this.detectedInvariants.push({
         id: this.generateInvariantId('dependency_constraint', constraint.from + '_' + constraint.to),
         system: 'automatic',
-        statement: constraint.description,
+        statement: constraint.description || `Dependency constraint from ${constraint.from} to ${constraint.to}`,  // Ensure statement exists
         description: constraint.description,
         scope: { files: [constraint.from, constraint.to] },
         critical_path: constraint.critical,
@@ -145,7 +172,7 @@ class InvariantDetector {
           this.detectedInvariants.push({
             id: this.generateInvariantId(pattern.type, relativePath, i),
             system: 'automatic',
-            statement: `System invariant implemented in ${relativePath}: ${pattern.description}`,
+            statement: `System invariant implemented in ${relativePath}: ${pattern.description}` || `Pattern-based invariant in ${relativePath}`,  // Ensure statement exists
             description: `System invariant implemented in ${relativePath}: ${pattern.description}`,
             scope: { files: [relativePath] },
             critical_path: true,  // File specifically for invariants is likely critical
@@ -191,10 +218,13 @@ class InvariantDetector {
     for (const pattern of validationPatterns) {
       const matches = content.match(pattern);
       if (matches) {
+        const matchCount = matches.length;
+        const patternName = pattern.source.replace(/\\/g, '').replace(/function\s+/, '');
         invariants.push({
           pattern: pattern.source,
-          description: `Validation function pattern found in ${filePath}: ${matches.length} matches`,
-          isCritical: true
+          description: `Validation function pattern found in ${filePath}: ${matchCount} matches`,
+          isCritical: true,
+          position: content.indexOf(matches[0])
         });
       }
     }
@@ -214,7 +244,8 @@ class InvariantDetector {
         invariants.push({
           pattern: pattern.source,
           description: `Constraint enforcement pattern found in ${filePath}`,
-          isCritical: false
+          isCritical: false,
+          position: match.index
         });
       }
     }
@@ -236,7 +267,8 @@ class InvariantDetector {
         invariants.push({
           pattern: pattern.source,
           description: `State transition constraint pattern found in ${filePath}`,
-          isCritical: true
+          isCritical: true,
+          position: match.index
         });
       }
     }
@@ -259,7 +291,8 @@ class InvariantDetector {
         invariants.push({
           pattern: pattern.source,
           description: `Boundary enforcement pattern found in ${filePath}`,
-          isCritical: true
+          isCritical: true,
+          position: match.index
         });
       }
     }
@@ -676,7 +709,7 @@ class InvariantDetector {
         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`,
+          statement: `Layer dependency rule: ${fromLayer} components should not depend on ${toLayer} components` || `Architectural layer constraint: ${fromLayer} -> ${toLayer}`,  // Ensure statement exists
           description: `Prevent ${fromLayer} layer from depending on ${toLayer} layer to maintain separation of concerns`,
           scope: { files: dependencies.map(d => d.from) },
           critical_path: true,
@@ -729,7 +762,7 @@ class InvariantDetector {
           this.detectedInvariants.push({
             id: this.generateInvariantId(`hub_protection_${nodeId}`, 'high_degree'),
             system: 'architectural',
-            statement: `Protect high-degree node ${nodeId} from unauthorized modifications`,
+            statement: `Protect high-degree node ${nodeId} from unauthorized modifications` || `Hub node protection: ${nodeId}`,  // Ensure statement exists
             description: `Node ${nodeId} has ${degrees.incoming} incoming dependencies, changes here affect many components`,
             scope: { files: [nodeId] },
             critical_path: true,
@@ -781,7 +814,7 @@ class InvariantDetector {
         this.detectedInvariants.push({
           id: this.generateInvariantId(`tight_coupling_${nodeA}_${nodeB}`, 'bidirectional'),
           system: 'architectural',
-          statement: `Prevent tight coupling between ${nodeA} and ${nodeB}`,
+          statement: `Prevent tight coupling between ${nodeA} and ${nodeB}` || `Coupling constraint: ${nodeA} and ${nodeB}`,  // Ensure statement exists
           description: `Bidirectional dependency detected between ${nodeA} and ${nodeB}, indicating tight coupling`,
           scope: { files: [nodeA, nodeB] },
           critical_path: false,

package/src/core/scanner.js

@@ -181,24 +181,69 @@ async function scan(directory) {
                 existingIds.add(existingInv.id);
             }
         }
+        
+        // Ensure all invariants have statement fields as fallback
+        console.log(`🔍 Ensuring all ${allInvariants.length} invariants have statement fields...`);
+        for (let i = 0; i < allInvariants.length; i++) {
+            const inv = allInvariants[i];
+            if (!inv.statement) {
+                // Create statement from available fields
+                if (inv.description) {
+                    inv.statement = inv.description;
+                } else if (inv.id) {
+                    inv.statement = `Invariant ${inv.id}`;
+                } else {
+                    inv.statement = 'Unnamed architectural invariant';
+                }
+                console.log(`🔧 Added missing statement to invariant ${i + 1}/${allInvariants.length}: ${inv.id || 'unnamed'}`);
+            }
+        }
+        console.log('✅ All invariants now have statement fields');
 
         // Initialize components for new features
         const ownershipResolver = new OwnershipResolver();
         const failureModeSynthesizer = new FailureModeSynthesizer();
 
         // Resolve ownership
-        const ownership = ownershipResolver.resolveOwnership(
-            { nodes, edges }
-        );
+        let ownership = {};
+        try {
+            console.log('🔍 Resolving ownership...');
+            ownership = ownershipResolver.resolveOwnership(
+                { nodes, edges }
+            );
+            console.log('✅ Ownership resolved');
+        } catch (ownershipError) {
+            console.warn(`⚠️  Failed to resolve ownership: ${ownershipError.message}`);
+            console.warn('Continuing with empty ownership data...');
+            ownership = {};
+        }
 
         // Synthesize failure modes
-        const failure_modes = failureModeSynthesizer.synthesizeFailureModes(
-            { nodes, edges },
-            allInvariants
-        );
+        let failure_modes = [];
+        try {
+            console.log('🔍 Synthesizing failure modes for ${allInvariants.length} invariants...');
+            failure_modes = failureModeSynthesizer.synthesizeFailureModes(
+                { nodes, edges },
+                allInvariants
+            );
+            console.log(`✅ Generated ${failure_modes.length} failure modes`);
+        } catch (error) {
+            console.warn(`⚠️  Failed to synthesize failure modes: ${error.message}`);
+            console.warn('Continuing with empty failure modes...');
+            failure_modes = [];
+        }
 
         // Generate decision guidance
-        const decision_guidance = generateDecisionGuidance(allInvariants, failure_modes);
+        let decision_guidance = {};
+        try {
+            console.log('🔍 Generating decision guidance...');
+            decision_guidance = generateDecisionGuidance(allInvariants, failure_modes);
+            console.log('✅ Decision guidance generated');
+        } catch (error) {
+            console.warn(`⚠️  Failed to generate decision guidance: ${error.message}`);
+            console.warn('Continuing with empty decision guidance...');
+            decision_guidance = {};
+        }
 
         console.log(`📊 Total invariants to "Set" in context: ${allInvariants.length}`);
 
@@ -209,12 +254,18 @@ async function scan(directory) {
         if (allInvariants && allInvariants.length > 0) {
             // Analyze all invariants (detected + existing)
             const invariantAnalyzer = new InvariantAnalyzer();
-            invariantAnalysis = invariantAnalyzer.analyzeInvariants(allInvariants, {
-                directory,
-                projectName: path.basename(directory),
-                nodeCount: nodes.length,
-                edgeCount: edges.length
-            });
+            try {
+                invariantAnalysis = invariantAnalyzer.analyzeInvariants(allInvariants, {
+                    directory,
+                    projectName: path.basename(directory),
+                    nodeCount: nodes.length,
+                    edgeCount: edges.length
+                });
+            } catch (analysisError) {
+                console.warn(`⚠️  Failed to analyze invariants: ${analysisError.message}`);
+                console.warn('Continuing with empty invariant analysis...');
+                invariantAnalysis = null;
+            }
 
             // Assess architectural health based on all invariants
             try {
@@ -234,17 +285,31 @@ async function scan(directory) {
         } else {
             // Even if no invariants are detected, create a baseline analysis
             const invariantAnalyzer = new InvariantAnalyzer();
-            invariantAnalysis = invariantAnalyzer.analyzeInvariants([], {
-                directory,
-                projectName: path.basename(directory),
-                nodeCount: nodes.length,
-                edgeCount: edges.length
-            });
+            try {
+                invariantAnalysis = invariantAnalyzer.analyzeInvariants([], {
+                    directory,
+                    projectName: path.basename(directory),
+                    nodeCount: nodes.length,
+                    edgeCount: edges.length
+                });
+            } catch (baselineError) {
+                console.warn(`⚠️  Failed to create baseline invariant analysis: ${baselineError.message}`);
+                invariantAnalysis = null;
+            }
 
-            architecturalHealth = invariantAnalyzer.assessArchitecturalHealth([], {
-                directory,
-                projectName: path.basename(directory)
-            });
+            try {
+                architecturalHealth = invariantAnalyzer.assessArchitecturalHealth([], {
+                    directory,
+                    projectName: path.basename(directory)
+                });
+            } catch (baselineHealthError) {
+                console.warn(`⚠️  Failed to assess baseline architectural health: ${baselineHealthError.message}`);
+                architecturalHealth = {
+                    score: 0,
+                    level: 'unknown',
+                    assessment: 'Could not assess architectural health due to analysis error'
+                };
+            }
         }
 
         // --- FINAL BUILD & VALIDATION ---
@@ -343,8 +408,32 @@ async function scan(directory) {
 
         // Ensure authority ledger directory exists
         const arcvisionDir = path.join(directory, 'arcvision_context');
+        console.log(`🔍 Ensuring arcvision_context directory exists at: ${arcvisionDir}`);
         if (!fs.existsSync(arcvisionDir)) {
+            console.log('📁 Creating arcvision_context directory...');
             fs.mkdirSync(arcvisionDir, { recursive: true });
+            console.log('✅ arcvision_context directory created');
+        } else {
+            console.log('✅ arcvision_context directory already exists');
+        }
+
+        // Write context to file
+        const contextFilePath = path.join(arcvisionDir, 'arcvision.context.json');
+        console.log(`💾 Writing context to: ${contextFilePath}`);
+        try {
+            fs.writeFileSync(contextFilePath, JSON.stringify(sortedContext, null, 2));
+            console.log('✅ Context file written successfully');
+            
+            // Verify file was written
+            if (fs.existsSync(contextFilePath)) {
+                const stats = fs.statSync(contextFilePath);
+                console.log(`📊 Context file size: ${stats.size} bytes`);
+            } else {
+                console.warn('⚠️  Context file was not found after write operation');
+            }
+        } catch (writeError) {
+            console.error(`❌ Failed to write context file: ${writeError.message}`);
+            throw writeError;
         }
 
         console.log('   ✅ Context "Set" & Verified');