@aiready/consistency 0.4.1 → 0.6.0

package/dist/cli.js

@@ -29,11 +29,436 @@ var import_commander = require("commander");
 // src/analyzer.ts
 var import_core3 = require("@aiready/core");
 
-// src/analyzers/naming.ts
+// src/analyzers/naming-ast.ts
 var import_core = require("@aiready/core");
 var import_path = require("path");
+
+// src/utils/ast-parser.ts
+var import_typescript_estree = require("@typescript-eslint/typescript-estree");
+var import_fs = require("fs");
+function parseFile(filePath, content) {
+  try {
+    const code = content ?? (0, import_fs.readFileSync)(filePath, "utf-8");
+    const isTypeScript = filePath.match(/\.tsx?$/);
+    return (0, import_typescript_estree.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([
-  // Full English words (1-3 letters)
   "day",
   "key",
   "net",
@@ -89,14 +514,12 @@ var COMMON_SHORT_WORDS = /* @__PURE__ */ new Set([
   "tmp",
   "ext",
   "sep",
-  // Prepositions and conjunctions
   "and",
   "from",
   "how",
   "pad",
   "bar",
   "non",
-  // Additional full words commonly flagged
   "tax",
   "cat",
   "dog",
@@ -176,18 +599,15 @@ var COMMON_SHORT_WORDS = /* @__PURE__ */ new Set([
   "won"
 ]);
 var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
-  // Standard identifiers
   "id",
   "uid",
   "gid",
   "pid",
-  // Loop counters and iterators
   "i",
   "j",
   "k",
   "n",
   "m",
-  // Web/Network
   "url",
   "uri",
   "api",
@@ -207,7 +627,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "cors",
   "ws",
   "wss",
-  // Data formats
   "json",
   "xml",
   "yaml",
@@ -216,7 +635,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "css",
   "svg",
   "pdf",
-  // File types & extensions
   "img",
   "txt",
   "doc",
@@ -228,7 +646,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "jpg",
   "png",
   "gif",
-  // Databases
   "db",
   "sql",
   "orm",
@@ -237,7 +654,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "ddb",
   "rds",
   "nosql",
-  // File system
   "fs",
   "dir",
   "tmp",
@@ -246,7 +662,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "bin",
   "lib",
   "pkg",
-  // Operating system
   "os",
   "env",
   "arg",
@@ -255,20 +670,17 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "exe",
   "cwd",
   "pwd",
-  // UI/UX
   "ui",
   "ux",
   "gui",
   "dom",
   "ref",
-  // Request/Response
   "req",
   "res",
   "ctx",
   "err",
   "msg",
   "auth",
-  // Mathematics/Computing
   "max",
   "min",
   "avg",
@@ -286,7 +698,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "int",
   "num",
   "idx",
-  // Time
   "now",
   "utc",
   "tz",
@@ -296,7 +707,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "min",
   "yr",
   "mo",
-  // Common patterns
   "app",
   "cfg",
   "config",
@@ -315,7 +725,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "post",
   "sub",
   "pub",
-  // Programming/Framework specific
   "ts",
   "js",
   "jsx",
@@ -329,7 +738,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "mod",
   "opts",
   "dev",
-  // Cloud/Infrastructure
   "s3",
   "ec2",
   "sqs",
@@ -353,7 +761,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "cf",
   "cfn",
   "ga",
-  // Metrics/Performance
   "fcp",
   "lcp",
   "cls",
@@ -365,14 +772,12 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "rps",
   "tps",
   "wpm",
-  // Testing & i18n
   "po",
   "e2e",
   "a11y",
   "i18n",
   "l10n",
   "spy",
-  // Domain-specific abbreviations (context-aware)
   "sk",
   "fy",
   "faq",
@@ -383,7 +788,6 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "kpi",
   "ttl",
   "pct",
-  // Technical abbreviations
   "mac",
   "hex",
   "esm",
@@ -391,19 +795,27 @@ var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
   "rec",
   "loc",
   "dup",
-  // Boolean helpers (these are intentional short names)
   "is",
   "has",
   "can",
   "did",
   "was",
   "are",
-  // Date/Time context (when in date contexts)
   "d",
   "t",
-  "dt"
+  "dt",
+  "s",
+  "b",
+  "f",
+  "l",
+  // Coverage metrics
+  "vid",
+  "pic",
+  "img",
+  "doc",
+  "msg"
 ]);
-async function analyzeNaming(files) {
+async function analyzeNamingAST(files) {
   const issues = [];
   const rootDir = files.length > 0 ? (0, import_path.dirname)(files[0]) : process.cwd();
   const config = (0, import_core.loadConfig)(rootDir);
@@ -411,184 +823,221 @@ async function analyzeNaming(files) {
   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) {
-    const content = await (0, import_core.readFileContent)(file);
-    const fileIssues = analyzeFileNaming(file, content, customAbbreviations, customShortWords, disabledChecks);
-    issues.push(...fileIssues);
+    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 analyzeFileNaming(file, content, customAbbreviations, customShortWords, disabledChecks) {
+function analyzeFileNamingAST(file, ast, allAbbreviations, allShortWords, disabledChecks) {
   const issues = [];
-  const isTestFile = file.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/);
-  const lines = content.split("\n");
-  const allAbbreviations = /* @__PURE__ */ new Set([...ACCEPTABLE_ABBREVIATIONS, ...customAbbreviations]);
-  const allShortWords = /* @__PURE__ */ new Set([...COMMON_SHORT_WORDS, ...customShortWords]);
-  const getContextWindow = (index, windowSize = 3) => {
-    const start = Math.max(0, index - windowSize);
-    const end = Math.min(lines.length, index + windowSize + 1);
-    return lines.slice(start, end).join("\n");
-  };
-  const isShortLivedVariable = (varName, declarationIndex) => {
-    const searchRange = 5;
-    const endIndex = Math.min(lines.length, declarationIndex + searchRange + 1);
-    let usageCount = 0;
-    for (let i = declarationIndex; i < endIndex; i++) {
-      const regex = new RegExp(`\\b${varName}\\b`, "g");
-      const matches = lines[i].match(regex);
-      if (matches) {
-        usageCount += matches.length;
-      }
-    }
-    return usageCount >= 2 && usageCount <= 3;
-  };
-  lines.forEach((line, index) => {
-    const lineNumber = index + 1;
-    const contextWindow = getContextWindow(index);
-    if (!disabledChecks.has("single-letter")) {
-      const singleLetterMatches = line.matchAll(/\b(?:const|let|var)\s+([a-hm-z])\s*=/gi);
-      for (const match of singleLetterMatches) {
-        const letter = match[1].toLowerCase();
-        const isInLoopContext = line.includes("for") || /\.(map|filter|forEach|reduce|find|some|every)\s*\(/.test(line) || line.includes("=>") || // Arrow function
-        /\w+\s*=>\s*/.test(line);
-        const isI18nContext = line.includes("useTranslation") || line.includes("i18n.t") || /\bt\s*\(['"]/.test(line);
-        const isArrowFunctionParam = /\(\s*[a-z]\s*(?:,\s*[a-z]\s*)*\)\s*=>/.test(line) || // (s) => or (a, b) =>
-        /[a-z]\s*=>/.test(line) || // s => on same line
-        // Multi-line arrow function detection: look for pattern in context window
-        new RegExp(`\\b${letter}\\s*\\)\\s*$`).test(line) && /=>/.test(contextWindow) || // (s)\n =>
-        new RegExp(`\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`).test(lines[index - 1] || "") && /=>/.test(contextWindow);
-        const isShortLived = isShortLivedVariable(letter, index);
-        if (!isInLoopContext && !isI18nContext && !isArrowFunctionParam && !isShortLived && !["x", "y", "z", "i", "j", "k", "l", "n", "m"].includes(letter)) {
-          if (isTestFile && ["a", "b", "c", "d", "e", "f", "s"].includes(letter)) {
-            continue;
+  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);
+            }
           }
-          issues.push({
-            file,
-            line: lineNumber,
-            type: "poor-naming",
-            identifier: match[1],
-            severity: "minor",
-            suggestion: `Use descriptive variable name instead of single letter '${match[1]}'`
-          });
         }
+      } 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 (!disabledChecks.has("abbreviation")) {
-      const abbreviationMatches = line.matchAll(/\b(?:const|let|var)\s+([a-z]{1,3})(?=[A-Z]|_|\s*=)/g);
-      for (const match of abbreviationMatches) {
-        const abbrev = match[1].toLowerCase();
-        if (allShortWords.has(abbrev)) {
-          continue;
-        }
-        if (allAbbreviations.has(abbrev)) {
-          continue;
-        }
-        const isArrowFunctionParam = /\(\s*[a-z]\s*(?:,\s*[a-z]\s*)*\)\s*=>/.test(line) || // (s) => or (a, b) =>
-        new RegExp(`\\b${abbrev}\\s*=>`).test(line) || // s => on same line
-        // Multi-line arrow function: check context window
-        new RegExp(`\\b${abbrev}\\s*\\)\\s*$`).test(line) && /=>/.test(contextWindow) || // (s)\n =>
-        new RegExp(`\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`).test(lines[index - 1] || "") && new RegExp(`^\\s*${abbrev}\\s*=>`).test(line);
-        if (isArrowFunctionParam) {
-          continue;
+      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 (abbrev.length <= 2) {
-          const isDateTimeContext = /date|time|day|hour|minute|second|timestamp/i.test(line);
-          if (isDateTimeContext && ["d", "t", "dt"].includes(abbrev)) {
-            continue;
-          }
-          const isUserContext = /user|auth|account/i.test(line);
-          if (isUserContext && abbrev === "u") {
-            continue;
+      }
+      if (node.type === "Identifier" && parent) {
+        if (parent.type !== "VariableDeclarator" || parent.id !== node) {
+          if (parent.type !== "FunctionDeclaration" || parent.id !== node) {
+            scopeTracker.addReference(node.name, node);
           }
         }
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "abbreviation",
-          identifier: match[1],
-          severity: "info",
-          suggestion: `Consider using full word instead of abbreviation '${match[1]}'`
-        });
+      }
+    },
+    leave: (node) => {
+      ancestors.pop();
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "BlockStatement" || isLoopStatement(node) || node.type === "ClassDeclaration") {
+        scopeTracker.exitScope();
       }
     }
-    if (!disabledChecks.has("convention-mix") && file.match(/\.(ts|tsx|js|jsx)$/)) {
-      const camelCaseVars = line.match(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*=/);
-      const snakeCaseVars = line.match(/\b(?:const|let|var)\s+([a-z][a-z0-9]*_[a-z0-9_]*)\s*=/);
-      if (snakeCaseVars) {
+  });
+  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: lineNumber,
-          type: "convention-mix",
-          identifier: snakeCaseVars[1],
-          severity: "minor",
-          suggestion: `Use camelCase '${snakeCaseToCamelCase(snakeCaseVars[1])}' instead of snake_case in TypeScript/JavaScript`
+          line,
+          type: "poor-naming",
+          identifier: name,
+          severity: adjustSeverity("minor", context, "poor-naming"),
+          suggestion: `Use descriptive variable name instead of single letter '${name}'`
         });
       }
+      continue;
     }
-    if (!disabledChecks.has("unclear")) {
-      const booleanMatches = line.matchAll(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*:\s*boolean/gi);
-      for (const match of booleanMatches) {
-        const name = match[1];
-        if (!name.match(/^(is|has|should|can|will|did)/i)) {
+    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: lineNumber,
-            type: "unclear",
+            line,
+            type: "abbreviation",
             identifier: name,
-            severity: "info",
-            suggestion: `Boolean variable '${name}' should start with is/has/should/can for clarity`
+            severity: adjustSeverity("info", context, "abbreviation"),
+            suggestion: `Consider using full word instead of abbreviation '${name}'`
           });
         }
       }
+      continue;
     }
-    if (!disabledChecks.has("unclear")) {
-      const functionMatches = line.matchAll(/function\s+([a-z][a-zA-Z0-9]*)/g);
-      for (const match of functionMatches) {
-        const name = match[1];
-        const isKeyword = ["for", "if", "else", "while", "do", "switch", "case", "break", "continue", "return", "throw", "try", "catch", "finally", "with", "yield", "await"].includes(name);
-        if (isKeyword) {
-          continue;
-        }
-        const isEntryPoint = ["main", "init", "setup", "bootstrap"].includes(name);
-        if (isEntryPoint) {
-          continue;
-        }
-        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 isDescriptivePattern = name.match(/^(default|total|count|sum|avg|max|min|initial|current|previous|next)\w+/) || name.match(/\w+(Count|Total|Sum|Average|List|Map|Set|Config|Settings|Options|Props|Data|Info|Details|State|Status|Response|Result)$/);
-        const isHelperPattern = name.match(/^(to|from|with|without|for|as|into)\w+/) || // toMetadata, withLogger, forPath
-        name.match(/^\w+(To|From|With|Without|For|As|Into)\w*$/);
-        const isUtilityName = ["cn", "proxy", "sitemap", "robots", "gtag"].includes(name);
-        const capitalCount = (name.match(/[A-Z]/g) || []).length;
-        const isCompoundWord = capitalCount >= 3;
-        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)/);
-        if (!hasActionVerb && !isFactoryPattern && !isEventHandler && !isDescriptiveLong && !isDescriptivePattern && !isCompoundWord && !isHelperPattern && !isUtilityName && !isReactHook) {
-          issues.push({
-            file,
-            line: lineNumber,
-            type: "unclear",
-            identifier: name,
-            severity: "info",
-            suggestion: `Function '${name}' should start with an action verb (get, set, create, etc.)`
-          });
-        }
+    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);
+          const isDescriptivePattern = name.match(/^(default|total|count|sum|avg|max|min|initial|current|previous|next)\w+/) || name.match(/\w+(Count|Total|Sum|Average|List|Map|Set|Config|Settings|Options|Props|Data|Info|Details|State|Status|Response|Result)$/);
+          const capitalCount = (name.match(/[A-Z]/g) || []).length;
+          const isCompoundWord = capitalCount >= 3;
+          if (!hasActionVerb && !isFactoryPattern && !isEventHandler && !isDescriptiveLong && !isReactHook && !isHelperPattern && !isUtilityName && !isDescriptivePattern && !isCompoundWord) {
+            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 snakeCaseToCamelCase(str) {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-function detectNamingConventions(files, allIssues) {
-  const camelCaseCount = allIssues.filter((i) => i.type === "convention-mix").length;
-  const totalChecks = files.length * 10;
-  if (camelCaseCount / totalChecks > 0.3) {
-    return { dominantConvention: "mixed", conventionScore: 0.5 };
+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
+          }
+        );
+      }
+    }
   }
-  return { dominantConvention: "camelCase", conventionScore: 0.9 };
 }
 
 // src/analyzers/patterns.ts
@@ -747,7 +1196,7 @@ async function analyzeConsistency(options) {
     ...scanOptions
   } = options;
   const filePaths = await (0, import_core3.scanFiles)(scanOptions);
-  const namingIssues = checkNaming ? await analyzeNaming(filePaths) : [];
+  const namingIssues = checkNaming ? await analyzeNamingAST(filePaths) : [];
   const patternIssues = checkPatterns ? await analyzePatterns(filePaths) : [];
   const results = [];
   const fileIssuesMap = /* @__PURE__ */ new Map();
@@ -806,7 +1255,6 @@ async function analyzeConsistency(options) {
     });
   }
   const recommendations = generateRecommendations(namingIssues, patternIssues);
-  const conventionAnalysis = detectNamingConventions(filePaths, namingIssues);
   return {
     summary: {
       totalIssues: namingIssues.length + patternIssues.length,
@@ -872,7 +1320,7 @@ function generateRecommendations(namingIssues, patternIssues) {
 
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
-var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_path2 = require("path");
 var import_core4 = require("@aiready/core");
 var program = new import_commander.Command();
@@ -923,10 +1371,10 @@ EXAMPLES:
       directory
     );
     const dir = (0, import_path2.dirname)(outputPath);
-    if (!(0, import_fs.existsSync)(dir)) {
-      (0, import_fs.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_fs2.existsSync)(dir)) {
+      (0, import_fs2.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_fs.writeFileSync)(outputPath, output);
+    (0, import_fs2.writeFileSync)(outputPath, output);
     console.log(import_chalk.default.green(`\u2713 Report saved to ${outputPath}`));
   } else if (options.output === "markdown") {
     const markdown = generateMarkdownReport(report, elapsedTime);
@@ -936,10 +1384,10 @@ EXAMPLES:
       directory
     );
     const dir = (0, import_path2.dirname)(outputPath);
-    if (!(0, import_fs.existsSync)(dir)) {
-      (0, import_fs.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_fs2.existsSync)(dir)) {
+      (0, import_fs2.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_fs.writeFileSync)(outputPath, markdown);
+    (0, import_fs2.writeFileSync)(outputPath, markdown);
     console.log(import_chalk.default.green(`\u2713 Report saved to ${outputPath}`));
   } else {
     displayConsoleReport(report, elapsedTime);