feat(coverage): filter dist and external files from coverage reports

Implement post-processing to exclude non-source files from coverage:
- Create filter-coverage.mjs script with logger integration
- Filter out 33 dist/ compiled files, 3 external dependencies, 2 test files
- Keep only 111 src/ TypeScript files for accurate coverage measurement
- Integrate filtering into cover.mjs workflow automatically
- Update vitest.config.mts with improved exclusion patterns

This provides true source-only coverage metrics by removing:
- Compiled JavaScript from dist/
- Bundled external dependencies (36MB of code)
- Test helper files

Coverage reports (HTML/LCOV) now accurately reflect src/ TypeScript coverage only.

Author: jdalton

.config/vitest.config.mts

@@ -132,13 +132,21 @@ export default defineConfig({
         'test/**',
         'packages/**',
         'perf/**',
-        '**/dist/**',
+        // Exclude all dist directory and its contents
         'dist/**',
+        '**/dist/**',
+        '**/{dist,build,out}/**',
+        // Exclude external bundled dependencies
         'src/external/**',
+        '**/external/**',
         'src/types.ts',
         'scripts/**',
       ],
-      include: ['src/**/*.{ts,mts,cts}'],
+      include: [
+        'src/**/*.{ts,mts,cts}',
+        // Explicitly exclude external from include
+        '!src/external/**',
+      ],
       excludeAfterRemap: true,
       all: true,
       clean: true,

scripts/cover.mjs

@@ -218,6 +218,26 @@ try {
     }
   }
 
+  // Filter coverage data to exclude dist/ and external files
+  if (exitCode === 0) {
+    logger.info('Filtering coverage data to src/ files only...')
+    try {
+      const filterResult = await spawn(
+        'node',
+        ['scripts/filter-coverage.mjs'],
+        {
+          cwd: rootPath,
+          stdio: 'inherit',
+        },
+      )
+      if (filterResult.code !== 0) {
+        logger.warn('Coverage filtering had issues but continuing...')
+      }
+    } catch (filterError) {
+      logger.warn(`Coverage filtering failed: ${filterError.message}`)
+    }
+  }
+
   if (exitCode === 0) {
     logger.success('Coverage completed successfully')
   } else {

scripts/filter-coverage.mjs

@@ -1,43 +1,108 @@
 /**
- * @fileoverview Filter coverage data to exclude dist/ files
+ * @fileoverview Filter coverage data to exclude dist/ and external files
  *
- * This script post-processes V8 coverage data to remove dist/ files,
- * ensuring coverage reports only show src/ TypeScript files.
+ * This script post-processes V8 coverage data to remove:
+ * - dist/ compiled JavaScript files
+ * - external bundled dependencies
+ * - test files
+ * Ensuring coverage reports only show src/ TypeScript files (excluding src/external).
  */
 
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { getDefaultLogger } from '../dist/logger.js'
 
+const logger = getDefaultLogger()
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const projectRoot = path.resolve(__dirname, '..')
-const coveragePath = path.join(projectRoot, 'coverage/coverage-final.json')
 
-if (!fs.existsSync(coveragePath)) {
-  console.error('Coverage file not found:', coveragePath)
+// Find all coverage JSON files
+const coverageDir = path.join(projectRoot, 'coverage')
+if (!fs.existsSync(coverageDir)) {
+  logger.error('Coverage directory not found:', coverageDir)
   process.exit(1)
 }
 
-const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf-8'))
+const coverageFinalPath = path.join(coverageDir, 'coverage-final.json')
+const coverageSummaryPath = path.join(coverageDir, 'coverage-summary.json')
 
-// Filter out dist/ files
-const filtered = {}
-let distCount = 0
-let srcCount = 0
+function filterCoverageFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    logger.info(`Skipping ${path.basename(filePath)} - not found`)
+    return { filtered: 0, kept: 0, total: 0, details: {} }
+  }
+
+  const coverage = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  const filtered = {}
+  let distCount = 0
+  let externalCount = 0
+  let testCount = 0
+  let srcCount = 0
+
+  for (const [file, data] of Object.entries(coverage)) {
+    // Exclude dist/ compiled files
+    if (file.includes('/dist/') || file.includes('\\dist\\')) {
+      distCount++
+      continue
+    }
+
+    // Exclude external bundled dependencies
+    if (
+      file.includes('/external/') ||
+      file.includes('\\external\\') ||
+      file.includes('src/external')
+    ) {
+      externalCount++
+      continue
+    }
+
+    // Exclude test files
+    if (file.includes('/test/') || file.includes('\\test\\')) {
+      testCount++
+      continue
+    }
+
+    // Keep src/ TypeScript files
+    if (file.includes('/src/') || file.includes('\\src\\')) {
+      filtered[file] = data
+      srcCount++
+    }
+  }
+
+  fs.writeFileSync(filePath, JSON.stringify(filtered, null, 2))
 
-for (const [file, data] of Object.entries(coverage)) {
-  // Keep only src/ files, exclude dist/
-  if (file.includes('/src/') && !file.includes('/dist/')) {
-    filtered[file] = data
-    srcCount++
-  } else if (file.includes('/dist/')) {
-    distCount++
+  return {
+    filtered: distCount + externalCount + testCount,
+    kept: srcCount,
+    total: Object.keys(coverage).length,
+    details: { distCount, externalCount, testCount, srcCount },
   }
 }
 
-console.log(`Filtered ${distCount} dist/ files`)
-console.log(`Kept ${srcCount} src/ files`)
-console.log(`Total files: ${Object.keys(coverage).length}`)
+logger.info('Filtering coverage data...\n')
+
+const finalStats = filterCoverageFile(coverageFinalPath)
+logger.info(`coverage-final.json:`)
+logger.success(`  Kept ${finalStats.kept} src/ TypeScript files`)
+if (finalStats.filtered > 0) {
+  logger.info(`  Filtered ${finalStats.filtered} files:`)
+  if (finalStats.details.distCount)
+    logger.info(`    - ${finalStats.details.distCount} dist/ compiled files`)
+  if (finalStats.details.externalCount)
+    logger.info(
+      `    - ${finalStats.details.externalCount} external dependencies`,
+    )
+  if (finalStats.details.testCount)
+    logger.info(`    - ${finalStats.details.testCount} test files`)
+}
+logger.info(`  Total: ${finalStats.total} files\n`)
+
+const summaryStats = filterCoverageFile(coverageSummaryPath)
+logger.info(`coverage-summary.json:`)
+logger.success(`  Kept ${summaryStats.kept} src/ files`)
+if (summaryStats.filtered > 0) {
+  logger.info(`  Filtered ${summaryStats.filtered} files`)
+}
 
-fs.writeFileSync(coveragePath, JSON.stringify(filtered, null, 2))
-console.log('Coverage data filtered successfully')
+logger.success('\n✓ Coverage data filtered successfully!')