spec-up-t 1.2.5 → 1.2.7

package/src/create-pdf.js

@@ -29,7 +29,7 @@ const pdfLib = require('pdf-lib');
         let bootstrapCss = bootstrapExists ? fs.readFileSync(bootstrapCssPath, 'utf8') : '';
 
         // Path to PDF styles CSS
-        const pdfStylesPath = path.resolve(process.cwd(), 'assets/css/pdf-styles.css');
+        const pdfStylesPath = path.resolve(process.cwd(), 'assets/css/create-pdf.css');
         const pdfStylesExist = fs.existsSync(pdfStylesPath);
         const pdfStylesCss = pdfStylesExist ? fs.readFileSync(pdfStylesPath, 'utf8') : '';
 
@@ -38,8 +38,14 @@ const pdfLib = require('pdf-lib');
 
         // Clean up unnecessary elements but be careful not to remove styles we need
         await page.evaluate(() => {
-            document.querySelectorAll('[style*="display: none"], .d-print-none, script').forEach(element => element.remove());
+            // Preserve TOC if it exists (skip removing it even if it has display:none)
+            document.querySelectorAll('[style*="display: none"]:not(#toc):not(#toc *), .d-print-none:not(#toc):not(#toc *), script').forEach(element => element.remove());
             // Don't remove all style elements as some might be important
+
+            // If TOC doesn't exist, we'll need to create one
+            if (!document.getElementById('toc')) {
+                console.log('No TOC found in the document. Will create one.');
+            }
         });
 
         // Handle dynamically fetched cross-reference terms
@@ -68,7 +74,7 @@ const pdfLib = require('pdf-lib');
                 container.style.margin = '0 auto';
                 container.style.padding = '0';
             });
-            
+
             // Override any Bootstrap column constraints
             const columns = document.querySelectorAll('[class*="col-"]');
             columns.forEach(col => {
@@ -77,7 +83,7 @@ const pdfLib = require('pdf-lib');
                 col.style.paddingLeft = '0';
                 col.style.paddingRight = '0';
             });
-            
+
             // Ensure body takes full width
             document.body.style.maxWidth = '100%';
             document.body.style.width = '100%';
@@ -113,18 +119,18 @@ const pdfLib = require('pdf-lib');
             document.querySelectorAll('table').forEach(table => {
                 table.classList.add('table', 'table-bordered', 'table-striped', 'table-hover');
             });
-            
+
             // Make sure meta-info is visible and toggle buttons are hidden
             document.querySelectorAll('.meta-info, .term-meta').forEach(meta => {
                 meta.style.display = 'block';
             });
-            
+
             document.querySelectorAll('.meta-toggle, button.meta-toggle').forEach(button => {
                 button.style.display = 'none';
             });
         });
 
-        // Inject logo, title, and description
+        // Inject logo, title, and description AND handle TOC creation if needed
         await page.evaluate((logo, logoLink, title, description) => {
             const titleWrapper = document.createElement('div');
             titleWrapper.className = 'text-center mb-5 pb-4 border-bottom';
@@ -155,9 +161,88 @@ const pdfLib = require('pdf-lib');
             }
 
             document.body.insertBefore(titleWrapper, document.body.firstChild);
+
+            // Create a Table of Contents if it doesn't exist
+            if (!document.getElementById('toc')) {
+                // Generate a TOC based on the headings in the document
+                const headings = Array.from(document.querySelectorAll('h1:not(.pdf-title), h2, h3, h4, h5, h6')).filter(h => {
+                    // Only include headings with IDs that can be linked to
+                    return h.id && h.id.trim() !== '';
+                });
+
+                if (headings.length > 0) {
+                    // Create TOC container
+                    const tocContainer = document.createElement('div');
+                    tocContainer.id = 'toc';
+                    tocContainer.className = 'toc-container';
+
+                    // Create TOC heading
+                    const tocHeading = document.createElement('h2');
+                    tocHeading.textContent = 'Contents';
+                    tocHeading.className = 'toc-heading';
+                    tocContainer.appendChild(tocHeading);
+
+                    // Create TOC list
+                    const tocList = document.createElement('ul');
+                    tocList.className = 'toc-list';
+                    tocContainer.appendChild(tocList);
+
+                    // Add all headings to the TOC
+                    let currentLevel = 0;
+                    let currentList = tocList;
+                    let listStack = [tocList];
+
+                    headings.forEach(heading => {
+                        // Get heading level (1-6 for h1-h6)
+                        const level = parseInt(heading.tagName[1]);
+
+                        // Navigate to the correct nesting level
+                        if (level > currentLevel) {
+                            // Go deeper - create a new nested list
+                            for (let i = currentLevel; i < level; i++) {
+                                if (currentList.lastChild) {
+                                    const nestedList = document.createElement('ul');
+                                    currentList.lastChild.appendChild(nestedList);
+                                    listStack.push(nestedList);
+                                    currentList = nestedList;
+                                } else {
+                                    // If no items exist yet, add a dummy item
+                                    const dummyItem = document.createElement('li');
+                                    const nestedList = document.createElement('ul');
+                                    dummyItem.appendChild(nestedList);
+                                    currentList.appendChild(dummyItem);
+                                    listStack.push(nestedList);
+                                    currentList = nestedList;
+                                }
+                            }
+                        } else if (level < currentLevel) {
+                            // Go up - pop from the stack
+                            for (let i = currentLevel; i > level; i--) {
+                                listStack.pop();
+                            }
+                            currentList = listStack[listStack.length - 1];
+                        }
+
+                        currentLevel = level;
+
+                        // Create list item with link
+                        const listItem = document.createElement('li');
+                        const link = document.createElement('a');
+                        link.href = '#' + heading.id;
+                        link.textContent = heading.textContent;
+                        listItem.appendChild(link);
+                        currentList.appendChild(listItem);
+                    });
+
+                    // Insert the TOC after the title section
+                    document.body.insertBefore(tocContainer, titleWrapper.nextSibling);
+
+                    console.log('Generated a Table of Contents with ' + headings.length + ' entries.');
+                }
+            }
         }, logo, logoLink, title, description);
-        
-        // Direct manipulation of definition lists to ensure proper styling in PDF
+
+        // Direct manipulation of definition lists and TOC to ensure proper styling in PDF
         await page.evaluate(() => {
             // Process all definition lists
             const definitionLists = document.querySelectorAll('dl.terms-and-definitions-list');
@@ -168,7 +253,7 @@ const pdfLib = require('pdf-lib');
                     // Remove background and borders with !important to override any existing styles
                     term.setAttribute('style', term.getAttribute('style') + '; background: transparent !important; background-color: transparent !important; background-image: none !important; border: none !important; border-radius: 0 !important; padding: 0.5rem 0 !important;');
                 });
-                
+
                 // Ensure all meta-info content is visible
                 const metaInfoContents = list.querySelectorAll('dd.meta-info-content-wrapper');
                 metaInfoContents.forEach(content => {
@@ -179,42 +264,266 @@ const pdfLib = require('pdf-lib');
                     content.style.padding = '0.5rem 0';
                     content.style.margin = '0';
                     content.style.lineHeight = 'normal';
-                    
+
                     // Remove the collapsed class if present
                     content.classList.remove('collapsed');
                 });
-                
+
                 // Hide all meta-info toggle buttons
                 const toggleButtons = list.querySelectorAll('.meta-info-toggle-button');
                 toggleButtons.forEach(button => {
                     button.style.display = 'none';
                 });
             });
-            
+
             // Special handling for ALL transcluded terms with blue background - no class restrictions
             document.querySelectorAll('.transcluded-xref-term').forEach(el => {
                 // Use the most aggressive approach possible to override the blue background
                 el.setAttribute('style', el.getAttribute('style') + '; background: transparent !important; background-color: transparent !important; background-image: none !important;');
-                
+
                 // Also process any child elements to ensure complete removal of background
                 Array.from(el.children).forEach(child => {
                     child.setAttribute('style', child.getAttribute('style') + '; background: transparent !important; background-color: transparent !important; background-image: none !important;');
                 });
             });
-            
+
             // Remove any inline styles that might be setting backgrounds
             document.querySelectorAll('style').forEach(styleTag => {
                 let cssText = styleTag.textContent;
                 // If the style tag contains transcluded-xref-term styles, modify them
                 if (cssText.includes('transcluded-xref-term') && cssText.includes('background')) {
-                    cssText = cssText.replace(/dt\.transcluded-xref-term[^}]+}/g, 
-                                             'dt.transcluded-xref-term, dd.transcluded-xref-term { background: transparent !important; background-color: transparent !important; background-image: none !important; }');
+                    cssText = cssText.replace(/dt\.transcluded-xref-term[^}]+}/g,
+                        'dt.transcluded-xref-term, dd.transcluded-xref-term { background: transparent !important; background-color: transparent !important; background-image: none !important; }');
                     styleTag.textContent = cssText;
                 }
-            });
+            });            // Format Table of Contents for book-like layout
+            const toc = document.getElementById('toc');
+            if (toc) {
+                // Make sure TOC is visible
+                toc.style.display = 'block';
+                toc.style.visibility = 'visible';
+                toc.style.opacity = '1';
+
+                // Create a new TOC div for the PDF using a completely different approach
+                const pdfToc = document.createElement('div');
+                pdfToc.id = 'pdf-toc';
+
+                // Ensure TOC has a header
+                const tocHeading = document.createElement('h2');
+                tocHeading.textContent = 'Contents';
+                tocHeading.style.textAlign = 'center';
+                tocHeading.style.fontWeight = 'bold';
+                tocHeading.style.marginBottom = '1.5rem';
+                tocHeading.style.paddingBottom = '0.5rem';
+                tocHeading.style.borderBottom = '1px solid #000';
+                pdfToc.appendChild(tocHeading);
+
+                // Create a fresh TOC structure - completely rebuilding it
+                const tocList = document.createElement('ul');
+                tocList.style.listStyleType = 'none';
+                tocList.style.padding = '0';
+                tocList.style.margin = '0';
+                pdfToc.appendChild(tocList);
+
+                // Find all section headings to include in the TOC
+                // Look for both original TOC entries and also scan document headings
+                const tocOriginalLinks = toc.querySelectorAll('a');
+
+                // Process each TOC link to create a new TOC item
+                tocOriginalLinks.forEach((link, index) => {
+                    const li = document.createElement('li');
+                    const rowDiv = document.createElement('div');
+                    rowDiv.className = 'toc-row';
+
+                    const title = document.createElement('a');
+                    title.href = link.getAttribute('href');
+                    title.textContent = link.textContent;
+                    title.className = 'toc-title';
+                    title.setAttribute('data-target-id', link.getAttribute('href').substring(1)); // Store the target id
+                    // Ensure no blue color or underline for TOC links
+                    title.style.color = '#000';
+                    title.style.textDecoration = 'none';
+                    title.style.borderBottom = 'none';
+                    title.style.backgroundColor = 'transparent';
+
+                    const leader = document.createElement('div');
+                    leader.className = 'toc-leader';
+
+                    // Create page number placeholder - we'll fill in actual page numbers later
+                    const pageNumber = document.createElement('span');
+                    pageNumber.className = 'toc-page-number';
+                    pageNumber.textContent = ''; // Empty for now
+                    pageNumber.setAttribute('data-for-id', link.getAttribute('href').substring(1));
+                    pageNumber.style.position = 'absolute';
+                    pageNumber.style.right = '0';
+
+                    rowDiv.appendChild(title);
+                    rowDiv.appendChild(leader);
+                    li.appendChild(rowDiv);
+                    li.appendChild(pageNumber);
+
+                    // Determine nesting level from original TOC
+                    let level = 0;
+                    let parent = link.closest('li');
+                    while (parent) {
+                        const parentList = parent.closest('ul');
+                        if (parentList && parentList !== toc) {
+                            level++;
+                            parent = parentList.closest('li');
+                        } else {
+                            break;
+                        }
+                    }
+
+                    // Apply indentation based on level
+                    if (level > 0) {
+                        li.style.paddingLeft = (level * 15) + 'px';
+                    }
+
+                    tocList.appendChild(li);
+                });
+
+                // Insert the new TOC at the beginning of the document after the title
+                const titleWrapper = document.querySelector('.text-center.mb-5.pb-4.border-bottom');
+                if (titleWrapper && titleWrapper.nextSibling) {
+                    document.body.insertBefore(pdfToc, titleWrapper.nextSibling);
+                } else {
+                    document.body.insertBefore(pdfToc, document.body.firstChild);
+                }
+
+                // Force page break before TOC
+                pdfToc.style.breakBefore = 'page';
+                pdfToc.style.pageBreakBefore = 'always';
+
+                // Force page break after TOC
+                const tocNext = pdfToc.nextElementSibling;
+                if (tocNext) {
+                    tocNext.style.breakBefore = 'page';
+                    tocNext.style.pageBreakBefore = 'always';
+                }
+
+                // Hide the original TOC
+                toc.style.display = 'none';
+            }
+        });
+
+        console.log('Generating PDF with proper TOC page numbers...');
+
+        // First, generate a draft PDF to calculate the page positions of each heading
+        const draftPdfBuffer = await page.pdf({
+            format: 'A4',
+            displayHeaderFooter: true,
+            footerTemplate: `
+                <div style="width: 100%; text-align: center; font-size: 10pt; margin-top: 10mm;">
+                    Page <span class="pageNumber"></span> of <span class="totalPages"></span>
+                </div>
+            `,
+            headerTemplate: '<div></div>',
+            preferCSSPageSize: true,
+            printBackground: true,
+            margin: { top: '10mm', bottom: '10mm', left: '10mm', right: '10mm' }
+        });
+
+        // Now extract the page numbers from the tooltips and update the TOC entries
+        await page.evaluate(() => {
+            // Find the PDF TOC 
+            const pdfToc = document.getElementById('pdf-toc');
+            if (!pdfToc) return;
+            
+            const tocEntries = pdfToc.querySelectorAll('.toc-page-number');
+            const originalToc = document.getElementById('toc');
+            
+            if (originalToc) {
+                // Get all links from the original TOC that have tooltip data
+                const originalLinks = originalToc.querySelectorAll('a[title], a[data-bs-title]');
+                
+                // Create a mapping from heading IDs to page numbers based on tooltips
+                const idToPageMap = {};
+                
+                originalLinks.forEach(link => {
+                    // Extract the heading ID from href
+                    const href = link.getAttribute('href');
+                    if (!href || !href.startsWith('#')) return;
+                    
+                    const headingId = href.substring(1);
+                    
+                    // Extract page number from tooltip text (e.g., "Go to page 5")
+                    const tooltipText = link.getAttribute('title') || link.getAttribute('data-bs-title');
+                    if (!tooltipText) return;
+                    
+                    const pageNumberMatch = tooltipText.match(/Go to page (\d+)/i);
+                    if (pageNumberMatch && pageNumberMatch[1]) {
+                        const pageNumber = parseInt(pageNumberMatch[1], 10);
+                        if (!isNaN(pageNumber)) {
+                            idToPageMap[headingId] = pageNumber;
+                        }
+                    }
+                });
+                
+                // Now update the TOC page numbers using the extracted values
+                tocEntries.forEach(entry => {
+                    const targetId = entry.getAttribute('data-for-id');
+                    if (targetId && idToPageMap[targetId]) {
+                        entry.textContent = idToPageMap[targetId];
+                        // Ensure page numbers are clearly visible with proper styling
+                        entry.style.visibility = 'visible';
+                        entry.style.opacity = '1';
+                        entry.style.color = '#000';
+                        entry.style.background = '#fff';
+                        entry.style.padding = '0 4px';
+                        entry.style.fontWeight = 'normal';
+                    }
+                });
+            } else {
+                // Fallback to old estimation method if original TOC is not available
+                console.log('Original TOC not found, using page number estimation method');
+                
+                // Find all headings with IDs (potential TOC targets)
+                const headingsWithIds = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6')).filter(h => h.id);
+                
+                // Use real offsets for more accurate page numbers
+                const idToPosition = {};
+
+                headingsWithIds.forEach(heading => {
+                    const rect = heading.getBoundingClientRect();
+                    idToPosition[heading.id] = {
+                        top: rect.top + window.scrollY,
+                        id: heading.id
+                    };
+                });
+
+                // Sort by vertical position
+                const sortedPositions = Object.values(idToPosition).sort((a, b) => a.top - b.top);
+
+                // A4 page height (mm to pixels at 96 DPI)
+                const pageHeight = 297 * 96 / 25.4;
+                const effectivePageHeight = pageHeight - 20; // Account for margins
+
+                // Start on page 3 (after title and TOC)
+                let currentPage = 3;
+                let currentOffset = 0;
+
+                // Calculate page numbers based on relative positions
+                sortedPositions.forEach(pos => {
+                    while (pos.top > currentOffset + effectivePageHeight) {
+                        currentPage++;
+                        currentOffset += effectivePageHeight;
+                    }
+
+                    idToPosition[pos.id].page = currentPage;
+                });
+
+                // Update TOC entries with calculated page numbers
+                tocEntries.forEach(entry => {
+                    const targetId = entry.getAttribute('data-for-id');
+                    if (targetId && idToPosition[targetId] && idToPosition[targetId].page) {
+                        entry.textContent = idToPosition[targetId].page;
+                    }
+                });
+            }
         });
 
-        // Generate PDF
+        // Final PDF generation with correct page numbers
         const pdfBuffer = await page.pdf({
             path: path.resolve(process.cwd(), 'docs/index.pdf'),
             format: 'A4',
@@ -228,7 +537,7 @@ const pdfLib = require('pdf-lib');
             preferCSSPageSize: true,
             printBackground: true,
             quality: 100,
-            margin: { top: '10mm', bottom: '10mm', left: '3mm', right: '3mm' }
+            margin: { top: '10mm', bottom: '10mm', left: '10mm', right: '10mm' }
         });
 
         await browser.close();
@@ -248,4 +557,4 @@ const pdfLib = require('pdf-lib');
     } catch (error) {
         console.error('❌ Error generating PDF:', error);
     }
-})();
+})();

package/src/health-check/{output-gitignore-checker.js → destination-gitignore-checker.js}

@@ -1,6 +1,17 @@
+/**
+ * @file destination-gitignore-checker.js
+ * @description Checks if the final destination directory (from output_path in specs.json) 
+ * is being ignored by Git. This is the directory where index.html is generated, 
+ * NOT the temporary .cache directory (formerly called "output").
+ * 
+ * Important: This file deals with concept #1 (output_path from specs.json),
+ * not concept #2 (the temporary .cache directory for build artifacts).
+ */
+
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
+const { spawnSync } = require('child_process');
+const fileOpener = require('../utils/file-opener');
 
 /**
  * Checks if a path is gitignored
@@ -13,8 +24,11 @@ function isPathGitIgnored(projectRoot, targetPath) {
     // Use git check-ignore to determine if the path is ignored
     // If command exits with status 0, path is ignored
     // If command exits with status 1, path is not ignored
-    execSync(`git -C "${projectRoot}" check-ignore -q "${targetPath}"`, { stdio: 'ignore' });
-    return true; // Path is ignored (command exited with status 0)
+    const gitPath = fileOpener.getCommandPath('git');
+    const result = spawnSync(gitPath, ['-C', projectRoot, 'check-ignore', '-q', targetPath], { 
+      stdio: 'ignore' 
+    });
+    return result.status === 0; // Path is ignored (command exited with status 0)
   } catch (error) {
     console.log(`Error checking if path is gitignored: ${error.message}`);
     return false; // Path is not ignored (command exited with non-zero status)
@@ -87,11 +101,11 @@ function extractOutputPath(specsPath) {
 }
 
 /**
- * Check if the output directory exists
+ * Check if the final destination directory (from output_path) exists
  * @param {string} projectRoot - Root directory of the project
  * @param {string} outputPath - Output path from specs.json
  * @param {string} normalizedPath - Normalized output path
- * @returns {Object} - Result with output directory check
+ * @returns {Object} - Result with final destination directory check
  */
 function checkOutputDirExists(projectRoot, outputPath, normalizedPath) {
   // Check if the path exists
@@ -100,17 +114,17 @@ function checkOutputDirExists(projectRoot, outputPath, normalizedPath) {
   
   if (!outputPathExists) {
     return {
-      name: 'Output directory existence',
+      name: 'Final destination directory existence',
       status: 'warning',
       success: true, // Still considered a "success" for backward compatibility
-      details: `Output directory "${outputPath}" does not exist yet. This is OK if you haven't rendered the specs yet.`
+      details: `Final destination directory "${outputPath}" does not exist yet. This is OK if you haven't rendered the specs yet.`
     };
   } 
   
   return {
-    name: 'Output directory existence',
+    name: 'Final destination directory existence',
     success: true,
-    details: `Output directory "${outputPath}" exists`
+    details: `Final destination directory "${outputPath}" exists`
   };
 }
 
@@ -245,7 +259,7 @@ function findComplexHtmlPatterns(lines) {
 }
 
 /**
- * Check if HTML files in the output directory are being ignored by Git
+ * Check if HTML files in the final destination directory are being ignored by Git
  * @param {string} projectRoot - Root directory of the project
  * @param {string} normalizedPath - Normalized output path
  * @param {string} outputPath - Original output path
@@ -273,8 +287,8 @@ function checkHtmlFilesGitignore(projectRoot, normalizedPath, outputPath, releva
     name: 'Check if index.html files are gitignored',
     success: !isIndexHtmlIgnored,
     details: isIndexHtmlIgnored 
-      ? `index.html files in the output directory would be ignored by Git. This is problematic as they're crucial output files.`
-      : `index.html files in the output directory are properly tracked by Git.`
+      ? `index.html files in the final destination directory would be ignored by Git. This is problematic as they're crucial output files.`
+      : `index.html files in the final destination directory are properly tracked by Git.`
   });
   
   // If index.html is ignored but we couldn't find an explicit pattern, look for more complex patterns
@@ -295,22 +309,22 @@ function checkHtmlFilesGitignore(projectRoot, normalizedPath, outputPath, releva
 }
 
 /**
- * Check if output directory is being ignored by Git
+ * Check if final destination directory (from output_path) is being ignored by Git
  * @param {string} projectRoot - Root directory of the project
  * @param {string} normalizedPath - Normalized output path
  * @param {string} outputPath - Original output path
  * @param {string} dirName - Directory name from path
  * @param {Array} relevantLines - Relevant lines from .gitignore
- * @returns {Array} - Results for output directory gitignore check
+ * @returns {Array} - Results for final destination directory gitignore check
  */
 function checkOutputDirIgnorePatterns(projectRoot, normalizedPath, outputPath, dirName, relevantLines) {
   const dirIgnorePatterns = findOutputDirIgnorePatterns(relevantLines, normalizedPath, dirName);
   
   if (dirIgnorePatterns.length > 0) {
     return [{
-      name: 'Check if output directory is gitignored',
+      name: 'Check if final destination directory is gitignored',
       success: false,
-      details: `Found patterns in .gitignore that would ignore the output directory: ${dirIgnorePatterns.join(', ')}. Remove these entries to ensure generated content is tracked.`
+      details: `Found patterns in .gitignore that would ignore the final destination directory: ${dirIgnorePatterns.join(', ')}. Remove these entries to ensure generated content is tracked.`
     }];
   }
   
@@ -318,20 +332,21 @@ function checkOutputDirIgnorePatterns(projectRoot, normalizedPath, outputPath, d
   const isIgnored = isPathGitIgnored(projectRoot, normalizedPath);
   
   return [{
-    name: 'Check if output directory is gitignored',
+    name: 'Check if final destination directory is gitignored',
     success: !isIgnored,
     details: isIgnored 
-      ? `Output directory "${outputPath}" is being ignored by Git. This could be due to a complex pattern in .gitignore. Remove any entries that might affect this directory.`
-      : `Output directory "${outputPath}" is not being ignored by Git, which is good.`
+      ? `Final destination directory "${outputPath}" is being ignored by Git. This could be due to a complex pattern in .gitignore. Remove any entries that might affect this directory.`
+      : `Final destination directory "${outputPath}" is not being ignored by Git, which is good.`
   }];
 }
 
 /**
- * Check if the output directory is being ignored by Git
+ * Check if the final destination directory (from output_path in specs.json) is being ignored by Git
+ * This checks the directory where index.html is generated, NOT the temporary .cache directory
  * @param {string} projectRoot - Root directory of the project
  * @returns {Promise<Array>} - Array of check results
  */
-async function checkOutputDirGitIgnore(projectRoot) {
+async function checkDestinationGitIgnore(projectRoot) {
   const results = [];
   
   try {
@@ -369,7 +384,7 @@ async function checkOutputDirGitIgnore(projectRoot) {
     const relevantLines = getRelevantGitignoreLines(gitignoreContent);
     const dirName = path.basename(normalizedPath);
     
-    // Check output directory ignore patterns
+    // Check final destination directory ignore patterns
     const dirResults = checkOutputDirIgnorePatterns(
       projectRoot, normalizedPath, outputPath, dirName, relevantLines
     );
@@ -383,9 +398,9 @@ async function checkOutputDirGitIgnore(projectRoot) {
     
     return results;
   } catch (error) {
-    console.error('Error checking output directory gitignore status:', error);
+    console.error('Error checking final destination directory gitignore status:', error);
     return [{
-      name: 'Output directory gitignore check',
+      name: 'Final destination directory gitignore check',
       success: false,
       details: `Error: ${error.message}`
     }];
@@ -393,5 +408,5 @@ async function checkOutputDirGitIgnore(projectRoot) {
 }
 
 module.exports = {
-  checkOutputDirGitIgnore
+  checkDestinationGitIgnore
 };