depwire-cli 0.5.0 → 0.6.1

package/dist/{chunk-Q733EWFA.js → chunk-S3RUBXRF.js}

@@ -2638,12 +2638,501 @@ async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
   }
 }
 
+// src/health/metrics.ts
+import { dirname as dirname6 } from "path";
+function scoreToGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function calculateCouplingScore(graph) {
+  const files = /* @__PURE__ */ new Set();
+  graph.forEachNode((node, attrs) => {
+    files.add(attrs.filePath);
+  });
+  if (files.size === 0) {
+    return {
+      name: "Coupling",
+      score: 100,
+      weight: 0.25,
+      grade: "A",
+      details: "No files to analyze",
+      metrics: { avgConnections: 0, maxConnections: 0, crossDirCoupling: 0 }
+    };
+  }
+  const fileConnections = /* @__PURE__ */ new Map();
+  let crossDirEdges = 0;
+  let totalEdges = 0;
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceAttrs = graph.getNodeAttributes(source);
+    const targetAttrs = graph.getNodeAttributes(target);
+    if (sourceAttrs.filePath !== targetAttrs.filePath) {
+      totalEdges++;
+      fileConnections.set(sourceAttrs.filePath, (fileConnections.get(sourceAttrs.filePath) || 0) + 1);
+      fileConnections.set(targetAttrs.filePath, (fileConnections.get(targetAttrs.filePath) || 0) + 1);
+      const sourceDir = dirname6(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname6(targetAttrs.filePath).split("/")[0];
+      if (sourceDir !== targetDir) {
+        crossDirEdges++;
+      }
+    }
+  });
+  const avgConnections = totalEdges / files.size;
+  const maxConnections = Math.max(...Array.from(fileConnections.values()), 0);
+  const crossDirCoupling = totalEdges > 0 ? crossDirEdges / totalEdges : 0;
+  let score = 100;
+  if (avgConnections <= 3) {
+    score = 100;
+  } else if (avgConnections <= 6) {
+    score = 80;
+  } else if (avgConnections <= 10) {
+    score = 60;
+  } else if (avgConnections <= 15) {
+    score = 40;
+  } else {
+    score = 20;
+  }
+  if (maxConnections > avgConnections * 3) {
+    score -= 10;
+  }
+  if (crossDirCoupling > 0.7) {
+    score -= 10;
+  }
+  score = Math.max(0, Math.min(100, score));
+  return {
+    name: "Coupling",
+    score,
+    weight: 0.25,
+    grade: scoreToGrade(score),
+    details: `Average ${avgConnections.toFixed(1)} connections per file, max ${maxConnections}, ${(crossDirCoupling * 100).toFixed(0)}% cross-directory`,
+    metrics: {
+      avgConnections: parseFloat(avgConnections.toFixed(2)),
+      maxConnections,
+      crossDirCoupling: parseFloat((crossDirCoupling * 100).toFixed(1))
+    }
+  };
+}
+function calculateCohesionScore(graph) {
+  const dirEdges = /* @__PURE__ */ new Map();
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceAttrs = graph.getNodeAttributes(source);
+    const targetAttrs = graph.getNodeAttributes(target);
+    if (sourceAttrs.filePath !== targetAttrs.filePath) {
+      const sourceDir = dirname6(sourceAttrs.filePath);
+      const targetDir = dirname6(targetAttrs.filePath);
+      if (!dirEdges.has(sourceDir)) {
+        dirEdges.set(sourceDir, { internal: 0, total: 0 });
+      }
+      const stats = dirEdges.get(sourceDir);
+      stats.total++;
+      if (sourceDir === targetDir) {
+        stats.internal++;
+      }
+    }
+  });
+  if (dirEdges.size === 0) {
+    return {
+      name: "Cohesion",
+      score: 100,
+      weight: 0.2,
+      grade: "A",
+      details: "No inter-file dependencies",
+      metrics: { avgInternalRatio: 1, directories: 0 }
+    };
+  }
+  let totalRatio = 0;
+  for (const stats of dirEdges.values()) {
+    if (stats.total > 0) {
+      totalRatio += stats.internal / stats.total;
+    }
+  }
+  const avgInternalRatio = totalRatio / dirEdges.size;
+  let score = 100;
+  if (avgInternalRatio >= 0.7) {
+    score = 100;
+  } else if (avgInternalRatio >= 0.5) {
+    score = 80;
+  } else if (avgInternalRatio >= 0.3) {
+    score = 60;
+  } else if (avgInternalRatio >= 0.1) {
+    score = 40;
+  } else {
+    score = 20;
+  }
+  return {
+    name: "Cohesion",
+    score,
+    weight: 0.2,
+    grade: scoreToGrade(score),
+    details: `Average ${(avgInternalRatio * 100).toFixed(0)}% internal dependencies per directory`,
+    metrics: {
+      avgInternalRatio: parseFloat((avgInternalRatio * 100).toFixed(1)),
+      directories: dirEdges.size
+    }
+  };
+}
+function calculateCircularDepsScore(graph) {
+  const fileGraph = /* @__PURE__ */ new Map();
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceFile = graph.getNodeAttributes(source).filePath;
+    const targetFile = graph.getNodeAttributes(target).filePath;
+    if (sourceFile !== targetFile) {
+      if (!fileGraph.has(sourceFile)) {
+        fileGraph.set(sourceFile, /* @__PURE__ */ new Set());
+      }
+      fileGraph.get(sourceFile).add(targetFile);
+    }
+  });
+  const visited = /* @__PURE__ */ new Set();
+  const recStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  function dfs(node, path2) {
+    if (recStack.has(node)) {
+      const cycleStart = path2.indexOf(node);
+      if (cycleStart >= 0) {
+        cycles.push(path2.slice(cycleStart));
+      }
+      return;
+    }
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    recStack.add(node);
+    path2.push(node);
+    const neighbors = fileGraph.get(node);
+    if (neighbors) {
+      for (const neighbor of neighbors) {
+        dfs(neighbor, [...path2]);
+      }
+    }
+    recStack.delete(node);
+  }
+  for (const node of fileGraph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  const uniqueCycles = /* @__PURE__ */ new Set();
+  for (const cycle of cycles) {
+    const sorted = [...cycle].sort().join(",");
+    uniqueCycles.add(sorted);
+  }
+  const cycleCount = uniqueCycles.size;
+  let score = 100;
+  if (cycleCount === 0) {
+    score = 100;
+  } else if (cycleCount <= 2) {
+    score = 80;
+  } else if (cycleCount <= 5) {
+    score = 60;
+  } else if (cycleCount <= 10) {
+    score = 40;
+  } else {
+    score = 20;
+  }
+  return {
+    name: "Circular Dependencies",
+    score,
+    weight: 0.2,
+    grade: scoreToGrade(score),
+    details: cycleCount === 0 ? "No circular dependencies detected" : `${cycleCount} circular dependency cycle${cycleCount === 1 ? "" : "s"} detected`,
+    metrics: { cycles: cycleCount }
+  };
+}
+function calculateGodFilesScore(graph) {
+  const files = /* @__PURE__ */ new Set();
+  const fileConnections = /* @__PURE__ */ new Map();
+  graph.forEachNode((node, attrs) => {
+    files.add(attrs.filePath);
+  });
+  if (files.size === 0) {
+    return {
+      name: "God Files",
+      score: 100,
+      weight: 0.15,
+      grade: "A",
+      details: "No files to analyze",
+      metrics: { godFiles: 0, threshold: 0 }
+    };
+  }
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceFile = graph.getNodeAttributes(source).filePath;
+    const targetFile = graph.getNodeAttributes(target).filePath;
+    if (sourceFile !== targetFile) {
+      fileConnections.set(sourceFile, (fileConnections.get(sourceFile) || 0) + 1);
+      fileConnections.set(targetFile, (fileConnections.get(targetFile) || 0) + 1);
+    }
+  });
+  const connections = Array.from(fileConnections.values());
+  const avgConnections = connections.length > 0 ? connections.reduce((a, b) => a + b, 0) / connections.length : 0;
+  const godThreshold = avgConnections * 3;
+  const godFiles = connections.filter((c) => c > godThreshold).length;
+  let score = 100;
+  if (godFiles === 0) {
+    score = 100;
+  } else if (godFiles === 1) {
+    score = 80;
+  } else if (godFiles <= 3) {
+    score = 60;
+  } else if (godFiles <= 5) {
+    score = 40;
+  } else {
+    score = 20;
+  }
+  return {
+    name: "God Files",
+    score,
+    weight: 0.15,
+    grade: scoreToGrade(score),
+    details: godFiles === 0 ? "No god files detected" : `${godFiles} god file${godFiles === 1 ? "" : "s"} (>${godThreshold.toFixed(0)} connections)`,
+    metrics: { godFiles, threshold: parseFloat(godThreshold.toFixed(1)) }
+  };
+}
+function calculateOrphansScore(graph) {
+  const files = /* @__PURE__ */ new Set();
+  const connectedFiles = /* @__PURE__ */ new Set();
+  graph.forEachNode((node, attrs) => {
+    files.add(attrs.filePath);
+  });
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceFile = graph.getNodeAttributes(source).filePath;
+    const targetFile = graph.getNodeAttributes(target).filePath;
+    if (sourceFile !== targetFile) {
+      connectedFiles.add(sourceFile);
+      connectedFiles.add(targetFile);
+    }
+  });
+  const orphanCount = files.size - connectedFiles.size;
+  const orphanPercent = files.size > 0 ? orphanCount / files.size * 100 : 0;
+  let score = 100;
+  if (orphanPercent === 0) {
+    score = 100;
+  } else if (orphanPercent <= 5) {
+    score = 80;
+  } else if (orphanPercent <= 10) {
+    score = 60;
+  } else if (orphanPercent <= 20) {
+    score = 40;
+  } else {
+    score = 20;
+  }
+  return {
+    name: "Orphan Files",
+    score,
+    weight: 0.1,
+    grade: scoreToGrade(score),
+    details: orphanCount === 0 ? "No orphan files" : `${orphanCount} orphan file${orphanCount === 1 ? "" : "s"} (${orphanPercent.toFixed(0)}%)`,
+    metrics: { orphans: orphanCount, percentage: parseFloat(orphanPercent.toFixed(1)) }
+  };
+}
+function calculateDepthScore(graph) {
+  const fileGraph = /* @__PURE__ */ new Map();
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceFile = graph.getNodeAttributes(source).filePath;
+    const targetFile = graph.getNodeAttributes(target).filePath;
+    if (sourceFile !== targetFile) {
+      if (!fileGraph.has(sourceFile)) {
+        fileGraph.set(sourceFile, /* @__PURE__ */ new Set());
+      }
+      fileGraph.get(sourceFile).add(targetFile);
+    }
+  });
+  function findLongestPath(start) {
+    const visited = /* @__PURE__ */ new Set();
+    let maxDepth2 = 0;
+    function dfs(node, depth) {
+      if (visited.has(node)) {
+        return;
+      }
+      visited.add(node);
+      maxDepth2 = Math.max(maxDepth2, depth);
+      const neighbors = fileGraph.get(node);
+      if (neighbors) {
+        for (const neighbor of neighbors) {
+          dfs(neighbor, depth + 1);
+        }
+      }
+      visited.delete(node);
+    }
+    dfs(start, 0);
+    return maxDepth2;
+  }
+  let maxDepth = 0;
+  for (const node of fileGraph.keys()) {
+    const depth = findLongestPath(node);
+    maxDepth = Math.max(maxDepth, depth);
+  }
+  let score = 100;
+  if (maxDepth <= 4) {
+    score = 100;
+  } else if (maxDepth <= 6) {
+    score = 80;
+  } else if (maxDepth <= 8) {
+    score = 60;
+  } else if (maxDepth <= 12) {
+    score = 40;
+  } else {
+    score = 20;
+  }
+  return {
+    name: "Dependency Depth",
+    score,
+    weight: 0.1,
+    grade: scoreToGrade(score),
+    details: `Maximum dependency chain: ${maxDepth} level${maxDepth === 1 ? "" : "s"}`,
+    metrics: { maxDepth }
+  };
+}
+
+// src/health/index.ts
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync6, mkdirSync } from "fs";
+import { join as join9, dirname as dirname7 } from "path";
+function calculateHealthScore(graph, projectRoot) {
+  const coupling = calculateCouplingScore(graph);
+  const cohesion = calculateCohesionScore(graph);
+  const circular = calculateCircularDepsScore(graph);
+  const godFiles = calculateGodFilesScore(graph);
+  const orphans = calculateOrphansScore(graph);
+  const depth = calculateDepthScore(graph);
+  const dimensions = [coupling, cohesion, circular, godFiles, orphans, depth];
+  const overall = Math.round(
+    dimensions.reduce((sum, dim) => sum + dim.score * dim.weight, 0)
+  );
+  const files = /* @__PURE__ */ new Set();
+  const languages2 = {};
+  graph.forEachNode((node, attrs) => {
+    files.add(attrs.filePath);
+    const ext = attrs.filePath.toLowerCase();
+    let lang;
+    if (ext.endsWith(".ts") || ext.endsWith(".tsx")) {
+      lang = "TypeScript";
+    } else if (ext.endsWith(".js") || ext.endsWith(".jsx") || ext.endsWith(".mjs") || ext.endsWith(".cjs")) {
+      lang = "JavaScript";
+    } else if (ext.endsWith(".py")) {
+      lang = "Python";
+    } else if (ext.endsWith(".go")) {
+      lang = "Go";
+    } else {
+      lang = "Other";
+    }
+    languages2[lang] = (languages2[lang] || 0) + 1;
+  });
+  const grade = scoreToGrade(overall);
+  let summary = `Project health score is ${overall}/100 (Grade: ${grade}). `;
+  if (overall >= 90) {
+    summary += "Excellent architecture with minimal issues.";
+  } else if (overall >= 80) {
+    summary += "Good architecture with some areas for improvement.";
+  } else if (overall >= 70) {
+    summary += "Moderate architecture quality. Consider refactoring high-risk areas.";
+  } else if (overall >= 60) {
+    summary += "Architecture needs improvement. Multiple issues detected.";
+  } else {
+    summary += "Poor architecture quality. Significant refactoring recommended.";
+  }
+  const recommendations = [];
+  if (coupling.score < 70) {
+    recommendations.push(`High coupling detected: Average ${coupling.metrics.avgConnections} connections per file. Consider breaking down large modules.`);
+  }
+  if (cohesion.score < 70) {
+    recommendations.push(`Low cohesion: Only ${cohesion.metrics.avgInternalRatio}% internal dependencies. Reorganize files by feature or domain.`);
+  }
+  if (circular.score < 80 && typeof circular.metrics.cycles === "number" && circular.metrics.cycles > 0) {
+    recommendations.push(`${circular.metrics.cycles} circular dependency cycle${circular.metrics.cycles === 1 ? "" : "s"} detected. Break cycles by introducing interfaces or extracting shared code.`);
+  }
+  if (godFiles.score < 80 && typeof godFiles.metrics.godFiles === "number" && godFiles.metrics.godFiles > 0) {
+    recommendations.push(`${godFiles.metrics.godFiles} god file${godFiles.metrics.godFiles === 1 ? "" : "s"} detected with >${godFiles.metrics.threshold} connections. Split into smaller, focused modules.`);
+  }
+  if (orphans.score < 80 && typeof orphans.metrics.orphans === "number" && orphans.metrics.orphans > 0) {
+    recommendations.push(`${orphans.metrics.orphans} orphan file${orphans.metrics.orphans === 1 ? "" : "s"} detected. Verify they're needed or remove dead code.`);
+  }
+  if (depth.score < 80 && typeof depth.metrics.maxDepth === "number") {
+    recommendations.push(`Maximum dependency depth is ${depth.metrics.maxDepth} levels. Consider flattening the deepest chains.`);
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("No critical issues detected. Maintain current architecture quality.");
+  }
+  const report = {
+    overall,
+    grade,
+    dimensions,
+    summary,
+    recommendations,
+    projectStats: {
+      files: files.size,
+      symbols: graph.order,
+      edges: graph.size,
+      languages: languages2
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveHealthHistory(projectRoot, report);
+  return report;
+}
+function getHealthTrend(projectRoot, currentScore) {
+  const history = loadHealthHistory(projectRoot);
+  if (history.length < 2) {
+    return null;
+  }
+  const previous = history[history.length - 2];
+  const delta = currentScore - previous.score;
+  if (delta > 0) {
+    return `\u2191 +${delta}`;
+  } else if (delta < 0) {
+    return `\u2193 ${delta}`;
+  } else {
+    return "\u2192 0";
+  }
+}
+function saveHealthHistory(projectRoot, report) {
+  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
+  const entry = {
+    timestamp: report.timestamp,
+    score: report.overall,
+    grade: report.grade,
+    dimensions: report.dimensions.map((d) => ({
+      name: d.name,
+      score: d.score,
+      grade: d.grade
+    }))
+  };
+  let history = [];
+  if (existsSync6(historyFile)) {
+    try {
+      const content = readFileSync4(historyFile, "utf-8");
+      history = JSON.parse(content);
+    } catch {
+    }
+  }
+  history.push(entry);
+  if (history.length > 50) {
+    history = history.slice(-50);
+  }
+  mkdirSync(dirname7(historyFile), { recursive: true });
+  writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
+}
+function loadHealthHistory(projectRoot) {
+  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
+  if (!existsSync6(historyFile)) {
+    return [];
+  }
+  try {
+    const content = readFileSync4(historyFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync8 } from "fs";
-import { join as join11 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync9 } from "fs";
+import { join as join12 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname6 } from "path";
+import { dirname as dirname8 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -2654,9 +3143,9 @@ function header(text, level = 1) {
 function code(text) {
   return `\`${text}\``;
 }
-function codeBlock(code2, lang = "") {
+function codeBlock(code3, lang = "") {
   return `\`\`\`${lang}
-${code2}
+${code3}
 \`\`\`
 
 `;
@@ -2794,7 +3283,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname6(attrs.filePath);
+    const dir = dirname8(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -2819,7 +3308,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname6(attrs.filePath);
+    const dir = dirname8(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -2834,8 +3323,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname6(sourceAttrs.filePath);
-    const targetDir = dirname6(targetAttrs.filePath);
+    const sourceDir = dirname8(sourceAttrs.filePath);
+    const targetDir = dirname8(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -3816,7 +4305,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname7 } from "path";
+import { dirname as dirname9 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -3875,7 +4364,7 @@ function generateQuickOrientation(graph) {
   const primaryLang = Object.entries(languages2).sort((a, b) => b[1] - a[1])[0];
   const dirs = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname7(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -3979,7 +4468,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname7(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -3994,7 +4483,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname7(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4009,8 +4498,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname7(sourceAttrs.filePath);
-    const targetDir = dirname7(targetAttrs.filePath);
+    const sourceDir = dirname9(sourceAttrs.filePath);
+    const targetDir = dirname9(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4091,7 +4580,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname7(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4145,8 +4634,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname7(files[0]);
-  if (files.every((f) => dirname7(f) === commonDir)) {
+  const commonDir = dirname9(files[0]);
+  if (files.every((f) => dirname9(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -4204,7 +4693,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname8, basename as basename3 } from "path";
+import { dirname as dirname10, basename as basename3 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4308,7 +4797,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname8(file.filePath);
+    const dir = dirname10(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -4951,7 +5440,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname9 } from "path";
+import { basename as basename4, dirname as dirname11 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4980,7 +5469,7 @@ function getFileCount8(graph) {
 }
 function isTestFile(filePath) {
   const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname9(filePath).toLowerCase();
+  const dirPath = dirname11(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -5039,12 +5528,12 @@ function generateTestFileInventory(graph) {
 }
 function matchTestToSource(testFile) {
   const testFileName = basename4(testFile);
-  const testDir = dirname9(testFile);
+  const testDir = dirname11(testFile);
   let sourceFileName = testFileName.replace(/\.test\./g, ".").replace(/\.spec\./g, ".").replace(/_test\./g, ".").replace(/_spec\./g, ".");
   const possiblePaths = [];
   possiblePaths.push(testDir + "/" + sourceFileName);
   if (testDir.endsWith("/test") || testDir.endsWith("/tests") || testDir.endsWith("/__tests__")) {
-    const parentDir = dirname9(testDir);
+    const parentDir = dirname11(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -5241,7 +5730,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname9(sourceFile).split("/")[0];
+    const dir = dirname11(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -5264,7 +5753,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname12 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -5545,7 +6034,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -5627,7 +6116,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname11 } from "path";
+import { dirname as dirname13 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5765,7 +6254,7 @@ function generateCompleteFileIndex(graph) {
   fileInfos.sort((a, b) => a.filePath.localeCompare(b.filePath));
   const dirGroups = /* @__PURE__ */ new Map();
   for (const info of fileInfos) {
-    const dir = dirname11(info.filePath);
+    const dir = dirname13(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -5976,8 +6465,8 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
+import { join as join10 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6010,12 +6499,12 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join9(projectRoot, filePath);
-  if (!existsSync6(fullPath)) {
+  const fullPath = join10(projectRoot, filePath);
+  if (!existsSync7(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync4(fullPath, "utf-8");
+    const content = readFileSync5(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -6329,16 +6818,171 @@ function generateCompleteness(projectRoot, graph) {
   return output;
 }
 
+// src/docs/health.ts
+function generateHealth(graph, projectRoot, version) {
+  let output = "";
+  const report = calculateHealthScore(graph, projectRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const fileCount = getFileCount12(graph);
+  output += timestamp(version, now, fileCount, graph.order);
+  output += header("Dependency Health Score");
+  output += "Analysis of dependency architecture quality across 6 dimensions.\n\n";
+  output += header("Overall Score", 2);
+  output += generateOverallScore(report);
+  output += header("Dimension Breakdown", 2);
+  output += generateDimensionsBreakdown(report.dimensions);
+  output += header("Recommendations", 2);
+  output += generateRecommendations2(report.recommendations);
+  output += header("Historical Trend", 2);
+  output += generateHistoricalTrend(projectRoot, report);
+  output += header("Detailed Metrics", 2);
+  output += generateDetailedMetrics(report.dimensions);
+  return output;
+}
+function getFileCount12(graph) {
+  const files = /* @__PURE__ */ new Set();
+  graph.forEachNode((node, attrs) => {
+    files.add(attrs.filePath);
+  });
+  return files.size;
+}
+function generateOverallScore(report) {
+  let output = "";
+  const gradeEmoji = {
+    "A": "\u{1F7E2}",
+    "B": "\u{1F535}",
+    "C": "\u{1F7E1}",
+    "D": "\u{1F7E0}",
+    "F": "\u{1F534}"
+  };
+  output += `**Score:** ${report.overall}/100
+
+`;
+  output += `**Grade:** ${gradeEmoji[report.grade]} ${report.grade}
+
+`;
+  output += `**Summary:** ${report.summary}
+
+`;
+  output += `**Project Statistics:**
+
+`;
+  output += `- Files: ${formatNumber(report.projectStats.files)}
+`;
+  output += `- Symbols: ${formatNumber(report.projectStats.symbols)}
+`;
+  output += `- Edges: ${formatNumber(report.projectStats.edges)}
+`;
+  const langs = Object.entries(report.projectStats.languages).sort((a, b) => b[1] - a[1]).map(([lang, count]) => `${lang} (${count})`).join(", ");
+  output += `- Languages: ${langs}
+
+`;
+  return output;
+}
+function generateDimensionsBreakdown(dimensions) {
+  let output = "";
+  const headers = ["Dimension", "Score", "Grade", "Weight", "Details"];
+  const rows = dimensions.map((d) => [
+    d.name,
+    `${d.score}/100`,
+    d.grade,
+    `${(d.weight * 100).toFixed(0)}%`,
+    d.details
+  ]);
+  output += table(headers, rows);
+  return output;
+}
+function generateRecommendations2(recommendations) {
+  if (recommendations.length === 0) {
+    return "\u2705 No critical issues detected.\n\n";
+  }
+  return unorderedList(recommendations);
+}
+function generateHistoricalTrend(projectRoot, currentReport) {
+  const history = loadHealthHistory(projectRoot);
+  if (history.length < 2) {
+    return "No historical data available. Run `depwire health` regularly to track trends.\n\n";
+  }
+  let output = `Showing last ${Math.min(history.length, 10)} health checks:
+
+`;
+  const headers = ["Date", "Score", "Grade", "Trend"];
+  const recent = history.slice(-10);
+  const rows = recent.map((entry, idx) => {
+    let trend = "\u2014";
+    if (idx > 0) {
+      const prev = recent[idx - 1];
+      const delta = entry.score - prev.score;
+      if (delta > 0) {
+        trend = `\u2191 +${delta}`;
+      } else if (delta < 0) {
+        trend = `\u2193 ${delta}`;
+      } else {
+        trend = "\u2192 0";
+      }
+    }
+    return [
+      entry.timestamp.split("T")[0],
+      entry.score.toString(),
+      entry.grade,
+      trend
+    ];
+  });
+  output += table(headers, rows);
+  const first = recent[0];
+  const last = recent[recent.length - 1];
+  const totalDelta = last.score - first.score;
+  output += `
+**Trend:** `;
+  if (totalDelta > 0) {
+    output += `\u{1F4C8} Improved by ${totalDelta} points over ${recent.length} checks
+
+`;
+  } else if (totalDelta < 0) {
+    output += `\u{1F4C9} Declined by ${Math.abs(totalDelta)} points over ${recent.length} checks
+
+`;
+  } else {
+    output += `\u{1F4CA} Stable at ${last.score} points over ${recent.length} checks
+
+`;
+  }
+  return output;
+}
+function generateDetailedMetrics(dimensions) {
+  let output = "";
+  for (const dim of dimensions) {
+    output += header(dim.name, 3);
+    output += `**Score:** ${dim.score}/100 (${dim.grade})
+
+`;
+    output += `**Details:** ${dim.details}
+
+`;
+    if (Object.keys(dim.metrics).length > 0) {
+      output += `**Metrics:**
+
+`;
+      for (const [key, value] of Object.entries(dim.metrics)) {
+        output += `- ${key}: ${typeof value === "number" ? formatNumber(value) : value}
+`;
+      }
+      output += "\n";
+    }
+  }
+  return output;
+}
+
 // src/docs/metadata.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join11 } from "path";
 function loadMetadata(outputDir) {
-  const metadataPath = join10(outputDir, "metadata.json");
-  if (!existsSync7(metadataPath)) {
+  const metadataPath = join11(outputDir, "metadata.json");
+  if (!existsSync8(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync5(metadataPath, "utf-8");
+    const content = readFileSync6(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -6346,14 +6990,14 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const metadataPath = join10(outputDir, "metadata.json");
-  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+  const metadataPath = join11(outputDir, "metadata.json");
+  writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 function createMetadata(version, projectPath, fileCount, symbolCount, edgeCount, docTypes) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const documents = {};
   for (const docType of docTypes) {
-    const fileName = docType === "architecture" ? "ARCHITECTURE.md" : docType === "conventions" ? "CONVENTIONS.md" : docType === "dependencies" ? "DEPENDENCIES.md" : docType === "onboarding" ? "ONBOARDING.md" : docType === "files" ? "FILES.md" : docType === "api_surface" ? "API_SURFACE.md" : docType === "errors" ? "ERRORS.md" : docType === "tests" ? "TESTS.md" : docType === "history" ? "HISTORY.md" : docType === "current" ? "CURRENT.md" : docType === "status" ? "STATUS.md" : `${docType.toUpperCase()}.md`;
+    const fileName = docType === "architecture" ? "ARCHITECTURE.md" : docType === "conventions" ? "CONVENTIONS.md" : docType === "dependencies" ? "DEPENDENCIES.md" : docType === "onboarding" ? "ONBOARDING.md" : docType === "files" ? "FILES.md" : docType === "api_surface" ? "API_SURFACE.md" : docType === "errors" ? "ERRORS.md" : docType === "tests" ? "TESTS.md" : docType === "history" ? "HISTORY.md" : docType === "current" ? "CURRENT.md" : docType === "status" ? "STATUS.md" : docType === "health" ? "HEALTH.md" : `${docType.toUpperCase()}.md`;
     documents[docType] = {
       generated_at: now,
       file: fileName
@@ -6389,8 +7033,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync8(options.outputDir)) {
-      mkdirSync(options.outputDir, { recursive: true });
+    if (!existsSync9(options.outputDir)) {
+      mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
       }
@@ -6411,14 +7055,15 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         "tests",
         "history",
         "current",
-        "status"
+        "status",
+        "health"
       ];
     }
     let metadata = null;
     if (options.update) {
       metadata = loadMetadata(options.outputDir);
     }
-    const fileCount = getFileCount12(graph);
+    const fileCount = getFileCount13(graph);
     const symbolCount = graph.order;
     const edgeCount = graph.size;
     if (options.format === "markdown") {
@@ -6426,8 +7071,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ARCHITECTURE.md...");
           const content = generateArchitecture(graph, projectRoot, version, parseTime);
-          const filePath = join11(options.outputDir, "ARCHITECTURE.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "ARCHITECTURE.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
           errors.push(`Failed to generate ARCHITECTURE.md: ${err}`);
@@ -6437,8 +7082,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CONVENTIONS.md...");
           const content = generateConventions(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "CONVENTIONS.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "CONVENTIONS.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
           errors.push(`Failed to generate CONVENTIONS.md: ${err}`);
@@ -6448,8 +7093,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEPENDENCIES.md...");
           const content = generateDependencies(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "DEPENDENCIES.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "DEPENDENCIES.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
           errors.push(`Failed to generate DEPENDENCIES.md: ${err}`);
@@ -6459,8 +7104,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ONBOARDING.md...");
           const content = generateOnboarding(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "ONBOARDING.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "ONBOARDING.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
           errors.push(`Failed to generate ONBOARDING.md: ${err}`);
@@ -6470,8 +7115,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating FILES.md...");
           const content = generateFiles(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "FILES.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "FILES.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
           errors.push(`Failed to generate FILES.md: ${err}`);
@@ -6481,8 +7126,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating API_SURFACE.md...");
           const content = generateApiSurface(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "API_SURFACE.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "API_SURFACE.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
           errors.push(`Failed to generate API_SURFACE.md: ${err}`);
@@ -6492,8 +7137,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ERRORS.md...");
           const content = generateErrors(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "ERRORS.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "ERRORS.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
           errors.push(`Failed to generate ERRORS.md: ${err}`);
@@ -6503,8 +7148,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating TESTS.md...");
           const content = generateTests(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "TESTS.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "TESTS.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
           errors.push(`Failed to generate TESTS.md: ${err}`);
@@ -6514,8 +7159,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HISTORY.md...");
           const content = generateHistory(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "HISTORY.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "HISTORY.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
           errors.push(`Failed to generate HISTORY.md: ${err}`);
@@ -6525,8 +7170,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CURRENT.md...");
           const content = generateCurrent(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "CURRENT.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "CURRENT.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
           errors.push(`Failed to generate CURRENT.md: ${err}`);
@@ -6536,13 +7181,24 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating STATUS.md...");
           const content = generateStatus(graph, projectRoot, version);
-          const filePath = join11(options.outputDir, "STATUS.md");
-          writeFileSync2(filePath, content, "utf-8");
+          const filePath = join12(options.outputDir, "STATUS.md");
+          writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
           errors.push(`Failed to generate STATUS.md: ${err}`);
         }
       }
+      if (docsToGenerate.includes("health")) {
+        try {
+          if (options.verbose) console.log("Generating HEALTH.md...");
+          const content = generateHealth(graph, projectRoot, version);
+          const filePath = join12(options.outputDir, "HEALTH.md");
+          writeFileSync3(filePath, content, "utf-8");
+          generated.push("HEALTH.md");
+        } catch (err) {
+          errors.push(`Failed to generate HEALTH.md: ${err}`);
+        }
+      }
     } else if (options.format === "json") {
       errors.push("JSON format not yet supported");
     }
@@ -6571,7 +7227,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
     };
   }
 }
-function getFileCount12(graph) {
+function getFileCount13(graph) {
   const files = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
     files.add(attrs.filePath);
@@ -6584,13 +7240,13 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import { dirname as dirname12, join as join13 } from "path";
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname14, join as join14 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 
 // src/mcp/connect.ts
 import simpleGit from "simple-git";
-import { existsSync as existsSync9 } from "fs";
-import { join as join12, basename as basename5, resolve as resolve2 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join13, basename as basename5, resolve as resolve2 } from "path";
 import { tmpdir, homedir } from "os";
 function validateProjectPath(source) {
   const resolved = resolve2(source);
@@ -6603,11 +7259,11 @@ function validateProjectPath(source) {
     "/boot",
     "/proc",
     "/sys",
-    join12(homedir(), ".ssh"),
-    join12(homedir(), ".gnupg"),
-    join12(homedir(), ".aws"),
-    join12(homedir(), ".config"),
-    join12(homedir(), ".env")
+    join13(homedir(), ".ssh"),
+    join13(homedir(), ".gnupg"),
+    join13(homedir(), ".aws"),
+    join13(homedir(), ".config"),
+    join13(homedir(), ".env")
   ];
   for (const blocked of blockedPaths) {
     if (resolved.startsWith(blocked)) {
@@ -6630,11 +7286,11 @@ async function connectToRepo(source, subdirectory, state) {
         };
       }
       projectName = match[1];
-      const reposDir = join12(tmpdir(), "depwire-repos");
-      const cloneDir = join12(reposDir, projectName);
+      const reposDir = join13(tmpdir(), "depwire-repos");
+      const cloneDir = join13(reposDir, projectName);
       console.error(`Connecting to GitHub repo: ${source}`);
       const git = simpleGit();
-      if (existsSync9(cloneDir)) {
+      if (existsSync10(cloneDir)) {
         console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
         try {
           await git.cwd(cloneDir).pull();
@@ -6652,7 +7308,7 @@ async function connectToRepo(source, subdirectory, state) {
           };
         }
       }
-      projectRoot = subdirectory ? join12(cloneDir, subdirectory) : cloneDir;
+      projectRoot = subdirectory ? join13(cloneDir, subdirectory) : cloneDir;
     } else {
       const validation2 = validateProjectPath(source);
       if (!validation2.valid) {
@@ -6661,13 +7317,13 @@ async function connectToRepo(source, subdirectory, state) {
           message: validation2.error
         };
       }
-      if (!existsSync9(source)) {
+      if (!existsSync10(source)) {
         return {
           error: "Directory not found",
           message: `Directory does not exist: ${source}`
         };
       }
-      projectRoot = subdirectory ? join12(source, subdirectory) : source;
+      projectRoot = subdirectory ? join13(source, subdirectory) : source;
       projectName = basename5(projectRoot);
     }
     const validation = validateProjectPath(projectRoot);
@@ -6677,7 +7333,7 @@ async function connectToRepo(source, subdirectory, state) {
         message: validation.error
       };
     }
-    if (!existsSync9(projectRoot)) {
+    if (!existsSync10(projectRoot)) {
       return {
         error: "Project root not found",
         message: `Directory does not exist: ${projectRoot}`
@@ -6951,6 +7607,14 @@ function getToolsList() {
           }
         }
       }
+    },
+    {
+      name: "get_health_score",
+      description: "Get a 0-100 health score for the project's dependency architecture. Scores coupling, cohesion, circular dependencies, god files, orphan files, and dependency depth. Returns overall score, per-dimension breakdown, and actionable recommendations.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
     }
   ];
 }
@@ -6995,6 +7659,15 @@ async function handleToolCall(name, args, state) {
       } else {
         result = await handleUpdateProjectDocs(args.doc_type || "all", state);
       }
+    } else if (name === "get_health_score") {
+      if (!isProjectLoaded(state)) {
+        result = {
+          error: "No project loaded",
+          message: "Use connect_repo to connect to a codebase first"
+        };
+      } else {
+        result = handleGetHealthScore(state);
+      }
     } else {
       if (!isProjectLoaded(state)) {
         result = {
@@ -7332,7 +8005,7 @@ function handleGetArchitectureSummary(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   const languageBreakdown = {};
   fileSummary.forEach((f) => {
-    const dir = f.filePath.includes("/") ? dirname12(f.filePath) : ".";
+    const dir = f.filePath.includes("/") ? dirname14(f.filePath) : ".";
     if (!dirMap.has(dir)) {
       dirMap.set(dir, { fileCount: 0, symbolCount: 0 });
     }
@@ -7419,8 +8092,8 @@ The server will keep running until you end the MCP session or press Ctrl+C.`;
   };
 }
 async function handleGetProjectDocs(docType, state) {
-  const docsDir = join13(state.projectRoot, ".depwire");
-  if (!existsSync10(docsDir)) {
+  const docsDir = join14(state.projectRoot, ".depwire");
+  if (!existsSync11(docsDir)) {
     const errorMessage = `Project documentation has not been generated yet.
 
 Run \`depwire docs ${state.projectRoot}\` to generate codebase documentation.
@@ -7450,12 +8123,12 @@ Available document types:
       missing.push(doc);
       continue;
     }
-    const filePath = join13(docsDir, metadata.documents[doc].file);
-    if (!existsSync10(filePath)) {
+    const filePath = join14(docsDir, metadata.documents[doc].file);
+    if (!existsSync11(filePath)) {
       missing.push(doc);
       continue;
     }
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     if (docsToReturn.length > 1) {
       output += `
 
@@ -7480,16 +8153,16 @@ Available document types:
 }
 async function handleUpdateProjectDocs(docType, state) {
   const startTime = Date.now();
-  const docsDir = join13(state.projectRoot, ".depwire");
+  const docsDir = join14(state.projectRoot, ".depwire");
   console.error("Regenerating project documentation...");
   const parsedFiles = await parseProject(state.projectRoot);
   const graph = buildGraph(parsedFiles);
   const parseTime = (Date.now() - startTime) / 1e3;
   state.graph = graph;
-  const packageJsonPath = join13(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+  const packageJsonPath = join14(__dirname, "../../package.json");
+  const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
   const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  const docsExist = existsSync10(docsDir);
+  const docsExist = existsSync11(docsDir);
   const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
     outputDir: docsDir,
     format: "markdown",
@@ -7524,6 +8197,12 @@ async function handleUpdateProjectDocs(docType, state) {
     };
   }
 }
+function handleGetHealthScore(state) {
+  const graph = state.graph;
+  const projectRoot = state.projectRoot;
+  const report = calculateHealthScore(graph, projectRoot);
+  return report;
+}
 
 // src/mcp/server.ts
 async function startMcpServer(state) {
@@ -7569,6 +8248,8 @@ export {
   startVizServer,
   createEmptyState,
   updateFileInGraph,
+  calculateHealthScore,
+  getHealthTrend,
   generateDocs,
   startMcpServer
 };