@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/build/adapters/playwrightAdapter.js

@@ -1,182 +0,0 @@
-/**
- * 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/pytestAdapter.d.ts

@@ -1,15 +0,0 @@
-import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
-export declare function parsePytestJson(report: unknown, opts?: {
-    truncated?: boolean;
-}): ParsedExternalRun;
-/**
- * Builds the args appended to the suite's `testRunCommand` (e.g. `pytest`).
- * Selectors are pytest nodeids (`file.py::Class::test`) and pass through as
- * positional args — `file::test` IS a nodeid, so no separate name filter is
- * needed. Forces the json-report reporter to the given path.
- */
-export declare function buildPytestArgs(input: {
-    selectors: string[];
-    mode: "confirm" | "verify" | "probe";
-    reportPath: string;
-}): string[];

package/build/adapters/pytestAdapter.js

@@ -1,108 +0,0 @@
-/**
- * pytest adapter for skyramp_run_existing_tests. Normalizes the
- * `pytest-json-report` (`--json-report`) output into the neutral result shape.
- * Native JSON (not junit): preserves the real nodeid and pytest's explicit
- * passed/failed/error/skipped, so a fixture/collection error stays distinct from
- * an assertion failure.
- */
-import { stripVTControlCharacters } from "util";
-function mapOutcome(outcome) {
-    switch (outcome) {
-        case "passed":
-        case "xpassed":
-            return "pass";
-        case "failed":
-            return "fail";
-        case "error":
-            return "error";
-        case "skipped":
-        case "xfailed":
-            return "skipped";
-        default:
-            return outcome ? "error" : "skipped";
-    }
-}
-function fileOf(nodeid) {
-    const idx = nodeid.indexOf("::");
-    return idx >= 0 ? nodeid.slice(0, idx) : nodeid;
-}
-function messageOf(test) {
-    const raw = test.call?.longrepr ?? test.setup?.longrepr ?? test.teardown?.longrepr;
-    if (!raw)
-        return undefined;
-    return stripVTControlCharacters(raw).trim() || undefined;
-}
-function durationMsOf(test) {
-    const secs = (test.setup?.duration ?? 0) + (test.call?.duration ?? 0) + (test.teardown?.duration ?? 0);
-    return Math.round(secs * 1000);
-}
-export function parsePytestJson(report, opts) {
-    const rep = (report ?? {});
-    const tests = rep.tests ?? [];
-    // Real test outcomes.
-    const testResults = tests.map((t) => {
-        const status = mapOutcome(t.outcome);
-        const nodeid = t.nodeid ?? "(unknown)";
-        return {
-            testId: nodeid,
-            file: fileOf(nodeid),
-            status,
-            message: status === "fail" || status === "error" ? messageOf(t) : undefined,
-            durationMs: durationMsOf(t),
-        };
-    });
-    const collectionErrors = (rep.collectors ?? []).filter((c) => c.outcome === "error" || c.outcome === "failed");
-    const lastLine = (raw) => stripVTControlCharacters(raw ?? "collection error").split("\n").filter(Boolean).slice(-1)[0] ?? "collection error";
-    // Surface each collection/import error as an errored result so a broken file is
-    // never invisible — regardless of whether other selected files ran. A collection
-    // error IS a real breakage (PR signal), counted in `errored`/`ran`.
-    const collectionResults = collectionErrors.map((c) => {
-        const nodeid = c.nodeid ?? "(collection)";
-        return {
-            testId: `${nodeid} › (collection error)`,
-            file: fileOf(nodeid),
-            status: "error",
-            message: lastLine(c.longrepr),
-            durationMs: 0,
-        };
-    });
-    const results = [...testResults, ...collectionResults];
-    let environmentHealthy = true;
-    let healthDetail;
-    // When collection failed AND no real test ran, the suite as a whole could not be
-    // collected — environmental (a wall of red), not PR signal. When some real tests
-    // DID run, the collection errors above stand as ordinary PR-signal error results.
-    if (collectionErrors.length > 0 && testResults.length === 0) {
-        environmentHealthy = false;
-        const first = collectionErrors[0];
-        healthDetail = `pytest could not collect the suite: ${collectionErrors.length} collection error(s). First (${first.nodeid ?? "?"}): ${lastLine(first.longrepr)}`;
-    }
-    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: collectionErrors.map((c) => lastLine(c.longrepr)),
-            infraSpecFailed: false,
-            maxFailuresBail: false,
-        },
-    };
-}
-/**
- * Builds the args appended to the suite's `testRunCommand` (e.g. `pytest`).
- * Selectors are pytest nodeids (`file.py::Class::test`) and pass through as
- * positional args — `file::test` IS a nodeid, so no separate name filter is
- * needed. Forces the json-report reporter to the given path.
- */
-export function buildPytestArgs(input) {
-    const args = input.selectors.map((s) => s.trim()).filter(Boolean);
-    args.push("--json-report", `--json-report-file=${input.reportPath}`);
-    if (input.mode === "probe")
-        args.push("--maxfail=1");
-    return args;
-}

package/build/prompts/enhance-assertions/contractProviderAssertionsPrompt.d.ts

@@ -1,2 +0,0 @@
-import { EnhanceType } from "./sharedAssertionRules.js";
-export declare function getContractProviderAssertionsPrompt(testFile: string, enhanceType: EnhanceType): string;

package/build/prompts/enhance-assertions/contractProviderAssertionsPrompt.js

@@ -1,29 +0,0 @@
-import { getAssertionsPrompt, } from "./sharedAssertionRules.js";
-const specificRules = [
-    {
-        title: "Chained values from inline request data",
-        description: "Every value used in an assertion must come from what is written inline in the test function — the request body, path, or query parameters.",
-        subPoints: [
-            "Do not reference data set up in `beforeAll` or any other setup helper.",
-            "When an ID was sent in the request body, path, or query, assert its exact value in the response. Since the sent value is already known, asserting only that it is non-null is not sufficient.",
-            "Reserve `is not None` / `not.toBeNull()` for server-generated IDs only.",
-            "Apply the same rule to all other fields and to array items: use inline request body values as the expected values, not setup helper data.",
-            "The behaviour this test claims must be proven from `expected_response_body`, the inline request body, or path/query literals — do not rely on the integration test to cover it.",
-        ],
-        examples: [
-            {
-                language: "javascript",
-                code: `expect(getResponseValue(productGetResponse, "id"), 'id').toBe(getResponseValue(productsPostResponse, "id"));`,
-            },
-        ],
-    },
-];
-const SCOPE = `### Scope
-- Only modify test functions — do not touch \`beforeAll\`, \`afterAll\`, or any setup or teardown helper.
-- Only add assertions clearly supported by \`expected_response_body\`, inline request / path / query literals, codebase evidence, or the test generation recommendations received for this test. Do not invent constraints.
-- A response no behaviour in this file depends on needs its status code and nothing more.
-- Add new assertions immediately after the existing status-code assertion — do not move or remove anything.
-- Do not reference \`beforeAll\` / \`afterAll\` provisioning data in any assertion — every assertion value must come from the inline request body, path, query, prior response, or \`expected_response_body\`.`;
-export function getContractProviderAssertionsPrompt(testFile, enhanceType) {
-    return getAssertionsPrompt(specificRules, SCOPE, testFile, enhanceType);
-}

package/build/prompts/enhance-assertions/integrationAssertionsPrompt.d.ts

@@ -1,2 +0,0 @@
-import { EnhanceType } from "./sharedAssertionRules.js";
-export declare function getIntegrationAssertionsPrompt(testFile: string, enhanceType: EnhanceType): string;

package/build/prompts/enhance-assertions/integrationAssertionsPrompt.js

@@ -1,36 +0,0 @@
-import { getAssertionsPrompt, } from "./sharedAssertionRules.js";
-const specificRules = [
-    {
-        title: "Chained values across steps — chain, never hardcode",
-        description: "Every ID used in a later step must come from a prior step's response using the SDK helper — never hardcode an ID or declare it as a constant before the response that provides it.",
-        subPoints: [
-            "After a POST creates a resource, GET and PATCH steps should assert that the returned ID matches the one from the POST response.",
-            "When a non-ID response value (such as a collection name, slug, or timestamp) is reused in a later request, extract it from the prior response instead of hardcoding it.",
-            "After any POST, PATCH, DELETE, sort, reorder, or bulk operation, re-assert the chained, stable, and computed values on the follow-up read step: a follow-up GET after DELETE should return 404 or show the item absent; a follow-up GET after PATCH should assert the new value; a follow-up GET after sort/reorder should confirm the new ordering with chained IDs.",
-            "After a POST creates a resource and a GET retrieves the collection, assert that the created item appears in the list by its chained ID with its exact stable fields — do not stop at a null-check on the array or the id alone.",
-            "When one response field describes a count or summary of a collection returned by a related endpoint (for example, `active_session_count` from `/users/me` and the array length from `/users/me/sessions`), assert that relationship by comparing both extracted values — never hardcode the same number in two places.",
-            'A state change the test is for ("Updates X", "Increments Y" — from the recommendation it came from, or from the test name when that name says more than `test_integration`) must be proven across the calls that carry it — do not rely on the contract test to cover it.',
-        ],
-        examples: [
-            {
-                language: "javascript",
-                code: `expect(getResponseValue(productGetResponse, "id"), 'id').toBe(getResponseValue(productsPostResponse, "id"));
-const collection = getValue(collectionsPostResponse, "data.collection");
-expect(getValue(sessionsResponse, "data").length).toBe(getValue(meResponse, "data.active_session_count"));`,
-            },
-            {
-                language: "javascript",
-                code: `const orderId = getResponseValue(ordersPostResponse, "id");
-await skyramp.sendRequest(\`/orders/\${orderId}\`);`,
-            },
-        ],
-    },
-];
-const SCOPE = `### Scope
-- Apply to every \`send_request\` / \`sendRequest\` call that returns a body.
-- Only add assertions clearly supported by the request body, prior response values, field names, codebase evidence, or the test generation recommendations received for this test. Do not invent constraints.
-- A response no behaviour in this file depends on needs its status code and nothing more.
-- Add new assertions immediately after the existing status-code assertion — do not move or remove anything.`;
-export function getIntegrationAssertionsPrompt(testFile, enhanceType) {
-    return getAssertionsPrompt(specificRules, SCOPE, testFile, enhanceType);
-}

package/build/prompts/enhance-assertions/sharedAssertionRules.d.ts

@@ -1,16 +0,0 @@
-export type EnhanceType = "generation" | "maintenance";
-export declare const MAINTENANCE_SCOPE_NOTE = "Apply only to new test functions you are adding and existing test functions affected by changes in the diff. Do NOT modify test functions unrelated to the diff. A test function you do touch is held to the same standard as a new one: the behaviour the diff changed must be asserted by its exact value there too, so an existing `is not None` on a field the diff gives a knowable value becomes that value.";
-export declare function maintenanceTaskSuffix(enhanceType: EnhanceType): string;
-export interface AssertionEnrichmentExample {
-    language: string;
-    code: string;
-}
-export interface AssertionEnrichmentRule {
-    title: string;
-    description: string;
-    subPoints?: string[];
-    examples: AssertionEnrichmentExample[];
-}
-export declare function renderRule(index: number, rule: AssertionEnrichmentRule): string;
-export declare function renderSharedAssertionRules(): string;
-export declare function getAssertionsPrompt(specificRules: AssertionEnrichmentRule[], scope: string, testFile: string, enhanceType: EnhanceType): string;