@mintlify/prebuild 1.0.779 → 1.0.780

package/dist/prebuild/update/git/getGitBlame.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets git blame data for a file, returning a map of line numbers to ISO date strings.
+ * Uses author-time (when the change was originally created) rather than committer-time.
+ * @param filePath - Absolute path to the file
+ * @param repoPath - Path to the git repository root
+ * @returns Record<number, string> mapping line numbers (1-indexed) to ISO date strings
+ */
+export declare const getGitBlame: (filePath: string, repoPath: string) => Promise<Record<number, string>>;

package/dist/prebuild/update/git/getGitBlame.js

@@ -0,0 +1,62 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Gets git blame data for a file, returning a map of line numbers to ISO date strings.
+ * Uses author-time (when the change was originally created) rather than committer-time.
+ * @param filePath - Absolute path to the file
+ * @param repoPath - Path to the git repository root
+ * @returns Record<number, string> mapping line numbers (1-indexed) to ISO date strings
+ */
+export const getGitBlame = async (filePath, repoPath) => {
+    try {
+        // Make file path relative to repo root for git blame
+        const relativeFilePath = filePath.startsWith(repoPath)
+            ? filePath.substring(repoPath.length + 1)
+            : filePath;
+        // Use git blame with porcelain format for easier parsing
+        // --line-porcelain gives us detailed info for each line
+        const { stdout } = await execAsync(`git blame --line-porcelain "${relativeFilePath}"`, {
+            cwd: repoPath,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large files
+        });
+        const lineBlame = {};
+        const lines = stdout.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            // Line starting with commit hash indicates a new blame entry
+            // Format: <commit-hash> <original-line> <final-line> <num-lines>
+            const commitMatch = line.match(/^[0-9a-f]{40}\s+\d+\s+(\d+)/);
+            if (commitMatch && commitMatch[1]) {
+                const lineNumber = parseInt(commitMatch[1], 10);
+                // Look ahead for 'author-time' field (Unix timestamp)
+                let authorTime;
+                for (let j = i + 1; j < lines.length && j < i + 15; j++) {
+                    const nextLine = lines[j];
+                    if (!nextLine)
+                        continue;
+                    if (nextLine.startsWith('author-time ')) {
+                        const timestamp = parseInt(nextLine.substring('author-time '.length), 10);
+                        authorTime = new Date(timestamp * 1000).toISOString();
+                        break;
+                    }
+                    // Stop when we hit the content line (starts with tab)
+                    if (nextLine.startsWith('\t')) {
+                        break;
+                    }
+                }
+                if (authorTime) {
+                    lineBlame[lineNumber] = authorTime;
+                }
+            }
+        }
+        return lineBlame;
+    }
+    catch (error) {
+        // If git blame fails (e.g., file not in git, no commits), silently return empty blame
+        // Server will use current date as fallback
+        return {};
+    }
+};

package/dist/prebuild/update/index.d.ts

@@ -2279,7 +2279,9 @@ export declare const update: ({ contentDirectoryPath, staticFilenames, openApiFi
 }>;
 export declare const writeMdxFilesWithNoImports: (mdxFilesWithNoImports: {
     targetPath: string;
+    sourcePath: string;
     tree: Root;
+    metadata: unknown;
 }[]) => Promise<void>[];
 export * from './mintConfig/index.js';
 export * from './docsConfig/index.js';

package/dist/prebuild/update/index.js

@@ -1,6 +1,7 @@
 import { stringifyTree, containsUpdates } from '@mintlify/common';
 import { upgradeToDocsConfig } from '@mintlify/validation';
 import { outputFile } from 'fs-extra';
+import { join } from 'path';
 import { updateDocsConfigFile } from './docsConfig/index.js';
 import { updateMintConfigFile } from './mintConfig/index.js';
 import { readPageContents, readSnippetsV2Contents } from './read/readContent.js';
@@ -36,7 +37,49 @@ export const update = async ({ contentDirectoryPath, staticFilenames, openApiFil
         snippetV2Promises,
         pagePromises,
     ]);
-    const rssPages = mdxFilesWithNoImports.filter((page) => containsUpdates(page.tree));
+    // Filter pages with rss: true in frontmatter OR pages that contain Update components
+    const rssPages = mdxFilesWithNoImports.filter((page) => page.metadata.rss === true || containsUpdates(page.tree));
+    // Also include RSS pages that have imports (e.g., changelog entries as separate snippet files)
+    // For these, we need to extract the snippets using the importMap and include the component names
+    // so they can be properly resolved on the server side
+    const rssPagesWithImports = filesWithImports
+        .filter((file) => {
+        // Check if the file has rss: true metadata
+        if (file.metadata?.rss === true) {
+            return true;
+        }
+        // Check if the file itself contains Update components
+        if (containsUpdates(file.tree)) {
+            return true;
+        }
+        // Check if any of the imported snippets contain Update components
+        const importedSnippets = Object.keys(file.importMap).map((importPath) => snippetV2Contents.find((s) => s.filename === importPath));
+        return importedSnippets.some((snippet) => snippet && containsUpdates(snippet.tree));
+    })
+        .map((file) => {
+        // Extract snippets referenced by this page using its importMap
+        // Map component names (import specifiers) to snippets for proper injection
+        const referencedSnippets = [];
+        for (const [importPath, importSpecifiers] of Object.entries(file.importMap)) {
+            const snippet = snippetV2Contents.find((s) => s.filename === importPath);
+            if (snippet) {
+                // Get all the import names (component names) for this snippet
+                const importNames = importSpecifiers.map((spec) => spec.name);
+                referencedSnippets.push({
+                    ...snippet,
+                    importNames,
+                });
+            }
+        }
+        return {
+            targetPath: join('src', '_props', file.filename),
+            sourcePath: join(contentDirectoryPath, file.filename),
+            tree: file.tree,
+            metadata: file.metadata,
+            snippets: referencedSnippets,
+        };
+    });
+    const allRssPages = [...rssPages, ...rssPagesWithImports];
     const writeDevGroupsPromise = groups && groups.length > 0
         ? outputFile('src/_props/dev-groups.json', JSON.stringify({ groups }, null, 2), { flag: 'w' })
         : Promise.resolve();
@@ -59,7 +102,7 @@ export const update = async ({ contentDirectoryPath, staticFilenames, openApiFil
         writeFile(customLanguages, 'src/_props/customLanguages.json'),
         writeOpenApiData(newOpenApiFiles),
         writeAsyncApiFiles(newAsyncApiFiles),
-        writeRssFiles(newDocsConfig, rssPages),
+        writeRssFiles(newDocsConfig, allRssPages, contentDirectoryPath, snippetV2Contents),
         updateFavicons(newDocsConfig, contentDirectoryPath),
         ...writeMdxFilesWithNoImports(mdxFilesWithNoImports),
         ...writeFiles(contentDirectoryPath, 'public', [...staticFilenames, ...snippets]),

package/dist/prebuild/update/read/readContent.d.ts

@@ -2,6 +2,10 @@ import type { FileWithImports } from '@mintlify/common';
 import { AsyncAPIFile } from '@mintlify/common';
 import type { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
 import type { Root } from 'mdast';
+export type FileWithImportsAndMetadata = FileWithImports & {
+    metadata?: Record<string, unknown>;
+    contentDirectoryPath?: string;
+};
 type ReadPageContentsArgs = {
     contentDirectoryPath: string;
     openApiFiles: OpenApiFile[];
@@ -12,10 +16,12 @@ type ReadPageContentsArgs = {
 export declare const readPageContents: ({ contentDirectoryPath, openApiFiles, asyncApiFiles, contentFilenames, pagesAcc, }: ReadPageContentsArgs) => Promise<{
     mdxFilesWithNoImports: {
         targetPath: string;
+        sourcePath: string;
         tree: Root;
+        metadata: DecoratedNavigationPage;
     }[];
     pagesAcc: Record<string, DecoratedNavigationPage>;
-    filesWithImports: FileWithImports[];
+    filesWithImports: FileWithImportsAndMetadata[];
 }>;
 export declare const readSnippetsV2Contents: (contentDirectoryPath: string, snippetV2Filenames: string[]) => Promise<{
     filename: string;

package/dist/prebuild/update/read/readContent.js

@@ -1,4 +1,4 @@
-import { hasImports, findAndRemoveImports, getDecoratedNavPageAndSlug } from '@mintlify/common';
+import { hasImports, findAndRemoveImports, getDecoratedNavPageAndSlug, parseFrontmatter, } from '@mintlify/common';
 import { promises as _promises } from 'fs';
 import { join } from 'path';
 import { preparseMdxTree } from '../../../createPage/preparseMdx/index.js';
@@ -10,19 +10,25 @@ export const readPageContents = async ({ contentDirectoryPath, openApiFiles, asy
         const targetPath = join('src', '_props', filename);
         try {
             const contentStr = (await readFile(sourcePath)).toString();
-            // if is snippet add to static file array
             const tree = await preparseMdxTree(contentStr, contentDirectoryPath, sourcePath);
             const importsResponse = await findAndRemoveImports(tree);
             if (hasImports(importsResponse)) {
+                let metadata;
+                try {
+                    metadata = parseFrontmatter(contentStr).attributes;
+                }
+                catch (error) { }
                 filesWithImports.push({
                     ...importsResponse,
                     filename,
+                    metadata,
+                    contentDirectoryPath,
                 });
                 return;
             }
             const { slug, pageMetadata } = getDecoratedNavPageAndSlug(filename, contentStr, openApiFiles, asyncApiFiles);
             pagesAcc[slug] = pageMetadata;
-            return { targetPath, tree };
+            return { targetPath, sourcePath, tree, metadata: pageMetadata };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred reading and parsing file.';

package/dist/prebuild/update/write/writeRssFiles.d.ts

@@ -2,5 +2,14 @@ import { DocsConfig } from '@mintlify/validation';
 import type { Root } from 'mdast';
 export declare const writeRssFiles: (docsConfig: DocsConfig, rssPages: {
     targetPath: string;
+    sourcePath: string;
+    tree: Root;
+    snippets?: {
+        filename: string;
+        tree: Root;
+        importNames?: string[];
+    }[];
+}[], contentDirectoryPath: string, allSnippets?: {
+    filename: string;
     tree: Root;
 }[]) => Promise<void>;

package/dist/prebuild/update/write/writeRssFiles.js

@@ -1,33 +1,73 @@
-import { isUpdate, processUpdateNode, UPDATE_MAX } from '@mintlify/common';
+import { stringifyTree, findAndRemoveImports } from '@mintlify/common';
 import fse from 'fs-extra';
+import { getGitBlame } from '../git/getGitBlame.js';
 import { docsConfigToRss } from '../rss/docsConfigToRss.js';
 import { pageToRss } from '../rss/pageToRss.js';
 import { pathToRss } from '../rss/pathToRss.js';
-export const writeRssFiles = async (docsConfig, rssPages) => {
+const extractSnippets = async (tree, allSnippets) => {
+    if (!allSnippets || allSnippets.length === 0) {
+        return [];
+    }
+    const clonedTree = structuredClone(tree);
+    const { importMap } = await findAndRemoveImports(clonedTree);
+    if (Object.keys(importMap).length === 0) {
+        return [];
+    }
+    const referencedSnippets = [];
+    for (const importPath of Object.keys(importMap)) {
+        const normalizedImportPath = importPath.startsWith('/') ? importPath.slice(1) : importPath;
+        const snippet = allSnippets.find((s) => s.filename === normalizedImportPath);
+        if (snippet) {
+            referencedSnippets.push({
+                path: snippet.filename,
+                content: stringifyTree(snippet.tree),
+            });
+        }
+    }
+    return referencedSnippets;
+};
+export const writeRssFiles = async (docsConfig, rssPages, contentDirectoryPath, allSnippets) => {
     const { orgName, orgDescription } = docsConfigToRss(docsConfig);
     const rssTargetPath = 'src/_props/rssFiles.json';
-    const rssItemsToSave = rssPages.map((page) => {
-        const { targetPath, tree } = page;
+    const rssItemsPromises = rssPages.map(async (page) => {
+        const { targetPath, sourcePath, tree, snippets: preExtractedSnippets } = page;
         const { title, description } = pageToRss(tree);
         const rssPath = pathToRss(targetPath);
-        const pageUpdateComponents = tree.children.filter((child) => isUpdate(child));
-        const updates = [];
-        for (const update of pageUpdateComponents) {
-            const newUpdates = processUpdateNode({ updateNode: update, date: new Date().toISOString() });
-            updates.push(...newUpdates);
+        const content = stringifyTree(tree);
+        let lineBlame = {};
+        try {
+            lineBlame = await getGitBlame(sourcePath, contentDirectoryPath);
+        }
+        catch (error) { }
+        let snippets;
+        if (preExtractedSnippets && preExtractedSnippets.length > 0) {
+            snippets = preExtractedSnippets.map((s) => ({
+                path: s.filename,
+                content: stringifyTree(s.tree),
+                importNames: s.importNames,
+            }));
+        }
+        else {
+            snippets = await extractSnippets(tree, allSnippets);
         }
-        const trimmedUpdates = updates.slice(0, UPDATE_MAX);
-        return {
+        const filePath = sourcePath.substring(contentDirectoryPath.length + 1);
+        const rssFileV4 = {
+            version: 'v4',
             rssPath,
             orgName,
             orgDescription,
             title,
             description,
-            updates: trimmedUpdates,
+            filePath,
+            content,
+            lineBlame,
+            snippets: snippets.length > 0 ? snippets : undefined,
         };
+        return rssFileV4;
     });
+    const rssItemsToSave = await Promise.all(rssItemsPromises);
     await fse.remove(rssTargetPath);
-    await fse.outputFile(rssTargetPath, JSON.stringify(rssItemsToSave), {
+    await fse.outputFile(rssTargetPath, JSON.stringify(rssItemsToSave, null, 2), {
         flag: 'w',
     });
 };