@aiready/core 0.9.25 → 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",
@@ -573,6 +674,200 @@ function formatHours(hours) {
 function formatAcceptanceRate(rate) {
   return `${Math.round(rate * 100)}%`;
 }
+function calculateScoreTrend(history) {
+  if (history.length < 2) {
+    return {
+      direction: "stable",
+      change30Days: 0,
+      change90Days: 0,
+      velocity: 0,
+      projectedScore: history[0]?.overallScore || 100
+    };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3);
+  const ninetyDaysAgo = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1e3);
+  const last30Days = history.filter((e) => new Date(e.timestamp) >= thirtyDaysAgo);
+  const last90Days = history.filter((e) => new Date(e.timestamp) >= ninetyDaysAgo);
+  const currentScore = history[history.length - 1].overallScore;
+  const thirtyDaysAgoScore = last30Days[0]?.overallScore || currentScore;
+  const ninetyDaysAgoScore = last90Days[0]?.overallScore || thirtyDaysAgoScore;
+  const change30Days = currentScore - thirtyDaysAgoScore;
+  const change90Days = currentScore - ninetyDaysAgoScore;
+  const weeksOfData = Math.max(1, history.length / 7);
+  const totalChange = currentScore - history[0].overallScore;
+  const velocity = totalChange / weeksOfData;
+  let direction;
+  if (change30Days > 3) direction = "improving";
+  else if (change30Days < -3) direction = "degrading";
+  else direction = "stable";
+  const projectedScore = Math.max(0, Math.min(100, currentScore + velocity * 4));
+  return {
+    direction,
+    change30Days,
+    change90Days,
+    velocity: Math.round(velocity * 10) / 10,
+    projectedScore: Math.round(projectedScore)
+  };
+}
+function calculateRemediationVelocity(history, currentIssues) {
+  if (history.length < 2) {
+    return {
+      issuesFixedThisWeek: 0,
+      avgIssuesPerWeek: 0,
+      trend: "stable",
+      estimatedCompletionWeeks: currentIssues > 0 ? Infinity : 0
+    };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+  const twoWeeksAgo = new Date(now.getTime() - 14 * 24 * 60 * 60 * 1e3);
+  const thisWeek = history.filter((e) => new Date(e.timestamp) >= oneWeekAgo);
+  const lastWeek = history.filter(
+    (e) => new Date(e.timestamp) >= twoWeeksAgo && new Date(e.timestamp) < oneWeekAgo
+  );
+  const issuesFixedThisWeek = thisWeek.length > 1 ? thisWeek[0].totalIssues - thisWeek[thisWeek.length - 1].totalIssues : 0;
+  const totalIssuesFixed = history[0].totalIssues - history[history.length - 1].totalIssues;
+  const weeksOfData = Math.max(1, history.length / 7);
+  const avgIssuesPerWeek = totalIssuesFixed / weeksOfData;
+  let trend;
+  if (lastWeek.length > 1) {
+    const lastWeekFixed = lastWeek[0].totalIssues - lastWeek[lastWeek.length - 1].totalIssues;
+    if (issuesFixedThisWeek > lastWeekFixed * 1.2) trend = "accelerating";
+    else if (issuesFixedThisWeek < lastWeekFixed * 0.8) trend = "decelerating";
+    else trend = "stable";
+  } else {
+    trend = "stable";
+  }
+  const estimatedCompletionWeeks = avgIssuesPerWeek > 0 ? Math.ceil(currentIssues / avgIssuesPerWeek) : Infinity;
+  return {
+    issuesFixedThisWeek: Math.max(0, issuesFixedThisWeek),
+    avgIssuesPerWeek: Math.round(avgIssuesPerWeek * 10) / 10,
+    trend,
+    estimatedCompletionWeeks
+  };
+}
+function calculateKnowledgeConcentration(files, authorData) {
+  if (files.length === 0) {
+    return {
+      score: 0,
+      rating: "low",
+      analysis: {
+        uniqueConceptFiles: 0,
+        totalFiles: 0,
+        concentrationRatio: 0,
+        singleAuthorFiles: 0,
+        orphanFiles: 0
+      },
+      recommendations: ["No files to analyze"]
+    };
+  }
+  const orphanFiles = files.filter((f) => f.exports < 2 && f.imports < 2).length;
+  const avgExports = files.reduce((sum, f) => sum + f.exports, 0) / files.length;
+  const uniqueConceptFiles = files.filter((f) => f.exports > avgExports * 2).length;
+  const totalExports = files.reduce((sum, f) => sum + f.exports, 0);
+  const concentrationRatio = totalExports > 0 ? uniqueConceptFiles / files.length : 0;
+  let singleAuthorFiles = 0;
+  if (authorData) {
+    for (const files2 of authorData.values()) {
+      if (files2.length === 1) singleAuthorFiles++;
+    }
+  }
+  const orphanRisk = orphanFiles / files.length * 30;
+  const uniqueRisk = concentrationRatio * 40;
+  const singleAuthorRisk = authorData ? singleAuthorFiles / files.length * 30 : 0;
+  const score = Math.min(100, Math.round(orphanRisk + uniqueRisk + singleAuthorRisk));
+  let rating;
+  if (score < 20) rating = "low";
+  else if (score < 40) rating = "moderate";
+  else if (score < 70) rating = "high";
+  else rating = "critical";
+  const recommendations = [];
+  if (orphanFiles > files.length * 0.2) {
+    recommendations.push(`Reduce ${orphanFiles} orphan files by connecting them to main modules`);
+  }
+  if (uniqueConceptFiles > files.length * 0.1) {
+    recommendations.push("Distribute high-export files into more focused modules");
+  }
+  if (authorData && singleAuthorFiles > files.length * 0.3) {
+    recommendations.push("Increase knowledge sharing to reduce single-author dependencies");
+  }
+  return {
+    score,
+    rating,
+    analysis: {
+      uniqueConceptFiles,
+      totalFiles: files.length,
+      concentrationRatio: Math.round(concentrationRatio * 100) / 100,
+      singleAuthorFiles,
+      orphanFiles
+    },
+    recommendations
+  };
+}
+function calculateTechnicalDebtInterest(params) {
+  const { currentMonthlyCost, issues, monthsOpen } = params;
+  const criticalCount = issues.filter((i) => i.severity === "critical").length;
+  const majorCount = issues.filter((i) => i.severity === "major").length;
+  const minorCount = issues.filter((i) => i.severity === "minor").length;
+  const severityWeight = (criticalCount * 3 + majorCount * 2 + minorCount * 1) / Math.max(1, issues.length);
+  const baseRate = 0.02 + severityWeight * 0.01;
+  const timeMultiplier = Math.max(1, 1 + monthsOpen * 0.1);
+  const monthlyRate = baseRate * timeMultiplier;
+  const projectDebt = (principal2, months) => {
+    let debt = principal2;
+    for (let i = 0; i < months; i++) {
+      debt = debt * (1 + monthlyRate);
+    }
+    return Math.round(debt);
+  };
+  const principal = currentMonthlyCost * 12;
+  const projections = {
+    months6: projectDebt(principal, 6),
+    months12: projectDebt(principal, 12),
+    months24: projectDebt(principal, 24)
+  };
+  return {
+    monthlyRate: Math.round(monthlyRate * 1e4) / 100,
+    annualRate: Math.round((Math.pow(1 + monthlyRate, 12) - 1) * 1e4) / 100,
+    principal,
+    projections,
+    monthlyCost: Math.round(currentMonthlyCost * (1 + monthlyRate) * 100) / 100
+  };
+}
+function getDebtBreakdown(patternCost, contextCost, consistencyCost) {
+  const breakdowns = [
+    {
+      category: "Semantic Duplication",
+      currentCost: patternCost,
+      monthlyGrowthRate: 5,
+      // Grows as devs copy-paste
+      priority: patternCost > 1e3 ? "high" : "medium",
+      fixCost: patternCost * 3
+      // Fixing costs 3x current waste
+    },
+    {
+      category: "Context Fragmentation",
+      currentCost: contextCost,
+      monthlyGrowthRate: 3,
+      // Grows with new features
+      priority: contextCost > 500 ? "high" : "medium",
+      fixCost: contextCost * 2.5
+    },
+    {
+      category: "Consistency Issues",
+      currentCost: consistencyCost,
+      monthlyGrowthRate: 2,
+      // Grows with new devs
+      priority: consistencyCost > 200 ? "medium" : "low",
+      fixCost: consistencyCost * 1.5
+    }
+  ];
+  return breakdowns.sort((a, b) => {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return priorityOrder[a.priority] - priorityOrder[b.priority];
+  });
+}
 
 // src/parsers/typescript-parser.ts
 import { parse as parse2 } from "@typescript-eslint/typescript-estree";
@@ -1053,23 +1348,671 @@ function isFileSupported(filePath) {
 function getSupportedLanguages() {
   return ParserFactory.getInstance().getSupportedLanguages();
 }
+
+// src/future-proof-metrics.ts
+function calculateCognitiveLoad(params) {
+  const { linesOfCode, exportCount, importCount, uniqueConcepts, cyclomaticComplexity = 1 } = params;
+  const sizeFactor = {
+    name: "Size Complexity",
+    score: Math.min(100, Math.max(0, (linesOfCode - 50) / 10)),
+    weight: 0.3,
+    description: `${linesOfCode} lines of code`
+  };
+  const interfaceFactor = {
+    name: "Interface Complexity",
+    score: Math.min(100, exportCount * 5),
+    weight: 0.25,
+    description: `${exportCount} exported concepts`
+  };
+  const dependencyFactor = {
+    name: "Dependency Complexity",
+    score: Math.min(100, importCount * 8),
+    weight: 0.25,
+    description: `${importCount} dependencies`
+  };
+  const conceptDensity = linesOfCode > 0 ? uniqueConcepts / linesOfCode : 0;
+  const conceptFactor = {
+    name: "Conceptual Density",
+    score: Math.min(100, conceptDensity * 500),
+    weight: 0.2,
+    description: `${uniqueConcepts} unique concepts`
+  };
+  const factors = [sizeFactor, interfaceFactor, dependencyFactor, conceptFactor];
+  const score = factors.reduce((sum, f) => sum + f.score * f.weight, 0);
+  let rating;
+  if (score < 20) rating = "trivial";
+  else if (score < 40) rating = "easy";
+  else if (score < 60) rating = "moderate";
+  else if (score < 80) rating = "difficult";
+  else rating = "expert";
+  return {
+    score: Math.round(score),
+    rating,
+    factors,
+    rawValues: {
+      size: linesOfCode,
+      complexity: cyclomaticComplexity,
+      dependencyCount: importCount,
+      conceptCount: uniqueConcepts
+    }
+  };
+}
+function calculateSemanticDistance(params) {
+  const { file1, file2, file1Domain, file2Domain, sharedDependencies } = params;
+  const domainDistance = file1Domain === file2Domain ? 0 : file1Domain && file2Domain ? 0.5 : 0.8;
+  const importOverlap = sharedDependencies.length / Math.max(1, Math.min(params.file1Imports.length, params.file2Imports.length));
+  const importDistance = 1 - importOverlap;
+  const distance = domainDistance * 0.4 + importDistance * 0.3 + (sharedDependencies.length > 0 ? 0 : 0.3);
+  let relationship;
+  if (file1 === file2) relationship = "same-file";
+  else if (file1Domain === file2Domain) relationship = "same-domain";
+  else if (sharedDependencies.length > 0) relationship = "cross-domain";
+  else relationship = "unrelated";
+  const pathItems = [file1Domain, ...sharedDependencies, file2Domain].filter((s) => typeof s === "string" && s.length > 0);
+  return {
+    between: [file1, file2],
+    distance: Math.round(distance * 100) / 100,
+    relationship,
+    path: pathItems,
+    reason: relationship === "same-domain" ? `Both in "${file1Domain}" domain` : relationship === "cross-domain" ? `Share ${sharedDependencies.length} dependency(ies)` : "No strong semantic relationship detected"
+  };
+}
+function calculatePatternEntropy(files) {
+  if (files.length === 0) {
+    return {
+      domain: "unknown",
+      entropy: 0,
+      rating: "crystalline",
+      distribution: { locationCount: 0, dominantLocation: "", giniCoefficient: 0 },
+      recommendations: ["No files to analyze"]
+    };
+  }
+  const dirGroups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const parts = file.path.split("/").slice(0, 4).join("/") || "root";
+    dirGroups.set(parts, (dirGroups.get(parts) || 0) + 1);
+  }
+  const counts = Array.from(dirGroups.values());
+  const total = counts.reduce((a, b) => a + b, 0);
+  let entropy = 0;
+  for (const count of counts) {
+    const p = count / total;
+    if (p > 0) entropy -= p * Math.log2(p);
+  }
+  const maxEntropy = Math.log2(dirGroups.size || 1);
+  const normalizedEntropy = maxEntropy > 0 ? entropy / maxEntropy : 0;
+  const sortedCounts = counts.sort((a, b) => a - b);
+  let gini = 0;
+  for (let i = 0; i < sortedCounts.length; i++) {
+    gini += (2 * (i + 1) - sortedCounts.length - 1) * sortedCounts[i];
+  }
+  gini /= total * sortedCounts.length;
+  let dominantLocation = "";
+  let maxCount = 0;
+  for (const [loc, count] of dirGroups.entries()) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominantLocation = loc;
+    }
+  }
+  let rating;
+  if (normalizedEntropy < 0.2) rating = "crystalline";
+  else if (normalizedEntropy < 0.4) rating = "well-structured";
+  else if (normalizedEntropy < 0.6) rating = "moderate";
+  else if (normalizedEntropy < 0.8) rating = "fragmented";
+  else rating = "chaotic";
+  const recommendations = [];
+  if (normalizedEntropy > 0.5) {
+    recommendations.push(`Consolidate ${files.length} files into fewer directories by domain`);
+  }
+  if (dirGroups.size > 5) {
+    recommendations.push("Consider barrel exports to reduce directory navigation");
+  }
+  if (gini > 0.5) {
+    recommendations.push("Redistribute files more evenly across directories");
+  }
+  const firstFile = files.length > 0 ? files[0] : null;
+  const domainValue = firstFile ? firstFile.domain : "mixed";
+  return {
+    domain: domainValue,
+    entropy: Math.round(normalizedEntropy * 100) / 100,
+    rating,
+    distribution: {
+      locationCount: dirGroups.size,
+      dominantLocation,
+      giniCoefficient: Math.round(gini * 100) / 100
+    },
+    recommendations
+  };
+}
+function calculateConceptCohesion(params) {
+  const { exports } = params;
+  if (exports.length === 0) {
+    return {
+      score: 1,
+      rating: "excellent",
+      analysis: { uniqueDomains: 0, domainConcentration: 0, exportPurposeClarity: 1 }
+    };
+  }
+  const allDomains = [];
+  for (const exp of exports) {
+    if (exp.inferredDomain) allDomains.push(exp.inferredDomain);
+    if (exp.domains) allDomains.push(...exp.domains);
+  }
+  const uniqueDomains = new Set(allDomains);
+  const domainCounts = /* @__PURE__ */ new Map();
+  for (const d of allDomains) {
+    domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
+  }
+  const maxCount = Math.max(...Array.from(domainCounts.values()), 1);
+  const domainConcentration = maxCount / allDomains.length;
+  const exportPurposeClarity = 1 - (uniqueDomains.size - 1) / Math.max(1, exports.length);
+  const score = domainConcentration * 0.5 + exportPurposeClarity * 0.5;
+  let rating;
+  if (score > 0.8) rating = "excellent";
+  else if (score > 0.6) rating = "good";
+  else if (score > 0.4) rating = "moderate";
+  else rating = "poor";
+  return {
+    score: Math.round(score * 100) / 100,
+    rating,
+    analysis: {
+      uniqueDomains: uniqueDomains.size,
+      domainConcentration: Math.round(domainConcentration * 100) / 100,
+      exportPurposeClarity: Math.round(exportPurposeClarity * 100) / 100
+    }
+  };
+}
+function calculateFutureProofScore(params) {
+  const loadScore = 100 - params.cognitiveLoad.score;
+  const entropyScore = 100 - params.patternEntropy.entropy * 100;
+  const cohesionScore = params.conceptCohesion.score * 100;
+  const overall = Math.round(
+    loadScore * 0.4 + entropyScore * 0.3 + cohesionScore * 0.3
+  );
+  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
+    }
+  ];
+  const recommendations = [];
+  for (const rec of params.patternEntropy.recommendations) {
+    recommendations.push({
+      action: rec,
+      estimatedImpact: 5,
+      priority: "medium"
+    });
+  }
+  if (params.conceptCohesion.rating === "poor") {
+    recommendations.push({
+      action: "Improve concept cohesion by grouping related exports",
+      estimatedImpact: 8,
+      priority: "high"
+    });
+  }
+  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,
+      semanticDistanceAvg
+    },
+    factors,
+    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";
+import { join as join4, dirname as dirname3 } from "path";
+function getHistoryPath(rootDir) {
+  return join4(rootDir, ".aiready", "history.json");
+}
+function loadScoreHistory(rootDir) {
+  const historyPath = getHistoryPath(rootDir);
+  if (!existsSync4(historyPath)) {
+    return [];
+  }
+  try {
+    const data = readFileSync2(historyPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    console.warn("Failed to load score history:", error);
+    return [];
+  }
+}
+function saveScoreEntry(rootDir, entry) {
+  const historyPath = getHistoryPath(rootDir);
+  const historyDir = dirname3(historyPath);
+  if (!existsSync4(historyDir)) {
+    mkdirSync2(historyDir, { recursive: true });
+  }
+  const history = loadScoreHistory(rootDir);
+  const newEntry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...entry
+  };
+  const oneYearAgo = Date.now() - 365 * 24 * 60 * 60 * 1e3;
+  const filteredHistory = history.filter(
+    (e) => new Date(e.timestamp).getTime() > oneYearAgo
+  );
+  filteredHistory.push(newEntry);
+  writeFileSync2(historyPath, JSON.stringify(filteredHistory, null, 2));
+}
+function getHistorySummary(rootDir) {
+  const history = loadScoreHistory(rootDir);
+  if (history.length === 0) {
+    return {
+      totalScans: 0,
+      firstScan: null,
+      lastScan: null,
+      avgScore: 0
+    };
+  }
+  const scores = history.map((e) => e.overallScore);
+  const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
+  return {
+    totalScans: history.length,
+    firstScan: history[0].timestamp,
+    lastScan: history[history.length - 1].timestamp,
+    avgScore: Math.round(avgScore)
+  };
+}
+function exportHistory(rootDir, format = "json") {
+  const history = loadScoreHistory(rootDir);
+  if (format === "csv") {
+    const headers = "timestamp,overallScore,totalIssues,totalTokens,patternScore,contextScore,consistencyScore\n";
+    const rows = history.map(
+      (e) => `${e.timestamp},${e.overallScore},${e.totalIssues},${e.totalTokens},${e.breakdown?.["pattern-detect"] || ""},${e.breakdown?.["context-analyzer"] || ""},${e.breakdown?.["consistency"] || ""}`
+    ).join("\n");
+    return headers + rows;
+  }
+  return JSON.stringify(history, null, 2);
+}
+function clearHistory(rootDir) {
+  const historyPath = getHistoryPath(rootDir);
+  if (existsSync4(historyPath)) {
+    writeFileSync2(historyPath, JSON.stringify([]));
+  }
+}
 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,
   calculateOverallScore,
+  calculatePatternEntropy,
   calculateProductivityImpact,
+  calculateRemediationVelocity,
+  calculateScoreTrend,
+  calculateSemanticDistance,
+  calculateTechnicalDebtInterest,
+  calculateTestabilityIndex,
+  clearHistory,
   estimateTokens,
+  exportHistory,
   extractFunctions,
   extractImports,
   formatAcceptanceRate,
@@ -1078,11 +2021,17 @@ export {
   formatScore,
   formatToolScore,
   generateHTML,
+  getDebtBreakdown,
   getElapsedTime,
   getFileExtension,
+  getHistorySummary,
+  getModelPreset,
   getParser,
+  getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingWithContext,
+  getRecommendedThreshold,
   getSupportedLanguages,
   getToolWeight,
   handleCLIError,
@@ -1091,6 +2040,7 @@ export {
   isSourceFile,
   loadConfig,
   loadMergedConfig,
+  loadScoreHistory,
   mergeConfigWithDefaults,
   normalizeToolName,
   parseCode,
@@ -1099,5 +2049,6 @@ export {
   predictAcceptanceRate,
   readFileContent,
   resolveOutputPath,
+  saveScoreEntry,
   scanFiles
 };