@vibecheckai/cli 3.5.0 → 3.5.1

package/bin/runners/lib/agent-firewall/simulator/diff-simulator.js

@@ -1,472 +0,0 @@
-/**
- * Diff Simulator
- * 
- * Simulates applying changes in memory before touching the disk.
- * Validates that the change won't break imports, routes, or other invariants.
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { extractImports, validateImport, buildImportGraph, detectCircularDeps } = require("./import-resolver");
-const { extractRoutes, validateRoutes } = require("./route-validator");
-
-/**
- * @typedef {Object} SimulationResult
- * @property {boolean} passed - Whether simulation passed
- * @property {Array} errors - Critical errors that would break the build
- * @property {Array} warnings - Non-critical issues
- * @property {Object} importAnalysis - Import validation results
- * @property {Object} routeAnalysis - Route validation results
- * @property {Object} orphanAnalysis - Orphan file detection results
- * @property {Object} circularDeps - Circular dependency detection
- */
-
-/**
- * Apply changes to virtual file system
- * @param {string} projectRoot - Project root
- * @param {Array} changes - Array of change operations
- * @returns {Object} Virtual file system state
- */
-function buildVirtualFS(projectRoot, changes) {
-  const virtualFiles = new Map(); // path -> content
-  const deletedFiles = new Set();
-  const modifiedFiles = new Set();
-  const createdFiles = new Set();
-  
-  for (const change of changes) {
-    const relativePath = change.path?.replace(/\\/g, "/") || change.filePath?.replace(/\\/g, "/");
-    
-    switch (change.type?.toLowerCase() || change.operation?.toLowerCase()) {
-      case "create":
-      case "add":
-        virtualFiles.set(relativePath, change.content || change.newContent || "");
-        createdFiles.add(relativePath);
-        break;
-        
-      case "modify":
-      case "update":
-      case "change":
-        virtualFiles.set(relativePath, change.content || change.newContent || "");
-        modifiedFiles.add(relativePath);
-        break;
-        
-      case "delete":
-      case "remove":
-        deletedFiles.add(relativePath);
-        virtualFiles.delete(relativePath);
-        break;
-    }
-  }
-  
-  return {
-    virtualFiles,
-    deletedFiles,
-    modifiedFiles,
-    createdFiles,
-  };
-}
-
-/**
- * Load existing file content
- * @param {string} projectRoot - Project root
- * @param {string} filePath - Relative file path
- * @returns {string|null} File content or null
- */
-function loadFileContent(projectRoot, filePath) {
-  const fullPath = path.join(projectRoot, filePath);
-  try {
-    if (fs.existsSync(fullPath)) {
-      return fs.readFileSync(fullPath, "utf-8");
-    }
-  } catch {
-    // Ignore read errors
-  }
-  return null;
-}
-
-/**
- * Get effective file content (virtual or real)
- * @param {string} projectRoot - Project root
- * @param {string} filePath - File path
- * @param {Map} virtualFiles - Virtual file system
- * @param {Set} deletedFiles - Deleted files
- * @returns {string|null} Content or null if deleted/missing
- */
-function getEffectiveContent(projectRoot, filePath, virtualFiles, deletedFiles) {
-  if (deletedFiles.has(filePath)) {
-    return null;
-  }
-  
-  if (virtualFiles.has(filePath)) {
-    return virtualFiles.get(filePath);
-  }
-  
-  return loadFileContent(projectRoot, filePath);
-}
-
-/**
- * Validate imports after changes
- * @param {string} projectRoot - Project root
- * @param {Object} vfs - Virtual file system state
- * @returns {Object} Import validation result
- */
-function validateImportsAfterChanges(projectRoot, vfs) {
-  const { virtualFiles, deletedFiles, modifiedFiles, createdFiles } = vfs;
-  const errors = [];
-  const warnings = [];
-  
-  // Get all files that need import validation
-  const filesToCheck = new Set([...modifiedFiles, ...createdFiles]);
-  
-  // Also check files that might import deleted files
-  if (deletedFiles.size > 0) {
-    // Scan source files to find potential importers
-    const srcDirs = ["src", "lib", "app", "pages", "components"];
-    for (const srcDir of srcDirs) {
-      const srcPath = path.join(projectRoot, srcDir);
-      if (fs.existsSync(srcPath)) {
-        scanForImporters(srcPath, deletedFiles, filesToCheck, projectRoot);
-      }
-    }
-  }
-  
-  // Validate imports in each file
-  for (const filePath of filesToCheck) {
-    const content = getEffectiveContent(projectRoot, filePath, virtualFiles, deletedFiles);
-    if (!content) continue;
-    
-    const imports = extractImports(content);
-    
-    for (const imp of imports) {
-      const result = validateImport(
-        imp,
-        path.join(projectRoot, filePath),
-        projectRoot,
-        virtualFiles,
-        deletedFiles
-      );
-      
-      if (!result.valid) {
-        if (result.resolution?.type === "internal") {
-          errors.push({
-            type: "broken_import",
-            file: filePath,
-            line: imp.line,
-            import: imp.source,
-            message: result.error,
-          });
-        } else if (result.resolution?.type === "unresolved") {
-          // Only error for internal unresolved imports
-          if (imp.source.startsWith(".") || imp.source.startsWith("@/")) {
-            errors.push({
-              type: "unresolved_import",
-              file: filePath,
-              line: imp.line,
-              import: imp.source,
-              message: result.error,
-            });
-          }
-        }
-      }
-    }
-  }
-  
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-    checkedFiles: filesToCheck.size,
-  };
-}
-
-/**
- * Scan directory for files that might import deleted files
- */
-function scanForImporters(dir, deletedFiles, filesToCheck, projectRoot, depth = 0) {
-  if (depth > 5) return;
-  
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      
-      const fullPath = path.join(dir, entry.name);
-      
-      if (entry.isDirectory()) {
-        scanForImporters(fullPath, deletedFiles, filesToCheck, projectRoot, depth + 1);
-      } else if (entry.isFile()) {
-        const ext = path.extname(entry.name);
-        if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
-          const relativePath = path.relative(projectRoot, fullPath).replace(/\\/g, "/");
-          
-          // Quick check if file might reference deleted files
-          try {
-            const content = fs.readFileSync(fullPath, "utf-8");
-            for (const deleted of deletedFiles) {
-              const basename = path.basename(deleted, path.extname(deleted));
-              if (content.includes(basename)) {
-                filesToCheck.add(relativePath);
-                break;
-              }
-            }
-          } catch {
-            // Ignore read errors
-          }
-        }
-      }
-    }
-  } catch {
-    // Ignore directory errors
-  }
-}
-
-/**
- * Detect orphaned files after changes
- * @param {string} projectRoot - Project root
- * @param {Object} vfs - Virtual file system state
- * @returns {Object} Orphan analysis result
- */
-function detectOrphanedFiles(projectRoot, vfs) {
-  const { virtualFiles, deletedFiles, createdFiles } = vfs;
-  const orphans = [];
-  const warnings = [];
-  
-  // Check for orphaned test files (test files without corresponding source)
-  for (const created of createdFiles) {
-    if (created.includes(".test.") || created.includes(".spec.")) {
-      const sourcePath = created
-        .replace(".test.", ".")
-        .replace(".spec.", ".")
-        .replace("__tests__/", "")
-        .replace("/tests/", "/");
-      
-      const sourceExists = 
-        virtualFiles.has(sourcePath) || 
-        fs.existsSync(path.join(projectRoot, sourcePath));
-      
-      if (!sourceExists) {
-        warnings.push({
-          type: "orphaned_test",
-          file: created,
-          expectedSource: sourcePath,
-          message: `Test file '${created}' has no corresponding source file`,
-        });
-      }
-    }
-  }
-  
-  // Check if deleted files are still imported somewhere
-  for (const deleted of deletedFiles) {
-    // This is handled by import validation
-    orphans.push({
-      file: deleted,
-      type: "deleted",
-    });
-  }
-  
-  return {
-    orphans,
-    warnings,
-  };
-}
-
-/**
- * Simulate changes and validate
- * @param {string} projectRoot - Project root directory
- * @param {Array} changes - Array of change operations
- * @param {Object} options - Simulation options
- * @returns {SimulationResult} Simulation result
- */
-function simulate(projectRoot, changes, options = {}) {
-  const {
-    validateImports: shouldValidateImports = true,
-    validateRoutes: shouldValidateRoutes = true,
-    detectOrphans = true,
-    detectCircular = true,
-    existingRoutes = [],
-  } = options;
-  
-  const result = {
-    passed: true,
-    errors: [],
-    warnings: [],
-    importAnalysis: null,
-    routeAnalysis: null,
-    orphanAnalysis: null,
-    circularDeps: null,
-    summary: {},
-  };
-  
-  // Build virtual file system
-  const vfs = buildVirtualFS(projectRoot, changes);
-  
-  result.summary.filesCreated = vfs.createdFiles.size;
-  result.summary.filesModified = vfs.modifiedFiles.size;
-  result.summary.filesDeleted = vfs.deletedFiles.size;
-  
-  // Validate imports
-  if (shouldValidateImports) {
-    const importResult = validateImportsAfterChanges(projectRoot, vfs);
-    result.importAnalysis = importResult;
-    
-    if (!importResult.valid) {
-      result.passed = false;
-      result.errors.push(...importResult.errors.map(e => ({
-        ...e,
-        category: "import",
-      })));
-    }
-    
-    result.warnings.push(...importResult.warnings.map(w => ({
-      ...w,
-      category: "import",
-    })));
-  }
-  
-  // Validate routes
-  if (shouldValidateRoutes && existingRoutes.length > 0) {
-    const changedFiles = new Map();
-    for (const [filePath, content] of vfs.virtualFiles) {
-      if (filePath.includes("route") || filePath.includes("api")) {
-        changedFiles.set(filePath, content);
-      }
-    }
-    
-    const routeResult = validateRoutes(existingRoutes, changedFiles, vfs.deletedFiles);
-    result.routeAnalysis = routeResult;
-    
-    if (!routeResult.valid) {
-      result.passed = false;
-      result.errors.push(...routeResult.issues
-        .filter(i => i.severity === "error")
-        .map(e => ({
-          ...e,
-          category: "route",
-        })));
-    }
-    
-    result.warnings.push(...routeResult.issues
-      .filter(i => i.severity === "warning")
-      .map(w => ({
-        ...w,
-        category: "route",
-      })));
-  }
-  
-  // Detect orphans
-  if (detectOrphans) {
-    const orphanResult = detectOrphanedFiles(projectRoot, vfs);
-    result.orphanAnalysis = orphanResult;
-    
-    result.warnings.push(...orphanResult.warnings.map(w => ({
-      ...w,
-      category: "orphan",
-    })));
-  }
-  
-  // Detect circular dependencies
-  if (detectCircular && vfs.virtualFiles.size > 0) {
-    // Build import graph with virtual files
-    const allFiles = new Map();
-    
-    // Add virtual files
-    for (const [filePath, content] of vfs.virtualFiles) {
-      allFiles.set(filePath, content);
-    }
-    
-    const graph = buildImportGraph(allFiles, projectRoot);
-    
-    if (graph.circularDeps.length > 0) {
-      result.circularDeps = graph.circularDeps;
-      
-      for (const cycle of graph.circularDeps) {
-        result.warnings.push({
-          type: "circular_dependency",
-          category: "circular",
-          cycle,
-          message: `Circular dependency detected: ${cycle.join(" -> ")}`,
-        });
-      }
-    }
-  }
-  
-  // Update summary
-  result.summary.errorCount = result.errors.length;
-  result.summary.warningCount = result.warnings.length;
-  result.summary.passed = result.passed;
-  
-  return result;
-}
-
-/**
- * Quick simulation for single file changes
- * @param {string} projectRoot - Project root
- * @param {string} filePath - File path
- * @param {string} newContent - New content
- * @param {string} oldContent - Old content (optional)
- * @returns {Object} Quick simulation result
- */
-function quickSimulate(projectRoot, filePath, newContent, oldContent = null) {
-  const changes = [{
-    type: oldContent ? "modify" : "create",
-    path: filePath,
-    content: newContent,
-  }];
-  
-  return simulate(projectRoot, changes, {
-    validateRoutes: false,
-    detectOrphans: false,
-    detectCircular: false,
-  });
-}
-
-/**
- * Format simulation result for display
- * @param {SimulationResult} result - Simulation result
- * @returns {string} Formatted output
- */
-function formatResult(result) {
-  const lines = [];
-  
-  lines.push(`Simulation ${result.passed ? "PASSED" : "FAILED"}`);
-  lines.push("");
-  lines.push(`Summary:`);
-  lines.push(`  Files Created: ${result.summary.filesCreated}`);
-  lines.push(`  Files Modified: ${result.summary.filesModified}`);
-  lines.push(`  Files Deleted: ${result.summary.filesDeleted}`);
-  lines.push(`  Errors: ${result.summary.errorCount}`);
-  lines.push(`  Warnings: ${result.summary.warningCount}`);
-  
-  if (result.errors.length > 0) {
-    lines.push("");
-    lines.push("Errors:");
-    for (const error of result.errors) {
-      lines.push(`  [${error.category}] ${error.message}`);
-      if (error.file) {
-        lines.push(`    at ${error.file}${error.line ? `:${error.line}` : ""}`);
-      }
-    }
-  }
-  
-  if (result.warnings.length > 0) {
-    lines.push("");
-    lines.push("Warnings:");
-    for (const warning of result.warnings) {
-      lines.push(`  [${warning.category}] ${warning.message}`);
-    }
-  }
-  
-  return lines.join("\n");
-}
-
-module.exports = {
-  simulate,
-  quickSimulate,
-  buildVirtualFS,
-  validateImportsAfterChanges,
-  detectOrphanedFiles,
-  formatResult,
-};