spec-up-t 1.6.3-beta.1 → 1.6.4

package/src/install-from-boilerplate/custom-update.js

@@ -3,17 +3,20 @@ const { configOverwriteScriptsKeys } = require('./config-scripts-keys');
 const addScriptsKeys = require('./add-scripts-keys');
 const copySystemFiles = require('./copy-system-files');
 const { gitIgnoreEntries } = require('./config-gitignore-entries');
-const {updateGitignore} = require('./add-gitignore-entries');
+const { updateGitignore } = require('./add-gitignore-entries');
+const updateDependencies = require('./update-dependencies');
+const Logger = require('../utils/logger');
 
 
 addScriptsKeys(configScriptsKeys, configOverwriteScriptsKeys);
 copySystemFiles();
 updateGitignore(gitIgnoreEntries.gitignorePath, gitIgnoreEntries.filesToAdd);
 
-const Logger = require('../utils/logger');
-
 // We can use this file to do any custom updates during post-install.
 const customUpdate = () => {
+    // Update dependencies based on package.spec-up-t.json
+    updateDependencies();
+
     // Custom logic here
     // ...
 }

package/src/install-from-boilerplate/update-dependencies.js

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const Logger = require('../utils/logger');
+
+/**
+ * URL to the canonical package.spec-up-t.json in the starter-pack repository.
+ * This defines the recommended dependency versions for consuming repos.
+ */
+const STARTER_PACK_PACKAGE_URL = 'https://raw.githubusercontent.com/trustoverip/spec-up-t-starter-pack/main/package.spec-up-t.json';
+
+/**
+ * Fetches package.spec-up-t.json from the remote starter-pack repository.
+ * 
+ * @returns {Promise<Object>} The parsed package.spec-up-t.json content
+ * @throws {Error} If the fetch fails or the response is invalid
+ */
+function fetchStarterPackageConfig() {
+    return new Promise((resolve, reject) => {
+        https.get(STARTER_PACK_PACKAGE_URL, (response) => {
+            if (response.statusCode !== 200) {
+                reject(new Error(`Failed to fetch package.spec-up-t.json: HTTP ${response.statusCode}`));
+                return;
+            }
+
+            let data = '';
+            response.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            response.on('end', () => {
+                try {
+                    const config = JSON.parse(data);
+                    resolve(config);
+                } catch (error) {
+                    reject(new Error(`Failed to parse package.spec-up-t.json: ${error.message}`));
+                }
+            });
+        }).on('error', (error) => {
+            reject(new Error(`Network error fetching package.spec-up-t.json: ${error.message}`));
+        });
+    });
+}
+
+/**
+ * Updates dependencies in the consuming repo's package.json based on the
+ * canonical package.spec-up-t.json from the starter-pack repository.
+ * This ensures that the consuming repo always has the correct dependency versions
+ * as specified by the spec-up-t-starter-pack.
+ */
+async function updateDependencies() {
+    // Path to the consuming repo's package.json
+    const consumerPackagePath = path.resolve(process.cwd(), 'package.json');
+
+    try {
+        // Fetch the canonical package.spec-up-t.json from the starter-pack repo
+        Logger.info('Fetching latest dependency configuration...');
+        const specUpPackage = await fetchStarterPackageConfig();
+
+        // Read consuming repo's package.json
+        if (!fs.existsSync(consumerPackagePath)) {
+            Logger.error('package.json not found at:', consumerPackagePath);
+            return;
+        }
+
+        const consumerPackageData = fs.readFileSync(consumerPackagePath, 'utf8');
+        const consumerPackage = JSON.parse(consumerPackageData);
+
+        // Initialize dependencies section if it doesn't exist
+        if (!consumerPackage.dependencies) {
+            consumerPackage.dependencies = {};
+        }
+
+        // Check if there are dependencies to update
+        if (!specUpPackage.dependencies) {
+            Logger.info('No dependencies found in package.spec-up-t.json');
+            return;
+        }
+
+        let updatedCount = 0;
+
+        // Update each dependency from package.spec-up-t.json
+        for (const [packageName, version] of Object.entries(specUpPackage.dependencies)) {
+            const currentVersion = consumerPackage.dependencies[packageName];
+
+            if (currentVersion !== version) {
+                consumerPackage.dependencies[packageName] = version;
+                updatedCount++;
+                Logger.info(`Updated ${packageName}: ${currentVersion || 'not installed'} -> ${version}`);
+            }
+        }
+
+        if (updatedCount > 0) {
+            // Write the updated package.json back to disk
+            fs.writeFileSync(consumerPackagePath, JSON.stringify(consumerPackage, null, 2) + '\n', 'utf8');
+            Logger.success(`Successfully updated ${updatedCount} dependenc${updatedCount === 1 ? 'y' : 'ies'} in package.json`);
+        } else {
+            Logger.info('All dependencies are already up to date');
+        }
+    } catch (error) {
+        Logger.error('Error updating dependencies:', error.message);
+    }
+}
+
+module.exports = updateDependencies;

package/src/pipeline/references/collect-external-references.js

@@ -253,10 +253,22 @@ function processExternalReferences(config, GITHUB_API_TOKEN) {
         });
     });
 
+    // Filter out xtrefs that don't exist in any current file
     allXTrefs.xtrefs = allXTrefs.xtrefs.filter(existingXTref =>
         isXTrefInAnyFile(existingXTref, fileContents)
     );
 
+    // Clean up sourceFiles arrays to remove deleted files
+    // This ensures that if a file is deleted, its entry is removed from all sourceFiles arrays
+    allXTrefs.xtrefs.forEach(xtref => {
+        if (xtref.sourceFiles && Array.isArray(xtref.sourceFiles)) {
+            const currentFiles = Array.from(fileContents.keys());
+            xtref.sourceFiles = xtref.sourceFiles.filter(sf => 
+                currentFiles.includes(sf.file)
+            );
+        }
+    });
+
     fileContents.forEach((content, filename) => {
         addNewXTrefsFromMarkdown(content, allXTrefs, filename, processXTrefObject, externalSpecsRepos);
     });

package/src/pipeline/references/external-references-service.js

@@ -19,7 +19,7 @@ function validateReferences(references, definitions, render) {
   if (unresolvedRefs.length > 0) {
     Logger.warn(`Unresolved References: ${unresolvedRefs.join(',')}`, {
       context: 'These terms are referenced in your spec but not defined',
-      hint: 'Add [[def: term]] definitions or [[tref: repo, term]] transclusion for these terms in your terminology files, or check for typos in [[ref: term]] references',
+      hint: 'Add [[def: term]] definitions or [[tref: repo, term]] transclusion for these terms or alter existing definitions, optionally by adding aliases, in your terminology files, or check for typos in [[ref: term]] references',
       details: `Count: ${unresolvedRefs.length} unresolved term(s)`
     });
   }

package/src/pipeline/rendering/render-spec-document.js

@@ -10,7 +10,7 @@ const path = require('path');
 const { fetchExternalSpecs, validateReferences, mergeXrefTermsIntoAllXTrefs } = require('../references/external-references-service.js');
 const { processEscapedTags, restoreEscapedTags } = require('../preprocessing/escape-placeholder-utils.js');
 const { sortDefinitionTermsInHtml, fixDefinitionListStructure } = require('../postprocessing/definition-list-postprocessor.js');
-const { getGithubRepoInfo } = require('../../utils/git-info.js');
+const { getGithubRepoInfo, getCurrentBranch } = require('../../utils/git-info.js');
 const { templateTags } = require('../../utils/regex-patterns.js');
 
 const { createScriptElementWithXTrefDataForEmbeddingInHtml, applyReplacers } = require('./render-utils.js');
@@ -37,6 +37,9 @@ async function render(spec, assets, sharedVars, config, template, assetsGlobal,
     // Add universal timestamp in ISO 8601 format for template injection
     const universalTimestamp = date.toISOString();
 
+    // Get the branch name from which the index.html was generated
+    const buildBranch = getCurrentBranch();
+
     // Read all markdown files into an array
     const docs = await Promise.all(
       (spec.markdown_paths || ['spec.md']).map(_path =>
@@ -162,6 +165,7 @@ async function render(spec, assets, sharedVars, config, template, assetsGlobal,
       externalSpecsList: externalSpecsList,
       currentDate: currentDate,
       universalTimestamp: universalTimestamp,
+      buildBranch: buildBranch,
       githubRepoInfo: getGithubRepoInfo(spec)
     });
 

package/templates/template.html

@@ -137,15 +137,6 @@
         <!-- Right-aligned elements -->
         <div class="d-flex align-items-center service-menu d-print-none">
 
-            <!-- Settings side menu -->
-            <button id="repo_settings" class="btn btn-sm btn-outline-secondary ms-2" type="button"
-                data-bs-toggle="offcanvas" data-bs-target="#offcanvasSettings" aria-controls="offcanvasSettings">
-                <svg class="bi" width="1em" height="1em" aria-hidden="true">
-                    <use href="#gear-wide-connected"></use>
-                </svg>
-                <span class="visually-hidden">Settings</span>
-            </button>
-
             <!-- Dark / Light theme selector -->
             <div class="dropdown bd-mode-toggle">
                 <button
@@ -247,6 +238,16 @@
         </div>
     </div>
 
+    <!-- Menu toggle button - hamburger icon fixed at right edge for slide-in panel -->
+    <button id="repo_settings" class="btn btn-sm btn-outline-secondary menu-toggle-btn d-print-none" type="button"
+        data-bs-toggle="offcanvas" data-bs-target="#offcanvasSettings" aria-controls="offcanvasSettings"
+        title="Open menu">
+        <svg class="bi" width="1.25em" height="1.25em" aria-hidden="true">
+            <use href="#list"></use>
+        </svg>
+        <span class="visually-hidden">Open menu</span>
+    </button>
+
     <div class="offcanvas offcanvas-end" tabindex="-1" id="offcanvasSettings" aria-labelledby="offcanvasSettingsLabel">
         <div class="offcanvas-header">
             <h5 class="offcanvas-title mt-0" id="offcanvasSettingsLabel">Settings</h5>
@@ -293,7 +294,39 @@
                 ${externalSpecsList}
             </div>
             <hr>
-            <p class="ps-3 pe-3" id="w3c-state">W3C Recommendation, ${currentDate}</p>
+            <!-- External Reference Changes Report Section -->
+            <div class="ps-3 pe-3" id="external-ref-changes-section" style="display: none;">
+                <div class="d-flex justify-content-between align-items-center mb-2">
+                    <p class="mb-0 fw-bold">External Reference Changes:</p>
+                    <span id="external-ref-changes-badge" class="badge bg-warning text-dark">0</span>
+                </div>
+                <p class="small text-muted mb-2">Terms whose definitions have changed since the last build:</p>
+                <div id="external-ref-changes-container" class="external-ref-changes-report">
+                    <!-- Report table will be populated by JavaScript -->
+                </div>
+                <div id="external-ref-validation-status" class="small text-muted mt-2">
+                    <i class="bi bi-hourglass-split me-1"></i>
+                    Validating external references...
+                </div>
+            </div>
+            <hr id="external-ref-changes-divider" style="display: none;">
+            <p class="d-none ps-3 pe-3" id="w3c-state">W3C Recommendation, ${currentDate}</p>
+            <!-- Build Information Section -->
+            <div class="ps-3 pe-3">
+                <p class="mb-2 fw-bold">Build Information:</p>
+                <div id="build-info" class="small text-muted">
+                    <div class="d-flex align-items-center mb-1">
+                        <i class="bi bi-calendar-event me-2"></i>
+                        <time class="timestamp" datetime="${universalTimestamp}">
+                            Generated: ${universalTimestamp}
+                        </time>
+                    </div>
+                    <div class="d-flex align-items-center mb-1">
+                        <i class="bi bi-signpost-split me-2"></i>
+                        <span>Source branch: <strong>${buildBranch}</strong></span>
+                    </div>
+                </div>
+            </div>
         </div>
     </div>
 

package/src/health-check/destination-gitignore-checker.js

@@ -1,414 +0,0 @@
-/**
- * @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 { spawnSync } = require('child_process');
-const fileOpener = require('../utils/file-opener');
-const Logger = require('../utils/logger');
-const { utils } = require('../utils/regex-patterns');
-
-/**
- * Checks if a path is gitignored
- * @param {string} projectRoot - Root directory of the project
- * @param {string} targetPath - Path to check (relative to project root)
- * @returns {boolean} - Whether the path is gitignored
- */
-function isPathGitIgnored(projectRoot, targetPath) {
-  try {
-    // 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
-    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) {
-    Logger.info(`Error checking if path is gitignored: ${error.message}`);
-    return false; // Path is not ignored (command exited with non-zero status)
-  }
-}
-
-/**
- * Check if specs.json exists and return relevant result
- * @param {string} projectRoot - Root directory of the project
- * @returns {Object} - Result object with specs file check result
- */
-function checkSpecsFileExists(projectRoot) {
-  const specsPath = path.join(projectRoot, 'specs.json');
-  
-  if (!fs.existsSync(specsPath)) {
-    return {
-      result: [{
-        name: 'Find specs.json file',
-        success: false,
-        details: 'specs.json file not found in project root'
-      }],
-      specsPath: null
-    };
-  }
-  
-  return {
-    result: [{
-      name: 'Find specs.json file',
-      success: true,
-      details: 'specs.json file found'
-    }],
-    specsPath
-  };
-}
-
-/**
- * Extract output path from specs.json
- * @param {string} specsPath - Path to specs.json file
- * @returns {Object} - Result object with output path check result
- */
-function extractOutputPath(specsPath) {
-  const results = [];
-  
-  // Read specs.json to get the output path
-  const specsContent = fs.readFileSync(specsPath, 'utf8');
-  const specs = JSON.parse(specsContent);
-  
-  // Get the output_path value
-  const outputPath = specs.specs?.[0]?.output_path;
-  
-  if (!outputPath) {
-    results.push({
-      name: 'Find output_path field',
-      success: false,
-      details: 'output_path field not found in specs.json'
-    });
-    return { results, outputPath: null };
-  }
-  
-  results.push({
-    name: 'Find output_path field',
-    success: true,
-    details: `output_path field found: "${outputPath}"`
-  });
-  
-  // Normalize the path to handle different formats (./, /, etc.)
-  const normalizedPath = outputPath.replace(/^\.\/|^\//, '');
-  
-  return { results, outputPath, normalizedPath };
-}
-
-/**
- * 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 final destination directory check
- */
-function checkOutputDirExists(projectRoot, outputPath, normalizedPath) {
-  // Check if the path exists
-  const fullPath = path.join(projectRoot, normalizedPath);
-  const outputPathExists = fs.existsSync(fullPath);
-  
-  if (!outputPathExists) {
-    return {
-      name: 'Final destination directory existence',
-      status: 'warning',
-      success: true, // Still considered a "success" for backward compatibility
-      details: `Final destination directory "${outputPath}" does not exist yet. This is OK if you haven't rendered the specs yet.`
-    };
-  } 
-  
-  return {
-    name: 'Final destination directory existence',
-    success: true,
-    details: `Final destination directory "${outputPath}" exists`
-  };
-}
-
-/**
- * Check if .gitignore file exists
- * @param {string} projectRoot - Root directory of the project
- * @param {string} normalizedPath - Normalized output path 
- * @returns {Object} - Result with gitignore check details
- */
-function checkGitignoreExists(projectRoot, normalizedPath) {
-  const results = [];
-  
-  const gitignorePath = path.join(projectRoot, '.gitignore');
-  if (!fs.existsSync(gitignorePath)) {
-    results.push({
-      name: 'Find .gitignore file',
-      status: 'warning',
-      success: true, // Still considered a "success" for backward compatibility
-      details: '.gitignore file not found in project root. Consider adding one for better version control.'
-    });
-    
-    // If no .gitignore, we can assume the output path is not ignored
-    results.push({
-      name: 'Check if output directory is gitignored',
-      success: true,
-      details: 'No .gitignore file found, so output directory is not being ignored'
-    });
-    
-    return { results, gitignoreExists: false };
-  }
-  
-  results.push({
-    name: 'Find .gitignore file',
-    success: true,
-    details: '.gitignore file found'
-  });
-  
-  return { results, gitignoreExists: true, gitignorePath };
-}
-
-/**
- * Filter non-comment lines from gitignore content
- * @param {string} content - Content of .gitignore file
- * @returns {Array} - Array of non-comment, non-empty lines
- */
-function getRelevantGitignoreLines(content) {
-  const allLines = content.split('\n');
-  
-  return allLines.filter(line => {
-    const trimmedLine = line.trim();
-    return trimmedLine !== '' && !trimmedLine.startsWith('#');
-  }).map(line => line.trim());
-}
-
-/**
- * Check for patterns that might ignore output directory
- * @param {Array} lines - Array of gitignore lines
- * @param {string} normalizedPath - Normalized output path
- * @param {string} dirName - Directory name from path
- * @returns {Array} - Array of ignoring patterns found
- */
-function findOutputDirIgnorePatterns(lines, normalizedPath, dirName) {
-  const dirIgnorePatterns = [];
-  
-  for (const trimmedLine of lines) {
-    // Directly check for common patterns that would ignore the output directory
-    if (
-      trimmedLine === normalizedPath || 
-      trimmedLine === `/${normalizedPath}` || 
-      trimmedLine === `./${normalizedPath}` ||
-      trimmedLine === `${normalizedPath}/` ||
-      trimmedLine === `/${normalizedPath}/` ||
-      trimmedLine === `./${normalizedPath}/` ||
-      // Check for just the directory name (e.g., "docs")
-      trimmedLine === dirName ||
-      trimmedLine === `/${dirName}` ||
-      trimmedLine === `./${dirName}` ||
-      trimmedLine === `${dirName}/` ||
-      trimmedLine === `/${dirName}/` ||
-      trimmedLine === `./${dirName}/` ||
-      // Check for wildcards covering all directories
-      trimmedLine === '*/' ||
-      // Check for wildcards that might match our path using regex
-      (trimmedLine.includes('*') && utils.createGitignoreRegex(trimmedLine).test(normalizedPath))
-    ) {
-      dirIgnorePatterns.push(trimmedLine);
-    }
-  }
-  
-  return dirIgnorePatterns;
-}
-
-/**
- * Check for patterns that might ignore HTML files
- * @param {Array} lines - Array of gitignore lines
- * @returns {Array} - Array of HTML ignoring patterns found
- */
-function findHtmlIgnorePatterns(lines) {
-  const htmlIgnorePatterns = [];
-  
-  for (const trimmedLine of lines) {
-    if (
-      trimmedLine === 'index.html' || 
-      trimmedLine === '*.html' || 
-      trimmedLine === '/index.html' || 
-      trimmedLine === '**/index.html' ||
-      trimmedLine === '**/*.html'
-    ) {
-      htmlIgnorePatterns.push(trimmedLine);
-    }
-  }
-  
-  return htmlIgnorePatterns;
-}
-
-/**
- * Find complex patterns that might be affecting HTML files
- * @param {Array} lines - Array of gitignore lines
- * @returns {Array} - Array of complex patterns found
- */
-function findComplexHtmlPatterns(lines) {
-  const patterns = [];
-  
-  for (const trimmedLine of lines) {
-    // Check for wildcards and patterns that might match index.html
-    if (trimmedLine.includes('*') || trimmedLine.includes('.html')) {
-      patterns.push(trimmedLine);
-    }
-  }
-  
-  return patterns;
-}
-
-/**
- * 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
- * @param {Array} relevantLines - Relevant lines from .gitignore
- * @returns {Array} - Results for HTML files gitignore check
- */
-function checkHtmlFilesGitignore(projectRoot, normalizedPath, outputPath, relevantLines) {
-  const results = [];
-  const htmlIgnorePatterns = findHtmlIgnorePatterns(relevantLines);
-  
-  if (htmlIgnorePatterns.length > 0) {
-    results.push({
-      name: 'Check if index.html files are gitignored',
-      success: false,
-      details: `Found patterns in .gitignore that would ignore HTML files: ${htmlIgnorePatterns.join(', ')}. This is problematic as they're crucial output files.`
-    });
-    return results;
-  }
-  
-  // Check if index.html would be ignored
-  const indexHtmlPath = path.join(normalizedPath, 'index.html');
-  const isIndexHtmlIgnored = isPathGitIgnored(projectRoot, indexHtmlPath);
-  
-  results.push({
-    name: 'Check if index.html files are gitignored',
-    success: !isIndexHtmlIgnored,
-    details: isIndexHtmlIgnored 
-      ? `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
-  if (isIndexHtmlIgnored && htmlIgnorePatterns.length === 0) {
-    const complexPatterns = findComplexHtmlPatterns(relevantLines);
-    
-    if (complexPatterns.length > 0) {
-      results.push({
-        name: 'Found complex .gitignore entries potentially affecting HTML files',
-        status: 'warning',
-        success: true, // Still considered a "success" for backward compatibility
-        details: `The following entries in .gitignore might cause HTML files to be ignored: ${complexPatterns.join(', ')}. Consider reviewing these patterns.`
-      });
-    }
-  }
-  
-  return results;
-}
-
-/**
- * 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 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 final destination directory is gitignored',
-      success: false,
-      details: `Found patterns in .gitignore that would ignore the final destination directory: ${dirIgnorePatterns.join(', ')}. Remove these entries to ensure generated content is tracked.`
-    }];
-  }
-  
-  // Fall back to using git check-ignore for verification
-  const isIgnored = isPathGitIgnored(projectRoot, normalizedPath);
-  
-  return [{
-    name: 'Check if final destination directory is gitignored',
-    success: !isIgnored,
-    details: isIgnored 
-      ? `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 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 checkDestinationGitIgnore(projectRoot) {
-  const results = [];
-  
-  try {
-    // Check if specs.json exists
-    const specsCheck = checkSpecsFileExists(projectRoot);
-    if (!specsCheck.specsPath) {
-      return specsCheck.result;
-    }
-    
-    results.push(...specsCheck.result);
-    
-    // Extract and validate output path
-    const outputPathCheck = extractOutputPath(specsCheck.specsPath);
-    if (!outputPathCheck.outputPath) {
-      return [...results, ...outputPathCheck.results];
-    }
-    
-    results.push(...outputPathCheck.results);
-    const { outputPath, normalizedPath } = outputPathCheck;
-    
-    // Check if output directory exists
-    const outputDirResult = checkOutputDirExists(projectRoot, outputPath, normalizedPath);
-    results.push(outputDirResult);
-    
-    // Check if .gitignore exists
-    const gitignoreCheck = checkGitignoreExists(projectRoot, normalizedPath);
-    results.push(...gitignoreCheck.results);
-    
-    if (!gitignoreCheck.gitignoreExists) {
-      return results;
-    }
-    
-    // Read .gitignore content and process it
-    const gitignoreContent = fs.readFileSync(gitignoreCheck.gitignorePath, 'utf8');
-    const relevantLines = getRelevantGitignoreLines(gitignoreContent);
-    const dirName = path.basename(normalizedPath);
-    
-    // Check final destination directory ignore patterns
-    const dirResults = checkOutputDirIgnorePatterns(
-      projectRoot, normalizedPath, outputPath, dirName, relevantLines
-    );
-    results.push(...dirResults);
-    
-    // Check HTML files ignore patterns
-    const htmlResults = checkHtmlFilesGitignore(
-      projectRoot, normalizedPath, outputPath, relevantLines
-    );
-    results.push(...htmlResults);
-    
-    return results;
-  } catch (error) {
-    Logger.error('Error checking final destination directory gitignore status:', error);
-    return [{
-      name: 'Final destination directory gitignore check',
-      success: false,
-      details: `Error: ${error.message}`
-    }];
-  }
-}
-
-module.exports = {
-  checkDestinationGitIgnore
-};