@aiready/testability 0.6.22 → 0.6.23

package/dist/chunk-KYBNMI4K.mjs

@@ -0,0 +1,237 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+  runBatchAnalysis,
+  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 = await 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 = [];
+  await runBatchAnalysis(
+    sourceFiles,
+    "analyzing files",
+    "testability",
+    options.onProgress,
+    async (f) => ({ filePath: f, analysis: await analyzeFileTestability(f) }),
+    (result) => {
+      const a = result.analysis;
+      for (const key of Object.keys(aggregated)) {
+        aggregated[key] += a[key];
+      }
+      fileDetails.push({
+        filePath: result.filePath,
+        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, buildStandardToolScore } from "@aiready/core";
+function calculateTestabilityScore(report) {
+  const { summary, rawData, recommendations } = report;
+  return buildStandardToolScore({
+    toolName: ToolName.TestabilityIndex,
+    score: summary.score,
+    rawData,
+    dimensions: summary.dimensions,
+    dimensionNames: {
+      testCoverageRatio: "Test Coverage",
+      purityScore: "Function Purity",
+      dependencyInjectionScore: "Dependency Injection",
+      interfaceFocusScore: "Interface Focus",
+      observabilityScore: "Observability"
+    },
+    recommendations,
+    recommendationImpact: summary.aiChangeSafetyRating === "blind-risk" ? 15 : 8,
+    rating: summary.aiChangeSafetyRating || summary.rating
+  });
+}
+
+export {
+  analyzeTestability,
+  calculateTestabilityScore
+};

package/dist/cli.js

@@ -29,7 +29,6 @@ var import_commander = require("commander");
 // src/analyzer.ts
 var import_core = require("@aiready/core");
 var import_fs = require("fs");
-var import_path = require("path");
 async function analyzeFileTestability(filePath) {
   const result = {
     pureFunctions: 0,
@@ -80,49 +79,6 @@ async function analyzeFileTestability(filePath) {
   }
   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 = (0, import_path.join)(rootDir, m.file);
-    if ((0, import_fs.existsSync)(p)) {
-      if (m.file === "go.mod") return true;
-      try {
-        const content = (0, import_fs.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 (0, import_core.scanFiles)({
     ...options,
@@ -130,9 +86,9 @@ async function analyzeTestability(options) {
     includeTests: true
   });
   const sourceFiles = allFiles.filter(
-    (f) => !isTestFile(f, options.testPatterns)
+    (f) => !(0, import_core.isTestFile)(f, options.testPatterns)
   );
-  const testFiles = allFiles.filter((f) => isTestFile(f, options.testPatterns));
+  const testFiles = allFiles.filter((f) => (0, import_core.isTestFile)(f, options.testPatterns));
   const aggregated = {
     pureFunctions: 0,
     totalFunctions: 0,
@@ -143,27 +99,28 @@ async function analyzeTestability(options) {
     externalStateMutations: 0
   };
   const fileDetails = [];
-  let processed = 0;
-  for (const f of sourceFiles) {
-    processed++;
-    (0, import_core.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({
+  await (0, import_core.runBatchAnalysis)(
+    sourceFiles,
+    "analyzing files",
+    "testability",
+    options.onProgress,
+    async (f) => ({
       filePath: f,
-      pureFunctions: a.pureFunctions,
-      totalFunctions: a.totalFunctions
-    });
-  }
-  const hasTestFramework = detectTestFramework(options.rootDir);
+      analysis: await analyzeFileTestability(f)
+    }),
+    (result) => {
+      const a = result.analysis;
+      for (const key of Object.keys(aggregated)) {
+        aggregated[key] += a[key];
+      }
+      fileDetails.push({
+        filePath: result.filePath,
+        pureFunctions: a.pureFunctions,
+        totalFunctions: a.totalFunctions
+      });
+    }
+  );
+  const hasTestFramework = (0, import_core.detectTestFramework)(options.rootDir);
   const indexResult = (0, import_core.calculateTestabilityIndex)({
     testFiles: testFiles.length,
     sourceFiles: sourceFiles.length,
@@ -257,7 +214,7 @@ function calculateTestabilityScore(report) {
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
 var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_path = require("path");
 var import_core3 = require("@aiready/core");
 var program = new import_commander.Command();
 var startTime = Date.now();
@@ -311,35 +268,35 @@ EXAMPLES:
       `testability-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
       directory
     );
-    const dir = (0, import_path2.dirname)(outputPath);
+    const dir = (0, import_path.dirname)(outputPath);
     if (!(0, import_fs2.existsSync)(dir)) (0, import_fs2.mkdirSync)(dir, { recursive: true });
     (0, import_fs2.writeFileSync)(outputPath, JSON.stringify(payload, null, 2));
     console.log(import_chalk.default.green(`\u2713 Report saved to ${outputPath}`));
   } else {
     (0, import_core3.displayStandardConsoleReport)({
       title: "\u{1F9EA} Testability Analysis",
-      score: scoring.summary.score,
-      rating: scoring.summary.rating,
+      score: scoring.score,
+      rating: scoring.rating || report.summary.rating,
       dimensions: [
         {
           name: "Test Coverage",
-          value: scoring.summary.dimensions.testCoverageRatio
+          value: report.summary.dimensions.testCoverageRatio
         },
         {
           name: "Function Purity",
-          value: scoring.summary.dimensions.purityScore
+          value: report.summary.dimensions.purityScore
         },
         {
           name: "Dependency Injection",
-          value: scoring.summary.dimensions.dependencyInjectionScore
+          value: report.summary.dimensions.dependencyInjectionScore
         },
         {
           name: "Interface Focus",
-          value: scoring.summary.dimensions.interfaceFocusScore
+          value: report.summary.dimensions.interfaceFocusScore
         },
         {
           name: "Observability",
-          value: scoring.summary.dimensions.observabilityScore
+          value: report.summary.dimensions.observabilityScore
         }
       ],
       stats: [
@@ -347,7 +304,7 @@ EXAMPLES:
         { label: "Test Files", value: report.rawData.testFiles },
         {
           label: "Coverage Ratio",
-          value: Math.round(scoring.summary.coverageRatio * 100) + "%"
+          value: Math.round(report.summary.coverageRatio * 100) + "%"
         }
       ],
       issues: report.issues,

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeTestability,
   calculateTestabilityScore
-} from "./chunk-QMDUZA7H.mjs";
+} from "./chunk-CISO2RDG.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -73,28 +73,28 @@ EXAMPLES:
   } else {
     displayStandardConsoleReport({
       title: "\u{1F9EA} Testability Analysis",
-      score: scoring.summary.score,
-      rating: scoring.summary.rating,
+      score: scoring.score,
+      rating: scoring.rating || report.summary.rating,
       dimensions: [
         {
           name: "Test Coverage",
-          value: scoring.summary.dimensions.testCoverageRatio
+          value: report.summary.dimensions.testCoverageRatio
         },
         {
           name: "Function Purity",
-          value: scoring.summary.dimensions.purityScore
+          value: report.summary.dimensions.purityScore
         },
         {
           name: "Dependency Injection",
-          value: scoring.summary.dimensions.dependencyInjectionScore
+          value: report.summary.dimensions.dependencyInjectionScore
         },
         {
           name: "Interface Focus",
-          value: scoring.summary.dimensions.interfaceFocusScore
+          value: report.summary.dimensions.interfaceFocusScore
         },
         {
           name: "Observability",
-          value: scoring.summary.dimensions.observabilityScore
+          value: report.summary.dimensions.observabilityScore
         }
       ],
       stats: [
@@ -102,7 +102,7 @@ EXAMPLES:
         { label: "Test Files", value: report.rawData.testFiles },
         {
           label: "Coverage Ratio",
-          value: Math.round(scoring.summary.coverageRatio * 100) + "%"
+          value: Math.round(report.summary.coverageRatio * 100) + "%"
         }
       ],
       issues: report.issues,

package/dist/index.js

@@ -33,7 +33,6 @@ var import_core3 = require("@aiready/core");
 // src/analyzer.ts
 var import_core = require("@aiready/core");
 var import_fs = require("fs");
-var import_path = require("path");
 async function analyzeFileTestability(filePath) {
   const result = {
     pureFunctions: 0,
@@ -84,49 +83,6 @@ async function analyzeFileTestability(filePath) {
   }
   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 = (0, import_path.join)(rootDir, m.file);
-    if ((0, import_fs.existsSync)(p)) {
-      if (m.file === "go.mod") return true;
-      try {
-        const content = (0, import_fs.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 (0, import_core.scanFiles)({
     ...options,
@@ -134,9 +90,9 @@ async function analyzeTestability(options) {
     includeTests: true
   });
   const sourceFiles = allFiles.filter(
-    (f) => !isTestFile(f, options.testPatterns)
+    (f) => !(0, import_core.isTestFile)(f, options.testPatterns)
   );
-  const testFiles = allFiles.filter((f) => isTestFile(f, options.testPatterns));
+  const testFiles = allFiles.filter((f) => (0, import_core.isTestFile)(f, options.testPatterns));
   const aggregated = {
     pureFunctions: 0,
     totalFunctions: 0,
@@ -147,27 +103,28 @@ async function analyzeTestability(options) {
     externalStateMutations: 0
   };
   const fileDetails = [];
-  let processed = 0;
-  for (const f of sourceFiles) {
-    processed++;
-    (0, import_core.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({
+  await (0, import_core.runBatchAnalysis)(
+    sourceFiles,
+    "analyzing files",
+    "testability",
+    options.onProgress,
+    async (f) => ({
       filePath: f,
-      pureFunctions: a.pureFunctions,
-      totalFunctions: a.totalFunctions
-    });
-  }
-  const hasTestFramework = detectTestFramework(options.rootDir);
+      analysis: await analyzeFileTestability(f)
+    }),
+    (result) => {
+      const a = result.analysis;
+      for (const key of Object.keys(aggregated)) {
+        aggregated[key] += a[key];
+      }
+      fileDetails.push({
+        filePath: result.filePath,
+        pureFunctions: a.pureFunctions,
+        totalFunctions: a.totalFunctions
+      });
+    }
+  );
+  const hasTestFramework = (0, import_core.detectTestFramework)(options.rootDir);
   const indexResult = (0, import_core.calculateTestabilityIndex)({
     testFiles: testFiles.length,
     sourceFiles: sourceFiles.length,

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/testability",
-  "version": "0.6.22",
+  "version": "0.6.23",
   "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.23"
+    "@aiready/core": "0.23.24"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/scoring.test.ts

@@ -78,4 +78,35 @@ describe('Testability Scoring', () => {
     expect(scoring.recommendations[0].estimatedImpact).toBe(15);
     expect(scoring.recommendations[0].priority).toBe('high');
   });
+
+  it('should return ToolScoringOutput with score at top level (not summary.score)', () => {
+    const scoring = calculateTestabilityScore(mockReport);
+
+    // The bug was that CLI tried to access scoring.summary.score
+    // but ToolScoringOutput has score at the top level
+    expect(scoring.score).toBeDefined();
+    expect(typeof scoring.score).toBe('number');
+    expect(scoring.score).toBe(75);
+
+    // Verify there is no .summary property (which would cause the CLI crash)
+    expect((scoring as any).summary).toBeUndefined();
+  });
+
+  it('should return rating at top level (not summary.rating)', () => {
+    const scoring = calculateTestabilityScore(mockReport);
+
+    // The CLI accesses scoring.rating || report.summary.rating
+    // ToolScoringOutput may not have rating, but it should not have summary
+    expect((scoring as any).summary).toBeUndefined();
+  });
+
+  it('should have rawMetrics with testability data', () => {
+    const scoring = calculateTestabilityScore(mockReport);
+
+    expect(scoring.rawMetrics).toBeDefined();
+    expect(scoring.rawMetrics).toHaveProperty('sourceFiles');
+    expect(scoring.rawMetrics).toHaveProperty('testFiles');
+    expect(scoring.rawMetrics).toHaveProperty('pureFunctions');
+    expect(scoring.rawMetrics).toHaveProperty('totalFunctions');
+  });
 });