@aiready/consistency 0.20.12 → 0.20.13

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @aiready/consistency@0.20.12 build /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.20.13 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
@@ -8,15 +8,15 @@ CLI tsup v8.5.1
 CLI Target: es2020
 CJS Build start
 ESM Build start
+CJS dist/cli.js   34.64 KB
+CJS dist/index.js 32.53 KB
+CJS ⚡️ Build success in 565ms
 ESM dist/cli.mjs            8.83 KB
-ESM dist/chunk-TE6JYZD3.mjs 23.58 KB
+ESM dist/chunk-LSXZH6X6.mjs 23.77 KB
 ESM dist/index.mjs          7.04 KB
-ESM ⚡️ Build success in 114ms
-CJS dist/index.js 32.34 KB
-CJS dist/cli.js   34.45 KB
-CJS ⚡️ Build success in 114ms
+ESM ⚡️ Build success in 584ms
 DTS Build start
-DTS ⚡️ Build success in 8839ms
+DTS ⚡️ Build success in 11169ms
 DTS dist/cli.d.ts    20.00 B
 DTS dist/index.d.ts  3.87 KB
 DTS dist/cli.d.mts   20.00 B

package/.turbo/turbo-test.log

@@ -1,29 +1,32 @@
 
-> @aiready/consistency@0.20.11 test /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.20.12 test /Users/pengcao/projects/aiready/packages/consistency
 > vitest run
 
 
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/consistency
 
- ✓ dist/__tests__/scoring.test.js (8 tests) 17ms
+ ✓ src/__tests__/naming-constants.test.ts (14 tests) 4ms
+ ✓ dist/__tests__/scoring.test.js (8 tests) 36ms
+ ✓ src/__tests__/language-filter.test.ts (3 tests) 3ms
 Sourcemap for "/Users/pengcao/projects/aiready/packages/consistency/dist/analyzers/naming-python.js" points to missing source files
- ✓ src/__tests__/language-filter.test.ts (3 tests) 18ms
- ✓ dist/__tests__/language-filter.test.js (3 tests) 176ms
+ ✓ src/__tests__/scoring.test.ts (8 tests) 12ms
 stdout | src/__tests__/contract.test.ts > Consistency Spoke Contract Validation > should produce output matching the SpokeOutput contract
 Consistency: Skipping unparseable file file1.ts: ENOENT: no such file or directory, open 'file1.ts'
 
- ✓ src/__tests__/contract.test.ts (1 test) 5ms
- ✓ src/__tests__/provider.test.ts (2 tests) 3ms
- ✓ src/__tests__/scoring.test.ts (8 tests) 11ms
- ✓ dist/__tests__/analyzer.test.js (18 tests) 1235ms
-     ✓ should analyze naming issues  650ms
-     ✓ should detect minimum severity filtering  397ms
- ✓ src/__tests__/analyzer.test.ts (18 tests) 1606ms
-     ✓ should analyze naming issues  967ms
-     ✓ should generate relevant recommendations  420ms
+ ✓ dist/__tests__/language-filter.test.js (3 tests) 7ms
+ ✓ src/__tests__/contract.test.ts (1 test) 22ms
+ ✓ src/__tests__/provider.test.ts (2 tests) 19ms
+ ✓ src/__tests__/analyzer.test.ts (18 tests) 2253ms
+     ✓ should analyze naming issues  1241ms
+     ✓ should detect minimum severity filtering  564ms
+     ✓ should generate relevant recommendations  443ms
+ ✓ dist/__tests__/analyzer.test.js (18 tests) 2456ms
+     ✓ should analyze naming issues  771ms
+     ✓ should detect minimum severity filtering  621ms
+     ✓ should generate relevant recommendations  1057ms
 
- Test Files  8 passed (8)
-      Tests  61 passed (61)
-   Start at  16:30:27
-   Duration  4.81s (transform 4.06s, setup 0ms, import 16.19s, tests 3.07s, environment 1ms)
+ Test Files  9 passed (9)
+      Tests  75 passed (75)
+   Start at  10:44:29
+   Duration  5.77s (transform 3.42s, setup 0ms, import 20.19s, tests 4.81s, environment 3ms)
 

package/dist/chunk-LSXZH6X6.mjs

@@ -0,0 +1,810 @@
+// 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, 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",
+    "req",
+    "res",
+    "err",
+    "ctx",
+    "cb",
+    "idx",
+    "src",
+    "dir",
+    "app",
+    "dev",
+    "qa",
+    "dto",
+    "dao",
+    "ref",
+    "ast",
+    "dom",
+    "log",
+    "msg",
+    "pkg",
+    "req",
+    "err",
+    "res",
+    "css",
+    "html",
+    "xml",
+    "jsx",
+    "tsx",
+    "ts",
+    "js"
+  ];
+  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 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;
+    }
+  }
+  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: "pattern-inconsistency",
+      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: "pattern-inconsistency",
+      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 Severity5,
+  IssueType,
+  getSeverityLevel
+} from "@aiready/core";
+
+// src/analyzers/naming-generalized.ts
+import { getParser, Severity as Severity4 } from "@aiready/core";
+import { readFileSync as readFileSync3 } from "fs";
+var COMMON_ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "id",
+  "db",
+  "fs",
+  "os",
+  "ip",
+  "ui",
+  "ux",
+  "api",
+  "env",
+  "url",
+  "req",
+  "res",
+  "err",
+  "ctx",
+  "cb",
+  "idx",
+  "src",
+  "dir",
+  "app",
+  "dev",
+  "qa",
+  "dto",
+  "dao",
+  "ref",
+  "ast",
+  "dom",
+  "log",
+  "msg",
+  "pkg",
+  "css",
+  "html",
+  "xml",
+  "jsx",
+  "tsx",
+  "ts",
+  "js"
+]);
+async function analyzeNamingGeneralized(files) {
+  const issues = [];
+  for (const file of files) {
+    const parser = getParser(file);
+    if (!parser) continue;
+    try {
+      const code = readFileSync3(file, "utf-8");
+      if (!code.trim()) continue;
+      await parser.initialize();
+      const result = parser.parse(code, file);
+      const conventions = parser.getNamingConventions();
+      const exceptions = new Set(conventions.exceptions || []);
+      for (const exp of result.exports) {
+        if (!exp.name || exp.name === "default") continue;
+        if (exceptions.has(exp.name)) continue;
+        if (COMMON_ABBREVIATIONS.has(exp.name.toLowerCase())) continue;
+        let pattern;
+        if (exp.type === "class") {
+          pattern = conventions.classPattern;
+        } else if (exp.type === "interface" && conventions.interfacePattern) {
+          pattern = conventions.interfacePattern;
+        } else if (exp.type === "type" && conventions.typePattern) {
+          pattern = conventions.typePattern;
+        } else if (exp.type === "function") {
+          pattern = conventions.functionPattern;
+        } else if (exp.type === "const") {
+          pattern = exp.isPrimitive ? conventions.constantPattern : conventions.variablePattern;
+        } else {
+          pattern = conventions.variablePattern;
+        }
+        if (pattern && !pattern.test(exp.name)) {
+          issues.push({
+            type: "naming-inconsistency",
+            identifier: exp.name,
+            file,
+            line: exp.loc?.start.line || 1,
+            column: exp.loc?.start.column || 0,
+            // Recalibrate naming issues to Minor to differentiate from structural/architectural issues
+            severity: Severity4.Minor,
+            category: "naming",
+            suggestion: `Follow ${parser.language} ${exp.type} naming convention: ${pattern.toString()}`
+          });
+        }
+      }
+      for (const imp of result.imports) {
+        for (const spec of imp.specifiers) {
+          if (!spec || spec === "*" || spec === "default") continue;
+          if (exceptions.has(spec)) continue;
+          if (COMMON_ABBREVIATIONS.has(spec.toLowerCase())) continue;
+          if (!conventions.variablePattern.test(spec) && !conventions.classPattern.test(spec) && !conventions.constantPattern.test(spec) && (!conventions.typePattern || !conventions.typePattern.test(spec)) && (!conventions.interfacePattern || !conventions.interfacePattern.test(spec))) {
+            issues.push({
+              type: "naming-inconsistency",
+              identifier: spec,
+              file,
+              line: imp.loc?.start.line || 1,
+              column: imp.loc?.start.column || 0,
+              severity: Severity4.Info,
+              // Reduced from Minor to Info for imports
+              category: "naming",
+              suggestion: `Imported identifier '${spec}' may not follow standard conventions for this language.`
+            });
+          }
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.debug(
+        `Consistency: Skipping unparseable file ${file}: ${errorMessage.split("\\n")[0]}`
+      );
+    }
+  }
+  return issues;
+}
+
+// src/analyzer.ts
+async function analyzeConsistency(options) {
+  const {
+    checkNaming = true,
+    checkPatterns = true,
+    checkArchitecture = false,
+    // Not implemented yet
+    minSeverity = Severity5.Info,
+    ...scanOptions
+  } = options;
+  void checkArchitecture;
+  const filePaths = await scanFiles(scanOptions);
+  let namingIssues = [];
+  if (checkNaming) {
+    namingIssues = await analyzeNamingGeneralized(filePaths);
+    const tsJsFiles = filePaths.filter((f) => /\.(ts|tsx|js|jsx)$/i.test(f));
+    if (tsJsFiles.length > 0) {
+      const deepTsIssues = await analyzeNamingAST(tsJsFiles);
+      namingIssues = [...namingIssues, ...deepTsIssues];
+    }
+  }
+  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 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 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.entries()) {
+    results.push({
+      fileName,
+      issues: issues.map((i) => transformToIssue(i)),
+      metrics: {
+        consistencyScore: calculateConsistencyScore(issues)
+      }
+    });
+  }
+  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"
+    );
+  }
+  return {
+    results,
+    summary: {
+      filesAnalyzed: filePaths.length,
+      totalIssues: results.reduce((acc, r) => acc + r.issues.length, 0),
+      namingIssues: namingIssues.length,
+      patternIssues: patternIssues.length,
+      architectureIssues: 0
+    },
+    recommendations,
+    metadata: {
+      toolName: "naming-consistency",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function shouldIncludeSeverity(severity, minSeverity) {
+  return getSeverityLevel(severity) >= getSeverityLevel(minSeverity);
+}
+function getIssueType(type) {
+  if (!type) return IssueType.NamingInconsistency;
+  const typeMap = {
+    "naming-inconsistency": IssueType.NamingInconsistency,
+    "naming-quality": IssueType.NamingQuality,
+    "pattern-inconsistency": IssueType.PatternInconsistency,
+    "architecture-inconsistency": IssueType.ArchitectureInconsistency,
+    "error-handling": IssueType.PatternInconsistency,
+    "async-style": IssueType.PatternInconsistency,
+    "import-style": IssueType.PatternInconsistency,
+    "api-design": IssueType.PatternInconsistency
+  };
+  return typeMap[type] || IssueType.NamingInconsistency;
+}
+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
+    };
+  }
+  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);
+    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);
+}
+
+export {
+  analyzeNamingAST,
+  analyzePatterns,
+  analyzeConsistency
+};

package/dist/cli.js

@@ -579,7 +579,7 @@ async function analyzeNamingGeneralized(files) {
           if (!spec || spec === "*" || spec === "default") continue;
           if (exceptions.has(spec)) continue;
           if (COMMON_ABBREVIATIONS.has(spec.toLowerCase())) continue;
-          if (!conventions.variablePattern.test(spec) && !conventions.classPattern.test(spec)) {
+          if (!conventions.variablePattern.test(spec) && !conventions.classPattern.test(spec) && !conventions.constantPattern.test(spec) && (!conventions.typePattern || !conventions.typePattern.test(spec)) && (!conventions.interfacePattern || !conventions.interfacePattern.test(spec))) {
             issues.push({
               type: "naming-inconsistency",
               identifier: spec,

package/dist/cli.mjs

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

package/dist/index.js

@@ -587,7 +587,7 @@ async function analyzeNamingGeneralized(files) {
           if (!spec || spec === "*" || spec === "default") continue;
           if (exceptions.has(spec)) continue;
           if (COMMON_ABBREVIATIONS.has(spec.toLowerCase())) continue;
-          if (!conventions.variablePattern.test(spec) && !conventions.classPattern.test(spec)) {
+          if (!conventions.variablePattern.test(spec) && !conventions.classPattern.test(spec) && !conventions.constantPattern.test(spec) && (!conventions.typePattern || !conventions.typePattern.test(spec)) && (!conventions.interfacePattern || !conventions.interfacePattern.test(spec))) {
             issues.push({
               type: "naming-inconsistency",
               identifier: spec,

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.20.12",
+  "version": "0.20.13",
   "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.13"
+    "@aiready/core": "0.23.14"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/naming-constants.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import {
+  snakeCaseToCamelCase,
+  detectNamingConventions,
+  COMMON_SHORT_WORDS,
+  ACCEPTABLE_ABBREVIATIONS,
+} from '../analyzers/naming-constants';
+
+describe('snakeCaseToCamelCase', () => {
+  it('should convert simple snake_case to camelCase', () => {
+    expect(snakeCaseToCamelCase('hello_world')).toBe('helloWorld');
+    expect(snakeCaseToCamelCase('foo_bar')).toBe('fooBar');
+  });
+
+  it('should handle single word snake_case', () => {
+    expect(snakeCaseToCamelCase('hello')).toBe('hello');
+  });
+
+  it('should handle multiple underscores', () => {
+    expect(snakeCaseToCamelCase('a_b_c_d')).toBe('aBCD');
+  });
+
+  it('should handle leading underscores', () => {
+    expect(snakeCaseToCamelCase('_private_method')).toBe('privateMethod');
+  });
+
+  it('should handle numbers in snake_case', () => {
+    expect(snakeCaseToCamelCase('user_id_1')).toBe('userId1');
+  });
+
+  it('should handle already camelCase strings', () => {
+    expect(snakeCaseToCamelCase('alreadyCamelCase')).toBe('alreadyCamelCase');
+  });
+
+  it('should handle uppercase letters after underscore', () => {
+    expect(snakeCaseToCamelCase('hello_WORLD')).toBe('helloWORLD');
+  });
+});
+
+describe('COMMON_SHORT_WORDS', () => {
+  it('should include common short English words', () => {
+    expect(COMMON_SHORT_WORDS.has('day')).toBe(true);
+    expect(COMMON_SHORT_WORDS.has('key')).toBe(true);
+    expect(COMMON_SHORT_WORDS.has('net')).toBe(true);
+    expect(COMMON_SHORT_WORDS.has('use')).toBe(true);
+  });
+});
+
+describe('ACCEPTABLE_ABBREVIATIONS', () => {
+  it('should include standard identifiers', () => {
+    expect(ACCEPTABLE_ABBREVIATIONS.has('id')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('uid')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('pid')).toBe(true);
+  });
+
+  it('should include web/network abbreviations', () => {
+    expect(ACCEPTABLE_ABBREVIATIONS.has('url')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('api')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('http')).toBe(true);
+  });
+
+  it('should include data format abbreviations', () => {
+    expect(ACCEPTABLE_ABBREVIATIONS.has('json')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('xml')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('yaml')).toBe(true);
+  });
+
+  it('should include boolean helpers', () => {
+    expect(ACCEPTABLE_ABBREVIATIONS.has('is')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('has')).toBe(true);
+    expect(ACCEPTABLE_ABBREVIATIONS.has('can')).toBe(true);
+  });
+});
+
+describe('detectNamingConventions', () => {
+  it('should detect camelCase as dominant for TypeScript files', () => {
+    const result = detectNamingConventions(
+      ['file.ts', 'another.ts'],
+      [{ type: 'other-issue' }]
+    );
+    expect(result.dominantConvention).toBe('camelCase');
+    expect(result.conventionScore).toBe(0.9);
+  });
+
+  it('should detect mixed conventions when there are many convention issues', () => {
+    const manyIssues = Array(40).fill({ type: 'convention-mix' });
+    const result = detectNamingConventions(['file.ts'], manyIssues as any);
+    expect(result.dominantConvention).toBe('mixed');
+    expect(result.conventionScore).toBe(0.5);
+  });
+});

package/src/analyzers/naming-constants.ts

@@ -393,7 +393,9 @@ export const ACCEPTABLE_ABBREVIATIONS = new Set([
  * Convert snake_case to camelCase
  */
 export function snakeCaseToCamelCase(str: string): string {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  return str
+    .replace(/^_+/, '')
+    .replace(/_([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
 }
 
 /**

package/src/analyzers/naming-generalized.ts

@@ -124,7 +124,11 @@ export async function analyzeNamingGeneralized(
 
           if (
             !conventions.variablePattern.test(spec) &&
-            !conventions.classPattern.test(spec)
+            !conventions.classPattern.test(spec) &&
+            !conventions.constantPattern.test(spec) &&
+            (!conventions.typePattern || !conventions.typePattern.test(spec)) &&
+            (!conventions.interfacePattern ||
+              !conventions.interfacePattern.test(spec))
           ) {
             // This is often a 'convention-mix' issue (e.g. importing snake_case into camelCase project)
             issues.push({