spec-up-t 1.2.3 → 1.2.5

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

@@ -15,11 +15,11 @@ function extractTrefInfo(firstLine) {
   try {
     // Extract content between [[tref: and ]]
     const trefMatch = firstLine.match(/\[\[tref:([^\]]+)\]\]/);
-    if (!trefMatch || !trefMatch[1]) {
+    if (!trefMatch?.length) {
       return null;
     }
     
-    const trefContent = trefMatch[1].trim();
+    const trefContent = trefMatch[1]?.trim();
     
     // Split by the first comma
     const parts = trefContent.split(',');
@@ -75,7 +75,7 @@ function termExistsInRepo(filePath, term) {
     const cacheData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
     
     // Check if the file has a terms array
-    if (!cacheData || !cacheData.terms || !Array.isArray(cacheData.terms)) {
+    if (!cacheData?.terms?.length) {
       console.log(`Warning: Cache file ${filePath} has no terms array`);
       return false;
     }
@@ -86,7 +86,7 @@ function termExistsInRepo(filePath, term) {
     // Check each term in the terms array
     for (const termObj of cacheData.terms) {
       // First check the 'term' property if it exists
-      if (termObj.term && termObj.term.toLowerCase() === termLower) {
+      if (termObj.term?.toLowerCase() === termLower) {
         return true;
       }
       
@@ -94,7 +94,7 @@ function termExistsInRepo(filePath, term) {
       if (termObj.definition) {
         // Look for patterns like [[def: term]] or similar
         const defMatch = termObj.definition.match(/\[\[def:\s*([^\],]+)/i);
-        if (defMatch && defMatch[1] && defMatch[1].trim().toLowerCase() === termLower) {
+        if (defMatch?.[1]?.trim().toLowerCase() === termLower) {
           return true;
         }
       }
@@ -117,7 +117,7 @@ function findRepoForCacheFile(filePath, externalSpecs) {
   try {
     const cacheData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
     
-    if (!cacheData || !cacheData.repository) {
+    if (!cacheData?.repository) {
       return null;
     }
     
@@ -129,15 +129,16 @@ function findRepoForCacheFile(filePath, externalSpecs) {
       if (!spec.url) continue;
       
       // Extract owner/repo from the URL
-      const match = spec.url.match(/github\.com\/([^\/]+\/[^\/]+)/i);
-      if (match && match[1] && repoPath.includes(match[1])) {
+      const match = spec.url.match(/github\.com\/([^/]+\/[^/]+)/i);
+      if (match?.[1] && repoPath.includes(match[1])) {
         return spec.external_spec;
       }
     }
     
     return null;
   } catch (error) {
-    return null;
+    console.error(`Error finding repository for cache file ${filePath}:`, error);
+    return null; // Could not determine repository due to error reading or parsing cache file
   }
 }
 
@@ -180,14 +181,14 @@ function findTermInOtherRepos(cacheDir, externalSpecs, currentRepo, term) {
  * @returns {string|null} - Path to the cache file or null
  */
 function findCacheFileForRepo(cacheDir, specConfig) {
-  if (!fs.existsSync(cacheDir) || !specConfig || !specConfig.url) {
+  if (!fs.existsSync(cacheDir) || !specConfig?.url) {
     return null;
   }
   
   try {
     // Extract owner and repo from URL
-    const match = specConfig.url.match(/github\.com\/([^\/]+)\/([^\/]+)/i);
-    if (!match || !match[1] || !match[2]) {
+    const match = specConfig.url.match(/github\.com\/([^/]+)\/([^/]+)/i);
+    if (!match?.[1] || !match?.[2]) {
       return null;
     }
     
@@ -203,8 +204,8 @@ function findCacheFileForRepo(cacheDir, specConfig) {
       }))
       // Sort by timestamp descending (assuming timestamp is at the beginning of filename)
       .sort((a, b) => {
-        const timestampA = parseInt(a.name.split('-')[0] || '0', 10);
-        const timestampB = parseInt(b.name.split('-')[0] || '0', 10);
+        const timestampA = parseInt(a.name.split('-')[0] ?? '0', 10);
+        const timestampB = parseInt(b.name.split('-')[0] ?? '0', 10);
         return timestampB - timestampA;
       });
     
@@ -223,121 +224,276 @@ function findCacheFileForRepo(cacheDir, specConfig) {
 }
 
 /**
- * Check if terms referenced via tref tags exist in the corresponding external repos
+ * Get configuration and setup data from specs.json
  * @param {string} projectRoot - Root directory of the project
- * @returns {Promise<Array>} - Array of check results
+ * @returns {Object} - Object containing results, specs data, external specs and spec directories
  */
-async function checkTrefTerms(projectRoot) {
+async function getProjectConfiguration(projectRoot) {
   const results = [];
   
-  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 [{
+  // Path to the project's specs.json
+  const specsPath = path.join(projectRoot, 'specs.json');
+  
+  // Check if specs.json exists
+  if (!fs.existsSync(specsPath)) {
+    return {
+      results: [{
         name: 'Find specs.json file',
         success: false,
         details: 'specs.json file not found in project root'
-      }];
+      }],
+      valid: false
+    };
+  }
+  
+  results.push({
+    name: 'Find specs.json file',
+    success: true,
+    details: 'specs.json file found'
+  });
+  
+  // Read specs.json to get the spec directory
+  const specsContent = fs.readFileSync(specsPath, 'utf8');
+  const specs = JSON.parse(specsContent);
+  
+  // Get the external specs
+  if (!specs.specs?.length) {
+    results.push({
+      name: 'Find specs configuration',
+      success: false,
+      details: 'specs array not found in specs.json'
+    });
+    return { results, valid: false };
+  }
+  
+  // Collect all external specs and spec directories
+  const externalSpecs = [];
+  const specDirs = [];
+  
+  specs.specs.forEach(spec => {
+    if (spec.external_specs?.length) {
+      externalSpecs.push(...spec.external_specs);
     }
     
+    if (spec.spec_directory && spec.spec_terms_directory) {
+      const termsDir = path.join(
+        projectRoot, 
+        spec.spec_directory, 
+        spec.spec_terms_directory
+      );
+      specDirs.push(termsDir);
+    }
+  });
+
+  if (externalSpecs.length === 0) {
+    results.push({
+      name: 'Find external specs',
+      success: false,
+      details: 'No external specs found in specs.json'
+    });
+    return { results, valid: false };
+  }
+  
+  results.push({
+    name: 'Find external specs',
+    success: true,
+    details: `Found ${externalSpecs.length} external specs`
+  });
+  
+  if (specDirs.length === 0) {
+    results.push({
+      name: 'Find spec terms directories',
+      success: false,
+      details: 'No spec terms directories found'
+    });
+    return { results, valid: false };
+  }
+  
+  results.push({
+    name: 'Find spec terms directories', 
+    success: true,
+    details: `Found ${specDirs.length} spec terms directories`
+  });
+
+  return { 
+    results, 
+    specs, 
+    externalSpecs, 
+    specDirs, 
+    valid: true,
+    githubCacheDir: path.join(projectRoot, '.cache', 'github-cache')
+  };
+}
+
+/**
+ * Verify if a term exists in the specified repository
+ * @param {Object} options - Options for verification
+ * @param {string} options.githubCacheDir - Path to GitHub cache directory
+ * @param {string} options.repo - Repository to check
+ * @param {string} options.term - Term to find
+ * @param {string} options.file - File name for reporting
+ * @param {Array} options.externalSpecs - List of external specs
+ * @returns {Object} - Object containing results and status
+ */
+function verifyTermInRepo(options) {
+  const { githubCacheDir, repo, term, file, externalSpecs } = options;
+  const results = [];
+
+  // Check if the referenced repo exists in external_specs
+  const specConfig = externalSpecs.find(spec => spec.external_spec === repo);
+  if (!specConfig) {
+    results.push({
+      name: `Check repo reference in ${file}`,
+      success: false,
+      details: `Referenced repo "${repo}" is not defined in external_specs`
+    });
+    return { results, status: 'invalid_repo' };
+  }
+  
+  // Find the cache file for this repo
+  const cacheFile = findCacheFileForRepo(githubCacheDir, specConfig);
+  
+  if (!cacheFile) {
+    results.push({
+      name: `Find cache for repo "${repo}" referenced in ${file}`,
+      success: false,
+      details: `No cache file found for repo "${repo}". Unable to verify if term "${term}" exists.`
+    });
+    return { results, status: 'no_cache' };
+  }
+  
+  // Check if the term exists in the repo
+  const termExists = termExistsInRepo(cacheFile, term);
+  
+  if (termExists) {
     results.push({
-      name: 'Find specs.json file',
+      name: `Term "${term}" in repo "${repo}" (${file})`,
       success: true,
-      details: 'specs.json file found'
+      details: `Term "${term}" found in repo "${repo}"`
+    });
+    return { results, status: 'found' };
+  }
+  
+  // Check if the term exists in other repos
+  const otherRepos = findTermInOtherRepos(githubCacheDir, externalSpecs, repo, term);
+  
+  if (otherRepos.length > 0) {
+    // Show as warning (partial success) instead of failure
+    results.push({
+      name: `Term "${term}" in repo "${repo}" (${file})`,
+      success: 'partial', // Use 'partial' to indicate a warning
+      details: `Warning: Term <code>${term}</code> NOT found in repo ${repo} but found in these repos: <code>${otherRepos.join(', ')}</code>. Consider updating the reference.`
     });
+    return { results, status: 'found_elsewhere' };
+  }
+  
+  results.push({
+    name: `Term "${term}" in repo "${repo}" (${file})`,
+    success: false,
+    details: `Term <code>${term}</code> NOT found in repo <code>${repo}</code> and not found in any other external repos`
+  });
+  return { results, status: 'not_found' };
+}
+
+/**
+ * Process a single markdown file to check for tref tags
+ * @param {Object} options - Processing options
+ * @param {string} options.filePath - Path to markdown file
+ * @param {string} options.githubCacheDir - Path to GitHub cache directory
+ * @param {Array} options.externalSpecs - List of external specs
+ * @returns {Object} - Object containing results and counts
+ */
+function processMarkdownFile(options) {
+  const { filePath, githubCacheDir, externalSpecs } = options;
+  const file = path.basename(filePath);
+  const results = [];
+  const counts = { 
+    filesWithTref: 0, 
+    validTerms: 0, 
+    invalidTerms: 0, 
+    termsFoundInOtherRepos: 0 
+  };
+  
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const firstLine = lines[0];
+    
+    if (!firstLine.includes('[[tref:')) {
+      return { results, counts };
+    }
     
-    // Read specs.json to get the spec directory
-    const specsContent = fs.readFileSync(specsPath, 'utf8');
-    const specs = JSON.parse(specsContent);
+    counts.filesWithTref = 1;
     
-    // Get the external specs
-    if (!specs.specs || !Array.isArray(specs.specs)) {
+    // Extract repo and term information
+    const trefInfo = extractTrefInfo(firstLine);
+    if (!trefInfo) {
       results.push({
-        name: 'Find specs configuration',
+        name: `Parse tref in ${file}`,
         success: false,
-        details: 'specs array not found in specs.json'
+        details: `Could not parse tref information from first line: "${firstLine}"`
       });
-      return results;
+      return { results, counts };
     }
     
-    // Collect all external specs and spec directories
-    const externalSpecs = [];
-    const specDirs = [];
+    const { repo, term } = trefInfo;
     
-    specs.specs.forEach(spec => {
-      if (spec.external_specs && Array.isArray(spec.external_specs)) {
-        externalSpecs.push(...spec.external_specs);
-      }
-      
-      if (spec.spec_directory && spec.spec_terms_directory) {
-        const termsDir = path.join(
-          projectRoot, 
-          spec.spec_directory, 
-          spec.spec_terms_directory
-        );
-        specDirs.push(termsDir);
-      }
+    // Verify the term
+    const verification = verifyTermInRepo({
+      githubCacheDir,
+      repo,
+      term,
+      file,
+      externalSpecs
     });
     
-    if (externalSpecs.length === 0) {
-      results.push({
-        name: 'Find external specs',
-        success: false,
-        details: 'No external specs found in specs.json'
-      });
-      return results;
+    results.push(...verification.results);
+    
+    // Update counts based on verification status
+    if (verification.status === 'found') {
+      counts.validTerms = 1;
+    } else if (verification.status === 'found_elsewhere') {
+      counts.termsFoundInOtherRepos = 1;
+    } else if (verification.status === 'not_found') {
+      counts.invalidTerms = 1;
     }
     
+  } catch (error) {
     results.push({
-      name: 'Find external specs',
-      success: true,
-      details: `Found ${externalSpecs.length} external specs`
+      name: `Process file ${file}`,
+      success: false,
+      details: `Error processing file: ${error.message}`
     });
+  }
+  
+  return { results, counts };
+}
+
+/**
+ * Check if terms referenced via tref tags exist in the corresponding external repos
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {Promise<Array>} - Array of check results
+ */
+async function checkTrefTerms(projectRoot) {
+  try {
+    // Get project configuration
+    const config = await getProjectConfiguration(projectRoot);
     
-    if (specDirs.length === 0) {
-      results.push({
-        name: 'Find spec terms directories',
-        success: false,
-        details: 'No spec terms directories found'
-      });
-      return results;
+    // If configuration is invalid, return early with errors
+    if (!config.valid) {
+      return config.results;
     }
     
-    results.push({
-      name: 'Find spec terms directories', 
-      success: true,
-      details: `Found ${specDirs.length} spec terms directories`
-    });
+    const { results, specDirs, externalSpecs, githubCacheDir } = config;
     
-    // Directory is auto generated, no need for this warning
-    // // Path to the GitHub cache directory
-    // const githubCacheDir = path.join(projectRoot, 'output', 'github-cache');
-    
-    // if (!fs.existsSync(githubCacheDir)) {
-    //   results.push({
-    //     name: 'Find GitHub cache directory',
-    //     success: false,
-    //     details: 'GitHub cache directory not found at output/github-cache. Terms in external repos cannot be verified.'
-    //   });
-    //   return results;
-    // }
-    
-    // results.push({
-    //   name: 'Find GitHub cache directory',
-    //   success: true,
-    //   details: 'GitHub cache directory found'
-    // });
-    
-    // Find and check all markdown files in all spec directories
+    // Initialize counters
     let totalFiles = 0;
     let filesWithTref = 0;
     let validTerms = 0;
     let invalidTerms = 0;
     let termsFoundInOtherRepos = 0;
     
+    // Process each spec directory
     for (const specDir of specDirs) {
       if (!fs.existsSync(specDir)) {
         continue;
@@ -349,98 +505,27 @@ async function checkTrefTerms(projectRoot) {
       
       totalFiles += markdownFiles.length;
       
+      // Process each markdown file
       for (const file of markdownFiles) {
         const filePath = path.join(specDir, file);
+        const fileResult = processMarkdownFile({
+          filePath,
+          githubCacheDir,
+          externalSpecs
+        });
         
-        try {
-          const content = fs.readFileSync(filePath, 'utf8');
-          const lines = content.split('\n');
-          const firstLine = lines[0];
-          
-          if (!firstLine.includes('[[tref:')) {
-            continue;
-          }
-          
-          filesWithTref++;
-          
-          // Extract repo and term information
-          const trefInfo = extractTrefInfo(firstLine);
-          if (!trefInfo) {
-            results.push({
-              name: `Parse tref in ${file}`,
-              success: false,
-              details: `Could not parse tref information from first line: "${firstLine}"`
-            });
-            continue;
-          }
-          
-          const { repo, term } = trefInfo;
-          
-          // Check if the referenced repo exists in external_specs
-          const specConfig = externalSpecs.find(spec => spec.external_spec === repo);
-          if (!specConfig) {
-            results.push({
-              name: `Check repo reference in ${file}`,
-              success: false,
-              details: `Referenced repo "${repo}" is not defined in external_specs`
-            });
-            continue;
-          }
-          
-          // Find the cache file for this repo
-          const cacheFile = findCacheFileForRepo(githubCacheDir, specConfig);
-          
-          if (!cacheFile) {
-            results.push({
-              name: `Find cache for repo "${repo}" referenced in ${file}`,
-              success: false,
-              details: `No cache file found for repo "${repo}". Unable to verify if term "${term}" exists.`
-            });
-            continue;
-          }
-          
-          // Check if the term exists in the repo
-          const termExists = termExistsInRepo(cacheFile, term);
-          
-          if (termExists) {
-            validTerms++;
-            results.push({
-              name: `Term "${term}" in repo "${repo}" (${file})`,
-              success: true,
-              details: `Term "${term}" found in repo "${repo}"`
-            });
-          } else {
-            // Check if the term exists in other repos
-            const otherRepos = findTermInOtherRepos(githubCacheDir, externalSpecs, repo, term);
-            
-            if (otherRepos.length > 0) {
-              // Change: Show as warning (partial success) instead of failure
-              termsFoundInOtherRepos++;
-              results.push({
-                name: `Term "${term}" in repo "${repo}" (${file})`,
-                success: 'partial', // Use 'partial' to indicate a warning
-                details: `Warning: Term <code>${term}</code> NOT found in repo ${repo} but found in these repos: <code>${otherRepos.join(', ')}</code>. Consider updating the reference.`
-              });
-            } else {
-              invalidTerms++;
-              results.push({
-                name: `Term "${term}" in repo "${repo}" (${file})`,
-                success: false,
-                details: `Term <code>${term}</code> NOT found in repo <code>${repo}</code> and not found in any other external repos`
-              });
-            }
-          }
-        } catch (error) {
-          results.push({
-            name: `Process file ${file}`,
-            success: false,
-            details: `Error processing file: ${error.message}`
-          });
-        }
+        // Add results
+        results.push(...fileResult.results);
+        
+        // Update counters
+        filesWithTref += fileResult.counts.filesWithTref;
+        validTerms += fileResult.counts.validTerms;
+        invalidTerms += fileResult.counts.invalidTerms;
+        termsFoundInOtherRepos += fileResult.counts.termsFoundInOtherRepos;
       }
     }
     
-    // Add summary results - modified to include terms found in other repos
+    // Add summary results
     results.push({
       name: 'Term reference validation summary',
       success: invalidTerms === 0,