@aiready/consistency 0.16.5 → 0.18.0

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/consistency@0.16.4 build /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.17.0 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,16 +9,16 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-ESM dist/cli.mjs            8.83 KB
 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
+ESM dist/cli.mjs            8.83 KB
+ESM dist/index.mjs          7.17 KB
+ESM ⚡️ Build success in 113ms
+CJS dist/index.js 34.41 KB
 CJS dist/cli.js   35.81 KB
-CJS ⚡️ Build success in 24ms
+CJS ⚡️ Build success in 113ms
 DTS Build start
-DTS ⚡️ Build success in 1221ms
+DTS ⚡️ Build success in 3044ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  3.34 KB
+DTS dist/index.d.ts  3.46 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 3.34 KB
+DTS dist/index.d.mts 3.46 KB

package/.turbo/turbo-lint.log

@@ -1,5 +1,17 @@
 
 
-> @aiready/consistency@0.8.32 lint /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.16.5 lint /Users/pengcao/projects/aiready/packages/consistency
 > eslint src
 
+
+/Users/pengcao/projects/aiready/packages/consistency/src/analyzers/naming-ast.ts
+    7:3   warning  'getFunctionName' is defined but never used    @typescript-eslint/no-unused-vars
+    9:3   warning  'isCoverageContext' is defined but never used  @typescript-eslint/no-unused-vars
+  157:17  warning  'node' is assigned a value but never used      @typescript-eslint/no-unused-vars
+
+/Users/pengcao/projects/aiready/packages/consistency/src/analyzers/patterns.ts
+  16:9  warning  'catchPattern' is assigned a value but never used  @typescript-eslint/no-unused-vars
+  42:9  warning  'totalFiles' is assigned a value but never used    @typescript-eslint/no-unused-vars
+
+✖ 5 problems (0 errors, 5 warnings)
+

package/.turbo/turbo-test.log

@@ -1,22 +1,26 @@
 
 
-> @aiready/consistency@0.16.4 test /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.17.0 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
+ ✓ dist/__tests__/scoring.test.js (8 tests) 3ms
+ ✓ src/__tests__/language-filter.test.ts (3 tests) 4ms
  ✓ 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
+stdout | src/__tests__/contract.test.ts
+[ToolRegistry#0.3287512410546808] Registering tool: naming-consistency (consistency, naming, standards)
+
+ ✓ src/__tests__/contract.test.ts (1 test) 5ms
+ ✓ dist/__tests__/language-filter.test.js (3 tests) 3ms
+ ✓ dist/__tests__/analyzer.test.js (18 tests) 387ms
+ ✓ src/__tests__/analyzer.test.ts (18 tests) 653ms
+     ✓ should analyze naming issues  383ms
 
  Test Files  7 passed (7)
       Tests  59 passed (59)
-   Start at  21:39:02
-   Duration  1.94s (transform 1.08s, setup 0ms, import 5.25s, tests 939ms, environment 1ms)
+   Start at  09:33:02
+   Duration  1.97s (transform 710ms, setup 0ms, import 4.13s, tests 1.06s, environment 1ms)
 
 [?25h

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");
@@ -866,83 +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;
@@ -1018,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,
@@ -1036,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

@@ -4,83 +4,17 @@ import {
   analyzePatterns
 } 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;
@@ -158,7 +92,7 @@ function calculateConsistencyScore(issues, totalFilesAnalyzed, costConfig) {
   }
   const productivityImpact = calculateProductivityImpact(issues);
   return {
-    toolName: "consistency",
+    toolName: ToolName.NamingConsistency,
     score,
     rawMetrics: {
       totalIssues,
@@ -174,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.5",
+  "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.5"
+    "@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/index.ts

@@ -1,9 +1,16 @@
+import { ToolRegistry } from '@aiready/core';
+import { ConsistencyProvider } from './provider';
+
+// Register with global registry
+ToolRegistry.register(ConsistencyProvider);
+
 export { analyzeConsistency } from './analyzer';
 export { analyzeNamingAST } from './analyzers/naming-ast';
 export { analyzeNaming } from './analyzers/naming'; // Legacy regex version
 export { detectNamingConventions } from './analyzers/naming-constants';
 export { analyzePatterns } from './analyzers/patterns';
 export { calculateConsistencyScore } from './scoring';
+export { ConsistencyProvider };
 export type {
   ConsistencyOptions,
   ConsistencyReport,

package/src/provider.ts

@@ -0,0 +1,48 @@
+import {
+  ToolProvider,
+  ToolName,
+  SpokeOutput,
+  ScanOptions,
+  ToolScoringOutput,
+  AnalysisResult,
+  SpokeOutputSchema,
+} from '@aiready/core';
+import { analyzeConsistency } from './analyzer';
+import { calculateConsistencyScore } from './scoring';
+import { ConsistencyOptions, ConsistencyIssue } from './types';
+
+/**
+ * Consistency Tool Provider
+ */
+export const ConsistencyProvider: ToolProvider = {
+  id: ToolName.NamingConsistency,
+  alias: ['consistency', 'naming', 'standards'],
+
+  async analyze(options: ScanOptions): Promise<SpokeOutput> {
+    const report = await analyzeConsistency(options as ConsistencyOptions);
+
+    return SpokeOutputSchema.parse({
+      results: report.results as AnalysisResult[],
+      summary: report.summary,
+      metadata: {
+        toolName: ToolName.NamingConsistency,
+        version: '0.16.5',
+        timestamp: new Date().toISOString(),
+      },
+    });
+  },
+
+  score(output: SpokeOutput, options: ScanOptions): ToolScoringOutput {
+    const results = output.results as AnalysisResult[];
+    const allIssues = results.flatMap((r) => r.issues as ConsistencyIssue[]);
+    const totalFiles = (output.summary as any).filesAnalyzed || results.length;
+
+    return calculateConsistencyScore(
+      allIssues,
+      totalFiles,
+      (options as any).costConfig
+    );
+  },
+
+  defaultWeight: 14,
+};

package/src/scoring.ts

@@ -1,4 +1,4 @@
-import { calculateProductivityImpact } from '@aiready/core';
+import { calculateProductivityImpact, ToolName } from '@aiready/core';
 import type { ToolScoringOutput, CostConfig } from '@aiready/core';
 import type { ConsistencyIssue } from './types';
 
@@ -127,7 +127,7 @@ export function calculateConsistencyScore(
   const productivityImpact = calculateProductivityImpact(issues);
 
   return {
-    toolName: 'consistency',
+    toolName: ToolName.NamingConsistency,
     score,
     rawMetrics: {
       totalIssues,