@aiready/testability 0.4.16 → 0.4.17

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/testability@0.4.15 build /Users/pengcao/projects/aiready/packages/testability
+> @aiready/testability@0.4.16 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/cli.js   15.61 KB
+CJS dist/index.js 10.73 KB
+CJS ⚡️ Build success in 42ms
 ESM dist/cli.mjs            5.75 KB
-ESM dist/chunk-LJLAJRZR.mjs 11.12 KB
 ESM dist/index.mjs          1.28 KB
-ESM ⚡️ Build success in 138ms
-CJS dist/index.js 13.60 KB
-CJS dist/cli.js   18.49 KB
-CJS ⚡️ Build success in 142ms
+ESM dist/chunk-QOIBI5E7.mjs 8.31 KB
+ESM ⚡️ Build success in 42ms
 DTS Build start
-DTS ⚡️ Build success in 2714ms
+DTS ⚡️ Build success in 1209ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  2.78 KB
+DTS dist/index.d.ts  2.41 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 2.78 KB
+DTS dist/index.d.mts 2.41 KB

package/.turbo/turbo-test.log

@@ -1,16 +1,16 @@
 
 
-> @aiready/testability@0.4.15 test /Users/pengcao/projects/aiready/packages/testability
+> @aiready/testability@0.4.16 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) 145ms
+ ✓ src/__tests__/analyzer.test.ts (3 tests) 87ms
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  02:11:32
-   Duration  1.40s (transform 184ms, setup 0ms, import 926ms, tests 145ms, environment 0ms)
+   Start at  12:45:53
+   Duration  1.37s (transform 221ms, setup 0ms, import 663ms, tests 87ms, environment 0ms)
 
 [?25h

package/README.md

@@ -9,6 +9,12 @@
 
 The "Verify" loop is the most expensive part of the AI agent workflow. Codebases with high global state, missing dependency injection, or poor test coverage force agents into long, expensive retry loops. The **Testability Index** quantifies these frictions.
 
+### Language Support
+
+- **Full Support:** TypeScript, JavaScript, Python, Java, Go, C#
+- **Capabilities:** Purity analysis, global state detection, DI pattern recognition.
+  toxicology
+
 ## 🏛️ Architecture
 
 ```

package/dist/chunk-P53QYYIW.mjs

@@ -0,0 +1,258 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+  emitProgress,
+  getParser
+} from "@aiready/core";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+async function analyzeFileTestability(filePath) {
+  const result = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  const parser = getParser(filePath);
+  if (!parser) return result;
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  try {
+    await parser.initialize();
+    const parseResult = parser.parse(code, filePath);
+    for (const exp of parseResult.exports) {
+      if (exp.type === "function") {
+        result.totalFunctions++;
+        if (exp.isPure) result.pureFunctions++;
+        if (exp.hasSideEffects) result.externalStateMutations++;
+      }
+      if (exp.type === "class") {
+        result.totalClasses++;
+        if (exp.parameters && exp.parameters.length > 0) {
+          result.injectionPatterns++;
+        }
+      }
+      if (exp.type === "interface" || exp.type === "class") {
+        if (exp.type === "interface") result.totalInterfaces++;
+        const total = (exp.methodCount || 0) + (exp.propertyCount || 0);
+        if (total > 5) {
+          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
+  };
+  let processed = 0;
+  for (const f of sourceFiles) {
+    processed++;
+    emitProgress(
+      processed,
+      sourceFiles.length,
+      "testability",
+      "analyzing files",
+      options.onProgress
+    );
+    const a = await analyzeFileTestability(f);
+    for (const key of Object.keys(aggregated)) {
+      aggregated[key] += a[key];
+    }
+  }
+  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 major testing framework detected \u2014 AI changes cannot be safely verified.",
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Add a testing framework (e.g., Jest, Pytest, JUnit) to enable automated verification."
+    });
+  }
+  if (actualRatio < minCoverage) {
+    const needed = Math.ceil(sourceFiles.length * minCoverage) - testFiles.length;
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "test-coverage",
+      severity: actualRatio === 0 ? Severity.Critical : Severity.Major,
+      message: `Test ratio is ${Math.round(actualRatio * 100)}% (${testFiles.length} test files for ${sourceFiles.length} source files). Need at least ${Math.round(minCoverage * 100)}%.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: `Add ~${needed} test file(s) to reach the ${Math.round(minCoverage * 100)}% minimum for safe AI assistance.`
+    });
+  }
+  if (indexResult.dimensions.purityScore < 50) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "purity",
+      severity: Severity.Major,
+      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure \u2014 side-effectful code is harder for AI to verify safely.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Refactor complex side-effectful logic into pure functions where possible."
+    });
+  }
+  return {
+    summary: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      coverageRatio: Math.round(actualRatio * 100) / 100,
+      score: indexResult.score,
+      rating: indexResult.rating,
+      aiChangeSafetyRating: indexResult.aiChangeSafetyRating,
+      dimensions: indexResult.dimensions
+    },
+    issues,
+    rawData: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      ...aggregated,
+      hasTestFramework
+    },
+    recommendations: indexResult.recommendations
+  };
+}
+
+// src/scoring.ts
+import { ToolName } from "@aiready/core";
+function calculateTestabilityScore(report) {
+  const { summary, rawData, recommendations } = report;
+  const factors = [
+    {
+      name: "Test Coverage",
+      impact: Math.round(summary.dimensions.testCoverageRatio - 50),
+      description: `${rawData.testFiles} test files / ${rawData.sourceFiles} source files (${Math.round(summary.coverageRatio * 100)}%)`
+    },
+    {
+      name: "Function Purity",
+      impact: Math.round(summary.dimensions.purityScore - 50),
+      description: `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`
+    },
+    {
+      name: "Dependency Injection",
+      impact: Math.round(summary.dimensions.dependencyInjectionScore - 50),
+      description: `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`
+    },
+    {
+      name: "Interface Focus",
+      impact: Math.round(summary.dimensions.interfaceFocusScore - 50),
+      description: `${rawData.bloatedInterfaces} interfaces have >10 methods`
+    },
+    {
+      name: "Observability",
+      impact: Math.round(summary.dimensions.observabilityScore - 50),
+      description: `${rawData.externalStateMutations} functions mutate external state`
+    }
+  ];
+  const recs = recommendations.map(
+    (action) => ({
+      action,
+      estimatedImpact: summary.aiChangeSafetyRating === "blind-risk" ? 15 : 8,
+      priority: summary.aiChangeSafetyRating === "blind-risk" || summary.aiChangeSafetyRating === "high-risk" ? "high" : "medium"
+    })
+  );
+  return {
+    toolName: ToolName.TestabilityIndex,
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating,
+      aiChangeSafetyRating: summary.aiChangeSafetyRating,
+      coverageRatio: summary.coverageRatio
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+export {
+  analyzeTestability,
+  calculateTestabilityScore
+};

package/dist/chunk-QOIBI5E7.mjs

@@ -0,0 +1,262 @@
+// src/analyzer.ts
+import {
+  scanFiles,
+  calculateTestabilityIndex,
+  Severity,
+  IssueType,
+  emitProgress,
+  getParser
+} from "@aiready/core";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+async function analyzeFileTestability(filePath) {
+  const result = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  const parser = getParser(filePath);
+  if (!parser) return result;
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  try {
+    await parser.initialize();
+    const parseResult = parser.parse(code, filePath);
+    for (const exp of parseResult.exports) {
+      if (exp.type === "function") {
+        result.totalFunctions++;
+        if (exp.isPure) result.pureFunctions++;
+        if (exp.hasSideEffects) result.externalStateMutations++;
+      }
+      if (exp.type === "class") {
+        result.totalClasses++;
+        if (exp.parameters && exp.parameters.length > 0) {
+          result.injectionPatterns++;
+        }
+        const total = (exp.methodCount || 0) + (exp.propertyCount || 0);
+        if (total > 5) {
+          result.bloatedInterfaces++;
+        }
+      }
+      if (exp.type === "interface") {
+        result.totalInterfaces++;
+        const total = (exp.methodCount || 0) + (exp.propertyCount || 0);
+        if (total > 5) {
+          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
+  };
+  let processed = 0;
+  for (const f of sourceFiles) {
+    processed++;
+    emitProgress(
+      processed,
+      sourceFiles.length,
+      "testability",
+      "analyzing files",
+      options.onProgress
+    );
+    const a = await analyzeFileTestability(f);
+    for (const key of Object.keys(aggregated)) {
+      aggregated[key] += a[key];
+    }
+  }
+  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 major testing framework detected \u2014 AI changes cannot be safely verified.",
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Add a testing framework (e.g., Jest, Pytest, JUnit) to enable automated verification."
+    });
+  }
+  if (actualRatio < minCoverage) {
+    const needed = Math.ceil(sourceFiles.length * minCoverage) - testFiles.length;
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "test-coverage",
+      severity: actualRatio === 0 ? Severity.Critical : Severity.Major,
+      message: `Test ratio is ${Math.round(actualRatio * 100)}% (${testFiles.length} test files for ${sourceFiles.length} source files). Need at least ${Math.round(minCoverage * 100)}%.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: `Add ~${needed} test file(s) to reach the ${Math.round(minCoverage * 100)}% minimum for safe AI assistance.`
+    });
+  }
+  if (indexResult.dimensions.purityScore < 50) {
+    issues.push({
+      type: IssueType.LowTestability,
+      dimension: "purity",
+      severity: Severity.Major,
+      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure \u2014 side-effectful code is harder for AI to verify safely.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Refactor complex side-effectful logic into pure functions where possible."
+    });
+  }
+  return {
+    summary: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      coverageRatio: Math.round(actualRatio * 100) / 100,
+      score: indexResult.score,
+      rating: indexResult.rating,
+      aiChangeSafetyRating: indexResult.aiChangeSafetyRating,
+      dimensions: indexResult.dimensions
+    },
+    issues,
+    rawData: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      ...aggregated,
+      hasTestFramework
+    },
+    recommendations: indexResult.recommendations
+  };
+}
+
+// src/scoring.ts
+import { ToolName } from "@aiready/core";
+function calculateTestabilityScore(report) {
+  const { summary, rawData, recommendations } = report;
+  const factors = [
+    {
+      name: "Test Coverage",
+      impact: Math.round(summary.dimensions.testCoverageRatio - 50),
+      description: `${rawData.testFiles} test files / ${rawData.sourceFiles} source files (${Math.round(summary.coverageRatio * 100)}%)`
+    },
+    {
+      name: "Function Purity",
+      impact: Math.round(summary.dimensions.purityScore - 50),
+      description: `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`
+    },
+    {
+      name: "Dependency Injection",
+      impact: Math.round(summary.dimensions.dependencyInjectionScore - 50),
+      description: `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`
+    },
+    {
+      name: "Interface Focus",
+      impact: Math.round(summary.dimensions.interfaceFocusScore - 50),
+      description: `${rawData.bloatedInterfaces} interfaces have >10 methods`
+    },
+    {
+      name: "Observability",
+      impact: Math.round(summary.dimensions.observabilityScore - 50),
+      description: `${rawData.externalStateMutations} functions mutate external state`
+    }
+  ];
+  const recs = recommendations.map(
+    (action) => ({
+      action,
+      estimatedImpact: summary.aiChangeSafetyRating === "blind-risk" ? 15 : 8,
+      priority: summary.aiChangeSafetyRating === "blind-risk" || summary.aiChangeSafetyRating === "high-risk" ? "high" : "medium"
+    })
+  );
+  return {
+    toolName: ToolName.TestabilityIndex,
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating,
+      aiChangeSafetyRating: summary.aiChangeSafetyRating,
+      coverageRatio: summary.coverageRatio
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+export {
+  analyzeTestability,
+  calculateTestabilityScore
+};