@skyramp/mcp 0.1.0 → 0.1.2

package/build/services/TestDiscoveryService.test.js

@@ -0,0 +1,361 @@
+// Mock heavy dependencies
+jest.mock("simple-git", () => ({
+    simpleGit: jest.fn(() => ({
+        checkIsRepo: jest.fn().mockResolvedValue(false),
+    })),
+}));
+jest.mock("../utils/logger.js", () => ({
+    logger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        warning: jest.fn(),
+    },
+}));
+// fast-glob must return real file paths from the temp directory.
+// We use the real implementation by not mocking it.
+// Jest resolves .js → .ts via moduleNameMapper in jest.config.
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { TestDiscoveryService } from "./TestDiscoveryService.js";
+import { TestSource } from "../types/TestAnalysis.js";
+describe("TestDiscoveryService", () => {
+    let service;
+    let tmpDir;
+    beforeEach(() => {
+        service = new TestDiscoveryService();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-discovery-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeFile(relPath, content) {
+        const fullPath = path.join(tmpDir, relPath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content, "utf-8");
+        return fullPath;
+    }
+    // ── classifyTestFiles ──
+    describe("classifyTestFiles", () => {
+        it("classifies files with Skyramp marker as skyramp", async () => {
+            writeFile("tests/test_orders_smoke.py", '# Generated by Skyramp\nimport skyramp\nskyramp generate smoke rest');
+            const result = await service.discoverTests(tmpDir);
+            const skyrampTests = result.tests.filter((t) => t.source === TestSource.Skyramp);
+            expect(skyrampTests.length).toBe(1);
+            expect(skyrampTests[0].testFile).toContain("test_orders_smoke.py");
+        });
+        it("classifies test files without Skyramp marker as external", async () => {
+            writeFile("tests/test_orders.py", 'import pytest\nimport requests\nresponse = requests.get("/api/orders")');
+            const result = await service.discoverTests(tmpDir);
+            const externalTests = result.tests.filter((t) => t.source === TestSource.External);
+            expect(externalTests.length).toBe(1);
+            expect(externalTests[0].testFile).toContain("test_orders.py");
+        });
+        it("skips non-test files that lack the Skyramp marker", async () => {
+            writeFile("src/utils.py", 'def helper():\n    return True');
+            const result = await service.discoverTests(tmpDir);
+            expect(result.tests.length).toBe(0);
+        });
+        it("handles both Skyramp and external tests in the same repo", async () => {
+            writeFile("tests/test_orders_smoke.py", '# Generated by Skyramp\nskyramp generate smoke rest');
+            writeFile("tests/test_api.py", 'import pytest\nrequests.get("/api/users")');
+            const result = await service.discoverTests(tmpDir);
+            expect(result.tests.length).toBe(2);
+            expect(result.tests.filter((t) => t.source === TestSource.Skyramp).length).toBe(1);
+            expect(result.tests.filter((t) => t.source === TestSource.External).length).toBe(1);
+        });
+    });
+    // ── isExternalTestFile (via classification) ──
+    describe("external test file detection", () => {
+        const patterns = [
+            ["test_orders.py", true],
+            ["orders_test.py", true],
+            ["orders.test.ts", true],
+            ["orders.spec.js", true],
+            ["OrdersTest.java", true],
+            ["orders_test.go", true],
+            ["orders_spec.rb", true],
+            ["OrdersTest.kt", true],
+            ["OrdersTests.cs", true],
+            ["orders_test.rs", true],
+            ["OrdersTest.php", true],
+            ["test_orders.rb", true],
+            ["utils.py", false],
+            ["main.ts", false],
+            ["main.go", false],
+        ];
+        it.each(patterns)("file %s → isExternal: %s", async (filename, expected) => {
+            writeFile(filename, 'import pytest\ndef test_something():\n    pass');
+            const result = await service.discoverTests(tmpDir);
+            const externalTests = result.tests.filter((t) => t.source === TestSource.External);
+            if (expected) {
+                expect(externalTests.length).toBe(1);
+            }
+            else {
+                expect(externalTests.length).toBe(0);
+            }
+        });
+        it("detects files in test directories", async () => {
+            writeFile("tests/helpers.py", 'import requests\nrequests.get("/api/health")');
+            const result = await service.discoverTests(tmpDir);
+            const externalTests = result.tests.filter((t) => t.source === TestSource.External);
+            expect(externalTests.length).toBe(1);
+        });
+        it("detects files in __tests__ directory", async () => {
+            writeFile("src/__tests__/api.ts", 'import axios from "axios";\naxios.get("/api/items");');
+            const result = await service.discoverTests(tmpDir);
+            const externalTests = result.tests.filter((t) => t.source === TestSource.External);
+            expect(externalTests.length).toBe(1);
+        });
+    });
+    // ── extractExternalEndpoints ──
+    describe("extractExternalEndpoints", () => {
+        it("extracts endpoints from Python requests library", async () => {
+            writeFile("test_api.py", 'import requests\nrequests.get("/api/orders")\nrequests.post("/api/orders")');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+            expect(ext.apiEndpoint).toContain("POST /api/orders");
+        });
+        it("extracts endpoints from Python test client", async () => {
+            writeFile("test_api.py", 'def test_orders(client):\n    client.get("/api/orders")\n    client.post("/api/orders")');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+        });
+        it("extracts endpoints from axios", async () => {
+            writeFile("api.test.ts", 'import axios from "axios";\naxios.get("/api/items");\naxios.post("/api/items");');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/items");
+            expect(ext.apiEndpoint).toContain("POST /api/items");
+        });
+        it("extracts endpoints from supertest", async () => {
+            writeFile("api.test.ts", 'import supertest from "supertest";\nconst req = supertest(app);\nreq.get("/api/users");\nreq.post("/api/users");');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/users");
+            expect(ext.apiEndpoint).toContain("POST /api/users");
+        });
+        it("extracts endpoints from fetch with explicit method", async () => {
+            writeFile("api.test.ts", 'fetch("/api/orders", { method: "POST" });\nfetch("/api/orders");');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("POST /api/orders");
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+        });
+        it("strips base URL from endpoints", async () => {
+            writeFile("test_api.py", 'import requests\nrequests.get("http://localhost:8000/api/orders")');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+            expect(ext.apiEndpoint).not.toContain("localhost");
+        });
+        it("extracts endpoints from Java RestAssured", async () => {
+            writeFile("OrdersTest.java", 'import io.restassured.*;\ngiven().when().get("/api/orders").then();');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+        });
+        it("extracts endpoints from Go http.NewRequest", async () => {
+            writeFile("orders_test.go", 'package main\nimport "testing"\nimport "net/http"\nfunc TestOrders(t *testing.T) {\n  req, _ := http.NewRequest("GET", "/api/orders", nil)\n  http.NewRequest("POST", "/api/orders", body)\n}');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+            expect(ext.apiEndpoint).toContain("POST /api/orders");
+        });
+        it("extracts endpoints from C# HttpClient", async () => {
+            writeFile("OrdersTests.cs", 'using Xunit;\npublic class OrdersTests {\n  [Fact]\n  public async Task GetOrders() {\n    await client.GetAsync("/api/orders");\n    await client.PostAsync("/api/orders", content);\n  }\n}');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+            expect(ext.apiEndpoint).toContain("POST /api/orders");
+        });
+        it("extracts endpoints from Ruby Net::HTTP", async () => {
+            writeFile("orders_spec.rb", 'require "rspec"\nRSpec.describe "Orders" do\n  it "lists" do\n    Net::HTTP.get("/api/orders")\n    Net::HTTP.post("/api/orders", body)\n  end\nend');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext).toBeDefined();
+            expect(ext.apiEndpoint).toContain("GET /api/orders");
+        });
+    });
+    // ── detectExternalTestType ──
+    describe("detectExternalTestType", () => {
+        it("detects integration from filename", async () => {
+            writeFile("test_orders_integration.py", "import pytest\ndef test(): pass");
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.testType).toBe("integration");
+        });
+        it("detects e2e from filename", async () => {
+            writeFile("test_e2e_flow.py", "import pytest\ndef test(): pass");
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.testType).toBe("e2e");
+        });
+        it("detects contract from filename", async () => {
+            writeFile("test_contract.py", "import pytest\ndef test(): pass");
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.testType).toBe("contract");
+        });
+        it("falls back to integration for files with HTTP calls", async () => {
+            writeFile("test_api.py", 'import requests\nrequests.get("/api/orders")');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.testType).toBe("integration");
+        });
+        it("returns unknown when no heuristic matches", async () => {
+            writeFile("test_utils.py", "def test_helper():\n    assert True");
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.testType).toBe("unknown");
+        });
+    });
+    // ── detectExternalFramework ──
+    describe("detectExternalFramework", () => {
+        it("detects pytest", async () => {
+            writeFile("test_api.py", "import pytest\ndef test(): pass");
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("pytest");
+        });
+        it("detects jest", async () => {
+            writeFile("api.test.ts", 'import { jest } from "jest";\ndescribe("api", () => {});');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("jest");
+        });
+        it("detects junit", async () => {
+            writeFile("OrdersTest.java", "import org.junit.Test;\n@Test\npublic void test() {}");
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("junit");
+        });
+        it("detects supertest", async () => {
+            writeFile("api.test.ts", 'import supertest from "supertest";\nconst req = supertest(app);');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("supertest");
+        });
+        it("detects go-testing", async () => {
+            writeFile("orders_test.go", 'package main\nimport "testing"\nfunc TestOrders(t *testing.T) {}');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("go-testing");
+        });
+        it("detects rspec", async () => {
+            writeFile("orders_spec.rb", 'require "rspec"\nRSpec.describe "Orders" do\n  it "works" do; end\nend');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("rspec");
+        });
+        it("detects xunit", async () => {
+            writeFile("OrdersTests.cs", 'using Xunit;\npublic class OrdersTests {\n  [Fact]\n  public void Test() {}\n}');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("xunit");
+        });
+        it("detects phpunit", async () => {
+            writeFile("OrdersTest.php", '<?php\nuse PHPUnit\\Framework\\TestCase;\nclass OrdersTest extends TestCase {\n  public function testList() {}\n}');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("phpunit");
+        });
+        it("detects rust-test", async () => {
+            writeFile("orders_test.rs", '#[cfg(test)]\nmod tests {\n  #[test]\n  fn test_orders() {}\n}');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext.framework).toBe("rust-test");
+        });
+    });
+    // ── source field ──
+    describe("source field tagging", () => {
+        it("tags Skyramp tests with source: skyramp", async () => {
+            writeFile("test_smoke.py", '# Generated by Skyramp\nskyramp generate smoke rest');
+            const result = await service.discoverTests(tmpDir);
+            expect(result.tests[0].source).toBe(TestSource.Skyramp);
+        });
+        it("tags external tests with source: external", async () => {
+            writeFile("test_api.py", "import pytest\ndef test(): pass");
+            const result = await service.discoverTests(tmpDir);
+            expect(result.tests[0].source).toBe(TestSource.External);
+        });
+    });
+    // ── relevance-based partitioning ──
+    describe("relevance-based external test partitioning", () => {
+        it("returns all external test files without a hard cap in PR mode", async () => {
+            for (let i = 0; i < 60; i++) {
+                writeFile(`test_file_${i}.py`, `def test_${i}(): pass`);
+            }
+            const result = await service.discoverTests(tmpDir, { changedResources: ["file"] });
+            const externalTests = result.tests.filter((t) => t.source === TestSource.External);
+            expect(externalTests.length).toBe(60);
+        });
+        it("extracts endpoints only for relevant files when changedResources provided", async () => {
+            writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
+            writeFile("test_products_api.py", 'import requests\nrequests.get("/api/products")');
+            const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
+            const externalTests = result.tests.filter((t) => t.source === TestSource.External);
+            expect(externalTests.length).toBe(2);
+            const ordersTest = externalTests.find(t => t.testFile.includes("orders"));
+            const productsTest = externalTests.find(t => t.testFile.includes("products"));
+            // Relevant file gets endpoint extraction
+            expect(ordersTest?.apiEndpoint).toContain("GET /api/orders");
+            // Low-relevance file gets name-only entry (no endpoint extraction)
+            expect(productsTest?.apiEndpoint).toBe("");
+        });
+        it("returns relevantExternalTestPaths including files where extraction may have failed", async () => {
+            writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
+            writeFile("test_orders_helpers.py", 'def create_order(): pass'); // no extractable endpoints
+            writeFile("test_products_api.py", 'import requests\nrequests.get("/api/products")');
+            const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
+            // Both orders-related files should be in relevantExternalTestPaths
+            expect(result.relevantExternalTestPaths.some(p => p.includes("test_orders_api"))).toBe(true);
+            expect(result.relevantExternalTestPaths.some(p => p.includes("test_orders_helpers"))).toBe(true);
+            // Products file should NOT be in relevantExternalTestPaths
+            expect(result.relevantExternalTestPaths.some(p => p.includes("test_products_api"))).toBe(false);
+        });
+        it("does full extraction for all files when no changedResources provided", async () => {
+            writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
+            const result = await service.discoverTests(tmpDir);
+            const ext = result.tests.find((t) => t.source === TestSource.External);
+            expect(ext?.apiEndpoint).toContain("GET /api/orders");
+        });
+        it("caps full-repo mode at MAX_EXTERNAL_FULL_REPO for full extraction", async () => {
+            // Create 12 external test files to test the boundary (MAX_EXTERNAL_FULL_REPO=100 is too
+            // large to create in a unit test, so we verify the partitioning logic is wired correctly)
+            for (let i = 0; i < 12; i++) {
+                writeFile(`test_api_${i}.py`, `import requests\nrequests.get("/api/items/${i}")`);
+            }
+            const result = await service.discoverTests(tmpDir);
+            const externalTests = result.tests.filter(t => t.source === TestSource.External);
+            // All 12 files should be discovered
+            expect(externalTests.length).toBe(12);
+            // In full-repo mode (no changedResources) all files under cap go to relevantExternal
+            expect(result.relevantExternalTestPaths.length).toBe(12);
+            // All relevant files get full extraction (apiEndpoint populated)
+            const withEndpoints = externalTests.filter(t => t.apiEndpoint !== "");
+            expect(withEndpoints.length).toBe(12);
+        });
+        it("low-relevance files have empty apiEndpoint and empty framework in PR mode", async () => {
+            writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
+            writeFile("test_products_api.py", 'import requests\nrequests.get("/api/products")');
+            const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
+            const productsTest = result.tests.find(t => t.testFile.includes("test_products_api"));
+            expect(productsTest?.source).toBe(TestSource.External);
+            expect(productsTest?.apiEndpoint).toBe("");
+            expect(productsTest?.framework).toBe("");
+        });
+    });
+});

package/build/tools/code-refactor/enhanceAssertionsTool.js

@@ -1,12 +1,10 @@
 import { z } from "zod";
 import { TestType } from "../../types/TestTypes.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { CONTRACT_PROVIDER_ASSERTIONS_PROMPT } from "../../prompts/enhance-assertions/contractProviderAssertionsPrompt.js";
-import { INTEGRATION_ASSERTIONS_PROMPT } from "../../prompts/enhance-assertions/integrationAssertionsPrompt.js";
-import { UI_ASSERTIONS_PROMPT } from "../../prompts/enhance-assertions/uiAssertionsPrompt.js";
+import { getContractProviderAssertionsPrompt } from "../../prompts/enhance-assertions/contractProviderAssertionsPrompt.js";
+import { getIntegrationAssertionsPrompt } from "../../prompts/enhance-assertions/integrationAssertionsPrompt.js";
+import { getUIAssertionsPrompt } from "../../prompts/enhance-assertions/uiAssertionsPrompt.js";
 const TOOL_NAME = "skyramp_enhance_assertions";
-const SCOPE_GENERATION = "Apply to every test function in the generated file.";
-const SCOPE_MAINTENANCE = "Apply to **new test functions you are adding** and **existing functions that cover endpoints changed in the diff** only. Do NOT touch existing functions for endpoints unrelated to the diff.";
 const TESTBOT_UI_CHECKS = `
 ### Additional Testbot-Specific Checks
 - If no suitable selector exists in the generated file for an assertion you need to add, go back and call \`browser_assert\` on the live page to record it with a valid selector, then re-export and regenerate.
@@ -35,28 +33,28 @@ export function registerEnhanceAssertionsTool(server) {
         inputSchema: enhanceAssertionsSchema,
     }, async (params) => {
         const { testFile, testType, enhanceType } = params;
+        const enhanceCtx = enhanceType;
         let instructions;
         if (testType === TestType.UI) {
-            instructions = UI_ASSERTIONS_PROMPT;
+            instructions = getUIAssertionsPrompt(testFile, enhanceCtx);
             if (process.env.SKYRAMP_FEATURE_TESTBOT === "1") {
                 instructions += TESTBOT_UI_CHECKS;
             }
         }
         else if (testType === TestType.CONTRACT) {
-            instructions = CONTRACT_PROVIDER_ASSERTIONS_PROMPT;
+            instructions = getContractProviderAssertionsPrompt(testFile, enhanceCtx);
         }
         else if (testType === TestType.INTEGRATION) {
-            instructions = INTEGRATION_ASSERTIONS_PROMPT;
+            instructions = getIntegrationAssertionsPrompt(testFile, enhanceCtx);
         }
         else {
             throw new Error(`Unsupported testType for ${TOOL_NAME}: ${testType}`);
         }
-        const scope = enhanceType === "maintenance" ? SCOPE_MAINTENANCE : SCOPE_GENERATION;
         const result = {
             content: [
                 {
                     type: "text",
-                    text: `**You MUST execute the following assertion enhancement instructions to modify the test file.**\n\n**Target file:** ${testFile}\n\n**Scope:** ${scope}\n\n${instructions}`,
+                    text: instructions,
                 },
             ],
             isError: false,

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { logger } from "../../utils/logger.js";
 import { StateManager, } from "../../utils/AnalysisStateManager.js";
+import { TestSource } from "../../types/TestAnalysis.js";
 import { TestType } from "../../types/TestTypes.js";
 import * as fs from "fs";
 import * as path from "path";
@@ -106,7 +107,9 @@ Comprehensive report with executed actions, summary, and instructions for ADD re
                 };
                 return errorResult;
             }
-            const testAnalysisResults = stateData.existingTests || [];
+            // External tests must not be candidates for UPDATE/REGENERATE/DELETE actions.
+            // Default source to Skyramp for backwards compat with state files created before the source field existed.
+            const testAnalysisResults = (stateData.existingTests || []).filter((t) => (t.source ?? TestSource.Skyramp) !== TestSource.External);
             const newEndpoints = stateData.newEndpoints || [];
             // ── Build recommendations from existing tests ──
             const recommendations = [];

package/build/tools/test-management/analyzeChangesTool.js

@@ -12,12 +12,13 @@ import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-r
 import { TestDiscoveryService } from "../../services/TestDiscoveryService.js";
 import { ScenarioSource, AnalysisScope } from "../../types/RepositoryAnalysis.js";
 import { computeBranchDiff } from "../../utils/branchDiff.js";
-import { parseEndpointsFromDiff, resolveEndpointPaths, } from "../../utils/routeParsers.js";
+import { parseEndpointsFromDiff, resolveEndpointPaths, extractResourceFromPath, } from "../../utils/routeParsers.js";
 import { scanAllRepoEndpoints, scanRelatedEndpoints, grepRouterMountingContext, findCandidateRouteFiles, } from "../../utils/repoScanner.js";
 import { detectProjectMetadata } from "../../utils/projectMetadata.js";
 import { draftScenariosFromEndpoints } from "../../utils/scenarioDrafting.js";
 import { buildAnalysisOutputText } from "../../prompts/test-recommendation/analysisOutputPrompt.js";
 import { parseTraceFile, discoverTraceFiles, discoverPlaywrightZips, } from "../../utils/trace-parser.js";
+import { TestSource } from "../../types/TestAnalysis.js";
 import { parsePRComments } from "../../utils/pr-comment-parser.js";
 const TOOL_NAME = "skyramp_analyze_changes";
 // Must match testbot/src/constants.ts BOT_EMAIL
@@ -318,10 +319,21 @@ to produce a unified state file for the test health workflow.
             }
             await sendProgress(50, 100, "Discovering existing tests...");
             // ── Step 3: Discover existing tests ──
+            // In PR mode, extract resource names from the diff endpoints so that
+            // TestDiscoveryService can limit full extraction to relevant files only.
+            const changedResources = parsedDiff
+                ? [
+                    ...parsedDiff.newEndpoints,
+                    ...parsedDiff.modifiedEndpoints,
+                ]
+                    .map(ep => extractResourceFromPath(ep.path))
+                    .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i)
+                : [];
             let existingTests = [];
+            let discoveredRelevantExternalPaths = [];
             try {
                 const testDiscoveryService = new TestDiscoveryService();
-                const discoveryResult = await testDiscoveryService.discoverTests(params.repositoryPath);
+                const discoveryResult = await testDiscoveryService.discoverTests(params.repositoryPath, { changedResources });
                 existingTests = discoveryResult.tests.map((test) => ({
                     testFile: test.testFile,
                     testType: test.testType,
@@ -329,10 +341,15 @@ to produce a unified state file for the test health workflow.
                     framework: test.framework,
                     apiSchema: test.apiSchema,
                     apiEndpoint: test.apiEndpoint,
+                    source: test.source,
                     generatedAt: test.generatedAt,
                 }));
+                // Use the authoritative list from discovery — includes relevant files even
+                // when regex endpoint extraction failed (e.g. helper-abstracted HTTP calls).
+                discoveredRelevantExternalPaths = discoveryResult.relevantExternalTestPaths;
                 logger.info("Test discovery completed", {
                     totalTests: existingTests.length,
+                    relevantExternal: discoveredRelevantExternalPaths.length,
                 });
             }
             catch (err) {
@@ -562,18 +579,67 @@ to produce a unified state file for the test health workflow.
             await sendProgress(80, 100, "Building unified state...");
             // ── Step 10: Build full RepositoryAnalysis for ranked recommendations ──
             const sessionId = crypto.randomUUID();
-            // Build existing test locations map (type → file list) for deduplication in recommendations
-            // Include covered endpoints so the agent can cross-check resource paths before creating new files.
+            // Build existing test locations map (type → file list) for deduplication in recommendations.
+            // Order per type: relevant external (with covers) → Skyramp → low-relevance external (name-only).
+            // This ensures the LLM and programmatic dedup encounter external coverage signals first.
+            // testFile is kept absolute for filesystem use; displayPath is relativized for prompt display.
+            const relevantExternalSet = new Set(discoveredRelevantExternalPaths);
+            const displayPath = (absPath) => path.relative(params.repositoryPath, absPath);
             const testLocationsByType = {};
-            for (const t of existingTests) {
-                const type = t.testType || "unknown";
-                const entry = t.apiEndpoint
-                    ? `${t.testFile} (covers: ${t.apiEndpoint})`
-                    : t.testFile;
+            const addEntry = (type, entry) => {
                 testLocationsByType[type] = testLocationsByType[type]
                     ? `${testLocationsByType[type]}, ${entry}`
                     : entry;
+            };
+            // Pass 1: relevant external tests with extracted endpoints
+            for (const t of existingTests) {
+                if (t.source !== TestSource.External)
+                    continue;
+                if (!relevantExternalSet.has(t.testFile))
+                    continue;
+                const dp = displayPath(t.testFile);
+                const entry = t.apiEndpoint
+                    ? `${dp} [external] (covers: ${t.apiEndpoint})`
+                    : `${dp} [external]`;
+                addEntry(t.testType || "unknown", entry);
+            }
+            // Pass 2: Skyramp tests — tagged [skyramp] so the LLM can positively identify the source
+            for (const t of existingTests) {
+                if (t.source === TestSource.External)
+                    continue;
+                const dp = displayPath(t.testFile);
+                const entry = t.apiEndpoint
+                    ? `${dp} [skyramp] (covers: ${t.apiEndpoint})`
+                    : `${dp} [skyramp]`;
+                addEntry(t.testType || "unknown", entry);
+            }
+            // Pass 3: low-relevance external tests (name-only) — capped to avoid context overflow
+            const LOW_RELEVANCE_CAP = 20;
+            let lowRelevanceCount = 0;
+            let lowRelevanceSuppressed = 0;
+            for (const t of existingTests) {
+                if (t.source !== TestSource.External)
+                    continue;
+                if (relevantExternalSet.has(t.testFile))
+                    continue;
+                if (lowRelevanceCount < LOW_RELEVANCE_CAP) {
+                    addEntry(t.testType || "unknown", `${displayPath(t.testFile)} [external]`);
+                    lowRelevanceCount++;
+                }
+                else {
+                    lowRelevanceSuppressed++;
+                }
+            }
+            if (lowRelevanceSuppressed > 0) {
+                // Append a summary so the LLM knows more files exist
+                const summaryType = "unknown";
+                addEntry(summaryType, `[${lowRelevanceSuppressed} more external test file(s) not shown — low relevance to this PR]`);
             }
+            // Use the authoritative relevant paths from discovery — includes files where
+            // regex extraction failed but path/name scoring identified as PR-relevant.
+            // Relativize against repositoryPath to avoid leaking absolute machine paths
+            // into the prompt, state file, and PR reports.
+            const relevantExternalTestPaths = discoveredRelevantExternalPaths.map(p => path.relative(params.repositoryPath, p));
             // Build the full RepositoryAnalysis object — same structure as analyzeRepositoryTool
             // so buildRecommendationPrompt can reason over enriched endpoint + scenario data
             const diffContext = parsedDiff ? {
@@ -661,6 +727,7 @@ to produce a unified state file for the test health workflow.
                     coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 },
                     testLocations: testLocationsByType,
                     hasCoverageReports: false,
+                    relevantExternalTestPaths,
                 },
                 ...(diffContext ? { branchDiffContext: diffContext } : {}),
             };

package/build/tools/test-management/analyzeTestHealthTool.js

@@ -4,6 +4,7 @@ import { StateManager, } from "../../utils/AnalysisStateManager.js";
 import path from "path";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { buildDriftAnalysisPrompt } from "../../prompts/test-maintenance/drift-analysis-prompt.js";
+import { TestSource } from "../../types/TestAnalysis.js";
 const TOOL_NAME = "skyramp_analyze_test_health";
 export function registerAnalyzeTestHealthTool(server) {
     server.registerTool(TOOL_NAME, {
@@ -52,8 +53,11 @@ exist only in the LLM's reasoning context and are acted on by \`skyramp_actions\
                 };
                 return errorResult;
             }
-            const existingTests = stateData.existingTests || [];
-            logger.info(`Loaded ${existingTests.length} existing tests from state file`);
+            // Only Skyramp tests are candidates for drift analysis and maintenance actions.
+            // External (user-written) tests are used only for recommendation deduplication.
+            // Default source to Skyramp for backwards compat with state files created before the source field existed.
+            const existingTests = (stateData.existingTests || []).filter((t) => (t.source ?? TestSource.Skyramp) !== TestSource.External);
+            logger.info(`Loaded ${existingTests.length} existing Skyramp tests from state file (excluded external)`);
             if (!repositoryPath || typeof repositoryPath !== "string") {
                 errorResult = {
                     content: [

package/build/types/RepositoryAnalysis.js

@@ -229,6 +229,7 @@ export const repositoryAnalysisSchema = z.object({
         testLocations: z.record(z.string()),
         hasCoverageReports: z.boolean(),
         estimatedCoverage: z.number().optional(),
+        relevantExternalTestPaths: z.array(z.string()).optional(),
     }),
     branchDiffContext: branchDiffContextSchema.optional(),
 });

package/build/types/TestAnalysis.js

@@ -1 +1,6 @@
-export {};
+/** Origin of a test file — whether it was generated by Skyramp or is user/third-party maintained. */
+export var TestSource;
+(function (TestSource) {
+    TestSource["Skyramp"] = "skyramp";
+    TestSource["External"] = "external";
+})(TestSource || (TestSource = {}));

package/build/utils/docker.test.js

@@ -54,7 +54,7 @@ describe("dockerImageExistsLocally", () => {
     });
 });
 describe("pullDockerImage", () => {
-    const IMAGE = "skyramp/executor:v1.3.22";
+    const IMAGE = "skyramp/executor:v1.3.23";
     beforeEach(() => jest.clearAllMocks());
     describe("on amd64 host", () => {
         const originalArch = process.arch;

package/build/utils/routeParsers.js

@@ -323,6 +323,13 @@ export function parseEndpointsFromDiff(diffData) {
         affectedServices,
     };
 }
+export const SKIP_PATH_SEGMENTS = new Set(["api", "v1", "v2", "v3", "public"]);
+/** Extract the primary resource name from an endpoint path (e.g. "/api/v1/orders/{id}" → "orders"). */
+export function extractResourceFromPath(endpointPath) {
+    const segments = endpointPath.split("/").filter(Boolean);
+    const meaningful = segments.filter(s => !s.startsWith("{") && !SKIP_PATH_SEGMENTS.has(s));
+    return meaningful[meaningful.length - 1] || "unknown";
+}
 /**
  * Resolve incomplete diff-parsed endpoint paths against the authoritative
  * scanned endpoint catalog. Route decorators in diffs often contain only the