arcvision 0.2.12 → 0.2.15

package/src/core/chunked-uploader.js

@@ -0,0 +1,180 @@
+const chalk = require('chalk');
+const { Buffer } = require('buffer');
+
+class ChunkedUploader {
+  constructor(chunkSize = 1024 * 1024 * 4) { // 4MB default chunk size
+    this.chunkSize = chunkSize;
+  }
+
+  /**
+   * Calculate approximate byte size of a JSON object
+   */
+  calculateByteSize(obj) {
+    return Buffer.byteLength(JSON.stringify(obj));
+  }
+
+  /**
+   * Split a large JSON object into chunks
+   */
+  splitIntoChunks(data, maxChunkSize = this.chunkSize) {
+    const jsonString = JSON.stringify(data);
+    const chunks = [];
+    
+    for (let i = 0; i < jsonString.length; i += maxChunkSize) {
+      const chunk = jsonString.slice(i, i + maxChunkSize);
+      chunks.push({
+        data: chunk,
+        index: Math.floor(i / maxChunkSize),
+        totalChunks: Math.ceil(jsonString.length / maxChunkSize)
+      });
+    }
+    
+    return chunks;
+  }
+
+  /**
+   * Reconstruct data from chunks
+   */
+  reconstructFromChunks(chunks) {
+    // Sort chunks by index to ensure correct order
+    chunks.sort((a, b) => a.index - b.index);
+    const reconstructedString = chunks.map(chunk => chunk.data).join('');
+    return JSON.parse(reconstructedString);
+  }
+
+  /**
+   * Upload data in chunks to the server
+   */
+  async uploadInChunks(data, token, apiUrl) {
+    const totalSize = this.calculateByteSize(data);
+    const chunks = this.splitIntoChunks(data);
+    
+    console.log(chalk.blue(`Preparing to upload ${chunks.length} chunks (${Math.round(totalSize / 1024 / 1024)} MB total)`));
+
+    // First, initiate the chunked upload session
+    const sessionId = await this.initiateSession(chunks.length, token, apiUrl);
+    
+    if (!sessionId) {
+      throw new Error('Failed to initiate upload session');
+    }
+
+    // Upload each chunk individually
+    const uploadPromises = chunks.map(async (chunk, index) => {
+      const progress = ((index + 1) / chunks.length) * 100;
+      console.log(chalk.yellow(`Uploading chunk ${index + 1}/${chunks.length} (${Math.round(progress)}%)`));
+      
+      return this.uploadChunk(chunk, sessionId, token, apiUrl);
+    });
+
+    // Wait for all chunks to upload
+    const results = await Promise.all(uploadPromises);
+
+    // Verify all chunks were uploaded successfully
+    const allSuccessful = results.every(result => result.success);
+    
+    if (!allSuccessful) {
+      throw new Error('Some chunks failed to upload');
+    }
+
+    // Finalize the upload
+    const finalResult = await this.finalizeUpload(sessionId, token, apiUrl);
+    
+    return finalResult;
+  }
+
+  /**
+   * Initiate a chunked upload session
+   */
+  async initiateSession(totalChunks, token, apiUrl) {
+    try {
+      const response = await fetch(`${apiUrl}/api/upload/initiate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          totalChunks,
+          timestamp: Date.now()
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Session initiation failed: ${response.status}`);
+      }
+
+      const result = await response.json();
+      return result.sessionId;
+    } catch (error) {
+      console.error(chalk.red(`Failed to initiate upload session: ${error.message}`));
+      return null;
+    }
+  }
+
+  /**
+   * Upload a single chunk
+   */
+  async uploadChunk(chunk, sessionId, token, apiUrl) {
+    try {
+      const response = await fetch(`${apiUrl}/api/upload/chunk`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          sessionId,
+          chunkIndex: chunk.index,
+          chunkData: chunk.data,
+          totalChunks: chunk.totalChunks
+        })
+      });
+
+      const result = await response.json();
+      
+      if (!response.ok) {
+        console.error(chalk.red(`Chunk ${chunk.index} upload failed: ${response.status}`));
+        return { success: false, error: result.error || response.statusText };
+      }
+
+      return { success: true, chunkIndex: chunk.index };
+    } catch (error) {
+      console.error(chalk.red(`Chunk ${chunk.index} upload error: ${error.message}`));
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Finalize the chunked upload
+   */
+  async finalizeUpload(sessionId, token, apiUrl) {
+    try {
+      console.log(chalk.yellow('Finalizing upload...'));
+      
+      const response = await fetch(`${apiUrl}/api/upload/finalize`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          sessionId
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Finalization failed: ${response.status}`);
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      console.error(chalk.red(`Upload finalization failed: ${error.message}`));
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  ChunkedUploader
+};

package/src/core/circular-dependency-detector.js

@@ -0,0 +1,404 @@
+/**
+ * Enhanced Circular Dependency Detector
+ * Detects bidirectional dependencies between modules
+ * Enhanced to catch all circular dependency patterns including transitive cycles
+ */
+
+const { patternMatcher } = require('./pattern-matcher');
+
+class CircularDependencyDetector {
+  constructor() {
+    this.detectedCycles = [];
+  }
+
+  /**
+   * Detect circular dependencies in the dependency graph
+   * Enhanced to detect all types of cycles including transitive dependencies
+   * @param {Array} nodes - Array of node objects
+   * @param {Array} edges - Array of edge objects
+   * @returns {Array} Array of detected circular dependencies
+   */
+  detectCircularDependencies(nodes, edges) {
+    const cycles = [];
+    const visited = new Set();
+    const recStack = new Set();
+    const adjList = new Map();
+    
+    // Enhanced data structures for better cycle detection
+    const nodePaths = new Map();
+    const edgeWeights = new Map();
+    
+    // Build adjacency list with enhanced metadata
+    for (const edge of edges) {
+      // Handle different edge structures (could be {from, to} or {source, target})
+      const fromNode = edge.from || edge.source;
+      const toNode = edge.to || edge.target;
+      
+      if (!adjList.has(fromNode)) {
+        adjList.set(fromNode, []);
+      }
+      adjList.get(fromNode).push(toNode);
+      
+      // Store edge weights for importance scoring
+      const edgeKey = `${fromNode}-${toNode}`;
+      edgeWeights.set(edgeKey, edge.weight || 1);
+    }
+    
+    // Map node IDs to file paths
+    nodes.forEach(node => {
+      // Handle different node structures (could be {id, path} or other formats)
+      const nodeId = node.id || node.name || node.filePath;
+      const nodePath = node.path || node.filePath || node.name;
+      if (nodeId && nodePath) {
+        nodePaths.set(nodeId, nodePath);
+      }
+    });
+
+    // Enhanced DFS to detect cycles with comprehensive tracking
+    const dfs = (node, path) => {
+      if (recStack.has(node)) {
+        // Found cycle - get the cycle portion
+        const cycleStartIndex = path.indexOf(node);
+        if (cycleStartIndex !== -1) {
+          const cycleNodes = path.slice(cycleStartIndex);
+          const cycleEdges = [];
+          
+          // Calculate cycle metrics
+          let totalWeight = 0;
+          let maxLength = 0;
+          
+          for (let i = 0; i < cycleNodes.length; i++) {
+            const from = cycleNodes[i];
+            const to = cycleNodes[(i + 1) % cycleNodes.length];
+            const edgeKey = `${from}-${to}`;
+            
+            cycleEdges.push({ from, to });
+            totalWeight += edgeWeights.get(edgeKey) || 1;
+            maxLength = Math.max(maxLength, nodePaths.get(from)?.length || 0);
+          }
+          
+          cycles.push({
+            cycle: [...cycleNodes, node],
+            edges: cycleEdges,
+            length: cycleNodes.length + 1,
+            totalWeight,
+            maxLength,
+            severity: this.calculateCycleSeverity(totalWeight, cycleNodes.length)
+          });
+        }
+        return;
+      }
+
+      if (visited.has(node)) return;
+
+      visited.add(node);
+      recStack.add(node);
+      path.push(node);
+
+      const neighbors = adjList.get(node) || [];
+      for (const neighbor of neighbors) {
+        dfs(neighbor, [...path]);
+      }
+
+      recStack.delete(node);
+    };
+
+    // Run enhanced DFS from each unvisited node
+    for (const node of adjList.keys()) {
+      if (!visited.has(node)) {
+        dfs(node, []);
+      }
+    }
+
+    // Enhanced cycle reporting with detailed information
+    return cycles.map(cycle => ({
+      ...cycle,
+      fileCycle: cycle.cycle.map(nodeId => nodePaths.get(nodeId) || nodeId),
+      description: this.formatCycleDescription(cycle, nodePaths),
+      impactScore: this.calculateImpactScore(cycle, nodePaths)
+    })).sort((a, b) => b.impactScore - a.impactScore); // Sort by impact severity
+  }
+
+  /**
+   * Check if a specific forbidden dependency pattern creates a cycle
+   * @param {Object} forbiddenDep - Forbidden dependency rule
+   * @param {Array} nodes - Array of nodes
+   * @param {Array} edges - Array of edges
+   * @returns {boolean} True if circular dependency detected
+   */
+  checkForbiddenCreatesCycle(forbiddenDep, nodes, edges) {
+    // First check if the direct forbidden dependency exists
+    const directViolation = edges.some(edge => {
+      const sourcePath = this.getNodePath(edge.from, nodes);
+      const targetPath = this.getNodePath(edge.to, nodes);
+      
+      const fromMatches = patternMatcher.match(sourcePath, forbiddenDep.from, { matchBase: true });
+      const toMatches = patternMatcher.match(targetPath, forbiddenDep.to, { matchBase: true });
+      
+      return fromMatches && toMatches;
+    });
+
+    if (!directViolation) {
+      return false;
+    }
+
+    // Check if this creates a cycle
+    const cycles = this.detectCircularDependencies(nodes, edges);
+    
+    // Check if any cycle involves the forbidden dependency pattern
+    return cycles.some(cycle => {
+      return cycle.fileCycle.some((filePath, index) => {
+        const nextIndex = (index + 1) % cycle.fileCycle.length;
+        const nextFilePath = cycle.fileCycle[nextIndex];
+        
+        const fromMatches = patternMatcher.match(filePath, forbiddenDep.from, { matchBase: true });
+        const toMatches = patternMatcher.match(nextFilePath, forbiddenDep.to, { matchBase: true });
+        
+        return fromMatches && toMatches;
+      });
+    });
+  }
+
+  /**
+   * Calculate cycle severity based on weight and length
+   */
+  calculateCycleSeverity(totalWeight, cycleLength) {
+    const baseSeverity = totalWeight / cycleLength;
+    if (baseSeverity >= 3) return 'CRITICAL';
+    if (baseSeverity >= 2) return 'HIGH';
+    if (baseSeverity >= 1) return 'MEDIUM';
+    return 'LOW';
+  }
+  
+  /**
+   * Format detailed cycle description
+   */
+  formatCycleDescription(cycle, nodePaths) {
+    const fileCycle = cycle.cycle.map(nodeId => nodePaths.get(nodeId) || nodeId);
+    const cycleString = fileCycle.join(' → ');
+    
+    let description = `Circular dependency detected (${cycle.severity}): ${cycleString}`;
+    
+    if (cycle.totalWeight > cycle.length) {
+      description += ` [Weight: ${cycle.totalWeight}, Avg: ${(cycle.totalWeight/cycle.length).toFixed(2)}]`;
+    }
+    
+    return description;
+  }
+  
+  /**
+   * Calculate impact score for prioritization
+   */
+  calculateImpactScore(cycle, nodePaths) {
+    // Factors: cycle length, total weight, file path complexity, severity
+    const lengthFactor = Math.log(cycle.length + 1);
+    const weightFactor = cycle.totalWeight;
+    const severityMultiplier = {
+      'CRITICAL': 4,
+      'HIGH': 3,
+      'MEDIUM': 2,
+      'LOW': 1
+    }[cycle.severity] || 1;
+    
+    // Path complexity factor (longer paths = higher complexity)
+    const pathComplexity = cycle.cycle.reduce((sum, nodeId) => {
+      const path = nodePaths.get(nodeId) || '';
+      return sum + (path.split('/').length + path.split('\\').length) / 2;
+    }, 0) / cycle.length;
+    
+    return (lengthFactor * weightFactor * severityMultiplier * pathComplexity);
+  }
+  
+  /**
+   * Get file path for a node ID
+   */
+  getNodePath(nodeId, nodes) {
+    const node = nodes.find(n => (n.id === nodeId) || (n.name === nodeId) || (n.filePath === nodeId));
+    return node ? (node.path || node.filePath || node.name) : nodeId;
+  }
+
+  /**
+   * Check for transitive forbidden dependencies
+   */
+  checkTransitiveForbiddenDependencies(forbiddenDep, nodes, edges) {
+    const violations = [];
+    
+    // Build adjacency list for path finding
+    const adjList = new Map();
+    for (const edge of edges) {
+      if (!adjList.has(edge.from)) {
+        adjList.set(edge.from, []);
+      }
+      adjList.get(edge.from).push(edge.to);
+    }
+    
+    // Check if there's a path from forbidden 'from' to forbidden 'to' through intermediate nodes
+    const nodePaths = new Map();
+    nodes.forEach(node => nodePaths.set(node.id, node.path));
+    
+    // Find all nodes that match the 'from' pattern
+    const fromNodes = nodes.filter(node => 
+      patternMatcher.match(node.path, forbiddenDep.from, { matchBase: true })
+    );
+    
+    // Find all nodes that match the 'to' pattern
+    const toNodes = nodes.filter(node => 
+      patternMatcher.match(node.path, forbiddenDep.to, { matchBase: true })
+    );
+    
+    // Check for transitive paths
+    for (const fromNode of fromNodes) {
+      for (const toNode of toNodes) {
+        if (fromNode.id !== toNode.id) {
+          const hasPath = this.hasPath(adjList, fromNode.id, toNode.id);
+          if (hasPath) {
+            violations.push({
+              type: 'TRANSITIVE_FORBIDDEN',
+              from: nodePaths.get(fromNode.id),
+              to: nodePaths.get(toNode.id),
+              description: `Transitive forbidden dependency path: ${nodePaths.get(fromNode.id)} → ... → ${nodePaths.get(toNode.id)}`
+            });
+          }
+        }
+      }
+    }
+    
+    return violations;
+  }
+  
+  /**
+   * Check for reverse forbidden dependencies
+   */
+  checkReverseForbiddenDependencies(forbiddenDep, nodes, edges) {
+    const violations = [];
+    
+    // Check if the reverse dependency exists (to → from)
+    for (const edge of edges) {
+      const sourcePath = this.getNodePath(edge.from, nodes);
+      const targetPath = this.getNodePath(edge.to, nodes);
+      
+      const reverseFromMatches = patternMatcher.match(sourcePath, forbiddenDep.to, { matchBase: true });
+      const reverseToMatches = patternMatcher.match(targetPath, forbiddenDep.from, { matchBase: true });
+      
+      if (reverseFromMatches && reverseToMatches) {
+        violations.push({
+          type: 'REVERSE_FORBIDDEN',
+          from: sourcePath,
+          to: targetPath,
+          description: `Reverse forbidden dependency: ${sourcePath} → ${targetPath} (opposite of allowed direction)`
+        });
+      }
+    }
+    
+    return violations;
+  }
+  
+  /**
+   * Check if there's a path between two nodes
+   */
+  hasPath(adjList, start, end) {
+    if (start === end) return false;
+    
+    const visited = new Set();
+    const queue = [start];
+    
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === end) return true;
+      
+      if (visited.has(current)) continue;
+      visited.add(current);
+      
+      const neighbors = adjList.get(current) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Calculate overall severity from multiple violations
+   */
+  calculateOverallSeverity(violations) {
+    if (violations.length === 0) return 'NONE';
+    
+    const severityMap = {
+      'DIRECT_FORBIDDEN': 4,
+      'CIRCULAR_DEPENDENCY': 3,
+      'TRANSITIVE_FORBIDDEN': 2,
+      'REVERSE_FORBIDDEN': 1
+    };
+    
+    const maxSeverity = Math.max(...violations.map(v => severityMap[v.type] || 0));
+    
+    if (maxSeverity >= 4) return 'CRITICAL';
+    if (maxSeverity >= 3) return 'HIGH';
+    if (maxSeverity >= 2) return 'MEDIUM';
+    return 'LOW';
+  }
+  
+  /**
+   * Enhanced forbidden dependency checker that considers bidirectional relationships
+   * and transitive dependencies
+   */
+  checkEnhancedForbiddenDependency(forbiddenDep, nodes, edges) {
+    // Comprehensive check for all types of forbidden dependencies
+    const violations = [];
+    
+    // Check 1: Direct forbidden dependency
+    const directForbidden = edges.some(edge => {
+      const sourcePath = this.getNodePath(edge.from, nodes);
+      const targetPath = this.getNodePath(edge.to, nodes);
+      
+      const fromMatches = patternMatcher.match(sourcePath, forbiddenDep.from, { matchBase: true });
+      const toMatches = patternMatcher.match(targetPath, forbiddenDep.to, { matchBase: true });
+      
+      if (fromMatches && toMatches) {
+        violations.push({
+          type: 'DIRECT_FORBIDDEN',
+          from: sourcePath,
+          to: targetPath,
+          description: `Direct forbidden dependency: ${sourcePath} → ${targetPath}`
+        });
+        return true;
+      }
+      return false;
+    });
+
+    // Check 2: Circular dependency creation
+    const createsCycle = this.checkForbiddenCreatesCycle(forbiddenDep, nodes, edges);
+    if (createsCycle) {
+      violations.push({
+        type: 'CIRCULAR_DEPENDENCY',
+        description: `Forbidden dependency creates circular dependency involving: ${forbiddenDep.from} ↔ ${forbiddenDep.to}`
+      });
+    }
+
+    // Check 3: Transitive forbidden dependencies
+    const transitiveViolations = this.checkTransitiveForbiddenDependencies(forbiddenDep, nodes, edges);
+    violations.push(...transitiveViolations);
+
+    // Check 4: Reverse dependency violations
+    const reverseViolations = this.checkReverseForbiddenDependencies(forbiddenDep, nodes, edges);
+    violations.push(...reverseViolations);
+
+    return {
+      directForbidden,
+      createsCycle,
+      transitiveViolations: transitiveViolations.length > 0,
+      reverseViolations: reverseViolations.length > 0,
+      violated: violations.length > 0,
+      violations,
+      description: violations.length > 0 ? 
+        violations.map(v => v.description).join('; ') : 
+        null,
+      severity: this.calculateOverallSeverity(violations)
+    };
+  }
+}
+
+module.exports = { CircularDependencyDetector };