vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/agent-firewall/simulator/import-resolver.js

@@ -0,0 +1,346 @@
+/**
+ * Import Resolver
+ * 
+ * Resolves and validates import statements in JavaScript/TypeScript code.
+ * Used by the diff simulator to detect broken imports.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Extract imports from source code
+ * @param {string} content - File content
+ * @returns {Array} Array of import objects
+ */
+function extractImports(content) {
+  const imports = [];
+  
+  // ES6 imports: import X from 'Y', import { X } from 'Y', import 'Y'
+  const importRegex = /import\s+(?:(?:(\w+)(?:\s*,\s*)?)?(?:\{([^}]+)\})?\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  
+  while ((match = importRegex.exec(content)) !== null) {
+    const [, defaultImport, namedImports, source] = match;
+    imports.push({
+      type: "esm",
+      source,
+      defaultImport: defaultImport || null,
+      namedImports: namedImports ? namedImports.split(",").map(s => s.trim()) : [],
+      line: content.substring(0, match.index).split("\n").length,
+    });
+  }
+  
+  // Dynamic imports: import('X'), await import('X')
+  const dynamicRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = dynamicRegex.exec(content)) !== null) {
+    imports.push({
+      type: "dynamic",
+      source: match[1],
+      defaultImport: null,
+      namedImports: [],
+      line: content.substring(0, match.index).split("\n").length,
+    });
+  }
+  
+  // CommonJS requires: require('X'), require("X")
+  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = requireRegex.exec(content)) !== null) {
+    imports.push({
+      type: "commonjs",
+      source: match[1],
+      defaultImport: null,
+      namedImports: [],
+      line: content.substring(0, match.index).split("\n").length,
+    });
+  }
+  
+  return imports;
+}
+
+/**
+ * Extract exports from source code
+ * @param {string} content - File content
+ * @returns {Array} Array of export objects
+ */
+function extractExports(content) {
+  const exports = [];
+  
+  // Named exports: export const X, export function X, export class X
+  const namedRegex = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
+  let match;
+  
+  while ((match = namedRegex.exec(content)) !== null) {
+    exports.push({
+      type: "named",
+      name: match[1],
+      line: content.substring(0, match.index).split("\n").length,
+    });
+  }
+  
+  // Export list: export { X, Y as Z }
+  const listRegex = /export\s+\{([^}]+)\}/g;
+  while ((match = listRegex.exec(content)) !== null) {
+    const names = match[1].split(",").map(s => {
+      const parts = s.trim().split(/\s+as\s+/);
+      return { original: parts[0].trim(), alias: parts[1]?.trim() || parts[0].trim() };
+    });
+    for (const name of names) {
+      exports.push({
+        type: "named",
+        name: name.alias,
+        originalName: name.original,
+        line: content.substring(0, match.index).split("\n").length,
+      });
+    }
+  }
+  
+  // Default export: export default X
+  const defaultRegex = /export\s+default\s+(?:class\s+(\w+)|function\s+(\w+)|(\w+))/g;
+  while ((match = defaultRegex.exec(content)) !== null) {
+    const name = match[1] || match[2] || match[3];
+    exports.push({
+      type: "default",
+      name: name || "default",
+      line: content.substring(0, match.index).split("\n").length,
+    });
+  }
+  
+  // Re-exports: export * from 'X', export { X } from 'X'
+  const reExportRegex = /export\s+(?:\*|{[^}]+})\s+from\s+['"]([^'"]+)['"]/g;
+  while ((match = reExportRegex.exec(content)) !== null) {
+    exports.push({
+      type: "reexport",
+      source: match[1],
+      line: content.substring(0, match.index).split("\n").length,
+    });
+  }
+  
+  // module.exports
+  if (content.includes("module.exports")) {
+    exports.push({
+      type: "commonjs",
+      name: "module.exports",
+      line: content.indexOf("module.exports"),
+    });
+  }
+  
+  return exports;
+}
+
+/**
+ * Resolve import path to actual file
+ * @param {string} importPath - Import path
+ * @param {string} fromFile - File containing the import
+ * @param {string} projectRoot - Project root directory
+ * @param {Map} virtualFiles - Virtual file system (for simulation)
+ * @returns {Object} Resolution result
+ */
+function resolveImportPath(importPath, fromFile, projectRoot, virtualFiles = new Map()) {
+  // Node built-ins
+  const builtins = [
+    "fs", "path", "os", "http", "https", "crypto", "util", "events",
+    "stream", "buffer", "url", "querystring", "child_process", "net",
+    "assert", "zlib", "readline", "cluster", "dns", "tls", "dgram",
+  ];
+  
+  if (builtins.includes(importPath) || importPath.startsWith("node:")) {
+    return { resolved: true, type: "builtin", path: importPath };
+  }
+  
+  // External packages (don't start with . or /)
+  if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/")) {
+    // Check if it looks like a scoped package
+    const isScoped = importPath.startsWith("@") && !importPath.startsWith("@/");
+    return { resolved: true, type: "external", path: importPath, isScoped };
+  }
+  
+  // Resolve relative imports
+  const fromDir = path.dirname(fromFile);
+  let resolvedPath;
+  
+  // Handle alias imports (@/)
+  if (importPath.startsWith("@/")) {
+    resolvedPath = path.join(projectRoot, "src", importPath.slice(2));
+  } else if (importPath.startsWith("~/")) {
+    resolvedPath = path.join(projectRoot, importPath.slice(2));
+  } else {
+    resolvedPath = path.resolve(fromDir, importPath);
+  }
+  
+  // Try different extensions
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".json", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+  
+  for (const ext of extensions) {
+    const fullPath = resolvedPath + ext;
+    const relativePath = path.relative(projectRoot, fullPath).replace(/\\/g, "/");
+    
+    // Check virtual files first
+    if (virtualFiles.has(relativePath)) {
+      return { resolved: true, type: "internal", path: relativePath, virtual: true };
+    }
+    
+    // Check real file system
+    if (fs.existsSync(fullPath)) {
+      return { resolved: true, type: "internal", path: relativePath };
+    }
+  }
+  
+  // Unresolved
+  return {
+    resolved: false,
+    type: "unresolved",
+    path: importPath,
+    attemptedPaths: extensions.map(ext => resolvedPath + ext),
+  };
+}
+
+/**
+ * Check if an import can be resolved with changes applied
+ * @param {Object} importObj - Import object
+ * @param {string} fromFile - Source file
+ * @param {string} projectRoot - Project root
+ * @param {Map} virtualFiles - Virtual file system state
+ * @param {Set} deletedFiles - Deleted files
+ * @returns {Object} Validation result
+ */
+function validateImport(importObj, fromFile, projectRoot, virtualFiles, deletedFiles) {
+  const resolution = resolveImportPath(importObj.source, fromFile, projectRoot, virtualFiles);
+  
+  // Check if resolved file is deleted
+  if (resolution.resolved && resolution.type === "internal") {
+    if (deletedFiles.has(resolution.path)) {
+      return {
+        valid: false,
+        import: importObj,
+        resolution,
+        error: `Import '${importObj.source}' resolves to deleted file '${resolution.path}'`,
+      };
+    }
+  }
+  
+  // Check if import is unresolved
+  if (!resolution.resolved) {
+    return {
+      valid: false,
+      import: importObj,
+      resolution,
+      error: `Cannot resolve import '${importObj.source}' from '${fromFile}'`,
+    };
+  }
+  
+  return {
+    valid: true,
+    import: importObj,
+    resolution,
+  };
+}
+
+/**
+ * Build import graph from files
+ * @param {Map} files - Map of file path to content
+ * @param {string} projectRoot - Project root
+ * @returns {Object} Import graph
+ */
+function buildImportGraph(files, projectRoot) {
+  const graph = {
+    nodes: new Map(),
+    edges: [],
+    circularDeps: [],
+  };
+  
+  // Build nodes and edges
+  for (const [filePath, content] of files) {
+    const imports = extractImports(content);
+    const exports = extractExports(content);
+    
+    graph.nodes.set(filePath, {
+      path: filePath,
+      imports,
+      exports,
+      importCount: imports.length,
+      exportCount: exports.length,
+    });
+    
+    // Add edges
+    for (const imp of imports) {
+      const resolution = resolveImportPath(imp.source, filePath, projectRoot, files);
+      if (resolution.type === "internal") {
+        graph.edges.push({
+          from: filePath,
+          to: resolution.path,
+          import: imp,
+        });
+      }
+    }
+  }
+  
+  // Detect circular dependencies
+  graph.circularDeps = detectCircularDeps(graph.edges);
+  
+  return graph;
+}
+
+/**
+ * Detect circular dependencies in import graph
+ * @param {Array} edges - Graph edges
+ * @returns {Array} Array of circular dependency chains
+ */
+function detectCircularDeps(edges) {
+  const graph = new Map();
+  
+  // Build adjacency list
+  for (const edge of edges) {
+    if (!graph.has(edge.from)) {
+      graph.set(edge.from, []);
+    }
+    graph.get(edge.from).push(edge.to);
+  }
+  
+  const visited = new Set();
+  const inStack = new Set();
+  const cycles = [];
+  
+  function dfs(node, path) {
+    if (inStack.has(node)) {
+      // Found cycle
+      const cycleStart = path.indexOf(node);
+      const cycle = path.slice(cycleStart);
+      cycle.push(node);
+      cycles.push(cycle);
+      return;
+    }
+    
+    if (visited.has(node)) return;
+    
+    visited.add(node);
+    inStack.add(node);
+    path.push(node);
+    
+    const neighbors = graph.get(node) || [];
+    for (const neighbor of neighbors) {
+      dfs(neighbor, [...path]);
+    }
+    
+    inStack.delete(node);
+  }
+  
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  
+  return cycles;
+}
+
+module.exports = {
+  extractImports,
+  extractExports,
+  resolveImportPath,
+  validateImport,
+  buildImportGraph,
+  detectCircularDeps,
+};

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

@@ -0,0 +1,181 @@
+/**
+ * Diff Simulator Module
+ * 
+ * Entry point for the diff simulation engine.
+ * Validates changes in memory before applying to disk.
+ * 
+ * Usage:
+ *   const { simulator } = require('./simulator');
+ *   
+ *   const result = simulator.simulate(projectRoot, [
+ *     { type: 'create', path: 'src/new.ts', content: '...' },
+ *     { type: 'modify', path: 'src/existing.ts', content: '...' },
+ *     { type: 'delete', path: 'src/old.ts' },
+ *   ]);
+ *   
+ *   if (!result.passed) {
+ *     console.log('Simulation failed:', result.errors);
+ *   }
+ */
+
+"use strict";
+
+const {
+  simulate,
+  quickSimulate,
+  buildVirtualFS,
+  validateImportsAfterChanges,
+  detectOrphanedFiles,
+  formatResult,
+} = require("./diff-simulator");
+
+const {
+  extractImports,
+  extractExports,
+  resolveImportPath,
+  validateImport,
+  buildImportGraph,
+  detectCircularDeps,
+} = require("./import-resolver");
+
+const {
+  extractRoutes,
+  validateRoutes,
+  findRouteReferences,
+} = require("./route-validator");
+
+/**
+ * Simulator singleton
+ */
+const simulator = {
+  /**
+   * Run full simulation
+   * @param {string} projectRoot - Project root directory
+   * @param {Array} changes - Array of change operations
+   * @param {Object} options - Simulation options
+   * @returns {Object} Simulation result
+   */
+  simulate(projectRoot, changes, options = {}) {
+    return simulate(projectRoot, changes, options);
+  },
+  
+  /**
+   * Quick simulation for single file
+   * @param {string} projectRoot - Project root
+   * @param {string} filePath - File path
+   * @param {string} newContent - New content
+   * @param {string} oldContent - Old content (optional)
+   * @returns {Object} Simulation result
+   */
+  quick(projectRoot, filePath, newContent, oldContent = null) {
+    return quickSimulate(projectRoot, filePath, newContent, oldContent);
+  },
+  
+  /**
+   * Validate imports only
+   * @param {string} projectRoot - Project root
+   * @param {Array} changes - Change operations
+   * @returns {Object} Import validation result
+   */
+  validateImports(projectRoot, changes) {
+    const vfs = buildVirtualFS(projectRoot, changes);
+    return validateImportsAfterChanges(projectRoot, vfs);
+  },
+  
+  /**
+   * Validate routes only
+   * @param {Array} existingRoutes - Current routes
+   * @param {Map} changedFiles - Changed files
+   * @param {Set} deletedFiles - Deleted files
+   * @returns {Object} Route validation result
+   */
+  validateRoutes(existingRoutes, changedFiles, deletedFiles) {
+    return validateRoutes(existingRoutes, changedFiles, deletedFiles);
+  },
+  
+  /**
+   * Extract imports from content
+   * @param {string} content - File content
+   * @returns {Array} Imports
+   */
+  extractImports(content) {
+    return extractImports(content);
+  },
+  
+  /**
+   * Extract exports from content
+   * @param {string} content - File content
+   * @returns {Array} Exports
+   */
+  extractExports(content) {
+    return extractExports(content);
+  },
+  
+  /**
+   * Extract routes from content
+   * @param {string} content - File content
+   * @param {string} filePath - File path
+   * @returns {Array} Routes
+   */
+  extractRoutes(content, filePath) {
+    return extractRoutes(content, filePath);
+  },
+  
+  /**
+   * Build import graph
+   * @param {Map} files - File map
+   * @param {string} projectRoot - Project root
+   * @returns {Object} Import graph
+   */
+  buildImportGraph(files, projectRoot) {
+    return buildImportGraph(files, projectRoot);
+  },
+  
+  /**
+   * Detect circular dependencies
+   * @param {Array} edges - Graph edges
+   * @returns {Array} Cycles found
+   */
+  detectCircularDeps(edges) {
+    return detectCircularDeps(edges);
+  },
+  
+  /**
+   * Format result for display
+   * @param {Object} result - Simulation result
+   * @returns {string} Formatted output
+   */
+  format(result) {
+    return formatResult(result);
+  },
+  
+  /**
+   * Build virtual file system from changes
+   * @param {string} projectRoot - Project root
+   * @param {Array} changes - Changes
+   * @returns {Object} Virtual FS state
+   */
+  buildVirtualFS(projectRoot, changes) {
+    return buildVirtualFS(projectRoot, changes);
+  },
+};
+
+module.exports = {
+  simulator,
+  // Direct exports
+  simulate,
+  quickSimulate,
+  buildVirtualFS,
+  validateImportsAfterChanges,
+  detectOrphanedFiles,
+  formatResult,
+  extractImports,
+  extractExports,
+  resolveImportPath,
+  validateImport,
+  buildImportGraph,
+  detectCircularDeps,
+  extractRoutes,
+  validateRoutes,
+  findRouteReferences,
+};