@aiready/testability 0.7.6 → 0.7.8

package/.turbo/turbo-build.log

@@ -1,23 +1,24 @@
-
-> @aiready/testability@0.7.6 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 8.62 KB
-CJS dist/cli.js   11.88 KB
-CJS ⚡️ Build success in 126ms
-ESM dist/cli.mjs            4.33 KB
-ESM dist/index.mjs          1.17 KB
-ESM dist/chunk-NC2LRFVJ.mjs 6.35 KB
-ESM ⚡️ Build success in 127ms
-DTS Build start
-DTS ⚡️ Build success in 10364ms
-DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  2.42 KB
-DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 2.42 KB
+
+
+> @aiready/testability@0.7.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
+ESM dist/chunk-YSXDYH7O.mjs 8.48 KB
+ESM dist/index.mjs          1.17 KB
+ESM dist/cli.mjs            4.33 KB
+ESM ⚡️ Build success in 23ms
+CJS dist/cli.js   14.11 KB
+CJS dist/index.js 10.85 KB
+CJS ⚡️ Build success in 23ms
+DTS Build start
+DTS ⚡️ Build success in 2347ms
+DTS dist/cli.d.ts    20.00 B
+DTS dist/index.d.ts  2.42 KB
+DTS dist/cli.d.mts   20.00 B
+DTS dist/index.d.mts 2.42 KB

package/.turbo/turbo-format-check.log

@@ -0,0 +1,7 @@
+
+
+> @aiready/testability@0.7.8 format-check /Users/pengcao/projects/aiready/packages/testability
+> prettier --check . --ignore-path ../../.prettierignore
+
+Checking formatting...
+package.jsonREADME.mdsrc/__tests__/analyzer.test.tssrc/__tests__/provider.test.tssrc/__tests__/scoring.test.tssrc/__tests__/types.test.tssrc/analyzer.tssrc/cli.tssrc/index.tssrc/provider.tssrc/scoring.tssrc/types.tstsconfig.jsonAll matched files use Prettier code style!

package/.turbo/turbo-lint.log

@@ -1,4 +1,5 @@
-
-> @aiready/testability@0.6.20 lint /Users/pengcao/projects/aiready/packages/testability
-> eslint src
-
+
+
+> @aiready/testability@0.7.8 lint /Users/pengcao/projects/aiready/packages/testability
+> eslint src
+

package/.turbo/turbo-test.log

@@ -1,18 +1,20 @@
-
-> @aiready/testability@0.7.5 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) 6ms
- ✓ src/__tests__/scoring.test.ts (6 tests) 2ms
- ✓ src/__tests__/provider.test.ts (2 tests) 22ms
- ✓ src/__tests__/analyzer.test.ts (5 tests) 3869ms
-     ✓ detects test frameworks in multiple languages  3833ms
-
- Test Files  4 passed (4)
-      Tests  17 passed (17)
-   Start at  20:27:24
-   Duration  8.32s (transform 2.13s, setup 0ms, import 10.42s, tests 3.90s, environment 0ms)
-
+
+
+> @aiready/testability@0.7.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__/provider.test.ts (2 tests) 4ms
+ ✓ src/__tests__/scoring.test.ts (6 tests) 3ms
+ ✓ src/__tests__/analyzer.test.ts (5 tests) 2017ms
+     ✓ detects test frameworks in multiple languages  1988ms
+
+ Test Files  4 passed (4)
+      Tests  17 passed (17)
+   Start at  00:08:36
+   Duration  3.74s (transform 1.07s, setup 0ms, import 4.57s, tests 2.03s, environment 0ms)
+
+[?25h

package/.turbo/turbo-type-check.log

@@ -0,0 +1,5 @@
+
+
+> @aiready/testability@0.7.8 type-check /Users/pengcao/projects/aiready/packages/testability
+> tsc --noEmit
+

package/dist/chunk-YSXDYH7O.mjs

@@ -0,0 +1,243 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+  runBatchAnalysis,
+  getParser,
+  isTestFile,
+  isIgnorableSourceFile,
+  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) && !isIgnorableSourceFile(f)
+  );
+  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 < 70) {
+    const worstPurityFiles = (indexResult.fileMetrics || []).filter((m) => !m.isEntryPoint && m.purityScore < 50).sort((a, b) => a.purityScore - b.purityScore).slice(0, 5);
+    if (worstPurityFiles.length > 0) {
+      worstPurityFiles.forEach((file) => {
+        issues.push({
+          type: IssueType.LowTestability,
+          dimension: "purity",
+          severity: Severity.Major,
+          message: `File has only ${file.purityScore}% pure functions \u2014 logic is hard for AI to verify safely.`,
+          location: { file: file.filePath, line: 1 },
+          suggestion: "Extract side-effectful logic into pure, testable functions."
+        });
+      });
+    } else {
+      issues.push({
+        type: IssueType.LowTestability,
+        dimension: "purity",
+        severity: Severity.Major,
+        message: `Only ${indexResult.dimensions.purityScore}% of project functions are pure \u2014 reduces AI verification safety.`,
+        location: { file: options.rootDir, line: 0 },
+        suggestion: "Promote pure function patterns to improve codebase testability."
+      });
+    }
+  }
+  if (indexResult.dimensions.dependencyInjectionScore < 60) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "dependency-injection",
+      severity: Severity.Major,
+      message: `Only ${indexResult.dimensions.dependencyInjectionScore}% of classes use dependency injection \u2014 hard to mock for AI verification.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Use constructor-based dependency injection to make components mockable."
+    });
+  }
+  if (aggregated.bloatedInterfaces > 0) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "interface-focus",
+      severity: Severity.Minor,
+      message: `Found ${aggregated.bloatedInterfaces} bloated interfaces/classes \u2014 large interfaces are harder for AI to implement correctly.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Split large interfaces into smaller, focused ones (Interface Segregation Principle)."
+    });
+  }
+  if (indexResult.dimensions.observabilityScore < 60) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "observability",
+      severity: Severity.Major,
+      message: `High rate of external state mutations detected (${indexResult.dimensions.observabilityScore}/100 observability) \u2014 hard for AI to reason about state changes.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Prefer immutable data patterns and return values instead of mutating external state."
+    });
+  }
+  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

@@ -158,14 +158,58 @@ async function analyzeTestability(options) {
       suggestion: `Add ~${needed} test file(s) to reach the ${Math.round(minCoverage * 100)}% minimum for safe AI assistance.`
     });
   }
-  if (indexResult.dimensions.purityScore < 50) {
+  if (indexResult.dimensions.purityScore < 70) {
+    const worstPurityFiles = (indexResult.fileMetrics || []).filter((m) => !m.isEntryPoint && m.purityScore < 50).sort((a, b) => a.purityScore - b.purityScore).slice(0, 5);
+    if (worstPurityFiles.length > 0) {
+      worstPurityFiles.forEach((file) => {
+        issues.push({
+          type: import_core.IssueType.LowTestability,
+          dimension: "purity",
+          severity: import_core.Severity.Major,
+          message: `File has only ${file.purityScore}% pure functions \u2014 logic is hard for AI to verify safely.`,
+          location: { file: file.filePath, line: 1 },
+          suggestion: "Extract side-effectful logic into pure, testable functions."
+        });
+      });
+    } else {
+      issues.push({
+        type: import_core.IssueType.LowTestability,
+        dimension: "purity",
+        severity: import_core.Severity.Major,
+        message: `Only ${indexResult.dimensions.purityScore}% of project functions are pure \u2014 reduces AI verification safety.`,
+        location: { file: options.rootDir, line: 0 },
+        suggestion: "Promote pure function patterns to improve codebase testability."
+      });
+    }
+  }
+  if (indexResult.dimensions.dependencyInjectionScore < 60) {
+    issues.push({
+      type: import_core.IssueType.LowTestability,
+      dimension: "dependency-injection",
+      severity: import_core.Severity.Major,
+      message: `Only ${indexResult.dimensions.dependencyInjectionScore}% of classes use dependency injection \u2014 hard to mock for AI verification.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Use constructor-based dependency injection to make components mockable."
+    });
+  }
+  if (aggregated.bloatedInterfaces > 0) {
+    issues.push({
+      type: import_core.IssueType.LowTestability,
+      dimension: "interface-focus",
+      severity: import_core.Severity.Minor,
+      message: `Found ${aggregated.bloatedInterfaces} bloated interfaces/classes \u2014 large interfaces are harder for AI to implement correctly.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Split large interfaces into smaller, focused ones (Interface Segregation Principle)."
+    });
+  }
+  if (indexResult.dimensions.observabilityScore < 60) {
     issues.push({
       type: import_core.IssueType.LowTestability,
-      dimension: "purity",
+      dimension: "observability",
       severity: import_core.Severity.Major,
-      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure \u2014 side-effectful code is harder for AI to verify safely.`,
+      message: `High rate of external state mutations detected (${indexResult.dimensions.observabilityScore}/100 observability) \u2014 hard for AI to reason about state changes.`,
       location: { file: options.rootDir, line: 0 },
-      suggestion: "Refactor complex side-effectful logic into pure functions where possible."
+      suggestion: "Prefer immutable data patterns and return values instead of mutating external state."
     });
   }
   return {

package/dist/cli.mjs

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

package/dist/index.js

@@ -162,14 +162,58 @@ async function analyzeTestability(options) {
       suggestion: `Add ~${needed} test file(s) to reach the ${Math.round(minCoverage * 100)}% minimum for safe AI assistance.`
     });
   }
-  if (indexResult.dimensions.purityScore < 50) {
+  if (indexResult.dimensions.purityScore < 70) {
+    const worstPurityFiles = (indexResult.fileMetrics || []).filter((m) => !m.isEntryPoint && m.purityScore < 50).sort((a, b) => a.purityScore - b.purityScore).slice(0, 5);
+    if (worstPurityFiles.length > 0) {
+      worstPurityFiles.forEach((file) => {
+        issues.push({
+          type: import_core.IssueType.LowTestability,
+          dimension: "purity",
+          severity: import_core.Severity.Major,
+          message: `File has only ${file.purityScore}% pure functions \u2014 logic is hard for AI to verify safely.`,
+          location: { file: file.filePath, line: 1 },
+          suggestion: "Extract side-effectful logic into pure, testable functions."
+        });
+      });
+    } else {
+      issues.push({
+        type: import_core.IssueType.LowTestability,
+        dimension: "purity",
+        severity: import_core.Severity.Major,
+        message: `Only ${indexResult.dimensions.purityScore}% of project functions are pure \u2014 reduces AI verification safety.`,
+        location: { file: options.rootDir, line: 0 },
+        suggestion: "Promote pure function patterns to improve codebase testability."
+      });
+    }
+  }
+  if (indexResult.dimensions.dependencyInjectionScore < 60) {
+    issues.push({
+      type: import_core.IssueType.LowTestability,
+      dimension: "dependency-injection",
+      severity: import_core.Severity.Major,
+      message: `Only ${indexResult.dimensions.dependencyInjectionScore}% of classes use dependency injection \u2014 hard to mock for AI verification.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Use constructor-based dependency injection to make components mockable."
+    });
+  }
+  if (aggregated.bloatedInterfaces > 0) {
+    issues.push({
+      type: import_core.IssueType.LowTestability,
+      dimension: "interface-focus",
+      severity: import_core.Severity.Minor,
+      message: `Found ${aggregated.bloatedInterfaces} bloated interfaces/classes \u2014 large interfaces are harder for AI to implement correctly.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Split large interfaces into smaller, focused ones (Interface Segregation Principle)."
+    });
+  }
+  if (indexResult.dimensions.observabilityScore < 60) {
     issues.push({
       type: import_core.IssueType.LowTestability,
-      dimension: "purity",
+      dimension: "observability",
       severity: import_core.Severity.Major,
-      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure \u2014 side-effectful code is harder for AI to verify safely.`,
+      message: `High rate of external state mutations detected (${indexResult.dimensions.observabilityScore}/100 observability) \u2014 hard for AI to reason about state changes.`,
       location: { file: options.rootDir, line: 0 },
-      suggestion: "Refactor complex side-effectful logic into pure functions where possible."
+      suggestion: "Prefer immutable data patterns and return values instead of mutating external state."
     });
   }
   return {

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/testability",
-  "version": "0.7.6",
+  "version": "0.7.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.24.6"
+    "@aiready/core": "0.24.8"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
@@ -57,6 +57,8 @@
     "test": "vitest run",
     "lint": "eslint src",
     "clean": "rm -rf dist",
-    "release": "pnpm build && pnpm publish --no-git-checks"
+    "release": "pnpm build && pnpm publish --no-git-checks",
+    "type-check": "tsc --noEmit",
+    "format-check": "prettier --check . --ignore-path ../../.prettierignore"
   }
 }

package/src/analyzer.ts

@@ -197,15 +197,70 @@ export async function analyzeTestability(
     });
   }
 
-  if (indexResult.dimensions.purityScore < 50) {
+  if (indexResult.dimensions.purityScore < 70) {
+    const worstPurityFiles = (indexResult.fileMetrics || [])
+      .filter((m) => !m.isEntryPoint && m.purityScore < 50)
+      .sort((a, b) => a.purityScore - b.purityScore)
+      .slice(0, 5);
+
+    if (worstPurityFiles.length > 0) {
+      worstPurityFiles.forEach((file) => {
+        issues.push({
+          type: IssueType.LowTestability,
+          dimension: 'purity',
+          severity: Severity.Major,
+          message: `File has only ${file.purityScore}% pure functions — logic is hard for AI to verify safely.`,
+          location: { file: file.filePath, line: 1 },
+          suggestion:
+            'Extract side-effectful logic into pure, testable functions.',
+        });
+      });
+    } else {
+      issues.push({
+        type: IssueType.LowTestability,
+        dimension: 'purity',
+        severity: Severity.Major,
+        message: `Only ${indexResult.dimensions.purityScore}% of project functions are pure — reduces AI verification safety.`,
+        location: { file: options.rootDir, line: 0 },
+        suggestion:
+          'Promote pure function patterns to improve codebase testability.',
+      });
+    }
+  }
+
+  if (indexResult.dimensions.dependencyInjectionScore < 60) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: 'dependency-injection',
+      severity: Severity.Major,
+      message: `Only ${indexResult.dimensions.dependencyInjectionScore}% of classes use dependency injection — hard to mock for AI verification.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion:
+        'Use constructor-based dependency injection to make components mockable.',
+    });
+  }
+
+  if (aggregated.bloatedInterfaces > 0) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: 'interface-focus',
+      severity: Severity.Minor,
+      message: `Found ${aggregated.bloatedInterfaces} bloated interfaces/classes — large interfaces are harder for AI to implement correctly.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion:
+        'Split large interfaces into smaller, focused ones (Interface Segregation Principle).',
+    });
+  }
+
+  if (indexResult.dimensions.observabilityScore < 60) {
     issues.push({
       type: IssueType.LowTestability,
-      dimension: 'purity',
+      dimension: 'observability',
       severity: Severity.Major,
-      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure — side-effectful code is harder for AI to verify safely.`,
+      message: `High rate of external state mutations detected (${indexResult.dimensions.observabilityScore}/100 observability) — hard for AI to reason about state changes.`,
       location: { file: options.rootDir, line: 0 },
       suggestion:
-        'Refactor complex side-effectful logic into pure functions where possible.',
+        'Prefer immutable data patterns and return values instead of mutating external state.',
     });
   }