arcvision 0.2.14 → 0.2.15

package/test_repos/risky-microservices-concerns/common/utils.js

@@ -0,0 +1,77 @@
+// Common Utilities - Growing beyond reasonable size limits
+
+// TODO: refactor this massive utility file into smaller, focused modules
+// FIXME: split authentication, validation, and formatting logic into separate files
+
+function authenticateUser(credentials) {
+  // Authentication logic
+  return credentials.username === 'admin' && credentials.password === 'password';
+}
+
+function validateEmail(email) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+function formatCurrency(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+
+function formatDate(date) {
+  return date.toISOString().split('T')[0];
+}
+
+function generateId() {
+  return Math.random().toString(36).substr(2, 9);
+}
+
+function calculateTax(amount, rate = 0.08) {
+  return amount * rate;
+}
+
+function validatePhone(phone) {
+  return /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/.test(phone);
+}
+
+function sanitizeInput(input) {
+  return input.replace(/[^a-zA-Z0-9\s]/g, '');
+}
+
+function encryptPassword(password) {
+  // Simple encryption for demo purposes
+  return Buffer.from(password).toString('base64');
+}
+
+function decryptPassword(encrypted) {
+  return Buffer.from(encrypted, 'base64').toString();
+}
+
+// More functions that make this file unwieldy...
+function complexBusinessLogic(data) {
+  // This function is getting too complex
+  // manualLoadBalancing logic should be extracted
+  return data.map(item => ({
+    ...item,
+    processed: true,
+    timestamp: new Date()
+  }));
+}
+
+function anotherUtilityFunction(param) {
+  // Yet another function making this file larger
+  return param.toUpperCase();
+}
+
+module.exports = {
+  authenticateUser,
+  validateEmail,
+  formatCurrency,
+  formatDate,
+  generateId,
+  calculateTax,
+  validatePhone,
+  sanitizeInput,
+  encryptPassword,
+  decryptPassword,
+  complexBusinessLogic,
+  anotherUtilityFunction
+};

package/test_repos/risky-microservices-concerns/gateways/apiGateway.js

@@ -0,0 +1,84 @@
+// API Gateway - Contains concerning complexity patterns
+
+const express = require('express');
+const userService = require('../services/userService');
+const orderService = require('../services/orderService');
+
+class ApiGateway {
+  constructor() {
+    this.app = express();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // Complex routing logic that should be simplified
+    // complexRoutingLogic pattern present
+    
+    this.app.get('/api/users/:id', async (req, res) => {
+      try {
+        const user = await userService.getUser(req.params.id);
+        res.json(user);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    this.app.get('/api/orders/:id', async (req, res) => {
+      try {
+        const order = await orderService.getOrder(req.params.id);
+        res.json(order);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    // Manual load balancing logic - concerning pattern
+    // manualLoadBalancing pattern present
+    this.app.post('/api/process-complex-request', async (req, res) => {
+      try {
+        // Simulating manual load balancing decisions
+        const serverInstance = this.selectServerInstance(req.body.priority);
+        const result = await this.routeToService(serverInstance, req.body);
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+  }
+
+  // Manual load balancing logic - should be handled by infrastructure
+  selectServerInstance(priority) {
+    // This manual load balancing logic is concerning
+    const instances = ['server-1', 'server-2', 'server-3'];
+    if (priority === 'high') {
+      return instances[0]; // Route high priority to first server
+    } else if (priority === 'medium') {
+      return instances[1]; // Route medium to second
+    } else {
+      return instances[2]; // Route low to third
+    }
+  }
+
+  async routeToService(instance, requestData) {
+    // Complex routing logic that mixes concerns
+    console.log(`Routing to ${instance} with data:`, requestData);
+    
+    // This kind of routing logic belongs in infrastructure, not application code
+    if (requestData.type === 'user') {
+      return await userService.getUser(requestData.id);
+    } else if (requestData.type === 'order') {
+      return await orderService.getOrder(requestData.id);
+    }
+    
+    return { error: 'Unknown request type' };
+  }
+
+  start(port = 3001) {
+    this.app.listen(port, () => {
+      console.log(`API Gateway listening on port ${port}`);
+      console.log('WARNING: Contains concerning architectural patterns');
+    });
+  }
+}
+
+module.exports = new ApiGateway();

package/test_repos/risky-microservices-concerns/index.js

@@ -0,0 +1,20 @@
+// Main Application Entry Point - Risky Microservices Architecture
+
+const apiGateway = require('./gateways/apiGateway');
+const userService = require('./services/userService');
+const orderService = require('./services/orderService');
+
+console.log('Starting Risky Microservices Architecture...');
+console.log('WARNING: This application contains concerning architectural patterns!');
+
+// Initialize services
+console.log('Initializing services...');
+console.log('Services ready with potential interdependencies');
+
+// Start the API gateway
+apiGateway.start(3001);
+
+// Health check endpoint
+setInterval(() => {
+  console.log('Health check: Services operational but with architectural concerns');
+}, 30000);

package/test_repos/risky-microservices-concerns/libs/deprecatedHelper.js

@@ -0,0 +1,36 @@
+// Deprecated Helper Library - Should not be used in new code
+
+// WARNING: This library is deprecated and should not be used
+// Kept for backward compatibility only
+
+function processUserData(userData) {
+  // Legacy processing logic
+  console.log('Using deprecated user data processor');
+  return {
+    ...userData,
+    processed: true,
+    legacyFlag: true,
+    // More legacy transformations...
+  };
+}
+
+function legacyFormatResponse(data) {
+  // Old response formatting
+  return {
+    success: true,
+    data: data,
+    timestamp: new Date().toISOString(),
+    legacyVersion: '1.0'
+  };
+}
+
+function deprecatedValidation(input) {
+  // Outdated validation logic
+  return input && input.length > 0;
+}
+
+module.exports = {
+  processUserData,
+  legacyFormatResponse,
+  deprecatedValidation
+};

package/test_repos/risky-microservices-concerns/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "risky-microservices-concerns",
+  "version": "1.0.0",
+  "description": "Microservices with concerning architectural patterns for ArcVision testing",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "author": "ArcVision Test Suite",
+  "license": "MIT"
+}

package/test_repos/risky-microservices-concerns/services/orderService.js

@@ -0,0 +1,42 @@
+// Order Service - Creates inter-service dependency cycle
+
+const userService = require('./userService'); // Creates circular dependency risk
+const commonUtils = require('../common/utils');
+
+class OrderService {
+  constructor() {
+    this.userService = userService;
+    this.utils = commonUtils;
+  }
+
+  async getOrder(orderId) {
+    // Order fetching logic
+    return { id: orderId, amount: 100, status: 'completed' };
+  }
+
+  async getUserOrders(userId) {
+    // Risky: Calling user service from order service creates tight coupling
+    const user = await this.userService.getUser(userId);
+    
+    // Complex business logic that should probably be elsewhere
+    // manualLoadBalancing logic here - triggers pattern detection
+    
+    return [
+      { id: 1, amount: 50, status: 'completed' },
+      { id: 2, amount: 150, status: 'pending' }
+    ];
+  }
+
+  async createOrder(orderData) {
+    // Order creation logic with complex routing
+    // complexRoutingLogic present - triggers pattern detection
+    
+    return {
+      id: Math.floor(Math.random() * 1000),
+      ...orderData,
+      status: 'created'
+    };
+  }
+}
+
+module.exports = new OrderService();

package/test_repos/risky-microservices-concerns/services/userService.js

@@ -0,0 +1,48 @@
+// User Service - Has concerning inter-service dependencies
+
+const orderService = require('../services/orderService'); // Risky: Direct service-to-service dependency
+const commonUtils = require('../common/utils');
+const deprecatedHelper = require('../libs/deprecatedHelper'); // Risky: Using deprecated library
+
+class UserService {
+  constructor() {
+    this.orderService = orderService;
+    this.utils = commonUtils;
+    this.deprecatedHelper = deprecatedHelper;
+  }
+
+  async getUser(userId) {
+    // TODO: refactor this complex logic into separate modules
+    const user = await this.fetchUserFromDB(userId);
+    
+    // Risky: Direct dependency on order service
+    const orders = await this.orderService.getUserOrders(userId);
+    
+    // FIXME: split this business logic into proper service boundaries
+    const enrichedUser = {
+      ...user,
+      orderCount: orders.length,
+      totalSpent: orders.reduce((sum, order) => sum + order.amount, 0)
+    };
+    
+    return enrichedUser;
+  }
+
+  async createUser(userData) {
+    // Using deprecated helper - risky pattern
+    const processedData = this.deprecatedHelper.processUserData(userData);
+    return this.saveUser(processedData);
+  }
+
+  async fetchUserFromDB(userId) {
+    // Database logic here
+    return { id: userId, name: 'John Doe', email: 'john@example.com' };
+  }
+
+  async saveUser(userData) {
+    // Save logic here
+    return { ...userData, id: Math.floor(Math.random() * 1000) };
+  }
+}
+
+module.exports = new UserService();

package/verify_engine.js

@@ -0,0 +1,116 @@
+const { scan } = require('./src/core/scanner');
+const path = require('path');
+const fs = require('fs');
+
+async function testEngine() {
+    try {
+        console.log("🧪 STARTING ENGINE VERIFICATION...");
+
+        // Target: arcvision-dashboard (sibling directory)
+        const targetDir = path.resolve(__dirname, '../arcvision-dashboard');
+
+        if (!fs.existsSync(targetDir)) {
+            console.log(`⚠️  Target directory not found: ${targetDir}`);
+            console.log("Testing with src/core instead...");
+            
+            // Test with local src/core directory
+            const localTarget = path.resolve(__dirname, './src/core');
+            if (!fs.existsSync(localTarget)) {
+                console.error(`❌ Local test directory not found: ${localTarget}`);
+                process.exit(1);
+            }
+            const context = await scan(localTarget);
+            await validateContext(context);
+            return;
+        }
+
+        const context = await scan(targetDir);
+
+        // Validation Checks
+        console.log("\n🧪 VERIFICATION CHECKS:");
+
+        // 1. Check for Nodes
+        if (context.nodes.length > 0) {
+            console.log(`✅ Nodes found: ${context.nodes.length}`);
+        } else {
+            console.error("❌ No nodes found!");
+        }
+
+        // 2. Check for Edges
+        if (context.edges.length > 0) {
+            console.log(`✅ Edges found: ${context.edges.length}`);
+        } else {
+            console.warn("⚠️ No edges found (might be expected if no dependencies, but unlikely)");
+        }
+
+        // 3. Check for Pass 3 Roles
+        const services = context.nodes.filter(n => n.role === 'service' || n.role === 'controller');
+        if (services.length > 0) {
+            console.log(`✅ Structural Roles Inferred: Found ${services.length} services/controllers`);
+        } else {
+            console.log(`ℹ️  No specific roles inferred (found ${context.nodes.length} total nodes with roles)`);
+        }
+
+        // 4. Check for Pass 2 Semantic Edges
+        const semanticEdges = context.edges.filter(e => e.relation === 'calls' || e.relation === 'depends_on');
+        if (semanticEdges.length > 0) {
+            console.log(`✅ Semantic Edges Resolved: ${semanticEdges.length} (calls/depends_on)`);
+        } else {
+            console.log(`ℹ️  No semantic edges found. ${context.edges.length - semanticEdges.length} import edges only.`);
+        }
+
+        // 5. Check for Pass 4 Signals
+        const criticalFiles = context.nodes.filter(n => n.blast_radius > 0);
+        if (criticalFiles.length > 0) {
+            console.log(`✅ Signals Computed: ${criticalFiles.length} files have dependencies`);
+        } else {
+            console.warn("⚠️ Blast radius appears to be 0 for all files");
+        }
+
+        console.log("\n✨ VERIFICATION COMPLETE");
+        process.exit(0);
+
+    } catch (e) {
+        console.error("❌ VERIFICATION FAILED:", e);
+        process.exit(1);
+    }
+}
+
+async function validateContext(context) {
+    console.log("\n🧪 CONTEXT VALIDATION:");
+    
+    // Basic structure checks
+    if (!context.nodes || !Array.isArray(context.nodes)) {
+        console.error("❌ Missing or invalid nodes array");
+        return;
+    }
+    
+    if (!context.edges || !Array.isArray(context.edges)) {
+        console.error("❌ Missing or invalid edges array");
+        return;
+    }
+    
+    if (!context.metrics) {
+        console.error("❌ Missing metrics object");
+        return;
+    }
+    
+    console.log(`✅ Nodes: ${context.nodes.length}`);
+    console.log(`✅ Edges: ${context.edges.length}`);
+    console.log(`✅ Schema version: ${context.schema_version || 'missing'}`);
+    console.log(`✅ Metrics present: ${!!context.metrics}`);
+    
+    // Check for expected multi-pass outputs
+    const nodesWithRoles = context.nodes.filter(n => n.role);
+    const nodesWithLayers = context.nodes.filter(n => n.layer);
+    const nodesWithSignals = context.nodes.filter(n => n.blast_radius !== undefined);
+    
+    console.log(`✅ Nodes with roles: ${nodesWithRoles.length}`);
+    console.log(`✅ Nodes with layers: ${nodesWithLayers.length}`);
+    console.log(`✅ Nodes with signals: ${nodesWithSignals.length}`);
+    
+    console.log("\n✨ VALIDATION COMPLETE");
+    process.exit(0);
+}
+
+testEngine();