@vibecheckai/cli 3.2.5 → 3.3.0

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

@@ -0,0 +1,472 @@
+/**
+ * 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,
+};