@skyramp/mcp 0.0.57 → 0.0.58

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>
@@ -24,12 +24,14 @@ Read the diff at \`${diffFile}\`. Classify each changed file. A file is applicat
 
 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.
 
+**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.
@@ -38,6 +40,8 @@ You MUST always run steps 1–4 below. Do NOT skip this task based on your own a
 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.
+   - 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.
 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.
 
@@ -70,9 +74,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 +87,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 +115,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.57",
+  "version": "0.0.58",
   "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",