@aiready/consistency 0.16.3 → 0.16.5

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/consistency@0.16.2 build /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.16.4 build /Users/pengcao/projects/aiready/packages/consistency
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,15 +9,15 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/cli.js   35.77 KB
-CJS dist/index.js 33.20 KB
-CJS ⚡️ Build success in 133ms
-ESM dist/index.mjs          6.06 KB
 ESM dist/cli.mjs            8.83 KB
-ESM dist/chunk-HJCP36VW.mjs 24.89 KB
-ESM ⚡️ Build success in 133ms
+ESM dist/chunk-IXBC6GVT.mjs 24.93 KB
+ESM dist/index.mjs          6.12 KB
+ESM ⚡️ Build success in 24ms
+CJS dist/index.js 33.31 KB
+CJS dist/cli.js   35.81 KB
+CJS ⚡️ Build success in 24ms
 DTS Build start
-DTS ⚡️ Build success in 2062ms
+DTS ⚡️ Build success in 1221ms
 DTS dist/cli.d.ts    20.00 B
 DTS dist/index.d.ts  3.34 KB
 DTS dist/cli.d.mts   20.00 B

package/.turbo/turbo-test.log

@@ -1,24 +1,22 @@
 
 
-> @aiready/consistency@0.16.2 test /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.16.4 test /Users/pengcao/projects/aiready/packages/consistency
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/consistency
 
  ✓ dist/__tests__/scoring.test.js (8 tests) 4ms
- ✓ src/__tests__/language-filter.test.ts (3 tests) 8ms
- ✓ src/__tests__/scoring.test.ts (8 tests) 6ms
- ✓ src/__tests__/contract.test.ts (1 test) 14ms
- ✓ dist/__tests__/language-filter.test.js (3 tests) 4ms
- ✓ src/__tests__/analyzer.test.ts (18 tests) 592ms
-     ✓ should analyze naming issues  406ms
- ✓ dist/__tests__/analyzer.test.js (18 tests) 620ms
-     ✓ should analyze naming issues  376ms
+ ✓ src/__tests__/scoring.test.ts (8 tests) 4ms
+ ✓ src/__tests__/language-filter.test.ts (3 tests) 5ms
+ ✓ dist/__tests__/language-filter.test.js (3 tests) 7ms
+ ✓ src/__tests__/contract.test.ts (1 test) 13ms
+ ✓ src/__tests__/analyzer.test.ts (18 tests) 222ms
+ ✓ dist/__tests__/analyzer.test.js (18 tests) 686ms
 
  Test Files  7 passed (7)
       Tests  59 passed (59)
-   Start at  20:23:03
-   Duration  3.42s (transform 2.39s, setup 0ms, import 13.08s, tests 1.25s, environment 1ms)
+   Start at  21:39:02
+   Duration  1.94s (transform 1.08s, setup 0ms, import 5.25s, tests 939ms, environment 1ms)
 
 [?25h

package/dist/chunk-IXBC6GVT.mjs

@@ -0,0 +1,832 @@
+// src/analyzers/naming-ast.ts
+import { Severity as Severity2 } from "@aiready/core";
+
+// 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) {
+    void 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 getLineNumber(node) {
+  return node.loc?.start.line ?? 0;
+}
+
+// src/utils/context-detector.ts
+import { Severity } from "@aiready/core";
+function detectFileType(filePath, ast) {
+  void 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) {
+  const getEnum = (s) => {
+    if (s === Severity.Critical || s === "critical") return Severity.Critical;
+    if (s === Severity.Major || s === "major") return Severity.Major;
+    if (s === Severity.Minor || s === "minor") return Severity.Minor;
+    return Severity.Info;
+  };
+  let currentSev = getEnum(baseSeverity);
+  if (context.isTestFile) {
+    if (currentSev === Severity.Minor) currentSev = Severity.Info;
+    if (currentSev === Severity.Major) currentSev = Severity.Minor;
+  }
+  if (context.isTypeDefinition) {
+    if (currentSev === Severity.Minor) currentSev = Severity.Info;
+  }
+  if (context.codeLayer === "api") {
+    if (currentSev === Severity.Info && issueType === "unclear")
+      currentSev = Severity.Minor;
+    if (currentSev === Severity.Minor && issueType === "unclear")
+      currentSev = Severity.Major;
+  }
+  if (context.complexity > 10) {
+    if (currentSev === Severity.Info) currentSev = Severity.Minor;
+  }
+  if (context.codeLayer === "utility") {
+    if (currentSev === Severity.Minor && issueType === "abbreviation")
+      currentSev = Severity.Info;
+  }
+  return currentSev;
+}
+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
+async function analyzeNamingAST(filePaths) {
+  const allIssues = [];
+  for (const filePath of filePaths) {
+    try {
+      const ast = parseFile(filePath);
+      if (!ast) continue;
+      const context = buildCodeContext(filePath, ast);
+      const issues = analyzeIdentifiers(ast, filePath, context);
+      allIssues.push(...issues);
+    } catch (err) {
+      void err;
+    }
+  }
+  return allIssues;
+}
+function analyzeIdentifiers(ast, filePath, context) {
+  const issues = [];
+  const scopeTracker = new ScopeTracker();
+  traverseAST(ast, {
+    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 === "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);
+          }
+        });
+      }
+      if ((node.type === "ClassDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") && node.id) {
+        checkNamingConvention(
+          node.id.name,
+          "PascalCase",
+          node.id,
+          filePath,
+          issues,
+          context
+        );
+      }
+    }
+  });
+  for (const varInfo of scopeTracker.getVariables()) {
+    checkVariableNaming(varInfo, filePath, issues, context);
+  }
+  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(Severity2.Info, context, "convention-mix");
+    issues.push({
+      file,
+      line: getLineNumber(node),
+      type: "convention-mix",
+      identifier: name,
+      severity,
+      suggestion: `Follow ${convention} for this identifier`
+    });
+  }
+}
+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(Severity2.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(Severity2.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(Severity2.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,
+          prop.value,
+          getLineNumber(prop.value),
+          {
+            isParameter,
+            isDestructured: true
+          }
+        );
+      }
+    });
+  } else if (node.type === "ArrayPattern") {
+    for (const element of node.elements) {
+      if (element?.type === "Identifier") {
+        scopeTracker.declareVariable(
+          element.name,
+          element,
+          getLineNumber(element),
+          {
+            isParameter,
+            isDestructured: true
+          }
+        );
+      }
+    }
+  }
+}
+
+// src/analyzers/patterns.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { Severity as Severity3 } from "@aiready/core";
+async function analyzePatterns(filePaths) {
+  const issues = [];
+  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 filePath of filePaths) {
+    try {
+      const content = readFileSync2(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 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: filePaths.filter((f) => {
+        const c = contents.get(f) || "";
+        return minority === "try-catch" ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
+      }),
+      type: "error-handling",
+      description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
+      examples: [dominant, minority],
+      severity: Severity3.Minor
+    });
+  }
+  if (styleStats.commonJs > 0 && styleStats.esm > 0) {
+    const minority = styleStats.esm >= styleStats.commonJs ? "CommonJS (require)" : "ESM (import)";
+    issues.push({
+      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 module systems: found both ESM and CommonJS.`,
+      examples: ['import X from "y"', 'const X = require("y")'],
+      severity: Severity3.Major
+    });
+  }
+  return issues;
+}
+
+// src/analyzer.ts
+import { scanFiles, Severity as Severity4, IssueType } from "@aiready/core";
+
+// src/analyzers/naming-python.ts
+import { getParser } from "@aiready/core";
+async function analyzePythonNaming(files) {
+  const issues = [];
+  const parser = getParser("dummy.py");
+  if (!parser) {
+    console.warn("Python parser not available");
+    return issues;
+  }
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  for (const file of pythonFiles) {
+    try {
+      const fs = await import("fs");
+      const code = await fs.promises.readFile(file, "utf-8");
+      const result = parser.parse(code, file);
+      for (const exp of result.exports) {
+        const nameIssue = checkPythonNaming(
+          exp.name,
+          exp.type,
+          file,
+          exp.loc?.start.line || 0
+        );
+        if (nameIssue) {
+          issues.push(nameIssue);
+        }
+      }
+      for (const imp of result.imports) {
+        for (const spec of imp.specifiers) {
+          if (spec !== "*" && spec !== "default") {
+            const nameIssue = checkPythonNaming(
+              spec,
+              "variable",
+              file,
+              imp.loc?.start.line || 0
+            );
+            if (nameIssue) {
+              issues.push(nameIssue);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Skipping ${file} due to error:`, error);
+    }
+  }
+  return issues;
+}
+function checkPythonNaming(identifier, type, file, line) {
+  const parser = getParser("dummy.py");
+  const conventions = parser?.getNamingConventions();
+  if (!conventions) return null;
+  if (conventions.exceptions?.includes(identifier)) {
+    return null;
+  }
+  if (type === "class") {
+    if (!conventions.classPattern.test(identifier)) {
+      return {
+        type: "poor-naming",
+        identifier,
+        file,
+        line,
+        column: 0,
+        severity: "major",
+        category: "naming",
+        suggestion: `Class names should use PascalCase (e.g., ${toPascalCase(identifier)})`
+      };
+    }
+  } else if (type === "function") {
+    if (!conventions.functionPattern.test(identifier)) {
+      if (/^[a-z][a-zA-Z0-9]*$/.test(identifier) && /[A-Z]/.test(identifier)) {
+        return {
+          type: "convention-mix",
+          identifier,
+          file,
+          line,
+          column: 0,
+          severity: "major",
+          category: "naming",
+          suggestion: `Function names should use snake_case, not camelCase (e.g., ${toSnakeCase(identifier)})`
+        };
+      }
+    }
+  } else if (type === "const" || type === "variable") {
+    if (identifier === identifier.toUpperCase() && identifier.length > 1) {
+      if (!conventions.constantPattern.test(identifier)) {
+        return {
+          type: "poor-naming",
+          identifier,
+          file,
+          line,
+          column: 0,
+          severity: "minor",
+          category: "naming",
+          suggestion: "Constants should use UPPER_CASE_WITH_UNDERSCORES"
+        };
+      }
+    } else {
+      if (!conventions.variablePattern.test(identifier)) {
+        if (/^[a-z][a-zA-Z0-9]*$/.test(identifier) && /[A-Z]/.test(identifier)) {
+          return {
+            type: "convention-mix",
+            identifier,
+            file,
+            line,
+            column: 0,
+            severity: "major",
+            category: "naming",
+            suggestion: `Variable names should use snake_case, not camelCase (e.g., ${toSnakeCase(identifier)})`
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toPascalCase(str) {
+  return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+
+// src/analyzer.ts
+async function analyzeConsistency(options) {
+  const {
+    checkNaming = true,
+    checkPatterns = true,
+    checkArchitecture = false,
+    // Not implemented yet
+    minSeverity = Severity4.Info,
+    ...scanOptions
+  } = options;
+  void checkArchitecture;
+  const filePaths = await 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 = [];
+  if (checkNaming) {
+    const tsJsNamingIssues = tsJsFiles.length > 0 ? await analyzeNamingAST(tsJsFiles) : [];
+    const pythonNamingIssues = pythonFiles.length > 0 ? await analyzePythonNaming(pythonFiles) : [];
+    namingIssues = [...tsJsNamingIssues, ...pythonNamingIssues];
+  }
+  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" ? IssueType.NamingInconsistency : IssueType.NamingQuality,
+      category: "naming",
+      severity: getSeverityEnum(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: IssueType.PatternInconsistency,
+      category: "patterns",
+      severity: getSeverityEnum(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)
+      }
+    });
+  }
+  results.sort((fileResultA, fileResultB) => {
+    const maxSeverityA = Math.min(
+      ...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) => {
+        const val = getSeverityLevel(i.severity);
+        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
+      })
+    );
+    if (maxSeverityA !== maxSeverityB) {
+      return maxSeverityA - maxSeverityB;
+    }
+    return fileResultB.issues.length - fileResultA.issues.length;
+  });
+  const recommendations = generateRecommendations(namingIssues, patternIssues);
+  const namingCountFiltered = namingIssues.filter(
+    (i) => shouldIncludeSeverity(i.severity, minSeverity)
+  ).length;
+  const patternCountFiltered = patternIssues.filter(
+    (i) => shouldIncludeSeverity(i.severity, minSeverity)
+  ).length;
+  return {
+    summary: {
+      totalIssues: namingCountFiltered + patternCountFiltered,
+      namingIssues: namingCountFiltered,
+      patternIssues: patternCountFiltered,
+      architectureIssues: 0,
+      filesAnalyzed: filePaths.length
+    },
+    results,
+    recommendations
+  };
+}
+function getSeverityLevel(s) {
+  if (s === Severity4.Critical || s === "critical") return 4;
+  if (s === Severity4.Major || s === "major") return 3;
+  if (s === Severity4.Minor || s === "minor") return 2;
+  if (s === Severity4.Info || s === "info") return 1;
+  return 0;
+}
+function getSeverityEnum(s) {
+  const val = getSeverityLevel(s);
+  switch (val) {
+    case 4:
+      return Severity4.Critical;
+    case 3:
+      return Severity4.Major;
+    case 2:
+      return Severity4.Minor;
+    case 1:
+      return Severity4.Info;
+    default:
+      return Severity4.Info;
+  }
+}
+function shouldIncludeSeverity(severity, minSeverity) {
+  return getSeverityLevel(severity) >= getSeverityLevel(minSeverity);
+}
+function calculateConsistencyScore(issues) {
+  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) {
+  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
+};

package/dist/cli.js

@@ -403,7 +403,18 @@ function checkVariableNaming(varInfo, file, issues, context) {
   }
 }
 function isCommonAbbreviation(name) {
-  const common = ["id", "db", "fs", "os", "ip", "ui", "ux", "api", "env", "url"];
+  const common = [
+    "id",
+    "db",
+    "fs",
+    "os",
+    "ip",
+    "ui",
+    "ux",
+    "api",
+    "env",
+    "url"
+  ];
   return common.includes(name.toLowerCase());
 }
 var ScopeTracker = class {

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   analyzeConsistency
-} from "./chunk-HJCP36VW.mjs";
+} from "./chunk-IXBC6GVT.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -416,7 +416,18 @@ function checkVariableNaming(varInfo, file, issues, context) {
   }
 }
 function isCommonAbbreviation(name) {
-  const common = ["id", "db", "fs", "os", "ip", "ui", "ux", "api", "env", "url"];
+  const common = [
+    "id",
+    "db",
+    "fs",
+    "os",
+    "ip",
+    "ui",
+    "ux",
+    "api",
+    "env",
+    "url"
+  ];
   return common.includes(name.toLowerCase());
 }
 var ScopeTracker = class {
@@ -865,7 +876,9 @@ async function analyzeNaming(filePaths) {
       const content = (0, import_fs3.readFileSync)(filePath, "utf-8");
       const lines = content.split("\n");
       lines.forEach((line, index) => {
-        const singleLetterMatch = line.match(/\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/);
+        const singleLetterMatch = line.match(
+          /\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/
+        );
         if (singleLetterMatch) {
           issues.push({
             file: filePath,
@@ -877,7 +890,9 @@ async function analyzeNaming(filePaths) {
           });
         }
         if (filePath.match(/\.(ts|tsx|js|jsx)$/)) {
-          const snakeCaseMatch = line.match(/\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/);
+          const snakeCaseMatch = line.match(
+            /\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/
+          );
           if (snakeCaseMatch) {
             issues.push({
               file: filePath,
@@ -889,7 +904,9 @@ async function analyzeNaming(filePaths) {
             });
           }
         }
-        const shortNameMatch = line.match(/\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/);
+        const shortNameMatch = line.match(
+          /\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/
+        );
         if (shortNameMatch) {
           const name = shortNameMatch[2].toLowerCase();
           const vagueNames = ["obj", "val", "tmp", "res", "ret", "data"];

package/dist/index.mjs

@@ -2,7 +2,7 @@ import {
   analyzeConsistency,
   analyzeNamingAST,
   analyzePatterns
-} from "./chunk-HJCP36VW.mjs";
+} from "./chunk-IXBC6GVT.mjs";
 
 // src/analyzers/naming.ts
 import { readFileSync } from "fs";
@@ -14,7 +14,9 @@ async function analyzeNaming(filePaths) {
       const content = readFileSync(filePath, "utf-8");
       const lines = content.split("\n");
       lines.forEach((line, index) => {
-        const singleLetterMatch = line.match(/\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/);
+        const singleLetterMatch = line.match(
+          /\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/
+        );
         if (singleLetterMatch) {
           issues.push({
             file: filePath,
@@ -26,7 +28,9 @@ async function analyzeNaming(filePaths) {
           });
         }
         if (filePath.match(/\.(ts|tsx|js|jsx)$/)) {
-          const snakeCaseMatch = line.match(/\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/);
+          const snakeCaseMatch = line.match(
+            /\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/
+          );
           if (snakeCaseMatch) {
             issues.push({
               file: filePath,
@@ -38,7 +42,9 @@ async function analyzeNaming(filePaths) {
             });
           }
         }
-        const shortNameMatch = line.match(/\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/);
+        const shortNameMatch = line.match(
+          /\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/
+        );
         if (shortNameMatch) {
           const name = shortNameMatch[2].toLowerCase();
           const vagueNames = ["obj", "val", "tmp", "res", "ret", "data"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.16.3",
+  "version": "0.16.5",
   "description": "Detects consistency issues in naming, patterns, and architecture that confuse AI models",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -43,7 +43,7 @@
     "@typescript-eslint/typescript-estree": "^8.53.0",
     "chalk": "^5.3.0",
     "commander": "^14.0.0",
-    "@aiready/core": "0.19.3"
+    "@aiready/core": "0.19.5"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/analyzer.ts

@@ -123,15 +123,15 @@ export async function analyzeConsistency(
     // Get highest severity in each file
     const maxSeverityA = Math.min(
       ...fileResultA.issues.map((i) => {
-          const val = getSeverityLevel((i as ConsistencyIssue).severity);
-          // Map 4->0, 3->1, 2->2, 1->3
-          return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
+        const val = getSeverityLevel((i as ConsistencyIssue).severity);
+        // Map 4->0, 3->1, 2->2, 1->3
+        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
       })
     );
     const maxSeverityB = Math.min(
       ...fileResultB.issues.map((i) => {
-          const val = getSeverityLevel((i as ConsistencyIssue).severity);
-          return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
+        const val = getSeverityLevel((i as ConsistencyIssue).severity);
+        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
       })
     );
 
@@ -179,11 +179,16 @@ function getSeverityLevel(s: any): number {
 function getSeverityEnum(s: any): Severity {
   const val = getSeverityLevel(s);
   switch (val) {
-    case 4: return Severity.Critical;
-    case 3: return Severity.Major;
-    case 2: return Severity.Minor;
-    case 1: return Severity.Info;
-    default: return Severity.Info;
+    case 4:
+      return Severity.Critical;
+    case 3:
+      return Severity.Major;
+    case 2:
+      return Severity.Minor;
+    case 1:
+      return Severity.Info;
+    default:
+      return Severity.Info;
   }
 }
 
@@ -199,11 +204,20 @@ function calculateConsistencyScore(issues: ConsistencyIssue[]): number {
   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;
+      case 4:
+        totalWeight += 10;
+        break;
+      case 3:
+        totalWeight += 5;
+        break;
+      case 2:
+        totalWeight += 2;
+        break;
+      case 1:
+        totalWeight += 1;
+        break;
+      default:
+        totalWeight += 1;
     }
   }
   // Score from 0-1, where 1 is perfect

package/src/analyzers/naming-ast.ts

@@ -218,7 +218,18 @@ function checkVariableNaming(
 }
 
 function isCommonAbbreviation(name: string): boolean {
-  const common = ['id', 'db', 'fs', 'os', 'ip', 'ui', 'ux', 'api', 'env', 'url'];
+  const common = [
+    'id',
+    'db',
+    'fs',
+    'os',
+    'ip',
+    'ui',
+    'ux',
+    'api',
+    'env',
+    'url',
+  ];
   return common.includes(name.toLowerCase());
 }
 
@@ -228,7 +239,12 @@ function isCommonAbbreviation(name: string): boolean {
 class ScopeTracker {
   private variables: any[] = [];
 
-  declareVariable(name: string, node: TSESTree.Node, line: number, options = {}) {
+  declareVariable(
+    name: string,
+    node: TSESTree.Node,
+    line: number,
+    options = {}
+  ) {
     this.variables.push({ name, node, line, options });
   }
 

package/src/analyzers/naming.ts

@@ -6,7 +6,9 @@ import type { NamingIssue } from '../types';
  * Legacy regex-based naming analyzer
  * (Used as fallback or for languages without AST support)
  */
-export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]> {
+export async function analyzeNaming(
+  filePaths: string[]
+): Promise<NamingIssue[]> {
   const issues: NamingIssue[] = [];
 
   for (const filePath of filePaths) {
@@ -16,9 +18,11 @@ export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]>
 
       lines.forEach((line, index) => {
         // Simple regex patterns for naming issues
-        
+
         // 1. Single letter variables (except common ones)
-        const singleLetterMatch = line.match(/\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/);
+        const singleLetterMatch = line.match(
+          /\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/
+        );
         if (singleLetterMatch) {
           issues.push({
             file: filePath,
@@ -32,7 +36,9 @@ export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]>
 
         // 2. Snake case in TS/JS files
         if (filePath.match(/\.(ts|tsx|js|jsx)$/)) {
-          const snakeCaseMatch = line.match(/\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/);
+          const snakeCaseMatch = line.match(
+            /\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/
+          );
           if (snakeCaseMatch) {
             issues.push({
               file: filePath,
@@ -40,13 +46,16 @@ export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]>
               type: 'convention-mix',
               identifier: snakeCaseMatch[2],
               severity: Severity.Info,
-              suggestion: 'Use camelCase instead of snake_case in TypeScript/JavaScript',
+              suggestion:
+                'Use camelCase instead of snake_case in TypeScript/JavaScript',
             });
           }
         }
 
         // 3. Very short names
-        const shortNameMatch = line.match(/\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/);
+        const shortNameMatch = line.match(
+          /\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/
+        );
         if (shortNameMatch) {
           const name = shortNameMatch[2].toLowerCase();
           const vagueNames = ['obj', 'val', 'tmp', 'res', 'ret', 'data'];

package/src/analyzers/patterns.ts

@@ -5,14 +5,16 @@ import type { PatternIssue } from '../types';
 /**
  * Detect inconsistent code patterns across files
  */
-export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue[]> {
+export async function analyzePatterns(
+  filePaths: string[]
+): Promise<PatternIssue[]> {
   const issues: PatternIssue[] = [];
   const contents = new Map<string, string>();
 
   // 1. Error handling style
   const tryCatchPattern = /try\s*\{/g;
   const catchPattern = /catch\s*\(\s*(\w+)\s*\)/g;
-  
+
   const styleStats = {
     tryCatch: 0,
     thenCatch: 0,
@@ -29,7 +31,7 @@ export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue
       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) {
@@ -41,13 +43,16 @@ export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue
 
   // Report inconsistencies if there's a significant mix
   if (styleStats.tryCatch > 0 && styleStats.thenCatch > 0) {
-    const dominant = styleStats.tryCatch >= styleStats.thenCatch ? 'try-catch' : '.catch()';
+    const dominant =
+      styleStats.tryCatch >= styleStats.thenCatch ? 'try-catch' : '.catch()';
     const minority = dominant === 'try-catch' ? '.catch()' : 'try-catch';
-    
+
     issues.push({
-      files: filePaths.filter(f => {
+      files: filePaths.filter((f) => {
         const c = contents.get(f) || '';
-        return minority === 'try-catch' ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
+        return minority === 'try-catch'
+          ? c.match(tryCatchPattern)
+          : c.match(/\.catch\s*\(/);
       }),
       type: 'error-handling',
       description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
@@ -57,11 +62,16 @@ export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue
   }
 
   if (styleStats.commonJs > 0 && styleStats.esm > 0) {
-    const minority = styleStats.esm >= styleStats.commonJs ? 'CommonJS (require)' : 'ESM (import)';
+    const minority =
+      styleStats.esm >= styleStats.commonJs
+        ? 'CommonJS (require)'
+        : 'ESM (import)';
     issues.push({
-      files: filePaths.filter(f => {
+      files: filePaths.filter((f) => {
         const c = contents.get(f) || '';
-        return minority === 'CommonJS (require)' ? c.match(/\brequire\s*\(/) : c.match(/\bimport\b/);
+        return minority === 'CommonJS (require)'
+          ? c.match(/\brequire\s*\(/)
+          : c.match(/\bimport\b/);
       }),
       type: 'import-style',
       description: `Mixed module systems: found both ESM and CommonJS.`,

package/src/types.ts

@@ -1,4 +1,10 @@
-import type { ScanOptions, AnalysisResult, Issue, Severity, IssueType } from '@aiready/core';
+import type {
+  ScanOptions,
+  AnalysisResult,
+  Issue,
+  Severity,
+  IssueType,
+} from '@aiready/core';
 
 export interface ConsistencyOptions extends ScanOptions {
   /** Check naming conventions and quality */