@aiready/testability 0.1.1

package/src/analyzer.ts

@@ -0,0 +1,381 @@
+/**
+ * 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 { readdirSync, statSync, readFileSync, existsSync } from 'fs';
+import { join, extname, basename } from 'path';
+import { parse } from '@typescript-eslint/typescript-estree';
+import type { TSESTree } from '@typescript-eslint/types';
+import { calculateTestabilityIndex } from '@aiready/core';
+import type { TestabilityOptions, TestabilityIssue, TestabilityReport } from './types';
+
+// ---------------------------------------------------------------------------
+// File classification
+// ---------------------------------------------------------------------------
+
+const SRC_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+const DEFAULT_EXCLUDES = ['node_modules', 'dist', '.git', 'coverage', '.turbo', 'build'];
+const TEST_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /__tests__\//,
+  /\/tests?\//,
+  /\/e2e\//,
+  /\/fixtures\//,
+];
+
+function isTestFile(filePath: string, extra?: string[]): boolean {
+  if (TEST_PATTERNS.some(p => p.test(filePath))) return true;
+  if (extra) return extra.some(p => filePath.includes(p));
+  return false;
+}
+
+function isSourceFile(filePath: string): boolean {
+  return SRC_EXTENSIONS.has(extname(filePath));
+}
+
+function collectFiles(
+  dir: string,
+  options: TestabilityOptions,
+  depth = 0,
+): string[] {
+  if (depth > (options.maxDepth ?? 20)) return [];
+  const excludes = [...DEFAULT_EXCLUDES, ...(options.exclude ?? [])];
+  const files: string[] = [];
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    if (excludes.some(ex => entry === ex || entry.includes(ex))) continue;
+    const full = join(dir, entry);
+    let stat;
+    try { stat = statSync(full); } catch { continue; }
+    if (stat.isDirectory()) {
+      files.push(...collectFiles(full, options, depth + 1));
+    } else if (stat.isFile() && isSourceFile(full)) {
+      if (!options.include || options.include.some(p => full.includes(p))) {
+        files.push(full);
+      }
+    }
+  }
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Per-file analysis
+// ---------------------------------------------------------------------------
+
+interface FileAnalysis {
+  pureFunctions: number;
+  totalFunctions: number;
+  injectionPatterns: number;
+  totalClasses: number;
+  bloatedInterfaces: number;
+  totalInterfaces: number;
+  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 {
+  const result: FileAnalysis = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0,
+  };
+
+  let code: string;
+  try { code = readFileSync(filePath, 'utf-8'); } catch { 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++;
+    }
+
+    if (node.type === 'TSInterfaceDeclaration' || node.type === 'TSTypeAliasDeclaration') {
+      result.totalInterfaces++;
+      const methodCount = countMethodsInInterface(node as any);
+      if (methodCount > 10) 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);
+      }
+    }
+  }
+
+  ast.body.forEach(visit);
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Test framework detection
+// ---------------------------------------------------------------------------
+
+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; }
+}
+
+// ---------------------------------------------------------------------------
+// Main analyzer
+// ---------------------------------------------------------------------------
+
+export async function analyzeTestability(
+  options: TestabilityOptions,
+): Promise<TestabilityReport> {
+  const allFiles = collectFiles(options.rootDir, options);
+
+  const sourceFiles = allFiles.filter(f => !isTestFile(f, options.testPatterns));
+  const testFiles = allFiles.filter(f => isTestFile(f, options.testPatterns));
+
+  const aggregated: FileAnalysis = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0,
+  };
+
+  for (const f of sourceFiles) {
+    const a = analyzeFileTestability(f);
+    for (const key of Object.keys(aggregated) as Array<keyof FileAnalysis>) {
+      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,
+  });
+
+  // Build issues
+  const issues: TestabilityIssue[] = [];
+  const minCoverage = options.minCoverageRatio ?? 0.3;
+  const actualRatio = sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
+
+  if (!hasTestFramework) {
+    issues.push({
+      type: 'low-testability',
+      dimension: 'framework',
+      severity: 'critical',
+      message: 'No testing framework detected in package.json — 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: 'low-testability',
+      dimension: 'test-coverage',
+      severity: actualRatio === 0 ? 'critical' : '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: 'low-testability',
+      dimension: 'purity',
+      severity: 'major',
+      message: `Only ${indexResult.dimensions.purityScore}% of functions are pure — 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: 'low-testability',
+      dimension: 'observability',
+      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.',
+    });
+  }
+
+  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,
+  };
+}

package/src/cli.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { analyzeTestability } from './analyzer';
+import { calculateTestabilityScore } from './scoring';
+import type { TestabilityOptions } from './types';
+import chalk from 'chalk';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+import { loadConfig, mergeConfigWithDefaults, resolveOutputPath } from '@aiready/core';
+
+const program = new Command();
+
+program
+  .name('aiready-testability')
+  .description('Measure how safely AI-generated changes can be verified in your codebase')
+  .version('0.1.0')
+  .addHelpText('after', `
+DIMENSIONS MEASURED:
+  Test Coverage       Ratio of test files to source files
+  Function Purity     Pure functions are trivially AI-testable
+  Dependency Inject.  DI makes classes mockable and verifiable
+  Interface Focus     Small interfaces are easier to mock
+  Observability       Functions returning values > mutating state
+
+AI CHANGE SAFETY RATINGS:
+  safe           ✅ AI changes can be safely verified (≥50% coverage + score ≥70)
+  moderate-risk  ⚠️  Some risk — partial test coverage
+  high-risk      🔴 Tests exist but insufficient — AI changes may slip through
+  blind-risk     💀 NO TESTS — AI changes cannot be verified at all
+
+EXAMPLES:
+  aiready-testability .                        # Full analysis
+  aiready-testability src/ --output json       # JSON report
+  aiready-testability . --min-coverage 0.5     # Stricter 50% threshold
+`)
+  .argument('<directory>', 'Directory to analyze')
+  .option('--min-coverage <ratio>', 'Minimum acceptable test/source ratio (default: 0.3)', '0.3')
+  .option('--test-patterns <patterns>', 'Additional test file patterns (comma-separated)')
+  .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(chalk.blue('🧪 Analyzing testability...\n'));
+    const startTime = Date.now();
+
+    const config = await loadConfig(directory);
+    const mergedConfig = mergeConfigWithDefaults(config, {
+      minCoverageRatio: 0.3,
+    });
+
+    const finalOptions: TestabilityOptions = {
+      rootDir: directory,
+      minCoverageRatio: parseFloat(options.minCoverage ?? '0.3') || mergedConfig.minCoverageRatio,
+      testPatterns: options.testPatterns?.split(','),
+      include: options.include?.split(','),
+      exclude: options.exclude?.split(','),
+    };
+
+    const report = await analyzeTestability(finalOptions);
+    const scoring = calculateTestabilityScore(report);
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    if (options.output === 'json') {
+      const payload = { report, score: scoring };
+      const outputPath = resolveOutputPath(
+        options.outputFile,
+        `testability-report-${new Date().toISOString().split('T')[0]}.json`,
+        directory,
+      );
+      const dir = dirname(outputPath);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(outputPath, JSON.stringify(payload, null, 2));
+      console.log(chalk.green(`✓ Report saved to ${outputPath}`));
+    } else {
+      displayConsoleReport(report, scoring, elapsed);
+    }
+  });
+
+program.parse();
+
+function safetyColor(rating: string) {
+  switch (rating) {
+    case 'safe': return chalk.green;
+    case 'moderate-risk': return chalk.yellow;
+    case 'high-risk': return chalk.red;
+    case 'blind-risk': return chalk.bgRed.white;
+    default: return chalk.white;
+  }
+}
+
+function safetyIcon(rating: string) {
+  switch (rating) {
+    case 'safe': return '✅';
+    case 'moderate-risk': return '⚠️ ';
+    case 'high-risk': return '🔴';
+    case 'blind-risk': return '💀';
+    default: return '❓';
+  }
+}
+
+function scoreBar(val: number): string {
+  return '█'.repeat(Math.round(val / 10)).padEnd(10, '░');
+}
+
+function displayConsoleReport(report: any, scoring: any, elapsed: string) {
+  const { summary, rawData, issues, recommendations } = report;
+
+  // The most important banner
+  const safetyRating = summary.aiChangeSafetyRating;
+  console.log(chalk.bold('\n🧪 Testability Analysis\n'));
+
+  if (safetyRating === 'blind-risk') {
+    console.log(chalk.bgRed.white.bold(
+      '  💀 BLIND RISK — NO TESTS DETECTED. AI-GENERATED CHANGES CANNOT BE VERIFIED.  '
+    ));
+    console.log();
+  } else if (safetyRating === 'high-risk') {
+    console.log(chalk.red.bold(`  🔴 HIGH RISK — Insufficient test coverage. AI changes may introduce silent bugs.`));
+    console.log();
+  }
+
+  console.log(`AI Change Safety: ${safetyColor(safetyRating)(`${safetyIcon(safetyRating)} ${safetyRating.toUpperCase()}`)}`);
+  console.log(`Score:            ${chalk.bold(summary.score + '/100')} (${summary.rating})`);
+  console.log(`Source Files:     ${chalk.cyan(rawData.sourceFiles)}   Test Files: ${chalk.cyan(rawData.testFiles)}`);
+  console.log(`Coverage Ratio:   ${chalk.bold(Math.round(summary.coverageRatio * 100) + '%')}`);
+  console.log(`Analysis Time:    ${chalk.gray(elapsed + 's')}\n`);
+
+  console.log(chalk.bold('📐 Dimension Scores\n'));
+  const dims: [string, number][] = [
+    ['Test Coverage', summary.dimensions.testCoverageRatio],
+    ['Function Purity', summary.dimensions.purityScore],
+    ['Dependency Injection', summary.dimensions.dependencyInjectionScore],
+    ['Interface Focus', summary.dimensions.interfaceFocusScore],
+    ['Observability', summary.dimensions.observabilityScore],
+  ];
+  for (const [name, val] of dims) {
+    const color = val >= 70 ? chalk.green : val >= 50 ? chalk.yellow : chalk.red;
+    console.log(`  ${name.padEnd(22)} ${color(scoreBar(val))} ${val}/100`);
+  }
+
+  if (issues.length > 0) {
+    console.log(chalk.bold('\n⚠️  Issues\n'));
+    for (const issue of issues) {
+      const sev = issue.severity === 'critical' ? chalk.red : issue.severity === 'major' ? chalk.yellow : chalk.blue;
+      console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
+      if (issue.suggestion) console.log(`       ${chalk.dim('→')} ${chalk.italic(issue.suggestion)}`);
+      console.log();
+    }
+  }
+
+  if (recommendations.length > 0) {
+    console.log(chalk.bold('💡 Recommendations\n'));
+    recommendations.forEach((rec: string, i: number) => {
+      console.log(`${i + 1}. ${rec}`);
+    });
+  }
+  console.log();
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { analyzeTestability } from './analyzer';
+export { calculateTestabilityScore } from './scoring';
+export type {
+  TestabilityOptions,
+  TestabilityReport,
+  TestabilityIssue,
+} from './types';

package/src/scoring.ts

@@ -0,0 +1,59 @@
+import { calculateTestabilityIndex } from '@aiready/core';
+import type { ToolScoringOutput } from '@aiready/core';
+import type { TestabilityReport } from './types';
+
+/**
+ * Convert testability report into a ToolScoringOutput for the unified score.
+ */
+export function calculateTestabilityScore(report: TestabilityReport): ToolScoringOutput {
+  const { summary, rawData, recommendations } = report;
+
+  const factors: ToolScoringOutput['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: ToolScoringOutput['recommendations'] = 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,
+  };
+}

package/src/types.ts

@@ -0,0 +1,55 @@
+import type { ScanOptions, Issue } from '@aiready/core';
+
+export interface TestabilityOptions {
+  /** Root directory to scan */
+  rootDir: string;
+  /** Minimum test-to-source ratio to consider acceptable (default: 0.3) */
+  minCoverageRatio?: number;
+  /** Custom test file patterns in addition to built-ins */
+  testPatterns?: string[];
+  /** Maximum scan depth */
+  maxDepth?: number;
+  /** File glob patterns to include */
+  include?: string[];
+  /** File glob patterns to exclude */
+  exclude?: string[];
+}
+
+export interface TestabilityIssue extends Issue {
+  type: 'low-testability';
+  /** Category of testability barrier */
+  dimension: 'test-coverage' | 'purity' | 'dependency-injection' | 'interface-focus' | 'observability' | 'framework';
+}
+
+export interface TestabilityReport {
+  summary: {
+    sourceFiles: number;
+    testFiles: number;
+    coverageRatio: number;
+    score: number;
+    rating: 'excellent' | 'good' | 'moderate' | 'poor' | 'unverifiable';
+    /** THE MOST IMPORTANT FIELD: is AI-generated code safe to ship? */
+    aiChangeSafetyRating: 'safe' | 'moderate-risk' | 'high-risk' | 'blind-risk';
+    dimensions: {
+      testCoverageRatio: number;
+      purityScore: number;
+      dependencyInjectionScore: number;
+      interfaceFocusScore: number;
+      observabilityScore: number;
+    };
+  };
+  issues: TestabilityIssue[];
+  rawData: {
+    sourceFiles: number;
+    testFiles: number;
+    pureFunctions: number;
+    totalFunctions: number;
+    injectionPatterns: number;
+    totalClasses: number;
+    bloatedInterfaces: number;
+    totalInterfaces: number;
+    externalStateMutations: number;
+    hasTestFramework: boolean;
+  };
+  recommendations: string[];
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../core/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}