@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/prompts/test-recommendation/recommendationShared.js

@@ -1,164 +1,58 @@
-import { extractResourceFromPath } from "../../utils/routeParsers.js";
-import { logger } from "../../utils/logger.js";
-/** Resolve the primary step and inferred test type for a scenario. */
-function resolvePrimaryStep(scenario) {
-    const testType = scenario.testType ?? (scenario.steps.length === 1 ? "contract" : "integration");
-    const mutatingSteps = scenario.steps.filter(st => ["POST", "PUT", "PATCH", "DELETE"].includes(st.method));
-    // Use the last mutating step — earlier steps are typically prerequisite setup
-    // (e.g. POST /products before PATCH /orders), while the final mutation is the
-    // primary action under test.
-    const primaryStep = mutatingSteps[mutatingSteps.length - 1] ?? scenario.steps[scenario.steps.length - 1];
-    return { primaryStep, testType };
-}
-/**
- * The one spelling of a coverage key, `METHOD::resource::testType`. Both
- * operands of the dedup comparison call it: a proposed test through
- * `externalDedupKeys`, and an existing test through `buildExternalCoverageSet`.
- * They used to build the same string in two places from two different inputs —
- * a typed step list on one side, regex-scraped prose on the other — so a fix to
- * one side left the other producing keys that could never match (SKYR-4214).
- */
-export function coverageKey(input) {
-    const method = (input.method ?? "GET").toUpperCase();
-    return `${method}::${extractResourceFromPath(input.path ?? "")}::${input.testType}`;
-}
-/** Test type of a scenario: its own label, else one step means a contract test. */
-function resolveTestType(scenario) {
-    return scenario.testType ?? (scenario.steps.length === 1 ? "contract" : "integration");
-}
 /**
- * Method-aware coverage keys for external test dedup — one per recorded subject
- * endpoint. Method-aware so that an external test covering "GET /orders" does
- * not block a test for "PUT /orders", a different operation on the same
- * resource.
- *
- * A caller must remove a candidate ONLY when the coverage set holds EVERY key
- * returned here. Removing it on one match would discard the coverage of its
- * other endpoints. An empty list must never remove anything.
+ * Shared prompt primitives, kept out of the prompt modules that use them to
+ * avoid circular imports.
  */
-export function externalDedupKeys(scenario) {
-    const testType = resolveTestType(scenario);
-    const subjects = scenario.subjectEndpoints;
-    if (subjects && subjects.length > 0) {
-        return subjects.map((s) => coverageKey({ ...s, testType }));
-    }
-    if (subjects)
-        return [];
-    const { primaryStep } = resolvePrimaryStep(scenario);
-    if (!primaryStep)
-        return [];
-    return [coverageKey({ method: primaryStep.method, path: primaryStep.path, testType })];
-}
-/**
- * Resource+type keys (no method) for the GENERATE/ADDITIONAL overlap filter —
- * one per recorded subject endpoint. Same rule as `externalDedupKeys`: remove
- * only on ALL keys, never on an empty list.
- */
-export function scenarioCoverageKeys(scenario) {
-    const testType = resolveTestType(scenario);
-    const steps = scenario.steps ?? [];
-    const subjects = scenario.subjectEndpoints;
-    // No recorded subject: fall back to the primary step, as externalDedupKeys does.
-    if (!subjects) {
-        const { primaryStep } = resolvePrimaryStep(scenario);
-        if (!primaryStep)
-            return [];
-        return [
-            overlapKey(primaryStep.method, extractResourceFromPath(primaryStep.path ?? ""), testType, primaryStep),
-        ];
-    }
-    return subjects.map((subject) => {
-        const step = steps.find((s) => s.method === subject.method && s.path === subject.path);
-        return overlapKey(subject.method, extractResourceFromPath(subject.path ?? ""), testType, step);
-    });
-}
 /**
- * The overlap key names the endpoint AND what the test asserts about it.
- *
- * It deliberately does NOT reuse `coverageKey`. That key's other operand comes
- * from `buildExternalCoverageSet`, which scrapes prose and can only ever know a
- * method and a path — adding a status there would stop every external key from
- * matching. Both operands of the OVERLAP comparison are drafted candidates with
- * a step list, so both sides know the method, the interaction type and the
- * status.
- *
- * The method is part of the key because `extractResourceFromPath` maps
- * `/api/orders` and `/api/orders/{id}` to the same resource. Without it a
- * GENERATE `PATCH /api/orders/{id}` (success, 200) removed an ADDITIONAL
- * `GET /api/orders/{id}` (success, 200) as a duplicate — a read test and an
- * update test on one resource are not duplicates.
+ * Labels for a hand-written ordered list, taken from declaration order. Insert a
+ * key and every later label moves with it — and so does every reference built
+ * from the constant. A number counts up; a single letter walks the alphabet.
  *
- * Measured on 839 nightly fixtures: 781 of them change exactly ONE route, so
- * every candidate resolves to the same subject and `resource::testType` yields
- * 2 keys for the whole pool. In 11 fixtures that removed EVERY ADDITIONAL
- * candidate — `01-site-stats-endpoint` lost all 18. Adding the interaction type
- * and the status roughly doubles the distinct keys on those pools. It does not
- * make the key complete: two tests that assert different things about the same
- * 200 response still collide, and no key built from a route can separate them.
- */
-function overlapKey(method, resource, testType, step) {
-    const interaction = step?.interactionType ?? "any";
-    const status = step?.expectedStatusCode ?? 0;
-    return `${(method ?? "ANY").toUpperCase()}::${resource}::${testType}::${interaction}::${status}`;
-}
-export function isAttackSurfaceSecurityBoundary(scenario) {
-    return scenario.category === "security_boundary" &&
-        (scenario.isAttackSurfaceSecurityBoundary === true ||
-            scenario.description.startsWith("Attack-surface auth boundary:"));
-}
-export function isOrdinaryDirectAuthBoundary(scenario) {
-    return scenario.category === "security_boundary" &&
-        !isAttackSurfaceSecurityBoundary(scenario) &&
-        scenario.description.startsWith("Auth boundary:");
-}
-/**
- * Build a set of coverage keys from external (non-Skyramp) tests.
- * Parses `testLocations` entries tagged with `[external]` to extract the
- * method-aware `METHOD::resource::testType` keys they cover.
+ * `PromptPlan` numbers the steps it also RENDERS. Use this for a list whose
+ * text is written by hand, where a plan's step headers would change the output.
  */
-export function buildExternalCoverageSet(testLocations) {
-    const coverage = new Set();
-    let externalWithoutCoverage = 0;
-    for (const [testType, fileList] of Object.entries(testLocations)) {
-        const externalCount = (fileList.match(/\[external\]/g) || []).length;
-        const coveredCount = (fileList.match(/\[external\]\s*\(covers:/g) || []).length;
-        externalWithoutCoverage += externalCount - coveredCount;
-        for (const m of fileList.matchAll(/\[external\]\s*\(covers:\s*([^)]+)\)/g)) {
-            const endpoints = m[1].split(",").map(e => e.trim());
-            for (const ep of endpoints) {
-                const spaceIdx = ep.indexOf(" ");
-                if (spaceIdx < 0)
-                    continue;
-                const method = ep.slice(0, spaceIdx).toUpperCase();
-                const epPath = ep.slice(spaceIdx + 1);
-                const resource = extractResourceFromPath(epPath);
-                if (resource !== "unknown") {
-                    if (testType === "unknown") {
-                        coverage.add(coverageKey({ method, path: epPath, testType: "integration" }));
-                        coverage.add(coverageKey({ method, path: epPath, testType: "contract" }));
-                    }
-                    else {
-                        coverage.add(coverageKey({ method, path: epPath, testType }));
-                    }
-                }
-            }
+export function orderedLabels(keys, start = 1) {
+    const numeric = typeof start === "number";
+    const firstCode = numeric ? start : start.charCodeAt(0);
+    const out = {};
+    keys.forEach((key, i) => {
+        if (out[key] !== undefined) {
+            throw new Error(`orderedLabels: duplicate key "${key}"`);
         }
-    }
-    if (externalWithoutCoverage > 0) {
-        logger.info(`${externalWithoutCoverage} external test file(s) have no extractable endpoint coverage — ` +
-            `programmatic dedup skipped for these; prompt-level semantic coverage check is the fallback.`);
-    }
-    return coverage;
+        if (!numeric && firstCode + i > "z".charCodeAt(0)) {
+            throw new Error(`orderedLabels: ran past "z" at key "${key}"`);
+        }
+        out[key] = numeric
+            ? String(firstCode + i)
+            : String.fromCharCode(firstCode + i);
+    });
+    return out;
 }
 // Shared Testbot task and step labels used by prompt modules that cannot import
-// testbot-prompts.ts directly without creating a circular dependency.
-export const TASK_UI_PRESCAN = "0";
-export const TASK_ANALYZE_MAINTAIN = "1";
-export const TASK_GENERATE = "2";
-export const TASK_SUBMIT = "3";
-export const TESTBOT_TASK1_STEP_ANALYZE = "1";
-export const TESTBOT_TASK1_STEP_MAINTAIN = "2";
-export const TESTBOT_TASK1_STEP_CODE_REVIEW = "3";
-export const TESTBOT_TASK1_STEP_UI_GROUNDING = "4";
+// testbot-prompts.ts directly without creating a circular dependency. Every
+// label comes from declaration order, so a task or step inserted here renumbers
+// its successors and every cross-reference at once.
+const TASK_LABELS = orderedLabels(["UI_PRESCAN", "ANALYZE_MAINTAIN", "GENERATE", "SUBMIT"], 0);
+export const TASK_ANALYZE_MAINTAIN = TASK_LABELS.ANALYZE_MAINTAIN;
+export const TASK_GENERATE = TASK_LABELS.GENERATE;
+export const TASK_SUBMIT = TASK_LABELS.SUBMIT;
+/** Top-level numbered steps of Task 1 ("Analyze & Maintain"). */
+export const TESTBOT_TASK1_STEP_LABELS = orderedLabels([
+    "ANALYZE",
+    "MAINTAIN",
+    "CODE_REVIEW",
+    "UI_GROUNDING",
+]);
+/** Lettered sub-steps of Task 1's "Maintain existing tests" step. */
+export const TESTBOT_TASK1_MAINTAIN_LABELS = orderedLabels([
+    "CONFIRM_EXTERNAL",
+    "TEST_HEALTH",
+    "UPDATE_INSTRUCTIONS",
+    "BASELINE",
+    "APPLY_ACTIONS",
+    "VERIFY_EXTERNAL",
+], "a");
+/** Lettered bullets of the multi-repo block inside Task 1's analyze step. */
+export const TESTBOT_TASK1_MULTIREPO_LABELS = orderedLabels(["REGISTER_SERVICES", "ANALYZE_REPO", "ON_FAILURE"], "a");
 export const taskRef = (taskId) => `Task ${taskId}`;
-export const taskStepRef = (taskId, stepId) => `Task ${taskId} Step ${stepId}`;
+/** A lettered sub-step, spelled the way the prompt body spells it: `step 2(a)`. */
+export const stepSubRef = (stepId, subId) => `step ${stepId}(${subId})`;

package/build/prompts/test-recommendation/registerRecommendTestsPrompt.d.ts

@@ -1,7 +1,2 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { DraftedScenario } from "../../types/RepositoryAnalysis.js";
-export declare function mergeEnrichedScenarios(serverScenarios: DraftedScenario[], raw: string): {
-    scenarios: DraftedScenario[];
-    rejectionNotes: string[];
-};
 export declare function registerRecommendTestsPrompt(server: McpServer): void;

package/build/prompts/test-recommendation/registerRecommendTestsPrompt.js

@@ -2,147 +2,20 @@ import { z } from "zod";
 import { StateManager, hasSessionData, getSessionData, } from "../../utils/AnalysisStateManager.js";
 import { logger } from "../../utils/logger.js";
 import { buildRecommendationPrompt } from "./test-recommendation-prompt.js";
-import { ScenarioSource, AnalysisScope } from "../../types/RepositoryAnalysis.js";
-import { SCENARIO_CATEGORIES } from "../../types/TestRecommendation.js";
-import { inferExpectedStatus } from "../../utils/httpDefaults.js";
-/**
- * True when two step lists name the same method+path sequence, ignoring
- * everything else (body, description, ...). Used to decide whether a
- * previously-resolved `subjectEndpoints` still applies to an enriched
- * replacement — this function has no PR diff in scope, so it cannot call
- * `resolveSubjectEndpoints` itself (SKYR-4214).
- */
-function sameStepRouteSequence(a, b) {
-    if (a.length !== b.length)
-        return false;
-    return a.every((step, i) => (step.method ?? "").toUpperCase() === (b[i].method ?? "").toUpperCase() && step.path === b[i].path);
-}
-export function mergeEnrichedScenarios(serverScenarios, raw) {
-    const rejectionNotes = [];
-    let parsed;
-    try {
-        const result = JSON.parse(raw);
-        if (!Array.isArray(result)) {
-            return { scenarios: serverScenarios, rejectionNotes: ["enrichedScenarios: expected a JSON array, got " + typeof result] };
-        }
-        parsed = result;
-    }
-    catch {
-        logger.warning("enrichedScenarios: invalid JSON — using server-side scenarios only");
-        return { scenarios: serverScenarios, rejectionNotes: ["enrichedScenarios: invalid JSON — all scenarios skipped"] };
-    }
-    const agentScenarios = [];
-    for (const s of parsed) {
-        const name = s?.scenarioName ? String(s.scenarioName) : null;
-        const label = name ? `"${name}"` : "(unnamed)";
-        if (!name) {
-            rejectionNotes.push(`rejected ${label}: missing scenarioName`);
-            continue;
-        }
-        if (!Array.isArray(s?.steps) || s.steps.length === 0) {
-            rejectionNotes.push(`rejected ${label}: missing or empty steps array`);
-            continue;
-        }
-        if (!s?.category) {
-            rejectionNotes.push(`rejected ${label}: missing category`);
-            continue;
-        }
-        if (!SCENARIO_CATEGORIES.includes(s.category)) {
-            rejectionNotes.push(`rejected ${label}: unknown category "${s.category}" — valid: ${SCENARIO_CATEGORIES.join(", ")}`);
-            continue;
-        }
-        agentScenarios.push({
-            scenarioName: name,
-            description: s.description ?? "",
-            category: s.category,
-            priority: s.priority ?? "high",
-            bugCatchingTarget: s.bugCatchingTarget,
-            testType: s.testType,
-            steps: s.steps.map((st, idx) => ({
-                order: st.order ?? idx + 1,
-                method: String(st.method ?? "GET").toUpperCase(),
-                path: String(st.path ?? "/"),
-                description: st.description ?? `${st.method} ${st.path}`,
-                interactionType: st.interactionType ?? "success",
-                requestBody: st.requestBody,
-                queryParams: st.queryParams,
-                responseBody: st.responseBody,
-                // Default status code by method if omitted to avoid `statusCode: undefined` in tool calls
-                expectedStatusCode: st.expectedStatusCode ?? inferExpectedStatus(String(st.method ?? "GET")),
-                expectedResponseFields: st.expectedResponseFields,
-                bodyMustInclude: st.bodyMustInclude,
-                chainsFrom: st.chainsFrom,
-            })),
-            chainingKeys: s.chainingKeys ?? [],
-            requiresAuth: s.requiresAuth ?? true,
-            estimatedComplexity: s.estimatedComplexity ?? "moderate",
-            source: ScenarioSource.AgentEnriched,
-        });
-    }
-    if (agentScenarios.length === 0) {
-        return { scenarios: serverScenarios, rejectionNotes };
-    }
-    const merged = new Map(serverScenarios.map(s => [s.scenarioName, s]));
-    for (const s of agentScenarios) {
-        const replaced = merged.get(s.scenarioName);
-        // The agent-submitted copy never carries subjectEndpoints — it is built
-        // fresh from the enriched JSON, not through resolveSubjectEndpoints. When
-        // the replaced server scenario had one and the steps still name the same
-        // endpoints, carry it forward so this candidate keeps the one recorded
-        // subject instead of falling back to a fresh last-mutating-step guess
-        // that could disagree with its siblings (SKYR-4214).
-        if (replaced?.subjectEndpoints && sameStepRouteSequence(replaced.steps, s.steps)) {
-            s.subjectEndpoints = replaced.subjectEndpoints;
-        }
-        merged.set(s.scenarioName, s);
-    }
-    logger.info("Merged agent-enriched scenarios", {
-        server: serverScenarios.length,
-        agent: agentScenarios.length,
-        total: merged.size,
-        rejected: rejectionNotes.length,
-    });
-    return { scenarios: Array.from(merged.values()), rejectionNotes };
-}
+import { AnalysisScope } from "../../types/RepositoryAnalysis.js";
 export function registerRecommendTestsPrompt(server) {
     server.registerPrompt("skyramp_recommend_tests", {
-        description: "Given the repository analysis in stateFile, produce ranked test recommendations split into " +
-            "GENERATE (call generation tools immediately) and ADDITIONAL (deferred, describe only).\n\n" +
-            "**Output contract:** Every GENERATE integration test targeting a business rule or formula " +
-            "MUST include a non-empty bugCatchingTarget. Parameters for generation tools must derive " +
-            "from the repository analysis, enrichedScenarios, or source code you read — no invented " +
-            "field names, no guessed URLs.\n\n" +
-            "**Ranking:** Prioritize business_rule and security_boundary over crud. Within a category, " +
-            "prefer tests that catch specific formulas, constraints, or state transitions over generic " +
-            "happy-path coverage. Provide a stateFile path from skyramp_analyze_changes.",
+        description: "Given the repository analysis in stateFile, produce the test recommendations this change " +
+            "warrants. The server drafts candidates and states no count; you decide which of them, and " +
+            "which of your own, this change is worth.\n\n" +
+            "**Output contract:** Every recommendation names the specific bug or failure it targets. " +
+            "Parameters for generation tools must derive from the repository analysis, enrichedScenarios, " +
+            "or source code you read — no invented field names, no guessed URLs. Provide a stateFile path " +
+            "from skyramp_analyze_changes.",
         argsSchema: {
             stateFile: z
                 .string()
                 .describe("State file path returned by skyramp_analyze_changes"),
-            topN: z
-                .number()
-                .int()
-                .positive()
-                .default(10)
-                .optional()
-                .describe("Maximum number of ranked recommendations to return (default: 10)"),
-            enrichedScenarios: z
-                .string()
-                .optional()
-                .refine((val) => {
-                if (val === undefined || val === "")
-                    return true;
-                try {
-                    const parsed = JSON.parse(val);
-                    return Array.isArray(parsed);
-                }
-                catch {
-                    return false;
-                }
-            }, { message: "enrichedScenarios must be a valid JSON array string (e.g. '[{\"scenarioName\":\"...\"}]')" })
-                .describe("JSON array of agent-drafted scenarios (DraftedScenario[]). Each must have " +
-                "scenarioName, category, and steps (array with method, path, order). " +
-                "Agent scenarios override server-side ones by scenarioName and are prioritized in ranking."),
         },
     }, async (args) => {
         const stateFile = args.stateFile;
@@ -203,24 +76,8 @@ export function registerRecommendTestsPrompt(server) {
         const analysisScope = rawScope === "branch_diff" || rawScope === AnalysisScope.CurrentBranchDiff
             ? AnalysisScope.CurrentBranchDiff
             : AnalysisScope.FullRepo;
-        const effectiveTopN = args.topN;
-        const enrichedRaw = args.enrichedScenarios;
-        let mergedAnalysis = fullAnalysis;
-        let rejectionWarning = "";
-        if (enrichedRaw) {
-            const { scenarios, rejectionNotes } = mergeEnrichedScenarios(fullAnalysis.businessContext.draftedScenarios ?? [], enrichedRaw);
-            mergedAnalysis = {
-                ...fullAnalysis,
-                businessContext: {
-                    ...fullAnalysis.businessContext,
-                    draftedScenarios: scenarios,
-                },
-            };
-            if (rejectionNotes.length > 0) {
-                rejectionWarning = `\n⚠️ enrichedScenarios — ${rejectionNotes.length} scenario(s) rejected and not used in recommendations:\n${rejectionNotes.map(n => `  - ${n}`).join("\n")}\nFix and re-call skyramp_recommend_tests to incorporate corrections.\n`;
-            }
-        }
-        const prompt = buildRecommendationPrompt(mergedAnalysis, analysisScope, effectiveTopN, undefined, wsAuthHeader, wsAuthType, wsAuthScheme, undefined, sessionId);
+        const rejectionWarning = "";
+        const prompt = buildRecommendationPrompt(fullAnalysis, analysisScope, undefined, wsAuthHeader, wsAuthType, wsAuthScheme, sessionId);
         logger.info("Serving recommendation prompt via MCP Prompt", {
             stateFile,
             analysisScope,

package/build/prompts/test-recommendation/test-recommendation-prompt.d.ts

@@ -1,31 +1,4 @@
-import { RepositoryAnalysis, AnalysisScope, DraftedScenario } from "../../types/RepositoryAnalysis.js";
+import { RepositoryAnalysis, AnalysisScope } from "../../types/RepositoryAnalysis.js";
 import { WorkspaceAuthType } from "../../utils/workspaceAuth.js";
 import { PRTestContext } from "../../utils/pr-comment-parser.js";
-import { Novelty, PriorityTier } from "../../types/TestRecommendation.js";
-import { buildExternalCoverageSet, externalDedupKeys } from "./recommendationShared.js";
-export { buildExternalCoverageSet, externalDedupKeys };
-/** Result of {@link computeScoredCandidates} — the scoring/classification
- *  inputs shared between prompt rendering and the SKYR-3879 register-plan
- *  pre-seed (analyzeChangesTool.ts), so both derive the exact same numbers. */
-export interface ScoredCandidatesResult {
-    scored: Array<{
-        scenario: DraftedScenario;
-        priority: PriorityTier;
-        novelty: Novelty;
-    }>;
-    filteredChangedFiles: string[];
-    isUIOnlyPR: boolean;
-    hasFrontendChanges: boolean;
-    hasApiChanges: boolean;
-    maxGen: number;
-    seed: string;
-}
-/**
- * Compute the pre-ranked scenario scoring, the UI/API classification flags,
- * and the effective GENERATE cap — extracted from buildRecommendationPrompt
- * so skyramp_analyze_changes (SKYR-3879 Path B pre-seed) can derive the exact
- * same candidate set the Execution Plan prompt is built from, without
- * duplicating (and risking drift from) this scoring logic.
- */
-export declare function computeScoredCandidates(analysis: RepositoryAnalysis, analysisScope?: AnalysisScope, topN?: number, maxGenerateOverride?: number): ScoredCandidatesResult;
-export declare function buildRecommendationPrompt(analysis: RepositoryAnalysis, analysisScope?: AnalysisScope, topN?: number, prContext?: PRTestContext, workspaceAuthHeader?: string, workspaceAuthType?: WorkspaceAuthType, workspaceAuthScheme?: string, maxGenerateOverride?: number, sessionId?: string): string;
+export declare function buildRecommendationPrompt(analysis: RepositoryAnalysis, analysisScope?: AnalysisScope, prContext?: PRTestContext, workspaceAuthHeader?: string, workspaceAuthType?: WorkspaceAuthType, workspaceAuthScheme?: string, sessionId?: string): string;