fix: Respect SourcePath config

and add additional parameter

Author: OleRoss

action.yaml

@@ -17,6 +17,10 @@ inputs:
     description: Select subdirectories to show coverage data for
     required: false
     default: '**'
+  source:
+    description: Source directory for resolving file paths from coverage files
+    required: false
+    default: ${{ github.workspace }}
   token:
     description: GitHub token for API access
     required: true

src/action.ts

@@ -8,6 +8,7 @@ export type Inputs = {
   updateComment: boolean
   showChangedLinesOnly: boolean
   showGlobOnly: string
+  sourceDir: string
 }
 
 /**
@@ -26,6 +27,7 @@ export const run = async (inputs: Inputs, octokit: Octokit, context: Context): P
   const result = await processCoverage(
     {
       files: inputs.files,
+      sourceDir: inputs.sourceDir,
       showChangedLinesOnly: inputs.showChangedLinesOnly,
       showGlobOnly: inputs.showGlobOnly,
       baseRef,

src/cli.ts

@@ -24,6 +24,7 @@ USAGE:
 OPTIONS:
   --files <patterns>       Coverage file patterns (required, comma or newline separated)
   --output <path>          Output file path (optional, prints to stdout if not specified)
+  --source <path>          Source directory for resolving file paths (default: current directory)
   --base-ref <ref>         Git ref to compare against (e.g., origin/main, HEAD~1)
   --show-changed-only      Filter to show only changed lines (requires --base-ref)
   --show-glob <pattern>    Glob pattern to filter which files to show (default: **)
@@ -49,6 +50,7 @@ async function main(): Promise<void> {
     options: {
       files: { type: 'string', short: 'f' },
       output: { type: 'string', short: 'o' },
+      source: { type: 'string', short: 's' },
       'base-ref': { type: 'string', short: 'b' },
       'show-changed-only': { type: 'boolean', default: false },
       'show-glob': { type: 'string', default: '**' },
@@ -81,6 +83,7 @@ async function main(): Promise<void> {
   const result = await processCoverage(
     {
       files: values.files,
+      sourceDir: values.source ?? process.cwd(),
       showChangedLinesOnly: values['show-changed-only'] ?? false,
       showGlobOnly: values['show-glob'] ?? '**',
       ...(values['base-ref'] && { baseRef: values['base-ref'] }),

src/core/process-coverage.ts

@@ -3,6 +3,7 @@ import { glob } from 'glob'
 import { CoberturaCoverageParser, type CoverageReport } from '../coverage/index.js'
 import { applyFilters, getChangedLinesFromGit, type ChangedLinesMap, type FilterContext } from '../filter/index.js'
 import { generateMarkdown } from '../markdown/index.js'
+import { resolveFilePaths, type PathResolutionContext } from '../path/index.js'
 
 /**
  * Logger interface for dependency injection.
@@ -19,6 +20,8 @@ export type Logger = {
 export type ProcessCoverageInputs = {
   /** Coverage file patterns (newline or comma separated) */
   files: string
+  /** Source directory for resolving file paths from coverage files */
+  sourceDir: string
   /** Whether to filter to show only changed lines */
   showChangedLinesOnly: boolean
   /** Glob pattern to filter which files to show */
@@ -86,9 +89,37 @@ export async function processCoverage(
     reports.push(report)
   }
 
-  // Merge all reports into one
+  // Merge all reports into one (including sources)
   const mergedReport = mergeReports(reports)
 
+  // Resolve file paths to get display paths and absolute paths
+  const allFilenames: string[] = []
+  for (const pkg of mergedReport.packages) {
+    for (const file of pkg.files) {
+      allFilenames.push(file.filename)
+    }
+  }
+
+  const pathContext: PathResolutionContext = {
+    sources: mergedReport.sources ?? [],
+    sourceDir: inputs.sourceDir,
+    logger,
+  }
+
+  logger.info(`Resolving file paths (sourceDir: ${inputs.sourceDir})...`)
+  const resolvedPaths = await resolveFilePaths(allFilenames, pathContext)
+
+  // Update file objects with resolved paths
+  for (const pkg of mergedReport.packages) {
+    for (const file of pkg.files) {
+      const resolution = resolvedPaths.get(file.filename)
+      if (resolution) {
+        file.resolvedPath = resolution.absolutePath
+        file.filename = resolution.displayPath
+      }
+    }
+  }
+
   // Get changed lines using git if filtering is enabled and we have a base ref
   let changedLines: ChangedLinesMap | undefined
   if (inputs.showChangedLinesOnly && inputs.baseRef) {
@@ -118,16 +149,18 @@ export async function processCoverage(
     logger.info('Coverage report filtered based on configuration')
   }
 
-  // Collect all unique file paths from the filtered report
-  const filePaths = new Set<string>()
+  // Collect all unique resolved file paths from the filtered report
+  // Map from display path (filename) to resolved path for reading
+  const filePathMap = new Map<string, string>()
   for (const pkg of filteredReport.packages) {
     for (const file of pkg.files) {
-      filePaths.add(file.filename)
+      // Use resolvedPath for reading, fall back to filename if not set
+      filePathMap.set(file.filename, file.resolvedPath ?? file.filename)
     }
   }
 
-  // Read file contents from disk
-  const fileContents = await readFileContents([...filePaths])
+  // Read file contents from disk using resolved paths
+  const fileContents = await readFileContents(filePathMap)
 
   // Generate markdown from filtered report
   const markdown = generateMarkdown(filteredReport, fileContents)
@@ -140,11 +173,20 @@ export async function processCoverage(
 
 /**
  * Merge multiple coverage reports into one.
+ * Also merges sources from all reports.
  */
 function mergeReports(reports: CoverageReport[]): CoverageReport {
   const packageMap = new Map<string, CoverageReport['packages'][0]>()
+  const allSources = new Set<string>()
 
   for (const report of reports) {
+    // Collect sources from all reports
+    if (report.sources) {
+      for (const source of report.sources) {
+        allSources.add(source)
+      }
+    }
+
     for (const pkg of report.packages) {
       if (packageMap.has(pkg.name)) {
         // Merge files into existing package
@@ -156,7 +198,11 @@ function mergeReports(reports: CoverageReport[]): CoverageReport {
     }
   }
 
-  return { packages: Array.from(packageMap.values()) }
+  const result: CoverageReport = { packages: Array.from(packageMap.values()) }
+  if (allSources.size > 0) {
+    result.sources = Array.from(allSources)
+  }
+  return result
 }
 
 /**
@@ -195,20 +241,22 @@ function calculateOverallMetrics(report: CoverageReport): CoverageMetrics {
 }
 
 /**
- * Read file contents from disk for a list of file paths.
- * Returns a map of filepath -> lines array.
+ * Read file contents from disk for a map of display paths to resolved paths.
+ * Returns a map of display path -> lines array.
  * Files that don't exist return empty arrays.
+ *
+ * @param pathMap - Map of display path to resolved (absolute) path
  */
-async function readFileContents(filepaths: string[]): Promise<Map<string, string[]>> {
+async function readFileContents(pathMap: Map<string, string>): Promise<Map<string, string[]>> {
   const contents = new Map<string, string[]>()
 
-  for (const filepath of filepaths) {
+  for (const [displayPath, resolvedPath] of pathMap) {
     try {
-      const content = await fs.readFile(filepath, 'utf-8')
-      contents.set(filepath, content.split('\n'))
+      const content = await fs.readFile(resolvedPath, 'utf-8')
+      contents.set(displayPath, content.split('\n'))
     } catch {
       // File doesn't exist or can't be read - use empty array
-      contents.set(filepath, [])
+      contents.set(displayPath, [])
     }
   }
 

src/coverage/model.ts

@@ -15,7 +15,10 @@ export type CoverageMetrics = {
 }
 
 export type FileCoverage = {
+  /** Display path (relative to source root) */
   filename: string
+  /** Absolute path for reading file contents (set after path resolution) */
+  resolvedPath?: string
   lines: LineCoverage[]
   lineMetrics: CoverageMetrics
   branchMetrics?: CoverageMetrics
@@ -29,4 +32,6 @@ export type PackageCoverage = {
 
 export type CoverageReport = {
   packages: PackageCoverage[]
+  /** Source paths from Cobertura XML <sources> element */
+  sources?: string[]
 }

src/coverage/parsers/cobertura.ts

@@ -49,6 +49,9 @@ type CoberturaRoot = {
     '@_lines-valid': string
     '@_branches-covered': string
     '@_branches-valid': string
+    sources?: {
+      source?: string | string[]
+    }
     packages?: {
       package?: CoberturaPackage | CoberturaPackage[]
     }
@@ -79,8 +82,20 @@ export class CoberturaCoverageParser implements CoverageParser {
     const coverage = parsed.coverage
 
     const packages = this.parsePackages(coverage.packages?.package)
+    const sources = this.parseSources(coverage.sources?.source)
+
+    const report: CoverageReport = { packages }
+    if (sources.length > 0) {
+      report.sources = sources
+    }
+    return report
+  }
 
-    return { packages }
+  private parseSources(sources: string | string[] | undefined): string[] {
+    if (!sources) return []
+    const sourceList = Array.isArray(sources) ? sources : [sources]
+    // Normalize path separators (Windows backslashes to forward slashes)
+    return sourceList.map((s) => s.replace(/\\/g, '/'))
   }
 
   private parsePackages(packages: CoberturaPackage | CoberturaPackage[] | undefined): PackageCoverage[] {

src/index.ts

@@ -9,6 +9,7 @@ try {
       updateComment: core.getBooleanInput('update-comment'),
       showChangedLinesOnly: core.getBooleanInput('show-changed-lines-only'),
       showGlobOnly: core.getInput('show-glob-only') || '**',
+      sourceDir: core.getInput('source') || process.env['GITHUB_WORKSPACE'] || process.cwd(),
     },
     getOctokit(),
     await getContext(),

src/path/index.ts

@@ -0,0 +1,7 @@
+export {
+  resolveFilePath,
+  resolveFilePaths,
+  type PathLogger,
+  type PathResolutionContext,
+  type PathResolutionResult,
+} from './resolve.js'