spec-up-t 1.2.3 → 1.2.4

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

@@ -16,234 +16,370 @@ function isPathGitIgnored(projectRoot, targetPath) {
     execSync(`git -C "${projectRoot}" check-ignore -q "${targetPath}"`, { stdio: 'ignore' });
     return true; // 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)
   }
 }
 
 /**
- * Check if the output directory is being ignored by Git
+ * Check if specs.json exists and return relevant result
  * @param {string} projectRoot - Root directory of the project
- * @returns {Promise<Array>} - Array of check results
+ * @returns {Object} - Result object with specs file check result
  */
-async function checkOutputDirGitIgnore(projectRoot) {
-  const results = [];
+function checkSpecsFileExists(projectRoot) {
+  const specsPath = path.join(projectRoot, 'specs.json');
   
-  try {
-    // Path to the project's specs.json
-    const specsPath = path.join(projectRoot, 'specs.json');
-    
-    // Check if specs.json exists
-    if (!fs.existsSync(specsPath)) {
-      return [{
+  if (!fs.existsSync(specsPath)) {
+    return {
+      result: [{
         name: 'Find specs.json file',
         success: false,
         details: 'specs.json file not found in project root'
-      }];
-    }
-    
-    results.push({
+      }],
+      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 output directory 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
+ */
+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: 'Output 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.`
+    };
+  } 
+  
+  return {
+    name: 'Output directory existence',
+    success: true,
+    details: `Output 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.'
     });
     
-    // 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;
-    }
-    
+    // If no .gitignore, we can assume the output path is not ignored
     results.push({
-      name: 'Find output_path field',
+      name: 'Check if output directory is gitignored',
       success: true,
-      details: `output_path field found: "${outputPath}"`
+      details: 'No .gitignore file found, so output directory is not being ignored'
     });
     
-    // Normalize the path to handle different formats (./, /, etc.)
-    const normalizedPath = outputPath.replace(/^\.\/|^\//, '');
-    
-    // Check if the path exists
-    const fullPath = path.join(projectRoot, normalizedPath);
-    const outputPathExists = fs.existsSync(fullPath);
-    
-    if (!outputPathExists) {
-      results.push({
-        name: 'Output 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.`
-      });
-    } else {
-      results.push({
-        name: 'Output directory existence',
-        success: true,
-        details: `Output directory "${outputPath}" exists`
-      });
+    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('*') && new RegExp('^' + trimmedLine.replace(/\*/g, '.*').replace(/\//g, '\\/') + '$').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 output 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 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.`
+  });
+  
+  // 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);
     
-    // Check if .gitignore exists
-    const gitignorePath = path.join(projectRoot, '.gitignore');
-    if (!fs.existsSync(gitignorePath)) {
+    if (complexPatterns.length > 0) {
       results.push({
-        name: 'Find .gitignore file',
+        name: 'Found complex .gitignore entries potentially affecting HTML files',
         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'
+        details: `The following entries in .gitignore might cause HTML files to be ignored: ${complexPatterns.join(', ')}. Consider reviewing these patterns.`
       });
-      
-      return results;
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Check if output directory 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
+ */
+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',
+      success: false,
+      details: `Found patterns in .gitignore that would ignore the output 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 output 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.`
+  }];
+}
+
+/**
+ * Check if the output directory is being ignored by Git
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {Promise<Array>} - Array of check results
+ */
+async function checkOutputDirGitIgnore(projectRoot) {
+  const results = [];
+  
+  try {
+    // Check if specs.json exists
+    const specsCheck = checkSpecsFileExists(projectRoot);
+    if (!specsCheck.specsPath) {
+      return specsCheck.result;
     }
     
-    results.push({
-      name: 'Find .gitignore file',
-      success: true,
-      details: '.gitignore file found'
-    });
+    results.push(...specsCheck.result);
     
-    // Read .gitignore content
-    const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
-    const lines = gitignoreContent.split('\n');
+    // Extract and validate output path
+    const outputPathCheck = extractOutputPath(specsCheck.specsPath);
+    if (!outputPathCheck.outputPath) {
+      return [...results, ...outputPathCheck.results];
+    }
     
-    // Extract the directory name from the path
-    const dirName = path.basename(normalizedPath);
+    results.push(...outputPathCheck.results);
+    const { outputPath, normalizedPath } = outputPathCheck;
     
-    // IMPROVED: First directly check .gitignore for patterns that would ignore the output directory
-    const dirIgnorePatterns = [];
+    // Check if output directory exists
+    const outputDirResult = checkOutputDirExists(projectRoot, outputPath, normalizedPath);
+    results.push(outputDirResult);
     
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      // Skip empty lines and comments
-      if (trimmedLine === '' || trimmedLine.startsWith('#')) {
-        continue;
-      }
-      
-      // 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('*') && new RegExp('^' + trimmedLine.replace(/\*/g, '.*').replace(/\//g, '\\/') + '$').test(normalizedPath))
-      ) {
-        dirIgnorePatterns.push(trimmedLine);
-      }
-    }
+    // Check if .gitignore exists
+    const gitignoreCheck = checkGitignoreExists(projectRoot, normalizedPath);
+    results.push(...gitignoreCheck.results);
     
-    // If we found patterns that would ignore the output directory, report them regardless of git check-ignore
-    if (dirIgnorePatterns.length > 0) {
-      results.push({
-        name: 'Check if output 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.`
-      });
-    } else {
-      // Fall back to using git check-ignore for verification
-      const isIgnored = isPathGitIgnored(projectRoot, normalizedPath);
-      
-      results.push({
-        name: 'Check if output 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.`
-      });
+    if (!gitignoreCheck.gitignoreExists) {
+      return results;
     }
     
-    // Check for HTML file ignoring patterns
-    const htmlIgnorePatterns = [];
+    // Read .gitignore content and process it
+    const gitignoreContent = fs.readFileSync(gitignoreCheck.gitignorePath, 'utf8');
+    const relevantLines = getRelevantGitignoreLines(gitignoreContent);
+    const dirName = path.basename(normalizedPath);
     
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      // Skip empty lines and comments
-      if (trimmedLine === '' || trimmedLine.startsWith('#')) {
-        continue;
-      }
-      
-      if (
-        trimmedLine === 'index.html' || 
-        trimmedLine === '*.html' || 
-        trimmedLine === '/index.html' || 
-        trimmedLine === '**/index.html' ||
-        trimmedLine === '**/*.html'
-      ) {
-        htmlIgnorePatterns.push(trimmedLine);
-      }
-    }
+    // Check output directory ignore patterns
+    const dirResults = checkOutputDirIgnorePatterns(
+      projectRoot, normalizedPath, outputPath, dirName, relevantLines
+    );
+    results.push(...dirResults);
     
-    // If we found HTML patterns in .gitignore, flag them regardless of git check-ignore result
-    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.`
-      });
-    } else {
-      // Only use git check-ignore as a fallback if we didn't find explicit HTML patterns
-      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 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.`
-      });
-      
-      // If index.html is ignored but we couldn't find an explicit pattern, look for more complex patterns
-      if (isIndexHtmlIgnored && htmlIgnorePatterns.length === 0) {
-        // Look for more complex patterns that might be ignoring index.html files
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (trimmedLine === '' || trimmedLine.startsWith('#')) {
-            continue;
-          }
-          
-          // Check for wildcards and patterns that might match index.html
-          if (trimmedLine.includes('*') || trimmedLine.includes('.html')) {
-            htmlIgnorePatterns.push(trimmedLine);
-          }
-        }
-        
-        if (htmlIgnorePatterns.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: ${htmlIgnorePatterns.join(', ')}. Consider reviewing these patterns.`
-          });
-        }
-      }
-    }
+    // Check HTML files ignore patterns
+    const htmlResults = checkHtmlFilesGitignore(
+      projectRoot, normalizedPath, outputPath, relevantLines
+    );
+    results.push(...htmlResults);
     
     return results;
   } catch (error) {