@aiready/testability 0.1.5 → 0.1.8

package/src/analyzer.ts

@@ -10,66 +10,16 @@
  * 5. Observability (return values vs. external state mutations)
  */
 
-import { readdirSync, statSync, readFileSync, existsSync } from 'fs';
-import { join, extname, basename } from 'path';
+import { scanFiles, calculateTestabilityIndex } from '@aiready/core';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
 import { parse } from '@typescript-eslint/typescript-estree';
 import type { TSESTree } from '@typescript-eslint/types';
-import { calculateTestabilityIndex } from '@aiready/core';
-import type { TestabilityOptions, TestabilityIssue, TestabilityReport } from './types';
-
-// ---------------------------------------------------------------------------
-// File classification
-// ---------------------------------------------------------------------------
-
-const SRC_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
-const DEFAULT_EXCLUDES = ['node_modules', 'dist', '.git', 'coverage', '.turbo', 'build'];
-const TEST_PATTERNS = [
-  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
-  /__tests__\//,
-  /\/tests?\//,
-  /\/e2e\//,
-  /\/fixtures\//,
-];
-
-function isTestFile(filePath: string, extra?: string[]): boolean {
-  if (TEST_PATTERNS.some(p => p.test(filePath))) return true;
-  if (extra) return extra.some(p => filePath.includes(p));
-  return false;
-}
-
-function isSourceFile(filePath: string): boolean {
-  return SRC_EXTENSIONS.has(extname(filePath));
-}
-
-function collectFiles(
-  dir: string,
-  options: TestabilityOptions,
-  depth = 0,
-): string[] {
-  if (depth > (options.maxDepth ?? 20)) return [];
-  const excludes = [...DEFAULT_EXCLUDES, ...(options.exclude ?? [])];
-  const files: string[] = [];
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return files;
-  }
-  for (const entry of entries) {
-    if (excludes.some(ex => entry === ex || entry.includes(ex))) continue;
-    const full = join(dir, entry);
-    let stat;
-    try { stat = statSync(full); } catch { continue; }
-    if (stat.isDirectory()) {
-      files.push(...collectFiles(full, options, depth + 1));
-    } else if (stat.isFile() && isSourceFile(full)) {
-      if (!options.include || options.include.some(p => full.includes(p))) {
-        files.push(full);
-      }
-    }
-  }
-  return files;
-}
+import type {
+  TestabilityOptions,
+  TestabilityIssue,
+  TestabilityReport,
+} from './types';
 
 // ---------------------------------------------------------------------------
 // Per-file analysis
@@ -85,20 +35,27 @@ interface FileAnalysis {
   externalStateMutations: number;
 }
 
-function countMethodsInInterface(node: TSESTree.TSInterfaceDeclaration | TSESTree.TSTypeAliasDeclaration): number {
+function countMethodsInInterface(
+  node: TSESTree.TSInterfaceDeclaration | TSESTree.TSTypeAliasDeclaration
+): number {
   // Count method signatures
   if (node.type === 'TSInterfaceDeclaration') {
-    return node.body.body.filter(m =>
-      m.type === 'TSMethodSignature' || m.type === 'TSPropertySignature'
+    return node.body.body.filter(
+      (m) => m.type === 'TSMethodSignature' || m.type === 'TSPropertySignature'
     ).length;
   }
-  if (node.type === 'TSTypeAliasDeclaration' && node.typeAnnotation.type === 'TSTypeLiteral') {
+  if (
+    node.type === 'TSTypeAliasDeclaration' &&
+    node.typeAnnotation.type === 'TSTypeLiteral'
+  ) {
     return node.typeAnnotation.members.length;
   }
   return 0;
 }
 
-function hasDependencyInjection(node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): boolean {
+function hasDependencyInjection(
+  node: TSESTree.ClassDeclaration | TSESTree.ClassExpression
+): boolean {
   // Look for a constructor with typed parameters (the most common DI pattern)
   for (const member of node.body.body) {
     if (
@@ -109,10 +66,12 @@ function hasDependencyInjection(node: TSESTree.ClassDeclaration | TSESTree.Class
       const fn = member.value;
       if (fn.params && fn.params.length > 0) {
         // If constructor takes parameters that are typed class/interface references, that's DI
-        const typedParams = fn.params.filter(p => {
+        const typedParams = fn.params.filter((p) => {
           const param = p as any;
-          return param.typeAnnotation != null ||
-            param.parameter?.typeAnnotation != null;
+          return (
+            param.typeAnnotation != null ||
+            param.parameter?.typeAnnotation != null
+          );
         });
         if (typedParams.length > 0) return true;
       }
@@ -122,7 +81,10 @@ function hasDependencyInjection(node: TSESTree.ClassDeclaration | TSESTree.Class
 }
 
 function isPureFunction(
-  fn: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression,
+  fn:
+    | TSESTree.FunctionDeclaration
+    | TSESTree.FunctionExpression
+    | TSESTree.ArrowFunctionExpression
 ): boolean {
   let hasReturn = false;
   let hasSideEffect = false;
@@ -132,14 +94,18 @@ function isPureFunction(
     if (
       node.type === 'AssignmentExpression' &&
       node.left.type === 'MemberExpression'
-    ) hasSideEffect = true;
+    )
+      hasSideEffect = true;
     // Calls to console, process, global objects
     if (
       node.type === 'CallExpression' &&
       node.callee.type === 'MemberExpression' &&
       node.callee.object.type === 'Identifier' &&
-      ['console', 'process', 'window', 'document', 'fs'].includes(node.callee.object.name)
-    ) hasSideEffect = true;
+      ['console', 'process', 'window', 'document', 'fs'].includes(
+        node.callee.object.name
+      )
+    )
+      hasSideEffect = true;
 
     // Recurse
     for (const key of Object.keys(node)) {
@@ -147,7 +113,7 @@ function isPureFunction(
       const child = (node as any)[key];
       if (child && typeof child === 'object') {
         if (Array.isArray(child)) {
-          child.forEach(c => c?.type && walk(c));
+          child.forEach((c) => c?.type && walk(c));
         } else if (child.type) {
           walk(child);
         }
@@ -156,7 +122,7 @@ function isPureFunction(
   }
 
   if (fn.body?.type === 'BlockStatement') {
-    fn.body.body.forEach(s => walk(s));
+    fn.body.body.forEach((s) => walk(s));
   } else if (fn.body) {
     hasReturn = true; // arrow expression body
   }
@@ -165,7 +131,10 @@ function isPureFunction(
 }
 
 function hasExternalStateMutation(
-  fn: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression,
+  fn:
+    | TSESTree.FunctionDeclaration
+    | TSESTree.FunctionExpression
+    | TSESTree.ArrowFunctionExpression
 ): boolean {
   let found = false;
   function walk(node: TSESTree.Node) {
@@ -173,17 +142,18 @@ function hasExternalStateMutation(
     if (
       node.type === 'AssignmentExpression' &&
       node.left.type === 'MemberExpression'
-    ) found = true;
+    )
+      found = true;
     for (const key of Object.keys(node)) {
       if (key === 'parent') continue;
       const child = (node as any)[key];
       if (child && typeof child === 'object') {
-        if (Array.isArray(child)) child.forEach(c => c?.type && walk(c));
+        if (Array.isArray(child)) child.forEach((c) => c?.type && walk(c));
         else if (child.type) walk(child);
       }
     }
   }
-  if (fn.body?.type === 'BlockStatement') fn.body.body.forEach(s => walk(s));
+  if (fn.body?.type === 'BlockStatement') fn.body.body.forEach((s) => walk(s));
   return found;
 }
 
@@ -199,7 +169,11 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
   };
 
   let code: string;
-  try { code = readFileSync(filePath, 'utf-8'); } catch { return result; }
+  try {
+    code = readFileSync(filePath, 'utf-8');
+  } catch {
+    return result;
+  }
 
   let ast: TSESTree.Program;
   try {
@@ -208,7 +182,9 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
       range: false,
       loc: false,
     });
-  } catch { return result; }
+  } catch {
+    return result;
+  }
 
   function visit(node: TSESTree.Node) {
     if (
@@ -226,7 +202,10 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
       if (hasDependencyInjection(node)) result.injectionPatterns++;
     }
 
-    if (node.type === 'TSInterfaceDeclaration' || node.type === 'TSTypeAliasDeclaration') {
+    if (
+      node.type === 'TSInterfaceDeclaration' ||
+      node.type === 'TSTypeAliasDeclaration'
+    ) {
       result.totalInterfaces++;
       const methodCount = countMethodsInInterface(node as any);
       if (methodCount > 10) result.bloatedInterfaces++;
@@ -237,7 +216,7 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
       if (key === 'parent') continue;
       const child = (node as any)[key];
       if (child && typeof child === 'object') {
-        if (Array.isArray(child)) child.forEach(c => c?.type && visit(c));
+        if (Array.isArray(child)) child.forEach((c) => c?.type && visit(c));
         else if (child.type) visit(child);
       }
     }
@@ -260,22 +239,54 @@ function detectTestFramework(rootDir: string): boolean {
       ...(pkg.dependencies ?? {}),
       ...(pkg.devDependencies ?? {}),
     };
-    const testFrameworks = ['jest', 'vitest', 'mocha', 'jasmine', 'ava', 'tap', 'pytest', 'unittest'];
-    return testFrameworks.some(fw => allDeps[fw]);
-  } catch { return false; }
+    const testFrameworks = [
+      'jest',
+      'vitest',
+      'mocha',
+      'jasmine',
+      'ava',
+      'tap',
+      'pytest',
+      'unittest',
+    ];
+    return testFrameworks.some((fw) => allDeps[fw]);
+  } catch {
+    return false;
+  }
 }
 
 // ---------------------------------------------------------------------------
 // Main analyzer
 // ---------------------------------------------------------------------------
 
+const TEST_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /__tests__\//,
+  /\/tests?\//,
+  /\/e2e\//,
+  /\/fixtures\//,
+];
+
+function isTestFile(filePath: string, extra?: string[]): boolean {
+  if (TEST_PATTERNS.some((p) => p.test(filePath))) return true;
+  if (extra) return extra.some((p) => filePath.includes(p));
+  return false;
+}
+
 export async function analyzeTestability(
-  options: TestabilityOptions,
+  options: TestabilityOptions
 ): Promise<TestabilityReport> {
-  const allFiles = collectFiles(options.rootDir, options);
+  // Use core scanFiles which respects .gitignore recursively
+  const allFiles = await scanFiles({
+    ...options,
+    include: options.include || ['**/*.{ts,tsx,js,jsx}'],
+    includeTests: true,
+  });
 
-  const sourceFiles = allFiles.filter(f => !isTestFile(f, options.testPatterns));
-  const testFiles = allFiles.filter(f => isTestFile(f, options.testPatterns));
+  const sourceFiles = allFiles.filter(
+    (f) => !isTestFile(f, options.testPatterns)
+  );
+  const testFiles = allFiles.filter((f) => isTestFile(f, options.testPatterns));
 
   const aggregated: FileAnalysis = {
     pureFunctions: 0,
@@ -287,7 +298,15 @@ export async function analyzeTestability(
     externalStateMutations: 0,
   };
 
+  let processed = 0;
   for (const f of sourceFiles) {
+    processed++;
+    options.onProgress?.(
+      processed,
+      sourceFiles.length,
+      `testability: analyzing files`
+    );
+
     const a = analyzeFileTestability(f);
     for (const key of Object.keys(aggregated) as Array<keyof FileAnalysis>) {
       aggregated[key] += a[key];
@@ -312,21 +331,25 @@ export async function analyzeTestability(
   // Build issues
   const issues: TestabilityIssue[] = [];
   const minCoverage = options.minCoverageRatio ?? 0.3;
-  const actualRatio = sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
+  const actualRatio =
+    sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
 
   if (!hasTestFramework) {
     issues.push({
       type: 'low-testability',
       dimension: 'framework',
       severity: 'critical',
-      message: 'No testing framework detected in package.json — AI changes cannot be verified at all.',
+      message:
+        'No testing framework detected in package.json — AI changes cannot be verified at all.',
       location: { file: options.rootDir, line: 0 },
-      suggestion: 'Add Jest, Vitest, or another testing framework as a devDependency.',
+      suggestion:
+        'Add Jest, Vitest, or another testing framework as a devDependency.',
     });
   }
 
   if (actualRatio < minCoverage) {
-    const needed = Math.ceil(sourceFiles.length * minCoverage) - testFiles.length;
+    const needed =
+      Math.ceil(sourceFiles.length * minCoverage) - testFiles.length;
     issues.push({
       type: 'low-testability',
       dimension: 'test-coverage',
@@ -344,7 +367,8 @@ export async function analyzeTestability(
       severity: 'major',
       message: `Only ${indexResult.dimensions.purityScore}% of functions are pure — side-effectful functions require complex test setup.`,
       location: { file: options.rootDir, line: 0 },
-      suggestion: 'Extract pure transformation logic from I/O and mutation code.',
+      suggestion:
+        'Extract pure transformation logic from I/O and mutation code.',
     });
   }
 

package/src/cli.ts

@@ -7,15 +7,23 @@ import type { TestabilityOptions } from './types';
 import chalk from 'chalk';
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { dirname } from 'path';
-import { loadConfig, mergeConfigWithDefaults, resolveOutputPath } from '@aiready/core';
+import {
+  loadConfig,
+  mergeConfigWithDefaults,
+  resolveOutputPath,
+} from '@aiready/core';
 
 const program = new Command();
 
 program
   .name('aiready-testability')
-  .description('Measure how safely AI-generated changes can be verified in your codebase')
+  .description(
+    'Measure how safely AI-generated changes can be verified in your codebase'
+  )
   .version('0.1.0')
-  .addHelpText('after', `
+  .addHelpText(
+    'after',
+    `
 DIMENSIONS MEASURED:
   Test Coverage       Ratio of test files to source files
   Function Purity     Pure functions are trivially AI-testable
@@ -33,10 +41,18 @@ EXAMPLES:
   aiready-testability .                        # Full analysis
   aiready-testability src/ --output json       # JSON report
   aiready-testability . --min-coverage 0.5     # Stricter 50% threshold
-`)
+`
+  )
   .argument('<directory>', 'Directory to analyze')
-  .option('--min-coverage <ratio>', 'Minimum acceptable test/source ratio (default: 0.3)', '0.3')
-  .option('--test-patterns <patterns>', 'Additional test file patterns (comma-separated)')
+  .option(
+    '--min-coverage <ratio>',
+    'Minimum acceptable test/source ratio (default: 0.3)',
+    '0.3'
+  )
+  .option(
+    '--test-patterns <patterns>',
+    'Additional test file patterns (comma-separated)'
+  )
   .option('--include <patterns>', 'File patterns to include (comma-separated)')
   .option('--exclude <patterns>', 'File patterns to exclude (comma-separated)')
   .option('-o, --output <format>', 'Output format: console|json', 'console')
@@ -52,7 +68,9 @@ EXAMPLES:
 
     const finalOptions: TestabilityOptions = {
       rootDir: directory,
-      minCoverageRatio: parseFloat(options.minCoverage ?? '0.3') || mergedConfig.minCoverageRatio,
+      minCoverageRatio:
+        parseFloat(options.minCoverage ?? '0.3') ||
+        mergedConfig.minCoverageRatio,
       testPatterns: options.testPatterns?.split(','),
       include: options.include?.split(','),
       exclude: options.exclude?.split(','),
@@ -67,7 +85,7 @@ EXAMPLES:
       const outputPath = resolveOutputPath(
         options.outputFile,
         `testability-report-${new Date().toISOString().split('T')[0]}.json`,
-        directory,
+        directory
       );
       const dir = dirname(outputPath);
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
@@ -82,21 +100,31 @@ program.parse();
 
 function safetyColor(rating: string) {
   switch (rating) {
-    case 'safe': return chalk.green;
-    case 'moderate-risk': return chalk.yellow;
-    case 'high-risk': return chalk.red;
-    case 'blind-risk': return chalk.bgRed.white;
-    default: return chalk.white;
+    case 'safe':
+      return chalk.green;
+    case 'moderate-risk':
+      return chalk.yellow;
+    case 'high-risk':
+      return chalk.red;
+    case 'blind-risk':
+      return chalk.bgRed.white;
+    default:
+      return chalk.white;
   }
 }
 
 function safetyIcon(rating: string) {
   switch (rating) {
-    case 'safe': return '✅';
-    case 'moderate-risk': return '⚠️ ';
-    case 'high-risk': return '🔴';
-    case 'blind-risk': return '💀';
-    default: return '❓';
+    case 'safe':
+      return '✅';
+    case 'moderate-risk':
+      return '⚠️ ';
+    case 'high-risk':
+      return '🔴';
+    case 'blind-risk':
+      return '💀';
+    default:
+      return '❓';
   }
 }
 
@@ -112,19 +140,33 @@ function displayConsoleReport(report: any, scoring: any, elapsed: string) {
   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(
+      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(
+      chalk.red.bold(
+        `  🔴 HIGH RISK — Insufficient test coverage. AI changes may introduce silent bugs.`
+      )
+    );
     console.log();
   }
 
-  console.log(`AI Change Safety: ${safetyColor(safetyRating)(`${safetyIcon(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(
+    `AI Change Safety: ${safetyColor(safetyRating)(`${safetyIcon(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'));
@@ -136,16 +178,25 @@ function displayConsoleReport(report: any, scoring: any, elapsed: string) {
     ['Observability', summary.dimensions.observabilityScore],
   ];
   for (const [name, val] of dims) {
-    const color = val >= 70 ? chalk.green : val >= 50 ? chalk.yellow : chalk.red;
+    const color =
+      val >= 70 ? chalk.green : val >= 50 ? chalk.yellow : chalk.red;
     console.log(`  ${name.padEnd(22)} ${color(scoreBar(val))} ${val}/100`);
   }
 
   if (issues.length > 0) {
     console.log(chalk.bold('\n⚠️  Issues\n'));
     for (const issue of issues) {
-      const sev = issue.severity === 'critical' ? chalk.red : issue.severity === 'major' ? chalk.yellow : chalk.blue;
+      const sev =
+        issue.severity === 'critical'
+          ? chalk.red
+          : issue.severity === 'major'
+            ? chalk.yellow
+            : chalk.blue;
       console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
-      if (issue.suggestion) console.log(`       ${chalk.dim('→')} ${chalk.italic(issue.suggestion)}`);
+      if (issue.suggestion)
+        console.log(
+          `       ${chalk.dim('→')} ${chalk.italic(issue.suggestion)}`
+        );
       console.log();
     }
   }

package/src/scoring.ts

@@ -1,11 +1,12 @@
-import { calculateTestabilityIndex } from '@aiready/core';
 import type { ToolScoringOutput } from '@aiready/core';
 import type { TestabilityReport } from './types';
 
 /**
  * Convert testability report into a ToolScoringOutput for the unified score.
  */
-export function calculateTestabilityScore(report: TestabilityReport): ToolScoringOutput {
+export function calculateTestabilityScore(
+  report: TestabilityReport
+): ToolScoringOutput {
   const { summary, rawData, recommendations } = report;
 
   const factors: ToolScoringOutput['factors'] = [
@@ -36,13 +37,17 @@ export function calculateTestabilityScore(report: TestabilityReport): ToolScorin
     },
   ];
 
-  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',
-  }));
+  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 {
     toolName: 'testability',

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ScanOptions, Issue } from '@aiready/core';
+import type { Issue } from '@aiready/core';
 
 export interface TestabilityOptions {
   /** Root directory to scan */
@@ -13,12 +13,20 @@ export interface TestabilityOptions {
   include?: string[];
   /** File glob patterns to exclude */
   exclude?: string[];
+  /** Progress callback */
+  onProgress?: (processed: number, total: number, message: string) => void;
 }
 
 export interface TestabilityIssue extends Issue {
   type: 'low-testability';
   /** Category of testability barrier */
-  dimension: 'test-coverage' | 'purity' | 'dependency-injection' | 'interface-focus' | 'observability' | 'framework';
+  dimension:
+    | 'test-coverage'
+    | 'purity'
+    | 'dependency-injection'
+    | 'interface-focus'
+    | 'observability'
+    | 'framework';
 }
 
 export interface TestabilityReport {