@aiready/testability 0.4.16 → 0.4.18

package/dist/chunk-VNU3SQOC.mjs

@@ -0,0 +1,265 @@
+// 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.name === "BloatedService") {
+        console.log(`[DEBUG] Found BloatedService: type=${exp.type}, methods=${exp.methodCount}, props=${exp.propertyCount}`);
+      }
+      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
+};

package/dist/cli.js

@@ -30,82 +30,7 @@ var import_commander = require("commander");
 var import_core = require("@aiready/core");
 var import_fs = require("fs");
 var import_path = require("path");
-var import_typescript_estree = require("@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) {
+async function analyzeFileTestability(filePath) {
   const result = {
     pureFunctions: 0,
     totalFunctions: 0,
@@ -115,75 +40,79 @@ function analyzeFileTestability(filePath) {
     totalInterfaces: 0,
     externalStateMutations: 0
   };
+  const parser = (0, import_core.getParser)(filePath);
+  if (!parser) return result;
   let code;
   try {
     code = (0, import_fs.readFileSync)(filePath, "utf-8");
   } catch {
     return result;
   }
-  let ast;
   try {
-    ast = (0, import_typescript_estree.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);
+    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}`);
   }
-  ast.body.forEach(visit);
   return result;
 }
 function detectTestFramework(rootDir) {
-  const pkgPath = (0, import_path.join)(rootDir, "package.json");
-  if (!(0, import_fs.existsSync)(pkgPath)) return false;
-  try {
-    const pkg = JSON.parse((0, import_fs.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;
+  const manifests = [
+    {
+      file: "package.json",
+      deps: ["jest", "vitest", "mocha", "mocha", "jasmine", "ava", "tap"]
+    },
+    { file: "requirements.txt", deps: ["pytest", "unittest", "nose"] },
+    { file: "pyproject.toml", deps: ["pytest"] },
+    { file: "pom.xml", deps: ["junit", "testng"] },
+    { file: "build.gradle", deps: ["junit", "testng"] },
+    { file: "go.mod", deps: ["testing"] }
+    // go testing is built-in
+  ];
+  for (const m of manifests) {
+    const p = (0, import_path.join)(rootDir, m.file);
+    if ((0, import_fs.existsSync)(p)) {
+      if (m.file === "go.mod") return true;
+      try {
+        const content = (0, import_fs.readFileSync)(p, "utf-8");
+        if (m.deps.some((d) => content.includes(d))) return true;
+      } catch {
+      }
+    }
   }
+  return false;
 }
 var TEST_PATTERNS = [
   /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /_test\.go$/,
+  /test_.*\.py$/,
+  /.*_test\.py$/,
+  /.*Test\.java$/,
+  /.*Tests\.cs$/,
   /__tests__\//,
   /\/tests?\//,
   /\/e2e\//,
@@ -197,7 +126,7 @@ function isTestFile(filePath, extra) {
 async function analyzeTestability(options) {
   const allFiles = await (0, import_core.scanFiles)({
     ...options,
-    include: options.include || ["**/*.{ts,tsx,js,jsx}"],
+    include: options.include || ["**/*.{ts,tsx,js,jsx,py,java,cs,go}"],
     includeTests: true
   });
   const sourceFiles = allFiles.filter(
@@ -223,7 +152,7 @@ async function analyzeTestability(options) {
       "analyzing files",
       options.onProgress
     );
-    const a = analyzeFileTestability(f);
+    const a = await analyzeFileTestability(f);
     for (const key of Object.keys(aggregated)) {
       aggregated[key] += a[key];
     }
@@ -249,9 +178,9 @@ async function analyzeTestability(options) {
       type: import_core.IssueType.LowTestability,
       dimension: "framework",
       severity: import_core.Severity.Critical,
-      message: "No testing framework detected in package.json \u2014 AI changes cannot be verified at all.",
+      message: "No major testing framework detected \u2014 AI changes cannot be safely verified.",
       location: { file: options.rootDir, line: 0 },
-      suggestion: "Add Jest, Vitest, or another testing framework as a devDependency."
+      suggestion: "Add a testing framework (e.g., Jest, Pytest, JUnit) to enable automated verification."
     });
   }
   if (actualRatio < minCoverage) {
@@ -270,19 +199,9 @@ async function analyzeTestability(options) {
       type: import_core.IssueType.LowTestability,
       dimension: "purity",
       severity: import_core.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: import_core.IssueType.LowTestability,
-      dimension: "observability",
-      severity: import_core.Severity.Major,
-      message: `Many functions mutate external state directly \u2014 outputs are invisible to unit tests.`,
+      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: "Prefer returning values over mutating shared state."
+      suggestion: "Refactor complex side-effectful logic into pure functions where possible."
     });
   }
   return {

package/dist/cli.mjs

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

package/dist/index.d.mts

@@ -59,18 +59,6 @@ interface TestabilityReport {
     recommendations: string[];
 }
 
-/**
- * Testability analyzer.
- *
- * Walks the codebase and measures 5 structural dimensions that determine
- * whether AI-generated changes can be safely verified:
- * 1. Test file coverage ratio
- * 2. Pure function prevalence
- * 3. Dependency injection patterns
- * 4. Interface focus (bloated interface detection)
- * 5. Observability (return values vs. external state mutations)
- */
-
 declare function analyzeTestability(options: TestabilityOptions): Promise<TestabilityReport>;
 
 /**

package/dist/index.d.ts

@@ -59,18 +59,6 @@ interface TestabilityReport {
     recommendations: string[];
 }
 
-/**
- * Testability analyzer.
- *
- * Walks the codebase and measures 5 structural dimensions that determine
- * whether AI-generated changes can be safely verified:
- * 1. Test file coverage ratio
- * 2. Pure function prevalence
- * 3. Dependency injection patterns
- * 4. Interface focus (bloated interface detection)
- * 5. Observability (return values vs. external state mutations)
- */
-
 declare function analyzeTestability(options: TestabilityOptions): Promise<TestabilityReport>;
 
 /**