@aiready/testability 0.6.7 → 0.6.8

package/.turbo/turbo-build.log

@@ -1,23 +1,24 @@
-
-> @aiready/testability@0.6.7 build /Users/pengcao/projects/aiready/packages/testability
-> tsup src/index.ts src/cli.ts --format cjs,esm --dts
-
-CLI Building entry: src/cli.ts, src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Target: es2020
-CJS Build start
-ESM Build start
-ESM dist/chunk-HIE74PK3.mjs 8.31 KB
-ESM dist/cli.mjs            5.75 KB
-ESM dist/index.mjs          1.17 KB
-ESM ⚡️ Build success in 128ms
-CJS dist/index.js 10.61 KB
-CJS dist/cli.js   15.61 KB
-CJS ⚡️ Build success in 128ms
-DTS Build start
-DTS ⚡️ Build success in 5667ms
-DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  2.62 KB
-DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 2.62 KB
+
+
+> @aiready/testability@0.6.8 build /Users/pengcao/projects/aiready/packages/testability
+> tsup src/index.ts src/cli.ts --format cjs,esm --dts
+
+CLI Building entry: src/cli.ts, src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2020
+CJS Build start
+ESM Build start
+CJS dist/index.js 10.78 KB
+CJS dist/cli.js   15.78 KB
+CJS ⚡️ Build success in 62ms
+ESM dist/index.mjs          1.17 KB
+ESM dist/cli.mjs            5.75 KB
+ESM dist/chunk-JL4S6RHJ.mjs 8.47 KB
+ESM ⚡️ Build success in 63ms
+DTS Build start
+DTS ⚡️ Build success in 4353ms
+DTS dist/cli.d.ts    20.00 B
+DTS dist/index.d.ts  2.62 KB
+DTS dist/cli.d.mts   20.00 B
+DTS dist/index.d.mts 2.62 KB

package/.turbo/turbo-test.log

@@ -1,18 +1,20 @@
-
-> @aiready/testability@0.6.6 test /Users/pengcao/projects/aiready/packages/testability
-> vitest run
-
-
- RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/testability
-
- ✓ src/__tests__/types.test.ts (4 tests) 2ms
- ✓ src/__tests__/scoring.test.ts (3 tests) 2ms
- ✓ src/__tests__/provider.test.ts (2 tests) 4ms
- ✓ src/__tests__/analyzer.test.ts (5 tests) 2336ms
-     ✓ detects test frameworks in multiple languages  2304ms
-
- Test Files  4 passed (4)
-      Tests  14 passed (14)
-   Start at  15:20:15
-   Duration  5.21s (transform 2.14s, setup 0ms, import 6.67s, tests 2.34s, environment 0ms)
-
+
+
+> @aiready/testability@0.6.7 test /Users/pengcao/projects/aiready/packages/testability
+> vitest run
+
+[?25l
+ RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/testability
+
+ ✓ src/__tests__/types.test.ts (4 tests) 2ms
+ ✓ src/__tests__/scoring.test.ts (3 tests) 4ms
+ ✓ src/__tests__/provider.test.ts (2 tests) 3ms
+ ✓ src/__tests__/analyzer.test.ts (5 tests) 943ms
+     ✓ detects test frameworks in multiple languages  916ms
+
+ Test Files  4 passed (4)
+      Tests  14 passed (14)
+   Start at  23:50:20
+   Duration  1.67s (transform 715ms, setup 0ms, import 1.94s, tests 951ms, environment 0ms)
+
+[?25h

package/dist/chunk-JL4S6RHJ.mjs

@@ -0,0 +1,269 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+  emitProgress,
+  getParser
+} from "@aiready/core";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+async function analyzeFileTestability(filePath) {
+  const result = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  const parser = getParser(filePath);
+  if (!parser) return result;
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  try {
+    await parser.initialize();
+    const parseResult = parser.parse(code, filePath);
+    for (const exp of parseResult.exports) {
+      if (exp.type === "function") {
+        result.totalFunctions++;
+        if (exp.isPure) result.pureFunctions++;
+        if (exp.hasSideEffects) result.externalStateMutations++;
+      }
+      if (exp.type === "class") {
+        result.totalClasses++;
+        if (exp.parameters && exp.parameters.length > 0) {
+          result.injectionPatterns++;
+        }
+        const total = (exp.methodCount || 0) + (exp.propertyCount || 0);
+        if (total > 10) {
+          result.bloatedInterfaces++;
+        }
+      }
+      if (exp.type === "interface") {
+        result.totalInterfaces++;
+        const total = (exp.methodCount || 0) + (exp.propertyCount || 0);
+        if (total > 10) {
+          result.bloatedInterfaces++;
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Testability: Failed to parse ${filePath}: ${error}`);
+  }
+  return result;
+}
+function detectTestFramework(rootDir) {
+  const manifests = [
+    {
+      file: "package.json",
+      deps: ["jest", "vitest", "mocha", "mocha", "jasmine", "ava", "tap"]
+    },
+    { file: "requirements.txt", deps: ["pytest", "unittest", "nose"] },
+    { file: "pyproject.toml", deps: ["pytest"] },
+    { file: "pom.xml", deps: ["junit", "testng"] },
+    { file: "build.gradle", deps: ["junit", "testng"] },
+    { file: "go.mod", deps: ["testing"] }
+    // go testing is built-in
+  ];
+  for (const m of manifests) {
+    const p = join(rootDir, m.file);
+    if (existsSync(p)) {
+      if (m.file === "go.mod") return true;
+      try {
+        const content = readFileSync(p, "utf-8");
+        if (m.deps.some((d) => content.includes(d))) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+var TEST_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /_test\.go$/,
+  /test_.*\.py$/,
+  /.*_test\.py$/,
+  /.*Test\.java$/,
+  /.*Tests\.cs$/,
+  /__tests__\//,
+  /\/tests?\//,
+  /\/e2e\//,
+  /\/fixtures\//
+];
+function isTestFile(filePath, extra) {
+  if (TEST_PATTERNS.some((p) => p.test(filePath))) return true;
+  if (extra) return extra.some((p) => filePath.includes(p));
+  return false;
+}
+async function analyzeTestability(options) {
+  const allFiles = await scanFiles({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx,py,java,cs,go}"],
+    includeTests: true
+  });
+  const sourceFiles = allFiles.filter(
+    (f) => !isTestFile(f, options.testPatterns)
+  );
+  const testFiles = allFiles.filter((f) => isTestFile(f, options.testPatterns));
+  const aggregated = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  const fileDetails = [];
+  let processed = 0;
+  for (const f of sourceFiles) {
+    processed++;
+    emitProgress(
+      processed,
+      sourceFiles.length,
+      "testability",
+      "analyzing files",
+      options.onProgress
+    );
+    const a = await analyzeFileTestability(f);
+    for (const key of Object.keys(aggregated)) {
+      aggregated[key] += a[key];
+    }
+    fileDetails.push({
+      filePath: f,
+      pureFunctions: a.pureFunctions,
+      totalFunctions: a.totalFunctions
+    });
+  }
+  const hasTestFramework = detectTestFramework(options.rootDir);
+  const indexResult = calculateTestabilityIndex({
+    testFiles: testFiles.length,
+    sourceFiles: sourceFiles.length,
+    pureFunctions: aggregated.pureFunctions,
+    totalFunctions: Math.max(1, aggregated.totalFunctions),
+    injectionPatterns: aggregated.injectionPatterns,
+    totalClasses: Math.max(1, aggregated.totalClasses),
+    bloatedInterfaces: aggregated.bloatedInterfaces,
+    totalInterfaces: Math.max(1, aggregated.totalInterfaces),
+    externalStateMutations: aggregated.externalStateMutations,
+    hasTestFramework,
+    fileDetails
+  });
+  const issues = [];
+  const minCoverage = options.minCoverageRatio ?? 0.3;
+  const actualRatio = sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
+  if (!hasTestFramework) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "framework",
+      severity: Severity.Critical,
+      message: "No major testing framework detected \u2014 AI changes cannot be safely verified.",
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Add a testing framework (e.g., Jest, Pytest, JUnit) to enable automated verification."
+    });
+  }
+  if (actualRatio < minCoverage) {
+    const needed = Math.ceil(sourceFiles.length * minCoverage) - testFiles.length;
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "test-coverage",
+      severity: actualRatio === 0 ? Severity.Critical : Severity.Major,
+      message: `Test ratio is ${Math.round(actualRatio * 100)}% (${testFiles.length} test files for ${sourceFiles.length} source files). Need at least ${Math.round(minCoverage * 100)}%.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: `Add ~${needed} test file(s) to reach the ${Math.round(minCoverage * 100)}% minimum for safe AI assistance.`
+    });
+  }
+  if (indexResult.dimensions.purityScore < 50) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "purity",
+      severity: Severity.Major,
+      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure \u2014 side-effectful code is harder for AI to verify safely.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Refactor complex side-effectful logic into pure functions where possible."
+    });
+  }
+  return {
+    summary: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      coverageRatio: Math.round(actualRatio * 100) / 100,
+      score: indexResult.score,
+      rating: indexResult.rating,
+      aiChangeSafetyRating: indexResult.aiChangeSafetyRating,
+      dimensions: indexResult.dimensions
+    },
+    issues,
+    rawData: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      ...aggregated,
+      hasTestFramework
+    },
+    recommendations: indexResult.recommendations
+  };
+}
+
+// src/scoring.ts
+import { ToolName } from "@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 {
+    toolName: ToolName.TestabilityIndex,
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating,
+      aiChangeSafetyRating: summary.aiChangeSafetyRating,
+      coverageRatio: summary.coverageRatio
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+export {
+  analyzeTestability,
+  calculateTestabilityScore
+};

package/dist/cli.js

@@ -142,6 +142,7 @@ async function analyzeTestability(options) {
     totalInterfaces: 0,
     externalStateMutations: 0
   };
+  const fileDetails = [];
   let processed = 0;
   for (const f of sourceFiles) {
     processed++;
@@ -156,6 +157,11 @@ async function analyzeTestability(options) {
     for (const key of Object.keys(aggregated)) {
       aggregated[key] += a[key];
     }
+    fileDetails.push({
+      filePath: f,
+      pureFunctions: a.pureFunctions,
+      totalFunctions: a.totalFunctions
+    });
   }
   const hasTestFramework = detectTestFramework(options.rootDir);
   const indexResult = (0, import_core.calculateTestabilityIndex)({
@@ -168,7 +174,8 @@ async function analyzeTestability(options) {
     bloatedInterfaces: aggregated.bloatedInterfaces,
     totalInterfaces: Math.max(1, aggregated.totalInterfaces),
     externalStateMutations: aggregated.externalStateMutations,
-    hasTestFramework
+    hasTestFramework,
+    fileDetails
   });
   const issues = [];
   const minCoverage = options.minCoverageRatio ?? 0.3;

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeTestability,
   calculateTestabilityScore
-} from "./chunk-HIE74PK3.mjs";
+} from "./chunk-JL4S6RHJ.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -146,6 +146,7 @@ async function analyzeTestability(options) {
     totalInterfaces: 0,
     externalStateMutations: 0
   };
+  const fileDetails = [];
   let processed = 0;
   for (const f of sourceFiles) {
     processed++;
@@ -160,6 +161,11 @@ async function analyzeTestability(options) {
     for (const key of Object.keys(aggregated)) {
       aggregated[key] += a[key];
     }
+    fileDetails.push({
+      filePath: f,
+      pureFunctions: a.pureFunctions,
+      totalFunctions: a.totalFunctions
+    });
   }
   const hasTestFramework = detectTestFramework(options.rootDir);
   const indexResult = (0, import_core.calculateTestabilityIndex)({
@@ -172,7 +178,8 @@ async function analyzeTestability(options) {
     bloatedInterfaces: aggregated.bloatedInterfaces,
     totalInterfaces: Math.max(1, aggregated.totalInterfaces),
     externalStateMutations: aggregated.externalStateMutations,
-    hasTestFramework
+    hasTestFramework,
+    fileDetails
   });
   const issues = [];
   const minCoverage = options.minCoverageRatio ?? 0.3;

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/testability",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "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.8"
+    "@aiready/core": "0.23.9"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/analyzer.ts

@@ -170,6 +170,13 @@ export async function analyzeTestability(
     externalStateMutations: 0,
   };
 
+  // Collect file-level details for smarter scoring
+  const fileDetails: Array<{
+    filePath: string;
+    pureFunctions: number;
+    totalFunctions: number;
+  }> = [];
+
   let processed = 0;
   for (const f of sourceFiles) {
     processed++;
@@ -185,6 +192,13 @@ export async function analyzeTestability(
     for (const key of Object.keys(aggregated) as Array<keyof FileAnalysis>) {
       aggregated[key] += a[key];
     }
+
+    // Collect file-level data
+    fileDetails.push({
+      filePath: f,
+      pureFunctions: a.pureFunctions,
+      totalFunctions: a.totalFunctions,
+    });
   }
 
   const hasTestFramework = detectTestFramework(options.rootDir);
@@ -200,6 +214,7 @@ export async function analyzeTestability(
     totalInterfaces: Math.max(1, aggregated.totalInterfaces),
     externalStateMutations: aggregated.externalStateMutations,
     hasTestFramework,
+    fileDetails,
   });
 
   // Build issues