@skyramp/mcp 0.4.2 → 0.4.3-rc.2

package/build/recommendation/verifierContracts.d.ts

@@ -188,6 +188,14 @@ export declare const COVERAGE_CONTRACT: {
             readonly message: "No {kind} test cites this change, which is on the {surface}.";
             readonly suggestion: "Add a test on that surface that cites this change, or answer in one line why that surface needs no test.";
         };
+        readonly surfaceCase: {
+            readonly message: "This change is on the page and the API, and no ui or e2e test that cites it chooses `{case}` on the page.";
+            readonly suggestion: "Add a ui or e2e test, or a step in one, that chooses that value on the page and names it in the step, as in `Principal radio`, or answer in one line why the page cannot send it.";
+        };
+        readonly surfaceReject: {
+            readonly message: "This change is on the page and the API, and no ui or e2e test that cites it tries `{case}` on the page or checks that the page no longer offers it.";
+            readonly suggestion: "Add a ui or e2e test, or a step in one, that names that value in the step, as in `Intern radio absent`: try it and assert the page refuses it, or assert the page no longer offers it. If an existing UI spec already does this and this run edits it, declare it in `maintains` with its real path and name the value in `differsBy`. If this run cannot write the test, answer it and set `blocker` to what stopped the run; an answer with no blocker leaves this open.";
+        };
     };
     readonly suggestion: "Which planned test tests each behaviour this change promises and each file it touches, and for one nothing covers, why does it need none?";
 };
@@ -255,8 +263,16 @@ export declare const REQUIREMENT_SOURCED_CONTRACT: {
             readonly suggestion: "Cite a change you read in the pull request or in a requirements file, or report this test as something other than a requirement conflict.";
         };
         readonly notNamed: {
-            readonly message: "Change `{change}` cites `{source}`, and the pull request names no such file.";
-            readonly suggestion: "Cite a file the title or description names. If neither names it, you read the change in the repository, so set `source` to `diff`.";
+            readonly message: "Change `{change}` cites `{source}`, and the pull request neither names nor changes such a file.";
+            readonly suggestion: "Cite a file the title or description names, or one the diff changes. If none does, you read the change in the repository, so set `source` to `diff`.";
+        };
+        readonly itemUnlinked: {
+            readonly message: "`{source}` lists item {number}, \"{item}\", and no change in this plan names it.";
+            readonly suggestion: "Set `source` to `{source}#{number}` on the change that covers this item, or answer with the reason it needs no test.";
+        };
+        readonly unnumbered: {
+            readonly message: "`{source}` lists {count} items, and no change names one of them by its number.";
+            readonly suggestion: "Name the item each change covers in its source, as `{source}#<number>` (`#7,8` for two), so each item can be checked.";
         };
         readonly emptyPullRequest: {
             readonly message: "Change `{change}` says it was read from the pull request, and the pull request has no title or description.";
@@ -307,6 +323,20 @@ export declare const DEFECTS_CONTRACT: {
     };
     readonly suggestion: "Which planned test proves each defect the review found, and for one nothing proves, why does it need no test?";
 };
+export declare const CHANGED_LINES_CLAIMED_CONTRACT: {
+    readonly id: "changedLinesClaimed";
+    readonly objections: {
+        readonly unclaimed: {
+            readonly message: "These changed lines are in a file a planned test covers, and no change in the plan names them in its `lines`.";
+            readonly suggestion: "Add these lines to the `lines` of the change they belong to, or declare a change for them, with a case that states what a test must see. If the lines change nothing a test can observe, say so as the answer.";
+        };
+        readonly noCase: {
+            readonly message: "These changed lines belong to a change that states no case, so no test is held to what they do.";
+            readonly suggestion: "Give the change a case whose `expectedValue` or `derived` states what a test must see after these lines. If the lines change nothing a test can observe, say so as the answer.";
+        };
+    };
+    readonly suggestion: "Which change owns each run of changed lines in a tested file, and what must a test see because of it?";
+};
 /** Fills a contract sentence's `{placeholder}` spans from the run's or the
  *  planned test's own values. A placeholder with no value is left as written rather
  *  than blanked, so a missed key shows up as `{knob}` instead of reading as a gap

package/build/recommendation/verifierContracts.js

@@ -202,6 +202,19 @@ export const COVERAGE_CONTRACT = {
             message: "No {kind} test cites this change, which is on the {surface}.",
             suggestion: "Add a test on that surface that cites this change, or answer in one line why that surface needs no test.",
         },
+        // `{case}` is the rendered case, as in `level="Principal" (accept)`. SKYR-4529: a form offered Lead and Principal, and
+        // only an API test sent Principal.
+        surfaceCase: {
+            message: "This change is on the page and the API, and no ui or e2e test that cites it chooses `{case}` on the page.",
+            suggestion: "Add a ui or e2e test, or a step in one, that chooses that value on the page and names it in the step, as in `Principal radio`, or answer in one line why the page cannot send it.",
+        },
+        // `{case}` is the rendered case, as in `level="Principal" (accept)`. The XR02 run removed Intern from a form; the page
+        // objection closed by a sentence, and no generated test checked the option was
+        // gone.
+        surfaceReject: {
+            message: "This change is on the page and the API, and no ui or e2e test that cites it tries `{case}` on the page or checks that the page no longer offers it.",
+            suggestion: "Add a ui or e2e test, or a step in one, that names that value in the step, as in `Intern radio absent`: try it and assert the page refuses it, or assert the page no longer offers it. If an existing UI spec already does this and this run edits it, declare it in `maintains` with its real path and name the value in `differsBy`. If this run cannot write the test, answer it and set `blocker` to what stopped the run; an answer with no blocker leaves this open.",
+        },
     },
     suggestion: "Which planned test tests each behaviour this change promises and each file it touches, and for one nothing covers, why does it need none?",
 };
@@ -305,11 +318,25 @@ export const REQUIREMENT_SOURCED_CONTRACT = {
             suggestion: "Cite a change you read in the pull request or in a requirements file, or report this test as something other than a requirement conflict.",
         },
         // The server rendered the prompt, so it holds the title and description the run
-        // was given. A requirements file the pull request never names is a file the agent
-        // found by looking, which is reading the repository, not reading a requirement.
+        // was given, and it holds the diff. A requirements file the pull request neither
+        // names nor changes is a file the agent found by looking, which is reading the
+        // repository, not reading a requirement.
         notNamed: {
-            message: "Change `{change}` cites `{source}`, and the pull request names no such file.",
-            suggestion: "Cite a file the title or description names. If neither names it, you read the change in the repository, so set `source` to `diff`.",
+            message: "Change `{change}` cites `{source}`, and the pull request neither names nor changes such a file.",
+            suggestion: "Cite a file the title or description names, or one the diff changes. If none does, you read the change in the repository, so set `source` to `diff`.",
+        },
+        // `{item}` is one top-level list line of the cited file or the description,
+        // `{number}` its number, `{source}` that source as the first change citing it
+        // spelled it, without its `#` anchor. The check
+        // reads only whether some change names the number, not whether a test covers it.
+        itemUnlinked: {
+            message: '`{source}` lists item {number}, "{item}", and no change in this plan names it.',
+            suggestion: "Set `source` to `{source}#{number}` on the change that covers this item, or answer with the reason it needs no test.",
+        },
+        // `{count}` is the number of top-level list items in `{source}`.
+        unnumbered: {
+            message: "`{source}` lists {count} items, and no change names one of them by its number.",
+            suggestion: "Name the item each change covers in its source, as `{source}#<number>` (`#7,8` for two), so each item can be checked.",
         },
         // Says only what was read: this pull request arrived with no words in it.
         emptyPullRequest: {
@@ -368,6 +395,20 @@ export const DEFECTS_CONTRACT = {
     },
     suggestion: "Which planned test proves each defect the review found, and for one nothing proves, why does it need no test?",
 };
+export const CHANGED_LINES_CLAIMED_CONTRACT = {
+    id: "changedLinesClaimed",
+    objections: {
+        unclaimed: {
+            message: "These changed lines are in a file a planned test covers, and no change in the plan names them in its `lines`.",
+            suggestion: "Add these lines to the `lines` of the change they belong to, or declare a change for them, with a case that states what a test must see. If the lines change nothing a test can observe, say so as the answer.",
+        },
+        noCase: {
+            message: "These changed lines belong to a change that states no case, so no test is held to what they do.",
+            suggestion: "Give the change a case whose `expectedValue` or `derived` states what a test must see after these lines. If the lines change nothing a test can observe, say so as the answer.",
+        },
+    },
+    suggestion: "Which change owns each run of changed lines in a tested file, and what must a test see because of it?",
+};
 /** Fills a contract sentence's `{placeholder}` spans from the run's or the
  *  planned test's own values. A placeholder with no value is left as written rather
  *  than blanked, so a missed key shows up as `{knob}` instead of reading as a gap

package/build/recommendation/verifiers/changedLinesClaimed.d.ts

@@ -0,0 +1,17 @@
+import { PlanChange, PlanInput, Verifier, VerifyContext } from "../types.js";
+import type { ChangedRun } from "../../utils/changedRuns.js";
+/** Whether a change's `lines` reach this run. Any overlap counts: a run that the
+ *  claimed range touches is the change's to answer for. */
+export declare function changeCoversRun(change: PlanChange, run: ChangedRun): boolean;
+/** The changed runs in files a planned test names as its changed file, each with
+ *  the changes that can claim it: a change counts in the repositories of the tests
+ *  that cite it, and in every repository when no test cites it. */
+export declare function runsInTestedFiles(registration: PlanInput, ctx: VerifyContext): Array<{
+    repository: string;
+    run: ChangedRun;
+    changes: PlanChange[];
+}>;
+/** Every changed run in a file a planned test covers belongs to a change that
+ *  states what a test must see. The server reads which lines changed; the agent
+ *  says what they do. One objection per run. */
+export declare const changedLinesClaimed: Verifier;

package/build/recommendation/verifiers/changedLinesClaimed.js

@@ -0,0 +1,88 @@
+import { normalizeCitedPath } from "./citedPath.js";
+import { CHANGED_LINES_CLAIMED_CONTRACT as CONTRACT } from "../verifierContracts.js";
+/** One `lines` entry read as a file and a line range: `path:12` or `path:12-20`. */
+function readLines(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const match = /^(.+):(\d+)(?:-(\d+))?$/.exec(raw.trim());
+    if (!match)
+        return undefined;
+    const file = normalizeCitedPath(match[1]);
+    const start = Number(match[2]);
+    const end = match[3] === undefined ? start : Number(match[3]);
+    return file && end >= start ? { file, start, end } : undefined;
+}
+/** Whether a change's `lines` reach this run. Any overlap counts: a run that the
+ *  claimed range touches is the change's to answer for. */
+export function changeCoversRun(change, run) {
+    const lines = Array.isArray(change?.lines) ? change.lines : [];
+    return lines.some((raw) => {
+        const range = readLines(raw);
+        return (range !== undefined &&
+            range.file === run.file &&
+            range.start <= run.end &&
+            range.end >= run.start);
+    });
+}
+/** Whether a change states what its test must see: some case carries an
+ *  `expectedValue` or a `derived` rule. */
+function statesAnOutput(change) {
+    return (change.testCases ?? []).some((entry) => entry &&
+        (entry.expectedValue !== undefined ||
+            String(entry.derived ?? "").trim().length > 0));
+}
+/** The changed runs in files a planned test names as its changed file, each with
+ *  the changes that can claim it: a change counts in the repositories of the tests
+ *  that cite it, and in every repository when no test cites it. */
+export function runsInTestedFiles(registration, ctx) {
+    const touched = new Set();
+    const citedIn = new Map();
+    for (const plannedTest of registration.plannedTests) {
+        const file = normalizeCitedPath(plannedTest.declarations.changedFile);
+        if (file)
+            touched.add(`${plannedTest.repository}\u0000${file}`);
+        for (const id of plannedTest.declarations.changes ?? []) {
+            const key = String(id ?? "").trim();
+            if (!citedIn.has(key))
+                citedIn.set(key, new Set());
+            citedIn.get(key)?.add(plannedTest.repository);
+        }
+    }
+    return Object.entries(ctx.changedRuns).flatMap(([repository, runs]) => runs
+        .filter((run) => touched.has(`${repository}\u0000${run.file}`))
+        .map((run) => ({
+        repository,
+        run,
+        changes: registration.changes.filter((change) => {
+            const repos = citedIn.get(String(change.id ?? "").trim());
+            return ((!repos || repos.has(repository)) && changeCoversRun(change, run));
+        }),
+    })));
+}
+/** Every changed run in a file a planned test covers belongs to a change that
+ *  states what a test must see. The server reads which lines changed; the agent
+ *  says what they do. One objection per run. */
+export const changedLinesClaimed = {
+    name: "changedLinesClaimed",
+    run(registration, ctx) {
+        const objections = [];
+        for (const { repository, run, changes } of runsInTestedFiles(registration, ctx)) {
+            if (changes.some(statesAnOutput))
+                continue;
+            const kind = changes.length === 0 ? "unclaimed" : "noCase";
+            const where = `${run.file}:${run.start}${run.end > run.start ? `-${run.end}` : ""}`;
+            objections.push({
+                objectionId: `changedLinesClaimed:${kind}:${repository}/${run.file}:${run.start}`,
+                verifier: "changedLinesClaimed",
+                message: CONTRACT.objections[kind].message,
+                evidence: kind === "unclaimed"
+                    ? `${repository} ${where} (\`${run.firstLine.trim().slice(0, 120)}\`): no change's \`lines\` covers it`
+                    : `${repository} ${where} (\`${run.firstLine.trim().slice(0, 120)}\`): covered by ${changes
+                        .map((change) => String(change.id ?? "?"))
+                        .join(", ")}, and none of them has a case with \`expectedValue\` or \`derived\``,
+                suggestion: CONTRACT.objections[kind].suggestion,
+            });
+        }
+        return objections;
+    },
+};

package/build/recommendation/verifiers/coverage.js

@@ -5,6 +5,7 @@ import { isTestPath } from "../../utils/testFileClassification.js";
 import { maintainedFileIsInItsRepository, normalizeCitedPath, } from "./citedPath.js";
 import { COVERAGE_CONTRACT, fillPlaceholders } from "../verifierContracts.js";
 import { isUIPlannedTest, stateRouteKey, subjectStep } from "../subjectStep.js";
+import { normalizeStepMethod } from "../../types/StepMethod.js";
 /** Whether a path can be product code at all, by the deny list route grounding
  *  already applies to a cited file. Nothing else is excluded: a file's kind is
  *  not this check's judgment to make. */
@@ -640,9 +641,6 @@ function rejectObjections(registration) {
     }
     return objections;
 }
-// ── The surface a change is on ──────────────────────────────────────────────
-/** The test types that reach each surface. An `e2e` test drives the page AND the
- *  requests behind it, so it counts for both. */
 const TEST_TYPES_FOR = {
     api: {
         types: new Set(["contract", "integration", "e2e"]),
@@ -658,7 +656,7 @@ function declaredSurfaces(change) {
         return [];
     return [
         ...new Set(named.map((surface) => String(surface ?? "").trim())),
-    ].filter((surface) => surface in TEST_TYPES_FOR);
+    ].filter((surface) => Object.hasOwn(TEST_TYPES_FOR, surface));
 }
 /** A change on a page needs a test that opens the page, and a change on the API
  *  needs one that calls it. Run 34065056830 cited a page change from an API test
@@ -698,6 +696,146 @@ function surfaceObjections(registration) {
     }
     return objections;
 }
+/** Whether `text` names `value` as a whole word, ignoring case. Letters in any
+ *  script: an ASCII boundary found "Gr" in "Größe". */
+function namesWord(text, value) {
+    const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])`, "iu").test(text);
+}
+/** An `absent` case names no value, so it draws no page objection. */
+function pageObjectionKind(testCase) {
+    if (testCase.absent === true)
+        return undefined;
+    if (testCase.expect === "accept")
+        return "surfaceCase";
+    if (testCase.expect === "reject")
+        return "surfaceReject";
+    return undefined;
+}
+/** The value as a UI step would spell it, or undefined when no step can: a number,
+ *  a boolean, text with no letter and a `{placeholder}` are never spelled in a step,
+ *  and a page chooses no HTTP verb. */
+function valueAPageSpells(testCase) {
+    const param = testCase.param.trim();
+    const value = testCase.value;
+    if (!param || param.toLowerCase() === METHOD_PARAM)
+        return undefined;
+    if (typeof value !== "string")
+        return undefined;
+    const word = value.trim();
+    if (!/\p{L}/u.test(word))
+        return undefined;
+    if (/^(true|false)$/i.test(word) || PLACEHOLDER_VALUE.test(word))
+        return undefined;
+    return word;
+}
+/** The page steps that choose a value. An `assert` that the radio is visible
+ *  chose nothing: the XR02 run passed Principal on one, and no test saved at it.
+ *  An e2e test's HTTP step is not the page either. */
+const CHOOSING_VERBS = new Set([
+    "click",
+    "type",
+    "press",
+    "tap",
+]);
+/** A refused value is also met by asserting the page no longer offers it. */
+const REFUSING_VERBS = new Set([
+    ...CHOOSING_VERBS,
+    "assert",
+]);
+/** The text that can name a value on the page: the steps of the UI tests whose verb
+ *  is in `verbs`, and the edit note of each maintained spec, which is prose with no
+ *  verb to read. */
+function pageTexts(uiTests, maintained, verbs) {
+    return [
+        ...uiTests.flatMap((plannedTest) => plannedTest.scenario.steps
+            .filter((step) => verbs.has(normalizeStepMethod(step.method) ?? ""))
+            .flatMap((step) => [step.path, step.description ?? ""])),
+        ...maintained.map((entry) => entry.differsBy),
+    ];
+}
+/** A change on the page AND the API needs each accepted value chosen on the page,
+ *  and each refused value tried or shown absent there, not only sent by an API
+ *  test. `surfaceObjections` passes the page once any UI test cites the change,
+ *  whatever value it picks. A UI step is free text (`Senior radio`), so the check
+ *  reads whether a page step of a citing ui or e2e test that chooses the value (or,
+ *  for a refused one, asserts it), or the `differsBy` of a citing maintained spec,
+ *  names the value.
+ *
+ *  A refused value takes a test, a resolving maintained spec, or a blocker, never a
+ *  sentence: in the XR02 run the page objection for a removed option closed by
+ *  prose, and only an existing spec checked that the option was gone. */
+function surfaceCaseObjections(registration, ctx) {
+    const objections = [];
+    const seen = new Set();
+    const pageTypes = TEST_TYPES_FOR.page.types;
+    for (const change of registration.changes) {
+        const id = change.id.trim();
+        const surfaces = declaredSurfaces(change);
+        if (!id || !surfaces.includes("page") || !surfaces.includes("api"))
+            continue;
+        const uiTests = registration.plannedTests.filter((plannedTest) => citesChange(plannedTest, id) &&
+            pageTypes.has(plannedTest.scenario.testType.toLowerCase()));
+        // A maintained spec counts only when its file resolves, the bar
+        // `citedBehaviors` sets: the refused half closes by no sentence, so a note on a
+        // file nobody can open must not close it either.
+        const maintained = (registration.maintains ?? []).filter((entry) => entry.changes.some((cited) => cited.trim() === id) &&
+            maintainedFileIsInItsRepository(entry, ctx));
+        const citedAtAll = maintained.length > 0 ||
+            registration.plannedTests.some((plannedTest) => citesChange(plannedTest, id));
+        const texts = {
+            surfaceCase: pageTexts(uiTests, maintained, CHOOSING_VERBS),
+            surfaceReject: pageTexts(uiTests, maintained, REFUSING_VERBS),
+        };
+        for (const testCase of change.testCases ?? []) {
+            const kind = pageObjectionKind(testCase);
+            // An accepted value with no UI test and no maintained spec already draws
+            // `coverage:surface:<id>:page`, and a second objection would need a second
+            // answer for one gap. A maintained spec alone does not stop that objection,
+            // but a sentence citing the spec closed it while a value went untried, so the
+            // value is checked then. A refused value is always checked: that sentence is
+            // the gap. A change nothing cites draws `coverage:change:<id>`.
+            if (!kind || !citedAtAll)
+                continue;
+            if (kind === "surfaceCase" &&
+                uiTests.length === 0 &&
+                maintained.length === 0)
+                continue;
+            const word = valueAPageSpells(testCase);
+            if (word === undefined)
+                continue;
+            if (texts[kind].some((text) => namesWord(text, word)))
+                continue;
+            const rendered = renderTestCase({
+                ...testCase,
+                param: testCase.param.trim(),
+                value: word,
+            });
+            const objectionId = `coverage:${kind}:${id}:page:${rendered}`;
+            // One step closes `Intern` and `intern` alike, so they are one objection.
+            const key = objectionId.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const citers = [
+                ...uiTests.map((plannedTest) => plannedTest.plannedTestId),
+                ...maintained.map((entry) => entry.file),
+            ];
+            objections.push({
+                objectionId,
+                verifier: "coverage",
+                message: fillPlaceholders(COVERAGE_CONTRACT.objections[kind].message, {
+                    case: rendered,
+                }),
+                evidence: citers.length === 0
+                    ? `No ui or e2e test or maintained spec cites ${id}.`
+                    : `${citers.join(", ")} cite ${id}; no step or maintained edit of theirs names ${word}.`,
+                suggestion: COVERAGE_CONTRACT.objections[kind].suggestion,
+            });
+        }
+    }
+    return objections;
+}
 /** One repository's changed files, and the name to attribute uncovered ones to.
  *  Keying the objection id on the path alone let two repositories that each change
  *  `src/App.tsx` share one id, so every id names its repository. */
@@ -759,6 +897,7 @@ export const coverage = {
             ...testCaseObjections(registration),
             ...rejectObjections(registration),
             ...surfaceObjections(registration),
+            ...surfaceCaseObjections(registration, ctx),
         ];
         if (allChangedFiles(ctx).length === 0)
             return objections;

package/build/recommendation/verifiers/expectedValueSourced.js

@@ -4,6 +4,7 @@ import { EXPECTED_VALUE_SOURCED_CONTRACT as CONTRACT } from "../verifierContract
 import { appearsIn, searchable } from "../pullRequestText.js";
 import { escapeRegExp } from "../../utils/regex.js";
 import { renderTestCase } from "./coverage.js";
+import { runsInTestedFiles } from "./changedLinesClaimed.js";
 function readSource(raw) {
     const source = typeof raw === "string" ? raw.trim() : "";
     if (source.length === 0)
@@ -119,6 +120,8 @@ export const expectedValueSourced = {
         const changed = changedPathSet(allChangedFiles(ctx), true);
         const prText = searchable(ctx.pullRequest);
         const raised = new Set();
+        // The changes that own a changed run in a file a planned test covers.
+        const owners = new Set(runsInTestedFiles(registration, ctx).flatMap(({ changes }) => changes));
         const changes = registration.changes;
         for (const change of changes) {
             const changeId = String(change.id ?? "?");
@@ -170,6 +173,11 @@ export const expectedValueSourced = {
                     raise("unsourced", CONTRACT.objections.missingSource, `expected value with no usable \`expectedFrom\`: ${where}`);
                 }
                 else if (source.kind === "code") {
+                    // A change read from the diff that names its changed lines has no other
+                    // source: no requirement exists for the code to disagree with.
+                    if (/^diff$/i.test(String(change.source ?? "").trim()) &&
+                        owners.has(change))
+                        return;
                     raise("code", CONTRACT.objections.sourcedFromCode, 
                     // A derived-only case pins no value, so quoting one read `expected
                     // undefined` — a sentence naming nothing the agent can act on.