@aiready/consistency 0.16.3 → 0.18.0

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.d.mts

@@ -1,4 +1,9 @@
-import { Severity, Issue, IssueType, ScanOptions, AnalysisResult, CostConfig, ToolScoringOutput } from '@aiready/core';
+import { ToolProvider, Severity, Issue, IssueType, ScanOptions, AnalysisResult, CostConfig, ToolScoringOutput } from '@aiready/core';
+
+/**
+ * Consistency Tool Provider
+ */
+declare const ConsistencyProvider: ToolProvider;
 
 interface ConsistencyOptions extends ScanOptions {
     /** Check naming conventions and quality */
@@ -99,4 +104,4 @@ declare function analyzePatterns(filePaths: string[]): Promise<PatternIssue[]>;
  */
 declare function calculateConsistencyScore(issues: ConsistencyIssue[], totalFilesAnalyzed: number, costConfig?: Partial<CostConfig>): ToolScoringOutput;
 
-export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, calculateConsistencyScore, detectNamingConventions };
+export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, ConsistencyProvider, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, calculateConsistencyScore, detectNamingConventions };

package/dist/index.d.ts

@@ -1,4 +1,9 @@
-import { Severity, Issue, IssueType, ScanOptions, AnalysisResult, CostConfig, ToolScoringOutput } from '@aiready/core';
+import { ToolProvider, Severity, Issue, IssueType, ScanOptions, AnalysisResult, CostConfig, ToolScoringOutput } from '@aiready/core';
+
+/**
+ * Consistency Tool Provider
+ */
+declare const ConsistencyProvider: ToolProvider;
 
 interface ConsistencyOptions extends ScanOptions {
     /** Check naming conventions and quality */
@@ -99,4 +104,4 @@ declare function analyzePatterns(filePaths: string[]): Promise<PatternIssue[]>;
  */
 declare function calculateConsistencyScore(issues: ConsistencyIssue[], totalFilesAnalyzed: number, costConfig?: Partial<CostConfig>): ToolScoringOutput;
 
-export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, calculateConsistencyScore, detectNamingConventions };
+export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, ConsistencyProvider, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, calculateConsistencyScore, detectNamingConventions };

package/dist/index.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ConsistencyProvider: () => ConsistencyProvider,
   analyzeConsistency: () => analyzeConsistency,
   analyzeNaming: () => analyzeNaming,
   analyzeNamingAST: () => analyzeNamingAST,
@@ -38,6 +39,10 @@ __export(index_exports, {
   detectNamingConventions: () => detectNamingConventions
 });
 module.exports = __toCommonJS(index_exports);
+var import_core9 = require("@aiready/core");
+
+// src/provider.ts
+var import_core7 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core5 = require("@aiready/core");
@@ -416,7 +421,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 {
@@ -855,77 +871,8 @@ function generateRecommendations(namingIssues, patternIssues) {
   return recommendations;
 }
 
-// src/analyzers/naming.ts
-var import_fs3 = require("fs");
-var import_core6 = require("@aiready/core");
-async function analyzeNaming(filePaths) {
-  const issues = [];
-  for (const filePath of filePaths) {
-    try {
-      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*=/);
-        if (singleLetterMatch) {
-          issues.push({
-            file: filePath,
-            line: index + 1,
-            type: "poor-naming",
-            identifier: singleLetterMatch[2],
-            severity: import_core6.Severity.Minor,
-            suggestion: "Use a more descriptive name than a single letter"
-          });
-        }
-        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: import_core6.Severity.Info,
-              suggestion: "Use camelCase instead of snake_case in TypeScript/JavaScript"
-            });
-          }
-        }
-        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: import_core6.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
-var import_core7 = require("@aiready/core");
+var import_core6 = require("@aiready/core");
 function calculateConsistencyScore2(issues, totalFilesAnalyzed, costConfig) {
   void costConfig;
   const criticalIssues = issues.filter((i) => i.severity === "critical").length;
@@ -1001,9 +948,9 @@ function calculateConsistencyScore2(issues, totalFilesAnalyzed, costConfig) {
       priority: "low"
     });
   }
-  const productivityImpact = (0, import_core7.calculateProductivityImpact)(issues);
+  const productivityImpact = (0, import_core6.calculateProductivityImpact)(issues);
   return {
-    toolName: "consistency",
+    toolName: import_core6.ToolName.NamingConsistency,
     score,
     rawMetrics: {
       totalIssues,
@@ -1019,8 +966,116 @@ function calculateConsistencyScore2(issues, totalFilesAnalyzed, costConfig) {
     recommendations
   };
 }
+
+// src/provider.ts
+var ConsistencyProvider = {
+  id: import_core7.ToolName.NamingConsistency,
+  alias: ["consistency", "naming", "standards"],
+  async analyze(options) {
+    const report = await analyzeConsistency(options);
+    return import_core7.SpokeOutputSchema.parse({
+      results: report.results,
+      summary: report.summary,
+      metadata: {
+        toolName: import_core7.ToolName.NamingConsistency,
+        version: "0.16.5",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  },
+  score(output, options) {
+    const results = output.results;
+    const allIssues = results.flatMap((r) => r.issues);
+    const totalFiles = output.summary.filesAnalyzed || results.length;
+    return calculateConsistencyScore2(
+      allIssues,
+      totalFiles,
+      options.costConfig
+    );
+  },
+  defaultWeight: 14
+};
+
+// src/analyzers/naming.ts
+var import_fs3 = require("fs");
+var import_core8 = require("@aiready/core");
+async function analyzeNaming(filePaths) {
+  const issues = [];
+  for (const filePath of filePaths) {
+    try {
+      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*=/
+        );
+        if (singleLetterMatch) {
+          issues.push({
+            file: filePath,
+            line: index + 1,
+            type: "poor-naming",
+            identifier: singleLetterMatch[2],
+            severity: import_core8.Severity.Minor,
+            suggestion: "Use a more descriptive name than a single letter"
+          });
+        }
+        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: import_core8.Severity.Info,
+              suggestion: "Use camelCase instead of snake_case in TypeScript/JavaScript"
+            });
+          }
+        }
+        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: import_core8.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/index.ts
+import_core9.ToolRegistry.register(ConsistencyProvider);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ConsistencyProvider,
   analyzeConsistency,
   analyzeNaming,
   analyzeNamingAST,

package/dist/index.mjs

@@ -2,79 +2,19 @@ import {
   analyzeConsistency,
   analyzeNamingAST,
   analyzePatterns
-} from "./chunk-HJCP36VW.mjs";
+} from "./chunk-IXBC6GVT.mjs";
 
-// src/analyzers/naming.ts
-import { readFileSync } from "fs";
-import { Severity } from "@aiready/core";
-async function analyzeNaming(filePaths) {
-  const issues = [];
-  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: filePath,
-            line: index + 1,
-            type: "poor-naming",
-            identifier: singleLetterMatch[2],
-            severity: Severity.Minor,
-            suggestion: "Use a more descriptive name than a single letter"
-          });
-        }
-        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"
-            });
-          }
-        }
-        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/index.ts
+import { ToolRegistry } from "@aiready/core";
 
-// 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/provider.ts
+import {
+  ToolName as ToolName2,
+  SpokeOutputSchema
+} from "@aiready/core";
 
 // src/scoring.ts
-import { calculateProductivityImpact } from "@aiready/core";
+import { calculateProductivityImpact, ToolName } from "@aiready/core";
 function calculateConsistencyScore(issues, totalFilesAnalyzed, costConfig) {
   void costConfig;
   const criticalIssues = issues.filter((i) => i.severity === "critical").length;
@@ -152,7 +92,7 @@ function calculateConsistencyScore(issues, totalFilesAnalyzed, costConfig) {
   }
   const productivityImpact = calculateProductivityImpact(issues);
   return {
-    toolName: "consistency",
+    toolName: ToolName.NamingConsistency,
     score,
     rawMetrics: {
       totalIssues,
@@ -168,7 +108,115 @@ function calculateConsistencyScore(issues, totalFilesAnalyzed, costConfig) {
     recommendations
   };
 }
+
+// src/provider.ts
+var ConsistencyProvider = {
+  id: ToolName2.NamingConsistency,
+  alias: ["consistency", "naming", "standards"],
+  async analyze(options) {
+    const report = await analyzeConsistency(options);
+    return SpokeOutputSchema.parse({
+      results: report.results,
+      summary: report.summary,
+      metadata: {
+        toolName: ToolName2.NamingConsistency,
+        version: "0.16.5",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  },
+  score(output, options) {
+    const results = output.results;
+    const allIssues = results.flatMap((r) => r.issues);
+    const totalFiles = output.summary.filesAnalyzed || results.length;
+    return calculateConsistencyScore(
+      allIssues,
+      totalFiles,
+      options.costConfig
+    );
+  },
+  defaultWeight: 14
+};
+
+// src/analyzers/naming.ts
+import { readFileSync } from "fs";
+import { Severity } from "@aiready/core";
+async function analyzeNaming(filePaths) {
+  const issues = [];
+  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: filePath,
+            line: index + 1,
+            type: "poor-naming",
+            identifier: singleLetterMatch[2],
+            severity: Severity.Minor,
+            suggestion: "Use a more descriptive name than a single letter"
+          });
+        }
+        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"
+            });
+          }
+        }
+        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/index.ts
+ToolRegistry.register(ConsistencyProvider);
 export {
+  ConsistencyProvider,
   analyzeConsistency,
   analyzeNaming,
   analyzeNamingAST,

package/package.json

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

package/src/__tests__/scoring.test.ts

@@ -8,7 +8,7 @@ describe('Consistency Scoring', () => {
       const result = calculateConsistencyScore([], 100);
 
       expect(result.score).toBe(100);
-      expect(result.toolName).toBe('consistency');
+      expect(result.toolName).toBe('naming-consistency');
       expect(result.rawMetrics.totalIssues).toBe(0);
       expect(result.recommendations).toHaveLength(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 });
   }