@aiready/testability 0.6.18 → 0.6.20

package/dist/index.js

@@ -44,7 +44,7 @@ async function analyzeFileTestability(filePath) {
     totalInterfaces: 0,
     externalStateMutations: 0
   };
-  const parser = (0, import_core.getParser)(filePath);
+  const parser = await (0, import_core.getParser)(filePath);
   if (!parser) return result;
   let code;
   try {
@@ -240,52 +240,22 @@ async function analyzeTestability(options) {
 var import_core2 = require("@aiready/core");
 function calculateTestabilityScore(report) {
   const { summary, rawData, recommendations } = report;
-  const factors = [
-    {
-      name: "Test Coverage",
-      impact: Math.round(summary.dimensions.testCoverageRatio - 50),
-      description: `${rawData.testFiles} test files / ${rawData.sourceFiles} source files (${Math.round(summary.coverageRatio * 100)}%)`
-    },
-    {
-      name: "Function Purity",
-      impact: Math.round(summary.dimensions.purityScore - 50),
-      description: `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`
-    },
-    {
-      name: "Dependency Injection",
-      impact: Math.round(summary.dimensions.dependencyInjectionScore - 50),
-      description: `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`
-    },
-    {
-      name: "Interface Focus",
-      impact: Math.round(summary.dimensions.interfaceFocusScore - 50),
-      description: `${rawData.bloatedInterfaces} interfaces have >10 methods`
-    },
-    {
-      name: "Observability",
-      impact: Math.round(summary.dimensions.observabilityScore - 50),
-      description: `${rawData.externalStateMutations} functions mutate external state`
-    }
-  ];
-  const recs = recommendations.map(
-    (action) => ({
-      action,
-      estimatedImpact: summary.aiChangeSafetyRating === "blind-risk" ? 15 : 8,
-      priority: summary.aiChangeSafetyRating === "blind-risk" || summary.aiChangeSafetyRating === "high-risk" ? "high" : "medium"
-    })
-  );
-  return {
+  return (0, import_core2.buildStandardToolScore)({
     toolName: import_core2.ToolName.TestabilityIndex,
     score: summary.score,
-    rawMetrics: {
-      ...rawData,
-      rating: summary.rating,
-      aiChangeSafetyRating: summary.aiChangeSafetyRating,
-      coverageRatio: summary.coverageRatio
+    rawData,
+    dimensions: summary.dimensions,
+    dimensionNames: {
+      testCoverageRatio: "Test Coverage",
+      purityScore: "Function Purity",
+      dependencyInjectionScore: "Dependency Injection",
+      interfaceFocusScore: "Interface Focus",
+      observabilityScore: "Observability"
     },
-    factors,
-    recommendations: recs
-  };
+    recommendations,
+    recommendationImpact: summary.aiChangeSafetyRating === "blind-risk" ? 15 : 8,
+    rating: summary.aiChangeSafetyRating || summary.rating
+  });
 }
 
 // src/provider.ts

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   analyzeTestability,
   calculateTestabilityScore
-} from "./chunk-JL4S6RHJ.mjs";
+} from "./chunk-QMDUZA7H.mjs";
 
 // src/index.ts
 import { ToolRegistry } from "@aiready/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/testability",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "description": "Measures how safely and verifiably AI-generated changes can be made to your codebase",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,7 +40,7 @@
     "chalk": "^5.3.0",
     "commander": "^14.0.0",
     "glob": "^13.0.0",
-    "@aiready/core": "0.23.19"
+    "@aiready/core": "0.23.21"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/analyzer.test.ts

@@ -1,14 +1,14 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { analyzeTestability } from '../analyzer';
 import { join } from 'path';
-import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
 import { tmpdir } from 'os';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
 describe('Testability Analyzer', () => {
   let tmpDir: string;
 
   beforeAll(() => {
-    tmpDir = join(tmpdir(), `aiready-testability-complex-${Date.now()}`);
+    tmpDir = join(tmpdir(), `aiready-testability-${Date.now()}`);
     mkdirSync(tmpDir, { recursive: true });
   });
 
@@ -52,55 +52,44 @@ describe('Testability Analyzer', () => {
     const javaReport = await analyzeTestability({ rootDir: javaDir });
     expect(javaReport.rawData.hasTestFramework).toBe(true);
 
-    // Test Go detection (built-in)
+    // Test Go detection
     const goReport = await analyzeTestability({ rootDir: goDir });
     expect(goReport.rawData.hasTestFramework).toBe(true);
-  });
+  }, 15000);
 
   it('flags missing test framework as critical', async () => {
     const emptyDir = join(tmpDir, 'no-tests');
     mkdirSync(emptyDir);
-    writeFileSync(join(emptyDir, 'app.ts'), 'export const x = 1;');
+    writeFileSync(join(emptyDir, 'App.ts'), 'export const a = 1;');
 
     const report = await analyzeTestability({ rootDir: emptyDir });
     expect(report.rawData.hasTestFramework).toBe(false);
-    expect(
-      report.issues.some(
-        (i) => i.dimension === 'framework' && i.severity === 'critical'
-      )
-    ).toBe(true);
+    // Rating is 'unverifiable' when no framework is found
+    expect(report.summary.rating).toBe('unverifiable');
   });
 
   it('detects injection patterns in classes', async () => {
     createTestFile(
       'src/di.ts',
-      `
-      export class Service {
-        constructor(public db: any) {}
-      }
-    `
+      'export class UserService { constructor(db: any) {} }'
     );
     const report = await analyzeTestability({ rootDir: tmpDir });
-    expect(report.rawData.injectionPatterns).toBeGreaterThanOrEqual(1);
+    expect(report.rawData.injectionPatterns).toBeGreaterThan(0);
   });
 
   it('detects bloated interfaces', async () => {
     createTestFile(
       'src/bloated.ts',
-      `
-      export interface Massive {
-        a(): void; b(): void; c(): void; d(): void; e(): void; f(): void; g(): void;
-        h(): void; i(): void; j(): void; k(): void; l(): void;
-      }
-    `
+      'export interface Big { m1(); m2(); m3(); m4(); m5(); m6(); m7(); m8(); m9(); m10(); m11(); m12(); }'
     );
     const report = await analyzeTestability({ rootDir: tmpDir });
-    expect(report.rawData.bloatedInterfaces).toBeGreaterThanOrEqual(1);
+    expect(report.rawData.bloatedInterfaces).toBeGreaterThan(0);
   });
 
   it('gracefully handles missing parser or read errors', async () => {
-    createTestFile('src/config.json', '{"test": true}');
+    createTestFile('src/unknown.xyz', 'some content');
     const report = await analyzeTestability({ rootDir: tmpDir });
-    expect(report.summary.sourceFiles).toBeDefined();
+    expect(report).toBeDefined();
+    expect(report.summary.sourceFiles).toBeGreaterThan(0);
   });
 });

package/src/__tests__/scoring.test.ts

@@ -44,7 +44,7 @@ describe('Testability Scoring', () => {
     expect(scoring.factors.length).toBe(5);
 
     const coverageFactor = scoring.factors.find(
-      (f) => f.name === 'Test Coverage'
+      (f: any) => f.name === 'Test Coverage'
     );
     expect(coverageFactor?.impact).toBe(30); // 80 - 50
     expect(coverageFactor?.description).toContain(

package/src/analyzer.ts

@@ -39,7 +39,7 @@ async function analyzeFileTestability(filePath: string): Promise<FileAnalysis> {
     externalStateMutations: 0,
   };
 
-  const parser = getParser(filePath);
+  const parser = await getParser(filePath);
   if (!parser) return result;
 
   let code: string;

package/src/cli.ts

@@ -8,15 +8,13 @@ import chalk from 'chalk';
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { dirname } from 'path';
 import {
-  loadConfig,
-  mergeConfigWithDefaults,
   resolveOutputPath,
-  getScoreBar,
-  getSafetyIcon,
-  getSeverityColor,
+  displayStandardConsoleReport,
+  createStandardProgressCallback,
 } from '@aiready/core';
 
 const program = new Command();
+const startTime = Date.now();
 
 program
   .name('aiready-testability')
@@ -62,21 +60,14 @@ EXAMPLES:
   .option('--output-file <path>', 'Output file path (for json)')
   .action(async (directory, options) => {
     console.log(chalk.blue('🧪 Analyzing testability...\n'));
-    const startTime = Date.now();
-
-    const config = await loadConfig(directory);
-    const mergedConfig = mergeConfigWithDefaults(config, {
-      minCoverageRatio: 0.3,
-    });
 
     const finalOptions: TestabilityOptions = {
       rootDir: directory,
-      minCoverageRatio:
-        parseFloat(options.minCoverage ?? '0.3') ||
-        mergedConfig.minCoverageRatio,
+      minCoverageRatio: parseFloat(options.minCoverage ?? '0.3'),
       testPatterns: options.testPatterns?.split(','),
       include: options.include?.split(','),
       exclude: options.exclude?.split(','),
+      onProgress: createStandardProgressCallback('testability'),
     };
 
     const report = await analyzeTestability(finalOptions);
@@ -95,82 +86,46 @@ EXAMPLES:
       writeFileSync(outputPath, JSON.stringify(payload, null, 2));
       console.log(chalk.green(`✓ Report saved to ${outputPath}`));
     } else {
-      displayConsoleReport(report, scoring, elapsed);
+      displayStandardConsoleReport({
+        title: '🧪 Testability Analysis',
+        score: scoring.summary.score,
+        rating: scoring.summary.rating,
+        dimensions: [
+          {
+            name: 'Test Coverage',
+            value: scoring.summary.dimensions.testCoverageRatio,
+          },
+          {
+            name: 'Function Purity',
+            value: scoring.summary.dimensions.purityScore,
+          },
+          {
+            name: 'Dependency Injection',
+            value: scoring.summary.dimensions.dependencyInjectionScore,
+          },
+          {
+            name: 'Interface Focus',
+            value: scoring.summary.dimensions.interfaceFocusScore,
+          },
+          {
+            name: 'Observability',
+            value: scoring.summary.dimensions.observabilityScore,
+          },
+        ],
+        stats: [
+          { label: 'Source Files', value: report.rawData.sourceFiles },
+          { label: 'Test Files', value: report.rawData.testFiles },
+          {
+            label: 'Coverage Ratio',
+            value: Math.round(scoring.summary.coverageRatio * 100) + '%',
+          },
+        ],
+        issues: report.issues,
+        recommendations: report.recommendations,
+        elapsedTime: elapsed,
+        safetyRating: report.summary.aiChangeSafetyRating,
+      });
     }
   });
 
 program.parse();
-
-function displayConsoleReport(report: any, scoring: any, elapsed: string) {
-  const { summary, rawData, issues, recommendations } = report;
-
-  // The most important banner
-  const safetyRating = summary.aiChangeSafetyRating;
-  console.log(chalk.bold('\n🧪 Testability Analysis\n'));
-
-  if (safetyRating === 'blind-risk') {
-    console.log(
-      chalk.bgRed.white.bold(
-        '  💀 BLIND RISK — NO TESTS DETECTED. AI-GENERATED CHANGES CANNOT BE VERIFIED.  '
-      )
-    );
-    console.log();
-  } else if (safetyRating === 'high-risk') {
-    console.log(
-      chalk.red.bold(
-        `  🔴 HIGH RISK — Insufficient test coverage. AI changes may introduce silent bugs.`
-      )
-    );
-    console.log();
-  }
-
-  const safetyColor = getSeverityColor(safetyRating, chalk);
-  console.log(
-    `AI Change Safety: ${safetyColor(`${getSafetyIcon(safetyRating)} ${safetyRating.toUpperCase()}`)}`
-  );
-  console.log(
-    `Score:            ${chalk.bold(summary.score + '/100')} (${summary.rating})`
-  );
-  console.log(
-    `Source Files:     ${chalk.cyan(rawData.sourceFiles)}   Test Files: ${chalk.cyan(rawData.testFiles)}`
-  );
-  console.log(
-    `Coverage Ratio:   ${chalk.bold(Math.round(summary.coverageRatio * 100) + '%')}`
-  );
-  console.log(`Analysis Time:    ${chalk.gray(elapsed + 's')}\n`);
-
-  console.log(chalk.bold('📐 Dimension Scores\n'));
-  const dims: [string, number][] = [
-    ['Test Coverage', summary.dimensions.testCoverageRatio],
-    ['Function Purity', summary.dimensions.purityScore],
-    ['Dependency Injection', summary.dimensions.dependencyInjectionScore],
-    ['Interface Focus', summary.dimensions.interfaceFocusScore],
-    ['Observability', summary.dimensions.observabilityScore],
-  ];
-  for (const [name, val] of dims) {
-    const color =
-      val >= 70 ? chalk.green : val >= 50 ? chalk.yellow : chalk.red;
-    console.log(`  ${name.padEnd(22)} ${color(getScoreBar(val))} ${val}/100`);
-  }
-
-  if (issues.length > 0) {
-    console.log(chalk.bold('\n⚠️  Issues\n'));
-    for (const issue of issues) {
-      const sev = getSeverityColor(issue.severity, chalk);
-      console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
-      if (issue.suggestion)
-        console.log(
-          `       ${chalk.dim('→')} ${chalk.italic(issue.suggestion)}`
-        );
-      console.log();
-    }
-  }
-
-  if (recommendations.length > 0) {
-    console.log(chalk.bold('💡 Recommendations\n'));
-    recommendations.forEach((rec: string, i: number) => {
-      console.log(`${i + 1}. ${rec}`);
-    });
-  }
-  console.log();
-}

package/src/scoring.ts

@@ -1,67 +1,27 @@
-import { type ToolScoringOutput, ToolName } from '@aiready/core';
+import { ToolName, buildStandardToolScore } from '@aiready/core';
 import type { TestabilityReport } from './types';
 
 /**
  * Convert testability report into a ToolScoringOutput for the unified score.
- *
- * @param report - The comprehensive testability report containing raw metrics and summary.
- * @returns Standardized scoring output with impact factors and recommendations.
  */
-export function calculateTestabilityScore(
-  report: TestabilityReport
-): ToolScoringOutput {
+export function calculateTestabilityScore(report: TestabilityReport): any {
   const { summary, rawData, recommendations } = report;
 
-  const factors: ToolScoringOutput['factors'] = [
-    {
-      name: 'Test Coverage',
-      impact: Math.round(summary.dimensions.testCoverageRatio - 50),
-      description: `${rawData.testFiles} test files / ${rawData.sourceFiles} source files (${Math.round(summary.coverageRatio * 100)}%)`,
-    },
-    {
-      name: 'Function Purity',
-      impact: Math.round(summary.dimensions.purityScore - 50),
-      description: `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`,
-    },
-    {
-      name: 'Dependency Injection',
-      impact: Math.round(summary.dimensions.dependencyInjectionScore - 50),
-      description: `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`,
-    },
-    {
-      name: 'Interface Focus',
-      impact: Math.round(summary.dimensions.interfaceFocusScore - 50),
-      description: `${rawData.bloatedInterfaces} interfaces have >10 methods`,
-    },
-    {
-      name: 'Observability',
-      impact: Math.round(summary.dimensions.observabilityScore - 50),
-      description: `${rawData.externalStateMutations} functions mutate external state`,
-    },
-  ];
-
-  const recs: ToolScoringOutput['recommendations'] = recommendations.map(
-    (action) => ({
-      action,
-      estimatedImpact: summary.aiChangeSafetyRating === 'blind-risk' ? 15 : 8,
-      priority:
-        summary.aiChangeSafetyRating === 'blind-risk' ||
-        summary.aiChangeSafetyRating === 'high-risk'
-          ? 'high'
-          : 'medium',
-    })
-  );
-
-  return {
+  return buildStandardToolScore({
     toolName: ToolName.TestabilityIndex,
     score: summary.score,
-    rawMetrics: {
-      ...rawData,
-      rating: summary.rating,
-      aiChangeSafetyRating: summary.aiChangeSafetyRating,
-      coverageRatio: summary.coverageRatio,
+    rawData,
+    dimensions: summary.dimensions,
+    dimensionNames: {
+      testCoverageRatio: 'Test Coverage',
+      purityScore: 'Function Purity',
+      dependencyInjectionScore: 'Dependency Injection',
+      interfaceFocusScore: 'Interface Focus',
+      observabilityScore: 'Observability',
     },
-    factors,
-    recommendations: recs,
-  };
+    recommendations,
+    recommendationImpact:
+      summary.aiChangeSafetyRating === 'blind-risk' ? 15 : 8,
+    rating: summary.aiChangeSafetyRating || summary.rating,
+  });
 }