@flakiness/vitest 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Degu Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,241 @@
+# Flakiness.io Vitest Reporter
+
+A custom Vitest reporter that generates Flakiness Reports from your Vitest test runs. The reporter automatically converts Vitest test results into the standardized [Flakiness JSON format](https://github.com/flakiness/flakiness-report), capturing test outcomes, system utilization, and environment information.
+
+## Table of Contents
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Uploading Reports](#uploading-reports)
+- [Viewing Reports](#viewing-reports)
+- [Features](#features)
+  - [Test Location Tracking](#test-location-tracking)
+  - [Duplicate Test Detection](#duplicate-test-detection)
+  - [Environment Detection](#environment-detection)
+  - [CI Integration](#ci-integration)
+- [Configuration Options](#configuration-options)
+  - [`flakinessProject?: string`](#flakinessproject-string)
+  - [`endpoint?: string`](#endpoint-string)
+  - [`token?: string`](#token-string)
+  - [`outputFolder?: string`](#outputfolder-string)
+  - [`open?: 'always' | 'never' | 'on-failure'`](#open-always--never--on-failure)
+  - [`disableUpload?: boolean`](#disableupload-boolean)
+- [Environment Variables](#environment-variables)
+- [Example Configuration](#example-configuration)
+
+## Requirements
+
+- Vitest 4.0 or higher
+- Node.js project with a git repository (for commit information)
+- Valid Flakiness.io access token (for uploads)
+
+## Installation
+
+```bash
+npm install @flakiness/vitest
+```
+
+## Quick Start
+
+Add the reporter to your `vitest.config.ts`:
+
+```typescript
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    includeTaskLocation: true,
+    reporters: [
+      ['@flakiness/vitest']
+    ],
+  },
+});
+```
+
+> **Note:** Setting `includeTaskLocation: true` is recommended to enable test locations the report.
+
+Run your tests. The report will be automatically generated in the `./flakiness-report` folder:
+
+```bash
+npx vitest run
+```
+
+View the interactive report:
+
+```bash
+npx flakiness show ./flakiness-report
+```
+
+## Uploading Reports
+
+Reports are automatically uploaded to Flakiness.io after test completion. Authentication can be done in two ways:
+
+- **Access token**: Provide a token via the `token` option or the `FLAKINESS_ACCESS_TOKEN` environment variable.
+- **GitHub OIDC**: When running in GitHub Actions, the reporter can authenticate using GitHub's OIDC token - no access token needed. This requires two conditions:
+  1. The `flakinessProject` option must be set to your Flakiness.io project identifier (`org/project`).
+  2. The Flakiness.io project must be bound to the GitHub repository that runs the GitHub Actions workflow.
+
+If upload fails, the report is still available locally in the output folder.
+
+## Viewing Reports
+
+After test execution, you can view the report using:
+
+```bash
+npx flakiness show ./flakiness-report
+```
+
+## Features
+
+### Test Location Tracking
+
+When `includeTaskLocation: true` is set in your Vitest config, the reporter records the exact file, line, and column for each test. This enables precise navigation from the Flakiness.io dashboard back to your source code.
+
+### Duplicate Test Detection
+
+Vitest allows multiple tests to share the same name:
+
+```typescript
+it('should work', () => { /* ... */ });
+it('should work', () => { /* ... */ });
+```
+
+Flakiness.io relies on full test names (all parent suite names + test name) to construct test history, so each test must have a unique full name. The reporter detects duplicates, issues warnings, and marks them as failed with a descriptive error message. Rename your tests to have unique full names to resolve this.
+
+### Environment Detection
+
+For each Vitest project, the reporter creates a unique environment. If a project has a name, it will be used as the environment name in Flakiness.io. Tests run in different projects get separate history timelines.
+
+Environment variables prefixed with `FK_ENV_` are automatically included in the environment metadata. The prefix is stripped and the key is converted to lowercase.
+
+**Example:**
+
+```bash
+export FK_ENV_DEPLOYMENT=staging
+export FK_ENV_REGION=us-east-1
+```
+
+This will result in the environment containing:
+```json
+{
+  "metadata": {
+    "deployment": "staging",
+    "region": "us-east-1"
+  }
+}
+```
+
+Flakiness.io will create a dedicated history for tests executed in each unique environment. This means tests run with `FK_ENV_DEPLOYMENT=staging` will have a separate timeline from tests run with `FK_ENV_DEPLOYMENT=production`, allowing you to track flakiness patterns specific to each deployment environment.
+
+### CI Integration
+
+The reporter automatically detects CI environments and includes:
+- CI run URLs (GitHub Actions, Azure DevOps, Jenkins, GitLab CI)
+- Git commit information
+- System environment data
+
+## Configuration Options
+
+The reporter accepts the following options:
+
+### `flakinessProject?: string`
+
+The Flakiness.io project identifier in `org/project` format. Used for GitHub OIDC authentication — when set, and the Flakiness.io project is bound to the GitHub repository running the workflow, the reporter authenticates uploads via GitHub Actions OIDC token with no access token required.
+
+```typescript
+reporters: [
+  ['@flakiness/vitest', { flakinessProject: 'my-org/my-project' }]
+]
+```
+
+### `endpoint?: string`
+
+Custom Flakiness.io endpoint URL for uploading reports. Defaults to the `FLAKINESS_ENDPOINT` environment variable, or `https://flakiness.io` if not set.
+
+Use this option to point to a custom or self-hosted Flakiness.io instance.
+
+```typescript
+reporters: [
+  ['@flakiness/vitest', { endpoint: 'https://custom.flakiness.io' }]
+]
+```
+
+### `token?: string`
+
+Access token for authenticating with Flakiness.io when uploading reports. Defaults to the `FLAKINESS_ACCESS_TOKEN` environment variable.
+
+If no token is provided, reporter will attempt to authenticate using Github OIDC.
+
+```typescript
+reporters: [
+  ['@flakiness/vitest', { token: 'your-access-token' }]
+]
+```
+
+### `outputFolder?: string`
+
+Directory path where the Flakiness report will be written. Defaults to `flakiness-report` in the current working directory, or the `FLAKINESS_OUTPUT_DIR` environment variable if set.
+
+```typescript
+reporters: [
+  ['@flakiness/vitest', { outputFolder: './test-results/flakiness' }]
+]
+```
+
+### `open?: 'always' | 'never' | 'on-failure'`
+
+Controls when the report viewer should automatically open in your browser after test completion.
+
+- **`'on-failure'`** (default): Opens the report only if tests failed and running in an interactive terminal (not in CI)
+- **`'always'`**: Always opens the report after test completion (when running in an interactive terminal)
+- **`'never'`**: Never automatically opens the report
+
+```typescript
+reporters: [
+  ['@flakiness/vitest', { open: 'always' }]
+]
+```
+
+### `disableUpload?: boolean`
+
+When set to `true`, prevents uploading the report to Flakiness.io. The report is still generated locally. Can also be controlled via the `FLAKINESS_DISABLE_UPLOAD` environment variable.
+
+```typescript
+reporters: [
+  ['@flakiness/vitest', { disableUpload: true }]
+]
+```
+
+## Environment Variables
+
+The reporter respects the following environment variables:
+
+- **`FLAKINESS_ACCESS_TOKEN`**: Access token for Flakiness.io uploads (equivalent to `token` option)
+- **`FLAKINESS_ENDPOINT`**: Custom Flakiness.io endpoint URL (equivalent to `endpoint` option)
+- **`FLAKINESS_OUTPUT_DIR`**: Output directory for reports (equivalent to `outputFolder` option)
+- **`FLAKINESS_DISABLE_UPLOAD`**: When set, disables report uploads (equivalent to `disableUpload` option)
+
+## Example Configuration
+
+Here's a complete example with all options:
+
+```typescript
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    includeTaskLocation: true,
+    reporters: [
+      ['@flakiness/vitest', {
+        flakinessProject: 'my-org/my-project',
+        endpoint: process.env.FLAKINESS_ENDPOINT,
+        token: process.env.FLAKINESS_ACCESS_TOKEN,
+        outputFolder: './flakiness-report',
+        open: 'on-failure',
+        disableUpload: false,
+      }]
+    ],
+  },
+});
+```

package/lib/reporter.js

@@ -0,0 +1,376 @@
+import { FlakinessReport as FK } from "@flakiness/flakiness-report";
+import { CIUtils, CPUUtilization, GitWorktree, RAMUtilization, ReportUtils, showReport, uploadReport, writeReport } from "@flakiness/sdk";
+import chalk from "chalk";
+import crypto from "crypto";
+import assert from "node:assert";
+import path from "node:path";
+class FKVitestReporter {
+  constructor(_options) {
+    this._options = _options;
+  }
+  _impl;
+  _logger = {
+    warn: (txt) => console.warn(chalk.yellow(txt)),
+    error: (txt) => console.error(chalk.red(txt)),
+    log: (txt) => console.log(txt)
+  };
+  setLoggerForTest(logger) {
+    this._logger = logger;
+  }
+  onUserConsoleLog(log) {
+    this._impl?.onUserConsoleLog(log);
+  }
+  onInit(vitest) {
+    this._impl = ReporterImpl.create(vitest.config.root, this._options, this._logger);
+    this._impl?.onInit(vitest);
+  }
+  /**
+  * Called when annotation is added via the `task.annotate` API.
+  */
+  onTestCaseAnnotate(testCase, annotation) {
+    this._impl?.onTestCaseAnnotate(testCase, annotation);
+  }
+  onTestRunStart() {
+    this._impl?.onTestRunStart();
+  }
+  async onTestCaseResult(testCase) {
+    this._impl?.onTestCaseResult(testCase);
+  }
+  async onTestRunEnd(testModules, unhandledErrors, reason) {
+    this._impl?.onTestRunEnd(testModules, unhandledErrors, reason);
+  }
+}
+class ReporterImpl {
+  constructor(_worktree, _commitId, _options, _logger) {
+    this._worktree = _worktree;
+    this._commitId = _commitId;
+    this._options = _options;
+    this._logger = _logger;
+    this._sampleSystem = this._sampleSystem.bind(this);
+  }
+  _telemetryTimer;
+  _cpuUtilization = new CPUUtilization({ precision: 10 });
+  _ramUtilization = new RAMUtilization({ precision: 10 });
+  _startTimestamp = Date.now();
+  _testCaseIdToTest = /* @__PURE__ */ new Map();
+  _testToTestCaseId = /* @__PURE__ */ new Map();
+  _stdio = /* @__PURE__ */ new Map();
+  _annotations = /* @__PURE__ */ new Map();
+  // In Vitest, all projects MUST HAVE UNIQUE NAMES.
+  // So we create environments per project name.
+  _environments = [];
+  _allSuites = /* @__PURE__ */ new Map();
+  _fileSuites = /* @__PURE__ */ new Map();
+  _configPath;
+  static create(rootPath, options, logger) {
+    let commitId;
+    let worktree;
+    try {
+      worktree = GitWorktree.create(rootPath);
+      commitId = worktree.headCommitId();
+      return new ReporterImpl(worktree, commitId, options, logger);
+    } catch (e) {
+      logger.warn(`[flakiness.io] Failed to fetch commit info - is this a git repo?`);
+      logger.error(`[flakiness.io] Report is NOT generated.`);
+      return;
+    }
+  }
+  _sampleSystem() {
+    this._cpuUtilization.sample();
+    this._ramUtilization.sample();
+    this._telemetryTimer = setTimeout(this._sampleSystem, 1e3);
+  }
+  onInit(vitest) {
+    this._configPath = vitest.config.config;
+  }
+  onUserConsoleLog(log) {
+    if (!log.taskId)
+      return;
+    let entries = this._stdio.get(log.taskId);
+    if (!entries) {
+      entries = [];
+      this._stdio.set(log.taskId, entries);
+    }
+    entries.push(log);
+  }
+  onTestCaseAnnotate(testCase, annotation) {
+    let entries = this._annotations.get(testCase.id);
+    if (!entries) {
+      entries = [];
+      this._annotations.set(testCase.id, entries);
+    }
+    entries.push(annotation);
+  }
+  onTestRunStart() {
+    this._startTimestamp = Date.now();
+    this._sampleSystem();
+  }
+  _ensureFKSuite(p) {
+    let suite = this._allSuites.get(p.id);
+    if (suite)
+      return suite;
+    if ("name" in p) {
+      const parent = this._ensureFKSuite(p.parent);
+      suite = {
+        type: "suite",
+        title: p.name,
+        location: p.location ? {
+          file: this._worktree.gitPath(p.module.moduleId),
+          column: p.location.column,
+          line: p.location.line
+        } : void 0
+      };
+      parent.suites ??= [];
+      parent.suites.push(suite);
+    } else {
+      suite = {
+        type: "file",
+        title: p.relativeModuleId,
+        location: {
+          file: this._worktree.gitPath(p.moduleId),
+          column: 0,
+          line: 0
+        }
+      };
+      this._fileSuites.set(p.id, suite);
+    }
+    this._allSuites.set(p.id, suite);
+    return suite;
+  }
+  _ensureTest(testCase) {
+    let fkTest = this._testCaseIdToTest.get(testCase.id);
+    if (!fkTest) {
+      fkTest = {
+        attempts: [],
+        title: testCase.name,
+        location: testCase.location ? {
+          file: this._worktree.gitPath(testCase.module.moduleId),
+          column: testCase.location.column,
+          line: testCase.location.line
+        } : void 0
+      };
+      this._testToTestCaseId.set(fkTest, testCase.id);
+      this._testCaseIdToTest.set(testCase.id, fkTest);
+      const parent = this._ensureFKSuite(testCase.parent);
+      parent.tests ??= [];
+      parent.tests.push(fkTest);
+    }
+    return fkTest;
+  }
+  _ensureEnvironmentIdx(testCase) {
+    let idx = this._environments.findIndex((env) => env.name === testCase.project.name);
+    if (idx === -1) {
+      idx = this._environments.length;
+      this._environments.push(ReportUtils.createEnvironment({
+        name: testCase.project.name
+      }));
+    }
+    return idx;
+  }
+  _errorLocation(stacks, testFile) {
+    const frame = stacks?.find((frame2) => this._worktree.gitPath(frame2.file) === testFile) ?? stacks?.find((frame2) => !frame2.file.includes("node_modules"));
+    return frame ? {
+      file: this._worktree.gitPath(frame.file),
+      line: frame.line,
+      column: frame.column
+    } : void 0;
+  }
+  async onTestCaseResult(testCase) {
+    const environmentIdx = this._ensureEnvironmentIdx(testCase);
+    const fkTest = this._ensureTest(testCase);
+    const result = testCase.result();
+    if (result.state === "skipped") {
+      fkTest.attempts.push({
+        environmentIdx,
+        startTimestamp: Date.now(),
+        duration: 0,
+        status: "skipped",
+        expectedStatus: "skipped"
+      });
+      return;
+    }
+    const diag = testCase.diagnostic();
+    assert(diag, `Diagnostic must be present in finished test cases`);
+    ;
+    const stdio = [];
+    let ts = diag.startTime;
+    for (const entry of this._stdio.get(testCase.id) ?? []) {
+      stdio.push({
+        text: entry.content,
+        stream: entry.type === "stdout" ? FK.STREAM_STDOUT : FK.STREAM_STDERR,
+        dts: entry.time - ts
+      });
+      ts = entry.time;
+    }
+    this._stdio.delete(testCase.id);
+    const testFile = this._worktree.gitPath(testCase.module.moduleId);
+    const errors = (result.errors ?? []).map((error) => ({
+      message: error.message,
+      stack: error.stack,
+      location: this._errorLocation(error.stacks, testFile)
+    }));
+    const annotations = (this._annotations.get(testCase.id) ?? []).map((annotation) => ({
+      type: annotation.type,
+      description: annotation.message,
+      location: annotation.location ? {
+        file: this._worktree.gitPath(annotation.location.file),
+        line: annotation.location.line,
+        column: annotation.location.column
+      } : void 0
+    }));
+    const expectedStatus = testCase.options.fails ? "failed" : "passed";
+    const oppositeStatus = expectedStatus === "failed" ? "passed" : "failed";
+    for (let i = 0; i < diag.retryCount; ++i) {
+      fkTest.attempts.push({
+        environmentIdx,
+        startTimestamp: diag.startTime,
+        duration: 0,
+        // retries have an opposite status from expected status to
+        // trigger retry.
+        status: oppositeStatus,
+        expectedStatus,
+        // TODO: ideally, we can differentiate STDIO between attempts.
+        // However, vitest doesn't let us do so easily.
+        stdio,
+        errors,
+        annotations
+      });
+    }
+    fkTest.attempts.push({
+      environmentIdx,
+      startTimestamp: diag.startTime,
+      duration: diag.duration,
+      status: result.state === "failed" ? oppositeStatus : expectedStatus,
+      expectedStatus,
+      // TODO: ideally, we can differentiate STDIO between attempts.
+      // However, vitest doesn't let us do so easily.
+      stdio,
+      errors,
+      annotations
+    });
+  }
+  _detectAndHandleTestDuplicates() {
+    const TITLE_SEPARATOR = crypto.randomBytes(128).toString("base64");
+    const testIdToTests = /* @__PURE__ */ new Map();
+    const testFullNames = /* @__PURE__ */ new Map();
+    function visitSuite(suite, parentTitles = []) {
+      parentTitles.push(suite.title);
+      for (const childSuite of suite.suites ?? [])
+        visitSuite(childSuite, parentTitles);
+      for (const test of suite.tests ?? []) {
+        const envs = Array.from(new Set(test.attempts.map((attempt) => attempt.environmentIdx ?? 0))).sort((a, b) => a - b);
+        const testId = [`[${envs.join(", ")}]`, ...parentTitles, test.title].join(TITLE_SEPARATOR);
+        testFullNames.set(test, [...parentTitles, test.title].join(" > "));
+        let tests = testIdToTests.get(testId);
+        if (!tests) {
+          tests = [];
+          testIdToTests.set(testId, tests);
+        }
+        tests.push(test);
+      }
+      parentTitles.pop();
+    }
+    for (const fileSuite of this._fileSuites.values())
+      visitSuite(fileSuite);
+    if (Array.from(testIdToTests.values()).every((tests) => tests.length <= 1))
+      return;
+    const warnMessages = [];
+    for (const [testId, tests] of testIdToTests) {
+      if (tests.length <= 1)
+        continue;
+      const testFullName = testFullNames.get(tests[0]);
+      const warnMessage = `${tests.length} tests: ${testFullName}`;
+      warnMessages.push(warnMessage);
+      const test = tests[0];
+      const envs = new Set(test.attempts.map((a) => a.environmentIdx ?? 0));
+      test.attempts = Array.from(envs).map((envIdx) => ({
+        environmentIdx: envIdx,
+        startTimestamp: Date.now(),
+        duration: 0,
+        expectedStatus: "passed",
+        status: "failed",
+        errors: [{
+          message: [
+            `Flakiness.io detected ${tests.length} tests with identical full name "${testFullName}"`,
+            `Please rename tests to ensure they all have unique full names.`
+          ].join("\n")
+        }],
+        annotations: [{
+          type: "duplicates",
+          description: [
+            `Flakiness.io failed to process this test because there are ${tests.length} tests with`,
+            `identical full name: "${testFullName}".`,
+            `Please make sure that all your tests have unique full names.`
+          ].join("\n")
+        }]
+      }));
+      for (let i = 1; i < tests.length; ++i)
+        tests[i].attempts = [];
+    }
+    if (warnMessages.length) {
+      this._logger.warn(`[flakiness.io] \u26A0 Detected test with duplicate names!`);
+      for (const warnMessage of warnMessages)
+        this._logger.warn(`[flakiness.io] - ${warnMessage}`);
+      this._logger.warn(`[flakiness.io] Please rename tests so that they all have unique full names.`);
+    }
+  }
+  async onTestRunEnd(testModules, unhandledErrors, reason) {
+    clearTimeout(this._telemetryTimer);
+    this._cpuUtilization.sample();
+    this._ramUtilization.sample();
+    this._detectAndHandleTestDuplicates();
+    const duration = Date.now() - this._startTimestamp;
+    const report = ReportUtils.normalizeReport({
+      url: CIUtils.runUrl(),
+      flakinessProject: this._options.flakinessProject,
+      category: "vitest",
+      configPath: this._configPath ? this._worktree.gitPath(this._configPath) : void 0,
+      commitId: this._commitId,
+      environments: this._environments,
+      startTimestamp: this._startTimestamp,
+      duration,
+      suites: Array.from(this._fileSuites.values()),
+      unattributedErrors: unhandledErrors.map((error) => ({
+        message: error.message,
+        stack: error.stack,
+        location: this._errorLocation(error.stacks)
+      }))
+    });
+    await ReportUtils.collectSources(this._worktree, report);
+    this._cpuUtilization.enrich(report);
+    this._ramUtilization.enrich(report);
+    const outputFolder = this._options.outputFolder ?? path.join(
+      process.cwd(),
+      process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report"
+    );
+    await writeReport(report, [], outputFolder);
+    const disableUpload = !!this._options.disableUpload || !!process.env.FLAKINESS_DISABLE_UPLOAD;
+    if (!disableUpload) {
+      await uploadReport(report, [], {
+        flakinessAccessToken: this._options.token,
+        flakinessEndpoint: this._options.endpoint,
+        logger: this._logger
+      });
+    }
+    const openMode = this._options.open ?? "on-failure";
+    const shouldOpen = process.stdin.isTTY && !process.env.CI && (openMode === "always" || openMode === "on-failure" && reason === "failed");
+    if (shouldOpen) {
+      await showReport(outputFolder);
+    } else {
+      const defaultOutputFolder = path.join(process.cwd(), "flakiness-report");
+      const folder = defaultOutputFolder === outputFolder ? "" : path.relative(process.cwd(), outputFolder);
+      this._logger.log(`
+To open last Flakiness report, run:
+
+  ${chalk.cyan(`npx flakiness show ${folder}`)}
+      `);
+    }
+  }
+}
+function dupeSuffix(dupeIndex) {
+  return ` \u2013 dupe #${dupeIndex}`;
+}
+export {
+  FKVitestReporter as default
+};
+//# sourceMappingURL=reporter.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@flakiness/vitest",
+  "version": "0.1.0-alpha.0",
+  "description": "",
+  "main": "index.js",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flakiness/vitest"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "@vitest/utils": "^4.0.18",
+    "esbuild": "^0.27.3",
+    "kubik": "^0.24.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@flakiness/flakiness-report": "^0.27.0",
+    "@flakiness/sdk": "^2.2.0",
+    "chalk": "^5.6.2"
+  },
+  "scripts": {
+    "build": "kubik build.mts",
+    "test": "vitest",
+    "test:run": "vitest run"
+  }
+}

package/types/src/reporter.d.ts

@@ -0,0 +1,65 @@
+import type { SerializedError, TestCase, TestModule, TestRunEndReason, Vitest } from 'vitest/node';
+import type { Reporter } from 'vitest/reporters';
+interface UserConsoleLog {
+    content: string;
+    origin?: string;
+    browser?: boolean;
+    type: "stdout" | "stderr";
+    taskId?: string;
+    time: number;
+    size: number;
+}
+interface TestArtifactLocation {
+    /** Line number in the source file (1-indexed) */
+    line: number;
+    /** Column number in the line (1-indexed) */
+    column: number;
+    /** Path to the source file */
+    file: string;
+}
+interface TestAttachment {
+    /** MIME type of the attachment (e.g., 'image/png', 'text/plain') */
+    contentType?: string;
+    /** File system path to the attachment */
+    path?: string;
+    /** Inline attachment content as a string or raw binary data */
+    body?: string | Uint8Array;
+}
+interface TestAnnotation {
+    message: string;
+    type: string;
+    location?: TestArtifactLocation;
+    attachment?: TestAttachment;
+}
+export type OpenMode = 'always' | 'never' | 'on-failure';
+export type FKVitestReporterOptions = {
+    disableUpload?: boolean;
+    flakinessProject?: string;
+    endpoint?: string;
+    token?: string;
+    outputFolder?: string;
+    open?: OpenMode;
+};
+export interface FKVitestLogger {
+    log(txt: string): void;
+    warn(txt: string): void;
+    error(txt: string): void;
+}
+export default class FKVitestReporter implements Reporter {
+    private _options;
+    private _impl?;
+    private _logger;
+    constructor(_options: FKVitestReporterOptions);
+    setLoggerForTest(logger: FKVitestLogger): void;
+    onUserConsoleLog(log: UserConsoleLog): void;
+    onInit(vitest: Vitest): void;
+    /**
+    * Called when annotation is added via the `task.annotate` API.
+    */
+    onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
+    onTestRunStart(): void;
+    onTestCaseResult(testCase: TestCase): Promise<void>;
+    onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
+}
+export {};
+//# sourceMappingURL=reporter.d.ts.map

package/types/src/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../src/reporter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAa,MAAM,EAAE,MAAM,aAAa,CAAC;AAC9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAIjD,UAAU,cAAc;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AACD,UAAU,oBAAoB;IAC7B,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;CACb;AACD,UAAU,cAAc;IACvB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AACD,UAAU,cAAc;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,UAAU,CAAC,EAAE,cAAc,CAAC;CAC5B;AAED,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;AAEzD,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB,CAAA;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,CAAC,OAAO,OAAO,gBAAiB,YAAW,QAAQ;IAQ3C,OAAO,CAAC,QAAQ;IAP5B,OAAO,CAAC,KAAK,CAAC,CAAe;IAC7B,OAAO,CAAC,OAAO,CAId;gBAEmB,QAAQ,EAAE,uBAAuB;IAGrD,gBAAgB,CAAC,MAAM,EAAE,cAAc;IAIvC,gBAAgB,CAAC,GAAG,EAAE,cAAc;IAIpC,MAAM,CAAC,MAAM,EAAE,MAAM;IAKtB;;MAEE;IACF,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,cAAc;IAIhE,cAAc;IAIR,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;IAInC,YAAY,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,eAAe,EAAE,aAAa,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,gBAAgB;CAGrI"}