@aiready/consistency 0.16.3 → 0.18.0

package/src/analyzers/naming.ts

@@ -6,7 +6,9 @@ import type { NamingIssue } from '../types';
  * Legacy regex-based naming analyzer
  * (Used as fallback or for languages without AST support)
  */
-export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]> {
+export async function analyzeNaming(
+  filePaths: string[]
+): Promise<NamingIssue[]> {
   const issues: NamingIssue[] = [];
 
   for (const filePath of filePaths) {
@@ -16,9 +18,11 @@ export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]>
 
       lines.forEach((line, index) => {
         // Simple regex patterns for naming issues
-        
+
         // 1. Single letter variables (except common ones)
-        const singleLetterMatch = line.match(/\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/);
+        const singleLetterMatch = line.match(
+          /\b(const|let|var)\s+([a-hj-km-np-zA-Z])\s*=/
+        );
         if (singleLetterMatch) {
           issues.push({
             file: filePath,
@@ -32,7 +36,9 @@ export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]>
 
         // 2. Snake case in TS/JS files
         if (filePath.match(/\.(ts|tsx|js|jsx)$/)) {
-          const snakeCaseMatch = line.match(/\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/);
+          const snakeCaseMatch = line.match(
+            /\b(const|let|var|function)\s+([a-z]+_[a-z0-9_]+)\b/
+          );
           if (snakeCaseMatch) {
             issues.push({
               file: filePath,
@@ -40,13 +46,16 @@ export async function analyzeNaming(filePaths: string[]): Promise<NamingIssue[]>
               type: 'convention-mix',
               identifier: snakeCaseMatch[2],
               severity: Severity.Info,
-              suggestion: 'Use camelCase instead of snake_case in TypeScript/JavaScript',
+              suggestion:
+                'Use camelCase instead of snake_case in TypeScript/JavaScript',
             });
           }
         }
 
         // 3. Very short names
-        const shortNameMatch = line.match(/\b(const|let|var)\s+([a-zA-Z0-9]{2,3})\s*=/);
+        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'];

package/src/analyzers/patterns.ts

@@ -5,14 +5,16 @@ import type { PatternIssue } from '../types';
 /**
  * Detect inconsistent code patterns across files
  */
-export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue[]> {
+export async function analyzePatterns(
+  filePaths: string[]
+): Promise<PatternIssue[]> {
   const issues: PatternIssue[] = [];
   const contents = new Map<string, string>();
 
   // 1. Error handling style
   const tryCatchPattern = /try\s*\{/g;
   const catchPattern = /catch\s*\(\s*(\w+)\s*\)/g;
-  
+
   const styleStats = {
     tryCatch: 0,
     thenCatch: 0,
@@ -29,7 +31,7 @@ export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue
       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) {
@@ -41,13 +43,16 @@ export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue
 
   // Report inconsistencies if there's a significant mix
   if (styleStats.tryCatch > 0 && styleStats.thenCatch > 0) {
-    const dominant = styleStats.tryCatch >= styleStats.thenCatch ? 'try-catch' : '.catch()';
+    const dominant =
+      styleStats.tryCatch >= styleStats.thenCatch ? 'try-catch' : '.catch()';
     const minority = dominant === 'try-catch' ? '.catch()' : 'try-catch';
-    
+
     issues.push({
-      files: filePaths.filter(f => {
+      files: filePaths.filter((f) => {
         const c = contents.get(f) || '';
-        return minority === 'try-catch' ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
+        return minority === 'try-catch'
+          ? c.match(tryCatchPattern)
+          : c.match(/\.catch\s*\(/);
       }),
       type: 'error-handling',
       description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
@@ -57,11 +62,16 @@ export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue
   }
 
   if (styleStats.commonJs > 0 && styleStats.esm > 0) {
-    const minority = styleStats.esm >= styleStats.commonJs ? 'CommonJS (require)' : 'ESM (import)';
+    const minority =
+      styleStats.esm >= styleStats.commonJs
+        ? 'CommonJS (require)'
+        : 'ESM (import)';
     issues.push({
-      files: filePaths.filter(f => {
+      files: filePaths.filter((f) => {
         const c = contents.get(f) || '';
-        return minority === 'CommonJS (require)' ? c.match(/\brequire\s*\(/) : c.match(/\bimport\b/);
+        return minority === 'CommonJS (require)'
+          ? c.match(/\brequire\s*\(/)
+          : c.match(/\bimport\b/);
       }),
       type: 'import-style',
       description: `Mixed module systems: found both ESM and CommonJS.`,

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,

package/src/types.ts

@@ -1,4 +1,10 @@
-import type { ScanOptions, AnalysisResult, Issue, Severity, IssueType } from '@aiready/core';
+import type {
+  ScanOptions,
+  AnalysisResult,
+  Issue,
+  Severity,
+  IssueType,
+} from '@aiready/core';
 
 export interface ConsistencyOptions extends ScanOptions {
   /** Check naming conventions and quality */