@aiready/testability 0.2.3 → 0.4.0

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/testability@0.2.2 build /Users/pengcao/projects/aiready/packages/testability
+> @aiready/testability@0.3.0 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
@@ -9,16 +9,16 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/index.js 12.28 KB
-CJS dist/cli.js   18.38 KB
-CJS ⚡️ Build success in 38ms
-ESM dist/chunk-7MM2QISW.mjs 11.02 KB
-ESM dist/index.mjs          152.00 B
+CJS dist/cli.js   18.44 KB
+CJS dist/index.js 13.56 KB
+CJS ⚡️ Build success in 51ms
 ESM dist/cli.mjs            5.75 KB
-ESM ⚡️ Build success in 38ms
+ESM dist/chunk-2QLLQPTL.mjs 11.08 KB
+ESM dist/index.mjs          1.28 KB
+ESM ⚡️ Build success in 53ms
 DTS Build start
-DTS ⚡️ Build success in 2233ms
+DTS ⚡️ Build success in 2884ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  2.66 KB
+DTS dist/index.d.ts  2.78 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 2.66 KB
+DTS dist/index.d.mts 2.78 KB

package/.turbo/turbo-lint.log

@@ -1,5 +1,5 @@
 
 
-> @aiready/testability@0.1.6 lint /Users/pengcao/projects/aiready/packages/testability
+> @aiready/testability@0.2.5 lint /Users/pengcao/projects/aiready/packages/testability
 > eslint src
 

package/.turbo/turbo-test.log

@@ -1,16 +1,16 @@
 
 
-> @aiready/testability@0.2.2 test /Users/pengcao/projects/aiready/packages/testability
+> @aiready/testability@0.3.0 test /Users/pengcao/projects/aiready/packages/testability
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/testability
 
- ✓ src/__tests__/analyzer.test.ts (3 tests) 217ms
+ ✓ src/__tests__/analyzer.test.ts (3 tests) 29ms
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  20:01:55
-   Duration  2.14s (transform 162ms, setup 0ms, import 1.21s, tests 217ms, environment 0ms)
+   Start at  09:33:04
+   Duration  463ms (transform 130ms, setup 0ms, import 311ms, tests 29ms, environment 0ms)
 
 [?25h

package/dist/chunk-2QLLQPTL.mjs

@@ -0,0 +1,339 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType
+} from "@aiready/core";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { parse } from "@typescript-eslint/typescript-estree";
+function countMethodsInInterface(node) {
+  if (node.type === "TSInterfaceDeclaration") {
+    return node.body.body.filter(
+      (m) => m.type === "TSMethodSignature" || m.type === "TSPropertySignature"
+    ).length;
+  }
+  if (node.type === "TSTypeAliasDeclaration" && node.typeAnnotation.type === "TSTypeLiteral") {
+    return node.typeAnnotation.members.length;
+  }
+  return 0;
+}
+function hasDependencyInjection(node) {
+  for (const member of node.body.body) {
+    if (member.type === "MethodDefinition" && member.key.type === "Identifier" && member.key.name === "constructor") {
+      const fn = member.value;
+      if (fn.params && fn.params.length > 0) {
+        const typedParams = fn.params.filter((p) => {
+          const param = p;
+          return param.typeAnnotation != null || param.parameter?.typeAnnotation != null;
+        });
+        if (typedParams.length > 0) return true;
+      }
+    }
+  }
+  return false;
+}
+function isPureFunction(fn) {
+  let hasReturn = false;
+  let hasSideEffect = false;
+  function walk(node) {
+    if (node.type === "ReturnStatement" && node.argument) hasReturn = true;
+    if (node.type === "AssignmentExpression" && node.left.type === "MemberExpression")
+      hasSideEffect = true;
+    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;
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        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));
+  } else if (fn.body) {
+    hasReturn = true;
+  }
+  return hasReturn && !hasSideEffect;
+}
+function hasExternalStateMutation(fn) {
+  let found = false;
+  function walk(node) {
+    if (found) return;
+    if (node.type === "AssignmentExpression" && node.left.type === "MemberExpression")
+      found = true;
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        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));
+  return found;
+}
+function analyzeFileTestability(filePath) {
+  const result = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      range: false,
+      loc: false
+    });
+  } catch {
+    return result;
+  }
+  function visit(node) {
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      result.totalFunctions++;
+      if (isPureFunction(node)) result.pureFunctions++;
+      if (hasExternalStateMutation(node)) result.externalStateMutations++;
+    }
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      result.totalClasses++;
+      if (hasDependencyInjection(node)) result.injectionPatterns++;
+    }
+    if (node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") {
+      result.totalInterfaces++;
+      const methodCount = countMethodsInInterface(node);
+      if (methodCount > 10) result.bloatedInterfaces++;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) child.forEach((c) => c?.type && visit(c));
+        else if (child.type) visit(child);
+      }
+    }
+  }
+  ast.body.forEach(visit);
+  return result;
+}
+function detectTestFramework(rootDir) {
+  const pkgPath = join(rootDir, "package.json");
+  if (!existsSync(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const testFrameworks = [
+      "jest",
+      "vitest",
+      "mocha",
+      "jasmine",
+      "ava",
+      "tap",
+      "pytest",
+      "unittest"
+    ];
+    return testFrameworks.some((fw) => allDeps[fw]);
+  } catch {
+    return false;
+  }
+}
+var TEST_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /__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}"],
+    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
+  };
+  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)) {
+      aggregated[key] += a[key];
+    }
+  }
+  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
+  });
+  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 testing framework detected in package.json \u2014 AI changes cannot be verified at all.",
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Add Jest, Vitest, or another testing framework as a devDependency."
+    });
+  }
+  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 are pure \u2014 side-effectful functions require complex test setup.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Extract pure transformation logic from I/O and mutation code."
+    });
+  }
+  if (indexResult.dimensions.observabilityScore < 50) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "observability",
+      severity: Severity.Major,
+      message: `Many functions mutate external state directly \u2014 outputs are invisible to unit tests.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Prefer returning values over mutating shared 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 } 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/chunk-ULOUVO3Q.mjs

@@ -0,0 +1,338 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType
+} from "@aiready/core";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { parse } from "@typescript-eslint/typescript-estree";
+function countMethodsInInterface(node) {
+  if (node.type === "TSInterfaceDeclaration") {
+    return node.body.body.filter(
+      (m) => m.type === "TSMethodSignature" || m.type === "TSPropertySignature"
+    ).length;
+  }
+  if (node.type === "TSTypeAliasDeclaration" && node.typeAnnotation.type === "TSTypeLiteral") {
+    return node.typeAnnotation.members.length;
+  }
+  return 0;
+}
+function hasDependencyInjection(node) {
+  for (const member of node.body.body) {
+    if (member.type === "MethodDefinition" && member.key.type === "Identifier" && member.key.name === "constructor") {
+      const fn = member.value;
+      if (fn.params && fn.params.length > 0) {
+        const typedParams = fn.params.filter((p) => {
+          const param = p;
+          return param.typeAnnotation != null || param.parameter?.typeAnnotation != null;
+        });
+        if (typedParams.length > 0) return true;
+      }
+    }
+  }
+  return false;
+}
+function isPureFunction(fn) {
+  let hasReturn = false;
+  let hasSideEffect = false;
+  function walk(node) {
+    if (node.type === "ReturnStatement" && node.argument) hasReturn = true;
+    if (node.type === "AssignmentExpression" && node.left.type === "MemberExpression")
+      hasSideEffect = true;
+    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;
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        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));
+  } else if (fn.body) {
+    hasReturn = true;
+  }
+  return hasReturn && !hasSideEffect;
+}
+function hasExternalStateMutation(fn) {
+  let found = false;
+  function walk(node) {
+    if (found) return;
+    if (node.type === "AssignmentExpression" && node.left.type === "MemberExpression")
+      found = true;
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        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));
+  return found;
+}
+function analyzeFileTestability(filePath) {
+  const result = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      range: false,
+      loc: false
+    });
+  } catch {
+    return result;
+  }
+  function visit(node) {
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      result.totalFunctions++;
+      if (isPureFunction(node)) result.pureFunctions++;
+      if (hasExternalStateMutation(node)) result.externalStateMutations++;
+    }
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      result.totalClasses++;
+      if (hasDependencyInjection(node)) result.injectionPatterns++;
+    }
+    if (node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") {
+      result.totalInterfaces++;
+      const methodCount = countMethodsInInterface(node);
+      if (methodCount > 10) result.bloatedInterfaces++;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) child.forEach((c) => c?.type && visit(c));
+        else if (child.type) visit(child);
+      }
+    }
+  }
+  ast.body.forEach(visit);
+  return result;
+}
+function detectTestFramework(rootDir) {
+  const pkgPath = join(rootDir, "package.json");
+  if (!existsSync(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const testFrameworks = [
+      "jest",
+      "vitest",
+      "mocha",
+      "jasmine",
+      "ava",
+      "tap",
+      "pytest",
+      "unittest"
+    ];
+    return testFrameworks.some((fw) => allDeps[fw]);
+  } catch {
+    return false;
+  }
+}
+var TEST_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /__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}"],
+    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
+  };
+  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)) {
+      aggregated[key] += a[key];
+    }
+  }
+  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
+  });
+  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 testing framework detected in package.json \u2014 AI changes cannot be verified at all.",
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Add Jest, Vitest, or another testing framework as a devDependency."
+    });
+  }
+  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 are pure \u2014 side-effectful functions require complex test setup.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Extract pure transformation logic from I/O and mutation code."
+    });
+  }
+  if (indexResult.dimensions.observabilityScore < 50) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "observability",
+      severity: Severity.Major,
+      message: `Many functions mutate external state directly \u2014 outputs are invisible to unit tests.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Prefer returning values over mutating shared 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
+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: "testability",
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating,
+      aiChangeSafetyRating: summary.aiChangeSafetyRating,
+      coverageRatio: summary.coverageRatio
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+export {
+  analyzeTestability,
+  calculateTestabilityScore
+};

package/dist/cli.js

@@ -305,6 +305,7 @@ async function analyzeTestability(options) {
 }
 
 // src/scoring.ts
+var import_core2 = require("@aiready/core");
 function calculateTestabilityScore(report) {
   const { summary, rawData, recommendations } = report;
   const factors = [
@@ -342,7 +343,7 @@ function calculateTestabilityScore(report) {
     })
   );
   return {
-    toolName: "testability",
+    toolName: import_core2.ToolName.TestabilityIndex,
     score: summary.score,
     rawMetrics: {
       ...rawData,
@@ -359,7 +360,7 @@ function calculateTestabilityScore(report) {
 var import_chalk = __toESM(require("chalk"));
 var import_fs2 = require("fs");
 var import_path2 = require("path");
-var import_core2 = require("@aiready/core");
+var import_core3 = require("@aiready/core");
 var program = new import_commander.Command();
 program.name("aiready-testability").description(
   "Measure how safely AI-generated changes can be verified in your codebase"
@@ -394,8 +395,8 @@ EXAMPLES:
 ).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").option("--output-file <path>", "Output file path (for json)").action(async (directory, options) => {
   console.log(import_chalk.default.blue("\u{1F9EA} Analyzing testability...\n"));
   const startTime = Date.now();
-  const config = await (0, import_core2.loadConfig)(directory);
-  const mergedConfig = (0, import_core2.mergeConfigWithDefaults)(config, {
+  const config = await (0, import_core3.loadConfig)(directory);
+  const mergedConfig = (0, import_core3.mergeConfigWithDefaults)(config, {
     minCoverageRatio: 0.3
   });
   const finalOptions = {
@@ -410,7 +411,7 @@ EXAMPLES:
   const elapsed = ((Date.now() - startTime) / 1e3).toFixed(2);
   if (options.output === "json") {
     const payload = { report, score: scoring };
-    const outputPath = (0, import_core2.resolveOutputPath)(
+    const outputPath = (0, import_core3.resolveOutputPath)(
       options.outputFile,
       `testability-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
       directory
@@ -443,9 +444,9 @@ function displayConsoleReport(report, scoring, elapsed) {
     );
     console.log();
   }
-  const safetyColor = (0, import_core2.getSeverityColor)(safetyRating, import_chalk.default);
+  const safetyColor = (0, import_core3.getSeverityColor)(safetyRating, import_chalk.default);
   console.log(
-    `AI Change Safety: ${safetyColor(`${(0, import_core2.getSafetyIcon)(safetyRating)} ${safetyRating.toUpperCase()}`)}`
+    `AI Change Safety: ${safetyColor(`${(0, import_core3.getSafetyIcon)(safetyRating)} ${safetyRating.toUpperCase()}`)}`
   );
   console.log(
     `Score:            ${import_chalk.default.bold(summary.score + "/100")} (${summary.rating})`
@@ -468,12 +469,12 @@ function displayConsoleReport(report, scoring, elapsed) {
   ];
   for (const [name, val] of dims) {
     const color = val >= 70 ? import_chalk.default.green : val >= 50 ? import_chalk.default.yellow : import_chalk.default.red;
-    console.log(`  ${name.padEnd(22)} ${color((0, import_core2.getScoreBar)(val))} ${val}/100`);
+    console.log(`  ${name.padEnd(22)} ${color((0, import_core3.getScoreBar)(val))} ${val}/100`);
   }
   if (issues.length > 0) {
     console.log(import_chalk.default.bold("\n\u26A0\uFE0F  Issues\n"));
     for (const issue of issues) {
-      const sev = (0, import_core2.getSeverityColor)(issue.severity, import_chalk.default);
+      const sev = (0, import_core3.getSeverityColor)(issue.severity, import_chalk.default);
       console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
       if (issue.suggestion)
         console.log(

package/dist/cli.mjs

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

package/dist/index.d.mts

@@ -1,4 +1,9 @@
-import { Issue, IssueType, ToolScoringOutput } from '@aiready/core';
+import { ToolProvider, Issue, IssueType, ToolScoringOutput } from '@aiready/core';
+
+/**
+ * Testability Tool Provider
+ */
+declare const TestabilityProvider: ToolProvider;
 
 interface TestabilityOptions {
     /** Root directory to scan */
@@ -73,4 +78,4 @@ declare function analyzeTestability(options: TestabilityOptions): Promise<Testab
  */
 declare function calculateTestabilityScore(report: TestabilityReport): ToolScoringOutput;
 
-export { type TestabilityIssue, type TestabilityOptions, type TestabilityReport, analyzeTestability, calculateTestabilityScore };
+export { type TestabilityIssue, type TestabilityOptions, TestabilityProvider, type TestabilityReport, analyzeTestability, calculateTestabilityScore };

package/dist/index.d.ts

@@ -1,4 +1,9 @@
-import { Issue, IssueType, ToolScoringOutput } from '@aiready/core';
+import { ToolProvider, Issue, IssueType, ToolScoringOutput } from '@aiready/core';
+
+/**
+ * Testability Tool Provider
+ */
+declare const TestabilityProvider: ToolProvider;
 
 interface TestabilityOptions {
     /** Root directory to scan */
@@ -73,4 +78,4 @@ declare function analyzeTestability(options: TestabilityOptions): Promise<Testab
  */
 declare function calculateTestabilityScore(report: TestabilityReport): ToolScoringOutput;
 
-export { type TestabilityIssue, type TestabilityOptions, type TestabilityReport, analyzeTestability, calculateTestabilityScore };
+export { type TestabilityIssue, type TestabilityOptions, TestabilityProvider, type TestabilityReport, analyzeTestability, calculateTestabilityScore };

package/dist/index.js

@@ -20,10 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  TestabilityProvider: () => TestabilityProvider,
   analyzeTestability: () => analyzeTestability,
   calculateTestabilityScore: () => calculateTestabilityScore
 });
 module.exports = __toCommonJS(index_exports);
+var import_core4 = require("@aiready/core");
+
+// src/provider.ts
+var import_core3 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core = require("@aiready/core");
@@ -304,6 +309,7 @@ async function analyzeTestability(options) {
 }
 
 // src/scoring.ts
+var import_core2 = require("@aiready/core");
 function calculateTestabilityScore(report) {
   const { summary, rawData, recommendations } = report;
   const factors = [
@@ -341,7 +347,7 @@ function calculateTestabilityScore(report) {
     })
   );
   return {
-    toolName: "testability",
+    toolName: import_core2.ToolName.TestabilityIndex,
     score: summary.score,
     rawMetrics: {
       ...rawData,
@@ -353,8 +359,47 @@ function calculateTestabilityScore(report) {
     recommendations: recs
   };
 }
+
+// src/provider.ts
+var TestabilityProvider = {
+  id: import_core3.ToolName.TestabilityIndex,
+  alias: ["testability", "tests", "verification"],
+  async analyze(options) {
+    const report = await analyzeTestability(options);
+    const results = report.issues.map((i) => ({
+      fileName: i.location.file,
+      issues: [i],
+      metrics: {
+        testabilityScore: report.summary.score
+      }
+    }));
+    return import_core3.SpokeOutputSchema.parse({
+      results,
+      summary: report.summary,
+      metadata: {
+        toolName: import_core3.ToolName.TestabilityIndex,
+        version: "0.2.5",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        rawData: report.rawData
+      }
+    });
+  },
+  score(output, options) {
+    const report = {
+      summary: output.summary,
+      rawData: output.metadata.rawData,
+      recommendations: output.summary.recommendations || []
+    };
+    return calculateTestabilityScore(report);
+  },
+  defaultWeight: 10
+};
+
+// src/index.ts
+import_core4.ToolRegistry.register(TestabilityProvider);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  TestabilityProvider,
   analyzeTestability,
   calculateTestabilityScore
 });

package/dist/index.mjs

@@ -1,8 +1,54 @@
 import {
   analyzeTestability,
   calculateTestabilityScore
-} from "./chunk-7MM2QISW.mjs";
+} from "./chunk-2QLLQPTL.mjs";
+
+// src/index.ts
+import { ToolRegistry } from "@aiready/core";
+
+// src/provider.ts
+import {
+  ToolName,
+  SpokeOutputSchema
+} from "@aiready/core";
+var TestabilityProvider = {
+  id: ToolName.TestabilityIndex,
+  alias: ["testability", "tests", "verification"],
+  async analyze(options) {
+    const report = await analyzeTestability(options);
+    const results = report.issues.map((i) => ({
+      fileName: i.location.file,
+      issues: [i],
+      metrics: {
+        testabilityScore: report.summary.score
+      }
+    }));
+    return SpokeOutputSchema.parse({
+      results,
+      summary: report.summary,
+      metadata: {
+        toolName: ToolName.TestabilityIndex,
+        version: "0.2.5",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        rawData: report.rawData
+      }
+    });
+  },
+  score(output, options) {
+    const report = {
+      summary: output.summary,
+      rawData: output.metadata.rawData,
+      recommendations: output.summary.recommendations || []
+    };
+    return calculateTestabilityScore(report);
+  },
+  defaultWeight: 10
+};
+
+// src/index.ts
+ToolRegistry.register(TestabilityProvider);
 export {
+  TestabilityProvider,
   analyzeTestability,
   calculateTestabilityScore
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/testability",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "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.19.3"
+    "@aiready/core": "0.21.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/analyzer.ts

@@ -10,7 +10,12 @@
  * 5. Observability (return values vs. external state mutations)
  */
 
-import { scanFiles, calculateTestabilityIndex, Severity, IssueType } from '@aiready/core';
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+} from '@aiready/core';
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { parse } from '@typescript-eslint/typescript-estree';

package/src/index.ts

@@ -1,5 +1,12 @@
+import { ToolRegistry } from '@aiready/core';
+import { TestabilityProvider } from './provider';
+
+// Register with global registry
+ToolRegistry.register(TestabilityProvider);
+
 export { analyzeTestability } from './analyzer';
 export { calculateTestabilityScore } from './scoring';
+export { TestabilityProvider };
 export type {
   TestabilityOptions,
   TestabilityReport,

package/src/provider.ts

@@ -0,0 +1,55 @@
+import {
+  ToolProvider,
+  ToolName,
+  SpokeOutput,
+  ScanOptions,
+  ToolScoringOutput,
+  AnalysisResult,
+  SpokeOutputSchema,
+} from '@aiready/core';
+import { analyzeTestability } from './analyzer';
+import { calculateTestabilityScore } from './scoring';
+import { TestabilityOptions, TestabilityReport } from './types';
+
+/**
+ * Testability Tool Provider
+ */
+export const TestabilityProvider: ToolProvider = {
+  id: ToolName.TestabilityIndex,
+  alias: ['testability', 'tests', 'verification'],
+
+  async analyze(options: ScanOptions): Promise<SpokeOutput> {
+    const report = await analyzeTestability(options as TestabilityOptions);
+
+    const results: AnalysisResult[] = report.issues.map((i) => ({
+      fileName: i.location.file,
+      issues: [i] as any[],
+      metrics: {
+        testabilityScore: report.summary.score,
+      },
+    }));
+
+    return SpokeOutputSchema.parse({
+      results,
+      summary: report.summary,
+      metadata: {
+        toolName: ToolName.TestabilityIndex,
+        version: '0.2.5',
+        timestamp: new Date().toISOString(),
+        rawData: report.rawData,
+      },
+    });
+  },
+
+  score(output: SpokeOutput, options: ScanOptions): ToolScoringOutput {
+    const report = {
+      summary: output.summary,
+      rawData: (output.metadata as any).rawData,
+      recommendations: (output.summary as any).recommendations || [],
+    } as unknown as TestabilityReport;
+
+    return calculateTestabilityScore(report);
+  },
+
+  defaultWeight: 10,
+};

package/src/scoring.ts

@@ -1,4 +1,4 @@
-import type { ToolScoringOutput } from '@aiready/core';
+import { type ToolScoringOutput, ToolName } from '@aiready/core';
 import type { TestabilityReport } from './types';
 
 /**
@@ -50,7 +50,7 @@ export function calculateTestabilityScore(
   );
 
   return {
-    toolName: 'testability',
+    toolName: ToolName.TestabilityIndex,
     score: summary.score,
     rawMetrics: {
       ...rawData,