@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/recommendation/verifiers/defects.js

@@ -1,27 +1,29 @@
 import { normalizeCategory } from "../../types/TestRecommendation.js";
+import { maintainedFileIsInItsRepository } from "./citedPath.js";
 import { DEFECTS_CONTRACT } from "../verifierContracts.js";
 /** A defect id as the plan spells it: trimmed, and exact otherwise. */
 function idKey(raw) {
-    return typeof raw === "string" ? raw.trim() : "";
+    return raw.trim();
 }
-/** The defect ids one planned test cites, trimmed and without repeats. Read
- *  defensively: the plan comes off disk, so the array type holds only on the
- *  validated path, and a throw here would hide every other objection. */
+/** The defect ids one planned test cites, trimmed and without repeats. */
 function citedDefects(plannedTest) {
-    const declared = plannedTest?.declarations?.defects;
-    if (!Array.isArray(declared))
-        return [];
+    const declared = plannedTest.declarations.defects ?? [];
     return [...new Set(declared.map(idKey))].filter(Boolean);
 }
+/** The defect ids one maintenance entry proves, trimmed and without repeats. The
+ *  schema requires the list, so it is always an array. */
+function maintainedDefects(entry) {
+    return [...new Set(entry.defects.map(idKey))].filter(Boolean);
+}
 /** Whether a planned test expects to fail. Undeclared reads as not failing: a test
  *  that says nothing about its outcome proves nothing about a defect either. */
 function expectsToFail(plannedTest) {
-    return plannedTest?.declarations?.expected?.outcome === "fail";
+    return plannedTest.declarations.expected?.outcome === "fail";
 }
 /** Where the defect sits, as the objection quotes it. */
 function locate(defect) {
-    const file = String(defect?.file ?? "").trim() || "no file";
-    return typeof defect?.line === "number" ? `${file}:${defect.line}` : file;
+    const file = String(defect.file ?? "").trim() || "no file";
+    return typeof defect.line === "number" ? `${file}:${defect.line}` : file;
 }
 /** Every declared defect needs one planned test that cites it and expects to fail,
  *  or an answer. Read off the PLAN alone, like the behaviour half of coverage: the
@@ -32,9 +34,19 @@ function locate(defect) {
  *  `issuesFound`, which exists at report time, after every test is generated. */
 export const defects = {
     name: "defects",
-    run(registration, _ctx) {
-        const declared = (Array.isArray(registration.defects) ? registration.defects : []).filter((defect) => idKey(defect?.id).length > 0);
-        const plannedTests = registration.plannedTests ?? [];
+    run(registration, ctx) {
+        const declared = registration.defects.filter((defect) => idKey(defect.id).length > 0);
+        const plannedTests = registration.plannedTests;
+        const maintains = registration.maintains ?? [];
+        // The defects the run proves by editing an existing test instead of planning a
+        // new one. Only from an entry whose file is in the repository it names.
+        const maintainedProof = new Set();
+        for (const entry of maintains) {
+            if (!maintainedFileIsInItsRepository(entry, ctx))
+                continue;
+            for (const id of maintainedDefects(entry))
+                maintainedProof.add(id);
+        }
         const objections = [];
         // An empty list is its own objection and NOT an early return: a plan that
         // declares nothing can still cite `D1` from a planned test, and that citation
@@ -57,6 +69,10 @@ export const defects = {
                 continue;
             seen.add(id);
             const citing = plannedTests.filter((plannedTest) => citedDefects(plannedTest).includes(id));
+            // A maintained spec is green after its edit, so the outcome rule below is for
+            // planned tests alone.
+            if (citing.length === 0 && maintainedProof.has(id))
+                continue;
             if (citing.length === 0) {
                 objections.push({
                     // Keyed on the defect's id, not its position: the agent reorders the
@@ -95,18 +111,42 @@ export const defects = {
                 });
             }
         }
+        // The maintenance mirror of `unknownId`, keyed on the file: two entries may name
+        // one file, and the agent answers a file once.
+        const unknownByFile = new Map();
+        for (const entry of maintains) {
+            const key = idKey(entry.file) || "unnamed";
+            for (const id of maintainedDefects(entry)) {
+                if (known.has(id))
+                    continue;
+                const unknown = unknownByFile.get(key) ?? [];
+                if (!unknown.includes(id))
+                    unknown.push(id);
+                unknownByFile.set(key, unknown);
+            }
+        }
+        for (const [key, unknown] of unknownByFile) {
+            objections.push({
+                objectionId: `defects:maintains:unknownDefect:${key}`,
+                verifier: "defects",
+                message: DEFECTS_CONTRACT.objections.maintainedUnknownDefect.message,
+                evidence: `${key === "unnamed" ? "an unnamed `maintains` entry" : key} cites ${unknown.map((id) => `"${id}"`).join(", ")}; this plan declares ${known.size > 0 ? [...known].map((declaredId) => `"${declaredId}"`).join(", ") : "no defects"}.`,
+                suggestion: DEFECTS_CONTRACT.objections.maintainedUnknownDefect.suggestion,
+            });
+        }
         // A requirement the code does not meet is a defect, and that defect's `file` is
         // the code that contradicts the requirement.
         for (const plannedTest of plannedTests) {
-            if (normalizeCategory(plannedTest?.scenario?.category) !== "requirement_conflict")
+            if (normalizeCategory(plannedTest.scenario.category) !==
+                "requirement_conflict")
                 continue;
             if (citedDefects(plannedTest).length > 0)
                 continue;
-            const plannedTestId = idKey(plannedTest?.plannedTestId) || "plan";
+            const plannedTestId = idKey(plannedTest.plannedTestId) || "plan";
             objections.push({
                 objectionId: `defects:conflictWithoutDefect:${plannedTestId}`,
                 verifier: "defects",
-                plannedTestId: plannedTest?.plannedTestId,
+                plannedTestId: plannedTest.plannedTestId,
                 message: DEFECTS_CONTRACT.objections.conflictWithoutDefect.message,
                 evidence: `${plannedTestId} is planned as \`requirement_conflict\` and cites no defect in \`defects\`.`,
                 suggestion: DEFECTS_CONTRACT.objections.conflictWithoutDefect.suggestion,

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

@@ -3,6 +3,10 @@ import { Plan } from "../registerPlan.js";
 /** One test as it appears in the submitted report. */
 export interface DeliveredTest {
     plannedTestId: string;
+    /** The repo the REPORT attributes it to. Compared against the plan's: an id is
+     *  unique within the plan, so a row reusing one under another repo would
+     *  otherwise join and ship the wrong attribution. */
+    repository: string;
 }
 /** One maintenance row that LEFT COVERAGE BEHIND, as the report publishes it. The
  *  caller filters by action: a row this check is handed is one whose edit a later
@@ -17,7 +21,9 @@ export interface MaintainedTest {
 /** Verifier 5, post-execution half. Both directions on one pass: a report entry
  *  that was in no plan, and a planned planned test that never shipped. The two lists
  *  join on `plannedTestId` exactly — never a name, an endpoint or a similarity
- *  score. Objections go to the report: the tests already exist. */
+ *  score — and the matched pair must agree on the repository, so a real id cannot
+ *  carry a made-up repo through. Objections go to the report: the tests already
+ *  exist. */
 export declare function checkDeliveredMatchesPlan(plan: Plan, delivered: DeliveredTest[]): Objection[];
 /** The maintenance mirror of "planned but not delivered". A `maintains` entry is
  *  what makes its changes count as covered, and until this ran nothing downstream

package/build/recommendation/verifiers/deliveredMatchesPlan.js

@@ -2,23 +2,37 @@ import { testFileMatches } from "../../utils/utils.js";
 /** Verifier 5, post-execution half. Both directions on one pass: a report entry
  *  that was in no plan, and a planned planned test that never shipped. The two lists
  *  join on `plannedTestId` exactly — never a name, an endpoint or a similarity
- *  score. Objections go to the report: the tests already exist. */
+ *  score — and the matched pair must agree on the repository, so a real id cannot
+ *  carry a made-up repo through. Objections go to the report: the tests already
+ *  exist. */
 export function checkDeliveredMatchesPlan(plan, delivered) {
-    const planned = new Set(plan.plannedTests.map((c) => c.plannedTestId));
-    const shipped = new Set(delivered.map((d) => d.plannedTestId));
+    const planned = new Map(plan.plannedTests.map((c) => [c.plannedTestId, c.repository]));
+    const shipped = new Map(delivered.map((d) => [d.plannedTestId, d.repository]));
     const objections = [];
-    for (const id of shipped) {
-        if (planned.has(id))
+    for (const [id, repository] of shipped) {
+        const plannedRepository = planned.get(id);
+        if (plannedRepository === undefined) {
+            objections.push({
+                objectionId: `deliveredMatchesPlan:${id}`,
+                verifier: "deliveredMatchesPlan",
+                message: "This test is in the report but was not in the plan. Every test written must be declared first.",
+                evidence: `delivered but unplanned: ${id}`,
+                suggestion: "Declare it in the plan and register it again, or take it out of the report.",
+            });
             continue;
-        objections.push({
-            objectionId: `deliveredMatchesPlan:${id}`,
-            verifier: "deliveredMatchesPlan",
-            message: "This test is in the report but was not in the plan. Every test written must be declared first.",
-            evidence: `delivered but unplanned: ${id}`,
-            suggestion: "Declare it in the plan and register it again, or take it out of the report.",
-        });
+        }
+        if (plannedRepository !== repository) {
+            objections.push({
+                objectionId: `deliveredMatchesPlan:repository:${id}`,
+                verifier: "deliveredMatchesPlan",
+                plannedTestId: id,
+                message: "This test names one repository in the plan and another in the report. A test belongs to one repository.",
+                evidence: `planned under ${plannedRepository}, reported under ${repository}`,
+                suggestion: "Set the report entry's repository to the one the plan declared, or plan the test under the repository it was written for.",
+            });
+        }
     }
-    for (const id of planned) {
+    for (const id of planned.keys()) {
         if (shipped.has(id))
             continue;
         objections.push({
@@ -47,7 +61,7 @@ export function checkMaintenanceDelivered(plan, maintained) {
     const claimed = Array.isArray(plan?.maintains) ? plan.maintains : [];
     if (claimed.length === 0)
         return [];
-    const text = (value) => (typeof value === "string" ? value.trim() : "");
+    const text = (value) => typeof value === "string" ? value.trim() : "";
     const editedPaths = [];
     for (const row of Array.isArray(maintained) ? maintained : []) {
         for (const full of [text(row?.testFilePath), text(row?.pomFile)])

package/build/recommendation/verifiers/endpointGrounded.js

@@ -1,12 +1,14 @@
 import { isUIPlannedTest } from "../subjectStep.js";
-import { ENDPOINT_GROUNDED_CONTRACT } from "../verifierContracts.js";
+import { ENDPOINT_GROUNDED_CONTRACT, } from "../verifierContracts.js";
 import { isTestPath } from "../../utils/testFileClassification.js";
 /** A path that leaves the checkout, in any of its spellings. Callers pass a
  *  trimmed path: " ../routes.rb" splits to [" ..", "routes.rb"], so no segment
  *  equals ".." and one leading space would carry it through. */
 export function escapesRepo(file) {
     // POSIX absolute, a Windows drive, a bare leading backslash, and a UNC share.
-    if (file.startsWith("/") || file.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(file))
+    if (file.startsWith("/") ||
+        file.startsWith("\\") ||
+        /^[A-Za-z]:[\\/]/.test(file))
         return true;
     // A URL, which both citation describes promise is not a citation: `http://host/x`
     // has no leading slash and no `..`, so without this it resolved against the
@@ -15,7 +17,9 @@ export function escapesRepo(file) {
     const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):([\s\S]*)$/.exec(file);
     if (scheme) {
         const [, name, rest] = scheme;
-        if (rest.startsWith("/") || rest.includes("://") || /^(file|data|javascript|jar|blob)$/i.test(name))
+        if (rest.startsWith("/") ||
+            rest.includes("://") ||
+            /^(file|data|javascript|jar|blob)$/i.test(name))
             return true;
     }
     return file.split(/[\\/]/).some((segment) => segment === "..");
@@ -70,20 +74,22 @@ export const endpointGrounded = {
         for (const plannedTest of registration.plannedTests) {
             if (isUIPlannedTest(plannedTest))
                 continue;
-            const evidence = plannedTest.declarations?.routes ?? [];
+            const evidence = plannedTest.declarations.routes ?? [];
             const ungrounded = [];
             let uncited = 0;
             let disqualified = 0;
-            for (const step of plannedTest.scenario?.steps ?? []) {
+            for (const step of plannedTest.scenario.steps) {
                 // A step naming no path calls nothing there is a file to cite for — a wait,
                 // a pause, a setup line. The verb is deliberately NOT read: requiring one
                 // made a Thrift or GraphQL call look like a click and skip this check.
-                if (!String(step?.path ?? "").trim())
+                if (!String(step.path ?? "").trim())
                     continue;
-                const key = `${String(step?.method ?? "ANY").trim() || "ANY"} ${String(step?.path).trim()}`;
+                const key = `${String(step.method ?? "ANY").trim() || "ANY"} ${String(step.path).trim()}`;
                 // Named by the step's own `order`, so nothing here compares two spellings
                 // of one route. The number must be a number: a string `"2"` names no step.
-                const cited = evidence.filter((e) => typeof e?.step === "number" && e.step === (step?.order ?? 0));
+                // The number must be a number: a string `"2"` names no step, and `===`
+                // alone would read one as a match against a numeric `order`.
+                const cited = evidence.filter((e) => typeof e.step === "number" && e.step === step.order);
                 if (cited.length === 0) {
                     uncited += 1;
                     pushOnce(ungrounded, `${key} (no file cited)`);

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

@@ -3,4 +3,10 @@ import { Verifier } from "../types.js";
  *  checkout, and nothing more: deciding that one already covers the planned test came
  *  from route-parsed `METHOD::resource` keys, wrong in both directions. `differsBy`
  *  is recorded, never judged, and citing nothing raises nothing. */
+/** The id plan time raises when a `maintains` entry's file does not resolve in the
+ *  checkout, or when the entry names no file. Built here and read by report time,
+ *  which has no `VerifyContext` and so cannot resolve a path itself: the presence
+ *  of this objection IS the file verdict. Exported rather than spelled twice —
+ *  `issueTraceability` looks it up per entry. */
+export declare function maintainedFileObjectionId(file: unknown): string;
 export declare const existingCoverage: Verifier;

package/build/recommendation/verifiers/existingCoverage.js

@@ -4,20 +4,28 @@ import { EXISTING_COVERAGE_CONTRACT } from "../verifierContracts.js";
  *  checkout, and nothing more: deciding that one already covers the planned test came
  *  from route-parsed `METHOD::resource` keys, wrong in both directions. `differsBy`
  *  is recorded, never judged, and citing nothing raises nothing. */
+/** The id plan time raises when a `maintains` entry's file does not resolve in the
+ *  checkout, or when the entry names no file. Built here and read by report time,
+ *  which has no `VerifyContext` and so cannot resolve a path itself: the presence
+ *  of this objection IS the file verdict. Exported rather than spelled twice —
+ *  `issueTraceability` looks it up per entry. */
+export function maintainedFileObjectionId(file) {
+    const named = String(file ?? "").trim();
+    return `existingCoverage:maintains:${named || "unnamed"}`;
+}
 export const existingCoverage = {
     name: "existingCoverage",
     run(registration, ctx) {
         const objections = [];
         for (const plannedTest of registration.plannedTests) {
-            // The plan is read off disk, so this is an array only on the validated
-            // path. A throw here would reach the agent as `:crashed`, hiding the real
-            // objection instead of raising it.
-            const cited = plannedTest?.declarations?.existingTests;
+            // The field AND its entries: `crashContainment.test.ts` feeds `[null]`, and
+            // `existingCoverage.test.ts` feeds the field itself as `5` and as a string.
+            const cited = plannedTest.declarations.existingTests;
             if (!Array.isArray(cited))
                 continue;
             const unreadable = [];
             for (const entry of cited) {
-                const file = String(entry?.file ?? "").trim();
+                const file = String(entry.file ?? "").trim();
                 if (!file) {
                     pushOnce(unreadable, "an entry names no file");
                     continue;
@@ -28,8 +36,9 @@ export const existingCoverage = {
                     pushOnce(unreadable, `${file} (points outside the repository)`);
                     continue;
                 }
-                if (!ctx.citedFileExists(file))
-                    pushOnce(unreadable, `${file} (not found)`);
+                // The planned test's own repository: two repositories can hold the same path.
+                if (!ctx.citedFileExists(file, plannedTest.repository))
+                    pushOnce(unreadable, `${file} (not found in ${plannedTest.repository})`);
             }
             if (unreadable.length === 0)
                 continue;
@@ -45,30 +54,28 @@ export const existingCoverage = {
         // `maintains` is what makes a change covered by an edited test count in
         // `coverage`, so the same file check applies to it, plus the change ids it
         // cites: an id no `changes` entry declares would credit coverage for nothing.
-        const maintains = Array.isArray(registration?.maintains) ? registration.maintains : [];
-        const declaredChanges = new Set((Array.isArray(registration?.changes) ? registration.changes : [])
-            .map((change) => String(change?.id ?? "").trim())
-            .filter(Boolean));
+        const maintains = registration.maintains ?? [];
+        const declaredChanges = new Set(registration.changes.map((change) => change.id.trim()).filter(Boolean));
         // Gathered per file BEFORE any objection is pushed: the schema allows two
         // entries naming the same file, the objection id is keyed on the file so the
         // agent answers a file once, and keying alone dropped the second entry's ids.
         const missingByFile = new Map();
         const unknownByFile = new Map();
         for (const entry of maintains) {
-            const file = String(entry?.file ?? "").trim();
+            const file = entry.file.trim();
             const key = file || "unnamed";
             const missing = !file
                 ? "an entry names no file"
                 : escapesRepo(file)
                     ? `${file} (points outside the repository)`
-                    : !ctx.citedFileExists(file)
-                        ? `${file} (not found)`
-                        : "";
+                    : // The repository the entry names, for the same reason.
+                        !ctx.citedFileExists(file, entry.repository)
+                            ? `${file} (not found in ${entry.repository})`
+                            : "";
             if (missing && !missingByFile.has(key))
                 missingByFile.set(key, missing);
-            const ids = Array.isArray(entry?.changes) ? entry.changes : [];
-            for (const raw of ids) {
-                const id = String(raw ?? "").trim();
+            for (const raw of entry.changes) {
+                const id = raw.trim();
                 if (!id || declaredChanges.has(id))
                     continue;
                 const unknown = unknownByFile.get(key) ?? [];
@@ -79,11 +86,12 @@ export const existingCoverage = {
         }
         for (const [key, missing] of missingByFile) {
             objections.push({
-                objectionId: `existingCoverage:maintains:${key}`,
+                objectionId: maintainedFileObjectionId(key),
                 verifier: "existingCoverage",
                 message: EXISTING_COVERAGE_CONTRACT.objections.maintainedTestMissing.message,
                 evidence: `maintained test not in the checkout: ${missing}`,
-                suggestion: EXISTING_COVERAGE_CONTRACT.objections.maintainedTestMissing.suggestion,
+                suggestion: EXISTING_COVERAGE_CONTRACT.objections.maintainedTestMissing
+                    .suggestion,
             });
         }
         for (const [key, unknown] of unknownByFile) {
@@ -92,7 +100,8 @@ export const existingCoverage = {
                 verifier: "existingCoverage",
                 message: EXISTING_COVERAGE_CONTRACT.objections.maintainedUnknownChange.message,
                 evidence: `${key === "unnamed" ? "an unnamed entry" : key} cites ${unknown.map((id) => `"${id}"`).join(", ")}; this plan declares ${[...declaredChanges].map((id) => `"${id}"`).join(", ") || "no changes"}`,
-                suggestion: EXISTING_COVERAGE_CONTRACT.objections.maintainedUnknownChange.suggestion,
+                suggestion: EXISTING_COVERAGE_CONTRACT.objections.maintainedUnknownChange
+                    .suggestion,
             });
         }
         return objections;

package/build/recommendation/verifiers/expectedOutcome.js

@@ -1,5 +1,5 @@
 import { categoryExpectsRed } from "../../types/TestRecommendation.js";
-import { fillPlaceholders, EXPECTED_OUTCOME_CONTRACT } from "../verifierContracts.js";
+import { fillPlaceholders, EXPECTED_OUTCOME_CONTRACT, } from "../verifierContracts.js";
 import { subjectStep } from "../subjectStep.js";
 /** The severities that count as the run's own reported defect. */
 const BLOCKER_FLOOR = ["critical", "high"];
@@ -11,7 +11,9 @@ function blockingIssue(plannedTest, issues) {
     if (!path)
         return undefined;
     for (const issue of issues) {
-        if (!BLOCKER_FLOOR.includes(String(issue?.severity ?? "").trim().toLowerCase()))
+        if (!BLOCKER_FLOOR.includes(String(issue?.severity ?? "")
+            .trim()
+            .toLowerCase()))
             continue;
         const description = String(issue?.description ?? "");
         const sourceFile = String(issue?.sourceFile ?? "");
@@ -36,6 +38,8 @@ export function checkExpectedOutcomeAfterExecution(plan, results, issues = []) {
         const result = byId.get(plannedTest.plannedTestId);
         if (!result)
             continue;
+        // The stored plan is not schema-validated. An entry with no `declarations`
+        // is skipped; a throw here would cost every entry after it as well.
         const declared = plannedTest.declarations?.expected?.outcome;
         if (declared === "fail" && result.passed) {
             objections.push({
@@ -62,14 +66,18 @@ export function checkExpectedOutcomeAfterExecution(plan, results, issues = []) {
         // Stated by the agent, not inferred: a 404 the test asked for and a 404 that
         // stopped it read the same in the failure text, and only whoever wrote the
         // test knows which it was. A row that leaves the field out raises nothing.
-        if (declared === "fail" && !result.passed && result.reachedBehavior === false) {
+        if (declared === "fail" &&
+            !result.passed &&
+            result.reachedBehavior === false) {
             const blocker = blockingIssue(plannedTest, issues);
             objections.push({
                 objectionId: `expectedOutcome:executed:${plannedTest.plannedTestId}`,
                 verifier: "expectedOutcome",
                 plannedTestId: plannedTest.plannedTestId,
                 message: EXPECTED_OUTCOME_CONTRACT.objections.executed.message,
-                evidence: blocker ? `blocked by reported issue: ${blocker}` : (result.failureDetail ?? ""),
+                evidence: blocker
+                    ? `blocked by reported issue: ${blocker}`
+                    : (result.failureDetail ?? ""),
                 suggestion: EXPECTED_OUTCOME_CONTRACT.objections.executed.suggestion,
             });
         }
@@ -87,8 +95,8 @@ export const expectedOutcomeAtPlanTime = {
         for (const plannedTest of registration.plannedTests) {
             // Compared normalised, reported as written: the agent has to recognise the
             // value it sent in the objection.
-            const category = String(plannedTest.scenario?.category ?? "");
-            const declaredOutcome = plannedTest.declarations?.expected?.outcome;
+            const category = String(plannedTest.scenario.category ?? "");
+            const declaredOutcome = plannedTest.declarations.expected?.outcome;
             if (declaredOutcome !== "pass" || !categoryExpectsRed(category))
                 continue;
             objections.push({
@@ -96,8 +104,9 @@ export const expectedOutcomeAtPlanTime = {
                 verifier: "expectedOutcome",
                 plannedTestId: plannedTest.plannedTestId,
                 message: fillPlaceholders(EXPECTED_OUTCOME_CONTRACT.objections.passInShouldFailCategory.message, { category }),
-                evidence: `category ${category}, declared pass: "${plannedTest.declarations?.expected?.why ?? ""}"`,
-                suggestion: EXPECTED_OUTCOME_CONTRACT.objections.passInShouldFailCategory.suggestion,
+                evidence: `category ${category}, declared pass: "${plannedTest.declarations.expected?.why ?? ""}"`,
+                suggestion: EXPECTED_OUTCOME_CONTRACT.objections.passInShouldFailCategory
+                    .suggestion,
             });
         }
         return objections;