@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/engines/naming-conventions-engine.js

@@ -1,544 +0,0 @@
-/**
- * Naming Conventions Engine
- * Detects:
- * - Inconsistent naming styles (camelCase, PascalCase, snake_case)
- * - Non-descriptive names (single letters, abbreviations)
- * - Boolean naming (should start with is/has/can/should)
- * - React component naming conventions
- * - File naming consistency
- * - Constants naming (UPPER_SNAKE_CASE)
- */
-
-const { getAST } = require("./ast-cache");
-const traverse = require("@babel/traverse").default;
-const t = require("@babel/types");
-const { shouldExcludeFile, isTestContext, hasIgnoreDirective } = require("./file-filter");
-const path = require("path");
-
-/**
- * Naming patterns
- */
-const PATTERNS = {
-  camelCase: /^[a-z][a-zA-Z0-9]*$/,
-  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
-  UPPER_SNAKE_CASE: /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/,
-  snake_case: /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/,
-  kebab_case: /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
-};
-
-/**
- * Common acceptable short names
- */
-const ACCEPTABLE_SHORT_NAMES = new Set([
-  // Loop variables
-  "i", "j", "k", "n", "x", "y", "z",
-  // Common abbreviations
-  "id", "db", "fs", "os", "io", "ui", "fn", "cb", "el", "ev", "re",
-  // Destructuring placeholders
-  "_",
-  // React refs
-  "ref",
-  // Error
-  "e", "err",
-  // Event
-  "evt",
-  // Props
-  "p",
-  // Context
-  "ctx", "c",
-  // Key/Value
-  "k", "v",
-  // Temp
-  "t",
-  // Result
-  "r",
-]);
-
-/**
- * Boolean prefixes
- */
-const BOOLEAN_PREFIXES = ["is", "has", "can", "should", "will", "did", "was", "are", "does", "do"];
-
-/**
- * Hook patterns
- */
-const HOOK_PATTERN = /^use[A-Z]/;
-
-/**
- * Check naming style
- */
-function detectNamingStyle(name) {
-  if (PATTERNS.UPPER_SNAKE_CASE.test(name)) return "UPPER_SNAKE_CASE";
-  if (PATTERNS.PascalCase.test(name)) return "PascalCase";
-  if (PATTERNS.camelCase.test(name)) return "camelCase";
-  if (PATTERNS.snake_case.test(name)) return "snake_case";
-  return "mixed";
-}
-
-/**
- * Check if name looks like a boolean
- */
-function looksLikeBoolean(name, isActuallyBoolean = false) {
-  // If it's actually a boolean type, check if it follows convention
-  if (isActuallyBoolean) {
-    return BOOLEAN_PREFIXES.some(prefix => 
-      name.startsWith(prefix) && name.length > prefix.length
-    );
-  }
-  
-  // Check if name suggests boolean but might not follow convention
-  const booleanSuffixes = ["flag", "enabled", "disabled", "active", "visible", "hidden", "loading", "loaded"];
-  return booleanSuffixes.some(suffix => name.toLowerCase().endsWith(suffix));
-}
-
-/**
- * Check if it's a React component name
- */
-function isComponentName(name) {
-  return PATTERNS.PascalCase.test(name);
-}
-
-/**
- * Check if it's a hook name
- */
-function isHookName(name) {
-  return HOOK_PATTERN.test(name);
-}
-
-/**
- * Get expected naming style for context
- */
-function getExpectedStyle(context) {
-  switch (context) {
-    case "component":
-      return "PascalCase";
-    case "hook":
-      return "camelCase starting with 'use'";
-    case "constant":
-      return "UPPER_SNAKE_CASE";
-    case "function":
-    case "variable":
-    case "parameter":
-      return "camelCase";
-    case "class":
-    case "type":
-    case "interface":
-      return "PascalCase";
-    default:
-      return "camelCase";
-  }
-}
-
-function snippetForLine(lines, line) {
-  return lines[line - 1] ? lines[line - 1].trim() : "";
-}
-
-/**
- * Analyze naming conventions
- */
-function analyzeNamingConventions(code, filePath) {
-  const findings = [];
-  
-  if (shouldExcludeFile(filePath)) return findings;
-  if (isTestContext(code, filePath)) return findings;
-  if (hasIgnoreDirective(code, "naming-conventions")) return findings;
-  
-  const ast = getAST(code, filePath);
-  if (!ast) return findings;
-  
-  const lines = code.split("\n");
-  const normalizedPath = filePath.replace(/\\/g, "/");
-  const fileName = path.basename(filePath);
-  const isReactFile = /\.(tsx|jsx)$/.test(filePath);
-  
-  // Track naming styles used in the file for consistency checking
-  const functionStyles = new Map();
-  const variableStyles = new Map();
-  
-  traverse(ast, {
-    // Check function declarations
-    FunctionDeclaration(pathNode) {
-      const node = pathNode.node;
-      const name = node.id?.name;
-      if (!name) return;
-      
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      const style = detectNamingStyle(name);
-      functionStyles.set(name, style);
-      
-      // React components should be PascalCase
-      if (isReactFile && returnsJSX(pathNode) && !isComponentName(name)) {
-        findings.push({
-          type: "naming_convention",
-          severity: "INFO",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Component should be PascalCase: ${name}`,
-          message: `React component '${name}' should use PascalCase naming.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "med",
-          fixHint: `Rename to ${toPascalCase(name)}`,
-        });
-      }
-      
-      // Hooks should start with 'use'
-      if (isReactFile && usesHooks(pathNode) && !isHookName(name) && !isComponentName(name)) {
-        findings.push({
-          type: "naming_convention",
-          severity: "INFO",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Custom hook should start with 'use': ${name}`,
-          message: `Function '${name}' uses React hooks but doesn't follow hook naming convention.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "low",
-          fixHint: `Rename to use${toPascalCase(name)}`,
-        });
-      }
-      
-      // Check for non-descriptive names
-      if (name.length <= 2 && !ACCEPTABLE_SHORT_NAMES.has(name)) {
-        findings.push({
-          type: "non_descriptive_name",
-          severity: "INFO",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Non-descriptive function name: ${name}`,
-          message: `Function name '${name}' is too short. Use a more descriptive name.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "low",
-          fixHint: "Use a descriptive name that explains the function's purpose",
-        });
-      }
-    },
-    
-    // Check variable declarations
-    VariableDeclarator(pathNode) {
-      const node = pathNode.node;
-      if (!t.isIdentifier(node.id)) return;
-      
-      const name = node.id.name;
-      const loc = node.loc?.start || pathNode.parentPath.node.loc?.start;
-      if (!loc) return;
-      
-      const style = detectNamingStyle(name);
-      const kind = pathNode.parentPath.node.kind; // const, let, var
-      
-      // Check for constants that should be UPPER_SNAKE_CASE
-      if (kind === "const" && t.isLiteral(node.init) && !t.isTemplateLiteral(node.init)) {
-        // Module-level constants
-        const isModuleLevel = pathNode.parentPath.parentPath.isProgram();
-        
-        if (isModuleLevel && style !== "UPPER_SNAKE_CASE" && name.length > 3) {
-          // Skip if it's clearly not a constant (function, object, etc.)
-          if (t.isStringLiteral(node.init) || t.isNumericLiteral(node.init)) {
-            findings.push({
-              type: "constant_naming",
-              severity: "INFO",
-              category: "NamingConventions",
-              file: filePath,
-              line: loc.line,
-              column: loc.column,
-              title: `Constant should be UPPER_SNAKE_CASE: ${name}`,
-              message: `Module-level constant '${name}' should use UPPER_SNAKE_CASE.`,
-              codeSnippet: snippetForLine(lines, loc.line),
-              confidence: "low",
-              fixHint: `Rename to ${toUpperSnakeCase(name)}`,
-            });
-          }
-        }
-      }
-      
-      // Check for arrow function components
-      if (isReactFile && 
-          (t.isArrowFunctionExpression(node.init) || t.isFunctionExpression(node.init)) &&
-          returnsJSXFromInit(node.init, pathNode)) {
-        
-        if (!isComponentName(name)) {
-          findings.push({
-            type: "naming_convention",
-            severity: "INFO",
-            category: "NamingConventions",
-            file: filePath,
-            line: loc.line,
-            column: loc.column,
-            title: `Component should be PascalCase: ${name}`,
-            message: `React component '${name}' should use PascalCase naming.`,
-            codeSnippet: snippetForLine(lines, loc.line),
-            confidence: "med",
-            fixHint: `Rename to ${toPascalCase(name)}`,
-          });
-        }
-      }
-      
-      // Check for boolean variables
-      if (node.init && (t.isBooleanLiteral(node.init) || isComparisonExpression(node.init))) {
-        if (!looksLikeBoolean(name, true)) {
-          findings.push({
-            type: "boolean_naming",
-            severity: "INFO",
-            category: "NamingConventions",
-            file: filePath,
-            line: loc.line,
-            column: loc.column,
-            title: `Boolean should use is/has/can prefix: ${name}`,
-            message: `Boolean variable '${name}' should start with is, has, can, should, etc.`,
-            codeSnippet: snippetForLine(lines, loc.line),
-            confidence: "low",
-            fixHint: `Rename to is${toPascalCase(name)} or has${toPascalCase(name)}`,
-          });
-        }
-      }
-    },
-    
-    // Check class names
-    ClassDeclaration(pathNode) {
-      const node = pathNode.node;
-      const name = node.id?.name;
-      if (!name) return;
-      
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (!PATTERNS.PascalCase.test(name)) {
-        findings.push({
-          type: "naming_convention",
-          severity: "WARN",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Class should be PascalCase: ${name}`,
-          message: `Class name '${name}' should use PascalCase.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "high",
-          fixHint: `Rename to ${toPascalCase(name)}`,
-        });
-      }
-    },
-    
-    // Check TypeScript interfaces and types
-    TSInterfaceDeclaration(pathNode) {
-      const node = pathNode.node;
-      const name = node.id?.name;
-      if (!name) return;
-      
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (!PATTERNS.PascalCase.test(name)) {
-        findings.push({
-          type: "naming_convention",
-          severity: "WARN",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Interface should be PascalCase: ${name}`,
-          message: `Interface name '${name}' should use PascalCase.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "high",
-          fixHint: `Rename to ${toPascalCase(name)}`,
-        });
-      }
-    },
-    
-    TSTypeAliasDeclaration(pathNode) {
-      const node = pathNode.node;
-      const name = node.id?.name;
-      if (!name) return;
-      
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (!PATTERNS.PascalCase.test(name)) {
-        findings.push({
-          type: "naming_convention",
-          severity: "WARN",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Type should be PascalCase: ${name}`,
-          message: `Type alias '${name}' should use PascalCase.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "high",
-          fixHint: `Rename to ${toPascalCase(name)}`,
-        });
-      }
-    },
-    
-    // Check enum names (TypeScript)
-    TSEnumDeclaration(pathNode) {
-      const node = pathNode.node;
-      const name = node.id?.name;
-      if (!name) return;
-      
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (!PATTERNS.PascalCase.test(name)) {
-        findings.push({
-          type: "naming_convention",
-          severity: "WARN",
-          category: "NamingConventions",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: `Enum should be PascalCase: ${name}`,
-          message: `Enum name '${name}' should use PascalCase.`,
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "high",
-          fixHint: `Rename to ${toPascalCase(name)}`,
-        });
-      }
-    },
-  });
-  
-  // Check file naming
-  if (isReactFile) {
-    // Component files should be PascalCase
-    const baseName = path.basename(fileName, path.extname(fileName));
-    
-    if (baseName !== "index" && 
-        !PATTERNS.PascalCase.test(baseName) && 
-        !baseName.startsWith("[") && // Skip dynamic routes
-        !baseName.includes(".")) { // Skip files like page.tsx, layout.tsx
-      
-      findings.push({
-        type: "file_naming",
-        severity: "INFO",
-        category: "NamingConventions",
-        file: filePath,
-        line: 1,
-        column: 0,
-        title: `React file should be PascalCase: ${fileName}`,
-        message: `React component file '${fileName}' should use PascalCase naming.`,
-        codeSnippet: "",
-        confidence: "low",
-        fixHint: `Rename to ${toPascalCase(baseName)}${path.extname(fileName)}`,
-      });
-    }
-  }
-  
-  return findings;
-}
-
-/**
- * Check if function returns JSX
- */
-function returnsJSX(pathNode) {
-  let hasJSX = false;
-  
-  pathNode.traverse({
-    JSXElement() {
-      hasJSX = true;
-    },
-    JSXFragment() {
-      hasJSX = true;
-    },
-  });
-  
-  return hasJSX;
-}
-
-/**
- * Check if init expression returns JSX
- */
-function returnsJSXFromInit(init, pathNode) {
-  if (!init.body) return false;
-  
-  // Check if body is JSX directly (arrow function without block)
-  if (t.isJSXElement(init.body) || t.isJSXFragment(init.body)) {
-    return true;
-  }
-  
-  // Check block body for return statement with JSX
-  let hasJSX = false;
-  if (t.isBlockStatement(init.body)) {
-    traverse(init.body, {
-      ReturnStatement(innerPath) {
-        if (t.isJSXElement(innerPath.node.argument) || 
-            t.isJSXFragment(innerPath.node.argument)) {
-          hasJSX = true;
-        }
-      },
-      noScope: true,
-    }, pathNode.scope);
-  }
-  
-  return hasJSX;
-}
-
-/**
- * Check if function uses React hooks
- */
-function usesHooks(pathNode) {
-  let usesHook = false;
-  
-  pathNode.traverse({
-    CallExpression(innerPath) {
-      const callee = innerPath.node.callee;
-      if (t.isIdentifier(callee) && HOOK_PATTERN.test(callee.name)) {
-        usesHook = true;
-      }
-    },
-  });
-  
-  return usesHook;
-}
-
-/**
- * Check if expression is a comparison
- */
-function isComparisonExpression(node) {
-  if (t.isBinaryExpression(node)) {
-    return ["===", "!==", "==", "!=", ">", "<", ">=", "<="].includes(node.operator);
-  }
-  if (t.isLogicalExpression(node)) {
-    return true;
-  }
-  if (t.isUnaryExpression(node) && node.operator === "!") {
-    return true;
-  }
-  return false;
-}
-
-/**
- * Convert to PascalCase
- */
-function toPascalCase(str) {
-  return str
-    .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
-    .replace(/^(.)/, (_, c) => c.toUpperCase());
-}
-
-/**
- * Convert to UPPER_SNAKE_CASE
- */
-function toUpperSnakeCase(str) {
-  return str
-    .replace(/([a-z])([A-Z])/g, "$1_$2")
-    .replace(/[-\s]/g, "_")
-    .toUpperCase();
-}
-
-module.exports = {
-  analyzeNamingConventions,
-  detectNamingStyle,
-  looksLikeBoolean,
-  isComponentName,
-  isHookName,
-  toPascalCase,
-  toUpperSnakeCase,
-  PATTERNS,
-  BOOLEAN_PREFIXES,
-};