@aiready/testability 0.6.21 → 0.6.23

package/coverage/scoring.ts.html

@@ -25,28 +25,28 @@
             <div class='fl pad1y space-right2'>
                 <span class="strong">100% </span>
                 <span class="quiet">Statements</span>
-                <span class='fraction'>5/5</span>
+                <span class='fraction'>2/2</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
                 <span class="strong">100% </span>
                 <span class="quiet">Branches</span>
-                <span class='fraction'>6/6</span>
+                <span class='fraction'>4/4</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
                 <span class="strong">100% </span>
                 <span class="quiet">Functions</span>
-                <span class='fraction'>2/2</span>
+                <span class='fraction'>1/1</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
                 <span class="strong">100% </span>
                 <span class="quiet">Lines</span>
-                <span class='fraction'>5/5</span>
+                <span class='fraction'>2/2</span>
             </div>
         
             
@@ -90,72 +90,16 @@
 <a name='L25'></a><a href='#L25'>25</a>
 <a name='L26'></a><a href='#L26'>26</a>
 <a name='L27'></a><a href='#L27'>27</a>
-<a name='L28'></a><a href='#L28'>28</a>
-<a name='L29'></a><a href='#L29'>29</a>
-<a name='L30'></a><a href='#L30'>30</a>
-<a name='L31'></a><a href='#L31'>31</a>
-<a name='L32'></a><a href='#L32'>32</a>
-<a name='L33'></a><a href='#L33'>33</a>
-<a name='L34'></a><a href='#L34'>34</a>
-<a name='L35'></a><a href='#L35'>35</a>
-<a name='L36'></a><a href='#L36'>36</a>
-<a name='L37'></a><a href='#L37'>37</a>
-<a name='L38'></a><a href='#L38'>38</a>
-<a name='L39'></a><a href='#L39'>39</a>
-<a name='L40'></a><a href='#L40'>40</a>
-<a name='L41'></a><a href='#L41'>41</a>
-<a name='L42'></a><a href='#L42'>42</a>
-<a name='L43'></a><a href='#L43'>43</a>
-<a name='L44'></a><a href='#L44'>44</a>
-<a name='L45'></a><a href='#L45'>45</a>
-<a name='L46'></a><a href='#L46'>46</a>
-<a name='L47'></a><a href='#L47'>47</a>
-<a name='L48'></a><a href='#L48'>48</a>
-<a name='L49'></a><a href='#L49'>49</a>
-<a name='L50'></a><a href='#L50'>50</a>
-<a name='L51'></a><a href='#L51'>51</a>
-<a name='L52'></a><a href='#L52'>52</a>
-<a name='L53'></a><a href='#L53'>53</a>
-<a name='L54'></a><a href='#L54'>54</a>
-<a name='L55'></a><a href='#L55'>55</a>
-<a name='L56'></a><a href='#L56'>56</a>
-<a name='L57'></a><a href='#L57'>57</a>
-<a name='L58'></a><a href='#L58'>58</a>
-<a name='L59'></a><a href='#L59'>59</a>
-<a name='L60'></a><a href='#L60'>60</a>
-<a name='L61'></a><a href='#L61'>61</a>
-<a name='L62'></a><a href='#L62'>62</a>
-<a name='L63'></a><a href='#L63'>63</a>
-<a name='L64'></a><a href='#L64'>64</a>
-<a name='L65'></a><a href='#L65'>65</a></td><td class="line-coverage quiet"><span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">4x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">4x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
+<a name='L28'></a><a href='#L28'>28</a></td><td class="line-coverage quiet"><span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">7x</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">7x</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
@@ -166,8 +110,6 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">4x</span>
-<span class="cline-any cline-yes">3x</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
@@ -175,85 +117,32 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">4x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span></td><td class="text"><pre class="prettyprint lang-js">import { type ToolScoringOutput, ToolName } from '@aiready/core';
+<span class="cline-any cline-neutral">&nbsp;</span></td><td class="text"><pre class="prettyprint lang-js">import { ToolName, buildStandardToolScore } from '@aiready/core';
 import type { TestabilityReport } from './types';
 &nbsp;
 /**
  * Convert testability report into a ToolScoringOutput for the unified score.
  */
-export function calculateTestabilityScore(
-  report: TestabilityReport
-): ToolScoringOutput {
+export function calculateTestabilityScore(report: TestabilityReport): any {
   const { summary, rawData, recommendations } = report;
 &nbsp;
-  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 &gt;10 methods`,
-    },
-    {
-      name: 'Observability',
-      impact: Math.round(summary.dimensions.observabilityScore - 50),
-      description: `${rawData.externalStateMutations} functions mutate external state`,
-    },
-  ];
-&nbsp;
-  const recs: ToolScoringOutput['recommendations'] = recommendations.map(
-    (action) =&gt; ({
-      action,
-      estimatedImpact: summary.aiChangeSafetyRating === 'blind-risk' ? 15 : 8,
-      priority:
-        summary.aiChangeSafetyRating === 'blind-risk' ||
-        summary.aiChangeSafetyRating === 'high-risk'
-          ? 'high'
-          : 'medium',
-    })
-  );
-&nbsp;
-  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,
+  });
 }
 &nbsp;</pre></td></tr></table></pre>
 
@@ -262,7 +151,7 @@ export function calculateTestabilityScore(
             <div class='footer quiet pad2 space-top1 center small'>
                 Code coverage generated by
                 <a href="https://istanbul.js.org/" target="_blank" rel="noopener noreferrer">istanbul</a>
-                at 2026-03-09T02:58:39.025Z
+                at 2026-03-24T09:07:15.069Z
             </div>
         <script src="prettify.js"></script>
         <script>

package/dist/chunk-CE46EON2.mjs

@@ -0,0 +1,240 @@
+// 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/chunk-CISO2RDG.mjs

@@ -0,0 +1,198 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+  runBatchAnalysis,
+  getParser,
+  isTestFile,
+  detectTestFramework
+} from "@aiready/core";
+import { readFileSync } from "fs";
+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;
+}
+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
+};