@aiready/consistency 0.20.2 → 0.20.4

package/dist/index.js

@@ -361,7 +361,7 @@ function checkNamingConvention(name, convention, node, file, issues, context) {
   }
 }
 function checkVariableNaming(varInfo, file, issues, context) {
-  const { name, node, line, options } = varInfo;
+  const { name, line, options } = varInfo;
   if (isAcceptableInContext(name, context, options)) {
     return;
   }
@@ -483,7 +483,6 @@ async function analyzeNamingGeneralized(files) {
       const conventions = parser.getNamingConventions();
       for (const exp of result.exports) {
         let pattern;
-        const typeName = exp.type;
         if (exp.type === "class") {
           pattern = conventions.classPattern;
         } else if (exp.type === "interface" && conventions.interfacePattern) {
@@ -499,7 +498,7 @@ async function analyzeNamingGeneralized(files) {
         }
         if (pattern && !pattern.test(exp.name)) {
           issues.push({
-            type: "poor-naming",
+            type: "naming-inconsistency",
             identifier: exp.name,
             file,
             line: exp.loc?.start.line || 1,
@@ -515,7 +514,7 @@ async function analyzeNamingGeneralized(files) {
           if (spec === "*" || spec === "default") continue;
           if (!conventions.variablePattern.test(spec) && !conventions.classPattern.test(spec)) {
             issues.push({
-              type: "convention-mix",
+              type: "naming-inconsistency",
               identifier: spec,
               file,
               line: imp.loc?.start.line || 1,
@@ -541,7 +540,6 @@ 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,
@@ -562,7 +560,6 @@ async function analyzePatterns(filePaths) {
       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";
@@ -571,7 +568,7 @@ async function analyzePatterns(filePaths) {
         const c = contents.get(f) || "";
         return minority === "try-catch" ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
       }),
-      type: "error-handling",
+      type: "pattern-inconsistency",
       description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
       examples: [dominant, minority],
       severity: import_core4.Severity.Minor
@@ -584,7 +581,7 @@ async function analyzePatterns(filePaths) {
         const c = contents.get(f) || "";
         return minority === "CommonJS (require)" ? c.match(/\brequire\s*\(/) : c.match(/\bimport\b/);
       }),
-      type: "import-style",
+      type: "pattern-inconsistency",
       description: `Mixed module systems: found both ESM and CommonJS.`,
       examples: ['import X from "y"', 'const X = require("y")'],
       severity: import_core4.Severity.Major
@@ -618,130 +615,126 @@ async function analyzeConsistency(options) {
   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" ? import_core5.IssueType.NamingInconsistency : import_core5.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);
+    if (!shouldIncludeSeverity(issue.severity, minSeverity)) continue;
+    const fileName = issue.fileName || issue.file || issue.filePath || "unknown";
+    if (!fileIssuesMap.has(fileName)) fileIssuesMap.set(fileName, []);
+    fileIssuesMap.get(fileName).push(issue);
   }
   for (const issue of patternIssues) {
-    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
-      continue;
-    }
-    const consistencyIssue = {
-      type: import_core5.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);
-    }
+    if (!shouldIncludeSeverity(issue.severity, minSeverity)) continue;
+    const fileName = issue.fileName || issue.file || issue.filePath || (Array.isArray(issue.files) ? issue.files[0] : "unknown");
+    if (!fileIssuesMap.has(fileName)) fileIssuesMap.set(fileName, []);
+    fileIssuesMap.get(fileName).push(issue);
   }
-  for (const [fileName, issues] of fileIssuesMap) {
+  for (const [fileName, issues] of fileIssuesMap.entries()) {
     results.push({
       fileName,
-      issues,
+      issues: issues.map((i) => transformToIssue(i)),
       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;
-      })
+  const recommendations = [];
+  if (namingIssues.length > 0) {
+    recommendations.push("Standardize naming conventions across the codebase");
+  }
+  if (patternIssues.length > 0) {
+    recommendations.push("Consolidate repetitive implementation patterns");
+  }
+  if (results.some((r) => (r.metrics?.consistencyScore ?? 1) < 0.8)) {
+    recommendations.push(
+      "Improve cross-module consistency to reduce AI confusion"
     );
-    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 {
+    results,
     summary: {
-      totalIssues: namingCountFiltered + patternCountFiltered,
-      namingIssues: namingCountFiltered,
-      patternIssues: patternCountFiltered,
-      architectureIssues: 0,
       filesAnalyzed: filePaths.length,
-      config: Object.fromEntries(
-        Object.entries(options).filter(
-          ([key]) => !import_core5.GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
-        )
-      )
+      totalIssues: results.reduce((acc, r) => acc + r.issues.length, 0),
+      namingIssues: namingIssues.length,
+      patternIssues: patternIssues.length,
+      architectureIssues: 0
     },
-    results,
-    recommendations
+    recommendations,
+    metadata: {
+      toolName: "naming-consistency",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
   };
 }
-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 shouldIncludeSeverity(severity, minSeverity) {
+  return (0, import_core5.getSeverityLevel)(severity) >= (0, import_core5.getSeverityLevel)(minSeverity);
+}
+function getIssueType(type) {
+  if (!type) return import_core5.IssueType.NamingInconsistency;
+  const typeMap = {
+    "naming-inconsistency": import_core5.IssueType.NamingInconsistency,
+    "naming-quality": import_core5.IssueType.NamingQuality,
+    "pattern-inconsistency": import_core5.IssueType.PatternInconsistency,
+    "architecture-inconsistency": import_core5.IssueType.ArchitectureInconsistency,
+    "error-handling": import_core5.IssueType.PatternInconsistency,
+    "async-style": import_core5.IssueType.PatternInconsistency,
+    "import-style": import_core5.IssueType.PatternInconsistency,
+    "api-design": import_core5.IssueType.PatternInconsistency
+  };
+  return typeMap[type] || import_core5.IssueType.NamingInconsistency;
 }
-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 transformToIssue(i) {
+  if (i.message && i.location) {
+    return {
+      type: getIssueType(i.type),
+      severity: i.severity,
+      message: i.message,
+      location: i.location,
+      suggestion: i.suggestion
+    };
   }
-}
-function shouldIncludeSeverity(severity, minSeverity) {
-  return getSeverityLevel(severity) >= getSeverityLevel(minSeverity);
+  if (i.identifier || i.type) {
+    const line = i.line || 1;
+    const column = i.column || 1;
+    return {
+      type: getIssueType(i.type),
+      severity: i.severity,
+      message: i.suggestion ? `Naming issue: ${i.suggestion}` : `Naming issue for '${i.identifier || "unknown"}'`,
+      location: {
+        file: i.file || i.fileName || "",
+        line,
+        column,
+        endLine: line,
+        endColumn: column + (i.identifier?.length || 10)
+      },
+      suggestion: i.suggestion
+    };
+  }
+  if (i.description || i.files) {
+    const fileName = Array.isArray(i.files) ? i.files[0] : i.file || "";
+    return {
+      type: getIssueType(i.type),
+      severity: i.severity,
+      message: i.description || "Pattern inconsistency found",
+      location: {
+        file: fileName,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 10
+      },
+      suggestion: i.examples?.[0]
+    };
+  }
+  return {
+    type: getIssueType(i.type),
+    severity: i.severity,
+    message: i.message || "Unknown issue",
+    location: i.location || { file: "", line: 1, column: 1 },
+    suggestion: i.suggestion
+  };
 }
 function calculateConsistencyScore(issues) {
   let totalWeight = 0;
   for (const issue of issues) {
-    const val = getSeverityLevel(issue.severity);
+    const val = (0, import_core5.getSeverityLevel)(issue.severity);
     switch (val) {
       case 4:
         totalWeight += 10;
@@ -761,55 +754,6 @@ function calculateConsistencyScore(issues) {
   }
   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;
-}
 
 // src/scoring.ts
 var import_core6 = require("@aiready/core");

package/dist/index.mjs

@@ -2,7 +2,7 @@ import {
   analyzeConsistency,
   analyzeNamingAST,
   analyzePatterns
-} from "./chunk-UMBBTNQN.mjs";
+} from "./chunk-S6BZVTWN.mjs";
 
 // src/index.ts
 import { ToolRegistry } from "@aiready/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.20.2",
+  "version": "0.20.4",
   "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.23.2"
+    "@aiready/core": "0.23.4"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",