spec-up-t 1.2.4 → 1.2.6

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/create-term-index.js

@@ -1,41 +1,145 @@
 /**
  * Steps:
- * 1. Reads the configuration from 'specs.json'.
- * 2. Extracts the directories containing the specifications and terms.
- * 3. Lists all file names in the specified terms directory.
+ * 1. Reads the configuration from 'specs.json', with fallbacks for missing or invalid files.
+ * 2. Extracts the directories containing the specifications and terms, with defaults for missing values.
+ * 3. Lists all file names in the specified terms directory if it exists.
  * 4. Joins each file name with the terms directory path.
- * 5. Creates an 'output' directory in the project root if it does not exist.
+ * 5. Creates an '.cache' directory in the project root if it does not exist.
  * 6. Writes the list of file paths to 'term-index.json' in the project root.
  *
+ * If any errors occur during the process, appropriate warnings are logged, and an empty term index
+ * will be created rather than throwing fatal errors.
+ *
  * @requires fs-extra - File system operations with extra methods.
  * @requires path - Utilities for working with file and directory paths.
  * @file src/create-term-index.js
  * @author Kor Dwarshuis
- * @version 1.0.0
+ * @version 1.1.0
  * @since 2024-09-02
  */
 
 const { shouldProcessFile } = require('./utils/file-filter');
 
 function createTermIndex() {
-    const fs = require('fs-extra');
-    const path = require('path');
-    const config = fs.readJsonSync('specs.json');
-    const specDirectories = config.specs.map(spec => spec.spec_directory);
-    const specTermDirectoryName = config.specs.map(spec => spec.spec_terms_directory);
-    const outputPathJSON = path.join('output', 'term-index.json');
-    const files = fs.readdirSync(path.join(specDirectories[0], specTermDirectoryName[0]))
-        .filter(shouldProcessFile);
-
-    const filePaths = files.map(file => specTermDirectoryName[0] + '/' + file);
-
-    if (!fs.existsSync('output')) {
-        fs.mkdirSync('output');
+    try {
+        const fs = require('fs-extra');
+        const path = require('path');
+        const configPath = 'specs.json';
+        
+        // Check if specs.json exists
+        if (!fs.existsSync(configPath)) {
+            console.warn(`Config file '${configPath}' not found. Using default configuration.`);
+            var config = { specs: [] };
+        } else {
+            // Read config with try-catch to handle parsing errors
+            try {
+                var config = fs.readJsonSync(configPath);
+            } catch (readError) {
+                console.warn(`Error reading config file: ${readError.message}. Using default configuration.`);
+                var config = { specs: [] };
+            }
+        }
+        
+        // Provide defaults for missing config
+        if (!config) {
+            console.warn('Config file is empty or invalid. Using defaults.');
+            config = { specs: [] };
+        }
+        
+        if (!config.specs) {
+            console.warn('No specs array found in config. Creating empty specs array.');
+            config.specs = [];
+        } else if (!Array.isArray(config.specs)) {
+            console.warn('Config specs is not an array. Converting to array.');
+            config.specs = [config.specs]; // Convert to array if it's an object
+        }
+        
+        // If no valid specs, create an empty term index
+        if (config.specs.length === 0) {
+            console.warn('No specs found in configuration. Creating an empty term index.');
+        }
+        
+        // Extract spec directories with fallback to current directory
+        const specDirectories = config.specs.map((spec, index) => {
+            if (!spec.spec_directory) {
+                console.warn(`Warning: spec_directory missing in specs.json entry #${index + 1}. Using current directory.`);
+                return '.';  // Default to current directory
+            }
+            return spec.spec_directory;
+        });
+        
+        // Extract term directories with fallback to default value
+        const specTermDirectoryName = config.specs.map((spec, index) => {
+            if (!spec.spec_terms_directory) {
+                console.warn(`Warning: spec_terms_directory missing in specs.json entry #${index + 1}. Using default 'terms' directory.`);
+                return 'terms'; // Default directory name for terms
+            }
+            return spec.spec_terms_directory;
+        });
+        
+        // Safety check - if we have no valid entries, warn and exit cleanly
+        if (specDirectories.length === 0 || specTermDirectoryName.length === 0) {
+            console.log('No term directories found in configuration. Creating empty term index.');
+            
+            // Create an empty term index
+            const outputPathJSON = path.join('.cache', 'term-index.json');
+            if (!fs.existsSync('.cache')) {
+                fs.mkdirSync('.cache', { recursive: true });
+            }
+            fs.writeJsonSync(outputPathJSON, [], { spaces: 2 });
+            console.log(`✅ Empty term index created at: ${outputPathJSON}`);
+            return; // Exit function early
+        }
+        
+        // Verify that the base spec directory exists
+        const baseSpecDir = specDirectories[0];
+        if (!baseSpecDir || !fs.existsSync(baseSpecDir)) {
+            console.warn(`Spec directory '${baseSpecDir}' does not exist. Creating empty term index.`);
+            
+            // Create an empty term index
+            const outputPathJSON = path.join('.cache', 'term-index.json');
+            if (!fs.existsSync('.cache')) {
+                fs.mkdirSync('.cache', { recursive: true });
+            }
+            fs.writeJsonSync(outputPathJSON, [], { spaces: 2 });
+            console.log(`✅ Empty term index created at: ${outputPathJSON}`);
+            return; // Exit function early
+        }
+        
+        // Verify that the terms directory exists
+        const termsDir = path.join(baseSpecDir, specTermDirectoryName[0]);
+        
+        let files = [];
+        if (!fs.existsSync(termsDir)) {
+            console.warn(`Terms directory '${termsDir}' does not exist. Creating an empty term index.`);
+        } else {
+            // Get list of files and filter them
+            files = fs.readdirSync(termsDir).filter(shouldProcessFile);
+        }
+        
+        if (files.length === 0) {
+            console.log('Warning: No term files found to process.');
+        }
+        
+        const filePaths = files.map(file => specTermDirectoryName[0] + '/' + file);
+        const outputPathJSON = path.join('.cache', 'term-index.json');
+        
+        // Create .cache directory if it doesn't exist
+        if (!fs.existsSync('.cache')) {
+            fs.mkdirSync('.cache', { recursive: true });
+        }
+        
+        // Write the term index file
+        try {
+            fs.writeJsonSync(outputPathJSON, filePaths, { spaces: 2 });
+            console.log(`✅ Term index created with ${files.length} terms. Output: ${outputPathJSON}`);
+        } catch (writeError) {
+            throw new Error(`Failed to write term index file: ${writeError.message}`);
+        }
+    } catch (error) {
+        console.error(`❌ Error creating term index: ${error.message}`);
+        throw error;
     }
-
-    fs.writeJsonSync(outputPathJSON, filePaths, { spaces: 2 });
-    
-    console.log(`✅ The new terms were added. All done.`);
 }
 
 module.exports = {

package/src/health-check/tref-term-checker.js

@@ -321,7 +321,7 @@ async function getProjectConfiguration(projectRoot) {
     externalSpecs, 
     specDirs, 
     valid: true,
-    githubCacheDir: path.join(projectRoot, 'output', 'github-cache')
+    githubCacheDir: path.join(projectRoot, '.cache', 'github-cache')
   };
 }
 

package/src/health-check.js

@@ -15,7 +15,7 @@ const outputGitignoreChecker = require('./health-check/output-gitignore-checker'
 const trefTermChecker = require('./health-check/tref-term-checker');
 
 // Configuration
-const OUTPUT_DIR = path.join(process.cwd(), 'output');
+const OUTPUT_DIR = path.join(process.cwd(), '.cache');
 
 // Create output directory if it doesn't exist
 if (!fs.existsSync(OUTPUT_DIR)) {

package/src/init.js

@@ -1,6 +1,6 @@
 const fs = require('fs-extra');
 const path = require('path');
-const outputDir = path.join(process.cwd(), 'output');
+const outputDir = path.join(process.cwd(), '.cache');
 const initFlagPath = path.join(outputDir, 'init.flag');
 
 async function initialize() {