@aiready/consistency 0.16.2 → 0.16.3

package/dist/cli.js

@@ -27,7 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // src/analyzer.ts
-var import_core4 = require("@aiready/core");
+var import_core5 = require("@aiready/core");
+
+// src/analyzers/naming-ast.ts
+var import_core2 = require("@aiready/core");
 
 // src/utils/ast-parser.ts
 var import_typescript_estree = require("@typescript-eslint/typescript-estree");
@@ -79,214 +82,12 @@ function isLoopStatement(node) {
     "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
+var import_core = require("@aiready/core");
 function detectFileType(filePath, ast) {
   void ast;
   const path = filePath.toLowerCase();
@@ -414,24 +215,34 @@ function buildCodeContext(filePath, ast) {
   };
 }
 function adjustSeverity(baseSeverity, context, issueType) {
+  const getEnum = (s) => {
+    if (s === import_core.Severity.Critical || s === "critical") return import_core.Severity.Critical;
+    if (s === import_core.Severity.Major || s === "major") return import_core.Severity.Major;
+    if (s === import_core.Severity.Minor || s === "minor") return import_core.Severity.Minor;
+    return import_core.Severity.Info;
+  };
+  let currentSev = getEnum(baseSeverity);
   if (context.isTestFile) {
-    if (baseSeverity === "minor") return "info";
-    if (baseSeverity === "major") return "minor";
+    if (currentSev === import_core.Severity.Minor) currentSev = import_core.Severity.Info;
+    if (currentSev === import_core.Severity.Major) currentSev = import_core.Severity.Minor;
   }
   if (context.isTypeDefinition) {
-    if (baseSeverity === "minor") return "info";
+    if (currentSev === import_core.Severity.Minor) currentSev = import_core.Severity.Info;
   }
   if (context.codeLayer === "api") {
-    if (baseSeverity === "info" && issueType === "unclear") return "minor";
-    if (baseSeverity === "minor" && issueType === "unclear") return "major";
+    if (currentSev === import_core.Severity.Info && issueType === "unclear")
+      currentSev = import_core.Severity.Minor;
+    if (currentSev === import_core.Severity.Minor && issueType === "unclear")
+      currentSev = import_core.Severity.Major;
   }
   if (context.complexity > 10) {
-    if (baseSeverity === "info") return "minor";
+    if (currentSev === import_core.Severity.Info) currentSev = import_core.Severity.Minor;
   }
   if (context.codeLayer === "utility") {
-    if (baseSeverity === "minor" && issueType === "abbreviation") return "info";
+    if (currentSev === import_core.Severity.Minor && issueType === "abbreviation")
+      currentSev = import_core.Severity.Info;
   }
-  return baseSeverity;
+  return currentSev;
 }
 function isAcceptableInContext(name, context, options) {
   if (options.isLoopVariable && ["i", "j", "k", "l", "n", "m"].includes(name)) {
@@ -458,638 +269,157 @@ function isAcceptableInContext(name, context, options) {
   return false;
 }
 
-// src/utils/config-loader.ts
-var import_core = require("@aiready/core");
-var import_path = require("path");
-
-// src/analyzers/naming-constants.ts
-var COMMON_SHORT_WORDS = /* @__PURE__ */ new Set([
-  // Full English words (1-3 letters)
-  "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",
-  // Prepositions and conjunctions
-  "and",
-  "from",
-  "how",
-  "pad",
-  "bar",
-  "non",
-  // Additional full words commonly flagged
-  "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([
-  // Standard identifiers
-  "id",
-  "uid",
-  "gid",
-  "pid",
-  // Loop counters and iterators
-  "i",
-  "j",
-  "k",
-  "n",
-  "m",
-  // Web/Network
-  "url",
-  "uri",
-  "api",
-  "cdn",
-  "dns",
-  "ip",
-  "tcp",
-  "udp",
-  "http",
-  "ssl",
-  "tls",
-  "utm",
-  "seo",
-  "rss",
-  "xhr",
-  "ajax",
-  "cors",
-  "ws",
-  "wss",
-  // Data formats
-  "json",
-  "xml",
-  "yaml",
-  "csv",
-  "html",
-  "css",
-  "svg",
-  "pdf",
-  // File types & extensions
-  "img",
-  "txt",
-  "doc",
-  "docx",
-  "xlsx",
-  "ppt",
-  "md",
-  "rst",
-  "jpg",
-  "png",
-  "gif",
-  // Databases
-  "db",
-  "sql",
-  "orm",
-  "dao",
-  "dto",
-  "ddb",
-  "rds",
-  "nosql",
-  // File system
-  "fs",
-  "dir",
-  "tmp",
-  "src",
-  "dst",
-  "bin",
-  "lib",
-  "pkg",
-  // Operating system
-  "os",
-  "env",
-  "arg",
-  "cli",
-  "cmd",
-  "exe",
-  "cwd",
-  "pwd",
-  // UI/UX
-  "ui",
-  "ux",
-  "gui",
-  "dom",
-  "ref",
-  // Request/Response
-  "req",
-  "res",
-  "ctx",
-  "err",
-  "msg",
-  "auth",
-  // Mathematics/Computing
-  "max",
-  "min",
-  "avg",
-  "sum",
-  "abs",
-  "cos",
-  "sin",
-  "tan",
-  "log",
-  "exp",
-  "pow",
-  "sqrt",
-  "std",
-  "var",
-  "int",
-  "num",
-  "idx",
-  // Time
-  "now",
-  "utc",
-  "tz",
-  "ms",
-  "sec",
-  "hr",
-  "min",
-  "yr",
-  "mo",
-  // Common patterns
-  "app",
-  "cfg",
-  "config",
-  "init",
-  "len",
-  "val",
-  "str",
-  "obj",
-  "arr",
-  "gen",
-  "def",
-  "raw",
-  "new",
-  "old",
-  "pre",
-  "post",
-  "sub",
-  "pub",
-  // Programming/Framework specific
-  "ts",
-  "js",
-  "jsx",
-  "tsx",
-  "py",
-  "rb",
-  "vue",
-  "re",
-  "fn",
-  "fns",
-  "mod",
-  "opts",
-  "dev",
-  // Cloud/Infrastructure
-  "s3",
-  "ec2",
-  "sqs",
-  "sns",
-  "vpc",
-  "ami",
-  "iam",
-  "acl",
-  "elb",
-  "alb",
-  "nlb",
-  "aws",
-  "ses",
-  "gst",
-  "cdk",
-  "btn",
-  "buf",
-  "agg",
-  "ocr",
-  "ai",
-  "cf",
-  "cfn",
-  "ga",
-  // Metrics/Performance
-  "fcp",
-  "lcp",
-  "cls",
-  "ttfb",
-  "tti",
-  "fid",
-  "fps",
-  "qps",
-  "rps",
-  "tps",
-  "wpm",
-  // Testing & i18n
-  "po",
-  "e2e",
-  "a11y",
-  "i18n",
-  "l10n",
-  "spy",
-  // Domain-specific abbreviations (context-aware)
-  "sk",
-  "fy",
-  "faq",
-  "og",
-  "seo",
-  "cta",
-  "roi",
-  "kpi",
-  "ttl",
-  "pct",
-  // Technical abbreviations
-  "mac",
-  "hex",
-  "esm",
-  "git",
-  "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",
-  // Coverage metrics (industry standard: statements/branches/functions/lines)
-  "s",
-  "b",
-  "f",
-  "l",
-  // Common media/content abbreviations
-  "vid",
-  "pic",
-  "img",
-  "doc",
-  "msg"
-]);
-
-// src/utils/config-loader.ts
-async function loadNamingConfig(files) {
-  const rootDir = files.length > 0 ? (0, import_path.dirname)(files[0]) : process.cwd();
-  const config = await (0, import_core.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]);
-  return {
-    customAbbreviations,
-    customShortWords,
-    disabledChecks,
-    allAbbreviations,
-    allShortWords
-  };
-}
-
 // src/analyzers/naming-ast.ts
-async function analyzeNamingAST(files) {
-  const issues = [];
-  const { allAbbreviations, allShortWords, disabledChecks } = await loadNamingConfig(files);
-  const supportedFiles = files.filter(
-    (file) => /\.(js|jsx|ts|tsx)$/i.test(file)
-  );
-  for (const file of supportedFiles) {
+async function analyzeNamingAST(filePaths) {
+  const allIssues = [];
+  for (const filePath of filePaths) {
     try {
-      const ast = parseFile(file);
+      const ast = parseFile(filePath);
       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);
+      const context = buildCodeContext(filePath, ast);
+      const issues = analyzeIdentifiers(ast, filePath, context);
+      allIssues.push(...issues);
+    } catch (err) {
+      void err;
     }
   }
-  return issues;
+  return allIssues;
 }
-function analyzeFileNamingAST(file, ast, allAbbreviations, allShortWords, disabledChecks) {
+function analyzeIdentifiers(ast, filePath, context) {
   const issues = [];
-  const scopeTracker = new ScopeTracker(ast);
-  const context = buildCodeContext(file, ast);
-  const ancestors = [];
+  const scopeTracker = new ScopeTracker();
   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") {
-          void 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
-          );
-        }
+    enter: (node) => {
+      if (node.type === "VariableDeclarator" && node.id.type === "Identifier") {
+        const isParameter = false;
+        const isLoopVariable = isLoopStatement(node.parent?.parent);
+        scopeTracker.declareVariable(
+          node.id.name,
+          node.id,
+          getLineNumber(node.id),
+          { isParameter, isLoopVariable }
+        );
       }
-      if (node.type === "Identifier" && parent) {
-        if (parent.type !== "VariableDeclarator" || parent.id !== node) {
-          if (parent.type !== "FunctionDeclaration" || parent.id !== node) {
-            scopeTracker.addReference(node.name, node);
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+        node.params.forEach((param) => {
+          if (param.type === "Identifier") {
+            scopeTracker.declareVariable(
+              param.name,
+              param,
+              getLineNumber(param),
+              { isParameter: true }
+            );
+          } else if (param.type === "ObjectPattern") {
+            extractDestructuredIdentifiers(param, true, scopeTracker);
           }
-        }
-      }
-    },
-    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()
+      if ((node.type === "ClassDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") && node.id) {
+        checkNamingConvention(
+          node.id.name,
+          "PascalCase",
+          node.id,
+          filePath,
+          issues,
+          context
         );
-        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`
-        });
       }
     }
+  });
+  for (const varInfo of scopeTracker.getVariables()) {
+    checkVariableNaming(varInfo, filePath, issues, context);
   }
-  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|count|detect|select)/
-          );
-          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+/) || name.match(/^\w+(To|From|With|Without|For|As|Into)\w*$/);
-          const isUtilityName = [
-            "cn",
-            "proxy",
-            "sitemap",
-            "robots",
-            "gtag"
-          ].includes(name);
-          const isLanguageKeyword = [
-            "constructor",
-            "toString",
-            "valueOf",
-            "toJSON"
-          ].includes(name);
-          const isFrameworkPattern = name.match(
-            /^(goto|fill|click|select|submit|wait|expect)\w*/
-          );
-          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 && !isLanguageKeyword && !isFrameworkPattern) {
-            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 checkNamingConvention(name, convention, node, file, issues, context) {
+  let isValid = true;
+  if (convention === "PascalCase") {
+    isValid = /^[A-Z][a-zA-Z0-9]*$/.test(name);
+  } else if (convention === "camelCase") {
+    isValid = /^[a-z][a-zA-Z0-9]*$/.test(name);
+  } else if (convention === "UPPER_CASE") {
+    isValid = /^[A-Z][A-Z0-9_]*$/.test(name);
+  }
+  if (!isValid) {
+    const severity = adjustSeverity(import_core2.Severity.Info, context, "convention-mix");
+    issues.push({
+      file,
+      line: getLineNumber(node),
+      type: "convention-mix",
+      identifier: name,
+      severity,
+      suggestion: `Follow ${convention} for this identifier`
     });
   }
-  return issues;
 }
-function extractIdentifiersFromPattern(pattern, scopeTracker, isParameter, ancestors) {
-  void ancestors;
-  if (pattern.type === "ObjectPattern") {
-    for (const prop of pattern.properties) {
+function checkVariableNaming(varInfo, file, issues, context) {
+  const { name, node, line, options } = varInfo;
+  if (isAcceptableInContext(name, context, options)) {
+    return;
+  }
+  if (name.length === 1 && !options.isLoopVariable) {
+    const severity = adjustSeverity(import_core2.Severity.Minor, context, "poor-naming");
+    issues.push({
+      file,
+      line,
+      type: "poor-naming",
+      identifier: name,
+      severity,
+      suggestion: "Use a more descriptive name than a single letter"
+    });
+  }
+  const vagueNames = [
+    "data",
+    "info",
+    "item",
+    "obj",
+    "val",
+    "tmp",
+    "temp",
+    "thing",
+    "stuff"
+  ];
+  if (vagueNames.includes(name.toLowerCase())) {
+    const severity = adjustSeverity(import_core2.Severity.Minor, context, "poor-naming");
+    issues.push({
+      file,
+      line,
+      type: "poor-naming",
+      identifier: name,
+      severity,
+      suggestion: `Avoid vague names like '${name}'. What does this data represent?`
+    });
+  }
+  if (name.length > 1 && name.length <= 3 && !options.isLoopVariable && !isCommonAbbreviation(name)) {
+    const severity = adjustSeverity(import_core2.Severity.Info, context, "abbreviation");
+    issues.push({
+      file,
+      line,
+      type: "abbreviation",
+      identifier: name,
+      severity,
+      suggestion: "Avoid non-standard abbreviations"
+    });
+  }
+}
+function isCommonAbbreviation(name) {
+  const common = ["id", "db", "fs", "os", "ip", "ui", "ux", "api", "env", "url"];
+  return common.includes(name.toLowerCase());
+}
+var ScopeTracker = class {
+  constructor() {
+    this.variables = [];
+  }
+  declareVariable(name, node, line, options = {}) {
+    this.variables.push({ name, node, line, options });
+  }
+  getVariables() {
+    return this.variables;
+  }
+};
+function extractDestructuredIdentifiers(node, isParameter, scopeTracker) {
+  if (node.type === "ObjectPattern") {
+    node.properties.forEach((prop) => {
       if (prop.type === "Property" && prop.value.type === "Identifier") {
         scopeTracker.declareVariable(
           prop.value.name,
@@ -1100,21 +430,11 @@ function extractIdentifiersFromPattern(pattern, scopeTracker, isParameter, ances
             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") {
+    });
+  } else if (node.type === "ArrayPattern") {
+    for (const element of node.elements) {
+      if (element?.type === "Identifier") {
         scopeTracker.declareVariable(
           element.name,
           element,
@@ -1130,10 +450,10 @@ function extractIdentifiersFromPattern(pattern, scopeTracker, isParameter, ances
 }
 
 // src/analyzers/naming-python.ts
-var import_core2 = require("@aiready/core");
+var import_core3 = require("@aiready/core");
 async function analyzePythonNaming(files) {
   const issues = [];
-  const parser = (0, import_core2.getParser)("dummy.py");
+  const parser = (0, import_core3.getParser)("dummy.py");
   if (!parser) {
     console.warn("Python parser not available");
     return issues;
@@ -1177,7 +497,7 @@ async function analyzePythonNaming(files) {
   return issues;
 }
 function checkPythonNaming(identifier, type, file, line) {
-  const parser = (0, import_core2.getParser)("dummy.py");
+  const parser = (0, import_core3.getParser)("dummy.py");
   const conventions = parser?.getNamingConventions();
   if (!conventions) return null;
   if (conventions.exceptions?.includes(identifier)) {
@@ -1252,162 +572,63 @@ function toPascalCase(str) {
 }
 
 // src/analyzers/patterns.ts
-var import_core3 = require("@aiready/core");
-async function analyzePatterns(files) {
+var import_fs2 = require("fs");
+var import_core4 = require("@aiready/core");
+async function analyzePatterns(filePaths) {
   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: []
+  const contents = /* @__PURE__ */ new Map();
+  const tryCatchPattern = /try\s*\{/g;
+  const catchPattern = /catch\s*\(\s*(\w+)\s*\)/g;
+  const styleStats = {
+    tryCatch: 0,
+    thenCatch: 0,
+    asyncAwait: 0,
+    commonJs: 0,
+    esm: 0
   };
-  for (const file of files) {
-    const content = await (0, import_core3.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);
+  for (const filePath of filePaths) {
+    try {
+      const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
+      contents.set(filePath, content);
+      if (content.match(tryCatchPattern)) styleStats.tryCatch++;
+      if (content.match(/\.catch\s*\(/)) styleStats.thenCatch++;
+      if (content.match(/\bawait\b/)) styleStats.asyncAwait++;
+      if (content.match(/\brequire\s*\(/)) styleStats.commonJs++;
+      if (content.match(/\bimport\b.*\bfrom\b/)) styleStats.esm++;
+    } catch (err) {
+      void err;
     }
   }
-  const issues = [];
-  const strategiesUsed = Object.values(patterns).filter(
-    (p) => p.length > 0
-  ).length;
-  if (strategiesUsed > 2) {
+  const totalFiles = filePaths.length;
+  if (styleStats.tryCatch > 0 && styleStats.thenCatch > 0) {
+    const dominant = styleStats.tryCatch >= styleStats.thenCatch ? "try-catch" : ".catch()";
+    const minority = dominant === "try-catch" ? ".catch()" : "try-catch";
     issues.push({
-      files: [
-        .../* @__PURE__ */ new Set([
-          ...patterns.tryCatch,
-          ...patterns.throwsError,
-          ...patterns.returnsNull,
-          ...patterns.returnsError
-        ])
-      ],
+      files: filePaths.filter((f) => {
+        const c = contents.get(f) || "";
+        return minority === "try-catch" ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
+      }),
       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"
+      description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
+      examples: [dominant, minority],
+      severity: import_core4.Severity.Minor
     });
   }
-  return issues;
-}
-async function analyzeAsyncPatterns(files) {
-  const patterns = {
-    asyncAwait: [],
-    promises: [],
-    callbacks: []
-  };
-  for (const file of files) {
-    const content = await (0, import_core3.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) {
+  if (styleStats.commonJs > 0 && styleStats.esm > 0) {
+    const minority = styleStats.esm >= styleStats.commonJs ? "CommonJS (require)" : "ESM (import)";
     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 (0, import_core3.readFileContent)(file);
-    const hasESM = content.match(/^import\s+/m);
-    const hasCJS = hasActualRequireCalls(content);
-    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,
+      files: filePaths.filter((f) => {
+        const c = contents.get(f) || "";
+        return minority === "CommonJS (require)" ? c.match(/\brequire\s*\(/) : c.match(/\bimport\b/);
+      }),
       type: "import-style",
-      description: "Mixed ES modules and CommonJS imports in same files",
-      examples: patterns.mixed.slice(0, 5),
-      severity: "major"
+      description: `Mixed module systems: found both ESM and CommonJS.`,
+      examples: ['import X from "y"', 'const X = require("y")'],
+      severity: import_core4.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;
 }
-function hasActualRequireCalls(content) {
-  let cleaned = content.replace(/\/\/.*$/gm, "");
-  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, "");
-  cleaned = cleaned.replace(/"[^"\n]*"/g, '""');
-  cleaned = cleaned.replace(/'[^'\n]*'/g, "''");
-  cleaned = cleaned.replace(/`[^`]*`/g, "``");
-  cleaned = cleaned.replace(/\/[^/\n]*require[^/\n]*\/[gimsuvy]*/g, "");
-  return /require\s*\(/.test(cleaned);
-}
 
 // src/analyzer.ts
 async function analyzeConsistency(options) {
@@ -1416,11 +637,11 @@ async function analyzeConsistency(options) {
     checkPatterns = true,
     checkArchitecture = false,
     // Not implemented yet
-    minSeverity = "info",
+    minSeverity = import_core5.Severity.Info,
     ...scanOptions
   } = options;
   void checkArchitecture;
-  const filePaths = await (0, import_core4.scanFiles)(scanOptions);
+  const filePaths = await (0, import_core5.scanFiles)(scanOptions);
   const tsJsFiles = filePaths.filter((f) => /\.(ts|tsx|js|jsx)$/i.test(f));
   const pythonFiles = filePaths.filter((f) => /\.py$/i.test(f));
   let namingIssues = [];
@@ -1437,9 +658,9 @@ async function analyzeConsistency(options) {
       continue;
     }
     const consistencyIssue = {
-      type: issue.type === "convention-mix" ? "naming-inconsistency" : "naming-quality",
+      type: issue.type === "convention-mix" ? import_core5.IssueType.NamingInconsistency : import_core5.IssueType.NamingQuality,
       category: "naming",
-      severity: issue.severity,
+      severity: getSeverityEnum(issue.severity),
       message: `${issue.type}: ${issue.identifier}`,
       location: {
         file: issue.file,
@@ -1458,9 +679,9 @@ async function analyzeConsistency(options) {
       continue;
     }
     const consistencyIssue = {
-      type: "pattern-inconsistency",
+      type: import_core5.IssueType.PatternInconsistency,
       category: "patterns",
-      severity: issue.severity,
+      severity: getSeverityEnum(issue.severity),
       message: issue.description,
       location: {
         file: issue.files[0] || "multiple files",
@@ -1487,16 +708,17 @@ async function analyzeConsistency(options) {
     });
   }
   results.sort((fileResultA, fileResultB) => {
-    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
     const maxSeverityA = Math.min(
-      ...fileResultA.issues.map(
-        (i) => severityOrder[i.severity]
-      )
+      ...fileResultA.issues.map((i) => {
+        const val = getSeverityLevel(i.severity);
+        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
+      })
     );
     const maxSeverityB = Math.min(
-      ...fileResultB.issues.map(
-        (i) => severityOrder[i.severity]
-      )
+      ...fileResultB.issues.map((i) => {
+        const val = getSeverityLevel(i.severity);
+        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
+      })
     );
     if (maxSeverityA !== maxSeverityB) {
       return maxSeverityA - maxSeverityB;
@@ -1522,16 +744,52 @@ async function analyzeConsistency(options) {
     recommendations
   };
 }
+function getSeverityLevel(s) {
+  if (s === import_core5.Severity.Critical || s === "critical") return 4;
+  if (s === import_core5.Severity.Major || s === "major") return 3;
+  if (s === import_core5.Severity.Minor || s === "minor") return 2;
+  if (s === import_core5.Severity.Info || s === "info") return 1;
+  return 0;
+}
+function getSeverityEnum(s) {
+  const val = getSeverityLevel(s);
+  switch (val) {
+    case 4:
+      return import_core5.Severity.Critical;
+    case 3:
+      return import_core5.Severity.Major;
+    case 2:
+      return import_core5.Severity.Minor;
+    case 1:
+      return import_core5.Severity.Info;
+    default:
+      return import_core5.Severity.Info;
+  }
+}
 function shouldIncludeSeverity(severity, minSeverity) {
-  const severityLevels = { info: 0, minor: 1, major: 2, critical: 3 };
-  return severityLevels[severity] >= severityLevels[minSeverity];
+  return getSeverityLevel(severity) >= getSeverityLevel(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
-  );
+  let totalWeight = 0;
+  for (const issue of issues) {
+    const val = getSeverityLevel(issue.severity);
+    switch (val) {
+      case 4:
+        totalWeight += 10;
+        break;
+      case 3:
+        totalWeight += 5;
+        break;
+      case 2:
+        totalWeight += 2;
+        break;
+      case 1:
+        totalWeight += 1;
+        break;
+      default:
+        totalWeight += 1;
+    }
+  }
   return Math.max(0, 1 - totalWeight / 100);
 }
 function generateRecommendations(namingIssues, patternIssues) {
@@ -1586,9 +844,9 @@ function generateRecommendations(namingIssues, patternIssues) {
 
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_core5 = require("@aiready/core");
+var import_fs3 = require("fs");
+var import_path = require("path");
+var import_core6 = require("@aiready/core");
 var program = new import_commander.Command();
 program.name("aiready-consistency").description(
   "Detect consistency patterns in naming, code structure, and architecture"
@@ -1627,7 +885,7 @@ EXAMPLES:
 ).option("--output-file <path>", "Output file path (for json/markdown)").action(async (directory, options) => {
   console.log(import_chalk.default.blue("\u{1F50D} Analyzing consistency...\n"));
   const startTime = Date.now();
-  const config = await (0, import_core5.loadConfig)(directory);
+  const config = await (0, import_core6.loadConfig)(directory);
   const defaults = {
     checkNaming: true,
     checkPatterns: true,
@@ -1636,7 +894,7 @@ EXAMPLES:
     include: void 0,
     exclude: void 0
   };
-  const mergedConfig = (0, import_core5.mergeConfigWithDefaults)(config, defaults);
+  const mergedConfig = (0, import_core6.mergeConfigWithDefaults)(config, defaults);
   const finalOptions = {
     rootDir: directory,
     checkNaming: options.naming !== false && mergedConfig.checkNaming,
@@ -1650,29 +908,29 @@ EXAMPLES:
   const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
   if (options.output === "json") {
     const output = JSON.stringify(report, null, 2);
-    const outputPath = (0, import_core5.resolveOutputPath)(
+    const outputPath = (0, import_core6.resolveOutputPath)(
       options.outputFile,
       `consistency-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
       directory
     );
-    const dir = (0, import_path2.dirname)(outputPath);
-    if (!(0, import_fs2.existsSync)(dir)) {
-      (0, import_fs2.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path.dirname)(outputPath);
+    if (!(0, import_fs3.existsSync)(dir)) {
+      (0, import_fs3.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_fs2.writeFileSync)(outputPath, output);
+    (0, import_fs3.writeFileSync)(outputPath, output);
     console.log(import_chalk.default.green(`\u2713 Report saved to ${outputPath}`));
   } else if (options.output === "markdown") {
     const markdown = generateMarkdownReport(report, elapsedTime);
-    const outputPath = (0, import_core5.resolveOutputPath)(
+    const outputPath = (0, import_core6.resolveOutputPath)(
       options.outputFile,
       `consistency-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.md`,
       directory
     );
-    const dir = (0, import_path2.dirname)(outputPath);
-    if (!(0, import_fs2.existsSync)(dir)) {
-      (0, import_fs2.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path.dirname)(outputPath);
+    if (!(0, import_fs3.existsSync)(dir)) {
+      (0, import_fs3.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_fs2.writeFileSync)(outputPath, markdown);
+    (0, import_fs3.writeFileSync)(outputPath, markdown);
     console.log(import_chalk.default.green(`\u2713 Report saved to ${outputPath}`));
   } else {
     displayConsoleReport(report, elapsedTime);