@skyramp/mcp 0.4.4-rc.1 → 0.4.4-rc.2

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

@@ -3,8 +3,8 @@ import { PlanMaintenance, VerifyContext } from "../types.js";
 /** Whether a `maintains` entry names a file that stays inside the repository and is
  *  present in the repository the entry names.
  *
- *  An entry credits its ids only when it is. `coverage:change:` closes only with a
- *  blocker and `defects:untested:` only with a test, so crediting a file nobody can
+ *  An entry credits its ids only when it is. `coverage:change:` and
+ *  `defects:untested:` close only with a blocker, so crediting a file nobody can
  *  open would route around both. */
 export declare function maintainedFileIsInItsRepository(entry: PlanMaintenance, ctx: VerifyContext): boolean;
 /** A cited path reduced to the spelling `git diff --name-status` produces: `./`,

package/build/recommendation/verifiers/citedPath.js

@@ -3,8 +3,8 @@ import { escapesRepo } from "./endpointGrounded.js";
 /** Whether a `maintains` entry names a file that stays inside the repository and is
  *  present in the repository the entry names.
  *
- *  An entry credits its ids only when it is. `coverage:change:` closes only with a
- *  blocker and `defects:untested:` only with a test, so crediting a file nobody can
+ *  An entry credits its ids only when it is. `coverage:change:` and
+ *  `defects:untested:` close only with a blocker, so crediting a file nobody can
  *  open would route around both. */
 export function maintainedFileIsInItsRepository(entry, ctx) {
     const path = entry.file.trim();

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

@@ -46,7 +46,11 @@ export interface TraceabilityLane {
  *  accepted that entry — the same claim a planned test makes. See
  *  {@link maintainedDefects} for how that acceptance is read.
  *  `deliveredMatchesPlan:maintains:` checks separately that the edit landed.
- */
+ *
+ *  A declared `defectId` also counts when the agent answered `defects:untested:<id>`
+ *  at plan time (or closed it with a blocker). The plan-time verifier asked why no
+ *  test proves that defect and the agent said; asking again here is the same
+ *  question twice, and the answer is already published with the plan. */
 export declare function checkIssueTraceability(plan: Plan, delivered: DeliveredForTraceability[], issues: ReportedIssueForTraceability[], lane?: TraceabilityLane): Objection[];
 /** Report-time. Every defect the plan declared is an `issuesFound` entry that
  *  names it by `defectId`. The review found it; the report must show it. */

package/build/recommendation/verifiers/issueTraceability.js

@@ -31,6 +31,30 @@ function quote(description) {
         .replace(/\s+/g, " ");
     return text.length > QUOTE_LENGTH ? `${text.slice(0, QUOTE_LENGTH)}…` : text;
 }
+/** The plan-time `defects:untested:<id>` objection, as the plan-time verifier ids it. */
+const UNTESTED_PREFIX = "defects:untested:";
+/** Defect ids whose `defects:untested:<id>` objection the agent closed when it
+ *  registered the plan, by an answer or by a blocker. Both buckets: a blocker
+ *  close is stored apart from an answer and is a close all the same. Read
+ *  defensively: the plan comes off disk. */
+function answeredUntested(plan) {
+    const closed = [
+        ...(Array.isArray(plan?.answeredObjections) ? plan.answeredObjections : []),
+        ...(Array.isArray(plan?.unverifiedCloses) ? plan.unverifiedCloses : []),
+    ];
+    const ids = new Set();
+    for (const entry of closed) {
+        const objectionId = idKey(entry?.objection?.objectionId);
+        if (!objectionId.startsWith(UNTESTED_PREFIX))
+            continue;
+        if (idKey(entry?.answer).length === 0)
+            continue;
+        const id = idKey(objectionId.slice(UNTESTED_PREFIX.length));
+        if (id)
+            ids.add(id);
+    }
+    return ids;
+}
 /** The declared defect ids a `maintains` entry proves, as plan time judged them.
  *  Report time has no VerifyContext, so it reads plan time's own verdict on the
  *  entry's file, `existingCoverage:maintains:<file>`, rather than resolving the path
@@ -98,7 +122,11 @@ function locate(defect) {
  *  accepted that entry — the same claim a planned test makes. See
  *  {@link maintainedDefects} for how that acceptance is read.
  *  `deliveredMatchesPlan:maintains:` checks separately that the edit landed.
- */
+ *
+ *  A declared `defectId` also counts when the agent answered `defects:untested:<id>`
+ *  at plan time (or closed it with a blocker). The plan-time verifier asked why no
+ *  test proves that defect and the agent said; asking again here is the same
+ *  question twice, and the answer is already published with the plan. */
 export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LANE) {
     const shipped = new Set(delivered.map((test) => idKey(test?.plannedTestId)).filter(Boolean));
     const plannedTests = Array.isArray(plan?.plannedTests)
@@ -145,6 +173,7 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
             bucket.set(defectId, [...(bucket.get(defectId) ?? []), id]);
         }
     }
+    const answered = answeredUntested(plan);
     const maintained = maintainedDefects(plan);
     const objections = [];
     issues.forEach((issue, index) => {
@@ -158,7 +187,9 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
         const defectId = idKey(issue?.defectId);
         const declaredDefect = defectId.length > 0 && known.has(defectId);
         if (declaredDefect &&
-            ((provenBy.get(defectId) ?? []).length > 0 || maintained.has(defectId))) {
+            ((provenBy.get(defectId) ?? []).length > 0 ||
+                maintained.has(defectId) ||
+                answered.has(defectId))) {
             return;
         }
         const named = [];
@@ -173,7 +204,7 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
                 named.push(`defectId "${defectId}" is cited by no ${word} test that expects to fail: ${(citedWeakly.get(defectId) ?? []).join(", ")} cite it and the plan declares each as expecting to pass`);
             }
             else {
-                named.push(`defectId "${defectId}" is cited by no ${word} test that expects to fail, no accepted \`maintains\` entry proves it — an entry naming a file that is not in the checkout is refused`);
+                named.push(`defectId "${defectId}" is cited by no ${word} test that expects to fail, no accepted \`maintains\` entry proves it — an entry naming a file that is not in the checkout is refused — and no plan-time answer closed ${UNTESTED_PREFIX}${defectId}`);
             }
         }
         const where = String(issue?.sourceFile ?? "").trim() || "no sourceFile";
@@ -186,7 +217,7 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
             verifier: "issueTraceability",
             message: `No test proves this bug: "${quote(issue?.description)}" (${where}).`,
             evidence: `issuesFound[${index}]: ${named.length > 0 ? named.join("; ") : "no plannedTestId and no defectId"}.`,
-            suggestion: "Set `plannedTestId` to the delivered test that proves this bug — one the plan declares with `expected.outcome: fail`, so it stays red until the bug is fixed — or set `defectId` to a declared plan defect such a test cites. If something stopped the test — a service that is not running, the one credential the run holds — answer and set `blocker` to it. A reason the bug is not worth testing is not a blocker.",
+            suggestion: "Set `plannedTestId` to the delivered test that proves this bug — one the plan declares with `expected.outcome: fail`, so it stays red until the bug is fixed — or set `defectId` to a declared plan defect such a test cites. If no test proves it, answer in one line why.",
         });
     });
     return objections;

package/build/resources/analysisResources.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare const ANALYSIS_URI_PREFIX = "skyramp://analysis";
 /**
  * Register MCP Resources for analysis data access.

package/build/resources/analysisResources.js

@@ -1,5 +1,5 @@
 import * as fs from "fs";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ResourceTemplate } from "@modelcontextprotocol/server";
 import { StateManager, getSessionFilePath, getRegisteredSessions, hasSessionData, getSessionData, normalizeRecommendationState, } from "../utils/AnalysisStateManager.js";
 import { logger } from "../utils/logger.js";
 import { AnalysisScope } from "../types/RepositoryAnalysis.js";

package/build/resources/progressResource.d.ts

@@ -1,2 +1,2 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpServer } from "@modelcontextprotocol/server";
 export declare function registerProgressResource(server: McpServer): void;

package/build/resources/sutSetupResource.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerSutSetupResource(server: McpServer): void;

package/build/resources/sutSetupResource.js

@@ -1,4 +1,4 @@
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ResourceTemplate } from "@modelcontextprotocol/server";
 import { logger } from "../utils/logger.js";
 import { resourceText } from "../utils/utils.js";
 import { AnalyticsService } from "../services/AnalyticsService.js";

package/build/resources/testbotResource.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerTestbotResource(server: McpServer): void;

package/build/resources/testbotResource.js

@@ -1,4 +1,4 @@
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ResourceTemplate } from "@modelcontextprotocol/server";
 import { logger } from "../utils/logger.js";
 import { AnalyticsService } from "../services/AnalyticsService.js";
 import { getTestbotPrompt, parseRelatedRepositories, } from "../prompts/testbot/testbot-prompts.js";

package/build/services/AnalyticsService.d.ts

@@ -1,4 +1,4 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolResult } from "@modelcontextprotocol/server";
 export declare class AnalyticsService {
     /**
      * Only the fields named here reach the analytics backend. The tool's own

package/build/services/FleetExecutionService.d.ts

@@ -0,0 +1,130 @@
+import Docker from "dockerode";
+/**
+ * Where the mounted pieces live inside the executor, per container platform.
+ *
+ * The two images are the same shape on purpose -- /app/classes, /app/lib, the work
+ * directory -- so the only real differences are the path separator, the classpath
+ * separator and the shell. Keeping them in one table is what stops those three leaking
+ * into the rest of the file.
+ */
+export type ContainerPlatform = "linux" | "windows";
+interface Layout {
+    work: string;
+    certs: string;
+    /** The directory a branch-built library jar is mounted from. */
+    overrideDir: string;
+    /** The directory a credential pool outside the work directory is mounted from. */
+    poolDir: string;
+    imageClasses: string;
+    imageLibDir: string;
+    classpathSep: string;
+    /** Path separator inside the container. */
+    sep: string;
+}
+/**
+ * A path inside the container's work directory.
+ *
+ * Everything the run reads or writes lives under the mount, so this is the only place a
+ * container path is spelled out -- which is the point of the table above. Writing them
+ * longhand per platform put the separator back in the call sites it was meant to keep it
+ * out of.
+ */
+export declare function workPath(l: Layout, ...parts: string[]): string;
+export declare const LAYOUT: Record<ContainerPlatform, Layout>;
+/**
+ * Which platform the executor runs as. The Docker daemon that will run the container
+ * decides, not the image name: a released executor is one tag carrying both operating
+ * systems, and a daemon pulls and starts the image for its own.
+ *
+ * Asked of `docker`, the client that creates the container. The image check and pull go
+ * through the default client (docker.ts), which is the same daemon for every caller today:
+ * skyramp_execute_fleet passes no client. A daemon whose OS cannot be read fails the run
+ * here with that error as the cause: guessing linux on a Windows daemon would fail later
+ * with a mount or pull error that says nothing about why. An explicit platform must match
+ * the daemon; a mismatch would pull or start an image the engine cannot run.
+ */
+export declare function resolvePlatform(docker: Docker, explicit?: ContainerPlatform): Promise<ContainerPlatform>;
+export interface FleetExecutionOptions {
+    directory: string;
+    executorImage?: string;
+    platform?: ContainerPlatform;
+    entryClass?: string;
+    certsDir: string;
+    credentials?: string;
+    libraryJar?: string;
+    timeoutSec?: number;
+    env?: Record<string, string>;
+}
+export interface FleetExecutionResult {
+    passed: boolean;
+    executorImage: string;
+    platform: ContainerPlatform;
+    entryClass: string;
+    exitCode: number | null;
+    report: string;
+    output: string;
+    result?: unknown;
+    timedOut?: boolean;
+}
+/** A simple (unqualified) Java class name. */
+export declare const JAVA_CLASS_NAME: RegExp;
+/**
+ * The generated fleet manager: the one class in the directory that JUnit runs. The journey
+ * and the load class travel with it because they sit beside it, and they are compiled but
+ * never selected -- the journey is an input the fleet ships to the worker, and the load
+ * class only supplies the scenario.
+ */
+export declare function findEntryClass(directory: string, explicit?: string): string;
+/**
+ * A fleet file that pins its worker image is refused.
+ *
+ * The library picks the image from the commit it was built from, and that pairing is what a
+ * run through this tool exercises. A pinned image proves the image is good and hides the
+ * case where the library asks for one that does not exist.
+ */
+export declare function assertNoPinnedImage(fleetFile: string): void;
+/**
+ * The fleet reaches the worker it deployed at an address derived from the Docker daemon:
+ * the daemon's host for a remote engine, `localhost` for a local socket. Inside this
+ * container `localhost` is the container, so a local-socket fleet cannot reach the worker it
+ * just deployed and would hang until the timeout instead of failing.
+ */
+export declare function assertRemoteDaemon(fleetFile: string): void;
+/**
+ * The image the run happens in.
+ *
+ * The released executor is named by version, and a branch build of it carries no commit in
+ * its name the way the worker images do -- `RUNNER_IMAGE` defaults to a constant tag. So a
+ * caller testing an unreleased library either names its image here, or mounts the jar.
+ */
+export declare function resolveExecutorImage(explicit?: string): string;
+/** What the container is told to run: the argv, and the script it ends with. */
+export interface ContainerCommand {
+    /** Passed to Docker as `Cmd`. */
+    argv: string[];
+    /** The shell script argv ends with -- named, because its index differs per platform. */
+    script: string;
+}
+/** javac, then the JUnit console runner, both against the image's classpath. */
+export declare function buildCommand(entryClass: string, overrideJar: string | undefined, platform?: ContainerPlatform): ContainerCommand;
+/** The lines the fleet printed, which is what a reader wants out of the JUnit noise. */
+export declare function extractReport(output: string): string;
+/**
+ * Where a path inside the container lands on the host.
+ *
+ * The work directory is a bind mount of `directory`, so anything written under it appears
+ * there. Deriving the host path from the container path keeps the two ends of
+ * SKYRAMP_FLEET_REPORT_JSON as one fact: the value handed to the JVM is the value read
+ * back, rather than a second hardcoded guess that happens to agree.
+ *
+ * Returns undefined when the path is not under the work directory -- a caller may point
+ * the variable anywhere, and nothing outside the mount is visible from here.
+ */
+export declare function hostPathForContainerPath(directory: string, workDir: string, containerPath: string): string | undefined;
+/**
+ * Compiles and runs a generated fleet trio in the executor image, and returns what the run
+ * reported. The container is the same one every other generated test runs in; only the
+ * command and the mounts differ.
+ */
+export declare function executeFleet(options: FleetExecutionOptions, docker?: Docker): Promise<FleetExecutionResult>;
+export {};