@aiready/consistency 0.5.0 → 0.6.1

package/dist/chunk-VODCPPET.mjs

@@ -0,0 +1,1292 @@
+// src/analyzers/naming-ast.ts
+import { loadConfig } from "@aiready/core";
+import { dirname } from "path";
+
+// src/utils/ast-parser.ts
+import { parse } from "@typescript-eslint/typescript-estree";
+import { readFileSync } from "fs";
+function parseFile(filePath, content) {
+  try {
+    const code = content ?? readFileSync(filePath, "utf-8");
+    const isTypeScript = filePath.match(/\.tsx?$/);
+    return parse(code, {
+      jsx: filePath.match(/\.[jt]sx$/i) !== null,
+      loc: true,
+      range: true,
+      comment: false,
+      tokens: false,
+      // Relaxed parsing for JavaScript files
+      sourceType: "module",
+      ecmaVersion: "latest",
+      // Only use TypeScript parser features for .ts/.tsx files
+      filePath: isTypeScript ? filePath : void 0
+    });
+  } catch (error) {
+    console.warn(`Failed to parse ${filePath}:`, error instanceof Error ? error.message : error);
+    return null;
+  }
+}
+function traverseAST(node, visitor, parent = null) {
+  if (!node) return;
+  visitor.enter?.(node, parent);
+  for (const key of Object.keys(node)) {
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (child && typeof child === "object" && "type" in child) {
+          traverseAST(child, visitor, node);
+        }
+      }
+    } else if (value && typeof value === "object" && "type" in value) {
+      traverseAST(value, visitor, node);
+    }
+  }
+  visitor.leave?.(node, parent);
+}
+function isLoopStatement(node) {
+  return [
+    "ForStatement",
+    "ForInStatement",
+    "ForOfStatement",
+    "WhileStatement",
+    "DoWhileStatement"
+  ].includes(node.type);
+}
+function getFunctionName(node) {
+  switch (node.type) {
+    case "FunctionDeclaration":
+      return node.id?.name ?? null;
+    case "FunctionExpression":
+      return node.id?.name ?? null;
+    case "ArrowFunctionExpression":
+      return null;
+    // Arrow functions don't have names directly
+    case "MethodDefinition":
+      if (node.key.type === "Identifier") {
+        return node.key.name;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function getLineNumber(node) {
+  return node.loc?.start.line ?? 0;
+}
+function isCoverageContext(node, ancestors) {
+  const coveragePatterns = /coverage|summary|metrics|pct|percent|statements|branches|functions|lines/i;
+  if (node.type === "Identifier" && coveragePatterns.test(node.name)) {
+    return true;
+  }
+  for (const ancestor of ancestors.slice(-3)) {
+    if (ancestor.type === "MemberExpression") {
+      const memberExpr = ancestor;
+      if (memberExpr.object.type === "Identifier" && coveragePatterns.test(memberExpr.object.name)) {
+        return true;
+      }
+    }
+    if (ancestor.type === "ObjectPattern" || ancestor.type === "ObjectExpression") {
+      const parent = ancestors[ancestors.indexOf(ancestor) - 1];
+      if (parent?.type === "VariableDeclarator") {
+        const varDecl = parent;
+        if (varDecl.id.type === "Identifier" && coveragePatterns.test(varDecl.id.name)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// src/utils/scope-tracker.ts
+var ScopeTracker = class {
+  constructor(rootNode) {
+    this.allScopes = [];
+    this.rootScope = {
+      type: "global",
+      node: rootNode,
+      parent: null,
+      children: [],
+      variables: /* @__PURE__ */ new Map()
+    };
+    this.currentScope = this.rootScope;
+    this.allScopes.push(this.rootScope);
+  }
+  /**
+   * Enter a new scope
+   */
+  enterScope(type, node) {
+    const newScope = {
+      type,
+      node,
+      parent: this.currentScope,
+      children: [],
+      variables: /* @__PURE__ */ new Map()
+    };
+    this.currentScope.children.push(newScope);
+    this.currentScope = newScope;
+    this.allScopes.push(newScope);
+  }
+  /**
+   * Exit current scope and return to parent
+   */
+  exitScope() {
+    if (this.currentScope.parent) {
+      this.currentScope = this.currentScope.parent;
+    }
+  }
+  /**
+   * Declare a variable in the current scope
+   */
+  declareVariable(name, node, line, options = {}) {
+    const varInfo = {
+      name,
+      node,
+      declarationLine: line,
+      references: [],
+      type: options.type,
+      isParameter: options.isParameter ?? false,
+      isDestructured: options.isDestructured ?? false,
+      isLoopVariable: options.isLoopVariable ?? false
+    };
+    this.currentScope.variables.set(name, varInfo);
+  }
+  /**
+   * Add a reference to a variable
+   */
+  addReference(name, node) {
+    const varInfo = this.findVariable(name);
+    if (varInfo) {
+      varInfo.references.push(node);
+    }
+  }
+  /**
+   * Find a variable in current or parent scopes
+   */
+  findVariable(name) {
+    let scope = this.currentScope;
+    while (scope) {
+      const varInfo = scope.variables.get(name);
+      if (varInfo) {
+        return varInfo;
+      }
+      scope = scope.parent;
+    }
+    return null;
+  }
+  /**
+   * Get all variables in current scope (not including parent scopes)
+   */
+  getCurrentScopeVariables() {
+    return Array.from(this.currentScope.variables.values());
+  }
+  /**
+   * Get all variables across all scopes
+   */
+  getAllVariables() {
+    const allVars = [];
+    for (const scope of this.allScopes) {
+      allVars.push(...Array.from(scope.variables.values()));
+    }
+    return allVars;
+  }
+  /**
+   * Calculate actual usage count (references minus declaration)
+   */
+  getUsageCount(varInfo) {
+    return varInfo.references.length;
+  }
+  /**
+   * Check if a variable is short-lived (used within N lines)
+   */
+  isShortLived(varInfo, maxLines = 5) {
+    if (varInfo.references.length === 0) {
+      return false;
+    }
+    const declarationLine = varInfo.declarationLine;
+    const maxUsageLine = Math.max(
+      ...varInfo.references.map((ref) => ref.loc?.start.line ?? declarationLine)
+    );
+    return maxUsageLine - declarationLine <= maxLines;
+  }
+  /**
+   * Check if a variable is used in a limited scope (e.g., only in one callback)
+   */
+  isLocallyScoped(varInfo) {
+    if (varInfo.references.length === 0) return false;
+    const lines = varInfo.references.map((ref) => ref.loc?.start.line ?? 0);
+    const minLine = Math.min(...lines);
+    const maxLine = Math.max(...lines);
+    return maxLine - minLine <= 3;
+  }
+  /**
+   * Get current scope type
+   */
+  getCurrentScopeType() {
+    return this.currentScope.type;
+  }
+  /**
+   * Check if currently in a loop scope
+   */
+  isInLoop() {
+    let scope = this.currentScope;
+    while (scope) {
+      if (scope.type === "loop") {
+        return true;
+      }
+      scope = scope.parent;
+    }
+    return false;
+  }
+  /**
+   * Check if currently in a function scope
+   */
+  isInFunction() {
+    let scope = this.currentScope;
+    while (scope) {
+      if (scope.type === "function") {
+        return true;
+      }
+      scope = scope.parent;
+    }
+    return false;
+  }
+  /**
+   * Get the root scope
+   */
+  getRootScope() {
+    return this.rootScope;
+  }
+};
+
+// src/utils/context-detector.ts
+function detectFileType(filePath, ast) {
+  const path = filePath.toLowerCase();
+  if (path.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/) || path.includes("__tests__")) {
+    return "test";
+  }
+  if (path.endsWith(".d.ts") || path.includes("types")) {
+    return "types";
+  }
+  if (path.match(/config|\.config\.|rc\.|setup/) || path.includes("configuration")) {
+    return "config";
+  }
+  return "production";
+}
+function detectCodeLayer(ast) {
+  let hasAPIIndicators = 0;
+  let hasBusinessIndicators = 0;
+  let hasDataIndicators = 0;
+  let hasUtilityIndicators = 0;
+  traverseAST(ast, {
+    enter: (node) => {
+      if (node.type === "ImportDeclaration") {
+        const source = node.source.value;
+        if (source.match(/express|fastify|koa|@nestjs|axios|fetch|http/i)) {
+          hasAPIIndicators++;
+        }
+        if (source.match(/database|prisma|typeorm|sequelize|mongoose|pg|mysql/i)) {
+          hasDataIndicators++;
+        }
+      }
+      if (node.type === "FunctionDeclaration" && node.id) {
+        const name = node.id.name;
+        if (name.match(/^(get|post|put|delete|patch|handle|api|route|controller)/i)) {
+          hasAPIIndicators++;
+        }
+        if (name.match(/^(calculate|process|validate|transform|compute|analyze)/i)) {
+          hasBusinessIndicators++;
+        }
+        if (name.match(/^(find|create|update|delete|save|fetch|query|insert)/i)) {
+          hasDataIndicators++;
+        }
+        if (name.match(/^(format|parse|convert|normalize|sanitize|encode|decode)/i)) {
+          hasUtilityIndicators++;
+        }
+      }
+      if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+        if (node.type === "ExportNamedDeclaration" && node.declaration) {
+          if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+            const name = node.declaration.id.name;
+            if (name.match(/handler|route|api|controller/i)) {
+              hasAPIIndicators += 2;
+            }
+          }
+        }
+      }
+    }
+  });
+  const scores = {
+    api: hasAPIIndicators,
+    business: hasBusinessIndicators,
+    data: hasDataIndicators,
+    utility: hasUtilityIndicators
+  };
+  const maxScore = Math.max(...Object.values(scores));
+  if (maxScore === 0) {
+    return "unknown";
+  }
+  if (scores.api === maxScore) return "api";
+  if (scores.data === maxScore) return "data";
+  if (scores.business === maxScore) return "business";
+  if (scores.utility === maxScore) return "utility";
+  return "unknown";
+}
+function calculateComplexity(node) {
+  let complexity = 1;
+  traverseAST(node, {
+    enter: (childNode) => {
+      switch (childNode.type) {
+        case "IfStatement":
+        case "ConditionalExpression":
+        // ternary
+        case "SwitchCase":
+        case "ForStatement":
+        case "ForInStatement":
+        case "ForOfStatement":
+        case "WhileStatement":
+        case "DoWhileStatement":
+        case "CatchClause":
+          complexity++;
+          break;
+        case "LogicalExpression":
+          if (childNode.operator === "&&" || childNode.operator === "||") {
+            complexity++;
+          }
+          break;
+      }
+    }
+  });
+  return complexity;
+}
+function buildCodeContext(filePath, ast) {
+  const fileType = detectFileType(filePath, ast);
+  const codeLayer = detectCodeLayer(ast);
+  let totalComplexity = 0;
+  let functionCount = 0;
+  traverseAST(ast, {
+    enter: (node) => {
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+        totalComplexity += calculateComplexity(node);
+        functionCount++;
+      }
+    }
+  });
+  const avgComplexity = functionCount > 0 ? totalComplexity / functionCount : 1;
+  return {
+    fileType,
+    codeLayer,
+    complexity: Math.round(avgComplexity),
+    isTestFile: fileType === "test",
+    isTypeDefinition: fileType === "types"
+  };
+}
+function adjustSeverity(baseSeverity, context, issueType) {
+  if (context.isTestFile) {
+    if (baseSeverity === "minor") return "info";
+    if (baseSeverity === "major") return "minor";
+  }
+  if (context.isTypeDefinition) {
+    if (baseSeverity === "minor") return "info";
+  }
+  if (context.codeLayer === "api") {
+    if (baseSeverity === "info" && issueType === "unclear") return "minor";
+    if (baseSeverity === "minor" && issueType === "unclear") return "major";
+  }
+  if (context.complexity > 10) {
+    if (baseSeverity === "info") return "minor";
+  }
+  if (context.codeLayer === "utility") {
+    if (baseSeverity === "minor" && issueType === "abbreviation") return "info";
+  }
+  return baseSeverity;
+}
+function isAcceptableInContext(name, context, options) {
+  if (options.isLoopVariable && ["i", "j", "k", "l", "n", "m"].includes(name)) {
+    return true;
+  }
+  if (context.isTestFile) {
+    if (["a", "b", "c", "x", "y", "z"].includes(name) && options.isParameter) {
+      return true;
+    }
+  }
+  if (context.codeLayer === "utility" && ["x", "y", "z"].includes(name)) {
+    return true;
+  }
+  if (options.isDestructured) {
+    if (["s", "b", "f", "l"].includes(name)) {
+      return true;
+    }
+  }
+  if (options.isParameter && (options.complexity ?? context.complexity) < 3) {
+    if (name.length >= 2) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/analyzers/naming-ast.ts
+var COMMON_SHORT_WORDS = /* @__PURE__ */ new Set([
+  "day",
+  "key",
+  "net",
+  "to",
+  "go",
+  "for",
+  "not",
+  "new",
+  "old",
+  "top",
+  "end",
+  "run",
+  "try",
+  "use",
+  "get",
+  "set",
+  "add",
+  "put",
+  "map",
+  "log",
+  "row",
+  "col",
+  "tab",
+  "box",
+  "div",
+  "nav",
+  "tag",
+  "any",
+  "all",
+  "one",
+  "two",
+  "out",
+  "off",
+  "on",
+  "yes",
+  "no",
+  "now",
+  "max",
+  "min",
+  "sum",
+  "avg",
+  "ref",
+  "src",
+  "dst",
+  "raw",
+  "def",
+  "sub",
+  "pub",
+  "pre",
+  "mid",
+  "alt",
+  "opt",
+  "tmp",
+  "ext",
+  "sep",
+  "and",
+  "from",
+  "how",
+  "pad",
+  "bar",
+  "non",
+  "tax",
+  "cat",
+  "dog",
+  "car",
+  "bus",
+  "web",
+  "app",
+  "war",
+  "law",
+  "pay",
+  "buy",
+  "win",
+  "cut",
+  "hit",
+  "hot",
+  "pop",
+  "job",
+  "age",
+  "act",
+  "let",
+  "lot",
+  "bad",
+  "big",
+  "far",
+  "few",
+  "own",
+  "per",
+  "red",
+  "low",
+  "see",
+  "six",
+  "ten",
+  "way",
+  "who",
+  "why",
+  "yet",
+  "via",
+  "due",
+  "fee",
+  "fun",
+  "gas",
+  "gay",
+  "god",
+  "gun",
+  "guy",
+  "ice",
+  "ill",
+  "kid",
+  "mad",
+  "man",
+  "mix",
+  "mom",
+  "mrs",
+  "nor",
+  "odd",
+  "oil",
+  "pan",
+  "pet",
+  "pit",
+  "pot",
+  "pow",
+  "pro",
+  "raw",
+  "rep",
+  "rid",
+  "sad",
+  "sea",
+  "sit",
+  "sky",
+  "son",
+  "tea",
+  "tie",
+  "tip",
+  "van",
+  "war",
+  "win",
+  "won"
+]);
+var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "id",
+  "uid",
+  "gid",
+  "pid",
+  "i",
+  "j",
+  "k",
+  "n",
+  "m",
+  "url",
+  "uri",
+  "api",
+  "cdn",
+  "dns",
+  "ip",
+  "tcp",
+  "udp",
+  "http",
+  "ssl",
+  "tls",
+  "utm",
+  "seo",
+  "rss",
+  "xhr",
+  "ajax",
+  "cors",
+  "ws",
+  "wss",
+  "json",
+  "xml",
+  "yaml",
+  "csv",
+  "html",
+  "css",
+  "svg",
+  "pdf",
+  "img",
+  "txt",
+  "doc",
+  "docx",
+  "xlsx",
+  "ppt",
+  "md",
+  "rst",
+  "jpg",
+  "png",
+  "gif",
+  "db",
+  "sql",
+  "orm",
+  "dao",
+  "dto",
+  "ddb",
+  "rds",
+  "nosql",
+  "fs",
+  "dir",
+  "tmp",
+  "src",
+  "dst",
+  "bin",
+  "lib",
+  "pkg",
+  "os",
+  "env",
+  "arg",
+  "cli",
+  "cmd",
+  "exe",
+  "cwd",
+  "pwd",
+  "ui",
+  "ux",
+  "gui",
+  "dom",
+  "ref",
+  "req",
+  "res",
+  "ctx",
+  "err",
+  "msg",
+  "auth",
+  "max",
+  "min",
+  "avg",
+  "sum",
+  "abs",
+  "cos",
+  "sin",
+  "tan",
+  "log",
+  "exp",
+  "pow",
+  "sqrt",
+  "std",
+  "var",
+  "int",
+  "num",
+  "idx",
+  "now",
+  "utc",
+  "tz",
+  "ms",
+  "sec",
+  "hr",
+  "min",
+  "yr",
+  "mo",
+  "app",
+  "cfg",
+  "config",
+  "init",
+  "len",
+  "val",
+  "str",
+  "obj",
+  "arr",
+  "gen",
+  "def",
+  "raw",
+  "new",
+  "old",
+  "pre",
+  "post",
+  "sub",
+  "pub",
+  "ts",
+  "js",
+  "jsx",
+  "tsx",
+  "py",
+  "rb",
+  "vue",
+  "re",
+  "fn",
+  "fns",
+  "mod",
+  "opts",
+  "dev",
+  "s3",
+  "ec2",
+  "sqs",
+  "sns",
+  "vpc",
+  "ami",
+  "iam",
+  "acl",
+  "elb",
+  "alb",
+  "nlb",
+  "aws",
+  "ses",
+  "gst",
+  "cdk",
+  "btn",
+  "buf",
+  "agg",
+  "ocr",
+  "ai",
+  "cf",
+  "cfn",
+  "ga",
+  "fcp",
+  "lcp",
+  "cls",
+  "ttfb",
+  "tti",
+  "fid",
+  "fps",
+  "qps",
+  "rps",
+  "tps",
+  "wpm",
+  "po",
+  "e2e",
+  "a11y",
+  "i18n",
+  "l10n",
+  "spy",
+  "sk",
+  "fy",
+  "faq",
+  "og",
+  "seo",
+  "cta",
+  "roi",
+  "kpi",
+  "ttl",
+  "pct",
+  "mac",
+  "hex",
+  "esm",
+  "git",
+  "rec",
+  "loc",
+  "dup",
+  "is",
+  "has",
+  "can",
+  "did",
+  "was",
+  "are",
+  "d",
+  "t",
+  "dt",
+  "s",
+  "b",
+  "f",
+  "l",
+  // Coverage metrics
+  "vid",
+  "pic",
+  "img",
+  "doc",
+  "msg"
+]);
+async function analyzeNamingAST(files) {
+  const issues = [];
+  const rootDir = files.length > 0 ? dirname(files[0]) : process.cwd();
+  const config = loadConfig(rootDir);
+  const consistencyConfig = config?.tools?.["consistency"];
+  const customAbbreviations = new Set(consistencyConfig?.acceptedAbbreviations || []);
+  const customShortWords = new Set(consistencyConfig?.shortWords || []);
+  const disabledChecks = new Set(consistencyConfig?.disableChecks || []);
+  const allAbbreviations = /* @__PURE__ */ new Set([...ACCEPTABLE_ABBREVIATIONS, ...customAbbreviations]);
+  const allShortWords = /* @__PURE__ */ new Set([...COMMON_SHORT_WORDS, ...customShortWords]);
+  for (const file of files) {
+    try {
+      const ast = parseFile(file);
+      if (!ast) continue;
+      const fileIssues = analyzeFileNamingAST(
+        file,
+        ast,
+        allAbbreviations,
+        allShortWords,
+        disabledChecks
+      );
+      issues.push(...fileIssues);
+    } catch (error) {
+      console.warn(`Skipping ${file} due to parse error:`, error);
+    }
+  }
+  return issues;
+}
+function analyzeFileNamingAST(file, ast, allAbbreviations, allShortWords, disabledChecks) {
+  const issues = [];
+  const scopeTracker = new ScopeTracker(ast);
+  const context = buildCodeContext(file, ast);
+  const ancestors = [];
+  traverseAST(ast, {
+    enter: (node, parent) => {
+      ancestors.push(node);
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+        scopeTracker.enterScope("function", node);
+        if ("params" in node) {
+          for (const param of node.params) {
+            if (param.type === "Identifier") {
+              scopeTracker.declareVariable(param.name, param, getLineNumber(param), {
+                isParameter: true
+              });
+            } else if (param.type === "ObjectPattern" || param.type === "ArrayPattern") {
+              extractIdentifiersFromPattern(param, scopeTracker, true);
+            }
+          }
+        }
+      } else if (node.type === "BlockStatement") {
+        scopeTracker.enterScope("block", node);
+      } else if (isLoopStatement(node)) {
+        scopeTracker.enterScope("loop", node);
+      } else if (node.type === "ClassDeclaration") {
+        scopeTracker.enterScope("class", node);
+      }
+      if (node.type === "VariableDeclarator") {
+        if (node.id.type === "Identifier") {
+          const isInCoverage = isCoverageContext(node, ancestors);
+          scopeTracker.declareVariable(
+            node.id.name,
+            node.id,
+            getLineNumber(node.id),
+            {
+              type: "typeAnnotation" in node.id ? node.id.typeAnnotation : null,
+              isDestructured: false,
+              isLoopVariable: scopeTracker.getCurrentScopeType() === "loop"
+            }
+          );
+        } else if (node.id.type === "ObjectPattern" || node.id.type === "ArrayPattern") {
+          extractIdentifiersFromPattern(node.id, scopeTracker, false, ancestors);
+        }
+      }
+      if (node.type === "Identifier" && parent) {
+        if (parent.type !== "VariableDeclarator" || parent.id !== node) {
+          if (parent.type !== "FunctionDeclaration" || parent.id !== node) {
+            scopeTracker.addReference(node.name, node);
+          }
+        }
+      }
+    },
+    leave: (node) => {
+      ancestors.pop();
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "BlockStatement" || isLoopStatement(node) || node.type === "ClassDeclaration") {
+        scopeTracker.exitScope();
+      }
+    }
+  });
+  const allVariables = scopeTracker.getAllVariables();
+  for (const varInfo of allVariables) {
+    const name = varInfo.name;
+    const line = varInfo.declarationLine;
+    if (disabledChecks.has("single-letter") && name.length === 1) continue;
+    if (disabledChecks.has("abbreviation") && name.length <= 3) continue;
+    const isInCoverage = ["s", "b", "f", "l"].includes(name) && varInfo.isDestructured;
+    if (isInCoverage) continue;
+    const functionComplexity = varInfo.node.type === "Identifier" && "parent" in varInfo.node ? calculateComplexity(varInfo.node) : context.complexity;
+    if (isAcceptableInContext(name, context, {
+      isLoopVariable: varInfo.isLoopVariable || allAbbreviations.has(name),
+      isParameter: varInfo.isParameter,
+      isDestructured: varInfo.isDestructured,
+      complexity: functionComplexity
+    })) {
+      continue;
+    }
+    if (name.length === 1 && !allAbbreviations.has(name) && !allShortWords.has(name)) {
+      const isShortLived = scopeTracker.isShortLived(varInfo, 5);
+      if (!isShortLived) {
+        issues.push({
+          file,
+          line,
+          type: "poor-naming",
+          identifier: name,
+          severity: adjustSeverity("minor", context, "poor-naming"),
+          suggestion: `Use descriptive variable name instead of single letter '${name}'`
+        });
+      }
+      continue;
+    }
+    if (name.length >= 2 && name.length <= 3) {
+      if (!allShortWords.has(name.toLowerCase()) && !allAbbreviations.has(name.toLowerCase())) {
+        const isShortLived = scopeTracker.isShortLived(varInfo, 5);
+        if (!isShortLived) {
+          issues.push({
+            file,
+            line,
+            type: "abbreviation",
+            identifier: name,
+            severity: adjustSeverity("info", context, "abbreviation"),
+            suggestion: `Consider using full word instead of abbreviation '${name}'`
+          });
+        }
+      }
+      continue;
+    }
+    if (!disabledChecks.has("convention-mix") && file.match(/\.(ts|tsx|js|jsx)$/)) {
+      if (name.includes("_") && !name.startsWith("_") && name.toLowerCase() === name) {
+        const camelCase = name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        issues.push({
+          file,
+          line,
+          type: "convention-mix",
+          identifier: name,
+          severity: adjustSeverity("minor", context, "convention-mix"),
+          suggestion: `Use camelCase '${camelCase}' instead of snake_case in TypeScript/JavaScript`
+        });
+      }
+    }
+  }
+  if (!disabledChecks.has("unclear")) {
+    traverseAST(ast, {
+      enter: (node) => {
+        if (node.type === "FunctionDeclaration" || node.type === "MethodDefinition") {
+          const name = getFunctionName(node);
+          if (!name) return;
+          const line = getLineNumber(node);
+          if (["main", "init", "setup", "bootstrap"].includes(name)) return;
+          const hasActionVerb = name.match(/^(get|set|is|has|can|should|create|update|delete|fetch|load|save|process|handle|validate|check|find|search|filter|map|reduce|make|do|run|start|stop|build|parse|format|render|calculate|compute|generate|transform|convert|normalize|sanitize|encode|decode|compress|extract|merge|split|join|sort|compare|test|verify|ensure|apply|execute|invoke|call|emit|dispatch|trigger|listen|subscribe|unsubscribe|add|remove|clear|reset|toggle|enable|disable|open|close|connect|disconnect|send|receive|read|write|import|export|register|unregister|mount|unmount|track|store|persist|upsert|derive|classify|combine|discover|activate|require|assert|expect|mask|escape|sign|put|list|complete|page|safe|mock|pick|pluralize|text)/);
+          const isFactoryPattern = name.match(/(Factory|Builder|Creator|Generator|Provider|Adapter|Mock)$/);
+          const isEventHandler = name.match(/^on[A-Z]/);
+          const isDescriptiveLong = name.length > 15;
+          const isReactHook = name.match(/^use[A-Z]/);
+          const isHelperPattern = name.match(/^(to|from|with|without|for|as|into)\w+/);
+          const isUtilityName = ["cn", "proxy", "sitemap", "robots", "gtag"].includes(name);
+          if (!hasActionVerb && !isFactoryPattern && !isEventHandler && !isDescriptiveLong && !isReactHook && !isHelperPattern && !isUtilityName) {
+            issues.push({
+              file,
+              line,
+              type: "unclear",
+              identifier: name,
+              severity: adjustSeverity("info", context, "unclear"),
+              suggestion: `Function '${name}' should start with an action verb (get, set, create, etc.)`
+            });
+          }
+        }
+      }
+    });
+  }
+  return issues;
+}
+function extractIdentifiersFromPattern(pattern, scopeTracker, isParameter, ancestors) {
+  if (pattern.type === "ObjectPattern") {
+    for (const prop of pattern.properties) {
+      if (prop.type === "Property" && prop.value.type === "Identifier") {
+        scopeTracker.declareVariable(
+          prop.value.name,
+          prop.value,
+          getLineNumber(prop.value),
+          {
+            isParameter,
+            isDestructured: true
+          }
+        );
+      } else if (prop.type === "RestElement" && prop.argument.type === "Identifier") {
+        scopeTracker.declareVariable(
+          prop.argument.name,
+          prop.argument,
+          getLineNumber(prop.argument),
+          {
+            isParameter,
+            isDestructured: true
+          }
+        );
+      }
+    }
+  } else if (pattern.type === "ArrayPattern") {
+    for (const element of pattern.elements) {
+      if (element && element.type === "Identifier") {
+        scopeTracker.declareVariable(
+          element.name,
+          element,
+          getLineNumber(element),
+          {
+            isParameter,
+            isDestructured: true
+          }
+        );
+      }
+    }
+  }
+}
+
+// src/analyzers/patterns.ts
+import { readFileContent } from "@aiready/core";
+async function analyzePatterns(files) {
+  const issues = [];
+  const errorHandlingIssues = await analyzeErrorHandling(files);
+  issues.push(...errorHandlingIssues);
+  const asyncIssues = await analyzeAsyncPatterns(files);
+  issues.push(...asyncIssues);
+  const importIssues = await analyzeImportStyles(files);
+  issues.push(...importIssues);
+  return issues;
+}
+async function analyzeErrorHandling(files) {
+  const patterns = {
+    tryCatch: [],
+    throwsError: [],
+    returnsNull: [],
+    returnsError: []
+  };
+  for (const file of files) {
+    const content = await readFileContent(file);
+    if (content.includes("try {") || content.includes("} catch")) {
+      patterns.tryCatch.push(file);
+    }
+    if (content.match(/throw new \w*Error/)) {
+      patterns.throwsError.push(file);
+    }
+    if (content.match(/return null/)) {
+      patterns.returnsNull.push(file);
+    }
+    if (content.match(/return \{ error:/)) {
+      patterns.returnsError.push(file);
+    }
+  }
+  const issues = [];
+  const strategiesUsed = Object.values(patterns).filter((p) => p.length > 0).length;
+  if (strategiesUsed > 2) {
+    issues.push({
+      files: [.../* @__PURE__ */ new Set([
+        ...patterns.tryCatch,
+        ...patterns.throwsError,
+        ...patterns.returnsNull,
+        ...patterns.returnsError
+      ])],
+      type: "error-handling",
+      description: "Inconsistent error handling strategies across codebase",
+      examples: [
+        patterns.tryCatch.length > 0 ? `Try-catch used in ${patterns.tryCatch.length} files` : "",
+        patterns.throwsError.length > 0 ? `Throws errors in ${patterns.throwsError.length} files` : "",
+        patterns.returnsNull.length > 0 ? `Returns null in ${patterns.returnsNull.length} files` : "",
+        patterns.returnsError.length > 0 ? `Returns error objects in ${patterns.returnsError.length} files` : ""
+      ].filter((e) => e),
+      severity: "major"
+    });
+  }
+  return issues;
+}
+async function analyzeAsyncPatterns(files) {
+  const patterns = {
+    asyncAwait: [],
+    promises: [],
+    callbacks: []
+  };
+  for (const file of files) {
+    const content = await readFileContent(file);
+    if (content.match(/async\s+(function|\(|[a-zA-Z])/)) {
+      patterns.asyncAwait.push(file);
+    }
+    if (content.match(/\.then\(/) || content.match(/\.catch\(/)) {
+      patterns.promises.push(file);
+    }
+    if (content.match(/callback\s*\(/) || content.match(/\(\s*err\s*,/)) {
+      patterns.callbacks.push(file);
+    }
+  }
+  const issues = [];
+  if (patterns.callbacks.length > 0 && patterns.asyncAwait.length > 0) {
+    issues.push({
+      files: [...patterns.callbacks, ...patterns.asyncAwait],
+      type: "async-style",
+      description: "Mixed async patterns: callbacks and async/await",
+      examples: [
+        `Callbacks found in: ${patterns.callbacks.slice(0, 3).join(", ")}`,
+        `Async/await used in: ${patterns.asyncAwait.slice(0, 3).join(", ")}`
+      ],
+      severity: "minor"
+    });
+  }
+  if (patterns.promises.length > patterns.asyncAwait.length * 0.3 && patterns.asyncAwait.length > 0) {
+    issues.push({
+      files: patterns.promises,
+      type: "async-style",
+      description: "Consider using async/await instead of promise chains for consistency",
+      examples: patterns.promises.slice(0, 5),
+      severity: "info"
+    });
+  }
+  return issues;
+}
+async function analyzeImportStyles(files) {
+  const patterns = {
+    esModules: [],
+    commonJS: [],
+    mixed: []
+  };
+  for (const file of files) {
+    const content = await readFileContent(file);
+    const hasESM = content.match(/^import\s+/m);
+    const hasCJS = content.match(/require\s*\(/);
+    if (hasESM && hasCJS) {
+      patterns.mixed.push(file);
+    } else if (hasESM) {
+      patterns.esModules.push(file);
+    } else if (hasCJS) {
+      patterns.commonJS.push(file);
+    }
+  }
+  const issues = [];
+  if (patterns.mixed.length > 0) {
+    issues.push({
+      files: patterns.mixed,
+      type: "import-style",
+      description: "Mixed ES modules and CommonJS imports in same files",
+      examples: patterns.mixed.slice(0, 5),
+      severity: "major"
+    });
+  }
+  if (patterns.esModules.length > 0 && patterns.commonJS.length > 0) {
+    const ratio = patterns.commonJS.length / (patterns.esModules.length + patterns.commonJS.length);
+    if (ratio > 0.2 && ratio < 0.8) {
+      issues.push({
+        files: [...patterns.esModules, ...patterns.commonJS],
+        type: "import-style",
+        description: "Inconsistent import styles across project",
+        examples: [
+          `ES modules: ${patterns.esModules.length} files`,
+          `CommonJS: ${patterns.commonJS.length} files`
+        ],
+        severity: "minor"
+      });
+    }
+  }
+  return issues;
+}
+
+// src/analyzer.ts
+import { scanFiles } from "@aiready/core";
+async function analyzeConsistency(options) {
+  const {
+    checkNaming = true,
+    checkPatterns = true,
+    checkArchitecture = false,
+    // Not implemented yet
+    minSeverity = "info",
+    ...scanOptions
+  } = options;
+  const filePaths = await scanFiles(scanOptions);
+  const namingIssues = checkNaming ? await analyzeNamingAST(filePaths) : [];
+  const patternIssues = checkPatterns ? await analyzePatterns(filePaths) : [];
+  const results = [];
+  const fileIssuesMap = /* @__PURE__ */ new Map();
+  for (const issue of namingIssues) {
+    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
+      continue;
+    }
+    const consistencyIssue = {
+      type: issue.type === "convention-mix" ? "naming-inconsistency" : "naming-quality",
+      category: "naming",
+      severity: issue.severity,
+      message: `${issue.type}: ${issue.identifier}`,
+      location: {
+        file: issue.file,
+        line: issue.line,
+        column: issue.column
+      },
+      suggestion: issue.suggestion
+    };
+    if (!fileIssuesMap.has(issue.file)) {
+      fileIssuesMap.set(issue.file, []);
+    }
+    fileIssuesMap.get(issue.file).push(consistencyIssue);
+  }
+  for (const issue of patternIssues) {
+    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
+      continue;
+    }
+    const consistencyIssue = {
+      type: "pattern-inconsistency",
+      category: "patterns",
+      severity: issue.severity,
+      message: issue.description,
+      location: {
+        file: issue.files[0] || "multiple files",
+        line: 1
+      },
+      examples: issue.examples,
+      suggestion: `Standardize ${issue.type} patterns across ${issue.files.length} files`
+    };
+    const firstFile = issue.files[0];
+    if (firstFile && !fileIssuesMap.has(firstFile)) {
+      fileIssuesMap.set(firstFile, []);
+    }
+    if (firstFile) {
+      fileIssuesMap.get(firstFile).push(consistencyIssue);
+    }
+  }
+  for (const [fileName, issues] of fileIssuesMap) {
+    results.push({
+      fileName,
+      issues,
+      metrics: {
+        consistencyScore: calculateConsistencyScore(issues)
+      }
+    });
+  }
+  const recommendations = generateRecommendations(namingIssues, patternIssues);
+  return {
+    summary: {
+      totalIssues: namingIssues.length + patternIssues.length,
+      namingIssues: namingIssues.length,
+      patternIssues: patternIssues.length,
+      architectureIssues: 0,
+      filesAnalyzed: filePaths.length
+    },
+    results,
+    recommendations
+  };
+}
+function shouldIncludeSeverity(severity, minSeverity) {
+  const severityLevels = { info: 0, minor: 1, major: 2, critical: 3 };
+  return severityLevels[severity] >= severityLevels[minSeverity];
+}
+function calculateConsistencyScore(issues) {
+  const weights = { critical: 10, major: 5, minor: 2, info: 1 };
+  const totalWeight = issues.reduce((sum, issue) => sum + weights[issue.severity], 0);
+  return Math.max(0, 1 - totalWeight / 100);
+}
+function generateRecommendations(namingIssues, patternIssues) {
+  const recommendations = [];
+  if (namingIssues.length > 0) {
+    const conventionMixCount = namingIssues.filter((i) => i.type === "convention-mix").length;
+    if (conventionMixCount > 0) {
+      recommendations.push(
+        `Standardize naming conventions: Found ${conventionMixCount} snake_case variables in TypeScript/JavaScript (use camelCase)`
+      );
+    }
+    const poorNamingCount = namingIssues.filter((i) => i.type === "poor-naming").length;
+    if (poorNamingCount > 0) {
+      recommendations.push(
+        `Improve variable naming: Found ${poorNamingCount} single-letter or unclear variable names`
+      );
+    }
+  }
+  if (patternIssues.length > 0) {
+    const errorHandlingIssues = patternIssues.filter((i) => i.type === "error-handling");
+    if (errorHandlingIssues.length > 0) {
+      recommendations.push(
+        "Standardize error handling strategy across the codebase (prefer try-catch with typed errors)"
+      );
+    }
+    const asyncIssues = patternIssues.filter((i) => i.type === "async-style");
+    if (asyncIssues.length > 0) {
+      recommendations.push(
+        "Use async/await consistently instead of mixing with promise chains or callbacks"
+      );
+    }
+    const importIssues = patternIssues.filter((i) => i.type === "import-style");
+    if (importIssues.length > 0) {
+      recommendations.push(
+        "Use ES modules consistently across the project (avoid mixing with CommonJS)"
+      );
+    }
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("No major consistency issues found! Your codebase follows good practices.");
+  }
+  return recommendations;
+}
+
+export {
+  analyzeNamingAST,
+  analyzePatterns,
+  analyzeConsistency
+};