@vibecheckai/cli 3.0.2 → 3.0.3

package/bin/runners/context/analyzer.js

@@ -1,462 +0,0 @@
-/**
- * Project Analyzer Module
- * Analyzes project structure, framework, and conventions
- */
-
-const fs = require("fs");
-const path = require("path");
-const { detectPatterns } = require("./patterns");
-const { detectMonorepo } = require("./monorepo");
-
-const c = {
-  dim: "\x1b[2m",
-  reset: "\x1b[0m",
-};
-
-/**
- * Find files recursively in a directory
- */
-function findFilesRecursive(dir, extensions, maxDepth = 5, currentDepth = 0) {
-  if (currentDepth >= maxDepth || !fs.existsSync(dir)) return [];
-  
-  const files = [];
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        files.push(...findFilesRecursive(fullPath, extensions, maxDepth, currentDepth + 1));
-      } else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
-        files.push(fullPath);
-      }
-    }
-  } catch {}
-  return files;
-}
-
-/**
- * Detect environment variables used in the codebase
- */
-function detectEnvVars(projectPath) {
-  const envVars = new Set();
-  const envFiles = [];
-  
-  const envFileNames = [".env", ".env.local", ".env.example", ".env.development", ".env.production"];
-  for (const envFile of envFileNames) {
-    const envPath = path.join(projectPath, envFile);
-    if (fs.existsSync(envPath)) {
-      envFiles.push(envFile);
-      try {
-        const content = fs.readFileSync(envPath, "utf-8");
-        const matches = content.match(/^([A-Z][A-Z0-9_]+)=/gm) || [];
-        matches.forEach(m => envVars.add(m.replace("=", "")));
-      } catch {}
-    }
-  }
-
-  const srcFiles = findFilesRecursive(projectPath, [".ts", ".tsx", ".js", ".jsx"], 4);
-  for (const file of srcFiles.slice(0, 50)) {
-    try {
-      const content = fs.readFileSync(file, "utf-8");
-      const matches = content.match(/process\.env\.([A-Z][A-Z0-9_]+)/g) || [];
-      matches.forEach(m => envVars.add(m.replace("process.env.", "")));
-      const viteMatches = content.match(/import\.meta\.env\.([A-Z][A-Z0-9_]+)/g) || [];
-      viteMatches.forEach(m => envVars.add(m.replace("import.meta.env.", "")));
-    } catch {}
-  }
-
-  return {
-    files: envFiles,
-    variables: Array.from(envVars).sort(),
-  };
-}
-
-/**
- * Extract key types and interfaces from the codebase
- */
-function extractTypes(projectPath) {
-  const types = {
-    interfaces: [],
-    types: [],
-    enums: [],
-    examples: {},
-  };
-
-  const srcFiles = findFilesRecursive(projectPath, [".ts", ".tsx"], 5);
-  
-  for (const file of srcFiles.slice(0, 80)) {
-    try {
-      const content = fs.readFileSync(file, "utf-8");
-      const relativePath = path.relative(projectPath, file);
-      
-      const interfaceMatches = content.match(/export\s+interface\s+(\w+)/g) || [];
-      interfaceMatches.forEach(m => {
-        const name = m.match(/interface\s+(\w+)/)?.[1];
-        if (name && !types.interfaces.includes(name)) {
-          types.interfaces.push(name);
-          if (!types.examples.interface) {
-            const fullMatch = content.match(new RegExp(`export\\s+interface\\s+${name}\\s*\\{[^}]+\\}`, 's'));
-            if (fullMatch && fullMatch[0].length < 300) {
-              types.examples.interface = { name, code: fullMatch[0], file: relativePath };
-            }
-          }
-        }
-      });
-
-      const typeMatches = content.match(/export\s+type\s+(\w+)\s*=/g) || [];
-      typeMatches.forEach(m => {
-        const name = m.match(/type\s+(\w+)/)?.[1];
-        if (name && !types.types.includes(name)) {
-          types.types.push(name);
-        }
-      });
-
-      const enumMatches = content.match(/export\s+enum\s+(\w+)/g) || [];
-      enumMatches.forEach(m => {
-        const name = m.match(/enum\s+(\w+)/)?.[1];
-        if (name && !types.enums.includes(name)) {
-          types.enums.push(name);
-        }
-      });
-    } catch {}
-  }
-
-  return types;
-}
-
-/**
- * Analyze import graph
- */
-function analyzeImports(projectPath) {
-  const imports = {
-    externalPackages: new Set(),
-    internalAliases: [],
-    importPatterns: [],
-  };
-
-  const srcFiles = findFilesRecursive(projectPath, [".ts", ".tsx", ".js", ".jsx"], 4);
-
-  for (const file of srcFiles.slice(0, 60)) {
-    try {
-      const content = fs.readFileSync(file, "utf-8");
-      const importMatches = content.match(/import\s+.*?\s+from\s+['"]([^'"]+)['"]/g) || [];
-      
-      importMatches.forEach(m => {
-        const source = m.match(/from\s+['"]([^'"]+)['"]/)?.[1];
-        if (source) {
-          if (source.startsWith("@/") || source.startsWith("~/")) {
-            if (!imports.internalAliases.includes(source.split("/")[0])) {
-              imports.internalAliases.push(source.split("/")[0]);
-            }
-          } else if (!source.startsWith(".") && !source.startsWith("/")) {
-            imports.externalPackages.add(source.split("/")[0]);
-          }
-        }
-      });
-    } catch {}
-  }
-
-  if (imports.internalAliases.includes("@/")) {
-    imports.importPatterns.push("Uses @/ path alias for src imports");
-  }
-
-  return {
-    externalPackages: Array.from(imports.externalPackages).slice(0, 30),
-    internalAliases: imports.internalAliases,
-    importPatterns: imports.importPatterns,
-  };
-}
-
-/**
- * Calculate file statistics
- */
-function calculateStats(projectPath) {
-  const stats = {
-    totalFiles: 0,
-    totalLines: 0,
-    byExtension: {},
-    largestFiles: [],
-  };
-
-  const allFiles = findFilesRecursive(projectPath, [".ts", ".tsx", ".js", ".jsx", ".css", ".scss", ".json"], 6);
-  
-  for (const file of allFiles) {
-    try {
-      const content = fs.readFileSync(file, "utf-8");
-      const lines = content.split("\n").length;
-      const ext = path.extname(file);
-      const relativePath = path.relative(projectPath, file);
-      
-      stats.totalFiles++;
-      stats.totalLines += lines;
-      stats.byExtension[ext] = (stats.byExtension[ext] || 0) + 1;
-      stats.largestFiles.push({ path: relativePath, lines });
-    } catch {}
-  }
-
-  stats.largestFiles.sort((a, b) => b.lines - a.lines);
-  stats.largestFiles = stats.largestFiles.slice(0, 5);
-
-  return stats;
-}
-
-/**
- * Get npm scripts from package.json
- */
-function getNpmScripts(projectPath) {
-  const pkgPath = path.join(projectPath, "package.json");
-  if (!fs.existsSync(pkgPath)) return [];
-  
-  try {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    return Object.entries(pkg.scripts || {}).map(([name, cmd]) => ({
-      name,
-      command: cmd.length > 50 ? cmd.slice(0, 50) + "..." : cmd,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Main project analysis function
- */
-function analyzeProject(projectPath) {
-  const analysis = {
-    name: path.basename(projectPath),
-    framework: null,
-    language: null,
-    architecture: null,
-    hasTypescript: false,
-    hasPrisma: false,
-    hasNextjs: false,
-    hasReact: false,
-    hasExpress: false,
-    hasTailwind: false,
-    directories: [],
-    entryPoints: [],
-    apiRoutes: [],
-    components: [],
-    models: [],
-    patterns: {},
-    conventions: {
-      naming: {},
-      imports: [],
-      patterns: [],
-    },
-  };
-
-  // Check package.json
-  const pkgPath = path.join(projectPath, "package.json");
-  if (fs.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      
-      // Full-stack frameworks (check first)
-      if (deps.next) {
-        analysis.framework = "Next.js";
-        analysis.hasNextjs = true;
-      } else if (deps.nuxt || deps["@nuxt/core"]) {
-        analysis.framework = "Nuxt";
-      } else if (deps["@remix-run/node"] || deps["@remix-run/react"]) {
-        analysis.framework = "Remix";
-      }
-      // Frontend frameworks
-      else if (deps.react || deps["react-dom"]) {
-        // Check for Vite
-        if (deps.vite || deps["@vitejs/plugin-react"] || 
-            fs.existsSync(path.join(projectPath, "vite.config.ts")) ||
-            fs.existsSync(path.join(projectPath, "vite.config.js"))) {
-          analysis.framework = "Vite + React";
-        } else {
-          analysis.framework = "React";
-        }
-        analysis.hasReact = true;
-      } else if (deps.vue) {
-        // Check for Vite
-        if (deps.vite || deps["@vitejs/plugin-vue"] ||
-            fs.existsSync(path.join(projectPath, "vite.config.ts")) ||
-            fs.existsSync(path.join(projectPath, "vite.config.js"))) {
-          analysis.framework = "Vite + Vue";
-        } else {
-          analysis.framework = "Vue";
-        }
-      } else if (deps.svelte || deps["svelte-kit"]) {
-        analysis.framework = "Svelte";
-      } else if (deps["@angular/core"]) {
-        analysis.framework = "Angular";
-      }
-      // Backend frameworks
-      else if (deps.express) {
-        analysis.framework = "Express";
-        analysis.hasExpress = true;
-      } else if (deps.fastify) {
-        analysis.framework = "Fastify";
-      } else if (deps["@nestjs/core"]) {
-        analysis.framework = "NestJS";
-      }
-      
-      analysis.hasTypescript = !!deps.typescript;
-      analysis.hasPrisma = !!deps.prisma || !!deps["@prisma/client"];
-      analysis.hasTailwind = !!deps.tailwindcss;
-      analysis.language = analysis.hasTypescript ? "TypeScript" : "JavaScript";
-    } catch {}
-  }
-
-  // Detect architecture
-  if (fs.existsSync(path.join(projectPath, "src/app"))) {
-    analysis.architecture = "Next.js App Router";
-  } else if (fs.existsSync(path.join(projectPath, "src/pages"))) {
-    analysis.architecture = "Next.js Pages Router";
-  } else if (fs.existsSync(path.join(projectPath, "app"))) {
-    analysis.architecture = "Next.js App Router (root)";
-  } else if (fs.existsSync(path.join(projectPath, "src"))) {
-    analysis.architecture = "Standard src/ layout";
-  } else {
-    analysis.architecture = "Flat structure";
-  }
-
-  // Find key directories
-  const dirsToCheck = ["src", "app", "pages", "components", "lib", "utils", "services", "api", "server", "prisma"];
-  for (const dir of dirsToCheck) {
-    if (fs.existsSync(path.join(projectPath, dir))) {
-      analysis.directories.push(dir);
-    }
-    if (fs.existsSync(path.join(projectPath, "src", dir))) {
-      analysis.directories.push(`src/${dir}`);
-    }
-  }
-
-  // Find API routes (including monorepo subdirectories)
-  const apiPaths = [
-    path.join(projectPath, "src/app/api"),
-    path.join(projectPath, "app/api"),
-    path.join(projectPath, "pages/api"),
-    path.join(projectPath, "server"),
-    // Monorepo common paths
-    path.join(projectPath, "services", "scanner-dash", "src", "app", "api"),
-    path.join(projectPath, "services", "scanner-dash", "src", "pages", "api"),
-    path.join(projectPath, "dashboard", "src", "app", "api"),
-    path.join(projectPath, "dashboard", "src", "pages", "api"),
-    path.join(projectPath, "apps", "web-ui", "src", "app", "api"),
-    path.join(projectPath, "apps", "web", "src", "app", "api"),
-  ];
-  
-  // Also search recursively for API directories
-  function findApiDirs(dir, depth = 0) {
-    const found = [];
-    if (depth > 3) return found; // Limit recursion depth
-    
-    try {
-      const items = fs.readdirSync(dir, { withFileTypes: true });
-      for (const item of items) {
-        if (item.isDirectory() && !["node_modules", ".next", "dist", ".git", ".turbo"].includes(item.name)) {
-          const itemPath = path.join(dir, item.name);
-          
-          // Check if this is an API directory
-          if (item.name === "api" || itemPath.includes("/api/") || itemPath.includes("\\api\\")) {
-            found.push(itemPath);
-          }
-          
-          // Also check for server/routes directories
-          if (item.name === "server" || item.name === "routes") {
-            found.push(itemPath);
-          }
-          
-          // Recursively search
-          found.push(...findApiDirs(itemPath, depth + 1));
-        }
-      }
-    } catch (err) {
-      // Skip directories we can't read
-    }
-    
-    return found;
-  }
-  
-  // Combine hardcoded paths with recursive search
-  const allApiPaths = [...apiPaths, ...findApiDirs(projectPath)];
-  
-  for (const apiPath of allApiPaths) {
-    if (fs.existsSync(apiPath)) {
-      const routes = findFilesRecursive(apiPath, [".ts", ".js", ".tsx", ".jsx"]).map(f => 
-        f.replace(apiPath, "").replace(/\\/g, "/").replace(/\/route\.(ts|js|tsx|jsx)$/, "").replace(/\.(ts|js|tsx|jsx)$/, "")
-      );
-      analysis.apiRoutes.push(...routes);
-    }
-  }
-  
-  // Remove duplicates
-  analysis.apiRoutes = [...new Set(analysis.apiRoutes)];
-
-  // Find components
-  const componentPaths = [
-    path.join(projectPath, "src/components"),
-    path.join(projectPath, "components"),
-    path.join(projectPath, "src/app/components"),
-  ];
-  
-  for (const compPath of componentPaths) {
-    if (fs.existsSync(compPath)) {
-      analysis.components = findFilesRecursive(compPath, [".tsx", ".jsx"])
-        .map(f => path.basename(f, path.extname(f)))
-        .filter(name => /^[A-Z]/.test(name));
-      break;
-    }
-  }
-
-  // Detect naming conventions
-  if (analysis.components.length > 0) {
-    const hasPascalCase = analysis.components.some(c => /^[A-Z][a-z]/.test(c));
-    const hasKebabCase = analysis.components.some(c => c.includes("-"));
-    analysis.conventions.naming.components = hasPascalCase ? "PascalCase" : hasKebabCase ? "kebab-case" : "mixed";
-  }
-
-  // Find models/schemas
-  const prismaSchema = path.join(projectPath, "prisma/schema.prisma");
-  if (fs.existsSync(prismaSchema)) {
-    const schema = fs.readFileSync(prismaSchema, "utf-8");
-    const modelMatches = schema.match(/model\s+(\w+)\s*{/g) || [];
-    analysis.models = modelMatches.map(m => m.replace(/model\s+/, "").replace(/\s*{/, ""));
-  }
-
-  // Deep pattern detection
-  console.log(`${c.dim}  Detecting patterns...${c.reset}`);
-  analysis.patterns = detectPatterns(projectPath);
-
-  // Environment variables
-  console.log(`${c.dim}  Scanning env vars...${c.reset}`);
-  analysis.envVars = detectEnvVars(projectPath);
-
-  // Types and interfaces
-  console.log(`${c.dim}  Extracting types...${c.reset}`);
-  analysis.types = extractTypes(projectPath);
-
-  // Import analysis
-  console.log(`${c.dim}  Analyzing imports...${c.reset}`);
-  analysis.imports = analyzeImports(projectPath);
-
-  // File statistics
-  console.log(`${c.dim}  Calculating stats...${c.reset}`);
-  analysis.stats = calculateStats(projectPath);
-
-  // NPM scripts
-  analysis.scripts = getNpmScripts(projectPath);
-
-  // Monorepo detection
-  console.log(`${c.dim}  Detecting monorepo...${c.reset}`);
-  analysis.monorepo = detectMonorepo(projectPath);
-
-  return analysis;
-}
-
-module.exports = {
-  analyzeProject,
-  findFilesRecursive,
-  detectEnvVars,
-  extractTypes,
-  analyzeImports,
-  calculateStats,
-  getNpmScripts,
-};