dead-links 0.1.4 → 0.3.0

package/dist/index.js

@@ -2,7 +2,8 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { writeFile } from "fs/promises";
+import { readFileSync } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
 import ora from "ora";
 
 // src/core/vault-loader.ts
@@ -24,6 +25,7 @@ async function loadVault(vaultPath, customIgnore = []) {
   const notes = [];
   for (const file of files) {
     const fullPath = resolve(absolutePath, file);
+    const relativePath = file.replace(/\\/g, "/");
     const content = await readFile(fullPath, "utf-8");
     const parsed = matter(content);
     const aliases = [];
@@ -36,7 +38,7 @@ async function loadVault(vaultPath, customIgnore = []) {
     }
     notes.push({
       path: fullPath,
-      relativePath: file,
+      relativePath,
       content: parsed.content,
       aliases,
       links: []
@@ -155,8 +157,42 @@ var AliasResolver = class {
   }
 };
 
+// src/core/link-resolver.ts
+import { dirname, isAbsolute, normalize, resolve as resolve2 } from "path";
+var REMOTE_TARGET = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i;
+function isExternalTarget(target) {
+  return REMOTE_TARGET.test(target) || target.startsWith("#");
+}
+function resolveNoteLink(link, source, notes, aliases, vaultPath) {
+  if (isExternalTarget(link.target)) return null;
+  if (link.type === "markdown") {
+    const target = decodeTarget(link.target).replace(/\\/g, "/");
+    const sourceRelativePath = normalize(resolve2(dirname(source.path), target));
+    const exact = notes.find((note) => normalize(note.path) === sourceRelativePath);
+    if (exact) return exact.path;
+    const vaultRelativePath = normalize(resolve2(vaultPath, target.replace(/^\/+/, "")));
+    const vaultRelative = notes.find((note) => normalize(note.path) === vaultRelativePath);
+    if (vaultRelative) return vaultRelative.path;
+  }
+  return aliases.resolve(decodeTarget(link.target));
+}
+function resolveAttachmentPath(target, source, vaultPath) {
+  const decoded = decodeTarget(target).replace(/\\/g, "/");
+  if (isAbsolute(decoded)) return normalize(decoded);
+  const relativeToSource = normalize(resolve2(dirname(source.path), decoded));
+  if (relativeToSource.startsWith(normalize(vaultPath))) return relativeToSource;
+  return normalize(resolve2(vaultPath, decoded.replace(/^\/+/, "")));
+}
+function decodeTarget(target) {
+  try {
+    return decodeURIComponent(target);
+  } catch {
+    return target;
+  }
+}
+
 // src/core/graph-builder.ts
-function buildGraph(notes, resolver) {
+function buildGraph(notes, resolver, vaultPath) {
   const notePathMap = /* @__PURE__ */ new Map();
   for (const note of notes) {
     notePathMap.set(note.path, {
@@ -168,10 +204,8 @@ function buildGraph(notes, resolver) {
   for (const note of notes) {
     const node = notePathMap.get(note.path);
     for (const link of note.links) {
-      if (link.type === "markdown" && !link.target.endsWith(".md")) {
-        continue;
-      }
-      const resolvedPath = resolver.resolve(link.target);
+      if (isExternalTarget(link.target)) continue;
+      const resolvedPath = resolveNoteLink(link, note, notes, resolver, vaultPath);
       if (resolvedPath && notePathMap.has(resolvedPath)) {
         if (!node.outgoing.includes(resolvedPath)) {
           node.outgoing.push(resolvedPath);
@@ -233,23 +267,34 @@ function isAttachment(target) {
   const ext = target.split(".").pop()?.toLowerCase();
   return ext ? ATTACHMENT_EXTENSIONS.has(ext) : false;
 }
-function analyze(notes, vaultPath, checkAttachments = false) {
+function analyze(notes, vaultPath, checkAttachments = false, ignoreFolders = []) {
   const resolver = new AliasResolver(notes);
-  const graph = buildGraph(notes, resolver);
+  const graph = buildGraph(notes, resolver, vaultPath);
   const brokenLinks = [];
   const orphanNotes = [];
   for (const node of graph) {
     if (node.incoming.length === 0 && node.outgoing.length === 0) {
-      orphanNotes.push(node.note);
+      if (!isIgnoredFolder(node.note.relativePath, ignoreFolders)) {
+        orphanNotes.push(node.note);
+      }
     }
     for (const link of node.note.links) {
-      if (link.type === "markdown" && !link.target.endsWith(".md")) {
+      if (isExternalTarget(link.target)) {
         continue;
       }
-      if (!checkAttachments && isAttachment(link.target)) {
+      if (isAttachment(link.target)) {
+        if (!checkAttachments) continue;
+        const attachmentPath = resolveAttachmentPath(link.target, node.note, vaultPath);
+        if (!existsSync(attachmentPath)) {
+          brokenLinks.push({
+            source: node.note.relativePath,
+            link,
+            reason: `File "${link.target}" does not exist`
+          });
+        }
         continue;
       }
-      const resolvedPath = resolver.resolve(link.target);
+      const resolvedPath = resolveNoteLink(link, node.note, notes, resolver, vaultPath);
       if (resolvedPath === node.note.path) {
         continue;
       }
@@ -259,14 +304,6 @@ function analyze(notes, vaultPath, checkAttachments = false) {
           link,
           reason: `Target "${link.target}" not found in vault`
         });
-      } else if (link.type === "embed" || link.type === "markdown") {
-        if (!existsSync(resolvedPath)) {
-          brokenLinks.push({
-            source: node.note.relativePath,
-            link,
-            reason: `File "${link.target}" does not exist`
-          });
-        }
       }
     }
   }
@@ -285,6 +322,13 @@ function analyze(notes, vaultPath, checkAttachments = false) {
     }
   };
 }
+function isIgnoredFolder(relativePath, ignoreFolders) {
+  const folder = relativePath.includes("/") ? relativePath.split("/").slice(0, -1).join("/") : "";
+  return ignoreFolders.some((ignored) => {
+    const normalized = ignored.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    return folder === normalized || folder.startsWith(`${normalized}/`);
+  });
+}
 function countConnectedComponents(graph) {
   if (graph.length === 0) return 0;
   const visited = /* @__PURE__ */ new Set();
@@ -312,15 +356,90 @@ function countConnectedComponents(graph) {
   return components;
 }
 
+// src/utils/suggestions.ts
+function levenshteinDistance(a, b) {
+  const matrix = Array(b.length + 1).fill(null).map(() => Array(a.length + 1).fill(0));
+  for (let i = 0; i <= a.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= b.length; j++) matrix[j][0] = j;
+  for (let j = 1; j <= b.length; j++) {
+    for (let i = 1; i <= a.length; i++) {
+      if (a[i - 1] === b[j - 1]) {
+        matrix[j][i] = matrix[j - 1][i - 1];
+      } else {
+        matrix[j][i] = Math.min(
+          matrix[j][i - 1] + 1,
+          matrix[j - 1][i] + 1,
+          matrix[j - 1][i - 1] + 1
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function calculateSimilarity(a, b) {
+  const distance = levenshteinDistance(
+    a.toLowerCase(),
+    b.toLowerCase()
+  );
+  const maxLen = Math.max(a.length, b.length);
+  return Math.max(0, 1 - distance / maxLen);
+}
+function generateSuggestions(brokenTargets, allNotes, threshold = 0.6) {
+  const availableNotes = allNotes.map((n) => ({
+    name: n.relativePath.replace(/\.(md|canvas)$/, ""),
+    basename: n.relativePath.split("/").pop()?.replace(/\.(md|canvas)$/, "") || "",
+    aliases: n.aliases
+  }));
+  const suggestions = [];
+  for (const broken of brokenTargets) {
+    const brokenBasename = broken.split("/").pop() || broken;
+    const candidates = [];
+    for (const note of availableNotes) {
+      const basenameScore = calculateSimilarity(brokenBasename, note.basename);
+      const fullScore = calculateSimilarity(broken, note.name);
+      for (const alias of note.aliases) {
+        const aliasScore = calculateSimilarity(broken, alias);
+        if (aliasScore > basenameScore && aliasScore > fullScore) {
+          candidates.push({ suggestion: note.name, similarity: aliasScore });
+        }
+      }
+      if (basenameScore >= fullScore && basenameScore > threshold) {
+        candidates.push({ suggestion: note.name, similarity: basenameScore });
+      } else if (fullScore > threshold) {
+        candidates.push({ suggestion: note.name, similarity: fullScore });
+      }
+    }
+    if (candidates.length > 0) {
+      const best = candidates.sort((a, b) => b.similarity - a.similarity)[0];
+      suggestions.push({
+        broken,
+        suggested: best.suggestion,
+        similarity: best.similarity,
+        source: broken
+      });
+    }
+  }
+  return suggestions.sort((a, b) => b.similarity - a.similarity);
+}
+
 // src/utils/engine.ts
 var DeadLinksEngine = class {
   async analyze(vaultPath, config = {}) {
     const startTime = Date.now();
     const notes = await loadVault(vaultPath, config.ignore);
-    for (const note of notes) {
-      note.links = parseLinks(note.content);
+    await Promise.all(
+      notes.map((note) => {
+        note.links = parseLinks(note.content);
+        return Promise.resolve();
+      })
+    );
+    const report = analyze(notes, vaultPath, config.checkAttachments, config.ignoreFolders);
+    if (config.suggestions || config.fix) {
+      const brokenTargets = Array.from(
+        new Set(report.brokenLinks.map((b) => b.link.target))
+      );
+      report.suggestions = generateSuggestions(brokenTargets, notes, 0.65);
     }
-    const report = analyze(notes, vaultPath, config.checkAttachments);
     report.duration = Date.now() - startTime;
     return report;
   }
@@ -328,11 +447,11 @@ var DeadLinksEngine = class {
 
 // src/utils/config-loader.ts
 import { readFile as readFile2, access } from "fs/promises";
-import { resolve as resolve2, join } from "path";
+import { resolve as resolve3, join } from "path";
 var CONFIG_FILES = [".deadlinksrc.json", ".deadlinksrc", "dead-links.config.json"];
 var ConfigLoader = class {
   async loadConfig(vaultPath) {
-    const absolutePath = resolve2(vaultPath);
+    const absolutePath = resolve3(vaultPath);
     for (const configFile of CONFIG_FILES) {
       const configPath = join(absolutePath, configFile);
       try {
@@ -356,19 +475,24 @@ var ConfigLoader = class {
     return {
       ignore: cliOptions.ignore || fileConfig.ignore,
       checkAttachments: cliOptions.attachments ?? fileConfig.checkAttachments ?? false,
-      ignoreFolders: cliOptions.ignoreFolders || fileConfig.ignoreFolders
+      ignoreFolders: cliOptions.ignoreFolders || fileConfig.ignoreFolders,
+      suggestions: cliOptions.suggestions ?? fileConfig.suggestions ?? false,
+      debug: cliOptions.debug ?? fileConfig.debug ?? false,
+      fix: cliOptions.fix ?? fileConfig.fix ?? false
     };
   }
 };
 
 // src/reporters/terminal-reporter.ts
-import chalk from "chalk";
+import { Chalk } from "chalk";
 var TerminalReporter = class {
   ignoreFolders;
   quiet;
-  constructor(ignoreFolders = [], quiet = false) {
+  chalk;
+  constructor(ignoreFolders = [], quiet = false, noColor = false) {
     this.ignoreFolders = ignoreFolders;
     this.quiet = quiet;
+    this.chalk = new Chalk({ level: noColor ? 0 : void 0 });
   }
   report(result) {
     if (this.quiet) {
@@ -378,6 +502,9 @@ var TerminalReporter = class {
     output += this.printStats(result);
     output += this.printBrokenLinks(result.brokenLinks);
     output += this.printOrphanNotes(result.orphanNotes);
+    if (result.suggestions && result.suggestions.length > 0) {
+      output += this.printSuggestions(result.suggestions);
+    }
     output += this.printDuration(result.duration);
     return output;
   }
@@ -407,12 +534,13 @@ var TerminalReporter = class {
     return out;
   }
   statLine(label, value, color = "white") {
-    return `  ${chalk.gray(label)}  ${color === "red" ? chalk.red.bold(value) : color === "yellow" ? chalk.yellow.bold(value) : chalk.white.bold(value)}
+    const chalk = this.chalk;
+    return `  ${this.chalk.gray(label)}  ${color === "red" ? this.chalk.red.bold(value) : color === "yellow" ? this.chalk.yellow.bold(value) : this.chalk.white.bold(value)}
 `;
   }
   printBrokenLinks(brokenLinks) {
     if (brokenLinks.length === 0) {
-      return chalk.green("  \u2713  No broken links\n\n");
+      return this.chalk.green("  \u2713  No broken links\n\n");
     }
     const grouped = /* @__PURE__ */ new Map();
     for (const broken of brokenLinks) {
@@ -421,18 +549,18 @@ var TerminalReporter = class {
       grouped.set(broken.source, existing);
     }
     const sorted = [...grouped.entries()].sort((a, b) => b[1].length - a[1].length);
-    let out = chalk.bold.red(`
+    let out = this.chalk.bold.red(`
 \u2716  Broken links (${brokenLinks.length})
 
 `);
     for (const [source, links] of sorted) {
       const count = links.length;
       const isMultiple = count >= 2;
-      const countStr = isMultiple ? chalk.red.bold(`\u2716  ${count}`) : chalk.yellow.bold(`\u2716  ${count}`);
-      out += `  ${countStr}  ${chalk.white.bold(source)}
+      const countStr = isMultiple ? this.chalk.red.bold(`\u2716  ${count}`) : this.chalk.yellow.bold(`\u2716  ${count}`);
+      out += `  ${countStr}  ${this.chalk.white.bold(source)}
 `;
       for (const link of links) {
-        const pill2 = isMultiple ? chalk.redBright(`[${link.link.target}]`) : chalk.yellowBright(`[${link.link.target}]`);
+        const pill2 = isMultiple ? this.chalk.redBright(`[${link.link.target}]`) : this.chalk.yellowBright(`[${link.link.target}]`);
         out += `      ${pill2}
 `;
       }
@@ -442,7 +570,7 @@ var TerminalReporter = class {
   }
   printOrphanNotes(orphanNotes) {
     if (orphanNotes.length === 0) {
-      return chalk.green("  \u2713  No orphan notes\n\n");
+      return this.chalk.green("  \u2713  No orphan notes\n\n");
     }
     const byFolder = /* @__PURE__ */ new Map();
     for (const note of orphanNotes) {
@@ -454,28 +582,44 @@ var TerminalReporter = class {
     }
     const sorted = [...byFolder.entries()].sort((a, b) => b[1] - a[1]);
     if (sorted.length === 0) {
-      return chalk.green("  \u2713  No orphan notes (all in ignored folders)\n\n");
+      return this.chalk.green("  \u2713  No orphan notes (all in ignored folders)\n\n");
     }
     const maxCount = sorted[0][1];
     const barWidth = 10;
-    let out = chalk.bold.yellow(`
+    let out = this.chalk.bold.yellow(`
 \u26A0  Orphan notes (${orphanNotes.length} total)
 
 `);
     for (const [folder, count] of sorted) {
       const filled = Math.round(count / maxCount * barWidth);
       const empty = barWidth - filled;
-      const bar2 = chalk.gray("\u2588".repeat(filled) + "\u2591".repeat(empty));
-      out += `  ${chalk.gray(folder.padEnd(40))}  ${bar2}  ${chalk.white.bold(String(count))}
+      const bar2 = this.chalk.gray("\u2588".repeat(filled) + "\u2591".repeat(empty));
+      out += `  ${this.chalk.gray(folder.padEnd(40))}  ${bar2}  ${this.chalk.white.bold(String(count))}
 `;
     }
     out += "\n";
     return out;
   }
   printDuration(ms) {
-    return chalk.dim(`  Completed in ${ms}ms
+    return this.chalk.dim(`  Completed in ${ms}ms
 `);
   }
+  printSuggestions(suggestions) {
+    let out = this.chalk.bold.cyan(`
+\u{1F4A1} Suggestions (${suggestions.length})
+
+`);
+    for (const suggestion of suggestions.slice(0, 5)) {
+      const confidence = Math.round(suggestion.similarity * 100);
+      const bar2 = confidence >= 80 ? this.chalk.green("\u2588\u2588\u2588\u2588\u2588") : confidence >= 60 ? this.chalk.yellow("\u2588\u2588\u2588\u2588\u2588") : this.chalk.gray("\u2588\u2588\u2588\u2588\u2588");
+      out += `  ${this.chalk.gray(suggestion.broken)} \u2192 ${this.chalk.cyan(suggestion.suggested)}
+`;
+      out += `      ${bar2} ${confidence}%
+
+`;
+    }
+    return out;
+  }
 };
 
 // src/reporters/json-reporter.ts
@@ -501,6 +645,510 @@ var JsonReporter = class {
   }
 };
 
+// src/reporters/csv-reporter.ts
+var CsvReporter = class {
+  report(result) {
+    const lines = [];
+    lines.push("# BROKEN LINKS");
+    lines.push("Source,Target,Type,Line,Reason");
+    for (const broken of result.brokenLinks) {
+      const source = this.escapeCsv(broken.source);
+      const target = this.escapeCsv(broken.link.target);
+      const type = broken.link.type;
+      const line = broken.link.line;
+      const reason = this.escapeCsv(broken.reason);
+      lines.push(`${source},${target},${type},${line},"${reason}"`);
+    }
+    lines.push("\n# ORPHAN NOTES");
+    lines.push("Note,Path");
+    for (const orphan of result.orphanNotes) {
+      const name = this.escapeCsv(orphan.relativePath);
+      lines.push(`${name},"${name}"`);
+    }
+    lines.push("\n# GRAPH STATISTICS");
+    lines.push("Metric,Value");
+    lines.push(`Total Notes,${result.stats.totalNotes}`);
+    lines.push(`Total Links,${result.stats.totalLinks}`);
+    lines.push(`Broken Links,${result.stats.brokenCount}`);
+    lines.push(`Orphan Notes,${result.stats.orphanCount}`);
+    lines.push(`Connected Components,${result.stats.connectedComponents}`);
+    lines.push(`Duration (ms),${result.duration}`);
+    return lines.join("\n");
+  }
+  escapeCsv(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+};
+
+// src/reporters/html-reporter.ts
+var HtmlReporter = class {
+  report(result) {
+    const brokenLinksHtml = this.renderBrokenLinks(result.brokenLinks);
+    const orphanNotesHtml = this.renderOrphanNotes(result.orphanNotes);
+    const graphHtml = this.renderGraph(result.graph);
+    const statsHtml = this.renderStats(result.stats, result.duration);
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Dead Links Report</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+            overflow: hidden;
+        }
+        header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px;
+            text-align: center;
+        }
+        header h1 { font-size: 2.5em; margin-bottom: 10px; }
+        header p { font-size: 1.1em; opacity: 0.9; }
+        .content { padding: 40px; }
+        .section {
+            margin-bottom: 40px;
+            border-left: 4px solid #667eea;
+            padding-left: 20px;
+        }
+        .section h2 {
+            font-size: 1.8em;
+            margin-bottom: 20px;
+            color: #333;
+        }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 40px;
+        }
+        .stat-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 8px;
+            text-align: center;
+        }
+        .stat-card .value { font-size: 2.5em; font-weight: bold; }
+        .stat-card .label { font-size: 0.9em; opacity: 0.9; margin-top: 10px; }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 20px;
+        }
+        th {
+            background: #f5f5f5;
+            padding: 12px;
+            text-align: left;
+            border-bottom: 2px solid #667eea;
+            font-weight: 600;
+        }
+        td {
+            padding: 12px;
+            border-bottom: 1px solid #eee;
+        }
+        tr:hover { background: #f9f9f9; }
+        .badge {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 0.85em;
+            font-weight: 500;
+        }
+        .badge-wiki { background: #dbeafe; color: #1e40af; }
+        .badge-embed { background: #fed7aa; color: #92400e; }
+        .badge-markdown { background: #d1fae5; color: #065f46; }
+        .error { color: #dc2626; }
+        .success { color: #16a34a; }
+        .tabs {
+            display: flex;
+            gap: 0;
+            border-bottom: 2px solid #eee;
+            margin-bottom: 20px;
+        }
+        .tab-button {
+            padding: 12px 20px;
+            border: none;
+            background: none;
+            cursor: pointer;
+            font-size: 1em;
+            border-bottom: 3px solid transparent;
+            color: #666;
+            transition: all 0.3s;
+        }
+        .tab-button.active {
+            color: #667eea;
+            border-bottom-color: #667eea;
+        }
+        .tab-content { display: none; }
+        .tab-content.active { display: block; }
+        .filter-box {
+            margin: 20px 0;
+            padding: 15px;
+            background: #f9f9f9;
+            border-radius: 8px;
+        }
+        .filter-box input {
+            width: 100%;
+            padding: 8px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 1em;
+        }
+        footer {
+            background: #f5f5f5;
+            padding: 20px;
+            text-align: center;
+            color: #666;
+            font-size: 0.9em;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>\u{1F50D} Dead Links Report</h1>
+            <p>Obsidian Vault Analysis</p>
+        </header>
+
+        <div class="content">
+            ${statsHtml}
+            ${brokenLinksHtml}
+            ${orphanNotesHtml}
+            ${graphHtml}
+        </div>
+
+        <footer>
+            Generated on ${(/* @__PURE__ */ new Date()).toLocaleString()}
+        </footer>
+    </div>
+
+    <script>
+        function setupTabs() {
+            const buttons = document.querySelectorAll('.tab-button');
+            const contents = document.querySelectorAll('.tab-content');
+
+            buttons.forEach((button, index) => {
+                button.addEventListener('click', () => {
+                    buttons.forEach(b => b.classList.remove('active'));
+                    contents.forEach(c => c.classList.remove('active'));
+                    button.classList.add('active');
+                    contents[index].classList.add('active');
+                });
+            });
+
+            // Activate first tab
+            if (buttons.length > 0) buttons[0].classList.add('active');
+            if (contents.length > 0) contents[0].classList.add('active');
+        }
+
+        function setupFilter(tableId, inputId) {
+            const input = document.getElementById(inputId);
+            const table = document.getElementById(tableId);
+            if (!input || !table) return;
+
+            input.addEventListener('keyup', (e) => {
+                const filter = e.target.value.toLowerCase();
+                const rows = table.querySelectorAll('tbody tr');
+                rows.forEach(row => {
+                    const text = row.textContent.toLowerCase();
+                    row.style.display = text.includes(filter) ? '' : 'none';
+                });
+            });
+        }
+
+        document.addEventListener('DOMContentLoaded', () => {
+            setupTabs();
+            setupFilter('broken-table', 'broken-filter');
+            setupFilter('orphan-table', 'orphan-filter');
+        });
+    </script>
+</body>
+</html>`;
+  }
+  renderStats(stats, duration) {
+    const healthColor = stats.brokenCount === 0 && stats.orphanCount === 0 ? "#16a34a" : "#dc2626";
+    return `
+        <div class="section">
+            <h2>\u{1F4CA} Overview</h2>
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="value">${stats.totalNotes}</div>
+                    <div class="label">Total Notes</div>
+                </div>
+                <div class="stat-card">
+                    <div class="value">${stats.totalLinks}</div>
+                    <div class="label">Total Links</div>
+                </div>
+                <div class="stat-card" style="background: linear-gradient(135deg, #dc2626 0%, #991b1b 100%);">
+                    <div class="value">${stats.brokenCount}</div>
+                    <div class="label">Broken Links</div>
+                </div>
+                <div class="stat-card" style="background: linear-gradient(135deg, #f59e0b 0%, #d97706 100%);">
+                    <div class="value">${stats.orphanCount}</div>
+                    <div class="label">Orphan Notes</div>
+                </div>
+                <div class="stat-card" style="background: linear-gradient(135deg, ${healthColor} 0%, ${healthColor === "#16a34a" ? "#15803d" : "#991b1b"} 100%);">
+                    <div class="value">${stats.connectedComponents}</div>
+                    <div class="label">Connected Components</div>
+                </div>
+                <div class="stat-card" style="background: linear-gradient(135deg, #8b5cf6 0%, #6d28d9 100%);">
+                    <div class="value">${duration}ms</div>
+                    <div class="label">Scan Duration</div>
+                </div>
+            </div>
+        </div>
+    `;
+  }
+  renderBrokenLinks(brokenLinks) {
+    if (brokenLinks.length === 0) {
+      return `
+        <div class="section">
+            <h2>\u2705 Broken Links</h2>
+            <p class="success">No broken links found!</p>
+        </div>
+      `;
+    }
+    const rows = brokenLinks.map(
+      (link) => `
+        <tr>
+            <td>${this.escapeHtml(link.source)}</td>
+            <td>${this.escapeHtml(link.link.target)}</td>
+            <td><span class="badge badge-${link.link.type}">${link.link.type}</span></td>
+            <td>${link.link.line}</td>
+            <td>${this.escapeHtml(link.reason)}</td>
+        </tr>
+      `
+    ).join("");
+    return `
+        <div class="section">
+            <h2>\u{1F534} Broken Links (${brokenLinks.length})</h2>
+            <div class="filter-box">
+                <input type="text" id="broken-filter" placeholder="Filter by source or target..." />
+            </div>
+            <table id="broken-table">
+                <thead>
+                    <tr>
+                        <th>Source</th>
+                        <th>Target</th>
+                        <th>Type</th>
+                        <th>Line</th>
+                        <th>Reason</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    ${rows}
+                </tbody>
+            </table>
+        </div>
+    `;
+  }
+  renderOrphanNotes(orphanNotes) {
+    if (orphanNotes.length === 0) {
+      return `
+        <div class="section">
+            <h2>\u2705 Orphan Notes</h2>
+            <p class="success">No orphan notes found!</p>
+        </div>
+      `;
+    }
+    const rows = orphanNotes.map(
+      (note) => `
+        <tr>
+            <td>${this.escapeHtml(note.relativePath)}</td>
+        </tr>
+      `
+    ).join("");
+    return `
+        <div class="section">
+            <h2>\u{1F7E1} Orphan Notes (${orphanNotes.length})</h2>
+            <div class="filter-box">
+                <input type="text" id="orphan-filter" placeholder="Filter by path..." />
+            </div>
+            <table id="orphan-table">
+                <thead>
+                    <tr>
+                        <th>Path</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    ${rows}
+                </tbody>
+            </table>
+        </div>
+    `;
+  }
+  renderGraph(graph) {
+    const mostConnected = [...graph].sort((a, b) => b.incoming.length + b.outgoing.length - (a.incoming.length + a.outgoing.length)).slice(0, 5);
+    const rows = mostConnected.map(
+      (node) => `
+        <tr>
+            <td>${this.escapeHtml(node.note.relativePath)}</td>
+            <td>${node.incoming.length}</td>
+            <td>${node.outgoing.length}</td>
+            <td>${node.incoming.length + node.outgoing.length}</td>
+        </tr>
+      `
+    ).join("");
+    return `
+        <div class="section">
+            <h2>\u{1F310} Most Connected Notes</h2>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Note</th>
+                        <th>Incoming</th>
+                        <th>Outgoing</th>
+                        <th>Total</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    ${rows}
+                </tbody>
+            </table>
+        </div>
+    `;
+  }
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+};
+
+// src/reporters/mermaid-reporter.ts
+var MermaidReporter = class {
+  report(result, maxNodes = 50) {
+    let output = "graph LR\n";
+    const nodesToShow = result.graph.slice(0, maxNodes);
+    const nodeMap = new Map(nodesToShow.map((n) => [n.note.path, n.note.relativePath]));
+    for (const node of nodesToShow) {
+      const id = this.sanitizeId(node.note.relativePath);
+      const label = this.escapeLabel(node.note.relativePath);
+      if (result.orphanNotes.some((o) => o.path === node.note.path)) {
+        output += `  ${id}["<b>\u{1F534} ${label}</b>"]:::orphan
+`;
+      } else if (node.incoming.length === 0) {
+        output += `  ${id}["\u{1F4C4} ${label}"]:::source
+`;
+      } else if (node.outgoing.length === 0) {
+        output += `  ${id}["\u{1F4CC} ${label}"]:::sink
+`;
+      } else {
+        output += `  ${id}["${label}"]
+`;
+      }
+    }
+    const addedEdges = /* @__PURE__ */ new Set();
+    for (const node of nodesToShow) {
+      const sourceId = this.sanitizeId(node.note.relativePath);
+      for (const targetPath of node.outgoing) {
+        const targetName = nodeMap.get(targetPath);
+        if (!targetName) continue;
+        const targetId = this.sanitizeId(targetName);
+        const edgeKey = `${sourceId}-${targetId}`;
+        if (!addedEdges.has(edgeKey)) {
+          output += `  ${sourceId} --> ${targetId}
+`;
+          addedEdges.add(edgeKey);
+        }
+      }
+    }
+    output += "\n  classDef orphan fill:#ff6b6b,stroke:#c92a2a,color:#fff\n";
+    output += "  classDef source fill:#4dabf7,stroke:#1971c2,color:#fff\n";
+    output += "  classDef sink fill:#51cf66,stroke:#2f9e44,color:#fff\n";
+    if (result.graph.length > maxNodes) {
+      output += `
+  note["Graph limited to ${maxNodes} of ${result.graph.length} nodes for readability"]
+`;
+    }
+    return output;
+  }
+  sanitizeId(name) {
+    return name.replace(/\.(md|canvas)$/, "").replace(/[^a-zA-Z0-9_]/g, "_").substring(0, 30);
+  }
+  escapeLabel(name) {
+    return name.replace(/"/g, '\\"').substring(0, 50);
+  }
+};
+
+// src/reporters/graphviz-reporter.ts
+var GraphVizReporter = class {
+  report(result, maxNodes = 100) {
+    let output = "digraph VaultGraph {\n";
+    output += "  rankdir=LR;\n";
+    output += "  node [shape=box, style=rounded];\n";
+    output += "  edge [arrowsize=0.5];\n\n";
+    const nodesToShow = result.graph.slice(0, maxNodes);
+    const nodeMap = new Map(nodesToShow.map((n) => [n.note.path, n.note.relativePath]));
+    for (const node of nodesToShow) {
+      const id = this.sanitizeId(node.note.relativePath);
+      const label = this.escapeLabel(node.note.relativePath);
+      let style = "filled";
+      let color = "#ffffff";
+      let fontColor = "#000000";
+      let shape = "box";
+      if (result.orphanNotes.some((o) => o.path === node.note.path)) {
+        color = "#ff6b6b";
+        fontColor = "#ffffff";
+        shape = "box";
+      } else if (node.incoming.length === 0) {
+        color = "#4dabf7";
+        fontColor = "#ffffff";
+      } else if (node.outgoing.length === 0) {
+        color = "#51cf66";
+        fontColor = "#ffffff";
+      }
+      output += `  "${id}" [label="${label}", fillcolor="${color}", fontcolor="${fontColor}", shape=${shape}];
+`;
+    }
+    output += "\n";
+    const addedEdges = /* @__PURE__ */ new Set();
+    for (const node of nodesToShow) {
+      const sourceId = this.sanitizeId(node.note.relativePath);
+      for (const targetPath of node.outgoing) {
+        const targetName = nodeMap.get(targetPath);
+        if (!targetName) continue;
+        const targetId = this.sanitizeId(targetName);
+        const edgeKey = `${sourceId}->${targetId}`;
+        if (!addedEdges.has(edgeKey)) {
+          output += `  "${sourceId}" -> "${targetId}";
+`;
+          addedEdges.add(edgeKey);
+        }
+      }
+    }
+    output += "\n  // Legend\n";
+    output += "  subgraph legend {\n";
+    output += "    rank=sink;\n";
+    output += '    orphan [label="\u{1F534} Orphan", fillcolor="#ff6b6b", fontcolor="white"];\n';
+    output += '    source [label="\u{1F4C4} Source (no incoming)", fillcolor="#4dabf7", fontcolor="white"];\n';
+    output += '    sink [label="\u{1F4CC} Sink (no outgoing)", fillcolor="#51cf66", fontcolor="white"];\n';
+    output += "  }\n";
+    output += "}\n";
+    return output;
+  }
+  sanitizeId(name) {
+    return name.replace(/\.(md|canvas)$/, "").replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+  escapeLabel(label) {
+    return label.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+};
+
 // src/utils/markdown-report.ts
 function pill(target, isMultiple) {
   return isMultiple ? `[${target}]` : `[${target}]`;
@@ -569,9 +1217,109 @@ function generateMarkdownReport(report) {
   return lines.join("\n");
 }
 
+// src/utils/auto-fixer.ts
+import { readFile as readFile3, writeFile } from "fs/promises";
+import { resolve as resolve4 } from "path";
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function autoFixBrokenLinks(fixMap, filePath) {
+  const results = [];
+  try {
+    const content = await readFile3(filePath, "utf-8");
+    let newContent = content;
+    for (const [oldTarget, newTarget] of fixMap.entries()) {
+      const wikiRegex = new RegExp(
+        `(!?\\[\\[${escapeRegExp(oldTarget)}(?:\\|[^\\]]*)?\\]\\])`,
+        "g"
+      );
+      const wikiMatches = content.match(wikiRegex);
+      if (wikiMatches) {
+        for (const match of wikiMatches) {
+          const isEmbed = match.startsWith("!");
+          const hasAlias = match.includes("|");
+          let replacement;
+          if (hasAlias) {
+            const parts = match.split("|");
+            replacement = `${isEmbed ? "!" : ""}[[${newTarget}|${parts[1]}`;
+          } else {
+            replacement = `${isEmbed ? "!" : ""}[[${newTarget}]]`;
+          }
+          newContent = newContent.replace(match, replacement);
+          results.push({
+            file: filePath,
+            originalLink: match,
+            newLink: replacement,
+            success: true
+          });
+        }
+      }
+      const markdownRegex = new RegExp(
+        `(\\[[^\\]]*\\]\\(${escapeRegExp(oldTarget)}(?:#[^)]*)?\\))`,
+        "g"
+      );
+      const markdownMatches = content.match(markdownRegex);
+      if (markdownMatches) {
+        for (const match of markdownMatches) {
+          const linkPart = match.match(/\(([^)]+)\)/)?.[1] || "";
+          const heading = linkPart.includes("#") ? linkPart.split("#")[1] : "";
+          const newLink = heading ? `${newTarget}#${heading}` : newTarget;
+          const textPart = match.match(/\[([^\]]*)\]/)?.[0] || "[]";
+          const replacement = `${textPart}(${newLink})`;
+          newContent = newContent.replace(match, replacement);
+          results.push({
+            file: filePath,
+            originalLink: match,
+            newLink: replacement,
+            success: true
+          });
+        }
+      }
+    }
+    if (newContent !== content) {
+      await writeFile(filePath, newContent, "utf-8");
+    }
+    return results;
+  } catch (error) {
+    return [
+      {
+        file: filePath,
+        originalLink: "",
+        newLink: "",
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }
+    ];
+  }
+}
+async function fixBrokenLinksBatch(brokenLinks, suggestionMap, vaultPath) {
+  const fileFixMap = /* @__PURE__ */ new Map();
+  for (const broken of brokenLinks) {
+    const suggestion = suggestionMap.get(broken.link.target);
+    if (!suggestion) continue;
+    if (!fileFixMap.has(broken.source)) {
+      fileFixMap.set(broken.source, /* @__PURE__ */ new Map());
+    }
+    fileFixMap.get(broken.source).set(broken.link.target, suggestion);
+  }
+  const allResults = /* @__PURE__ */ new Map();
+  const promises = Array.from(fileFixMap.entries()).map(
+    async ([source, fixMap]) => {
+      const filePath = resolve4(vaultPath, source);
+      const results = await autoFixBrokenLinks(fixMap, filePath);
+      allResults.set(source, results);
+    }
+  );
+  await Promise.all(promises);
+  return allResults;
+}
+
 // src/index.ts
+var packageMetadata = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
 var program = new Command();
-program.name("dead-links").description("Scan Obsidian vaults for broken links, orphan notes, and connection graphs").version("0.1.3");
+program.name("dead-links").description("Scan Obsidian vaults for broken links, orphan notes, and connection graphs").version(packageMetadata.version);
 async function loadConfigAndAnalyze(vaultPath, cliOptions) {
   const configLoader = new ConfigLoader();
   const fileConfig = await configLoader.loadConfig(vaultPath);
@@ -597,31 +1345,61 @@ function printOrphansVerbose(orphanNotes) {
     console.log(`  ${note.relativePath}`);
   }
 }
-program.command("scan").description("Scan the vault for all issues").option("--vault <path>", "Path to the Obsidian vault", process.cwd()).option("--format <type>", "Output format: text, json, markdown", "text").option("--output <file>", "Output file path").option("--ignore <patterns...>", "Ignore patterns (glob)").option("--attachments", "Also check embedded attachments (images, PDFs, etc.)").option("--ignore-folders <folders...>", "Exclude folders from orphan report").option("--quiet", "Only show issues, no stats or summary").option("--no-color", "Disable colored output").action(async (options) => {
+program.command("scan").description("Scan the vault for all issues").option("--vault <path>", "Path to the Obsidian vault", process.cwd()).option("--format <type>", "Output format: text, json, markdown, csv, html, mermaid, dot", "text").option("--output <file>", "Output file path").option("--ignore <patterns...>", "Ignore patterns (glob)").option("--attachments", "Also check embedded attachments (images, PDFs, etc.)").option("--ignore-folders <folders...>", "Exclude folders from orphan report").option("--quiet", "Only show issues, no stats or summary").option("--no-color", "Disable colored output").option("--suggestions", "Show smart suggestions for broken links").option("--debug", "Enable debug mode with verbose output").option("--fix", "Automatically fix broken links (requires suggestions)").action(async (options) => {
   const spinner = ora("Scanning vault...").start();
   try {
     const report = await loadConfigAndAnalyze(options.vault, options);
     spinner.succeed(`Scanned ${report.stats.totalNotes} notes in ${report.duration}ms`);
+    let fixSummary = "";
+    if (options.fix) {
+      const suggestionMap = new Map(
+        (report.suggestions || []).map((suggestion) => [suggestion.broken, suggestion.suggested])
+      );
+      const fixResults = await fixBrokenLinksBatch(report.brokenLinks, suggestionMap, options.vault);
+      const changed = [...fixResults.values()].flat().filter((result) => result.success).length;
+      const failed = [...fixResults.values()].flat().filter((result) => !result.success).length;
+      const fixSummary2 = `Auto-fix: ${changed} link(s) changed${failed > 0 ? `, ${failed} failed` : ""}.`;
+      console.error(fixSummary2);
+    }
+    if (options.debug) {
+      console.log(`[DEBUG] Vault: ${options.vault}`);
+      console.log(`[DEBUG] Format: ${options.format}`);
+      console.log(`[DEBUG] Broken links: ${report.stats.brokenCount}`);
+      console.log(`[DEBUG] Orphan notes: ${report.stats.orphanCount}`);
+    }
+    let output = "";
     if (options.format === "json") {
       const reporter = new JsonReporter();
-      const output = reporter.report(report);
-      if (options.output) {
-        await writeFile(options.output, output);
-        console.log(`JSON report written to ${options.output}`);
-      } else {
-        console.log(output);
-      }
+      output = reporter.report(report);
     } else if (options.format === "markdown") {
-      const output = generateMarkdownReport(report);
-      if (options.output) {
-        await writeFile(options.output, output);
-        console.log(`Markdown report written to ${options.output}`);
-      } else {
-        console.log(output);
-      }
+      output = generateMarkdownReport(report);
+    } else if (options.format === "csv") {
+      const reporter = new CsvReporter();
+      output = reporter.report(report);
+    } else if (options.format === "html") {
+      const reporter = new HtmlReporter();
+      output = reporter.report(report);
+    } else if (options.format === "mermaid") {
+      const reporter = new MermaidReporter();
+      output = reporter.report(report);
+    } else if (options.format === "dot") {
+      const reporter = new GraphVizReporter();
+      output = reporter.report(report);
     } else {
-      const reporter = new TerminalReporter(options.ignoreFolders || [], options.quiet || false);
-      console.log(reporter.report(report));
+      const reporter = new TerminalReporter(
+        options.ignoreFolders || [],
+        options.quiet || false,
+        options.color === false
+      );
+      output = reporter.report(report);
+    }
+    if (options.output) {
+      await writeFile2(options.output, output);
+      console.log(`Report written to ${options.output}`);
+    } else if (options.format === "text") {
+      console.log(output);
+    } else {
+      console.log(output);
     }
     process.exit(report.stats.brokenCount > 0 || report.stats.orphanCount > 0 ? 1 : 0);
   } catch (error) {
@@ -630,7 +1408,7 @@ program.command("scan").description("Scan the vault for all issues").option("--v
     process.exit(1);
   }
 });
-program.command("broken").description("Show only broken links").option("--vault <path>", "Path to the Obsidian vault", process.cwd()).option("--ignore <patterns...>", "Ignore patterns (glob)").option("--attachments", "Also check embedded attachments (images, PDFs, etc.)").option("--verbose", "Show line numbers and full details").action(async (options) => {
+program.command("broken").description("Show only broken links").option("--vault <path>", "Path to the Obsidian vault", process.cwd()).option("--ignore <patterns...>", "Ignore patterns (glob)").option("--attachments", "Also check embedded attachments (images, PDFs, etc.)").option("--verbose", "Show line numbers and full details").option("--suggestions", "Show smart suggestions for broken links").option("--debug", "Enable debug mode with verbose output").action(async (options) => {
   const spinner = ora("Scanning vault...").start();
   try {
     const report = await loadConfigAndAnalyze(options.vault, options);
@@ -656,6 +1434,14 @@ Broken links (${report.brokenLinks.length})
         }
       }
       console.log();
+      if (report.suggestions && report.suggestions.length > 0) {
+        console.log("\u{1F4A1} Suggestions:");
+        for (const suggestion of report.suggestions.slice(0, 5)) {
+          const confidence = Math.round(suggestion.similarity * 100);
+          console.log(`  ${suggestion.broken} \u2192 ${suggestion.suggested} (${confidence}%)`);
+        }
+        console.log();
+      }
     }
     process.exit(report.stats.brokenCount > 0 ? 1 : 0);
   } catch (error) {
@@ -734,7 +1520,7 @@ program.command("report").description("Generate a markdown report").option("--va
     const report = await loadConfigAndAnalyze(options.vault, options);
     spinner.succeed(`Scanned ${report.stats.totalNotes} notes in ${report.duration}ms`);
     const markdown = generateMarkdownReport(report);
-    await writeFile(options.output, markdown);
+    await writeFile2(options.output, markdown);
     console.log(`Report written to ${options.output}`);
   } catch (error) {
     spinner.fail("Scan failed");
@@ -742,5 +1528,40 @@ program.command("report").description("Generate a markdown report").option("--va
     process.exit(1);
   }
 });
+program.command("stats").description("Show detailed vault statistics").option("--vault <path>", "Path to the Obsidian vault", process.cwd()).option("--ignore <patterns...>", "Ignore patterns (glob)").option("--debug", "Enable debug mode").action(async (options) => {
+  const spinner = ora("Analyzing vault...").start();
+  try {
+    const report = await loadConfigAndAnalyze(options.vault, options);
+    spinner.succeed(`Analysis complete in ${report.duration}ms`);
+    console.log("\n\u{1F4CA} Vault Statistics\n");
+    console.log(`  Total Notes: ${report.stats.totalNotes}`);
+    console.log(`  Total Links: ${report.stats.totalLinks}`);
+    const averageLinks = report.stats.totalNotes === 0 ? 0 : report.stats.totalLinks / report.stats.totalNotes;
+    const healthScore = report.stats.totalLinks === 0 ? 100 : 100 - report.stats.brokenCount / report.stats.totalLinks * 100;
+    console.log(`  Avg Links per Note: ${averageLinks.toFixed(2)}`);
+    console.log(`  Broken Links: ${report.stats.brokenCount}`);
+    console.log(`  Orphan Notes: ${report.stats.orphanCount}`);
+    console.log(`  Connected Components: ${report.stats.connectedComponents}`);
+    console.log(`  Health Score: ${healthScore.toFixed(1)}%`);
+    const mostConnected = [...report.graph].sort((a, b) => b.incoming.length + b.outgoing.length - (a.incoming.length + a.outgoing.length)).slice(0, 5);
+    console.log("\n\u{1F310} Most Connected Notes:");
+    for (const node of mostConnected) {
+      const total = node.incoming.length + node.outgoing.length;
+      console.log(`  ${node.note.relativePath} (${total} connections: ${node.incoming.length} in, ${node.outgoing.length} out)`);
+    }
+    const lonelyNotes = report.graph.filter((n) => n.incoming.length === 0 && n.outgoing.length === 0).slice(0, 5);
+    if (lonelyNotes.length > 0) {
+      console.log("\n\u{1F534} Orphan Notes:");
+      for (const node of lonelyNotes) {
+        console.log(`  ${node.note.relativePath}`);
+      }
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail("Analysis failed");
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map