@aiready/consistency 0.16.2 → 0.16.3

package/dist/index.mjs

@@ -1,250 +1,78 @@
 import {
-  ACCEPTABLE_ABBREVIATIONS,
-  COMMON_SHORT_WORDS,
   analyzeConsistency,
   analyzeNamingAST,
-  analyzePatterns,
-  detectNamingConventions,
-  loadNamingConfig,
-  snakeCaseToCamelCase
-} from "./chunk-J5IFYDVU.mjs";
+  analyzePatterns
+} from "./chunk-HJCP36VW.mjs";
 
 // src/analyzers/naming.ts
-import { readFileContent } from "@aiready/core";
-async function analyzeNaming(files) {
-  const issues = [];
-  const { customAbbreviations, customShortWords, disabledChecks } = await loadNamingConfig(files);
-  for (const file of files) {
-    const content = await readFileContent(file);
-    const fileIssues = analyzeFileNaming(
-      file,
-      content,
-      customAbbreviations,
-      customShortWords,
-      disabledChecks
-    );
-    issues.push(...fileIssues);
-  }
-  return issues;
-}
-function analyzeFileNaming(file, content, customAbbreviations, customShortWords, disabledChecks) {
+import { readFileSync } from "fs";
+import { Severity } from "@aiready/core";
+async function analyzeNaming(filePaths) {
   const issues = [];
-  const isTestFile = file.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/);
-  const lines = content.split("\n");
-  const allAbbreviations = /* @__PURE__ */ new Set([
-    ...ACCEPTABLE_ABBREVIATIONS,
-    ...customAbbreviations
-  ]);
-  const allShortWords = /* @__PURE__ */ new Set([...COMMON_SHORT_WORDS, ...customShortWords]);
-  const getContextWindow = (index, windowSize = 3) => {
-    const start = Math.max(0, index - windowSize);
-    const end = Math.min(lines.length, index + windowSize + 1);
-    return lines.slice(start, end).join("\n");
-  };
-  const isShortLivedVariable = (varName, declarationIndex) => {
-    const searchRange = 5;
-    const endIndex = Math.min(lines.length, declarationIndex + searchRange + 1);
-    let usageCount = 0;
-    for (let i = declarationIndex; i < endIndex; i++) {
-      const regex = new RegExp(`\\b${varName}\\b`, "g");
-      const matches = lines[i].match(regex);
-      if (matches) {
-        usageCount += matches.length;
-      }
-    }
-    return usageCount >= 2 && usageCount <= 3;
-  };
-  lines.forEach((line, index) => {
-    const lineNumber = index + 1;
-    const contextWindow = getContextWindow(index);
-    if (!disabledChecks.has("single-letter")) {
-      const singleLetterMatches = line.matchAll(
-        /\b(?:const|let|var)\s+([a-hm-z])\s*=/gi
-      );
-      for (const match of singleLetterMatches) {
-        const letter = match[1].toLowerCase();
-        const isCoverageContext = /coverage|summary|metrics|pct|percent/i.test(line) || /\.(?:statements|branches|functions|lines)\.pct/i.test(line);
-        if (isCoverageContext && ["s", "b", "f", "l"].includes(letter)) {
-          continue;
-        }
-        const isInLoopContext = line.includes("for") || /\.(map|filter|forEach|reduce|find|some|every)\s*\(/.test(line) || line.includes("=>") || // Arrow function
-        /\w+\s*=>\s*/.test(line);
-        const isI18nContext = line.includes("useTranslation") || line.includes("i18n.t") || /\bt\s*\(['"]/.test(line);
-        const isArrowFunctionParam = /\(\s*[a-z]\s*(?:,\s*[a-z]\s*)*\)\s*=>/.test(line) || // (s) => or (a, b) =>
-        /[a-z]\s*=>/.test(line) || // s => on same line
-        // Multi-line arrow function detection: look for pattern in context window
-        new RegExp(`\\b${letter}\\s*\\)\\s*$`).test(line) && /=>/.test(contextWindow) || // (s)\n =>
-        new RegExp(
-          `\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`
-        ).test(lines[index - 1] || "") && /=>/.test(contextWindow);
-        const isShortLived = isShortLivedVariable(letter, index);
-        if (!isInLoopContext && !isI18nContext && !isArrowFunctionParam && !isShortLived && !["x", "y", "z", "i", "j", "k", "l", "n", "m"].includes(letter)) {
-          if (isTestFile && ["a", "b", "c", "d", "e", "f", "s"].includes(letter)) {
-            continue;
-          }
+  for (const filePath of filePaths) {
+    try {
+      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*=/);
+        if (singleLetterMatch) {
           issues.push({
-            file,
-            line: lineNumber,
+            file: filePath,
+            line: index + 1,
             type: "poor-naming",
-            identifier: match[1],
-            severity: "minor",
-            suggestion: `Use descriptive variable name instead of single letter '${match[1]}'`
+            identifier: singleLetterMatch[2],
+            severity: Severity.Minor,
+            suggestion: "Use a more descriptive name than a single letter"
           });
         }
-      }
-    }
-    if (!disabledChecks.has("abbreviation")) {
-      const abbreviationMatches = line.matchAll(
-        /\b(?:const|let|var)\s+([a-z]{1,3})(?=[A-Z]|_|\s*=)/g
-      );
-      for (const match of abbreviationMatches) {
-        const abbrev = match[1].toLowerCase();
-        if (allShortWords.has(abbrev)) {
-          continue;
-        }
-        if (allAbbreviations.has(abbrev)) {
-          continue;
-        }
-        const isArrowFunctionParam = /\(\s*[a-z]\s*(?:,\s*[a-z]\s*)*\)\s*=>/.test(line) || // (s) => or (a, b) =>
-        new RegExp(`\\b${abbrev}\\s*=>`).test(line) || // s => on same line
-        // Multi-line arrow function: check context window
-        new RegExp(`\\b${abbrev}\\s*\\)\\s*$`).test(line) && /=>/.test(contextWindow) || // (s)\n =>
-        new RegExp(
-          `\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`
-        ).test(lines[index - 1] || "") && new RegExp(`^\\s*${abbrev}\\s*=>`).test(line);
-        if (isArrowFunctionParam) {
-          continue;
-        }
-        if (abbrev.length <= 2) {
-          const isDateTimeContext = /date|time|day|hour|minute|second|timestamp/i.test(line);
-          if (isDateTimeContext && ["d", "t", "dt"].includes(abbrev)) {
-            continue;
-          }
-          const isUserContext = /user|auth|account/i.test(line);
-          if (isUserContext && abbrev === "u") {
-            continue;
+        if (filePath.match(/\.(ts|tsx|js|jsx)$/)) {
+          const snakeCaseMatch = line.match(/\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/);
+          if (snakeCaseMatch) {
+            issues.push({
+              file: filePath,
+              line: index + 1,
+              type: "convention-mix",
+              identifier: snakeCaseMatch[2],
+              severity: Severity.Info,
+              suggestion: "Use camelCase instead of snake_case in TypeScript/JavaScript"
+            });
           }
         }
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "abbreviation",
-          identifier: match[1],
-          severity: "info",
-          suggestion: `Consider using full word instead of abbreviation '${match[1]}'`
-        });
-      }
-    }
-    if (!disabledChecks.has("convention-mix") && file.match(/\.(ts|tsx|js|jsx)$/)) {
-      const camelCaseVars = line.match(
-        /\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*=/
-      );
-      void camelCaseVars;
-      const snakeCaseVars = line.match(
-        /\b(?:const|let|var)\s+([a-z][a-z0-9]*_[a-z0-9_]*)\s*=/
-      );
-      if (snakeCaseVars) {
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "convention-mix",
-          identifier: snakeCaseVars[1],
-          severity: "minor",
-          suggestion: `Use camelCase '${snakeCaseToCamelCase(snakeCaseVars[1])}' instead of snake_case in TypeScript/JavaScript`
-        });
-      }
-    }
-    if (!disabledChecks.has("unclear")) {
-      const booleanMatches = line.matchAll(
-        /\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*:\s*boolean/gi
-      );
-      for (const match of booleanMatches) {
-        const name = match[1];
-        if (!name.match(/^(is|has|should|can|will|did)/i)) {
-          issues.push({
-            file,
-            line: lineNumber,
-            type: "unclear",
-            identifier: name,
-            severity: "info",
-            suggestion: `Boolean variable '${name}' should start with is/has/should/can for clarity`
-          });
-        }
-      }
-    }
-    if (!disabledChecks.has("unclear")) {
-      const functionMatches = line.matchAll(/function\s+([a-z][a-zA-Z0-9]*)/g);
-      for (const match of functionMatches) {
-        const name = match[1];
-        const isKeyword = [
-          "for",
-          "if",
-          "else",
-          "while",
-          "do",
-          "switch",
-          "case",
-          "break",
-          "continue",
-          "return",
-          "throw",
-          "try",
-          "catch",
-          "finally",
-          "with",
-          "yield",
-          "await"
-        ].includes(name);
-        if (isKeyword) {
-          continue;
-        }
-        const isEntryPoint = ["main", "init", "setup", "bootstrap"].includes(
-          name
-        );
-        if (isEntryPoint) {
-          continue;
-        }
-        const isFactoryPattern = name.match(
-          /(Factory|Builder|Creator|Generator|Provider|Adapter|Mock)$/
-        );
-        const isEventHandler = name.match(/^on[A-Z]/);
-        const isDescriptiveLong = name.length > 15;
-        const isReactHook = name.match(/^use[A-Z]/);
-        const isDescriptivePattern = name.match(
-          /^(default|total|count|sum|avg|max|min|initial|current|previous|next)\w+/
-        ) || name.match(
-          /\w+(Count|Total|Sum|Average|List|Map|Set|Config|Settings|Options|Props|Data|Info|Details|State|Status|Response|Result)$/
-        );
-        const isHelperPattern = name.match(/^(to|from|with|without|for|as|into)\w+/) || // toMetadata, withLogger, forPath
-        name.match(/^\w+(To|From|With|Without|For|As|Into)\w*$/);
-        const isUtilityName = [
-          "cn",
-          "proxy",
-          "sitemap",
-          "robots",
-          "gtag"
-        ].includes(name);
-        const capitalCount = (name.match(/[A-Z]/g) || []).length;
-        const isCompoundWord = capitalCount >= 3;
-        const hasActionVerb = name.match(
-          /^(get|set|is|has|can|should|create|update|delete|fetch|load|save|process|handle|validate|check|find|search|filter|map|reduce|make|do|run|start|stop|build|parse|format|render|calculate|compute|generate|transform|convert|normalize|sanitize|encode|decode|compress|extract|merge|split|join|sort|compare|test|verify|ensure|apply|execute|invoke|call|emit|dispatch|trigger|listen|subscribe|unsubscribe|add|remove|clear|reset|toggle|enable|disable|open|close|connect|disconnect|send|receive|read|write|import|export|register|unregister|mount|unmount|track|store|persist|upsert|derive|classify|combine|discover|activate|require|assert|expect|mask|escape|sign|put|list|complete|page|safe|mock|pick|pluralize|text)/
-        );
-        if (!hasActionVerb && !isFactoryPattern && !isEventHandler && !isDescriptiveLong && !isDescriptivePattern && !isCompoundWord && !isHelperPattern && !isUtilityName && !isReactHook) {
-          issues.push({
-            file,
-            line: lineNumber,
-            type: "unclear",
-            identifier: name,
-            severity: "info",
-            suggestion: `Function '${name}' should start with an action verb (get, set, create, etc.)`
-          });
+        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"];
+          if (vagueNames.includes(name)) {
+            issues.push({
+              file: filePath,
+              line: index + 1,
+              type: "poor-naming",
+              identifier: name,
+              severity: Severity.Minor,
+              suggestion: `Avoid vague names like '${name}'`
+            });
+          }
         }
-      }
+      });
+    } catch (err) {
+      void err;
     }
-  });
+  }
   return issues;
 }
 
+// src/analyzers/naming-constants.ts
+function detectNamingConventions(files, allIssues) {
+  const camelCaseCount = allIssues.filter(
+    (i) => i.type === "convention-mix"
+  ).length;
+  const totalChecks = files.length * 10;
+  if (camelCaseCount / totalChecks > 0.3) {
+    return { dominantConvention: "mixed", conventionScore: 0.5 };
+  }
+  return { dominantConvention: "camelCase", conventionScore: 0.9 };
+}
+
 // src/scoring.ts
 import { calculateProductivityImpact } from "@aiready/core";
 function calculateConsistencyScore(issues, totalFilesAnalyzed, costConfig) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "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.2"
+    "@aiready/core": "0.19.3"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/contract.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { analyzeConsistency } from '../index';
-import { validateSpokeOutput } from '../../../core/src/types/contract';
+import { validateSpokeOutput, SpokeOutputSchema } from '@aiready/core';
 
 // Mock core functions
 vi.mock('@aiready/core', async (importOriginal) => {
@@ -21,14 +21,30 @@ describe('Consistency Spoke Contract Validation', () => {
     const fullOutput = {
       results: results.results,
       summary: results.summary,
+      metadata: {
+        toolName: 'consistency',
+        version: '0.1.0',
+        timestamp: new Date().toISOString(),
+      },
     };
 
+    // 1. Legacy validation
     const validation = validateSpokeOutput('consistency', fullOutput);
 
     if (!validation.valid) {
-      console.error('Contract Validation Errors:', validation.errors);
+      console.error('Contract Validation Errors (Legacy):', validation.errors);
     }
 
     expect(validation.valid).toBe(true);
+
+    // 2. Zod validation
+    const zodResult = SpokeOutputSchema.safeParse(fullOutput);
+    if (!zodResult.success) {
+      console.error(
+        'Contract Validation Errors (Zod):',
+        zodResult.error.format()
+      );
+    }
+    expect(zodResult.success).toBe(true);
   });
 });

package/src/analyzer.ts

@@ -1,4 +1,4 @@
-import { scanFiles } from '@aiready/core';
+import { scanFiles, Severity, IssueType } from '@aiready/core';
 import type { AnalysisResult, Issue } from '@aiready/core';
 import type {
   ConsistencyOptions,
@@ -20,7 +20,7 @@ export async function analyzeConsistency(
     checkNaming = true,
     checkPatterns = true,
     checkArchitecture = false, // Not implemented yet
-    minSeverity = 'info',
+    minSeverity = Severity.Info,
     ...scanOptions
   } = options;
 
@@ -59,10 +59,10 @@ export async function analyzeConsistency(
     const consistencyIssue: ConsistencyIssue = {
       type:
         issue.type === 'convention-mix'
-          ? 'naming-inconsistency'
-          : 'naming-quality',
+          ? IssueType.NamingInconsistency
+          : IssueType.NamingQuality,
       category: 'naming',
-      severity: issue.severity,
+      severity: getSeverityEnum(issue.severity),
       message: `${issue.type}: ${issue.identifier}`,
       location: {
         file: issue.file,
@@ -85,9 +85,9 @@ export async function analyzeConsistency(
     }
 
     const consistencyIssue: ConsistencyIssue = {
-      type: 'pattern-inconsistency',
+      type: IssueType.PatternInconsistency,
       category: 'patterns',
-      severity: issue.severity,
+      severity: getSeverityEnum(issue.severity),
       message: issue.description,
       location: {
         file: issue.files[0] || 'multiple files',
@@ -120,18 +120,19 @@ export async function analyzeConsistency(
 
   // Sort results by severity first, then by issue count per file
   results.sort((fileResultA, fileResultB) => {
-    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
-
     // Get highest severity in each file
     const maxSeverityA = Math.min(
-      ...fileResultA.issues.map(
-        (i) => severityOrder[(i as ConsistencyIssue).severity]
-      )
+      ...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 maxSeverityB = Math.min(
-      ...fileResultB.issues.map(
-        (i) => severityOrder[(i as ConsistencyIssue).severity]
-      )
+      ...fileResultB.issues.map((i) => {
+          const val = getSeverityLevel((i as ConsistencyIssue).severity);
+          return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
+      })
     );
 
     // Sort by severity first
@@ -154,9 +155,6 @@ export async function analyzeConsistency(
     shouldIncludeSeverity(i.severity, minSeverity)
   ).length;
 
-  // Detect naming conventions (TODO: re-implement for AST version)
-  // const conventionAnalysis = detectNamingConventions(filePaths, namingIssues);
-
   return {
     summary: {
       totalIssues: namingCountFiltered + patternCountFiltered,
@@ -170,21 +168,44 @@ export async function analyzeConsistency(
   };
 }
 
+function getSeverityLevel(s: any): number {
+  if (s === Severity.Critical || s === 'critical') return 4;
+  if (s === Severity.Major || s === 'major') return 3;
+  if (s === Severity.Minor || s === 'minor') return 2;
+  if (s === Severity.Info || s === 'info') return 1;
+  return 0;
+}
+
+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;
+  }
+}
+
 function shouldIncludeSeverity(
-  severity: 'critical' | 'major' | 'minor' | 'info',
-  minSeverity: 'critical' | 'major' | 'minor' | 'info'
+  severity: Severity | string,
+  minSeverity: Severity | string
 ): boolean {
-  const severityLevels = { info: 0, minor: 1, major: 2, critical: 3 };
-  return severityLevels[severity] >= severityLevels[minSeverity];
+  return getSeverityLevel(severity) >= getSeverityLevel(minSeverity);
 }
 
 function calculateConsistencyScore(issues: ConsistencyIssue[]): number {
-  // Higher score = more consistent (fewer issues)
-  const weights = { critical: 10, major: 5, minor: 2, info: 1 };
-  const totalWeight = issues.reduce(
-    (sum, issue) => sum + weights[issue.severity],
-    0
-  );
+  let totalWeight = 0;
+  for (const issue of issues) {
+    const val = getSeverityLevel(issue.severity);
+    switch (val) {
+      case 4: totalWeight += 10; break;
+      case 3: totalWeight += 5; break;
+      case 2: totalWeight += 2; break;
+      case 1: totalWeight += 1; break;
+      default: totalWeight += 1;
+    }
+  }
   // Score from 0-1, where 1 is perfect
   return Math.max(0, 1 - totalWeight / 100);
 }