arcvision 0.2.24 → 0.2.25

package/package.json

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

package/src/core/context_builder.js

@@ -191,8 +191,9 @@ function buildContext(fileNodes, edges, symbols, options = {}) {
         architectural_boundaries: options.architecturalBoundaries || {},
         structural_invariants: options.structuralInvariants || [],
         // 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 : [],
+        invariants: Array.isArray(options.autoDetectedInvariants) && options.autoDetectedInvariants.length > 0 ? options.autoDetectedInvariants : 
+                   Array.isArray(options.detectedInvariants) && options.detectedInvariants.length > 0 ? options.detectedInvariants : 
+                   [],
         // Include invariant analysis results
         invariant_analysis: options.invariantAnalysis || null,
         // Include architectural health assessment

package/src/core/scanner.js

@@ -133,6 +133,65 @@ async function scan(directory) {
             directory
         );
         
+        // Load existing invariants from arcvision.context.json (primary source)
+        const fs = require('fs');
+        const contextPath = path.join(directory, 'arcvision_context', 'arcvision.context.json');
+        let existingInvariants = [];
+        
+        if (fs.existsSync(contextPath)) {
+            try {
+                const contextContent = fs.readFileSync(contextPath, 'utf8');
+                const contextData = JSON.parse(contextContent);
+                if (contextData.invariants && Array.isArray(contextData.invariants)) {
+                    existingInvariants = contextData.invariants;
+                    console.log(`\n💾 Loaded ${existingInvariants.length} existing invariants from arcvision.context.json`);
+                }
+            } catch (error) {
+                console.warn(`⚠️  Could not load existing invariants from context: ${error.message}`);
+            }
+        }
+        
+        // Also check legacy .arcvision/invariants.json for backward compatibility
+        const legacyInvariantsPath = path.join(directory, '.arcvision', 'invariants.json');
+        if (fs.existsSync(legacyInvariantsPath)) {
+            try {
+                const legacyContent = fs.readFileSync(legacyInvariantsPath, 'utf8');
+                const legacyData = JSON.parse(legacyContent);
+                let legacyInvariants = [];
+                if (Array.isArray(legacyData)) {
+                    legacyInvariants = legacyData;
+                } else if (legacyData.project_specific_invariants && Array.isArray(legacyData.project_specific_invariants)) {
+                    legacyInvariants = legacyData.project_specific_invariants;
+                }
+                
+                if (legacyInvariants.length > 0) {
+                    console.log(`\n💾 Loaded ${legacyInvariants.length} legacy invariants from .arcvision/invariants.json`);
+                    // Merge with existing invariants, avoiding duplicates
+                    const existingIds = new Set(existingInvariants.map(inv => inv.id));
+                    for (const legacyInv of legacyInvariants) {
+                        if (!existingIds.has(legacyInv.id)) {
+                            existingInvariants.push(legacyInv);
+                            existingIds.add(legacyInv.id);
+                        }
+                    }
+                }
+            } catch (error) {
+                console.warn(`⚠️  Could not load legacy invariants: ${error.message}`);
+            }
+        }
+        
+        // Combine detected invariants with existing ones, avoiding duplicates
+        const allInvariants = [...detectedInvariants];
+        const existingIds = new Set(detectedInvariants.map(inv => inv.id));
+        for (const existingInv of existingInvariants) {
+            if (!existingIds.has(existingInv.id)) {
+                allInvariants.push(existingInv);
+                existingIds.add(existingInv.id);
+            }
+        }
+        
+        console.log(`📊 Total invariants to embed in context: ${allInvariants.length}`);
+        
         // Only analyze if we found invariants
         let invariantAnalysis = null;
         let architecturalHealth = null;
@@ -210,6 +269,10 @@ async function scan(directory) {
         // Prepare context options without archetype initially
         const { archetype: originalArchetype, ...otherContextOptions } = contextOptions;
         
+        // Update the combined invariants in otherContextOptions before creating finalContextOptions
+        otherContextOptions.autoDetectedInvariants = allInvariants;
+        otherContextOptions.detectedInvariants = allInvariants;
+        
         const finalContextOptions = {
             directory: directory,
             projectName: path.basename(directory),
@@ -268,6 +331,24 @@ async function scan(directory) {
         // Deterministic sort for consistent hashing/snapshots
         const sortedContext = sortContext(context);
 
+        // Ensure authority ledger is created in the arcvision_context directory
+        const arcvisionDir = path.join(directory, 'arcvision_context');
+        if (!fs.existsSync(arcvisionDir)) {
+            fs.mkdirSync(arcvisionDir, { recursive: true });
+            console.log('📁 Created arcvision_context directory');
+        }
+        
+        // Initialize authority ledger in the correct location
+        const { AuthorityLedger } = require('./authority-ledger');
+        const ledgerPath = path.join(arcvisionDir, 'architecture.authority.ledger.json');
+        const authorityLedger = new AuthorityLedger(ledgerPath);
+        
+        // Ensure ledger file exists
+        if (!fs.existsSync(ledgerPath)) {
+            authorityLedger.initialize();
+            console.log('📝 Created architecture.authority.ledger.json');
+        }
+
         console.log('   ✅ Context Verified & Ready');
 
         return sortedContext;

package/src/index.js

@@ -721,11 +721,45 @@ program
             console.log(chalk.green(`✅ Loaded ${loadedInvariants.length} auto-detected invariants from context file`));
             loadSuccess = loadedInvariants.length > 0;
           } else {
-            console.log(chalk.yellow('No auto-detected invariants found in context file'));
+            console.log(chalk.yellow('No auto-detected invariants found in context file'));        
+            // Check if invariants exist in the legacy location and migrate them to context
+            if (fs.existsSync(invariantsFile)) {
+              console.log(chalk.blue(`Found legacy invariants file at: ${invariantsFile}`));
+              const legacyInvariants = JSON.parse(fs.readFileSync(invariantsFile, 'utf8'));
+              if (Array.isArray(legacyInvariants)) {
+                for (const invariant of legacyInvariants) {
+                  if (invariantRegistry.register(invariant)) {
+                    loadedInvariants.push(invariant);
+                  }
+                }
+                console.log(chalk.green(`✅ Loaded ${legacyInvariants.length} invariants from legacy file`));
+                loadSuccess = loadedInvariants.length > 0;
+              }
+            }
           }
         } catch (contextError) {
           console.log(chalk.yellow(`⚠️  Could not load invariants from context file: ${contextError.message}`));
         }
+      } else {
+        console.log(chalk.yellow(`⚠️  Context file not found: ${contextFilePath}`));
+        // Try to load from legacy location if context file doesn't exist
+        if (fs.existsSync(invariantsFile)) {
+          console.log(chalk.blue(`Attempting to load invariants from legacy location: ${invariantsFile}`));
+          try {
+            const legacyInvariants = JSON.parse(fs.readFileSync(invariantsFile, 'utf8'));
+            if (Array.isArray(legacyInvariants)) {
+              for (const invariant of legacyInvariants) {
+                if (invariantRegistry.register(invariant)) {
+                  loadedInvariants.push(invariant);
+                }
+              }
+              console.log(chalk.green(`✅ Loaded ${legacyInvariants.length} invariants from legacy file`));
+              loadSuccess = loadedInvariants.length > 0;
+            }
+          } catch (legacyError) {
+            console.log(chalk.yellow(`⚠️  Could not load invariants from legacy file: ${legacyError.message}`));
+          }
+        }
       }
 
       // Then, try to load project-specific invariants from the separate file (for backward compatibility)