@skyramp/mcp 0.0.57 → 0.0.59

package/build/prompts/testbot/testbot-prompts.js

@@ -2,7 +2,7 @@ import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { logger } from "../../utils/logger.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
-function getTestbotPrompt(prTitle, prDescription, diffFile, testDirectory, summaryOutputFile, repositoryPath) {
+function getTestbotPrompt(prTitle, prDescription, diffFile, testDirectory, summaryOutputFile, repositoryPath, baseBranch) {
     return `<TITLE>${prTitle}</TITLE>
 <DESCRIPTION>${prDescription}</DESCRIPTION>
 <CODE CHANGES>${diffFile}</CODE CHANGES>
@@ -11,35 +11,72 @@ function getTestbotPrompt(prTitle, prDescription, diffFile, testDirectory, summa
 
 For all the following work, use the tools offered by Skyramp MCP server.
 
-First analyze the pull request title, description, and code changes to determine a business case
-justification for this code change.
-
 Then perform ALL of the following tasks. Every task is MANDATORY — do NOT skip any task based on your own judgment unless the task itself gives you an explicit condition to skip.
 
-## Task 1: Recommend New Tests (MANDATORY)
+## Task 1: Recommend New Tests (MANDATORY — but skip if no application code changed)
+
+Read the diff at \`${diffFile}\`. Classify EVERY changed file using these categories:
+
+**Non-application files (DO NOT generate tests for these):**
+- CI/CD workflow files (.github/workflows/*.yml, .gitlab-ci.yml, Jenkinsfile, etc.)
+- Markdown documentation (.md files, README, CHANGELOG, CONTRIBUTING, etc.)
+- Dependency lock files (package-lock.json, yarn.lock, Pipfile.lock, poetry.lock, Gemfile.lock, go.sum, etc.)
+- Configuration-only files (.gitignore, .editorconfig, .prettierrc, renovate.json, dependabot.yml, etc.)
+- License files (LICENSE, NOTICE, etc.)
 
-Read the diff at \`${diffFile}\`. Classify each changed file. A file is application source code if it is any of: a route/controller/handler, a model/schema/validator/serializer/DTO, business logic, middleware, service, utility, test helper, or has a source extension (.py, .ts, .js, .java, .go, .rb, .cs, .kt, .swift, etc.). When in doubt, treat the file as application source code.
+**Application source code (generate tests for these):**
+- Routes, controllers, handlers, API endpoints
+- Models, schemas, validators, serializers, DTOs
+- Business logic, services, middleware, utilities
+- Test helpers and test fixtures
+- Any file with a source extension (.py, .ts, .js, .java, .go, .rb, .cs, .kt, .swift, etc.) that is NOT in the non-application list above
 
-**DEFAULT: You MUST run steps 1–5 below.** The only exception is if you can confirm that EVERY changed file is exclusively a CI workflow YAML, markdown documentation, README, CHANGELOG, or a dependency lock file — and nothing else.
+**SKIP RULE — THIS IS MANDATORY:**
+If EVERY changed file in the diff falls into the "non-application files" category above, you MUST skip steps 1–6 entirely. Do NOT call \`skyramp_analyze_repository\`, do NOT call \`skyramp_map_tests\`, do NOT generate any tests. Instead, proceed directly to Task 2. In your report, state: "Task 1 skipped: PR contains only non-application changes (CI/docs/config)."
+
+**When in doubt:** If even ONE changed file looks like it could be application source code, run steps 1–6.
 
 1. Call \`skyramp_analyze_repository\` with:
    - \`repositoryPath\`: "${repositoryPath}"
-   - \`analysisScope\`: "current_branch_diff"
+   - \`analysisScope\`: "current_branch_diff"${baseBranch ? `\n   - \`baseBranch\`: "${baseBranch}"` : ''}
 2. MANDATORY: Call \`skyramp_map_tests\` with \`stateFile\` (the state file path returned above) and \`analysisScope: "current_branch_diff"\`.
 3. MANDATORY: Call \`skyramp_recommend_tests\` with the \`stateFile\` returned by \`skyramp_map_tests\`. Use the priority summary and the specific endpoints/files that changed to determine exactly what to test.
 4. Generate tests using the Skyramp MCP generate tools, in priority order (minimum 3 test types).
 5. Use Skyramp MCP to execute the generated tests and validate the results.
+6. **E2E / UI Test Generation from Trace Files**: Search the repository for existing Skyramp trace files that can be used for E2E or UI test generation. Look for:
+   - Backend trace files: files matching patterns like \`**/skyramp*trace*.json\`, \`**/skyramp-traces.json\`, or \`**/*trace*.json\` in test directories
+   - Playwright UI trace files: files matching patterns like \`**/skyramp*playwright*.zip\`, \`**/*playwright*.zip\`, or \`**/*ui*trace*.zip\`
+   Search in the test directory (\`${testDirectory}\`), the repository root, and any \`.skyramp/\` directories.
+   - If you find BOTH a backend trace file AND a Playwright trace ZIP, call \`skyramp_e2e_test_generation\` with both files to generate an E2E test.
+   - If you find ONLY a Playwright trace ZIP (no backend trace), call \`skyramp_ui_test_generation\` with the Playwright file to generate a UI test.
+   - When generating E2E/UI tests, use the same language and framework as other tests in the repository. Default to Python with pytest if no convention is detected.
+   - Execute any generated E2E/UI tests to validate them. Note: Playwright browsers are pre-installed in the CI environment.
+
+**IMPORTANT — Endpoint Renames:** If the diff shows an endpoint path was renamed (e.g. \`/products\` changed to \`/items\`) and existing tests already cover that endpoint under the old name, do NOT generate new tests for the renamed endpoint. The existing tests will be updated with the new path in Task 2 (Test Maintenance). Only generate new tests for genuinely new endpoints that have no existing test coverage under any name.
 
 ## Task 2: Existing Test Maintenance (MANDATORY)
 
-You MUST always run steps 1–4 below. Do NOT skip this task based on your own assessment of whether tests exist or are relevant — use the tools to determine that.
+You MUST always run the steps below. Do NOT skip this task based on your own assessment of whether tests exist or are relevant — use the tools to determine that.
 
 1. Call \`skyramp_discover_tests\` with \`repositoryPath\`: "${repositoryPath}" to find all existing Skyramp-generated tests.
-2. Call \`skyramp_analyze_test_drift\` with the \`stateFile\` returned by \`skyramp_discover_tests\`.
-3. Call \`skyramp_calculate_health_scores\` with the \`stateFile\` from the previous step.
-4. Call \`skyramp_actions\` with the updated \`stateFile\` to apply recommended updates.
-5. Execute any updated or affected tests using Skyramp MCP and validate the results.
-6. You may skip this task ONLY if \`skyramp_discover_tests\` explicitly returns zero Skyramp-generated tests.
+   You may skip the rest of this task ONLY if it explicitly returns zero Skyramp-generated tests.
+
+2. **Baseline — check for parallel CI first:**
+   a. Read the workflow files in \`.github/workflows/\` and check if any workflow (other than the Skyramp Testbot workflow) is triggered on \`pull_request\` AND runs tests against the test directory (look for commands like \`pytest\`, \`jest\`, \`npm test\`, \`go test\`, \`skyramp test\`, or similar test execution commands).
+   b. If such a workflow exists, run: \`gh run list --commit $(git rev-parse HEAD) --workflow <workflow-filename> --json status,conclusion --limit 1\` to check if it has completed for the current commit.
+   c. If the parallel workflow completed successfully — record beforeStatus as "Pass" for the discovered tests and note "baseline from CI workflow <workflow-name>" in beforeDetails. Skip to step 3.
+   d. If the parallel workflow completed with failure — record beforeStatus as "Fail" and capture the failure context in beforeDetails. Skip to step 3.
+   e. If no parallel test workflow exists, it hasn't completed yet, or the \`gh\` command fails for any reason (e.g. permissions, CLI not available) — execute ALL discovered tests AS-IS (before any modifications) using \`skyramp_execute_tests_batch\` or \`skyramp_execute_test\`. Record each test's status and details as the "before" results. In beforeDetails, describe the execution result (e.g. "Pass (10.8s)" or "Fail (404 Not Found)"). If you could not query CI, just note "unable to query existing CI pipeline" — do NOT expose internal details like authentication errors.
+
+3. Call \`skyramp_analyze_test_drift\` with the \`stateFile\` returned by \`skyramp_discover_tests\`.
+4. Call \`skyramp_calculate_health_scores\` with the \`stateFile\` from the previous step.
+5. Call \`skyramp_actions\` with the updated \`stateFile\`. This tool returns instructions describing what needs to change in each test file — it does NOT modify the files itself.
+6. **You MUST modify the existing test files in-place using your file editing tools.** Read the instructions from \`skyramp_actions\`, cross-reference with the code diff, and edit each test file directly.
+   - If \`skyramp_actions\` returns endpoint rename mappings (old path → new path), apply them as simple find-and-replace on the test file URLs. Do NOT regenerate or restructure the test — only update the paths.
+   - If \`skyramp_actions\` suggests file renames (e.g. \`products_smoke_test.py\` → \`items_smoke_test.py\`), rename the files using \`git mv\` after updating their content.
+   - The goal is to fix the discovered tests so they pass with the new code, preserving the original test structure and logic. Do NOT create new test files as a substitute for fixing existing ones.
+7. Execute the modified tests using Skyramp MCP and validate the results. This includes E2E and UI tests — Playwright browsers are pre-installed in the CI environment, so E2E/UI test execution is fully supported. Record each test's status and details as the "after" results.
+8. For each maintained test, report BOTH the before and after results in the \`testMaintenance\` array of the report (using the fileName, beforeStatus, beforeDetails, afterStatus, afterDetails fields), so the user has full visibility into whether the code change or the existing test was at fault.
 
 ## Task 3: Submit Report (MANDATORY)
 
@@ -55,6 +92,8 @@ Do NOT write the report to a file yourself. Do NOT skip this step. The skyramp_s
 
 ## Report Guidelines
 
+**businessCaseAnalysis:** Base this ONLY on facts from the PR title, description, and what the tools reported. If \`skyramp_analyze_repository\` reported 0 new endpoints, do NOT claim new endpoints were added — instead describe the change accurately (e.g. "frontend changes to consume existing API endpoints", "refactored service layer", "updated test configuration"). Never infer new backend endpoints from frontend fetch/API calls in the diff.
+
 When reporting test results, if you chose to skip executing a test, you MUST explain WHY you skipped it.
 NEVER use the phrase "CI timeout" or imply a timeout occurred unless a tool call actually timed out.
 Instead, set the status to "Skipped" and provide an honest reason in the details, for example:
@@ -70,9 +109,7 @@ export function registerTestbotPrompt(server) {
         description: "Run Skyramp TestBot to generate test recommendations and perform test maintenance for a pull request.",
         argsSchema: {
             prTitle: z.string().describe("Pull request title"),
-            prDescription: z
-                .string()
-                .describe("Pull request description/body"),
+            prDescription: z.string().describe("Pull request description/body"),
             diffFile: z.string().describe("Path to the git diff file"),
             testDirectory: z
                 .string()
@@ -85,9 +122,13 @@ export function registerTestbotPrompt(server) {
                 .string()
                 .default(".")
                 .describe("Absolute path to the repository being analyzed"),
+            baseBranch: z
+                .string()
+                .optional()
+                .describe("PR base branch name (e.g. 'main' or 'develop'). When provided, analyzeRepository diffs against this branch instead of auto-detecting."),
         },
     }, (args) => {
-        const prompt = getTestbotPrompt(args.prTitle, args.prDescription, args.diffFile, args.testDirectory, args.summaryOutputFile, args.repositoryPath);
+        const prompt = getTestbotPrompt(args.prTitle, args.prDescription, args.diffFile, args.testDirectory, args.summaryOutputFile, args.repositoryPath, args.baseBranch);
         AnalyticsService.pushMCPToolEvent("skyramp_testbot_prompt", undefined, {}).catch(() => { });
         return {
             messages: [
@@ -109,14 +150,16 @@ export function registerTestbotResource(server) {
     // fails on empty query-param values (e.g. prDescription=).
     // We then parse query params from the URL object which handles URL-decoding
     // and empty values correctly.
-    const template = new ResourceTemplate("skyramp://prompts/testbot{+rest}", { list: undefined });
+    const template = new ResourceTemplate("skyramp://prompts/testbot{+rest}", {
+        list: undefined,
+    });
     server.registerResource("skyramp_testbot", template, {
         title: "Skyramp TestBot Prompt",
         description: "Returns task instructions for PR test analysis, generation, and maintenance.",
         mimeType: "text/plain",
     }, (uri) => {
         const param = (name, fallback) => uri.searchParams.get(name) ?? fallback;
-        const prompt = getTestbotPrompt(param("prTitle", ""), param("prDescription", ""), param("diffFile", ".skyramp_git_diff"), param("testDirectory", "tests"), param("summaryOutputFile", ""), param("repositoryPath", "."));
+        const prompt = getTestbotPrompt(param("prTitle", ""), param("prDescription", ""), param("diffFile", ".skyramp_git_diff"), param("testDirectory", "tests"), param("summaryOutputFile", ""), param("repositoryPath", "."), uri.searchParams.get("baseBranch") || undefined);
         AnalyticsService.pushMCPToolEvent("skyramp_testbot_prompt", undefined, {}).catch(() => { });
         return {
             contents: [

package/build/services/DriftAnalysisService.js

@@ -394,29 +394,71 @@ export class EnhancedDriftAnalysisService {
             const newParsed = JSON.parse(newSchema);
             const changes = {
                 endpointsRemoved: [],
+                endpointsRenamed: [],
                 endpointsModified: [],
                 authenticationChanged: false,
             };
             const oldPaths = oldParsed.paths || {};
             const newPaths = newParsed.paths || {};
-            // Find removed endpoints
-            for (const path in oldPaths) {
-                if (!newPaths[path]) {
-                    for (const method in oldPaths[path]) {
-                        changes.endpointsRemoved.push({ path, method });
+            // Collect removed endpoints (old path not in new schema)
+            const removedEndpoints = [];
+            for (const pathStr in oldPaths) {
+                if (!newPaths[pathStr]) {
+                    for (const method in oldPaths[pathStr]) {
+                        removedEndpoints.push({ path: pathStr, method });
                     }
                 }
             }
+            // Collect added endpoints (new path not in old schema)
+            const addedEndpoints = [];
+            for (const pathStr in newPaths) {
+                if (!oldPaths[pathStr]) {
+                    for (const method in newPaths[pathStr]) {
+                        addedEndpoints.push({ path: pathStr, method });
+                    }
+                }
+            }
+            // Detect renames: match removed endpoints to added endpoints
+            const matchedRemoved = new Set();
+            const matchedAdded = new Set();
+            for (const removed of removedEndpoints) {
+                const removedKey = `${removed.path}::${removed.method}`;
+                if (matchedRemoved.has(removedKey))
+                    continue;
+                for (const added of addedEndpoints) {
+                    const addedKey = `${added.path}::${added.method}`;
+                    if (matchedAdded.has(addedKey))
+                        continue;
+                    if (this.isEndpointRename(removed.path, added.path, removed.method, added.method, oldPaths, newPaths)) {
+                        changes.endpointsRenamed.push({
+                            oldPath: removed.path,
+                            newPath: added.path,
+                            method: removed.method,
+                        });
+                        matchedRemoved.add(removedKey);
+                        matchedAdded.add(addedKey);
+                        logger.info(`Detected endpoint rename: ${removed.method} ${removed.path} -> ${added.path}`);
+                        break;
+                    }
+                }
+            }
+            // Remaining unmatched removals are true removals
+            for (const removed of removedEndpoints) {
+                const removedKey = `${removed.path}::${removed.method}`;
+                if (!matchedRemoved.has(removedKey)) {
+                    changes.endpointsRemoved.push(removed);
+                }
+            }
             // Find modified endpoints and removed methods from existing paths
-            for (const path in oldPaths) {
-                if (newPaths[path]) {
-                    for (const method in oldPaths[path]) {
-                        if (newPaths[path][method]) {
-                            const oldEndpoint = JSON.stringify(oldPaths[path][method]);
-                            const newEndpoint = JSON.stringify(newPaths[path][method]);
+            for (const pathStr in oldPaths) {
+                if (newPaths[pathStr]) {
+                    for (const method in oldPaths[pathStr]) {
+                        if (newPaths[pathStr][method]) {
+                            const oldEndpoint = JSON.stringify(oldPaths[pathStr][method]);
+                            const newEndpoint = JSON.stringify(newPaths[pathStr][method]);
                             if (oldEndpoint !== newEndpoint) {
                                 changes.endpointsModified.push({
-                                    path,
+                                    path: pathStr,
                                     method,
                                     changes: ["Parameters or response modified"],
                                 });
@@ -424,7 +466,7 @@ export class EnhancedDriftAnalysisService {
                         }
                         else {
                             // Method exists in old schema but not in new schema
-                            changes.endpointsRemoved.push({ path, method });
+                            changes.endpointsRemoved.push({ path: pathStr, method });
                         }
                     }
                 }
@@ -448,6 +490,73 @@ export class EnhancedDriftAnalysisService {
             return undefined;
         }
     }
+    /**
+     * Determine if a removed endpoint and an added endpoint represent a rename.
+     *
+     * Heuristics:
+     * 1. Must have the same HTTP method
+     * 2. Must have the same path structure (same number of segments, same param names)
+     * 3. The operations must be structurally similar (same response codes, similar params)
+     */
+    isEndpointRename(oldPath, newPath, oldMethod, newMethod, oldPaths, newPaths) {
+        // Must be the same HTTP method
+        if (oldMethod !== newMethod)
+            return false;
+        const oldSegments = oldPath.split("/").filter((s) => s.length > 0);
+        const newSegments = newPath.split("/").filter((s) => s.length > 0);
+        // Must have same number of path segments
+        if (oldSegments.length !== newSegments.length)
+            return false;
+        // Path parameters (e.g., {product_id}) must be in the same positions
+        const paramPattern = /^\{[^}]+\}$/;
+        let staticDiffs = 0;
+        for (let i = 0; i < oldSegments.length; i++) {
+            const oldIsParam = paramPattern.test(oldSegments[i]);
+            const newIsParam = paramPattern.test(newSegments[i]);
+            if (oldIsParam !== newIsParam)
+                return false; // Structural mismatch
+            if (oldIsParam && newIsParam) {
+                // Both are params — param names may differ but structure matches
+                continue;
+            }
+            if (oldSegments[i] !== newSegments[i]) {
+                staticDiffs++;
+            }
+        }
+        // At least one static segment must differ (otherwise paths are identical)
+        // But not too many — more than half differing suggests unrelated endpoints
+        if (staticDiffs === 0)
+            return false;
+        const staticSegments = oldSegments.filter((s) => !paramPattern.test(s));
+        if (staticDiffs > Math.max(1, Math.ceil(staticSegments.length / 2))) {
+            return false;
+        }
+        // Compare operation structure: same response codes is a strong signal
+        const oldOp = oldPaths[oldPath]?.[oldMethod];
+        const newOp = newPaths[newPath]?.[newMethod];
+        if (oldOp && newOp) {
+            const oldResponses = Object.keys(oldOp.responses || {}).sort();
+            const newResponses = Object.keys(newOp.responses || {}).sort();
+            if (oldResponses.length > 0 &&
+                newResponses.length > 0 &&
+                JSON.stringify(oldResponses) === JSON.stringify(newResponses)) {
+                return true; // Same method, similar structure, same response codes
+            }
+            // Fallback: if response codes differ, check parameter count similarity
+            const oldParamCount = (oldOp.parameters || []).length;
+            const newParamCount = (newOp.parameters || []).length;
+            const hasOldBody = !!oldOp.requestBody;
+            const hasNewBody = !!newOp.requestBody;
+            if (oldParamCount === newParamCount && hasOldBody === hasNewBody) {
+                return true;
+            }
+            // Operation data exists but doesn't match — not a rename
+            return false;
+        }
+        // If we can't access operations, rely on structural match alone
+        // (same segments, same params, only 1 static segment differs)
+        return staticDiffs === 1;
+    }
     /**
      * Extract API schema path from test file comments/metadata
      */
@@ -635,6 +744,17 @@ export class EnhancedDriftAnalysisService {
                     severity: "high",
                 });
             }
+            if (apiSchemaChanges.endpointsRenamed.length > 0) {
+                for (const renamed of apiSchemaChanges.endpointsRenamed) {
+                    changes.push({
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: `Endpoint renamed: ${renamed.method} ${renamed.oldPath} -> ${renamed.newPath}`,
+                        severity: "high",
+                        details: `Path changed from ${renamed.oldPath} to ${renamed.newPath}. Test endpoint URLs must be updated.`,
+                    });
+                }
+            }
             if (apiSchemaChanges.endpointsModified.length > 0) {
                 changes.push({
                     type: "endpoint_modified",
@@ -828,6 +948,7 @@ export class EnhancedDriftAnalysisService {
         // API schema changes
         if (apiSchemaChanges) {
             score += apiSchemaChanges.endpointsRemoved.length * 15;
+            score += apiSchemaChanges.endpointsRenamed.length * 12;
             score += apiSchemaChanges.endpointsModified.length * 10;
             if (apiSchemaChanges.authenticationChanged)
                 score += 25;
@@ -870,6 +991,11 @@ export class EnhancedDriftAnalysisService {
         }
         // Specific recommendations
         if (apiSchemaChanges) {
+            if (apiSchemaChanges.endpointsRenamed.length > 0) {
+                for (const renamed of apiSchemaChanges.endpointsRenamed) {
+                    recommendations.push(`🔄 Endpoint renamed: ${renamed.method} ${renamed.oldPath} -> ${renamed.newPath} — update test URL paths`);
+                }
+            }
             if (apiSchemaChanges.endpointsRemoved.length > 0) {
                 recommendations.push(`⚠️  ${apiSchemaChanges.endpointsRemoved.length} API endpoint(s) removed - update test`);
             }

package/build/services/DriftAnalysisService.test.js

@@ -0,0 +1,168 @@
+import { EnhancedDriftAnalysisService } from "./DriftAnalysisService.js";
+describe("DriftAnalysisService", () => {
+    let service;
+    beforeEach(() => {
+        service = new EnhancedDriftAnalysisService();
+    });
+    describe("isEndpointRename", () => {
+        // Helper to call the private method
+        function isRename(oldPath, newPath, oldMethod, newMethod, oldPaths = {}, newPaths = {}) {
+            return service["isEndpointRename"](oldPath, newPath, oldMethod, newMethod, oldPaths, newPaths);
+        }
+        // --- Basic rename detection ---
+        it("should detect a simple prefix rename", () => {
+            const oldPaths = {
+                "/api/v1/products": {
+                    get: { responses: { "200": {}, "404": {} } },
+                },
+            };
+            const newPaths = {
+                "/api/v1/items": {
+                    get: { responses: { "200": {}, "404": {} } },
+                },
+            };
+            expect(isRename("/api/v1/products", "/api/v1/items", "get", "get", oldPaths, newPaths)).toBe(true);
+        });
+        it("should detect rename with path parameters", () => {
+            const oldPaths = {
+                "/api/v1/products/{product_id}": {
+                    get: { responses: { "200": {}, "404": {} } },
+                },
+            };
+            const newPaths = {
+                "/api/v1/items/{product_id}": {
+                    get: { responses: { "200": {}, "404": {} } },
+                },
+            };
+            expect(isRename("/api/v1/products/{product_id}", "/api/v1/items/{product_id}", "get", "get", oldPaths, newPaths)).toBe(true);
+        });
+        it("should detect version bump as rename", () => {
+            const oldPaths = {
+                "/api/v1/products": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            const newPaths = {
+                "/api/v2/products": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            expect(isRename("/api/v1/products", "/api/v2/products", "get", "get", oldPaths, newPaths)).toBe(true);
+        });
+        it("should detect rename across multiple HTTP methods independently", () => {
+            const oldPaths = {
+                "/api/v1/products": {
+                    post: { responses: { "201": {} }, requestBody: {} },
+                },
+            };
+            const newPaths = {
+                "/api/v1/items": {
+                    post: { responses: { "201": {} }, requestBody: {} },
+                },
+            };
+            expect(isRename("/api/v1/products", "/api/v1/items", "post", "post", oldPaths, newPaths)).toBe(true);
+        });
+        // --- Should NOT match ---
+        it("should not match different HTTP methods", () => {
+            expect(isRename("/api/v1/products", "/api/v1/items", "get", "post")).toBe(false);
+        });
+        it("should not match paths with different segment counts", () => {
+            expect(isRename("/api/v1/products", "/api/v1/items/catalog", "get", "get")).toBe(false);
+        });
+        it("should not match identical paths", () => {
+            expect(isRename("/api/v1/products", "/api/v1/products", "get", "get")).toBe(false);
+        });
+        it("should not match when a static segment becomes a parameter", () => {
+            expect(isRename("/api/v1/products", "/api/v1/{resource}", "get", "get")).toBe(false);
+        });
+        it("should not match paths where too many segments differ", () => {
+            // 3 out of 3 static segments differ — clearly unrelated endpoints
+            const oldPaths = {
+                "/api/v1/products": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            const newPaths = {
+                "/rest/v2/orders": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            expect(isRename("/api/v1/products", "/rest/v2/orders", "get", "get", oldPaths, newPaths)).toBe(false);
+        });
+        it("should not match when response codes differ and params differ", () => {
+            const oldPaths = {
+                "/api/v1/products": {
+                    get: { responses: { "200": {} }, parameters: [{ name: "limit" }] },
+                },
+            };
+            const newPaths = {
+                "/api/v1/items": {
+                    get: { responses: { "201": {} } },
+                },
+            };
+            expect(isRename("/api/v1/products", "/api/v1/items", "get", "get", oldPaths, newPaths)).toBe(false);
+        });
+        // --- Structural fallback (no operation data) ---
+        it("should match with single static segment diff when no operation data", () => {
+            // Only 1 segment differs, no operation data — should match on structure alone
+            expect(isRename("/api/v1/products", "/api/v1/items", "get", "get", {}, {})).toBe(true);
+        });
+        it("should not match with 2+ static segment diffs when no operation data", () => {
+            expect(isRename("/api/v1/products", "/api/v2/items", "get", "get", {}, {})).toBe(false);
+        });
+        // --- Edge cases ---
+        it("should handle root-level path rename", () => {
+            const oldPaths = { "/products": { get: { responses: { "200": {} } } } };
+            const newPaths = { "/items": { get: { responses: { "200": {} } } } };
+            expect(isRename("/products", "/items", "get", "get", oldPaths, newPaths)).toBe(true);
+        });
+        it("should handle deeply nested paths", () => {
+            const oldPaths = {
+                "/api/v1/store/products/{id}/reviews": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            const newPaths = {
+                "/api/v1/store/items/{id}/reviews": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            expect(isRename("/api/v1/store/products/{id}/reviews", "/api/v1/store/items/{id}/reviews", "get", "get", oldPaths, newPaths)).toBe(true);
+        });
+        it("should match when param names differ but positions match", () => {
+            const oldPaths = {
+                "/api/v1/products/{product_id}": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            const newPaths = {
+                "/api/v1/items/{item_id}": {
+                    get: { responses: { "200": {} } },
+                },
+            };
+            expect(isRename("/api/v1/products/{product_id}", "/api/v1/items/{item_id}", "get", "get", oldPaths, newPaths)).toBe(true);
+        });
+        it("should match based on parameter count and request body similarity", () => {
+            const oldPaths = {
+                "/api/v1/products": {
+                    post: {
+                        responses: { "201": {} },
+                        parameters: [{ name: "x" }],
+                        requestBody: { content: {} },
+                    },
+                },
+            };
+            const newPaths = {
+                "/api/v1/items": {
+                    post: {
+                        responses: { "200": {} }, // Different response code
+                        parameters: [{ name: "y" }],
+                        requestBody: { content: {} },
+                    },
+                },
+            };
+            // Response codes differ, but param count and body presence match
+            expect(isRename("/api/v1/products", "/api/v1/items", "post", "post", oldPaths, newPaths)).toBe(true);
+        });
+    });
+});

package/build/services/TestExecutionService.js

@@ -6,7 +6,7 @@ import { stripVTControlCharacters } from "util";
 import { logger } from "../utils/logger.js";
 const DEFAULT_TIMEOUT = 300000; // 5 minutes
 const MAX_CONCURRENT_EXECUTIONS = 5;
-export const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.10";
+export const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.11";
 const DOCKER_PLATFORM = "linux/amd64";
 const EXECUTION_PROGRESS_INTERVAL = 10000; // 10 seconds between progress updates during execution
 // Files and directories to exclude when mounting workspace to Docker container

package/build/services/TestHealthService.js

@@ -68,7 +68,7 @@ export class TestHealthService {
             ? await this.extractEndpointFromTest(testFile, apiSchema)
             : undefined;
         // Generate recommendation
-        const recommendation = this.generateRecommendation(testFile, healthScore, drift?.driftScore, execution, issues, apiEndpoint);
+        const recommendation = this.generateRecommendation(testFile, healthScore, drift?.driftScore, execution, issues, apiEndpoint, drift?.apiSchemaChanges);
         return {
             testFile,
             healthScore,
@@ -265,6 +265,15 @@ export class TestHealthService {
                     details: `${drift.affectedFiles?.files.length || 0} file(s) changed`,
                 });
             }
+            const endpointsRenamed = drift.changes.filter((c) => c.type === "endpoint_renamed");
+            if (endpointsRenamed.length > 0) {
+                issues.push({
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: `${endpointsRenamed.length} API endpoint(s) renamed`,
+                    details: endpointsRenamed.map((c) => c.description).join("; "),
+                });
+            }
             const endpointsRemoved = drift.changes.filter((c) => c.type === "endpoint_removed");
             if (endpointsRemoved.length > 0) {
                 issues.push({
@@ -306,7 +315,7 @@ export class TestHealthService {
      *
      * Execution failures enhance rationale but don't change primary action
      */
-    generateRecommendation(testFile, healthScore, driftScore, execution, issues, apiEndpoint) {
+    generateRecommendation(testFile, healthScore, driftScore, execution, issues, apiEndpoint, apiSchemaChanges) {
         const drift = driftScore !== undefined ? driftScore : -1; // -1 means no drift data
         let action;
         let priority;
@@ -352,6 +361,21 @@ export class TestHealthService {
                 estimatedWork = "SMALL";
             }
         }
+        else if (issues && issues.some((i) => i.type === "endpoints_renamed")) {
+            // Endpoint renamed -> UPDATE with path substitution (regardless of drift score)
+            action = "UPDATE";
+            priority = "HIGH";
+            rationale =
+                "Endpoint path renamed - test URLs must be updated to match new path";
+            estimatedWork = "SMALL";
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            if (renameIssue?.details) {
+                rationale += `. ${renameIssue.details}`;
+            }
+            if (execution && !execution.passed) {
+                rationale += ". Test is currently failing due to the path change";
+            }
+        }
         else if (drift > 70) {
             // High drift -> REGENERATE
             action = "REGENERATE";
@@ -391,6 +415,7 @@ export class TestHealthService {
             const schemaChanges = issues?.filter((i) => [
                 "schema_changes",
                 "endpoints_removed",
+                "endpoints_renamed",
                 "authentication_changed",
             ].includes(i.type));
             if (schemaChanges && schemaChanges.length > 0) {
@@ -439,7 +464,11 @@ export class TestHealthService {
         }
         // Determine endpoint status
         let endpointStatus;
-        if (apiEndpoint === undefined) {
+        const renameIssues = issues?.filter((i) => i.type === "endpoints_renamed");
+        if (renameIssues && renameIssues.length > 0) {
+            endpointStatus = "renamed";
+        }
+        else if (apiEndpoint === undefined) {
             endpointStatus = undefined;
         }
         else if (apiEndpoint.exists) {
@@ -448,6 +477,11 @@ export class TestHealthService {
         else {
             endpointStatus = "missing";
         }
+        // Extract rename mappings from apiSchemaChanges for downstream tools
+        const renamedEndpoints = apiSchemaChanges?.endpointsRenamed &&
+            apiSchemaChanges.endpointsRenamed.length > 0
+            ? apiSchemaChanges.endpointsRenamed
+            : undefined;
         return {
             testFile,
             action,
@@ -459,6 +493,7 @@ export class TestHealthService {
                 driftScore: drift,
                 executionPassed: execution?.passed,
                 endpointStatus,
+                renamedEndpoints,
             },
         };
     }

package/build/services/TestHealthService.test.js

@@ -0,0 +1,211 @@
+import { TestHealthService } from "./TestHealthService.js";
+describe("TestHealthService", () => {
+    let service;
+    beforeEach(() => {
+        service = new TestHealthService();
+    });
+    describe("identifyIssues - endpoint rename detection", () => {
+        function identifyIssues(execution, drift) {
+            return service["identifyIssues"](execution, drift);
+        }
+        it("should create an endpoints_renamed issue when drift has endpoint_renamed changes", () => {
+            const drift = {
+                testFile: "products_smoke_test.py",
+                lastCommit: "abc123",
+                currentCommit: "def456",
+                driftScore: 30,
+                changes: [
+                    {
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                        severity: "high",
+                        details: "Path changed from /api/v1/products to /api/v1/items",
+                    },
+                ],
+                affectedFiles: { files: ["src/routers/product.py"] },
+                analysisTimestamp: new Date().toISOString(),
+            };
+            const issues = identifyIssues(undefined, drift);
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            expect(renameIssue).toBeDefined();
+            expect(renameIssue?.severity).toBe("high");
+            expect(renameIssue?.description).toContain("1 API endpoint(s) renamed");
+        });
+        it("should not create endpoints_renamed issue when no renames in drift", () => {
+            const drift = {
+                testFile: "products_smoke_test.py",
+                lastCommit: "abc123",
+                currentCommit: "def456",
+                driftScore: 15,
+                changes: [
+                    {
+                        type: "endpoint_removed",
+                        file: "API Schema",
+                        description: "1 endpoint(s) removed",
+                        severity: "high",
+                    },
+                ],
+                affectedFiles: { files: [] },
+                analysisTimestamp: new Date().toISOString(),
+            };
+            const issues = identifyIssues(undefined, drift);
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            expect(renameIssue).toBeUndefined();
+            const removeIssue = issues.find((i) => i.type === "endpoints_removed");
+            expect(removeIssue).toBeDefined();
+        });
+        it("should handle multiple rename changes", () => {
+            const drift = {
+                testFile: "products_smoke_test.py",
+                lastCommit: "abc123",
+                currentCommit: "def456",
+                driftScore: 40,
+                changes: [
+                    {
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                        severity: "high",
+                    },
+                    {
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: "Endpoint renamed: post /api/v1/products -> /api/v1/items",
+                        severity: "high",
+                    },
+                ],
+                affectedFiles: { files: [] },
+                analysisTimestamp: new Date().toISOString(),
+            };
+            const issues = identifyIssues(undefined, drift);
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            expect(renameIssue).toBeDefined();
+            expect(renameIssue?.description).toContain("2 API endpoint(s) renamed");
+        });
+    });
+    describe("generateRecommendation - endpoint rename handling", () => {
+        function generateRecommendation(testFile, driftScore, execution, issues, apiEndpoint, apiSchemaChanges) {
+            const healthScore = service["calculateHealthScore"](execution
+                ? service["calculateExecutionScore"](execution).score
+                : undefined, driftScore);
+            return service["generateRecommendation"](testFile, healthScore, driftScore, execution, issues, apiEndpoint, apiSchemaChanges);
+        }
+        it("should return UPDATE action for endpoint renames regardless of drift score", () => {
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "1 API endpoint(s) renamed",
+                    details: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                },
+            ];
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            // Even with low drift score, renames should trigger UPDATE
+            const rec = generateRecommendation("products_smoke_test.py", 12, // low drift
+            undefined, issues, undefined, apiSchemaChanges);
+            expect(rec.action).toBe("UPDATE");
+            expect(rec.priority).toBe("HIGH");
+            expect(rec.rationale).toContain("renamed");
+            expect(rec.estimatedWork).toBe("SMALL");
+        });
+        it("should include renamedEndpoints in recommendation details", () => {
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "1 API endpoint(s) renamed",
+                    details: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                },
+            ];
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            const rec = generateRecommendation("products_smoke_test.py", 30, undefined, issues, undefined, apiSchemaChanges);
+            expect(rec.details?.endpointStatus).toBe("renamed");
+            expect(rec.details?.renamedEndpoints).toBeDefined();
+            expect(rec.details?.renamedEndpoints).toHaveLength(1);
+            expect(rec.details?.renamedEndpoints?.[0]).toEqual({
+                oldPath: "/api/v1/products",
+                newPath: "/api/v1/items",
+                method: "get",
+            });
+        });
+        it("should mention test failure in rationale when test is failing due to rename", () => {
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "1 API endpoint(s) renamed",
+                    details: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                },
+            ];
+            const execution = {
+                testFile: "products_smoke_test.py",
+                executedAt: new Date().toISOString(),
+                passed: false,
+                duration: 10000,
+                errors: ["404 Not Found"],
+                warnings: [],
+                crashed: false,
+            };
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            const rec = generateRecommendation("products_smoke_test.py", 30, execution, issues, undefined, apiSchemaChanges);
+            expect(rec.action).toBe("UPDATE");
+            expect(rec.rationale).toContain("failing");
+        });
+        it("should not set renamedEndpoints when there are no renames", () => {
+            const rec = generateRecommendation("orders_smoke_test.py", 5, undefined, [], { exists: true }, undefined);
+            expect(rec.action).toBe("VERIFY");
+            expect(rec.details?.renamedEndpoints).toBeUndefined();
+            expect(rec.details?.endpointStatus).toBe("exists");
+        });
+        it("should prefer rename handling over high-drift REGENERATE", () => {
+            // If drift is > 70 but it's caused by a rename, we should UPDATE not REGENERATE
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "5 API endpoint(s) renamed",
+                    details: "Multiple renames",
+                },
+            ];
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "post" },
+                    { oldPath: "/api/v1/products/{id}", newPath: "/api/v1/items/{id}", method: "get" },
+                    { oldPath: "/api/v1/products/{id}", newPath: "/api/v1/items/{id}", method: "put" },
+                    { oldPath: "/api/v1/products/{id}", newPath: "/api/v1/items/{id}", method: "delete" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            const rec = generateRecommendation("products_smoke_test.py", 75, // would normally trigger REGENERATE
+            undefined, issues, undefined, apiSchemaChanges);
+            // Rename detection should take priority over drift threshold
+            expect(rec.action).toBe("UPDATE");
+            expect(rec.estimatedWork).toBe("SMALL"); // renames are simple substitutions
+        });
+    });
+});

package/build/tools/submitReportTool.js

@@ -19,6 +19,14 @@ const newTestSchema = z.object({
 const descriptionSchema = z.object({
     description: z.string().describe("One-line description"),
 });
+const testMaintenanceSchema = z.object({
+    fileName: z.string().describe("Test file that was maintained, e.g. 'products_smoke_test.py'"),
+    description: z.string().describe("What was changed and why"),
+    beforeStatus: z.enum(["Pass", "Fail", "Error"]).describe("Test result BEFORE modification"),
+    beforeDetails: z.string().describe("Execution output/timing before modification, or 'baseline from CI workflow <name>' if a parallel workflow provided the baseline"),
+    afterStatus: z.enum(["Pass", "Fail", "Error", "Skipped"]).describe("Test result AFTER modification"),
+    afterDetails: z.string().describe("Execution output/timing after modification"),
+});
 export function registerSubmitReportTool(server) {
     server.registerTool(TOOL_NAME, {
         description: "Submit the final testbot report. Call this tool once after completing all test analysis, generation, and execution. " +
@@ -34,8 +42,8 @@ export function registerSubmitReportTool(server) {
                 .array(newTestSchema)
                 .describe("List of new tests created. Use empty array [] if none."),
             testMaintenance: z
-                .array(descriptionSchema)
-                .describe("List of existing test modifications. Use empty array [] if none."),
+                .array(testMaintenanceSchema)
+                .describe("List of existing test modifications with before/after execution results. Use empty array [] if none."),
             testResults: z
                 .array(testResultSchema)
                 .describe("List of ALL test execution results. One entry per test executed."),

package/build/tools/test-maintenance/actionsTool.js

@@ -2,7 +2,60 @@ import { z } from "zod";
 import { logger } from "../../utils/logger.js";
 import { StateManager, } from "../../utils/AnalysisStateManager.js";
 import * as fs from "fs";
+import * as path from "path";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
+/**
+ * Compute a suggested new filename when an endpoint is renamed.
+ *
+ * Extracts the differing static segments between oldPath and newPath,
+ * then replaces occurrences in the filename.
+ *
+ * Example:
+ *   testFile:  "/repo/tests/python/products_smoke_test.py"
+ *   oldPath:   "/api/v1/products"
+ *   newPath:   "/api/v1/items"
+ *   result:    "/repo/tests/python/items_smoke_test.py"
+ */
+export function computeRenamedTestFile(testFile, renames) {
+    const basename = path.basename(testFile);
+    let newBasename = basename;
+    for (const rename of renames) {
+        const oldSegments = rename.oldPath.split("/").filter((s) => s.length > 0);
+        const newSegments = rename.newPath.split("/").filter((s) => s.length > 0);
+        if (oldSegments.length !== newSegments.length)
+            continue;
+        const paramPattern = /^\{[^}]+\}$/;
+        for (let i = 0; i < oldSegments.length; i++) {
+            if (paramPattern.test(oldSegments[i]))
+                continue;
+            if (oldSegments[i] !== newSegments[i]) {
+                // Replace the old segment name in the filename with the new one
+                // Handle both exact matches and common variations:
+                //   "products" in "products_smoke_test.py"
+                //   "product" in "product_smoke_test.py" (singular)
+                const oldName = oldSegments[i].toLowerCase();
+                const newName = newSegments[i].toLowerCase();
+                if (newBasename.toLowerCase().includes(oldName)) {
+                    // Case-preserving replace
+                    const idx = newBasename.toLowerCase().indexOf(oldName);
+                    newBasename =
+                        newBasename.substring(0, idx) +
+                            newName +
+                            newBasename.substring(idx + oldName.length);
+                }
+            }
+        }
+    }
+    if (newBasename === basename)
+        return null; // No change needed
+    const newFilePath = path.join(path.dirname(testFile), newBasename);
+    // Don't suggest a rename if the target file already exists
+    if (fs.existsSync(newFilePath)) {
+        logger.info(`Skipping file rename suggestion: ${newFilePath} already exists`);
+        return null;
+    }
+    return newFilePath;
+}
 const actionsSchema = {
     stateFile: z
         .string()
@@ -70,6 +123,7 @@ Comprehensive report with executed actions, summary, and detailed analysis
                         rationale: test.recommendation.rationale,
                         estimatedWork: test.recommendation.estimatedWork,
                         issues: test.issues || [],
+                        renamedEndpoints: test.recommendation.details?.renamedEndpoints || [],
                     });
                 }
             });
@@ -130,11 +184,33 @@ Comprehensive report with executed actions, summary, and detailed analysis
                     logger.error(`Failed to read test file ${rec.testFile}: ${error.message}`);
                     continue;
                 }
+                // Check if this is a rename-driven update
+                const renames = rec.renamedEndpoints || [];
+                const isRenameUpdate = renames.length > 0;
                 // Build update instructions
                 let instruction = `\n### ${rec.testFile}\n\n`;
                 instruction += `**Priority:** ${rec.priority} | `;
                 instruction += `**Estimated Effort:** ${rec.estimatedWork || "Small"}\n\n`;
                 instruction += `**Why Update Needed:** ${rec.rationale}\n\n`;
+                if (isRenameUpdate) {
+                    instruction += `**🔄 Endpoint Rename Detected — Path Substitution Required:**\n\n`;
+                    instruction += `| Old Path | New Path | Method |\n`;
+                    instruction += `|----------|----------|--------|\n`;
+                    for (const rename of renames) {
+                        instruction += `| \`${rename.oldPath}\` | \`${rename.newPath}\` | ${rename.method} |\n`;
+                    }
+                    instruction += `\n`;
+                    instruction += `**Action:** Find-and-replace all occurrences of the old path with the new path in this test file. `;
+                    instruction += `Do NOT change any test logic, assertions, or structure — only update the URL paths.\n\n`;
+                    // Compute suggested file rename
+                    const suggestedNewFile = computeRenamedTestFile(rec.testFile, renames);
+                    if (suggestedNewFile) {
+                        instruction += `**📁 File Rename:** After updating the paths, rename this file:\n`;
+                        instruction += `- From: \`${path.basename(rec.testFile)}\`\n`;
+                        instruction += `- To: \`${path.basename(suggestedNewFile)}\`\n\n`;
+                        rec._suggestedNewFile = suggestedNewFile;
+                    }
+                }
                 if (driftData) {
                     instruction += `**Analysis:**\n`;
                     instruction += `- Drift Score: ${driftData.driftScore ?? "N/A"}\n`;
@@ -184,16 +260,46 @@ Comprehensive report with executed actions, summary, and detailed analysis
             responseText += `4. Show you the changes made\n\n`;
             responseText += `5. At the end of the tool execution, MUST display the below message\n`;
             responseText += `**This tool is currently in Early Preview stage. Please verify the results.**\n\n`;
+            // Collect all rename mappings across recommendations
+            const allRenames = [];
+            for (const rec of updateRecommendations) {
+                if (rec.renamedEndpoints && rec.renamedEndpoints.length > 0) {
+                    allRenames.push(...rec.renamedEndpoints);
+                }
+            }
+            // Deduplicate renames
+            const uniqueRenames = allRenames.filter((r, i, arr) => arr.findIndex((x) => x.oldPath === r.oldPath &&
+                x.newPath === r.newPath &&
+                x.method === r.method) === i);
             // Build LLM-only instructions (hidden from users)
-            const llmInstructions = `<!-- LLM_INSTRUCTIONS:
-{
-  "workflow": "test_maintenance",
-  "action": "execute_updates",
-  "auto_proceed": true,
-  "files_to_update": ${JSON.stringify(testFilesToUpdate)},
-  "update_count": ${updateRecommendations.length}
-}
--->\n`;
+            const llmInstructionsObj = {
+                workflow: "test_maintenance",
+                action: "execute_updates",
+                auto_proceed: true,
+                files_to_update: testFilesToUpdate,
+                update_count: updateRecommendations.length,
+            };
+            if (uniqueRenames.length > 0) {
+                llmInstructionsObj.endpoint_renames = uniqueRenames;
+                llmInstructionsObj.rename_strategy =
+                    "For each file, find-and-replace all occurrences of oldPath with newPath. Do NOT regenerate or restructure the test — only update the URL paths.";
+                // Collect file rename suggestions
+                const fileRenames = [];
+                for (const rec of updateRecommendations) {
+                    if (rec._suggestedNewFile) {
+                        fileRenames.push({
+                            from: rec.testFile,
+                            to: rec._suggestedNewFile,
+                        });
+                    }
+                }
+                if (fileRenames.length > 0) {
+                    llmInstructionsObj.file_renames = fileRenames;
+                    llmInstructionsObj.file_rename_strategy =
+                        "After updating path content in each file, rename the file using 'mv' or equivalent. Use git mv if the repo tracks the file.";
+                }
+            }
+            const llmInstructions = `<!-- LLM_INSTRUCTIONS:\n${JSON.stringify(llmInstructionsObj, null, 2)}\n-->\n`;
             return {
                 content: [
                     {

package/build/tools/test-maintenance/actionsTool.test.js

@@ -0,0 +1,93 @@
+// Mock modules that use ESM-only features (import.meta) before importing actionsTool
+jest.mock("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushMCPToolEvent: jest.fn() },
+}));
+jest.mock("../../utils/logger.js", () => ({
+    logger: { info: jest.fn(), warning: jest.fn(), error: jest.fn(), debug: jest.fn() },
+}));
+jest.mock("../../utils/AnalysisStateManager.js", () => ({
+    StateManager: { fromStatePath: jest.fn() },
+}));
+jest.mock("fs");
+// @ts-ignore
+import { computeRenamedTestFile } from "./actionsTool.js";
+import * as fs from "fs";
+const mockExistsSync = fs.existsSync;
+describe("computeRenamedTestFile", () => {
+    beforeEach(() => {
+        // Default: target file does not exist
+        mockExistsSync.mockReturnValue(false);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    // --- Basic renames ---
+    it("should rename products_smoke_test.py to items_smoke_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_smoke_test.py");
+    });
+    it("should rename products_contract_test.py to items_contract_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_contract_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_contract_test.py");
+    });
+    it("should rename products_integration_test.py to items_integration_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_integration_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "post" }]);
+        expect(result).toBe("/repo/tests/python/items_integration_test.py");
+    });
+    it("should rename products_fuzz_test.py to items_fuzz_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_fuzz_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_fuzz_test.py");
+    });
+    it("should rename products_load_test.py to items_load_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_load_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_load_test.py");
+    });
+    // --- Different file extensions ---
+    it("should work with .ts test files", () => {
+        const result = computeRenamedTestFile("/repo/tests/products.test.ts", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/items.test.ts");
+    });
+    it("should work with .js test files", () => {
+        const result = computeRenamedTestFile("/repo/tests/products_smoke.test.js", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/items_smoke.test.js");
+    });
+    // --- Returns null when no rename needed ---
+    it("should return null when filename does not contain old segment", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/orders_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBeNull();
+    });
+    it("should return null when target file already exists", () => {
+        mockExistsSync.mockReturnValue(true);
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBeNull();
+    });
+    it("should return null when segments have different lengths", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v2/catalog/items", method: "get" }]);
+        // Different segment counts — no substitution attempted
+        expect(result).toBeNull();
+    });
+    it("should return null with empty renames array", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", []);
+        expect(result).toBeNull();
+    });
+    // --- Multiple renames ---
+    it("should apply multiple rename mappings", () => {
+        // Unlikely but possible: two segments change
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [
+            { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+            { oldPath: "/api/v1/products/{product_id}", newPath: "/api/v1/items/{item_id}", method: "get" },
+        ]);
+        expect(result).toBe("/repo/tests/python/items_smoke_test.py");
+    });
+    // --- Preserves directory structure ---
+    it("should preserve the directory path", () => {
+        const result = computeRenamedTestFile("/home/runner/work/api-insight/api-insight/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/home/runner/work/api-insight/api-insight/tests/python/items_smoke_test.py");
+    });
+    // --- Version bump rename ---
+    it("should handle version segment rename in filename if present", () => {
+        const result = computeRenamedTestFile("/repo/tests/v1_products_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v2/products", method: "get" }]);
+        // "v1" in filename gets replaced with "v2"
+        expect(result).toBe("/repo/tests/v2_products_test.py");
+    });
+});

package/build/tools/test-recommendation/analyzeRepositoryTool.js

@@ -119,7 +119,7 @@ function parseEndpointsFromDiff(diffData) {
         affectedServices,
     };
 }
-async function computeBranchDiff(repositoryPath) {
+async function computeBranchDiff(repositoryPath, providedBaseBranch) {
     const git = simpleGit(repositoryPath);
     const isRepo = await git.checkIsRepo();
     if (!isRepo) {
@@ -127,22 +127,27 @@ async function computeBranchDiff(repositoryPath) {
     }
     const branchInfo = await git.branch();
     const currentBranch = branchInfo.current || "HEAD";
-    // Prefer remote tracking refs (origin/main) over local branch names so this
-    // works in detached-HEAD CI environments (e.g. PR merge checkouts) where
-    // local "main"/"master" branches don't exist.
-    let baseBranch = "origin/main";
-    try {
-        const remoteBranches = await git.branch(["-r"]);
-        if (remoteBranches.all.some((b) => b.endsWith("/main"))) {
-            baseBranch = "origin/main";
+    let baseBranch;
+    if (providedBaseBranch) {
+        // Use the PR's base branch when explicitly provided (e.g. from testbot)
+        baseBranch = `origin/${providedBaseBranch}`;
+    }
+    else {
+        // Fall back to auto-detecting origin/main or origin/master
+        baseBranch = "origin/main";
+        try {
+            const remoteBranches = await git.branch(["-r"]);
+            if (remoteBranches.all.some((b) => b.endsWith("/main"))) {
+                baseBranch = "origin/main";
+            }
+            else if (remoteBranches.all.some((b) => b.endsWith("/master"))) {
+                baseBranch = "origin/master";
+            }
         }
-        else if (remoteBranches.all.some((b) => b.endsWith("/master"))) {
-            baseBranch = "origin/master";
+        catch {
+            logger.debug("Could not determine remote default branch, falling back to origin/main");
         }
     }
-    catch {
-        logger.debug("Could not determine remote default branch, falling back to origin/main");
-    }
     const changedFilesRaw = await git.diff([
         `${baseBranch}...HEAD`,
         "--name-only",
@@ -180,6 +185,10 @@ const analyzeRepositorySchema = z.object({
         .array(z.string())
         .optional()
         .describe("Optional: Specific areas to focus on (e.g., ['api', 'frontend', 'infrastructure'])"),
+    baseBranch: z
+        .string()
+        .optional()
+        .describe("Optional: PR base branch name (e.g. 'main', 'develop'). When provided, the diff is computed against origin/<baseBranch> instead of auto-detecting the default branch. Useful when the PR targets a non-default branch."),
 });
 const TOOL_NAME = "skyramp_analyze_repository";
 export function registerAnalyzeRepositoryTool(server) {
@@ -240,7 +249,7 @@ Output: Detailed RepositoryAnalysis JSON object with all repository characterist
             let diffData;
             if (analysisScope === "current_branch_diff") {
                 try {
-                    diffData = await computeBranchDiff(params.repositoryPath);
+                    diffData = await computeBranchDiff(params.repositoryPath, params.baseBranch);
                     logger.info("Branch diff computed via git", {
                         currentBranch: diffData.currentBranch,
                         baseBranch: diffData.baseBranch,

package/build/tools/test-recommendation/recommendTestsTool.js

@@ -137,6 +137,32 @@ ${diff.changedFiles.map((f) => `- \`${f}\``).join("\n")}
                 .join("\n");
             const highActions = buildActionList(mapping.summary.highPriority);
             const mediumActions = buildActionList(mapping.summary.mediumPriority);
+            // Check if E2E or UI tests are in the priority lists
+            const allPriority = [
+                ...mapping.summary.highPriority,
+                ...mapping.summary.mediumPriority,
+            ];
+            const hasE2EOrUI = allPriority.some((t) => t === TestType.E2E || t === TestType.UI);
+            const traceGuidance = hasE2EOrUI
+                ? `
+### Trace Files for E2E/UI Tests
+
+E2E and UI test generation requires pre-recorded trace files. Search the repository for:
+- Backend traces: \`**/skyramp*trace*.json\`, \`**/skyramp-traces.json\`
+- Playwright traces: \`**/skyramp*playwright*.zip\`, \`**/*playwright*.zip\`
+
+Look in the test directory, repository root, and \`.skyramp/\` directories.
+
+**IMPORTANT — Verify trace relevance before using it:**
+Before passing a trace file to a test generation tool, inspect its contents to confirm it actually exercises the UI components or pages affected by the PR. A trace recorded before the current changes will not cover new UI elements. If the trace does NOT cover the changed UI:
+- Do NOT use it for generating tests for the new changes.
+- Report in \`issuesFound\`: "A Playwright trace file was found (<filename>) but it does not cover the new UI changes in this PR. To generate UI tests for the new functionality, record a new trace that exercises the changed pages/components and commit it, then re-run the Testbot."
+
+- **Both found and relevant** → call \`skyramp_e2e_test_generation\` with both trace files
+- **Only Playwright ZIP found and relevant** → call \`skyramp_ui_test_generation\` with the Playwright file
+- **No traces found** → do NOT silently skip. Include in \`issuesFound\` when submitting your report: "E2E/UI tests were recommended but could not be generated because no Playwright trace file (.zip) was found in the repository. To enable E2E/UI test generation, record a Playwright trace and commit the .zip file, then re-run the Testbot."
+`
+                : "";
             const nextActionsSection = mapping.summary.highPriority.length > 0 ||
                 mapping.summary.mediumPriority.length > 0
                 ? `
@@ -148,7 +174,7 @@ Do NOT skip any. Do NOT just run existing tests — generate new ones.
 ### High Priority (call these first)
 ${highActions || "none"}
 
-${mediumActions ? `### Medium Priority (call after high)\n${mediumActions}\n` : ""}${isDiffScope && ((analysis?.branchDiffContext?.newEndpoints?.length ?? 0) + (analysis?.branchDiffContext?.modifiedEndpoints?.length ?? 0)) > 0 ? `\nTarget the changed endpoint(s) listed above for each generated test. Use the full URL (including base URL) as the \`endpointURL\` parameter when calling generate tools.` : ""}
+${mediumActions ? `### Medium Priority (call after high)\n${mediumActions}\n` : ""}${isDiffScope && ((analysis?.branchDiffContext?.newEndpoints?.length ?? 0) + (analysis?.branchDiffContext?.modifiedEndpoints?.length ?? 0)) > 0 ? `\nTarget the changed endpoint(s) listed above for each generated test. Use the full URL (including base URL) as the \`endpointURL\` parameter when calling generate tools.` : ""}${traceGuidance}
 `
                 : "";
             const output = `# Test Recommendations

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "main": "build/index.js",
   "type": "module",
   "bin": {
@@ -46,7 +46,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.10",
+    "@skyramp/skyramp": "1.3.11",
     "dockerode": "^4.0.6",
     "fast-glob": "^3.3.3",
     "simple-git": "^3.30.0",