pruny 1.36.1 → 1.38.0

package/README.md

@@ -1,6 +1,8 @@
 # pruny
 
-Find and remove unused Next.js API routes & Nest.js Controllers. 🪓
+Find and remove unused code in Next.js and NestJS projects.
+
+Pruny scans your codebase using regex-based static analysis to detect unused API routes, page links, exports, files, public assets, and NestJS service methods. Works with monorepos out of the box.
 
 ## Install
 
@@ -10,67 +12,153 @@ npm install -g pruny
 npx pruny
 ```
 
-## Usage
+## What It Detects
+
+| Scanner | What it finds |
+| :------ | :------------ |
+| **API Routes** | Unused Next.js `route.ts` handlers and NestJS controller methods |
+| **Broken Links** | `<Link>`, `router.push()`, `redirect()` pointing to pages that don't exist |
+| **Unused Exports** | Named exports and class methods not imported anywhere |
+| **Unused Files** | Source files not reachable from any entry point |
+| **Unused Services** | NestJS service methods never called by controllers or other services |
+| **Public Assets** | Images/files in `public/` not referenced in code |
+| **Source Assets** | Media files in `src/` not referenced in code |
+| **Missing Assets** | References to files in `public/` that don't exist |
 
 ## CLI Commands
 
-| Command                      | Description                                                                              |
-| :--------------------------- | :--------------------------------------------------------------------------------------- |
-| `pruny`                      | Scan for unused items interactively (monorepo-aware).                                    |
-| `pruny --dir <path>`         | Set the target project directory (default: `./`).                                        |
-| `pruny --app <name>`         | Scan a specific application within a monorepo.                                           |
-| `pruny --folder <path>`      | Scan a specific folder OR sub-directory for routes/controllers.                          |
-| `pruny --fix`                | Automatically delete unused items found during scan.                                     |
-| `pruny --cleanup <items>`    | Quick cleanup: `routes`, `exports`, `public`, `files`. (e.g. `--cleanup routes,exports`) |
-| `pruny --filter <pattern>`   | Filter results by string (app name, file path, etc).                                     |
-| `pruny --ignore-apps <list>` | Comma-separated list of apps to skip in monorepos.                                       |
-| `pruny --no-public`          | Disable scanning of public assets.                                                       |
-| `pruny --json`               | Output scan results as JSON for automation.                                              |
-| `pruny -v, --verbose`        | Show detailed debug logging and trace info.                                              |
-| `pruny init`                 | Create a `pruny.config.json` configuration file.                                         |
+| Command | Description |
+| :------ | :---------- |
+| `pruny` | Interactive scan (auto-detects monorepo apps) |
+| `pruny --all` | CI mode: scan all apps, exit 1 if issues found |
+| `pruny --fix` | Interactively delete unused items |
+| `pruny --dry-run` | Simulate fix mode and output a JSON report |
+| `pruny --app <name>` | Scan a specific app in a monorepo |
+| `pruny --folder <path>` | Scan a specific folder for routes/controllers |
+| `pruny --cleanup <items>` | Quick cleanup: `routes`, `exports`, `public`, `files` |
+| `pruny --filter <pattern>` | Filter results by path or app name |
+| `pruny --ignore-apps <list>` | Skip specific apps (comma-separated) |
+| `pruny --no-public` | Skip public asset scanning |
+| `pruny --json` | Output results as JSON |
+| `pruny -v, --verbose` | Verbose debug logging |
+| `pruny --dir <path>` | Set target directory (default: `./`) |
+| `pruny -c, --config <path>` | Path to config file |
+| `pruny init` | Generate a `pruny.config.json` with defaults |
+
+## Configuration
+
+Create `pruny.config.json` in your project root (or run `pruny init`):
+
+```json
+{
+  "ignore": {
+    "routes": ["/api/webhooks/**", "/api/cron/**"],
+    "folders": ["node_modules", ".next", "dist"],
+    "files": ["*.test.ts", "*.spec.ts"],
+    "links": ["/custom-path", "/legacy/*"]
+  },
+  "extensions": [".ts", ".tsx", ".js", ".jsx"]
+}
+```
+
+### Ignore Options
+
+| Key | What it does | Example |
+| :-- | :----------- | :------ |
+| `ignore.routes` | Skip API routes matching these patterns | `["/api/webhooks/**"]` |
+| `ignore.folders` | Exclude directories from scanning | `["node_modules", "dist"]` |
+| `ignore.files` | Exclude specific files from scanning | `["*.test.ts"]` |
+| `ignore.links` | Suppress broken link warnings for these paths | `["/view_seat", "/admin/*"]` |
+
+All patterns support glob syntax (`*` matches any characters, `**` matches nested paths).
+
+Pruny also reads `.gitignore` and automatically excludes those folders.
+
+### Additional Config Options
+
+| Key | What it does |
+| :-- | :----------- |
+| `nestGlobalPrefix` | NestJS global route prefix (e.g., `"api/v1"`) |
+| `extraRoutePatterns` | Additional glob patterns to detect route files |
+| `excludePublic` | Set `true` to skip public asset scanning |
 
-### Public Asset Scanning (New in v1.1.0)
+### Config File Locations
 
-Pruny automatically scans your `public/` directory for unused images and files.
+Pruny searches for config files recursively across your project:
+- `pruny.config.json`
+- `.prunyrc.json`
+- `.prunyrc`
 
-- **Enabled by default**: Run `npx pruny` and it will show unused assets, excluding ignored folders.
-- **Disable it**: Use `--no-public` flag.
-  ```bash
-  pruny --no-public
-  ```
-- **How it works**: It checks if filenames in `public/` (e.g., `logo.png` or `/images/logo.png`) are referenced in your code.
+In monorepos, configs from multiple apps are merged together. CLI `--config` takes precedence.
 
-## Config
+## Multi-Tenant / Subdomain Routing
 
-Create `pruny.config.json` (optional):
+Pruny automatically handles multi-tenant architectures where routes live under dynamic segments like `[domain]`.
+
+For example, if your file structure is:
+```
+app/(code)/tenant_sites/[domain]/view_seat/page.tsx
+```
+
+And your components reference `/view_seat` (resolved at runtime via subdomain), Pruny recognizes this as a valid route and will **not** report it as a broken link.
+
+If auto-detection doesn't cover your case, use `ignore.links` in config:
 
 ```json
 {
-  "dir": "./",
   "ignore": {
-    "routes": ["/api/webhooks/**", "/api/cron/**"],
-    "folders": ["node_modules", ".next", "dist"],
-    "files": ["*.test.ts", "*.spec.ts"]
-  },
-  "extensions": [".ts", ".tsx", ".js", ".jsx"]
+    "links": ["/view_seat", "/review", "/custom-path"]
+  }
 }
 ```
 
-## Features
+## Monorepo Support
+
+Pruny auto-detects monorepos by looking for an `apps/` directory. It scans each app independently but checks references across the entire monorepo root.
+
+```bash
+# Scan all apps (CI-friendly, exits 1 on issues)
+pruny --all
+
+# Scan a specific app
+pruny --app web
+
+# Skip certain apps
+pruny --ignore-apps admin,docs
+```
+
+## CI Integration
 
-- 🔍 Detects unused Next.js API routes & Nest.js Controller methods
-- 🗑️ `--fix` flag to delete unused routes
-- ⚡ Auto-detects `vercel.json` cron routes
-- 📁 Default ignores: `node_modules`, `.next`, `dist`, `.git`
-- 🎨 Beautiful CLI output
+Add to your CI pipeline to catch unused code before merging:
 
-## How it works
+```bash
+npx pruny --all
+```
+
+This scans all monorepo apps and exits with code 1 if any issues are found. Combine with `--json` for machine-readable output.
+
+## How It Works
+
+1. **Route Detection**: Finds all `app/api/**/route.ts` (Next.js) and `*.controller.ts` (NestJS) files
+2. **Link Detection**: Finds `<Link>`, `router.push()`, `redirect()`, `href:` patterns and validates against known page routes
+3. **Reference Scanning**: Searches the entire codebase for string references to routes, exports, and assets
+4. **Dynamic Route Matching**: Understands `[id]`, `[...slug]`, `[[...slug]]` dynamic segments
+5. **Fix Mode**: Removes unused methods, exports, and files with a cascading second pass to catch newly dead code
+
+### Vercel Cron Detection
+
+Routes listed in `vercel.json` cron jobs are automatically marked as used:
+```json
+{ "crons": [{ "path": "/api/cron/cleanup", "schedule": "0 0 * * *" }] }
+```
+
+## Debug Mode
+
+```bash
+DEBUG_PRUNY=1 pruny
+```
 
-1. **Next.js**: Finds all `app/api/**/route.ts` files.
-2. **Nest.js**: Finds all `*.controller.ts` files and extracts mapped routes (e.g., `@Get('users')`).
-3. Scans codebase for client-side usages (e.g., `fetch`, `axios`, or string literals matching the route).
-4. Reports routes with no detected references.
-5. `--fix` deletes the unused route file or method.
+Enables verbose logging across all scanners.
 
 ## License
 

package/dist/index.js

@@ -12567,8 +12567,8 @@ import { rmSync, existsSync as existsSync9, readdirSync, lstatSync, writeFileSyn
 import { dirname as dirname5, join as join10, relative as relative5, resolve as resolve3 } from "node:path";
 
 // src/scanner.ts
-var import_fast_glob9 = __toESM(require_out4(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync8 } from "node:fs";
+var import_fast_glob10 = __toESM(require_out4(), 1);
+import { existsSync as existsSync6, readFileSync as readFileSync9 } from "node:fs";
 import { join as join7 } from "node:path";
 
 // src/patterns.ts
@@ -15729,6 +15729,192 @@ async function scanUnusedServices(config) {
   return { total: methods.length, methods };
 }
 
+// src/scanners/broken-links.ts
+var import_fast_glob9 = __toESM(require_out4(), 1);
+import { readFileSync as readFileSync8 } from "node:fs";
+var LINK_PATTERNS = [
+  /<Link\s+[^>]*href\s*=\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
+  /router\.(push|replace)\s*\(\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
+  /(?:redirect|permanentRedirect)\s*\(\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
+  /href\s*:\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
+  /<a\s+[^>]*href\s*=\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
+  /revalidatePath\s*\(\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
+  /pathname\s*===?\s*['"`](\/[^'"`\s{}$]+)['"`]/g
+];
+function extractPath(match2) {
+  if (match2[2] && match2[2].startsWith("/"))
+    return match2[2];
+  if (match2[1] && match2[1].startsWith("/"))
+    return match2[1];
+  return null;
+}
+function shouldSkipPath(path2) {
+  if (/^https?:\/\//.test(path2))
+    return true;
+  if (/^mailto:/.test(path2))
+    return true;
+  if (/^tel:/.test(path2))
+    return true;
+  if (path2 === "#" || path2.startsWith("#"))
+    return true;
+  if (path2.startsWith("/api/") || path2 === "/api")
+    return true;
+  if (path2 === "/_next" || path2.startsWith("/_next/"))
+    return true;
+  return false;
+}
+function cleanPath(path2) {
+  return path2.replace(/[?#].*$/, "").replace(/\/$/, "") || "/";
+}
+function filePathToRoute(filePath) {
+  let path2 = filePath.replace(/^src\//, "").replace(/^apps\/[^/]+\//, "").replace(/^packages\/[^/]+\//, "");
+  path2 = path2.replace(/^app\//, "").replace(/^pages\//, "");
+  path2 = path2.replace(/\/page\.(ts|tsx|js|jsx|md|mdx)$/, "");
+  path2 = path2.replace(/\.(ts|tsx|js|jsx)$/, "");
+  path2 = path2.replace(/\/index$/, "");
+  const segments = path2.split("/").filter((segment) => {
+    if (/^\([^.)][^)]*\)$/.test(segment))
+      return false;
+    if (segment.startsWith("@"))
+      return false;
+    if (/^\(\.+\)/.test(segment))
+      return false;
+    return true;
+  });
+  return "/" + segments.join("/");
+}
+function matchesRoute(refPath, routes, routeSegments) {
+  const cleaned = cleanPath(refPath);
+  if (routes.has(cleaned))
+    return true;
+  const refSegments = cleaned.split("/").filter(Boolean);
+  for (const routeSeg of routeSegments) {
+    if (matchSegments(refSegments, routeSeg))
+      return true;
+    if (matchesDynamicSuffix(refSegments, routeSeg))
+      return true;
+  }
+  return false;
+}
+function matchesDynamicSuffix(refSegments, routeSegments) {
+  if (refSegments.length >= routeSegments.length)
+    return false;
+  const prefixLen = routeSegments.length - refSegments.length;
+  const prefix = routeSegments.slice(0, prefixLen);
+  if (!prefix.some((s) => /^\[.+\]$/.test(s)))
+    return false;
+  const tail = routeSegments.slice(prefixLen);
+  return matchSegments(refSegments, tail);
+}
+function matchSegments(refSegments, routeSegments) {
+  let ri = 0;
+  let si = 0;
+  while (ri < refSegments.length && si < routeSegments.length) {
+    const routeSeg = routeSegments[si];
+    if (/^\[\[?\.\.\./.test(routeSeg))
+      return true;
+    if (/^\[.+\]$/.test(routeSeg)) {
+      ri++;
+      si++;
+      continue;
+    }
+    if (refSegments[ri].toLowerCase() !== routeSeg.toLowerCase())
+      return false;
+    ri++;
+    si++;
+  }
+  return ri === refSegments.length && si === routeSegments.length;
+}
+async function scanBrokenLinks(config) {
+  const appDir = config.appSpecificScan ? config.appSpecificScan.appDir : config.dir;
+  const pagePatterns = [
+    "app/**/page.{ts,tsx,js,jsx,md,mdx}",
+    "src/app/**/page.{ts,tsx,js,jsx,md,mdx}",
+    "pages/**/*.{ts,tsx,js,jsx}",
+    "src/pages/**/*.{ts,tsx,js,jsx}"
+  ];
+  const pageFiles = await import_fast_glob9.default(pagePatterns, {
+    cwd: appDir,
+    ignore: [...config.ignore.folders, "**/node_modules/**", "**/_*/**"]
+  });
+  if (pageFiles.length === 0) {
+    return { total: 0, links: [] };
+  }
+  const knownRoutes = new Set;
+  const routeSegmentsList = [];
+  knownRoutes.add("/");
+  for (const file of pageFiles) {
+    const route = filePathToRoute(file);
+    knownRoutes.add(route);
+    const segments = route.split("/").filter(Boolean);
+    if (segments.some((s) => s.startsWith("["))) {
+      routeSegmentsList.push(segments);
+    }
+  }
+  if (process.env.DEBUG_PRUNY) {
+    console.log(`[DEBUG] Known routes: ${Array.from(knownRoutes).join(", ")}`);
+  }
+  const refDir = config.appSpecificScan ? config.appSpecificScan.rootDir : config.dir;
+  const ignore = [...config.ignore.folders, ...config.ignore.files, "**/node_modules/**"];
+  const extensions = config.extensions;
+  const globPattern = `**/*{${extensions.join(",")}}`;
+  const sourceFiles = await import_fast_glob9.default(globPattern, {
+    cwd: refDir,
+    ignore,
+    absolute: true
+  });
+  const brokenMap = new Map;
+  for (const file of sourceFiles) {
+    try {
+      const content = readFileSync8(file, "utf-8");
+      for (const pattern of LINK_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match2;
+        while ((match2 = pattern.exec(content)) !== null) {
+          const rawPath = extractPath(match2);
+          if (!rawPath)
+            continue;
+          if (shouldSkipPath(rawPath))
+            continue;
+          const cleaned = cleanPath(rawPath);
+          if (!cleaned || cleaned === "/")
+            continue;
+          if (!matchesRoute(cleaned, knownRoutes, routeSegmentsList)) {
+            const ignorePatterns = [
+              ...config.ignore.links || [],
+              ...config.ignore.routes
+            ];
+            const isIgnored = ignorePatterns.some((ignorePath) => {
+              const pattern2 = ignorePath.replace(/\*/g, ".*");
+              return new RegExp(`^${pattern2}$`).test(cleaned);
+            });
+            if (isIgnored)
+              continue;
+            const lineNumber = content.substring(0, match2.index).split(`
+`).length;
+            if (!brokenMap.has(cleaned)) {
+              brokenMap.set(cleaned, new Set);
+            }
+            brokenMap.get(cleaned).add(`${file}:${lineNumber}`);
+          }
+        }
+      }
+    } catch (_e) {}
+  }
+  const links = [];
+  for (const [path2, refs] of brokenMap.entries()) {
+    links.push({
+      path: path2,
+      references: Array.from(refs).sort()
+    });
+  }
+  links.sort((a, b) => b.references.length - a.references.length);
+  return {
+    total: links.length,
+    links
+  };
+}
+
 // src/scanner.ts
 function extractRoutePath(filePath) {
   let path2 = filePath.replace(/^src\//, "").replace(/^apps\/[^/]+\//, "").replace(/^packages\/[^/]+\//, "");
@@ -15834,19 +16020,19 @@ function extractNestMethodName(content) {
   return "";
 }
 function shouldIgnore(path2, ignorePatterns) {
-  const cleanPath = path2.replace(/\\/g, "/").replace(/^\//, "").replace(/^\.\//, "");
+  const cleanPath2 = path2.replace(/\\/g, "/").replace(/^\//, "").replace(/^\.\//, "");
   return ignorePatterns.some((pattern) => {
     let cleanPattern = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
     const isAbsolute4 = cleanPattern.startsWith("/");
     if (isAbsolute4)
       cleanPattern = cleanPattern.substring(1);
-    if (minimatch(cleanPath, cleanPattern))
+    if (minimatch(cleanPath2, cleanPattern))
       return true;
     const folderPattern = cleanPattern.endsWith("/") ? cleanPattern : cleanPattern + "/";
-    if (cleanPath.startsWith(folderPattern))
+    if (cleanPath2.startsWith(folderPattern))
       return true;
     if (!isAbsolute4 && !cleanPattern.includes("/") && !cleanPattern.includes("*")) {
-      if (cleanPath.endsWith("/" + cleanPattern) || cleanPath === cleanPattern)
+      if (cleanPath2.endsWith("/" + cleanPattern) || cleanPath2 === cleanPattern)
         return true;
     }
     return false;
@@ -15863,9 +16049,9 @@ async function detectGlobalPrefix(appDir) {
   const mainTsAltPath = join7(appDir, "main.ts");
   let content;
   if (existsSync6(mainTsPath)) {
-    content = readFileSync8(mainTsPath, "utf-8");
+    content = readFileSync9(mainTsPath, "utf-8");
   } else if (existsSync6(mainTsAltPath)) {
-    content = readFileSync8(mainTsAltPath, "utf-8");
+    content = readFileSync9(mainTsAltPath, "utf-8");
   } else {
     return "";
   }
@@ -15927,7 +16113,7 @@ function getVercelCronPaths(dir) {
     return [];
   }
   try {
-    const content = readFileSync8(vercelPath, "utf-8");
+    const content = readFileSync9(vercelPath, "utf-8");
     const config = JSON.parse(content);
     if (!config.crons) {
       return [];
@@ -15963,13 +16149,13 @@ async function scan(config) {
     if (prefix)
       detectedGlobalPrefix = prefix;
   }
-  const nextFiles = await import_fast_glob9.default(activeNextPatterns, {
+  const nextFiles = await import_fast_glob10.default(activeNextPatterns, {
     cwd: scanCwd,
     ignore: config.ignore.folders
   });
   const nextRoutes = nextFiles.map((file) => {
     const fullPath = join7(scanCwd, file);
-    const content = readFileSync8(fullPath, "utf-8");
+    const content = readFileSync9(fullPath, "utf-8");
     const { methods, methodLines } = extractExportedMethods(content);
     return {
       type: "nextjs",
@@ -15983,13 +16169,13 @@ async function scan(config) {
     };
   });
   const nestPatterns = ["**/*.controller.ts"];
-  const nestFiles = await import_fast_glob9.default(nestPatterns, {
+  const nestFiles = await import_fast_glob10.default(nestPatterns, {
     cwd: scanCwd,
     ignore: config.ignore.folders
   });
   const nestRoutes = nestFiles.flatMap((file) => {
     const fullPath = join7(scanCwd, file);
-    const content = readFileSync8(fullPath, "utf-8");
+    const content = readFileSync9(fullPath, "utf-8");
     const relativePathFromRoot = fullPath.replace(config.appSpecificScan ? config.appSpecificScan.rootDir + "/" : cwd + "/", "");
     return extractNestRoutes(relativePathFromRoot, content, detectedGlobalPrefix);
   });
@@ -16009,7 +16195,7 @@ async function scan(config) {
   }
   const referenceScanCwd = config.appSpecificScan ? config.appSpecificScan.rootDir : cwd;
   const extGlob = `**/*{${config.extensions.join(",")}}`;
-  const sourceFiles = await import_fast_glob9.default(extGlob, {
+  const sourceFiles = await import_fast_glob10.default(extGlob, {
     cwd: referenceScanCwd,
     ignore: [...config.ignore.folders, ...config.ignore.files]
   });
@@ -16018,7 +16204,7 @@ async function scan(config) {
   for (const file of sourceFiles) {
     const filePath = join7(referenceScanCwd, file);
     try {
-      const content = readFileSync8(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       const refs = extractApiReferences(content);
       if (refs.length > 0) {
         fileReferences.set(file, refs);
@@ -16065,6 +16251,7 @@ async function scan(config) {
     routes,
     publicAssets,
     missingAssets: await scanMissingAssets(config),
+    brokenLinks: await scanBrokenLinks(config),
     unusedFiles,
     unusedExports: await scanUnusedExports(config).then((result) => {
       const filtered = result.exports.filter((exp) => !exp.file.endsWith(".controller.ts") && !exp.file.endsWith(".controller.tsx"));
@@ -16076,8 +16263,8 @@ async function scan(config) {
 }
 
 // src/config.ts
-var import_fast_glob10 = __toESM(require_out4(), 1);
-import { existsSync as existsSync7, readFileSync as readFileSync9 } from "node:fs";
+var import_fast_glob11 = __toESM(require_out4(), 1);
+import { existsSync as existsSync7, readFileSync as readFileSync10 } from "node:fs";
 import { join as join8, resolve as resolve2, relative as relative4, dirname as dirname4 } from "node:path";
 var DEFAULT_CONFIG = {
   dir: "./",
@@ -16092,7 +16279,8 @@ var DEFAULT_CONFIG = {
       "**/.git/**",
       "**/coverage/**"
     ],
-    files: []
+    files: [],
+    links: []
   },
   extensions: [".ts", ".tsx", ".js", ".jsx"],
   nestGlobalPrefix: "",
@@ -16100,7 +16288,7 @@ var DEFAULT_CONFIG = {
 };
 function loadConfig(options) {
   const cwd = options.dir || "./";
-  const configFiles = import_fast_glob10.default.sync(["**/pruny.config.json", "**/.prunyrc.json", "**/.prunyrc"], {
+  const configFiles = import_fast_glob11.default.sync(["**/pruny.config.json", "**/.prunyrc.json", "**/.prunyrc"], {
     cwd,
     ignore: DEFAULT_CONFIG.ignore.folders,
     absolute: true
@@ -16118,7 +16306,8 @@ function loadConfig(options) {
   const mergedIgnore = {
     routes: [...DEFAULT_CONFIG.ignore.routes || []],
     folders: [...DEFAULT_CONFIG.ignore.folders || []],
-    files: [...DEFAULT_CONFIG.ignore.files || []]
+    files: [...DEFAULT_CONFIG.ignore.files || []],
+    links: [...DEFAULT_CONFIG.ignore.links || []]
   };
   let mergedExtensions = [...DEFAULT_CONFIG.extensions];
   let nestGlobalPrefix = DEFAULT_CONFIG.nestGlobalPrefix;
@@ -16126,7 +16315,7 @@ function loadConfig(options) {
   let excludePublic = options.excludePublic ?? false;
   for (const configPath of configFiles) {
     try {
-      const content = readFileSync9(configPath, "utf-8");
+      const content = readFileSync10(configPath, "utf-8");
       const config = JSON.parse(content);
       const configDir = dirname4(configPath);
       const relDir = relative4(cwd, configDir);
@@ -16142,6 +16331,8 @@ function loadConfig(options) {
         mergedIgnore.folders.push(...config.ignore.folders.map(prefixPattern));
       if (config.ignore?.files)
         mergedIgnore.files.push(...config.ignore.files.map(prefixPattern));
+      if (config.ignore?.links)
+        mergedIgnore.links.push(...config.ignore.links);
       if (config.extensions)
         mergedExtensions = [...new Set([...mergedExtensions, ...config.extensions])];
       if (config.nestGlobalPrefix)
@@ -16159,6 +16350,7 @@ function loadConfig(options) {
   mergedIgnore.routes = [...new Set(mergedIgnore.routes)];
   mergedIgnore.folders = [...new Set(mergedIgnore.folders)];
   mergedIgnore.files = [...new Set(mergedIgnore.files)];
+  mergedIgnore.links = [...new Set(mergedIgnore.links)];
   return {
     dir: cwd,
     ignore: mergedIgnore,
@@ -16173,7 +16365,7 @@ function parseGitIgnore(dir) {
   if (!existsSync7(gitIgnorePath))
     return [];
   try {
-    const content = readFileSync9(gitIgnorePath, "utf-8");
+    const content = readFileSync10(gitIgnorePath, "utf-8");
     return content.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((pattern) => {
       if (pattern.startsWith("/") || pattern.startsWith("**/"))
@@ -16448,6 +16640,10 @@ function filterResults(result, filterPattern) {
     result.unusedExports.total = result.unusedExports.exports.length;
     result.unusedExports.unused = result.unusedExports.exports.length;
   }
+  if (result.brokenLinks) {
+    result.brokenLinks.links = result.brokenLinks.links.filter((l) => matchesFilter(l.path, filter2));
+    result.brokenLinks.total = result.brokenLinks.links.length;
+  }
   result.total = result.routes.length;
   result.used = result.routes.filter((r) => r.used).length;
   result.unused = result.routes.filter((r) => !r.used).length;
@@ -16525,6 +16721,17 @@ function printDetailedReport(result) {
     }
     console.log("");
   }
+  if (result.brokenLinks && result.brokenLinks.total > 0) {
+    console.log(source_default.red.bold(`\uD83D\uDD17 Broken Internal Links:
+`));
+    for (const link of result.brokenLinks.links) {
+      console.log(source_default.red(`   ${link.path}`));
+      for (const ref of link.references) {
+        console.log(source_default.dim(`      → ${ref}`));
+      }
+    }
+    console.log("");
+  }
   if (!hasUnusedItems(result)) {
     console.log(source_default.green(`✅ Everything is used! Clean as a whistle.
 `));
@@ -16538,10 +16745,11 @@ function countIssues(result) {
   const partialRoutes = result.routes.filter((r) => r.used && r.unusedMethods.length > 0).length;
   const unusedAssets = result.publicAssets ? result.publicAssets.unused : 0;
   const missingAssets = result.missingAssets ? result.missingAssets.total : 0;
+  const brokenLinks = result.brokenLinks ? result.brokenLinks.total : 0;
   const unusedFiles = result.unusedFiles ? result.unusedFiles.unused : 0;
   const unusedExports = result.unusedExports ? result.unusedExports.unused : 0;
   const unusedServices = result.unusedServices ? result.unusedServices.total : 0;
-  return unusedRoutes + partialRoutes + unusedAssets + missingAssets + unusedFiles + unusedExports + unusedServices;
+  return unusedRoutes + partialRoutes + unusedAssets + missingAssets + brokenLinks + unusedFiles + unusedExports + unusedServices;
 }
 async function handleFixes(result, config, options, showBack) {
   const gitRoot = findGitRoot(config.dir);
@@ -16619,6 +16827,11 @@ Analyzing cascading impact...`));
       const title = count > 0 ? `⚠ Missing Assets (Broken Links) (${count})` : `✅ Missing Assets (0) - All good!`;
       choices.push({ title, value: "missing-assets" });
     }
+    if (result.brokenLinks) {
+      const count = result.brokenLinks.total;
+      const title = count > 0 ? `\uD83D\uDD17 Broken Internal Links (${count})` : `✅ Internal Links (0) - All good!`;
+      choices.push({ title, value: "broken-links" });
+    }
     if (showBack) {
       choices.push({ title: source_default.cyan("← Back"), value: "back" });
     }
@@ -16688,7 +16901,8 @@ Analyzing cascading impact...`));
         exports: [],
         files: [],
         assets: [],
-        missingAssets: []
+        missingAssets: [],
+        brokenLinks: []
       };
       if (selected === "routes" || selected === "dry-run-json" || action === "dry-run") {
         dryRunReport.routes = targetRoutes.map((r) => ({
@@ -16759,6 +16973,14 @@ Analyzing cascading impact...`));
         }));
         dryRunReport.uniqueFiles = missingList.length;
       }
+      if (selected === "broken-links") {
+        const brokenList = result.brokenLinks?.links || [];
+        dryRunReport.brokenLinks = brokenList.map((l) => ({
+          path: l.path,
+          references: l.references
+        }));
+        dryRunReport.uniqueFiles = brokenList.length;
+      }
       const reportPath = join10(process.cwd(), "pruny-dry-run.json");
       writeFileSync3(reportPath, JSON.stringify(dryRunReport, null, 2));
       console.log(source_default.green(`
@@ -16767,6 +16989,25 @@ Analyzing cascading impact...`));
     }
     const selectedList = options.cleanup ? options.cleanup.split(",").map((s) => s.trim()) : [selected];
     let fixedSomething = false;
+    if (selectedList.includes("broken-links")) {
+      if (result.brokenLinks && result.brokenLinks.total > 0) {
+        console.log(source_default.yellow.bold(`
+\uD83D\uDD17 Broken Internal Links Detected:`));
+        console.log(source_default.gray("   (These links point to pages that don't exist. Please fix or remove them:)"));
+        for (const link of result.brokenLinks.links) {
+          console.log(source_default.red.bold(`
+   ❌ ${link.path}`));
+          for (const ref of link.references) {
+            console.log(source_default.gray(`      ➜ ${ref}`));
+          }
+        }
+        console.log(source_default.yellow(`
+   Create the missing pages or update the links to valid routes.`));
+      } else {
+        console.log(source_default.green(`
+✅ No broken internal links found! All links are valid.`));
+      }
+    }
     if (selectedList.includes("missing-assets")) {
       if (result.missingAssets && result.missingAssets.total > 0) {
         console.log(source_default.yellow.bold(`
@@ -17149,6 +17390,14 @@ function printSummaryTable(result, context) {
       Unused: result.missingAssets.total
     });
   }
+  if (result.brokenLinks && result.brokenLinks.total > 0) {
+    summary.push({
+      Category: source_default.red.bold("\uD83D\uDD17 Broken Links"),
+      Total: result.brokenLinks.total,
+      Used: "-",
+      Unused: result.brokenLinks.total
+    });
+  }
   if (result.unusedFiles)
     summary.push({ Category: "Code Files (.ts/.js)", Total: result.unusedFiles.used + result.unusedFiles.unused, Used: result.unusedFiles.used, Unused: result.unusedFiles.unused });
   if (result.unusedExports)
@@ -17184,6 +17433,19 @@ function printSummaryTable(result, context) {
     console.log(source_default.yellow(`
    These files are referenced in code but don't exist. Update the links or create the files.`));
   }
+  if (result.brokenLinks && result.brokenLinks.total > 0) {
+    console.log(source_default.red.bold(`
+\uD83D\uDD17 Broken Internal Links:
+`));
+    for (const link of result.brokenLinks.links) {
+      console.log(source_default.red(`   ✗ ${link.path}`));
+      for (const ref of link.references) {
+        console.log(source_default.dim(`     → ${ref}`));
+      }
+    }
+    console.log(source_default.yellow(`
+   These links point to pages/routes that don't exist. Create the pages or fix the links.`));
+  }
 }
 function printConsolidatedTable(allResults) {
   console.log(source_default.bold(`\uD83D\uDCCA Monorepo Summary

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pruny",
-  "version": "1.36.1",
+  "version": "1.38.0",
   "description": "Find and remove unused Next.js API routes & Nest.js Controllers",
   "type": "module",
   "files": [