@testream/jest-reporter 0.1.0

package/LICENSE

@@ -0,0 +1,30 @@
+Proprietary License
+
+Copyright (c) 2026 Testream Team. All rights reserved.
+
+This software and associated documentation files (the "Software") are licensed,
+not sold, to you for use only under the terms of this license.
+
+GRANT OF LICENSE:
+You are granted a non-exclusive, non-transferable license to use the Software
+solely for the purpose of integrating test result reporting with the Testream service.
+
+RESTRICTIONS:
+- You may not modify, adapt, or create derivative works of the Software
+- You may not distribute, sublicense, lease, or rent the Software
+- You may not reverse engineer, decompile, or disassemble the Software
+- The Software may only be used in conjunction with the Testream service
+
+OWNERSHIP:
+The Software is licensed, not sold. This license does not grant you any rights
+to trademarks or service marks.
+
+TERMINATION:
+This license is effective until terminated. Your rights under this license will
+terminate automatically without notice if you fail to comply with any term of
+this license.
+
+DISCLAIMER:
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

package/README.md

@@ -0,0 +1,157 @@
+# @testream/jest-reporter
+
+Jest reporter that generates CTRF test reports and uploads them to Testream.
+
+- **Docs:** https://testream.github.io/docs/reporters/jest
+- **Docs repository:** https://github.com/testream/docs
+
+## Quick Start
+
+Install the reporter:
+
+```bash
+npm install --save-dev @testream/jest-reporter
+```
+
+Configure in your `jest.config.js`:
+
+```javascript
+module.exports = {
+  reporters: [
+    'default',
+    [
+      '@testream/jest-reporter',
+      {
+        apiKey: process.env.TESTREAM_API_KEY,
+        projectKey: 'PROJ',
+        uploadEnabled: true,
+      },
+    ],
+  ],
+};
+```
+
+Run your tests:
+
+```bash
+npm test
+```
+
+The reporter will automatically:
+1. Generate a CTRF report in `ctrf/ctrf-report.json`
+2. Upload test results to Testream
+3. Display results in Jira
+
+## Configuration Options
+
+```typescript
+{
+  // Required
+  apiKey: string;              // Testream API key
+  projectKey: string;          // Jira project key
+
+  // Optional - Git context (auto-detected in CI)
+  branch?: string;             // Git branch name
+  commitSha?: string;          // Git commit SHA
+  repositoryUrl?: string;      // Git repository URL
+
+  // Optional - Build metadata (auto-detected in CI)
+  buildName?: string;          // Build name/identifier
+  buildNumber?: string;        // Build number
+  buildUrl?: string;           // CI pipeline URL
+
+  // Optional - Environment metadata
+  testEnvironment?: string;    // e.g., 'staging', 'production', 'ci'
+  appName?: string;            // Application name under test
+  appVersion?: string;         // Application version
+  testType?: string;           // e.g., 'unit', 'integration', 'e2e'
+
+  // Optional - Upload options
+  uploadEnabled?: boolean;     // Enable/disable upload (default: true)
+  failOnUploadError?: boolean; // Fail tests if upload fails (default: false)
+}
+```
+
+## Examples
+
+### Basic Usage
+
+```javascript
+// jest.config.js
+module.exports = {
+  reporters: [
+    'default',
+    [
+      '@testream/jest-reporter',
+      {
+        apiKey: process.env.TESTREAM_API_KEY,
+        projectKey: 'MYPROJ',
+      },
+    ],
+  ],
+};
+```
+
+### With Environment Metadata
+
+```javascript
+// jest.config.js
+module.exports = {
+  reporters: [
+    'default',
+    [
+      '@testream/jest-reporter',
+      {
+        apiKey: process.env.TESTREAM_API_KEY,
+        projectKey: 'MYPROJ',
+        testEnvironment: 'ci',
+        appName: 'MyApp',
+        appVersion: '1.0.0',
+        testType: 'unit',
+      },
+    ],
+  ],
+};
+```
+
+### Generate CTRF Only (No Upload)
+
+```javascript
+// jest.config.js
+module.exports = {
+  reporters: [
+    'default',
+    [
+      '@testream/jest-reporter',
+      {
+        apiKey: '', // Not needed when upload is disabled
+        projectKey: '',
+        uploadEnabled: false,
+      },
+    ],
+  ],
+};
+```
+
+## How It Works
+
+1. The reporter uses `jest-ctrf-json-reporter` internally to generate CTRF reports
+2. Hooks into Jest's test lifecycle to collect results
+3. Converts Jest results to CTRF (Common Test Report Format)
+4. Writes CTRF report to `ctrf/ctrf-report.json`
+5. Optionally uploads results to Testream backend
+6. Test results appear in Jira automatically
+
+## CI/CD Integration
+
+The reporter auto-detects CI context from:
+- GitHub Actions
+- GitLab CI
+- Azure Pipelines
+- CircleCI
+- Jenkins
+- Bitbucket Pipelines
+
+You can also manually specify git/build context via configuration options.
+
+For full documentation and examples, see https://testream.github.io/docs/reporters/jest.

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @testream/jest-reporter
+ *
+ * Jest reporter that generates CTRF-format test reports and
+ * automatically uploads them to the Testream backend.
+ */
+export { TestreamJestReporter as default } from './reporter';
+export { TestreamJestReporter } from './reporter';
+export type { JestReporterConfig } from './types';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @testream/jest-reporter
+ *
+ * Jest reporter that generates CTRF-format test reports and
+ * automatically uploads them to the Testream backend.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestreamJestReporter = exports.default = void 0;
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return reporter_1.TestreamJestReporter; } });
+var reporter_2 = require("./reporter");
+Object.defineProperty(exports, "TestreamJestReporter", { enumerable: true, get: function () { return reporter_2.TestreamJestReporter; } });

package/dist/reporter.d.ts

@@ -0,0 +1,39 @@
+import type { Reporter, Test, TestContext } from '@jest/reporters';
+import type { AggregatedResult, TestResult } from '@jest/test-result';
+import { JestReporterConfig } from './types';
+/**
+ * Testream Jest Reporter
+ * Wraps jest-ctrf-json-reporter to generate CTRF reports and upload them to Testream
+ */
+export declare class TestreamJestReporter implements Reporter {
+    private config;
+    private ctrfReporter;
+    private readonly outputDir;
+    private readonly outputFile;
+    constructor(globalConfig: unknown, options?: JestReporterConfig, context?: unknown);
+    /**
+     * Called when test run starts
+     */
+    onRunStart(_aggregatedResult: AggregatedResult, _options: unknown): void | Promise<void>;
+    /**
+     * Called when an individual test starts
+     */
+    onTestStart(_test: Test): void | Promise<void>;
+    /**
+     * Called when a test file completes
+     */
+    onTestResult(test: Test, testResult: TestResult, _aggregatedResult: AggregatedResult): void | Promise<void>;
+    /**
+     * Called when entire test run completes
+     */
+    onRunComplete(_testContexts: Set<TestContext>, _results: AggregatedResult): Promise<void>;
+    /**
+     * Read CTRF report from file
+     */
+    private readCTRFReport;
+    /**
+     * Upload report to Testream API
+     */
+    private uploadReport;
+}
+export default TestreamJestReporter;

package/dist/reporter.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestreamJestReporter = void 0;
+const jest_ctrf_json_reporter_1 = __importDefault(require("jest-ctrf-json-reporter"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const uploader_1 = require("./uploader");
+/**
+ * Testream Jest Reporter
+ * Wraps jest-ctrf-json-reporter to generate CTRF reports and upload them to Testream
+ */
+class TestreamJestReporter {
+    constructor(globalConfig, options = {
+        apiKey: '',
+        projectKey: '',
+        uploadEnabled: true,
+    }, context = {}) {
+        this.outputDir = 'ctrf';
+        this.outputFile = 'ctrf-report.json';
+        this.config = {
+            uploadEnabled: true,
+            failOnUploadError: false,
+            ...options,
+        };
+        // Initialize jest-ctrf-json-reporter with fixed output path and metadata
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ctrfConfig = {
+            outputDir: this.outputDir,
+            outputFile: this.outputFile,
+        };
+        // Add environment metadata (same pattern as playwright-reporter)
+        if (this.config.testEnvironment)
+            ctrfConfig.testEnvironment = this.config.testEnvironment;
+        if (this.config.appName)
+            ctrfConfig.appName = this.config.appName;
+        if (this.config.appVersion)
+            ctrfConfig.appVersion = this.config.appVersion;
+        if (this.config.buildName)
+            ctrfConfig.buildName = this.config.buildName;
+        if (this.config.buildNumber)
+            ctrfConfig.buildNumber = this.config.buildNumber;
+        if (this.config.buildUrl)
+            ctrfConfig.buildUrl = this.config.buildUrl;
+        if (this.config.testType)
+            ctrfConfig.testType = this.config.testType;
+        if (this.config.branch)
+            ctrfConfig.branchName = this.config.branch;
+        if (this.config.commitSha)
+            ctrfConfig.commit = this.config.commitSha;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.ctrfReporter = new jest_ctrf_json_reporter_1.default(globalConfig, ctrfConfig, context);
+    }
+    /**
+     * Called when test run starts
+     */
+    onRunStart(_aggregatedResult, _options) {
+        if (this.ctrfReporter.onRunStart) {
+            return this.ctrfReporter.onRunStart();
+        }
+    }
+    /**
+     * Called when an individual test starts
+     */
+    onTestStart(_test) {
+        if (this.ctrfReporter.onTestStart) {
+            return this.ctrfReporter.onTestStart();
+        }
+    }
+    /**
+     * Called when a test file completes
+     */
+    onTestResult(test, testResult, _aggregatedResult) {
+        if (this.ctrfReporter.onTestResult) {
+            return this.ctrfReporter.onTestResult(test, testResult);
+        }
+    }
+    /**
+     * Called when entire test run completes
+     */
+    async onRunComplete(_testContexts, _results) {
+        // Let jest-ctrf-json-reporter complete and write the CTRF file
+        if (this.ctrfReporter.onRunComplete) {
+            await this.ctrfReporter.onRunComplete();
+        }
+        // Read the generated CTRF report
+        const report = await this.readCTRFReport();
+        if (!report) {
+            uploader_1.defaultLogger.error('Failed to read CTRF report, skipping upload');
+            return;
+        }
+        uploader_1.defaultLogger.info(`CTRF report written to: ${path.join(this.outputDir, this.outputFile)}`);
+        // Upload to API if enabled
+        if (this.config.uploadEnabled && this.config.apiKey && this.config.projectKey) {
+            await this.uploadReport(report);
+        }
+    }
+    /**
+     * Read CTRF report from file
+     */
+    async readCTRFReport() {
+        const reportPath = path.join(this.outputDir, this.outputFile);
+        try {
+            const content = await fs.readFile(reportPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            uploader_1.defaultLogger.error(`Failed to read CTRF report from ${reportPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Upload report to Testream API
+     */
+    async uploadReport(report) {
+        const ciContext = (0, uploader_1.detectCIContext)();
+        // Merge CLI options with auto-detected CI context (config takes precedence)
+        const branch = this.config.branch || ciContext.branch;
+        const commitSha = this.config.commitSha || ciContext.commitSha;
+        const repositoryUrl = this.config.repositoryUrl || ciContext.repositoryUrl;
+        const buildNumber = this.config.buildNumber || ciContext.buildNumber;
+        const buildUrl = this.config.buildUrl || ciContext.buildUrl;
+        const result = await (0, uploader_1.uploadToApi)({
+            report,
+            projectKey: this.config.projectKey,
+            apiKey: this.config.apiKey,
+            // Git context
+            branch,
+            commitSha,
+            repositoryUrl,
+            // Build metadata
+            buildName: this.config.buildName,
+            buildNumber,
+            buildUrl,
+            // Environment metadata
+            testEnvironment: this.config.testEnvironment,
+            appName: this.config.appName,
+            appVersion: this.config.appVersion,
+            testType: this.config.testType,
+            logger: uploader_1.defaultLogger,
+        });
+        if (!result.success && this.config.failOnUploadError) {
+            throw new Error(`Upload failed: ${result.error}`);
+        }
+    }
+}
+exports.TestreamJestReporter = TestreamJestReporter;
+exports.default = TestreamJestReporter;

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Re-export CTRF types from shared-types package
+ */
+export type { CTRFReport, CTRFTest, CTRFSummary, CTRFResults, CTRFAttachment, CTRFStep, } from '@jira-test-manager/shared-types';
+/**
+ * Re-export API types from shared-types package
+ */
+export type { IngestResponse, ApiErrorResponse, UploadResult, } from '@jira-test-manager/shared-types';
+/**
+ * Reporter Configuration Options
+ */
+export interface JestReporterConfig {
+    /**
+     * API key for authentication
+     * @required
+     */
+    apiKey: string;
+    /**
+     * Project key to associate test results with
+     * @required
+     */
+    projectKey: string;
+    /**
+     * Git branch name (auto-detected from CI environment if not provided)
+     */
+    branch?: string;
+    /**
+     * Git commit SHA (auto-detected from CI environment if not provided)
+     */
+    commitSha?: string;
+    /**
+     * Git repository URL (auto-detected from CI environment if not provided)
+     */
+    repositoryUrl?: string;
+    /**
+     * Enable/disable automatic upload to backend
+     * @default true
+     */
+    uploadEnabled?: boolean;
+    /**
+     * Fail the process if upload fails
+     * @default false
+     */
+    failOnUploadError?: boolean;
+    /**
+     * Test type identifier (e.g., 'unit', 'integration', 'e2e')
+     */
+    testType?: string;
+    /**
+     * Application name under test
+     */
+    appName?: string;
+    /**
+     * Application version under test
+     */
+    appVersion?: string;
+    /**
+     * Build name/identifier
+     */
+    buildName?: string;
+    /**
+     * Build number
+     */
+    buildNumber?: string;
+    /**
+     * Build URL (CI pipeline URL)
+     */
+    buildUrl?: string;
+    /**
+     * Test environment (e.g., 'staging', 'production', 'ci')
+     */
+    testEnvironment?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/uploader.d.ts

@@ -0,0 +1,45 @@
+import { CTRFReport, UploadResult } from './types';
+/**
+ * Logger interface for output
+ */
+export interface Logger {
+    info(message: string): void;
+    warning(message: string): void;
+    error(message: string): void;
+}
+/**
+ * Default console logger
+ */
+export declare const defaultLogger: Logger;
+export interface UploadToApiOptions {
+    report: CTRFReport;
+    projectKey: string;
+    apiKey: string;
+    commitSha?: string;
+    branch?: string;
+    repositoryUrl?: string;
+    buildName?: string;
+    buildNumber?: string;
+    buildUrl?: string;
+    testEnvironment?: string;
+    appName?: string;
+    appVersion?: string;
+    testType?: string;
+    logger?: Logger;
+}
+/**
+ * Upload CTRF report to Testream API
+ */
+export declare function uploadToApi(options: UploadToApiOptions): Promise<UploadResult>;
+/**
+ * Detect CI environment and extract context
+ */
+export interface CIContext {
+    branch?: string;
+    commitSha?: string;
+    repositoryUrl?: string;
+    buildNumber?: string;
+    buildUrl?: string;
+}
+export declare function detectCIContext(): CIContext;
+export declare const detectGitContext: typeof detectCIContext;

package/dist/uploader.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectGitContext = exports.defaultLogger = void 0;
+exports.uploadToApi = uploadToApi;
+exports.detectCIContext = detectCIContext;
+const crypto_1 = require("crypto");
+/**
+ * Hardcoded API URL for Testream backend
+ */
+const API_URL = 'https://test-manager-backend.fly.dev';
+/**
+ * Default console logger
+ */
+exports.defaultLogger = {
+    info: (msg) => console.log(msg),
+    warning: (msg) => console.warn(msg),
+    error: (msg) => console.error(msg),
+};
+/**
+ * Upload CTRF report to Testream API
+ */
+async function uploadToApi(options) {
+    const { report, projectKey, apiKey, commitSha = '', branch = '', repositoryUrl = '', buildName, buildNumber, buildUrl, testEnvironment, appName, appVersion, testType, logger = exports.defaultLogger, } = options;
+    // Ensure reportId exists
+    if (!report.reportId) {
+        report.reportId = (0, crypto_1.randomUUID)();
+    }
+    try {
+        logger.info('='.repeat(60));
+        logger.info('Testream - Jest Test Results Upload');
+        logger.info('='.repeat(60));
+        logger.info(`Test Summary:`);
+        logger.info(`  Total: ${report.results.summary.tests}`);
+        logger.info(`  Passed: ${report.results.summary.passed}`);
+        logger.info(`  Failed: ${report.results.summary.failed}`);
+        logger.info(`  Skipped: ${report.results.summary.skipped}`);
+        logger.info('');
+        // Log git context if provided
+        if (branch || commitSha || repositoryUrl) {
+            logger.info(`Git Context:`);
+            if (branch)
+                logger.info(`  Branch: ${branch}`);
+            if (commitSha)
+                logger.info(`  Commit: ${commitSha.substring(0, 7)}`);
+            if (repositoryUrl)
+                logger.info(`  Repository: ${repositoryUrl}`);
+            logger.info('');
+        }
+        // Log build info if provided
+        if (buildName || buildNumber || buildUrl) {
+            logger.info(`Build Info:`);
+            if (buildName)
+                logger.info(`  Name: ${buildName}`);
+            if (buildNumber)
+                logger.info(`  Number: ${buildNumber}`);
+            if (buildUrl)
+                logger.info(`  URL: ${buildUrl}`);
+            logger.info('');
+        }
+        // Log environment info if provided
+        if (testEnvironment || appName || appVersion || testType) {
+            logger.info(`Environment:`);
+            if (testEnvironment)
+                logger.info(`  Environment: ${testEnvironment}`);
+            if (appName)
+                logger.info(`  App: ${appName}`);
+            if (appVersion)
+                logger.info(`  Version: ${appVersion}`);
+            if (testType)
+                logger.info(`  Test Type: ${testType}`);
+            logger.info('');
+        }
+        // Prepare payload with all metadata
+        const ingestPayload = {
+            report,
+            reportId: report.reportId,
+            projectKey,
+            // Git context
+            commitSha,
+            branch,
+            repositoryUrl,
+            // Build metadata
+            buildName,
+            buildNumber,
+            buildUrl,
+            // Environment metadata
+            testEnvironment,
+            appName,
+            appVersion,
+            testType,
+        };
+        // Upload to API
+        logger.info(`Uploading test results...`);
+        let response;
+        try {
+            response = await fetch(`${API_URL}/api/v1/ingest`, {
+                method: 'POST',
+                headers: {
+                    'X-API-KEY': apiKey,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(ingestPayload),
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to connect to API: ${errorMessage}`);
+        }
+        // Handle errors
+        if (!response.ok) {
+            const responseText = await response.text();
+            let errorData = null;
+            try {
+                errorData = JSON.parse(responseText);
+            }
+            catch {
+                // Not JSON
+            }
+            // Handle 409 (already exists)
+            if (response.status === 409) {
+                logger.warning(`Report already exists: ${errorData?.reportId || 'unknown'}`);
+                logger.info('This is expected if the workflow was re-run');
+                return {
+                    success: true,
+                    reportId: errorData?.reportId || report.reportId,
+                    summary: {
+                        passed: report.results.summary.passed,
+                        failed: report.results.summary.failed,
+                        skipped: report.results.summary.skipped,
+                        total: report.results.summary.tests,
+                    },
+                };
+            }
+            // Other errors
+            const errorMessage = errorData?.error
+                ? `${errorData.error}${errorData.details ? `: ${errorData.details}` : ''}`
+                : responseText || `HTTP ${response.status}`;
+            throw new Error(`API ingest failed (${response.status}): ${errorMessage}`);
+        }
+        const result = (await response.json());
+        logger.info('');
+        logger.info('='.repeat(60));
+        logger.info('Upload completed successfully');
+        logger.info(`  Report ID: ${result.reportId}`);
+        logger.info(`  Test Run ID: ${result.testRunId}`);
+        logger.info('='.repeat(60));
+        return {
+            success: true,
+            reportId: result.reportId,
+            testRunId: result.testRunId,
+            summary: result.summary,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Upload failed: ${errorMessage}`);
+        return {
+            success: false,
+            reportId: '',
+            error: errorMessage,
+        };
+    }
+}
+function detectCIContext() {
+    const env = process.env;
+    // GitHub Actions
+    if (env.GITHUB_ACTIONS === 'true') {
+        return {
+            branch: env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME || env.GITHUB_REF?.replace('refs/heads/', ''),
+            commitSha: env.GITHUB_SHA,
+            repositoryUrl: env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY
+                ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}`
+                : undefined,
+            buildNumber: env.GITHUB_RUN_NUMBER,
+            buildUrl: env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID
+                ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}`
+                : undefined,
+        };
+    }
+    // GitLab CI
+    if (env.GITLAB_CI === 'true') {
+        return {
+            branch: env.CI_COMMIT_BRANCH || env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME,
+            commitSha: env.CI_COMMIT_SHA,
+            repositoryUrl: env.CI_PROJECT_URL,
+            buildNumber: env.CI_PIPELINE_IID,
+            buildUrl: env.CI_PIPELINE_URL,
+        };
+    }
+    // Azure Pipelines
+    if (env.TF_BUILD === 'True') {
+        return {
+            branch: env.BUILD_SOURCEBRANCH?.replace('refs/heads/', ''),
+            commitSha: env.BUILD_SOURCEVERSION,
+            repositoryUrl: env.BUILD_REPOSITORY_URI,
+            buildNumber: env.BUILD_BUILDNUMBER,
+            buildUrl: env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI && env.SYSTEM_TEAMPROJECT && env.BUILD_BUILDID
+                ? `${env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI}${env.SYSTEM_TEAMPROJECT}/_build/results?buildId=${env.BUILD_BUILDID}`
+                : undefined,
+        };
+    }
+    // CircleCI
+    if (env.CIRCLECI === 'true') {
+        return {
+            branch: env.CIRCLE_BRANCH,
+            commitSha: env.CIRCLE_SHA1,
+            repositoryUrl: env.CIRCLE_REPOSITORY_URL,
+            buildNumber: env.CIRCLE_BUILD_NUM,
+            buildUrl: env.CIRCLE_BUILD_URL,
+        };
+    }
+    // Jenkins
+    if (env.JENKINS_URL) {
+        return {
+            branch: env.GIT_BRANCH?.replace('origin/', ''),
+            commitSha: env.GIT_COMMIT,
+            repositoryUrl: env.GIT_URL,
+            buildNumber: env.BUILD_NUMBER,
+            buildUrl: env.BUILD_URL,
+        };
+    }
+    // Bitbucket Pipelines
+    if (env.BITBUCKET_BUILD_NUMBER) {
+        return {
+            branch: env.BITBUCKET_BRANCH,
+            commitSha: env.BITBUCKET_COMMIT,
+            repositoryUrl: env.BITBUCKET_GIT_HTTP_ORIGIN,
+            buildNumber: env.BITBUCKET_BUILD_NUMBER,
+            buildUrl: env.BITBUCKET_REPO_FULL_NAME && env.BITBUCKET_BUILD_NUMBER
+                ? `https://bitbucket.org/${env.BITBUCKET_REPO_FULL_NAME}/pipelines/results/${env.BITBUCKET_BUILD_NUMBER}`
+                : undefined,
+        };
+    }
+    return {};
+}
+// Keep old function name for backwards compatibility
+exports.detectGitContext = detectCIContext;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@testream/jest-reporter",
+  "version": "0.1.0",
+  "description": "Jest CTRF reporter with automatic upload to Testream",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write '**/*.ts'",
+    "lint": "eslint src/**/*.ts",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests yet\" && exit 0",
+    "all": "npm run format && npm run lint && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/testream/docs.git"
+  },
+  "keywords": [
+    "jest",
+    "reporter",
+    "testing",
+    "test-management",
+    "ctrf",
+    "test-results",
+    "jira"
+  ],
+  "author": "Testream",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@jira-test-manager/shared-types": "*",
+    "jest-ctrf-json-reporter": "^0.0.10"
+  },
+  "peerDependencies": {
+    "@jest/reporters": ">=27.0.0",
+    "@jest/test-result": ">=27.0.0"
+  },
+  "devDependencies": {
+    "@jest/reporters": "^29.0.0",
+    "@jest/test-result": "^29.0.0",
+    "@types/node": "^20.10.6",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "prettier": "^3.1.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}