@skyramp/mcp 0.3.2-rc.pom-2 → 0.3.2-rc.pom-3

package/build/adapters/jestAdapter.d.ts

@@ -0,0 +1,14 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parseJestJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+export declare function buildJestArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+    reportPath: string;
+}): string[];
+export declare function buildVitestArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+    reportPath: string;
+}): string[];

package/build/adapters/jestAdapter.js

@@ -0,0 +1,113 @@
+/**
+ * Shared jest + vitest adapter for skyramp_run_existing_tests. vitest's json
+ * reporter is jest-compatible, so both use ONE parser; only the reporter flag
+ * differs (`--json` vs `--reporter=json`), hence two buildArgs. Native JSON
+ * (not junit): preserves the fail signal and file-level testExecError (mapped to
+ * `error`).
+ */
+import { stripVTControlCharacters } from "util";
+function mapAssertion(status) {
+    switch (status) {
+        case "passed":
+            return "pass";
+        case "failed":
+            return "fail";
+        case "pending":
+        case "skipped":
+        case "todo":
+        case "disabled":
+            return "skipped";
+        default:
+            return status ? "error" : "skipped";
+    }
+}
+export function parseJestJson(report, opts) {
+    const rep = (report ?? {});
+    const results = [];
+    for (const file of rep.testResults ?? []) {
+        const name = file.name ?? "(unknown)";
+        // A test file that failed to compile/run has no assertionResults. Jest
+        // surfaces the cause two ways depending on failure type: a structured
+        // `testExecError` (e.g. environment setup errors), OR — confirmed against a
+        // REAL jest run with a syntax error — `status: "failed"` plus a plain
+        // top-level `message` and no `testExecError` at all. Treat either as one
+        // synthetic `error` result (a broken test file is PR signal, unlike a
+        // Playwright global-setup failure).
+        const noAssertions = (file.assertionResults ?? []).length === 0;
+        const isExecFailure = noAssertions && (file.testExecError || file.status === "failed");
+        if (isExecFailure) {
+            const raw = file.testExecError?.message ?? file.message ?? "test file failed to run";
+            results.push({
+                testId: `${name} › (file failed to run)`,
+                file: name,
+                status: "error",
+                message: stripVTControlCharacters(raw).trim() || undefined,
+                durationMs: 0,
+            });
+            continue;
+        }
+        for (const a of file.assertionResults ?? []) {
+            const status = mapAssertion(a.status);
+            const titlePath = [...(a.ancestorTitles ?? []), a.title ?? ""].filter(Boolean).join(" › ");
+            const message = status === "fail" || status === "error"
+                ? stripVTControlCharacters((a.failureMessages ?? [])[0] ?? "").trim() || undefined
+                : undefined;
+            results.push({
+                testId: `${name} › ${titlePath}`,
+                file: name,
+                status,
+                message,
+                durationMs: Math.round(a.duration ?? 0),
+            });
+        }
+    }
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: { ran: passed + failed + errored, failed, errored, skipped, truncated: opts?.truncated ?? false },
+        environmentHealthy: true,
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function splitSelectors(selectors) {
+    const files = [];
+    const titles = [];
+    for (const sel of selectors) {
+        const idx = sel.indexOf("::");
+        if (idx >= 0) {
+            const file = sel.slice(0, idx).trim();
+            const title = sel.slice(idx + 2).trim();
+            if (file && !files.includes(file))
+                files.push(file);
+            if (title)
+                titles.push(title);
+        }
+        else if (sel.trim() && !files.includes(sel.trim())) {
+            files.push(sel.trim());
+        }
+    }
+    return { files, titles };
+}
+export function buildJestArgs(input) {
+    const { files, titles } = splitSelectors(input.selectors);
+    const args = [...files, "--json", `--outputFile=${input.reportPath}`];
+    if (input.mode === "probe")
+        args.push("--bail=1");
+    if (titles.length > 0)
+        args.push("-t", titles.map(escapeRegex).join("|"));
+    return args;
+}
+export function buildVitestArgs(input) {
+    const { files, titles } = splitSelectors(input.selectors);
+    const args = [...files, "--reporter=json", `--outputFile=${input.reportPath}`];
+    if (input.mode === "probe")
+        args.push("--bail=1");
+    if (titles.length > 0)
+        args.push("-t", titles.map(escapeRegex).join("|"));
+    return args;
+}

package/build/adapters/jestAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/adapters/jestAdapter.test.js

@@ -0,0 +1,93 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { readFileSync } from "fs";
+import { parseJestJson, buildJestArgs, buildVitestArgs } from "./jestAdapter.js";
+const here = path.dirname(fileURLToPath(import.meta.url));
+function loadFixture(name) {
+    return JSON.parse(readFileSync(path.join(here, "__fixtures__", `${name}.json`), "utf8"));
+}
+describe("parseJestJson", () => {
+    describe("jest healthy variety report", () => {
+        const parsed = parseJestJson(loadFixture("jest-healthy"));
+        const byId = (s) => parsed.results.find((r) => r.testId.includes(s));
+        it("keeps the environment healthy (a broken test file is PR signal, not env)", () => {
+            expect(parsed.environmentHealthy).toBe(true);
+        });
+        it("maps passed/failed/todo and a file testExecError to pass/fail/skipped/error", () => {
+            expect(byId("adds numbers").status).toBe("pass");
+            expect(byId("detects a regression").status).toBe("fail");
+            expect(byId("todo later").status).toBe("skipped");
+            expect(byId("broken.test.js").status).toBe("error");
+        });
+        it("builds a testId from file + ancestorTitles + title", () => {
+            expect(byId("adds numbers").testId).toBe("/repo/src/math.test.js › math › adds numbers");
+            expect(byId("adds numbers").file).toBe("/repo/src/math.test.js");
+        });
+        it("captures a failure message for fail and file-exec error", () => {
+            expect(byId("detects a regression").message).toMatch(/Expected: 2/);
+            expect(byId("broken.test.js").message).toMatch(/SyntaxError/);
+        });
+        it("summarizes ran/failed/errored/skipped (skipped not in ran)", () => {
+            expect(parsed.summary).toMatchObject({ failed: 1, errored: 1, skipped: 1 });
+            expect(parsed.summary.ran).toBe(3);
+        });
+    });
+    describe("real jest syntax-error shape (no testExecError, top-level message)", () => {
+        // Confirmed against a REAL jest run (Step 7 smoke): a syntax error produces
+        // `status: "failed"`, `assertionResults: []`, and a top-level `message` —
+        // no `testExecError` object at all. Must map to "error" same as the
+        // testExecError shape.
+        const parsed = parseJestJson({
+            testResults: [
+                {
+                    name: "/repo/src/broken2.test.js",
+                    status: "failed",
+                    message: "SyntaxError: Unexpected token, expected \",\"",
+                    assertionResults: [],
+                },
+            ],
+        });
+        it("maps a message-only file failure to a single error result", () => {
+            expect(parsed.results).toHaveLength(1);
+            expect(parsed.results[0].status).toBe("error");
+            expect(parsed.results[0].message).toMatch(/SyntaxError/);
+            expect(parsed.summary).toMatchObject({ errored: 1, failed: 0, skipped: 0 });
+        });
+    });
+    describe("vitest report through the shared reader", () => {
+        const parsed = parseJestJson(loadFixture("vitest-healthy"));
+        it("parses vitest's jest-compatible json identically", () => {
+            expect(parsed.summary).toMatchObject({ failed: 0, errored: 0, skipped: 1 });
+            expect(parsed.summary.ran).toBe(1);
+            expect(parsed.results.find((r) => r.testId.includes("works")).status).toBe("pass");
+        });
+    });
+    it("honors an explicit truncated flag", () => {
+        expect(parseJestJson(loadFixture("jest-healthy"), { truncated: true }).summary.truncated).toBe(true);
+    });
+});
+describe("buildJestArgs", () => {
+    it("forces --json + --outputFile and passes files", () => {
+        const args = buildJestArgs({ selectors: ["src/a.test.js"], mode: "confirm", reportPath: "/tmp/r.json" });
+        expect(args).toContain("--json");
+        expect(args).toContain("--outputFile=/tmp/r.json");
+        expect(args).toContain("src/a.test.js");
+        expect(args).not.toContain("--bail=1");
+    });
+    it("bails at first failure in probe mode and filters by name via -t", () => {
+        const args = buildJestArgs({ selectors: ["src/a.test.js::renders header"], mode: "probe", reportPath: "/tmp/r.json" });
+        expect(args).toContain("--bail=1");
+        const ti = args.indexOf("-t");
+        expect(ti).toBeGreaterThanOrEqual(0);
+        expect(args[ti + 1]).toContain("renders header");
+        expect(args).toContain("src/a.test.js");
+    });
+});
+describe("buildVitestArgs", () => {
+    it("forces --reporter=json + --outputFile (vitest form)", () => {
+        const args = buildVitestArgs({ selectors: ["src/a.test.ts"], mode: "confirm", reportPath: "/tmp/r.json" });
+        expect(args).toContain("--reporter=json");
+        expect(args).toContain("--outputFile=/tmp/r.json");
+        expect(args).not.toContain("--json");
+    });
+});

package/build/adapters/mochaAdapter.d.ts

@@ -0,0 +1,13 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parseMochaJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+/**
+ * Builds the args appended to the suite's `testRunCommand` (e.g. `npx mocha`).
+ * `--reporter json` prints the report to stdout (the generic runner captures
+ * it). Selectors are spec files, optionally `file::title` → `--grep`.
+ */
+export declare function buildMochaArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+}): string[];

package/build/adapters/mochaAdapter.js

@@ -0,0 +1,87 @@
+/**
+ * Mocha adapter for skyramp_run_existing_tests. Normalizes `mocha --reporter
+ * json` (emitted to stdout) into the neutral shape. Mocha does not tag
+ * fail-vs-error, so we classify: an AssertionError is a test FAILURE; a hook
+ * failure or any other thrown error is an ERROR.
+ */
+import { stripVTControlCharacters } from "util";
+/** Assertion failure → fail; hook failure or any other throw → error. */
+function classifyFailure(t) {
+    const title = `${t.fullTitle ?? ""} ${t.title ?? ""}`;
+    // Mocha reports a hook failure with a title like `"before each" hook for "x"`.
+    // Match that specific shape (not a loose /hook/) so a normal test merely titled
+    // "...hook..." is not mislabeled as an environment error.
+    if (/"(before|after) (each|all)" hook\b/i.test(title))
+        return "error";
+    if (/assertion/i.test(t.err?.name ?? ""))
+        return "fail";
+    return "error";
+}
+function messageOf(t) {
+    const raw = t.err?.message ?? t.err?.stack;
+    if (!raw)
+        return undefined;
+    return stripVTControlCharacters(raw).split("\n")[0].trim() || undefined;
+}
+function toResult(t, status) {
+    const file = t.file ?? "(unknown)";
+    const full = t.fullTitle ?? t.title ?? "(unknown)";
+    return {
+        testId: `${file} › ${full}`,
+        file,
+        status,
+        message: status === "fail" || status === "error" ? messageOf(t) : undefined,
+        durationMs: Math.round(t.duration ?? 0),
+    };
+}
+export function parseMochaJson(report, opts) {
+    const rep = (report ?? {});
+    const results = [];
+    for (const t of rep.passes ?? [])
+        results.push(toResult(t, "pass"));
+    for (const t of rep.pending ?? [])
+        results.push(toResult(t, "skipped"));
+    for (const t of rep.failures ?? [])
+        results.push(toResult(t, classifyFailure(t)));
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: { ran: passed + failed + errored, failed, errored, skipped, truncated: opts?.truncated ?? false },
+        environmentHealthy: true,
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Builds the args appended to the suite's `testRunCommand` (e.g. `npx mocha`).
+ * `--reporter json` prints the report to stdout (the generic runner captures
+ * it). Selectors are spec files, optionally `file::title` → `--grep`.
+ */
+export function buildMochaArgs(input) {
+    const files = [];
+    const titles = [];
+    for (const sel of input.selectors) {
+        const idx = sel.indexOf("::");
+        if (idx >= 0) {
+            const file = sel.slice(0, idx).trim();
+            const title = sel.slice(idx + 2).trim();
+            if (file && !files.includes(file))
+                files.push(file);
+            if (title)
+                titles.push(title);
+        }
+        else if (sel.trim() && !files.includes(sel.trim())) {
+            files.push(sel.trim());
+        }
+    }
+    const args = [...files, "--reporter", "json"];
+    if (input.mode === "probe")
+        args.push("--bail");
+    if (titles.length > 0)
+        args.push("--grep", titles.map(escapeRegex).join("|"));
+    return args;
+}

package/build/adapters/mochaAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/adapters/mochaAdapter.test.js

@@ -0,0 +1,63 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { readFileSync } from "fs";
+import { parseMochaJson, buildMochaArgs } from "./mochaAdapter.js";
+const here = path.dirname(fileURLToPath(import.meta.url));
+function loadFixture(name) {
+    return JSON.parse(readFileSync(path.join(here, "__fixtures__", `mocha-${name}.json`), "utf8"));
+}
+describe("parseMochaJson", () => {
+    const parsed = parseMochaJson(loadFixture("healthy"));
+    const byId = (s) => parsed.results.find((r) => r.testId.includes(s));
+    it("keeps the environment healthy for a normal run", () => {
+        expect(parsed.environmentHealthy).toBe(true);
+    });
+    it("maps passes/pending/assertion-failure/hook-error to pass/skipped/fail/error", () => {
+        expect(byId("math adds").status).toBe("pass");
+        expect(byId("math later").status).toBe("skipped");
+        expect(byId("detects regression").status).toBe("fail");
+        expect(byId("before each").status).toBe("error");
+    });
+    it("builds testId from file + fullTitle", () => {
+        expect(byId("math adds").testId).toBe("/repo/test/math.spec.js › math adds");
+        expect(byId("math adds").file).toBe("/repo/test/math.spec.js");
+    });
+    it("captures a message for fail and error", () => {
+        expect(byId("detects regression").message).toMatch(/expected 2 to equal 3/);
+        expect(byId("before each").message).toMatch(/Cannot read properties/);
+    });
+    it("summarizes ran/failed/errored/skipped (skipped not in ran)", () => {
+        expect(parsed.summary).toMatchObject({ failed: 1, errored: 1, skipped: 1 });
+        expect(parsed.summary.ran).toBe(3);
+    });
+    it("classifies an assertion failure in a test merely titled with 'hook' as fail, not error", () => {
+        const parsed = parseMochaJson({
+            failures: [
+                {
+                    title: "renders the hook menu",
+                    fullTitle: "ui renders the hook menu",
+                    file: "/repo/test/ui.spec.js",
+                    duration: 2,
+                    err: { name: "AssertionError", message: "expected menu open" },
+                },
+            ],
+        });
+        expect(parsed.results[0].status).toBe("fail");
+    });
+});
+describe("buildMochaArgs", () => {
+    it("forces the json reporter (to stdout) and passes files", () => {
+        const args = buildMochaArgs({ selectors: ["test/math.spec.js"], mode: "confirm" });
+        expect(args).toContain("--reporter");
+        expect(args).toContain("json");
+        expect(args).toContain("test/math.spec.js");
+        expect(args).not.toContain("--bail");
+    });
+    it("bails in probe mode and filters by name via --grep", () => {
+        const args = buildMochaArgs({ selectors: ["test/math.spec.js::adds"], mode: "probe" });
+        expect(args).toContain("--bail");
+        const gi = args.indexOf("--grep");
+        expect(gi).toBeGreaterThanOrEqual(0);
+        expect(args[gi + 1]).toContain("adds");
+    });
+});

package/build/adapters/playwrightAdapter.d.ts

@@ -0,0 +1,17 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parsePlaywrightJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+/**
+ * Builds the argument list appended to a suite's `testRunCommand` (e.g.
+ * `npx playwright test`). Selectors are spec files, optionally `file::title`
+ * to also filter by test name. Forces the JSON reporter for machine-readable
+ * results and, in confirm mode, disables the failure cap so ALL breakages are
+ * counted (Ghost's config sets `maxFailures: 1`, which would otherwise stop at
+ * the first break).
+ */
+export declare function buildPlaywrightArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify";
+    project?: string;
+}): string[];

package/build/adapters/playwrightAdapter.js

@@ -0,0 +1,182 @@
+/**
+ * Playwright adapter for skyramp_run_existing_tests.
+ *
+ * Runs a repo's OWN Playwright suite (external, user-authored tests) and turns
+ * the `@playwright/test` JSON reporter output into the tool's neutral result
+ * shape. This is the DELEGATE-mode path (eng doc §7 / design spec §7): the
+ * suite owns environment bring-up (via a Playwright `global-setup` dependency
+ * and/or a wrapper entrypoint), and this adapter only drives the run with
+ * scoped selectors + config overrides and reads back structured results.
+ *
+ * The pure `parsePlaywrightJson` is the tested core; `buildPlaywrightArgs`
+ * builds the flags appended to the suite's `testRunCommand`. The IO shell that
+ * actually spawns the run lives in `runExistingTestsTool`.
+ */
+import { stripVTControlCharacters } from "util";
+/**
+ * A Playwright project (or spec file) is "infra" when it exists to bring up /
+ * tear down the environment rather than to assert product behavior. Its
+ * failures are environment health signals, not PR signals.
+ */
+function isInfraSpec(projectName, file) {
+    if (/setup|teardown/i.test(projectName ?? ""))
+        return true;
+    return /(^|\/)global[.-]?(setup|teardown)|\.(setup|teardown)\.[cm]?[jt]s$/i.test(file);
+}
+/** Depth-first walk collecting every spec with its file + describe-title path.
+ *  A file-level suite's own title is the filename, so it is NOT added to the
+ *  path; nested (describe) suite titles are. */
+function collectSpecs(suite, file, describePath, out) {
+    const suiteFile = suite.file ?? file;
+    for (const spec of suite.specs ?? []) {
+        out.push({ spec, file: spec.file ?? suiteFile, describePath });
+    }
+    for (const child of suite.suites ?? []) {
+        collectSpecs(child, suiteFile, [...describePath, child.title ?? ""], out);
+    }
+}
+/** Maps a single Playwright test (one project's run of a spec) to a neutral status. */
+function mapStatus(test) {
+    if (test.status === "skipped")
+        return "skipped";
+    const results = test.results ?? [];
+    if (results.length === 0)
+        return "skipped"; // never executed (e.g. dependency failed)
+    const final = results[results.length - 1];
+    switch (final.status) {
+        case "passed":
+            return "pass";
+        case "skipped":
+            return "skipped";
+        case "timedOut":
+        case "interrupted":
+            return "error";
+        case "failed":
+            return "fail";
+        default:
+            return final.status ? "error" : "skipped";
+    }
+}
+function messageOf(test) {
+    const results = test.results ?? [];
+    const final = results[results.length - 1];
+    const raw = final?.error?.message ?? final?.errors?.[0]?.message;
+    if (!raw)
+        return undefined;
+    return stripVTControlCharacters(raw).trim() || undefined;
+}
+export function parsePlaywrightJson(report, opts) {
+    const rep = (report ?? {});
+    const collected = [];
+    for (const fileSuite of rep.suites ?? []) {
+        collectSpecs(fileSuite, fileSuite.file ?? "", [], collected);
+    }
+    const results = [];
+    let environmentHealthy = true;
+    let healthDetail;
+    let infraSpecFailed = false;
+    const runLevelErrors = (rep.errors ?? []).map((e) => stripVTControlCharacters(e?.message ?? "unknown error").split("\n")[0]);
+    const isMaxFailuresBail = (m) => /maximum allowed failures|stopped early/i.test(m);
+    const maxFailuresBail = runLevelErrors.some(isMaxFailuresBail);
+    // A top-level error normally means the run never really started (import/config
+    // error) → broken environment. The exception is a --max-failures bail ("stopped
+    // early after N maximum allowed failures"): the run DID start and these are real
+    // product-test failures (still PR signal), so a bail must NOT flip
+    // environmentHealthy — otherwise downstream env-health logic would discard the
+    // failures it stands for. Only a non-bail run-level error marks the env unhealthy.
+    const firstFatalError = runLevelErrors.find((m) => !isMaxFailuresBail(m));
+    if (firstFatalError) {
+        environmentHealthy = false;
+        healthDetail =
+            `Playwright reported a run-level error; the suite could not be collected or configured. ` +
+                `First: ${firstFatalError}`;
+    }
+    for (const { spec, file, describePath } of collected) {
+        const tests = spec.tests ?? [];
+        const multiProject = tests.length > 1;
+        for (const test of tests) {
+            const status = mapStatus(test);
+            const infra = isInfraSpec(test.projectName, file);
+            if (infra) {
+                // Setup/teardown failure = broken environment, not a product failure, so
+                // the first failing infra spec flips environmentHealthy and its cause
+                // ("global-setup failed") — more actionable than any generic run-level
+                // line — wins the healthDetail.
+                if (status === "fail" || status === "error") {
+                    if (!infraSpecFailed) {
+                        environmentHealthy = false;
+                        healthDetail = `Environment setup failed: "${spec.title}" (${file}) reported ${status}. Skipped tests are not PR signal.`;
+                    }
+                    infraSpecFailed = true;
+                }
+                continue; // never reported as a test result
+            }
+            const titlePath = [...describePath, spec.title].filter(Boolean).join(" › ");
+            const testId = `${file} › ${titlePath}` +
+                (multiProject && test.projectName ? ` [${test.projectName}]` : "");
+            const durationMs = test.results?.[test.results.length - 1]?.duration ?? 0;
+            results.push({
+                testId,
+                file,
+                status,
+                message: status === "fail" || status === "error" ? messageOf(test) : undefined,
+                durationMs,
+            });
+        }
+    }
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: {
+            ran: passed + failed + errored,
+            failed,
+            errored,
+            skipped,
+            truncated: opts?.truncated ?? false,
+        },
+        environmentHealthy,
+        healthDetail,
+        diagnostics: { runLevelErrors, infraSpecFailed, maxFailuresBail },
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Builds the argument list appended to a suite's `testRunCommand` (e.g.
+ * `npx playwright test`). Selectors are spec files, optionally `file::title`
+ * to also filter by test name. Forces the JSON reporter for machine-readable
+ * results and, in confirm mode, disables the failure cap so ALL breakages are
+ * counted (Ghost's config sets `maxFailures: 1`, which would otherwise stop at
+ * the first break).
+ */
+export function buildPlaywrightArgs(input) {
+    const files = [];
+    const titles = [];
+    for (const sel of input.selectors) {
+        const idx = sel.indexOf("::");
+        if (idx >= 0) {
+            const file = sel.slice(0, idx).trim();
+            const title = sel.slice(idx + 2).trim();
+            if (file && !files.includes(file))
+                files.push(file);
+            if (title)
+                titles.push(title);
+        }
+        else if (sel.trim() && !files.includes(sel.trim())) {
+            files.push(sel.trim());
+        }
+    }
+    const args = [...files, "--reporter=json"];
+    if (input.mode === "confirm")
+        args.push("--max-failures=0");
+    if (input.project)
+        args.push(`--project=${input.project}`);
+    if (titles.length > 0) {
+        args.push("--grep", titles.map(escapeRegex).join("|"));
+    }
+    return args;
+}

package/build/adapters/playwrightAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};