@aiready/core 0.9.23 → 0.9.26

package/dist/index.mjs

@@ -19,7 +19,8 @@ import {
 import { glob } from "glob";
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
-import { join } from "path";
+import { join, relative } from "path";
+import ignorePkg from "ignore";
 var DEFAULT_EXCLUDE = [
   // Dependencies
   "**/node_modules/**",
@@ -88,6 +89,22 @@ async function scanFiles(options) {
     ignore: finalExclude,
     absolute: true
   });
+  const gitignorePath = join(rootDir || ".", ".gitignore");
+  if (existsSync(gitignorePath)) {
+    try {
+      const gitTxt = await readFile(gitignorePath, "utf-8");
+      const ig = ignorePkg();
+      ig.add(gitTxt);
+      const filtered = files.filter((f) => {
+        let rel = relative(rootDir || ".", f).replace(/\\/g, "/");
+        if (rel === "") rel = f;
+        return !ig.ignores(rel);
+      });
+      return filtered;
+    } catch (e) {
+      return files;
+    }
+  }
   return files;
 }
 async function readFileContent(filePath) {
@@ -396,6 +413,361 @@ function getElapsedTime(startTime) {
   return ((Date.now() - startTime) / 1e3).toFixed(2);
 }
 
+// src/business-metrics.ts
+var DEFAULT_COST_CONFIG = {
+  pricePer1KTokens: 0.01,
+  // $0.01 per 1K tokens (GPT-4)
+  queriesPerDevPerDay: 50,
+  // Average AI queries per developer
+  developerCount: 5,
+  // Default team size
+  daysPerMonth: 30
+};
+var SEVERITY_TIME_ESTIMATES = {
+  critical: 4,
+  // Complex architectural issues
+  major: 2,
+  // Significant refactoring needed
+  minor: 0.5,
+  // Simple naming/style fixes
+  info: 0.25
+  // Documentation improvements
+};
+var DEFAULT_HOURLY_RATE = 75;
+function calculateMonthlyCost(tokenWaste, config = {}) {
+  const cfg = { ...DEFAULT_COST_CONFIG, ...config };
+  const tokensPerDay = tokenWaste * cfg.queriesPerDevPerDay;
+  const tokensPerMonth = tokensPerDay * cfg.daysPerMonth;
+  const cost = tokensPerMonth / 1e3 * cfg.pricePer1KTokens;
+  return Math.round(cost * 100) / 100;
+}
+function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
+  const counts = {
+    critical: issues.filter((i) => i.severity === "critical").length,
+    major: issues.filter((i) => i.severity === "major").length,
+    minor: issues.filter((i) => i.severity === "minor").length,
+    info: issues.filter((i) => i.severity === "info").length
+  };
+  const hours = {
+    critical: counts.critical * SEVERITY_TIME_ESTIMATES.critical,
+    major: counts.major * SEVERITY_TIME_ESTIMATES.major,
+    minor: counts.minor * SEVERITY_TIME_ESTIMATES.minor,
+    info: counts.info * SEVERITY_TIME_ESTIMATES.info
+  };
+  const totalHours = hours.critical + hours.major + hours.minor + hours.info;
+  const totalCost = totalHours * hourlyRate;
+  return {
+    totalHours: Math.round(totalHours * 10) / 10,
+    hourlyRate,
+    totalCost: Math.round(totalCost),
+    bySeverity: {
+      critical: { hours: Math.round(hours.critical * 10) / 10, cost: Math.round(hours.critical * hourlyRate) },
+      major: { hours: Math.round(hours.major * 10) / 10, cost: Math.round(hours.major * hourlyRate) },
+      minor: { hours: Math.round(hours.minor * 10) / 10, cost: Math.round(hours.minor * hourlyRate) }
+    }
+  };
+}
+function predictAcceptanceRate(toolOutputs) {
+  const factors = [];
+  const patterns = toolOutputs.get("pattern-detect");
+  if (patterns) {
+    const patternImpact = (patterns.score - 50) * 0.3;
+    factors.push({
+      name: "Semantic Duplication",
+      impact: Math.round(patternImpact)
+    });
+  }
+  const context = toolOutputs.get("context-analyzer");
+  if (context) {
+    const contextImpact = (context.score - 50) * 0.4;
+    factors.push({
+      name: "Context Efficiency",
+      impact: Math.round(contextImpact)
+    });
+  }
+  const consistency = toolOutputs.get("consistency");
+  if (consistency) {
+    const consistencyImpact = (consistency.score - 50) * 0.3;
+    factors.push({
+      name: "Code Consistency",
+      impact: Math.round(consistencyImpact)
+    });
+  }
+  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;
+  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));
+  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));
+  const score = Math.round(
+    budgetFactor * 0.35 + depthFactor * 0.2 + fragmentationFactor * 0.2 + consistencyFactor * 0.15 + fileFactor * 0.1
+  );
+  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,
+    rating,
+    factors: [
+      {
+        name: "Context Budget",
+        contribution: Math.round(budgetFactor * 0.35),
+        description: `${Math.round(contextBudget)} tokens required`
+      },
+      {
+        name: "Import Depth",
+        contribution: Math.round(depthFactor * 0.2),
+        description: `${importDepth.toFixed(1)} average levels`
+      },
+      {
+        name: "Code Fragmentation",
+        contribution: Math.round(fragmentationFactor * 0.2),
+        description: `${(fragmentation * 100).toFixed(0)}% fragmentation`
+      },
+      {
+        name: "Consistency",
+        contribution: Math.round(consistencyFactor * 0.15),
+        description: `${consistencyScore}/100 consistency score`
+      },
+      {
+        name: "Project Scale",
+        contribution: Math.round(fileFactor * 0.1),
+        description: `${totalFiles} files analyzed`
+      }
+    ]
+  };
+}
+function formatCost(cost) {
+  if (cost < 1) {
+    return `$${cost.toFixed(2)}`;
+  } else if (cost < 1e3) {
+    return `$${cost.toFixed(0)}`;
+  } else {
+    return `$${(cost / 1e3).toFixed(1)}k`;
+  }
+}
+function formatHours(hours) {
+  if (hours < 1) {
+    return `${Math.round(hours * 60)}min`;
+  } else if (hours < 8) {
+    return `${hours.toFixed(1)}h`;
+  } else if (hours < 40) {
+    return `${Math.round(hours)}h`;
+  } else {
+    return `${(hours / 40).toFixed(1)} weeks`;
+  }
+}
+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";
 var TypeScriptParser = class {
@@ -875,7 +1247,310 @@ 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
+  };
+}
+
+// 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 {
+  DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
   LANGUAGE_EXTENSIONS,
@@ -885,16 +1560,35 @@ export {
   PythonParser,
   TOOL_NAME_MAP,
   TypeScriptParser,
+  calculateCognitiveLoad,
+  calculateComprehensionDifficulty,
+  calculateConceptCohesion,
+  calculateFutureProofScore,
   calculateImportSimilarity,
+  calculateKnowledgeConcentration,
+  calculateMonthlyCost,
   calculateOverallScore,
+  calculatePatternEntropy,
+  calculateProductivityImpact,
+  calculateRemediationVelocity,
+  calculateScoreTrend,
+  calculateSemanticDistance,
+  calculateTechnicalDebtInterest,
+  clearHistory,
   estimateTokens,
+  exportHistory,
   extractFunctions,
   extractImports,
+  formatAcceptanceRate,
+  formatCost,
+  formatHours,
   formatScore,
   formatToolScore,
   generateHTML,
+  getDebtBreakdown,
   getElapsedTime,
   getFileExtension,
+  getHistorySummary,
   getParser,
   getRating,
   getRatingDisplay,
@@ -906,12 +1600,15 @@ export {
   isSourceFile,
   loadConfig,
   loadMergedConfig,
+  loadScoreHistory,
   mergeConfigWithDefaults,
   normalizeToolName,
   parseCode,
   parseFileExports,
   parseWeightString,
+  predictAcceptanceRate,
   readFileContent,
   resolveOutputPath,
+  saveScoreEntry,
   scanFiles
 };