@aiready/core 0.9.25 → 0.9.26

package/dist/index.mjs

@@ -573,6 +573,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,6 +1247,308 @@ 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,
@@ -1064,12 +1560,23 @@ 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,
@@ -1078,8 +1585,10 @@ export {
   formatScore,
   formatToolScore,
   generateHTML,
+  getDebtBreakdown,
   getElapsedTime,
   getFileExtension,
+  getHistorySummary,
   getParser,
   getRating,
   getRatingDisplay,
@@ -1091,6 +1600,7 @@ export {
   isSourceFile,
   loadConfig,
   loadMergedConfig,
+  loadScoreHistory,
   mergeConfigWithDefaults,
   normalizeToolName,
   parseCode,
@@ -1099,5 +1609,6 @@ export {
   predictAcceptanceRate,
   readFileContent,
   resolveOutputPath,
+  saveScoreEntry,
   scanFiles
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.9.25",
+  "version": "0.9.26",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -51,8 +51,8 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/client.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts src/client.ts --format cjs,esm --dts --watch",
+    "build": "tsup src/index.ts src/client.ts --format cjs,esm",
+    "dev": "tsup src/index.ts src/client.ts --format cjs,esm --watch",
     "lint": "eslint src",
     "clean": "rm -rf dist",
     "release": "pnpm build && pnpm publish --no-git-checks"