@aiready/core 0.9.26 → 0.9.27

package/dist/index.mjs

@@ -1,19 +1,24 @@
 import {
+  CONTEXT_TIER_THRESHOLDS,
   DEFAULT_TOOL_WEIGHTS,
   LANGUAGE_EXTENSIONS,
   Language,
   ParseError,
+  SIZE_ADJUSTED_THRESHOLDS,
   TOOL_NAME_MAP,
   calculateOverallScore,
   formatScore,
   formatToolScore,
   generateHTML,
+  getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingWithContext,
+  getRecommendedThreshold,
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-HKSARRCD.mjs";
+} from "./chunk-JJ5JL5FX.mjs";
 
 // src/utils/file-scanner.ts
 import { glob } from "glob";
@@ -414,11 +419,87 @@ function getElapsedTime(startTime) {
 }
 
 // src/business-metrics.ts
+var MODEL_PRICING_PRESETS = {
+  "gpt-4": {
+    name: "GPT-4",
+    pricePer1KInputTokens: 0.03,
+    pricePer1KOutputTokens: 0.06,
+    contextTier: "standard",
+    typicalQueriesPerDevPerDay: 40
+  },
+  "gpt-4o": {
+    name: "GPT-4o",
+    pricePer1KInputTokens: 5e-3,
+    pricePer1KOutputTokens: 0.015,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 60
+  },
+  "gpt-4o-mini": {
+    name: "GPT-4o mini",
+    pricePer1KInputTokens: 15e-5,
+    pricePer1KOutputTokens: 6e-4,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 120
+  },
+  "claude-3-5-sonnet": {
+    name: "Claude 3.5 Sonnet",
+    pricePer1KInputTokens: 3e-3,
+    pricePer1KOutputTokens: 0.015,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 80
+  },
+  "claude-3-7-sonnet": {
+    name: "Claude 3.7 Sonnet",
+    pricePer1KInputTokens: 3e-3,
+    pricePer1KOutputTokens: 0.015,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 80
+  },
+  "claude-sonnet-4": {
+    name: "Claude Sonnet 4",
+    pricePer1KInputTokens: 3e-3,
+    pricePer1KOutputTokens: 0.015,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 80
+  },
+  "gemini-1-5-pro": {
+    name: "Gemini 1.5 Pro",
+    pricePer1KInputTokens: 125e-5,
+    pricePer1KOutputTokens: 5e-3,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 80
+  },
+  "gemini-2-0-flash": {
+    name: "Gemini 2.0 Flash",
+    pricePer1KInputTokens: 1e-4,
+    pricePer1KOutputTokens: 4e-4,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 150
+  },
+  "copilot": {
+    name: "GitHub Copilot (subscription)",
+    // Amortized per-request cost for a $19/month plan at 80 queries/day
+    pricePer1KInputTokens: 1e-4,
+    pricePer1KOutputTokens: 1e-4,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 80
+  },
+  "cursor-pro": {
+    name: "Cursor Pro (subscription)",
+    pricePer1KInputTokens: 1e-4,
+    pricePer1KOutputTokens: 1e-4,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 100
+  }
+};
+function getModelPreset(modelId) {
+  return MODEL_PRICING_PRESETS[modelId] ?? MODEL_PRICING_PRESETS["gpt-4o"];
+}
 var DEFAULT_COST_CONFIG = {
-  pricePer1KTokens: 0.01,
-  // $0.01 per 1K tokens (GPT-4)
-  queriesPerDevPerDay: 50,
-  // Average AI queries per developer
+  pricePer1KTokens: 5e-3,
+  // GPT-4o input price (updated from GPT-4 era 0.01)
+  queriesPerDevPerDay: 60,
+  // Average AI queries per developer (updated: 40→60 as of 2026)
   developerCount: 5,
   // Default team size
   daysPerMonth: 30
@@ -469,43 +550,63 @@ function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
 }
 function predictAcceptanceRate(toolOutputs) {
   const factors = [];
+  const baseRate = 0.3;
   const patterns = toolOutputs.get("pattern-detect");
   if (patterns) {
-    const patternImpact = (patterns.score - 50) * 0.3;
+    const patternImpact = (patterns.score - 50) * 3e-3;
     factors.push({
       name: "Semantic Duplication",
-      impact: Math.round(patternImpact)
+      impact: Math.round(patternImpact * 100)
     });
   }
   const context = toolOutputs.get("context-analyzer");
   if (context) {
-    const contextImpact = (context.score - 50) * 0.4;
+    const contextImpact = (context.score - 50) * 4e-3;
     factors.push({
       name: "Context Efficiency",
-      impact: Math.round(contextImpact)
+      impact: Math.round(contextImpact * 100)
     });
   }
   const consistency = toolOutputs.get("consistency");
   if (consistency) {
-    const consistencyImpact = (consistency.score - 50) * 0.3;
+    const consistencyImpact = (consistency.score - 50) * 2e-3;
     factors.push({
       name: "Code Consistency",
-      impact: Math.round(consistencyImpact)
+      impact: Math.round(consistencyImpact * 100)
+    });
+  }
+  const hallucinationRisk = toolOutputs.get("hallucination-risk");
+  if (hallucinationRisk) {
+    const hrImpact = (50 - hallucinationRisk.score) * 2e-3;
+    factors.push({
+      name: "Hallucination Risk",
+      impact: Math.round(hrImpact * 100)
     });
   }
-  const baseRate = 0.65;
   const totalImpact = factors.reduce((sum, f) => sum + f.impact / 100, 0);
-  const rate = Math.max(0.1, Math.min(0.95, baseRate + totalImpact));
-  const confidence = toolOutputs.size >= 3 ? 0.8 : toolOutputs.size >= 2 ? 0.6 : 0.4;
+  const rate = Math.max(0.05, Math.min(0.8, baseRate + totalImpact));
+  let confidence;
+  if (toolOutputs.size >= 4) confidence = 0.75;
+  else if (toolOutputs.size >= 3) confidence = 0.65;
+  else if (toolOutputs.size >= 2) confidence = 0.5;
+  else confidence = 0.35;
   return {
     rate: Math.round(rate * 100) / 100,
     confidence,
     factors
   };
 }
-function calculateComprehensionDifficulty(contextBudget, importDepth, fragmentation, consistencyScore, totalFiles) {
-  const budgetFactor = Math.min(100, Math.max(0, (contextBudget - 5e3) / 250));
-  const depthFactor = Math.min(100, Math.max(0, (importDepth - 5) * 10));
+function calculateComprehensionDifficulty(contextBudget, importDepth, fragmentation, consistencyScore, totalFiles, modelTier = "standard") {
+  const tierThresholds = CONTEXT_TIER_THRESHOLDS[modelTier];
+  const idealBudget = tierThresholds.idealTokens;
+  const criticalBudget = tierThresholds.criticalTokens;
+  const idealDepth = tierThresholds.idealDepth;
+  const budgetRange = criticalBudget - idealBudget;
+  const budgetFactor = Math.min(100, Math.max(
+    0,
+    (contextBudget - idealBudget) / budgetRange * 100
+  ));
+  const depthFactor = Math.min(100, Math.max(0, (importDepth - idealDepth) * 10));
   const fragmentationFactor = Math.min(100, Math.max(0, (fragmentation - 0.3) * 250));
   const consistencyFactor = Math.min(100, Math.max(0, 100 - consistencyScore));
   const fileFactor = Math.min(100, Math.max(0, (totalFiles - 50) / 5));
@@ -525,12 +626,12 @@ function calculateComprehensionDifficulty(contextBudget, importDepth, fragmentat
       {
         name: "Context Budget",
         contribution: Math.round(budgetFactor * 0.35),
-        description: `${Math.round(contextBudget)} tokens required`
+        description: `${Math.round(contextBudget)} tokens required (${modelTier} model tier: ideal <${idealBudget.toLocaleString()})`
       },
       {
         name: "Import Depth",
         contribution: Math.round(depthFactor * 0.2),
-        description: `${importDepth.toFixed(1)} average levels`
+        description: `${importDepth.toFixed(1)} average levels (ideal <${idealDepth} for ${modelTier})`
       },
       {
         name: "Code Fragmentation",
@@ -1475,6 +1576,334 @@ function calculateFutureProofScore(params) {
     recommendations
   };
 }
+function calculateHallucinationRisk(params) {
+  const {
+    overloadedSymbols,
+    magicLiterals,
+    booleanTraps,
+    implicitSideEffects,
+    deepCallbacks,
+    ambiguousNames,
+    undocumentedExports,
+    totalSymbols,
+    totalExports
+  } = params;
+  if (totalSymbols === 0) {
+    return {
+      score: 0,
+      rating: "minimal",
+      signals: [],
+      topRisk: "No symbols to analyze",
+      recommendations: []
+    };
+  }
+  const overloadRatio = Math.min(1, overloadedSymbols / Math.max(1, totalSymbols));
+  const overloadSignal = {
+    name: "Symbol Overloading",
+    count: overloadedSymbols,
+    riskContribution: Math.round(overloadRatio * 100 * 0.25),
+    // 25% weight
+    description: `${overloadedSymbols} overloaded symbols \u2014 AI picks wrong signature`
+  };
+  const magicRatio = Math.min(1, magicLiterals / Math.max(1, totalSymbols * 2));
+  const magicSignal = {
+    name: "Magic Literals",
+    count: magicLiterals,
+    riskContribution: Math.round(magicRatio * 100 * 0.2),
+    // 20% weight
+    description: `${magicLiterals} unnamed constants \u2014 AI invents wrong values`
+  };
+  const trapRatio = Math.min(1, booleanTraps / Math.max(1, totalSymbols));
+  const trapSignal = {
+    name: "Boolean Traps",
+    count: booleanTraps,
+    riskContribution: Math.round(trapRatio * 100 * 0.2),
+    // 20% weight
+    description: `${booleanTraps} boolean trap parameters \u2014 AI inverts intent`
+  };
+  const sideEffectRatio = Math.min(1, implicitSideEffects / Math.max(1, totalExports));
+  const sideEffectSignal = {
+    name: "Implicit Side Effects",
+    count: implicitSideEffects,
+    riskContribution: Math.round(sideEffectRatio * 100 * 0.15),
+    // 15% weight
+    description: `${implicitSideEffects} functions with implicit side effects \u2014 AI misses contracts`
+  };
+  const callbackRatio = Math.min(1, deepCallbacks / Math.max(1, totalSymbols * 0.1));
+  const callbackSignal = {
+    name: "Callback Nesting",
+    count: deepCallbacks,
+    riskContribution: Math.round(callbackRatio * 100 * 0.1),
+    // 10% weight
+    description: `${deepCallbacks} deep callback chains \u2014 AI loses control flow context`
+  };
+  const ambiguousRatio = Math.min(1, ambiguousNames / Math.max(1, totalSymbols));
+  const ambiguousSignal = {
+    name: "Ambiguous Names",
+    count: ambiguousNames,
+    riskContribution: Math.round(ambiguousRatio * 100 * 0.1),
+    // 10% weight
+    description: `${ambiguousNames} non-descriptive identifiers \u2014 AI guesses wrong intent`
+  };
+  const undocRatio = Math.min(1, undocumentedExports / Math.max(1, totalExports));
+  const undocSignal = {
+    name: "Undocumented Exports",
+    count: undocumentedExports,
+    riskContribution: Math.round(undocRatio * 100 * 0.1),
+    // 10% weight
+    description: `${undocumentedExports} public functions without docs \u2014 AI fabricates behavior`
+  };
+  const signals = [
+    overloadSignal,
+    magicSignal,
+    trapSignal,
+    sideEffectSignal,
+    callbackSignal,
+    ambiguousSignal,
+    undocSignal
+  ];
+  const score = Math.min(100, signals.reduce((sum, s) => sum + s.riskContribution, 0));
+  let rating;
+  if (score < 10) rating = "minimal";
+  else if (score < 25) rating = "low";
+  else if (score < 50) rating = "moderate";
+  else if (score < 75) rating = "high";
+  else rating = "severe";
+  const topSignal = signals.reduce((a, b) => a.riskContribution > b.riskContribution ? a : b);
+  const topRisk = topSignal.riskContribution > 0 ? topSignal.description : "No significant hallucination risks detected";
+  const recommendations = [];
+  if (overloadSignal.riskContribution > 5) {
+    recommendations.push(`Rename ${overloadedSymbols} overloaded symbols to unique, intent-revealing names`);
+  }
+  if (magicSignal.riskContribution > 5) {
+    recommendations.push(`Extract ${magicLiterals} magic literals into named constants`);
+  }
+  if (trapSignal.riskContribution > 5) {
+    recommendations.push(`Replace ${booleanTraps} boolean traps with named options objects`);
+  }
+  if (undocSignal.riskContribution > 5) {
+    recommendations.push(`Add JSDoc/docstrings to ${undocumentedExports} undocumented public functions`);
+  }
+  if (sideEffectSignal.riskContribution > 5) {
+    recommendations.push("Mark functions with side effects explicitly in their names or docs");
+  }
+  return {
+    score: Math.round(score),
+    rating,
+    signals: signals.filter((s) => s.count > 0),
+    topRisk,
+    recommendations
+  };
+}
+function calculateAgentGrounding(params) {
+  const {
+    deepDirectories,
+    totalDirectories,
+    vagueFileNames,
+    totalFiles,
+    hasRootReadme,
+    readmeIsFresh,
+    barrelExports,
+    untypedExports,
+    totalExports,
+    inconsistentDomainTerms,
+    domainVocabularySize
+  } = params;
+  const deepDirRatio = totalDirectories > 0 ? deepDirectories / totalDirectories : 0;
+  const structureClarityScore = Math.max(0, Math.round(100 - deepDirRatio * 80));
+  const vagueRatio = totalFiles > 0 ? vagueFileNames / totalFiles : 0;
+  const selfDocumentationScore = Math.max(0, Math.round(100 - vagueRatio * 90));
+  let entryPointScore = 60;
+  if (hasRootReadme) entryPointScore += 25;
+  if (readmeIsFresh) entryPointScore += 10;
+  const barrelRatio = totalFiles > 0 ? barrelExports / (totalFiles * 0.1) : 0;
+  entryPointScore += Math.round(Math.min(5, barrelRatio * 5));
+  entryPointScore = Math.min(100, entryPointScore);
+  const untypedRatio = totalExports > 0 ? untypedExports / totalExports : 0;
+  const apiClarityScore = Math.max(0, Math.round(100 - untypedRatio * 70));
+  const inconsistencyRatio = domainVocabularySize > 0 ? inconsistentDomainTerms / domainVocabularySize : 0;
+  const domainConsistencyScore = Math.max(0, Math.round(100 - inconsistencyRatio * 80));
+  const score = Math.round(
+    structureClarityScore * 0.2 + selfDocumentationScore * 0.25 + entryPointScore * 0.2 + apiClarityScore * 0.15 + domainConsistencyScore * 0.2
+  );
+  let rating;
+  if (score >= 85) rating = "excellent";
+  else if (score >= 70) rating = "good";
+  else if (score >= 50) rating = "moderate";
+  else if (score >= 30) rating = "poor";
+  else rating = "disorienting";
+  const recommendations = [];
+  if (structureClarityScore < 70) {
+    recommendations.push(`Flatten ${deepDirectories} overly-deep directories to improve agent navigation`);
+  }
+  if (selfDocumentationScore < 70) {
+    recommendations.push(`Rename ${vagueFileNames} vague files (utils, helpers, misc) to domain-specific names`);
+  }
+  if (!hasRootReadme) {
+    recommendations.push("Add a root README.md so agents understand the project context immediately");
+  } else if (!readmeIsFresh) {
+    recommendations.push("Update README.md \u2014 stale entry-point documentation disorients agents");
+  }
+  if (apiClarityScore < 70) {
+    recommendations.push(`Add TypeScript types to ${untypedExports} untyped exports to improve API discoverability`);
+  }
+  if (domainConsistencyScore < 70) {
+    recommendations.push(`Unify ${inconsistentDomainTerms} inconsistent domain terms \u2014 agents need one word per concept`);
+  }
+  return {
+    score,
+    rating,
+    dimensions: {
+      structureClarityScore,
+      selfDocumentationScore,
+      entryPointScore,
+      apiClarityScore,
+      domainConsistencyScore
+    },
+    recommendations
+  };
+}
+function calculateTestabilityIndex(params) {
+  const {
+    testFiles,
+    sourceFiles,
+    pureFunctions,
+    totalFunctions,
+    injectionPatterns,
+    totalClasses,
+    bloatedInterfaces,
+    totalInterfaces,
+    externalStateMutations,
+    hasTestFramework
+  } = params;
+  const rawCoverageRatio = sourceFiles > 0 ? testFiles / sourceFiles : 0;
+  const testCoverageRatio = Math.min(100, Math.round(rawCoverageRatio * 100));
+  const purityRatio = totalFunctions > 0 ? pureFunctions / totalFunctions : 0.5;
+  const purityScore = Math.round(purityRatio * 100);
+  const injectionRatio = totalClasses > 0 ? injectionPatterns / totalClasses : 0.5;
+  const dependencyInjectionScore = Math.round(Math.min(100, injectionRatio * 100));
+  const bloatedRatio = totalInterfaces > 0 ? bloatedInterfaces / totalInterfaces : 0;
+  const interfaceFocusScore = Math.max(0, Math.round(100 - bloatedRatio * 80));
+  const mutationRatio = totalFunctions > 0 ? externalStateMutations / totalFunctions : 0;
+  const observabilityScore = Math.max(0, Math.round(100 - mutationRatio * 100));
+  const frameworkWeight = hasTestFramework ? 1 : 0.8;
+  const rawScore = (testCoverageRatio * 0.3 + purityScore * 0.25 + dependencyInjectionScore * 0.2 + interfaceFocusScore * 0.1 + observabilityScore * 0.15) * frameworkWeight;
+  const score = Math.max(0, Math.min(100, Math.round(rawScore)));
+  let rating;
+  if (score >= 85) rating = "excellent";
+  else if (score >= 70) rating = "good";
+  else if (score >= 50) rating = "moderate";
+  else if (score >= 30) rating = "poor";
+  else rating = "unverifiable";
+  let aiChangeSafetyRating;
+  if (rawCoverageRatio >= 0.5 && score >= 70) aiChangeSafetyRating = "safe";
+  else if (rawCoverageRatio >= 0.2 && score >= 50) aiChangeSafetyRating = "moderate-risk";
+  else if (rawCoverageRatio > 0) aiChangeSafetyRating = "high-risk";
+  else aiChangeSafetyRating = "blind-risk";
+  const recommendations = [];
+  if (!hasTestFramework) {
+    recommendations.push("Add a testing framework (Jest, Vitest, pytest) \u2014 AI changes cannot be verified without tests");
+  }
+  if (rawCoverageRatio < 0.3) {
+    const neededTests = Math.round(sourceFiles * 0.3 - testFiles);
+    recommendations.push(`Add ~${neededTests} test files to reach 30% coverage ratio \u2014 minimum for safe AI assistance`);
+  }
+  if (purityScore < 50) {
+    recommendations.push("Extract pure functions from side-effectful code \u2014 pure functions are trivially AI-testable");
+  }
+  if (dependencyInjectionScore < 50 && totalClasses > 0) {
+    recommendations.push("Adopt dependency injection \u2014 makes classes mockable and AI-generated code verifiable");
+  }
+  if (externalStateMutations > totalFunctions * 0.3) {
+    recommendations.push("Reduce direct state mutations \u2014 return values instead to improve observability");
+  }
+  return {
+    score,
+    rating,
+    dimensions: {
+      testCoverageRatio,
+      purityScore,
+      dependencyInjectionScore,
+      interfaceFocusScore,
+      observabilityScore
+    },
+    aiChangeSafetyRating,
+    recommendations
+  };
+}
+function calculateExtendedFutureProofScore(params) {
+  const loadScore = 100 - params.cognitiveLoad.score;
+  const entropyScore = 100 - params.patternEntropy.entropy * 100;
+  const cohesionScore = params.conceptCohesion.score * 100;
+  const hallucinationScore = 100 - params.hallucinationRisk.score;
+  const groundingScore = params.agentGrounding.score;
+  const testabilityScore = params.testability.score;
+  const overall = Math.round(
+    loadScore * 0.2 + entropyScore * 0.15 + cohesionScore * 0.15 + hallucinationScore * 0.2 + groundingScore * 0.15 + testabilityScore * 0.15
+  );
+  const factors = [
+    {
+      name: "Cognitive Load",
+      impact: Math.round(loadScore - 50),
+      description: params.cognitiveLoad.rating
+    },
+    {
+      name: "Pattern Entropy",
+      impact: Math.round(entropyScore - 50),
+      description: params.patternEntropy.rating
+    },
+    {
+      name: "Concept Cohesion",
+      impact: Math.round(cohesionScore - 50),
+      description: params.conceptCohesion.rating
+    },
+    {
+      name: "Hallucination Risk",
+      impact: Math.round(hallucinationScore - 50),
+      description: `${params.hallucinationRisk.rating} risk (${params.hallucinationRisk.score}/100 raw)`
+    },
+    {
+      name: "Agent Grounding",
+      impact: Math.round(groundingScore - 50),
+      description: params.agentGrounding.rating
+    },
+    {
+      name: "Testability",
+      impact: Math.round(testabilityScore - 50),
+      description: `${params.testability.rating} \u2014 AI changes are ${params.testability.aiChangeSafetyRating}`
+    }
+  ];
+  const recommendations = [];
+  for (const rec of params.hallucinationRisk.recommendations) {
+    recommendations.push({ action: rec, estimatedImpact: 8, priority: "high" });
+  }
+  for (const rec of params.agentGrounding.recommendations) {
+    recommendations.push({ action: rec, estimatedImpact: 6, priority: "medium" });
+  }
+  for (const rec of params.testability.recommendations) {
+    const priority = params.testability.aiChangeSafetyRating === "blind-risk" ? "high" : "medium";
+    recommendations.push({ action: rec, estimatedImpact: 10, priority });
+  }
+  for (const rec of params.patternEntropy.recommendations) {
+    recommendations.push({ action: rec, estimatedImpact: 5, priority: "low" });
+  }
+  const semanticDistanceAvg = params.semanticDistances && params.semanticDistances.length > 0 ? params.semanticDistances.reduce((s, d) => s + d.distance, 0) / params.semanticDistances.length : 0;
+  return {
+    toolName: "future-proof",
+    score: overall,
+    rawMetrics: {
+      cognitiveLoadScore: params.cognitiveLoad.score,
+      entropyScore: params.patternEntropy.entropy,
+      cohesionScore: params.conceptCohesion.score,
+      hallucinationRiskScore: params.hallucinationRisk.score,
+      agentGroundingScore: params.agentGrounding.score,
+      testabilityScore: params.testability.score,
+      semanticDistanceAvg
+    },
+    factors,
+    recommendations
+  };
+}
 
 // src/utils/history.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
@@ -1550,20 +1979,26 @@ function clearHistory(rootDir) {
   }
 }
 export {
+  CONTEXT_TIER_THRESHOLDS,
   DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
   LANGUAGE_EXTENSIONS,
   Language,
+  MODEL_PRICING_PRESETS,
   ParseError,
   ParserFactory,
   PythonParser,
+  SIZE_ADJUSTED_THRESHOLDS,
   TOOL_NAME_MAP,
   TypeScriptParser,
+  calculateAgentGrounding,
   calculateCognitiveLoad,
   calculateComprehensionDifficulty,
   calculateConceptCohesion,
+  calculateExtendedFutureProofScore,
   calculateFutureProofScore,
+  calculateHallucinationRisk,
   calculateImportSimilarity,
   calculateKnowledgeConcentration,
   calculateMonthlyCost,
@@ -1574,6 +2009,7 @@ export {
   calculateScoreTrend,
   calculateSemanticDistance,
   calculateTechnicalDebtInterest,
+  calculateTestabilityIndex,
   clearHistory,
   estimateTokens,
   exportHistory,
@@ -1589,9 +2025,13 @@ export {
   getElapsedTime,
   getFileExtension,
   getHistorySummary,
+  getModelPreset,
   getParser,
+  getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingWithContext,
+  getRecommendedThreshold,
   getSupportedLanguages,
   getToolWeight,
   handleCLIError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.9.26",
+  "version": "0.9.27",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",