Add path-mapping feature for report path rewriting

Co-authored-by: neilime <314088+neilime@users.noreply.github.com>

Author: Copilot

actions/parse-ci-reports/README.md

@@ -83,6 +83,13 @@ It supports multiple common report standards out of the box.
     #
     # Default: `false`
     fail-on-error: "false"
+
+    # Path mapping to rewrite file paths in reports (format: "from_path:to_path").
+    # Useful when tests/lints run in a different directory or container.
+    # Example: "/app/src:./src" or "/var/lib/docker/.../app:."
+    #
+    # Default: ``
+    path-mapping: ""
 ```
 
 <!-- usage:end -->
@@ -99,6 +106,9 @@ It supports multiple common report standards out of the box.
 | **`include-passed`** | Whether to include passed tests in the summary.                                                       | **false**    | `false`          |
 | **`output-format`**  | Output format: comma-separated list of `summary`, `markdown`, `annotations`, or `all` for everything. | **false**    | `all`            |
 | **`fail-on-error`**  | Whether to fail the action if any test failures are detected.                                         | **false**    | `false`          |
+| **`path-mapping`**   | Path mapping to rewrite file paths in reports (format: `from_path:to_path`).                          | **false**    | `""`             |
+|                      | Useful when tests/lints run in a different directory or container.                                    |              |                  |
+|                      | Example: `/app/src:./src` or `/var/lib/docker/.../app:.`                                              |              |                  |
 
 <!-- inputs:end -->
 <!-- secrets:start -->
@@ -249,6 +259,37 @@ Parse test results, coverage, and linting in one action:
     report-name: "CI Results"
 ```
 
+### Path Rewriting for Containers
+
+When running tests in a container or different directory, use path-mapping to ensure file paths match your repository structure:
+
+```yaml
+- name: Run tests in container
+  run: |
+    docker run --rm -v ${{ github.workspace }}:/app myimage npm test
+
+- name: Parse test reports
+  uses: hoverkraft-tech/ci-github-common/actions/parse-ci-reports@e6405b7d4daa7292edb246103f42b333a96d0a9f # copilot/add-report-parser-action
+  with:
+    report-paths: "test-results/junit.xml"
+    report-name: "Test Results"
+    path-mapping: "/app:."
+    output-format: "annotations"
+```
+
+This ensures GitHub annotations point to the correct files in your repository, even when tests run in `/app` inside the container.
+
+Another example for complex Docker overlay paths:
+
+```yaml
+- name: Parse reports with path rewriting
+  uses: hoverkraft-tech/ci-github-common/actions/parse-ci-reports@e6405b7d4daa7292edb246103f42b333a96d0a9f # copilot/add-report-parser-action
+  with:
+    report-paths: "auto:all"
+    report-name: "CI Results"
+    path-mapping: "/var/lib/docker/overlay2/abc123/merged/workspace:./src"
+```
+
 ### Conditional PR Comment
 
 Only comment on PRs if there are failures:

actions/parse-ci-reports/action.yml

@@ -37,6 +37,13 @@ inputs:
     description: |
       Whether to fail the action if any test failures are detected.
     default: "false"
+  path-mapping:
+    description: |
+      Path mapping to rewrite file paths in reports (format: "from_path:to_path").
+      Useful when tests/lints run in a different directory or container.
+      Example: "/app/src:./src" or "/var/lib/docker/.../app:."
+    required: false
+    default: ""
 
 outputs:
   markdown:
@@ -69,6 +76,7 @@ runs:
         REPORT_NAME: ${{ inputs.report-name }}
         INCLUDE_PASSED: ${{ inputs.include-passed }}
         OUTPUT_FORMAT: ${{ inputs.output-format }}
+        PATH_MAPPING: ${{ inputs.path-mapping }}
         ACTION_PATH: ${{ github.action_path }}
       with:
         script: |
@@ -79,7 +87,8 @@ runs:
             reportPaths: process.env.REPORT_PATHS,
             reportName: process.env.REPORT_NAME,
             includePassed: process.env.INCLUDE_PASSED === 'true',
-            outputFormat: process.env.OUTPUT_FORMAT
+            outputFormat: process.env.OUTPUT_FORMAT,
+            pathMapping: process.env.PATH_MAPPING || null
           };
 
           await run({ core, glob, inputs });

actions/parse-ci-reports/src/PathRewriter.js

@@ -0,0 +1,99 @@
+/**
+ * PathRewriter - Utility to rewrite file paths in reports
+ *
+ * This is useful when tests/lints run in a different directory or container,
+ * but the paths in reports need to match the actual repository structure
+ * for GitHub annotations and file references to work correctly.
+ */
+export class PathRewriter {
+  /**
+   * Create a path rewriter
+   * @param {string|null} pathMapping - Path mapping in format "from:to" or null to disable
+   */
+  constructor(pathMapping = null) {
+    this.fromPath = null;
+    this.toPath = null;
+
+    if (pathMapping && pathMapping.trim().length > 0) {
+      this._parsePathMapping(pathMapping);
+    }
+  }
+
+  /**
+   * Parse path mapping string
+   * @param {string} pathMapping - Path mapping in format "from:to"
+   * @private
+   */
+  _parsePathMapping(pathMapping) {
+    const parts = pathMapping.split(":");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Invalid path-mapping format: "${pathMapping}". Expected format: "from_path:to_path"`,
+      );
+    }
+
+    this.fromPath = parts[0].trim();
+    this.toPath = parts[1].trim();
+
+    if (this.fromPath.length === 0 || this.toPath.length === 0) {
+      throw new Error(
+        `Invalid path-mapping format: "${pathMapping}". Paths cannot be empty.`,
+      );
+    }
+
+    // Normalize paths - remove trailing slashes for consistency
+    this.fromPath = this.fromPath.replace(/\/+$/, "");
+    this.toPath = this.toPath.replace(/\/+$/, "");
+  }
+
+  /**
+   * Check if path rewriting is enabled
+   * @returns {boolean} True if path mapping is configured
+   */
+  isEnabled() {
+    return this.fromPath !== null && this.toPath !== null;
+  }
+
+  /**
+   * Rewrite a file path
+   * @param {string} path - Original path from report
+   * @returns {string} Rewritten path or original if no mapping configured
+   */
+  rewritePath(path) {
+    if (!this.isEnabled() || !path) {
+      return path;
+    }
+
+    // Handle both absolute and relative paths
+    let normalizedPath = path;
+
+    // If path starts with fromPath, replace it
+    if (normalizedPath.startsWith(this.fromPath)) {
+      normalizedPath =
+        this.toPath + normalizedPath.substring(this.fromPath.length);
+    }
+    // Also handle case where fromPath has leading slash but path doesn't
+    else if (normalizedPath.startsWith(this.fromPath.replace(/^\//, ""))) {
+      const fromPathNoLeadingSlash = this.fromPath.replace(/^\//, "");
+      normalizedPath =
+        this.toPath + normalizedPath.substring(fromPathNoLeadingSlash.length);
+    }
+
+    return normalizedPath;
+  }
+
+  /**
+   * Get info about the path mapping configuration
+   * @returns {Object|null} Object with from and to paths, or null if not enabled
+   */
+  getMapping() {
+    if (!this.isEnabled()) {
+      return null;
+    }
+
+    return {
+      from: this.fromPath,
+      to: this.toPath,
+    };
+  }
+}

actions/parse-ci-reports/src/PathRewriter.test.js

@@ -0,0 +1,94 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { PathRewriter } from "./PathRewriter.js";
+
+describe("PathRewriter", () => {
+  it("should be disabled by default", () => {
+    const rewriter = new PathRewriter();
+    assert.strictEqual(rewriter.isEnabled(), false);
+    assert.strictEqual(rewriter.rewritePath("/some/path.js"), "/some/path.js");
+  });
+
+  it("should parse path mapping correctly", () => {
+    const rewriter = new PathRewriter("/app/src:/workspace/src");
+    assert.strictEqual(rewriter.isEnabled(), true);
+
+    const mapping = rewriter.getMapping();
+    assert.strictEqual(mapping.from, "/app/src");
+    assert.strictEqual(mapping.to, "/workspace/src");
+  });
+
+  it("should rewrite paths correctly", () => {
+    const rewriter = new PathRewriter("/app/src:/workspace/src");
+
+    assert.strictEqual(
+      rewriter.rewritePath("/app/src/utils/helper.js"),
+      "/workspace/src/utils/helper.js",
+    );
+
+    assert.strictEqual(
+      rewriter.rewritePath("/app/src/index.js"),
+      "/workspace/src/index.js",
+    );
+  });
+
+  it("should handle paths without leading slash in fromPath", () => {
+    const rewriter = new PathRewriter("/app/src:/workspace/src");
+
+    assert.strictEqual(
+      rewriter.rewritePath("app/src/utils/helper.js"),
+      "/workspace/src/utils/helper.js",
+    );
+  });
+
+  it("should not rewrite paths that don't match", () => {
+    const rewriter = new PathRewriter("/app/src:/workspace/src");
+
+    assert.strictEqual(
+      rewriter.rewritePath("/other/path/file.js"),
+      "/other/path/file.js",
+    );
+  });
+
+  it("should handle empty or null paths", () => {
+    const rewriter = new PathRewriter("/app/src:/workspace/src");
+
+    assert.strictEqual(rewriter.rewritePath(""), "");
+    assert.strictEqual(rewriter.rewritePath(null), null);
+  });
+
+  it("should normalize trailing slashes", () => {
+    const rewriter = new PathRewriter("/app/src/:/workspace/src/");
+
+    const mapping = rewriter.getMapping();
+    assert.strictEqual(mapping.from, "/app/src");
+    assert.strictEqual(mapping.to, "/workspace/src");
+  });
+
+  it("should throw error on invalid format", () => {
+    assert.throws(() => {
+      new PathRewriter("invalid-mapping");
+    }, /Invalid path-mapping format/);
+
+    assert.throws(() => {
+      new PathRewriter("/from/path");
+    }, /Invalid path-mapping format/);
+
+    assert.throws(() => {
+      new PathRewriter(":/to/path");
+    }, /Paths cannot be empty/);
+  });
+
+  it("should handle complex paths", () => {
+    const rewriter = new PathRewriter(
+      "/var/lib/docker/overlay2/hash/merged/app:./src",
+    );
+
+    assert.strictEqual(
+      rewriter.rewritePath(
+        "/var/lib/docker/overlay2/hash/merged/app/utils/helper.js",
+      ),
+      "./src/utils/helper.js",
+    );
+  });
+});

actions/parse-ci-reports/src/ReportParserCore.js

@@ -3,15 +3,17 @@ import { ParserFactory } from "./parsers/ParserFactory.js";
 import { SummaryFormatter } from "./formatters/SummaryFormatter.js";
 import { MarkdownFormatter } from "./formatters/MarkdownFormatter.js";
 import { ReportData } from "./models/ReportData.js";
+import { PathRewriter } from "./PathRewriter.js";
 
 /**
  * Core report parsing logic shared between CLI and Action
  */
 export class ReportParserCore {
-  constructor() {
+  constructor(pathMapping = null) {
     this.parserFactory = new ParserFactory();
     this.summaryFormatter = new SummaryFormatter();
     this.markdownFormatter = new MarkdownFormatter();
+    this.pathRewriter = new PathRewriter(pathMapping);
   }
 
   /**
@@ -24,12 +26,28 @@ export class ReportParserCore {
   parseReports(files, logger = console.log, errorLogger = console.error) {
     const aggregatedData = new ReportData();
 
+    // Log path rewriting configuration if enabled
+    if (this.pathRewriter.isEnabled()) {
+      const mapping = this.pathRewriter.getMapping();
+      logger(`Path rewriting enabled: "${mapping.from}" → "${mapping.to}"`);
+    }
+
     for (const file of files) {
       try {
         logger(`Parsing ${file}...`);
         const content = readFileSync(file, "utf-8");
         const reportData = this.parserFactory.parse(file, content);
 
+        // Apply path rewriting to test results
+        for (const test of reportData.tests) {
+          test.file = this.pathRewriter.rewritePath(test.file);
+        }
+
+        // Apply path rewriting to lint issues
+        for (const issue of reportData.lintIssues) {
+          issue.file = this.pathRewriter.rewritePath(issue.file);
+        }
+
         // Merge data
         aggregatedData.tests.push(...reportData.tests);
         aggregatedData.lintIssues.push(...reportData.lintIssues);

actions/parse-ci-reports/src/index.js

@@ -5,11 +5,14 @@ async function run({ core, glob: globModule, inputs }) {
     const { ReportParserCore } = await import("./ReportParserCore.js");
     const { ReportPathResolver } = await import("./ReportPathResolver.js");
 
-    const parserCore = new ReportParserCore();
+    const parserCore = new ReportParserCore(inputs.pathMapping);
     const pathResolver = new ReportPathResolver();
 
     core.info(`Report Name: ${inputs.reportName}`);
     core.info(`Output Format: ${inputs.outputFormat}`);
+    if (inputs.pathMapping) {
+      core.info(`Path Mapping: ${inputs.pathMapping}`);
+    }
 
     // Parse output formats (comma-separated or "all")
     const outputFormats = parserCore.parseOutputFormats(inputs.outputFormat);