@mintlify/link-rot 3.0.1037 → 3.0.1039

package/dist/graph.d.ts

@@ -67,6 +67,7 @@ export declare class Graph {
     private edges;
     private fileResolutionMap;
     private redirectMap;
+    private configRedirects;
     private mintIgnoreGlobs;
     private virtualNodes;
     constructor(baseDir: string, mintIgnoreGlobs?: string[]);
@@ -88,6 +89,10 @@ export declare class Graph {
     getBrokenInternalLinks(options?: {
         checkAnchors?: boolean;
     }): MdxPath[];
+    getBrokenRedirects(): {
+        source: string;
+        destination: string;
+    }[];
     getExternalPathsByNode(): Map<string, MdxPath[]>;
     getAllInternalPaths(): string[];
 }

package/dist/graph.js

@@ -3,7 +3,7 @@ import { getFileListWithDirectories } from '@mintlify/prebuild';
 import { existsSync } from 'fs';
 import { parse, join, resolve, relative, dirname, basename } from 'path';
 import { sep as WINDOWS_SEPARATOR } from 'path/win32';
-import { getLinkPaths, normalizePath } from './prebuild.js';
+import { getLinkPaths, normalizePath, removeSelectors } from './prebuild.js';
 var PathType;
 (function (PathType) {
     PathType["INTERNAL"] = "internal";
@@ -216,6 +216,7 @@ export class Graph {
         this.edges = [];
         this.fileResolutionMap = new Map();
         this.redirectMap = new Map();
+        this.configRedirects = [];
         this.mintIgnoreGlobs = [];
         this.virtualNodes = new Set();
         this.baseDir = resolve(baseDir);
@@ -239,6 +240,8 @@ export class Graph {
         }
     }
     setRedirects(redirects) {
+        this.configRedirects = redirects;
+        this.redirectMap.clear();
         for (const redirect of redirects) {
             this.redirectMap.set(normalizePath(redirect.source), normalizePath(redirect.destination));
         }
@@ -404,6 +407,63 @@ export class Graph {
         }
         return brokenLinks;
     }
+    getBrokenRedirects() {
+        const nodeSet = new Set(Object.values(this.nodes).map((node) => node.toString()));
+        const hasWildcard = (pattern) => /[:*]/.test(pattern);
+        const resolvesToValidPath = (rawDestination, visited) => {
+            if (URL.canParse(rawDestination))
+                return true;
+            const pathOnly = removeSelectors(rawDestination);
+            if (!pathOnly)
+                return true;
+            // Wildcard path destinations can't be validated as concrete paths — treat as valid,
+            // matching the top-level skip semantics. Checked after stripping so `:` or `*` in
+            // the fragment/query doesn't cause a false skip.
+            if (hasWildcard(pathOnly))
+                return true;
+            const normalized = normalizePath(pathOnly);
+            if (visited.has(normalized))
+                return false;
+            visited.add(normalized);
+            // normalizePath('/') yields '.' — resolve lookups against node labels (which use
+            // path.join, so `join('.', 'index.mdx') === 'index.mdx'`) rather than naive
+            // string concatenation that would produce './index.mdx' and never match.
+            const fileCandidates = normalized === '.'
+                ? ['index.mdx', 'index.md']
+                : [
+                    normalized,
+                    `${normalized}.mdx`,
+                    `${normalized}.md`,
+                    join(normalized, 'index.mdx'),
+                    join(normalized, 'index.md'),
+                ];
+            if (fileCandidates.some((candidate) => nodeSet.has(candidate)) ||
+                this.virtualNodes.has(normalized)) {
+                return true;
+            }
+            const chained = this.redirectMap.get(normalized);
+            if (chained !== undefined)
+                return resolvesToValidPath(chained, visited);
+            for (const [sourcePattern, destinationPattern] of this.redirectMap.entries()) {
+                if (hasWildcard(sourcePattern) && this.matchesWildcardPattern(normalized, sourcePattern)) {
+                    const resolved = this.applyWildcardRedirect(normalized, sourcePattern, destinationPattern);
+                    return resolvesToValidPath(resolved, visited);
+                }
+            }
+            return false;
+        };
+        const broken = [];
+        for (const { source, destination } of this.configRedirects) {
+            if (URL.canParse(destination))
+                continue;
+            if (hasWildcard(removeSelectors(destination)))
+                continue;
+            if (!resolvesToValidPath(destination, new Set())) {
+                broken.push({ source, destination });
+            }
+        }
+        return broken;
+    }
     getExternalPathsByNode() {
         const result = new Map();
         for (const [label, node] of Object.entries(this.nodes)) {

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { buildGraph, getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
 export { getBrokenExternalLinks } from './static-checking/getBrokenExternalLinks.js';
 export type { ExternalLinkResult } from './static-checking/getBrokenExternalLinks.js';
+export { getBrokenRedirects } from './static-checking/getBrokenRedirects.js';
 export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export { buildGraph, getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
 export { getBrokenExternalLinks } from './static-checking/getBrokenExternalLinks.js';
+export { getBrokenRedirects } from './static-checking/getBrokenRedirects.js';
 export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/static-checking/getBrokenRedirects.d.ts

@@ -0,0 +1,6 @@
+export declare const getBrokenRedirects: (repoPath?: string, options?: {
+    checkSnippets?: boolean;
+}) => Promise<{
+    source: string;
+    destination: string;
+}[]>;

package/dist/static-checking/getBrokenRedirects.js

@@ -0,0 +1,16 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { buildGraph } from './getBrokenInternalLinks.js';
+export const getBrokenRedirects = (repoPath, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const graph = yield buildGraph(repoPath, {
+        checkSnippets: options === null || options === void 0 ? void 0 : options.checkSnippets,
+    });
+    return graph.getBrokenRedirects();
+});

package/dist/static-checking/getNavigationHrefs.js

@@ -7,8 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import fs from 'fs-extra';
-import path from 'path';
+import { readResolvedConfigJson } from './readConfig.js';
 const collectHrefs = (obj) => {
     if (typeof obj !== 'object' || obj === null)
         return [];
@@ -25,17 +24,13 @@ const collectHrefs = (obj) => {
     return hrefs;
 };
 export const getNavigationHrefs = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
-    let configJson;
-    let configFile;
-    if (fs.existsSync(path.join(baseDir, 'docs.json'))) {
-        configJson = yield fs.readJSON(path.join(baseDir, 'docs.json'));
-        configFile = 'docs.json';
-    }
-    else if (fs.existsSync(path.join(baseDir, 'mint.json'))) {
-        configJson = yield fs.readJSON(path.join(baseDir, 'mint.json'));
-        configFile = 'mint.json';
-    }
-    if (!(configJson === null || configJson === void 0 ? void 0 : configJson.navigation) || !configFile)
+    const resolved = yield readResolvedConfigJson(baseDir);
+    if (!resolved)
+        return undefined;
+    if (!resolved.json.navigation)
         return undefined;
-    return { hrefs: collectHrefs(configJson.navigation), configFile };
+    return {
+        hrefs: collectHrefs(resolved.json.navigation),
+        configFile: resolved.configFile,
+    };
 });

package/dist/static-checking/getOpenApiPagePaths.d.ts

@@ -2,7 +2,12 @@
  * Extract virtual page paths that would be generated from OpenAPI specs.
  * These pages don't exist as files but are valid link targets.
  *
- * Note: Uses api.openapi.directory from docs.json, or falls back to 'api-reference'.
- * Per-navigation directory configs are not currently supported.
+ * For docs.json (v2) configs, this walks the navigation tree so that per-spec
+ * `directory` overrides and inherited directories are honored — matching the
+ * slugs production generates. For mint.json (v1) or missing configs, it falls
+ * back to generating page paths under the default `api-reference` directory.
+ *
+ * `$ref` pointers inside the config are resolved first, so navigation split
+ * across multiple JSON files is walked end-to-end.
  */
 export declare const getOpenApiPagePaths: (baseDir: string) => Promise<string[]>;

package/dist/static-checking/getOpenApiPagePaths.js

@@ -7,52 +7,52 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { categorizeFilePaths } from '@mintlify/prebuild';
+import { categorizeFilePaths, generateOpenApiFromDocsConfig, getOpenApiFilesFromConfig, } from '@mintlify/prebuild';
 import { generateOpenApiPagesForDocsConfig } from '@mintlify/scraping';
 import { validateDocsConfig } from '@mintlify/validation';
-import fs from 'fs-extra';
-import path from 'path';
+import { readResolvedConfigJson } from './readConfig.js';
 const DEFAULT_OUTPUT_DIR = 'api-reference';
-const getOpenApiDirectory = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const docsJsonPath = path.join(baseDir, 'docs.json');
-    if (!fs.existsSync(docsJsonPath))
-        return DEFAULT_OUTPUT_DIR;
-    try {
-        const docsJson = yield fs.readJSON(docsJsonPath);
-        const result = validateDocsConfig(docsJson);
-        if (!result.success)
-            return DEFAULT_OUTPUT_DIR;
-        const openapi = (_a = result.data.api) === null || _a === void 0 ? void 0 : _a.openapi;
-        if (typeof openapi === 'object' && 'directory' in openapi && openapi.directory) {
-            return openapi.directory;
-        }
-    }
-    catch (_b) {
-        throw new Error('Unable to parse OpenAPI directory from docs.json');
-    }
-    return DEFAULT_OUTPUT_DIR;
-});
 /**
  * Extract virtual page paths that would be generated from OpenAPI specs.
  * These pages don't exist as files but are valid link targets.
  *
- * Note: Uses api.openapi.directory from docs.json, or falls back to 'api-reference'.
- * Per-navigation directory configs are not currently supported.
+ * For docs.json (v2) configs, this walks the navigation tree so that per-spec
+ * `directory` overrides and inherited directories are honored — matching the
+ * slugs production generates. For mint.json (v1) or missing configs, it falls
+ * back to generating page paths under the default `api-reference` directory.
+ *
+ * `$ref` pointers inside the config are resolved first, so navigation split
+ * across multiple JSON files is walked end-to-end.
  */
 export const getOpenApiPagePaths = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
     const pagePaths = [];
     try {
-        const [{ openApiFiles }, outDir] = yield Promise.all([
-            categorizeFilePaths(baseDir),
-            getOpenApiDirectory(baseDir),
-        ]);
+        const { openApiFiles } = yield categorizeFilePaths(baseDir);
+        const docsConfig = yield readDocsConfig(baseDir);
+        if (docsConfig) {
+            const urlOpenApiFiles = yield safeGetOpenApiFilesFromConfig(docsConfig);
+            const allOpenApiFiles = [...openApiFiles, ...urlOpenApiFiles];
+            const pagesAcc = {};
+            try {
+                yield generateOpenApiFromDocsConfig(docsConfig.navigation, allOpenApiFiles, pagesAcc, {
+                    writeFiles: false,
+                });
+            }
+            catch (err) {
+                console.warn(`Warning: Failed to extract OpenAPI pages from navigation: ${err}`);
+            }
+            pagePaths.push(...Object.keys(pagesAcc));
+        }
+        // Also enumerate default-directory pages per local spec. This preserves
+        // the previous behavior for configs that don't wire every OpenAPI file
+        // into `navigation`, and keeps us permissive (extra virtual nodes can
+        // only hide broken-link reports, never add false positives).
         for (const openApiFile of openApiFiles) {
             try {
                 const { pagesAcc } = yield generateOpenApiPagesForDocsConfig(openApiFile.spec, {
                     openApiFilePath: openApiFile.originalFileLocation,
                     writeFiles: false,
-                    outDir,
+                    outDir: DEFAULT_OUTPUT_DIR,
                 });
                 pagePaths.push(...Object.keys(pagesAcc));
             }
@@ -66,3 +66,19 @@ export const getOpenApiPagePaths = (baseDir) => __awaiter(void 0, void 0, void 0
     }
     return [...new Set(pagePaths)];
 });
+const readDocsConfig = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
+    const resolved = yield readResolvedConfigJson(baseDir);
+    if (!resolved || resolved.configFile !== 'docs.json')
+        return null;
+    const result = validateDocsConfig(resolved.json);
+    return result.success ? result.data : null;
+});
+const safeGetOpenApiFilesFromConfig = (docsConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield getOpenApiFilesFromConfig('docs', docsConfig);
+    }
+    catch (err) {
+        console.warn(`Warning: Failed to fetch URL-based OpenAPI specs: ${err}`);
+        return [];
+    }
+});

package/dist/static-checking/getRedirects.js

@@ -7,25 +7,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { validateDocsConfig, validateMintConfig } from '@mintlify/validation';
-import fs from 'fs-extra';
-import path from 'path';
+import { readResolvedConfigJsonAndValidate } from './readConfig.js';
 export const getRedirects = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
     const configRedirects = [];
-    // read docs.json or mint.json to get redirects
-    if (fs.existsSync(path.join(baseDir, 'docs.json'))) {
-        const docsJson = yield fs.readJSON(path.join(baseDir, 'docs.json'));
-        const result = validateDocsConfig(docsJson);
-        if (result.success && 'redirects' in result.data && result.data.redirects) {
-            configRedirects.push(...result.data.redirects);
-        }
-    }
-    else if (fs.existsSync(path.join(baseDir, 'mint.json'))) {
-        const mintJson = yield fs.readJSON(path.join(baseDir, 'mint.json'));
-        const result = validateMintConfig(mintJson);
-        if (result.success && 'redirects' in result.data && result.data.redirects) {
-            configRedirects.push(...result.data.redirects);
-        }
+    const result = yield readResolvedConfigJsonAndValidate(baseDir);
+    if (!result)
+        return configRedirects;
+    if (result.success && 'redirects' in result.data && result.data.redirects) {
+        configRedirects.push(...result.data.redirects);
     }
     return configRedirects;
 });