@aiready/testability 0.4.15 → 0.4.17

package/dist/index.js

@@ -34,82 +34,7 @@ var import_core3 = require("@aiready/core");
 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,
@@ -119,75 +44,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\//,
@@ -201,7 +130,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(
@@ -227,7 +156,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];
     }
@@ -253,9 +182,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) {
@@ -274,19 +203,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/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/testability",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "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.21.15"
+    "@aiready/core": "0.21.17"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/analyzer.ts

@@ -1,26 +1,14 @@
-/**
- * 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)
- */
-
 import {
   scanFiles,
   calculateTestabilityIndex,
   Severity,
   IssueType,
   emitProgress,
+  getParser,
+  Language,
 } from '@aiready/core';
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
-import { parse } from '@typescript-eslint/typescript-estree';
-import type { TSESTree } from '@typescript-eslint/types';
 import type {
   TestabilityOptions,
   TestabilityIssue,
@@ -41,129 +29,7 @@ interface FileAnalysis {
   externalStateMutations: number;
 }
 
-function countMethodsInInterface(
-  node: TSESTree.TSInterfaceDeclaration | TSESTree.TSTypeAliasDeclaration
-): number {
-  // Count method signatures
-  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: TSESTree.ClassDeclaration | TSESTree.ClassExpression
-): boolean {
-  // Look for a constructor with typed parameters (the most common DI pattern)
-  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) {
-        // If constructor takes parameters that are typed class/interface references, that's DI
-        const typedParams = fn.params.filter((p) => {
-          const param = p as any;
-          return (
-            param.typeAnnotation != null ||
-            param.parameter?.typeAnnotation != null
-          );
-        });
-        if (typedParams.length > 0) return true;
-      }
-    }
-  }
-  return false;
-}
-
-function isPureFunction(
-  fn:
-    | TSESTree.FunctionDeclaration
-    | TSESTree.FunctionExpression
-    | TSESTree.ArrowFunctionExpression
-): boolean {
-  let hasReturn = false;
-  let hasSideEffect = false;
-
-  function walk(node: TSESTree.Node) {
-    if (node.type === 'ReturnStatement' && node.argument) hasReturn = true;
-    if (
-      node.type === 'AssignmentExpression' &&
-      node.left.type === 'MemberExpression'
-    )
-      hasSideEffect = true;
-    // Calls to console, process, global objects
-    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;
-
-    // Recurse
-    for (const key of Object.keys(node)) {
-      if (key === 'parent') continue;
-      const child = (node as any)[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; // arrow expression body
-  }
-
-  return hasReturn && !hasSideEffect;
-}
-
-function hasExternalStateMutation(
-  fn:
-    | TSESTree.FunctionDeclaration
-    | TSESTree.FunctionExpression
-    | TSESTree.ArrowFunctionExpression
-): boolean {
-  let found = false;
-  function walk(node: TSESTree.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 as any)[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: string): FileAnalysis {
+async function analyzeFileTestability(filePath: string): Promise<FileAnalysis> {
   const result: FileAnalysis = {
     pureFunctions: 0,
     totalFunctions: 0,
@@ -174,6 +40,9 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
     externalStateMutations: 0,
   };
 
+  const parser = getParser(filePath);
+  if (!parser) return result;
+
   let code: string;
   try {
     code = readFileSync(filePath, 'utf-8');
@@ -181,54 +50,43 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
     return result;
   }
 
-  let ast: TSESTree.Program;
   try {
-    ast = parse(code, {
-      jsx: filePath.endsWith('.tsx') || filePath.endsWith('.jsx'),
-      range: false,
-      loc: false,
-    });
-  } catch {
-    return result;
-  }
-
-  function visit(node: TSESTree.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++;
-    }
+    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 (
-      node.type === 'TSInterfaceDeclaration' ||
-      node.type === 'TSTypeAliasDeclaration'
-    ) {
-      result.totalInterfaces++;
-      const methodCount = countMethodsInInterface(node as any);
-      if (methodCount > 10) result.bloatedInterfaces++;
-    }
+      if (exp.type === 'class') {
+        result.totalClasses++;
+        // Generalized DI heuristic: constructor/initializer with parameters
+        if (exp.parameters && exp.parameters.length > 0) {
+          result.injectionPatterns++;
+        }
+        // Heuristic: bloated classes
+        const total = (exp.methodCount || 0) + (exp.propertyCount || 0);
+        if (total > 5) {
+          result.bloatedInterfaces++;
+        }
+      }
 
-    // Recurse
-    for (const key of Object.keys(node)) {
-      if (key === 'parent') continue;
-      const child = (node as any)[key];
-      if (child && typeof child === 'object') {
-        if (Array.isArray(child)) child.forEach((c) => c?.type && visit(c));
-        else if (child.type) visit(child);
+      if (exp.type === 'interface') {
+        result.totalInterfaces++;
+        // Heuristic: interfaces with many methods/props are considered bloated
+        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;
 }
 
@@ -237,28 +95,30 @@ function analyzeFileTestability(filePath: string): FileAnalysis {
 // ---------------------------------------------------------------------------
 
 function detectTestFramework(rootDir: string): boolean {
-  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;
+  // Check common manifest files
+  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; // built-in
+      try {
+        const content = readFileSync(p, 'utf-8');
+        if (m.deps.some((d) => content.includes(d))) return true;
+      } catch {}
+    }
   }
+  return false;
 }
 
 // ---------------------------------------------------------------------------
@@ -267,6 +127,11 @@ function detectTestFramework(rootDir: string): boolean {
 
 const TEST_PATTERNS = [
   /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /_test\.go$/,
+  /test_.*\.py$/,
+  /.*_test\.py$/,
+  /.*Test\.java$/,
+  /.*Tests\.cs$/,
   /__tests__\//,
   /\/tests?\//,
   /\/e2e\//,
@@ -285,7 +150,7 @@ export async function analyzeTestability(
   // Use core scanFiles which respects .gitignore recursively
   const allFiles = await scanFiles({
     ...options,
-    include: options.include || ['**/*.{ts,tsx,js,jsx}'],
+    include: options.include || ['**/*.{ts,tsx,js,jsx,py,java,cs,go}'],
     includeTests: true,
   });
 
@@ -315,7 +180,7 @@ export async function analyzeTestability(
       options.onProgress
     );
 
-    const a = analyzeFileTestability(f);
+    const a = await analyzeFileTestability(f);
     for (const key of Object.keys(aggregated) as Array<keyof FileAnalysis>) {
       aggregated[key] += a[key];
     }
@@ -348,10 +213,10 @@ export async function analyzeTestability(
       dimension: 'framework',
       severity: Severity.Critical,
       message:
-        'No testing framework detected in package.json — AI changes cannot be verified at all.',
+        'No major testing framework detected — AI changes cannot be safely verified.',
       location: { file: options.rootDir, line: 0 },
       suggestion:
-        'Add Jest, Vitest, or another testing framework as a devDependency.',
+        'Add a testing framework (e.g., Jest, Pytest, JUnit) to enable automated verification.',
     });
   }
 
@@ -373,21 +238,10 @@ export async function analyzeTestability(
       type: IssueType.LowTestability,
       dimension: 'purity',
       severity: Severity.Major,
-      message: `Only ${indexResult.dimensions.purityScore}% of functions are pure — side-effectful functions require complex test setup.`,
+      message: `Only ${indexResult.dimensions.purityScore}% of functions appear pure — side-effectful code is harder for AI to verify safely.`,
       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 — outputs are invisible to unit tests.`,
-      location: { file: options.rootDir, line: 0 },
-      suggestion: 'Prefer returning values over mutating shared state.',
+        'Refactor complex side-effectful logic into pure functions where possible.',
     });
   }