qase-report 1.0.0

package/dist/schemas/Attachment.schema.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * Schema for attachment files referenced in test results and steps.
+ * Attachments can be screenshots, videos, logs, or other files
+ * generated during test execution.
+ */
+export const AttachmentSchema = z
+    .object({
+    /**
+     * Unique identifier for the attachment
+     */
+    id: z.string(),
+    /**
+     * Original filename (e.g., "screenshot.png").
+     * Optional — derived from file_path when not provided by reporter.
+     */
+    file_name: z.string().optional(),
+    /**
+     * Relative path to the attachment file
+     * (e.g., "./build/qase-report/attachments/abc-123.png")
+     */
+    file_path: z.string(),
+    /**
+     * MIME type of the attachment (e.g., "image/png", "video/mp4")
+     */
+    mime_type: z.string().optional(),
+    /**
+     * File size in bytes (optional)
+     */
+    size: z.number().optional(),
+    /**
+     * Base64-encoded content for inline attachments (optional, nullable)
+     */
+    content: z.string().nullable().optional(),
+    /**
+     * Whether this is a temporary attachment (optional)
+     */
+    temporary: z.boolean().optional(),
+})
+    .transform(att => ({
+    ...att,
+    file_name: att.file_name ?? att.file_path.split('/').pop() ?? 'unknown',
+}));

package/dist/schemas/QaseHistory.schema.js

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+/**
+ * Enum for test execution status in historical data.
+ * Matches TestStatusEnum from QaseTestResult.schema.ts
+ */
+const TestStatusEnum = z.enum(['passed', 'failed', 'skipped', 'broken', 'blocked', 'invalid', 'muted']);
+/**
+ * Statistical summary of test run results.
+ * Simplified version for historical data storage.
+ */
+const HistoricalRunStatsSchema = z.object({
+    /**
+     * Total number of tests
+     */
+    total: z.number(),
+    /**
+     * Number of passed tests
+     */
+    passed: z.number(),
+    /**
+     * Number of failed tests
+     */
+    failed: z.number(),
+    /**
+     * Number of skipped tests
+     */
+    skipped: z.number(),
+    /**
+     * Number of blocked tests (optional)
+     */
+    blocked: z.number().optional(),
+    /**
+     * Number of invalid tests (optional)
+     */
+    invalid: z.number().optional(),
+    /**
+     * Number of muted tests (optional)
+     */
+    muted: z.number().optional(),
+});
+/**
+ * Summary data for each historical test run.
+ * Contains run-level metadata and statistics for tiered loading.
+ */
+export const HistoricalRunSchema = z.object({
+    /**
+     * Unique identifier for this run (can be timestamp or UUID)
+     */
+    run_id: z.string(),
+    /**
+     * Run title (optional, nullable)
+     */
+    title: z.string().nullable().optional(),
+    /**
+     * Environment where tests ran (optional, nullable)
+     */
+    environment: z.string().nullable().optional(),
+    /**
+     * Unix timestamp when run started (milliseconds)
+     */
+    start_time: z.number(),
+    /**
+     * Unix timestamp when run ended (milliseconds)
+     */
+    end_time: z.number().nullable(),
+    /**
+     * Total duration of the run in milliseconds
+     */
+    duration: z.number(),
+    /**
+     * Statistical summary of run results
+     */
+    stats: HistoricalRunStatsSchema,
+});
+/**
+ * Per-test run data for historical tracking.
+ * Contains status and timing for a single test execution in a specific run.
+ */
+export const HistoricalTestRunDataSchema = z.object({
+    /**
+     * Reference to HistoricalRunSchema.run_id
+     */
+    run_id: z.string(),
+    /**
+     * Test execution status
+     */
+    status: TestStatusEnum,
+    /**
+     * Test duration in milliseconds
+     */
+    duration: z.number(),
+    /**
+     * Unix timestamp when test started (milliseconds)
+     */
+    start_time: z.number(),
+    /**
+     * First line of error message or stacktrace (nullable).
+     * Used for flakiness detection - consistent errors vs random failures.
+     */
+    error_message: z.string().nullable(),
+});
+/**
+ * Per-test historical summary across runs.
+ * Uses signature-based identity for stable tracking across runs.
+ */
+export const HistoricalTestResultSchema = z.object({
+    /**
+     * Test signature (stable identifier, not run-specific UUID).
+     * Matches signature field from QaseTestResult.
+     */
+    signature: z.string(),
+    /**
+     * Test case title
+     */
+    title: z.string(),
+    /**
+     * Array of run data for this test.
+     * Each entry represents one execution of this test in a historical run.
+     */
+    runs: z.array(HistoricalTestRunDataSchema),
+});
+/**
+ * Root schema for test-history.json file.
+ * Contains versioned history data with run summaries and per-test results.
+ *
+ * Schema versioning uses SchemaVer format (MODEL-REVISION-ADDITION):
+ * - MODEL: Breaking changes requiring migration
+ * - REVISION: Backward-compatible additions
+ * - ADDITION: Minor fixes or metadata updates
+ */
+export const QaseHistorySchema = z.object({
+    /**
+     * Schema version for future migration support.
+     * Format: SchemaVer (MODEL-REVISION-ADDITION), e.g., "1.0.0"
+     */
+    schema_version: z.string().default('1.0.0'),
+    /**
+     * Array of historical run summaries.
+     * Contains high-level metadata and stats for tiered loading.
+     */
+    runs: z.array(HistoricalRunSchema),
+    /**
+     * Array of per-test historical results.
+     * Contains detailed run history for each test by signature.
+     */
+    tests: z.array(HistoricalTestResultSchema),
+});

package/dist/schemas/QaseRun.schema.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+/**
+ * Execution timing information for the test run.
+ */
+const RunExecutionSchema = z.object({
+    /**
+     * Unix timestamp when run started (milliseconds)
+     */
+    start_time: z.number(),
+    /**
+     * Unix timestamp when run ended (milliseconds)
+     */
+    end_time: z.number().nullable(),
+    /**
+     * Total duration of the run in milliseconds
+     */
+    duration: z.number(),
+    /**
+     * Cumulative duration of all test executions in milliseconds
+     */
+    cumulative_duration: z.number(),
+});
+/**
+ * Statistical summary of test run results.
+ */
+const RunStatsSchema = z.object({
+    /**
+     * Total number of tests
+     */
+    total: z.number(),
+    /**
+     * Number of passed tests
+     */
+    passed: z.number(),
+    /**
+     * Number of failed tests
+     */
+    failed: z.number(),
+    /**
+     * Number of skipped tests
+     */
+    skipped: z.number(),
+    /**
+     * Number of broken tests
+     */
+    broken: z.number().optional(),
+    /**
+     * Number of blocked tests
+     */
+    blocked: z.number().optional(),
+    /**
+     * Number of invalid tests
+     */
+    invalid: z.number().optional(),
+    /**
+     * Number of muted tests
+     */
+    muted: z.number().optional(),
+});
+/**
+ * Summary information for individual test results.
+ */
+const ResultSummarySchema = z.object({
+    /**
+     * Test result ID (matches filename in results/ directory)
+     */
+    id: z.string(),
+    /**
+     * Test title
+     */
+    title: z.string(),
+    /**
+     * Test execution status
+     */
+    status: z.string(),
+    /**
+     * Test duration in milliseconds
+     */
+    duration: z.number(),
+    /**
+     * Thread where test ran (nullable)
+     */
+    thread: z.string().nullable(),
+});
+/**
+ * Host system information where tests were executed.
+ * Fields vary depending on the reporter (Python vs JavaScript).
+ */
+const HostDataSchema = z
+    .object({
+    node: z.string().optional(),
+    system: z.string().optional(),
+    release: z.string().optional(),
+    version: z.string().optional(),
+    machine: z.string().optional(),
+    arch: z.string().optional(),
+    machineName: z.string().optional(),
+    python: z.string().optional(),
+    pip: z.string().optional(),
+    npm: z.string().optional(),
+    framework: z.string().optional(),
+    reporter: z.string().optional(),
+    commons: z.string().optional(),
+    apiClientV1: z.string().optional(),
+    apiClientV2: z.string().optional(),
+})
+    .passthrough();
+/**
+ * Schema for run.json file.
+ * Contains metadata about the test run, summary statistics,
+ * and references to individual test results.
+ */
+export const QaseRunSchema = z.object({
+    /**
+     * Run title (optional - may not be present in all formats)
+     */
+    title: z.string().optional(),
+    /**
+     * Environment where tests ran (optional, nullable)
+     */
+    environment: z.string().nullable().optional(),
+    /**
+     * Execution timing information
+     */
+    execution: RunExecutionSchema,
+    /**
+     * Statistical summary of results
+     */
+    stats: RunStatsSchema,
+    /**
+     * Array of test result summaries
+     */
+    results: z.array(ResultSummarySchema),
+    /**
+     * List of threads used for execution
+     */
+    threads: z.array(z.string()).optional(),
+    /**
+     * List of test suites in this run
+     */
+    suites: z.array(z.string()).optional(),
+    /**
+     * Host system information
+     */
+    host_data: HostDataSchema.optional(),
+});

package/dist/schemas/QaseTestResult.schema.js

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { AttachmentSchema } from './Attachment.schema.js';
+import { StepSchema } from './Step.schema.js';
+/**
+ * Enum for test execution status.
+ * - passed: Test completed successfully
+ * - failed: Test failed with assertion errors
+ * - skipped: Test was skipped
+ * - broken: Test encountered errors preventing execution
+ * - blocked: Test blocked by external dependency
+ * - invalid: Test has invalid configuration
+ * - muted: Test failures are muted/ignored
+ */
+const TestStatusEnum = z.enum(['passed', 'failed', 'skipped', 'broken', 'blocked', 'invalid', 'muted']);
+/**
+ * Execution information for a test result.
+ */
+const TestExecutionSchema = z.object({
+    /**
+     * Test execution status
+     */
+    status: TestStatusEnum,
+    /**
+     * Unix timestamp when test started (milliseconds)
+     */
+    start_time: z.number(),
+    /**
+     * Unix timestamp when test ended (milliseconds)
+     */
+    end_time: z.number().nullable(),
+    /**
+     * Duration in milliseconds
+     */
+    duration: z.number(),
+    /**
+     * Stack trace if test failed (nullable)
+     */
+    stacktrace: z.string().nullable().optional(),
+    /**
+     * Thread identifier where test ran (nullable)
+     */
+    thread: z.string().nullable(),
+});
+/**
+ * Relations metadata for test result.
+ * Contains suite hierarchy information.
+ */
+const TestRelationsSchema = z
+    .object({
+    suite: z.object({
+        data: z.array(z.object({
+            /**
+             * Suite title
+             */
+            title: z.string(),
+            /**
+             * Public ID from Qase TMS (nullable)
+             */
+            public_id: z.number().nullable().optional(),
+        })),
+    }),
+})
+    .nullable();
+/**
+ * Schema for individual test result file (results/{uuid}.json).
+ * Contains complete test execution data including steps, attachments,
+ * parameters, and metadata.
+ */
+export const TestResultSchema = z.object({
+    /**
+     * Unique identifier for this test result
+     */
+    id: z.string(),
+    /**
+     * Test case title
+     */
+    title: z.string(),
+    /**
+     * Test signature (unique identifier for test case)
+     */
+    signature: z.string(),
+    /**
+     * Whether test failures are muted/ignored
+     */
+    muted: z.boolean(),
+    /**
+     * Execution information (status, timing, stack trace)
+     */
+    execution: TestExecutionSchema,
+    /**
+     * Test result message (nullable)
+     */
+    message: z.string().nullable().optional(),
+    /**
+     * Relations to suite hierarchy (nullable)
+     */
+    relations: TestRelationsSchema,
+    /**
+     * Array of test steps (can be nested)
+     */
+    steps: z.array(StepSchema),
+    /**
+     * Attachments for this test
+     */
+    attachments: z.array(AttachmentSchema),
+    /**
+     * Test parameters (key-value pairs)
+     */
+    params: z.record(z.string(), z.string()),
+    /**
+     * Parameter groups for parameterized tests
+     */
+    param_groups: z.array(z.array(z.string())),
+    /**
+     * Custom fields (key-value pairs, values can be null)
+     */
+    fields: z.record(z.string(), z.string().nullable()),
+    /**
+     * Qase TMS test case IDs (optional, nullable)
+     */
+    testops_ids: z.array(z.number()).nullable().optional(),
+});

package/dist/schemas/Step.schema.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { AttachmentSchema } from './Attachment.schema.js';
+/**
+ * Step type - flexible to handle various step types from different reporters.
+ * Common values: text, request, assertion, gherkin, action
+ */
+const StepTypeSchema = z.string();
+/**
+ * Step execution status - flexible to handle various statuses.
+ * Common values: passed, failed, skipped, broken, pending
+ */
+const StepStatusSchema = z.string();
+/**
+ * Data associated with a test step.
+ * All fields are optional to handle various reporter formats.
+ */
+const StepDataSchema = z.object({
+    /**
+     * Action performed in this step (optional)
+     */
+    action: z.string().optional(),
+    /**
+     * Expected result for this step (optional, nullable)
+     */
+    expected_result: z.string().nullable().optional(),
+    /**
+     * Input data used in this step (optional, nullable)
+     */
+    input_data: z.string().nullable().optional(),
+});
+/**
+ * Execution information for a step.
+ */
+const StepExecutionSchema = z.object({
+    /**
+     * Execution status (passed, failed, skipped, broken, etc.)
+     */
+    status: StepStatusSchema,
+    /**
+     * Unix timestamp when step started (milliseconds)
+     */
+    start_time: z.number(),
+    /**
+     * Unix timestamp when step ended (milliseconds)
+     */
+    end_time: z.number().nullable(),
+    /**
+     * Duration in milliseconds
+     */
+    duration: z.number(),
+    /**
+     * Attachments created during this step
+     */
+    attachments: z.array(AttachmentSchema),
+});
+/**
+ * Recursive schema for test steps.
+ * Steps can contain nested steps, allowing hierarchical test structure.
+ *
+ * Uses z.lazy() to enable recursive type definition.
+ */
+export const StepSchema = z.lazy(() => z.object({
+    /**
+     * Unique identifier for this step
+     */
+    id: z.string(),
+    /**
+     * Type of step (text, request, assertion, gherkin, etc.)
+     */
+    step_type: StepTypeSchema,
+    /**
+     * ID of parent step (nullable for top-level steps)
+     */
+    parent_id: z.string().nullable().optional(),
+    /**
+     * Step data (action, expected result, input data)
+     */
+    data: StepDataSchema,
+    /**
+     * Execution information for this step
+     */
+    execution: StepExecutionSchema,
+    /**
+     * Nested steps (recursive array)
+     */
+    steps: z.array(StepSchema),
+}));

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "qase-report",
+  "private": false,
+  "version": "1.0.0",
+  "type": "module",
+  "description": "CLI tool for visualizing Qase TMS test reports with interactive UI",
+  "keywords": [
+    "qase",
+    "testing",
+    "test-report",
+    "visualization",
+    "tms",
+    "cli",
+    "reporter"
+  ],
+  "author": "Qase TMS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qase-tms/qase-report.git"
+  },
+  "homepage": "https://github.com/qase-tms/qase-report#readme",
+  "bugs": {
+    "url": "https://github.com/qase-tms/qase-report/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "qase-report": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist/cli/",
+    "dist/schemas/",
+    "dist/index.html"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build && npm run build:cli",
+    "build:cli": "tsc -p tsconfig.cli.json && chmod +x dist/cli/index.js",
+    "preview": "vite preview",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@tailwindcss/vite": "^4.1.18",
+    "@tanstack/match-sorter-utils": "^8.19.4",
+    "@tanstack/react-table": "^8.21.3",
+    "@tanstack/react-virtual": "^3.13.18",
+    "archiver": "^7.0.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "commander": "^14.0.3",
+    "express": "^5.2.1",
+    "lucide-react": "^0.563.0",
+    "mobx": "^6.9.0",
+    "mobx-react-lite": "^3.4.3",
+    "open": "^11.0.0",
+    "prism-react-renderer": "^2.4.1",
+    "radix-ui": "^1.4.3",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-hotkeys-hook": "^5.2.4",
+    "react-window": "^1.8.11",
+    "recharts": "^2.15.4",
+    "tailwind-merge": "^3.4.0",
+    "tailwindcss": "^4.1.18",
+    "tailwindcss-animate": "^1.0.7",
+    "yet-another-react-lightbox": "^3.28.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/archiver": "^7.0.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.2.3",
+    "@types/react": "^18.0.28",
+    "@types/react-dom": "^18.0.11",
+    "@types/react-window": "^1.8.8",
+    "@vitejs/plugin-legacy": "^5.4.3",
+    "@vitejs/plugin-react": "^4.7.0",
+    "prettier": "2.8.7",
+    "shadcn": "^3.8.4",
+    "terser": "^5.46.0",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.21",
+    "vite-plugin-singlefile": "^2.3.0"
+  },
+  "optionalDependencies": {
+    "playwright-core": "^1.58.0"
+  }
+}