@skyramp/mcp 0.1.5 → 0.1.6

package/build/utils/featureFlags.test.js

@@ -0,0 +1,81 @@
+import { resolveServiceDetailsRef } from "./utils.js";
+import { isTestbotEnabled } from "./featureFlags.js";
+// Capture and restore the original env var so these tests don't pollute other
+// test suites or a developer's shell environment where the var may already be set.
+let originalTestbotEnv;
+beforeAll(() => { originalTestbotEnv = process.env.SKYRAMP_FEATURE_TESTBOT; });
+afterAll(() => {
+    if (originalTestbotEnv === undefined) {
+        delete process.env.SKYRAMP_FEATURE_TESTBOT;
+    }
+    else {
+        process.env.SKYRAMP_FEATURE_TESTBOT = originalTestbotEnv;
+    }
+});
+describe("isTestbotEnabled", () => {
+    afterEach(() => {
+        delete process.env.SKYRAMP_FEATURE_TESTBOT;
+    });
+    it('returns true when SKYRAMP_FEATURE_TESTBOT is "1"', () => {
+        process.env.SKYRAMP_FEATURE_TESTBOT = "1";
+        expect(isTestbotEnabled()).toBe(true);
+    });
+    it("returns false when SKYRAMP_FEATURE_TESTBOT is unset", () => {
+        expect(isTestbotEnabled()).toBe(false);
+    });
+    it('returns false when SKYRAMP_FEATURE_TESTBOT is "0"', () => {
+        process.env.SKYRAMP_FEATURE_TESTBOT = "0";
+        expect(isTestbotEnabled()).toBe(false);
+    });
+    it('returns false when SKYRAMP_FEATURE_TESTBOT is "true"', () => {
+        process.env.SKYRAMP_FEATURE_TESTBOT = "true";
+        expect(isTestbotEnabled()).toBe(false);
+    });
+});
+describe("resolveServiceDetailsRef", () => {
+    afterEach(() => {
+        delete process.env.SKYRAMP_FEATURE_TESTBOT;
+    });
+    describe("testbot mode (SKYRAMP_FEATURE_TESTBOT=1)", () => {
+        beforeEach(() => {
+            process.env.SKYRAMP_FEATURE_TESTBOT = "1";
+        });
+        it("returns <services> block reference for testDirRef", () => {
+            expect(resolveServiceDetailsRef().testDirRef).toContain("<output_dir>");
+            expect(resolveServiceDetailsRef().testDirRef).toContain("<services>");
+        });
+        it("returns <services> block reference for frontendTestDirRef", () => {
+            expect(resolveServiceDetailsRef().frontendTestDirRef).toContain("<output_dir>");
+            expect(resolveServiceDetailsRef().frontendTestDirRef).toContain("<services>");
+        });
+        it("returns <services> block reference for authSourceRef", () => {
+            expect(resolveServiceDetailsRef().authSourceRef).toContain("<services>");
+        });
+        it("returns <services> block reference for baseUrlRef", () => {
+            expect(resolveServiceDetailsRef().baseUrlRef).toContain("<base_url>");
+        });
+        it("does NOT reference workspace.yml in any field", () => {
+            const refs = resolveServiceDetailsRef();
+            for (const val of Object.values(refs)) {
+                expect(val).not.toContain("workspace.yml");
+            }
+        });
+    });
+    describe("MCP mode (SKYRAMP_FEATURE_TESTBOT unset)", () => {
+        it("returns workspace.yml reference for testDirRef", () => {
+            expect(resolveServiceDetailsRef().testDirRef).toContain("workspace.yml");
+        });
+        it("returns workspace.yml reference for frontendTestDirRef", () => {
+            expect(resolveServiceDetailsRef().frontendTestDirRef).toContain("workspace.yml");
+        });
+        it("returns workspace.yml reference for authSourceRef", () => {
+            expect(resolveServiceDetailsRef().authSourceRef).toContain("workspace.yml");
+        });
+        it("does NOT reference <services> in any field", () => {
+            const refs = resolveServiceDetailsRef();
+            for (const val of Object.values(refs)) {
+                expect(val).not.toContain("<services>");
+            }
+        });
+    });
+});

package/build/utils/httpDefaults.js

@@ -0,0 +1,17 @@
+/**
+ * Shared HTTP method defaults used across scenario drafting and test generation.
+ */
+/**
+ * Returns the conventional success status code for a given HTTP method.
+ *   POST   → 201 Created
+ *   DELETE → 204 No Content
+ *   other  → 200 OK
+ */
+export function inferExpectedStatus(method) {
+    const m = method.toUpperCase();
+    if (m === "POST")
+        return 201;
+    if (m === "DELETE")
+        return 204;
+    return 200;
+}

package/build/utils/httpDefaults.test.js

@@ -0,0 +1,21 @@
+import { inferExpectedStatus } from "./httpDefaults.js";
+describe("inferExpectedStatus", () => {
+    it("returns 201 for POST", () => {
+        expect(inferExpectedStatus("POST")).toBe(201);
+        expect(inferExpectedStatus("post")).toBe(201);
+    });
+    it("returns 204 for DELETE", () => {
+        expect(inferExpectedStatus("DELETE")).toBe(204);
+        expect(inferExpectedStatus("delete")).toBe(204);
+    });
+    it("returns 200 for GET", () => {
+        expect(inferExpectedStatus("GET")).toBe(200);
+        expect(inferExpectedStatus("get")).toBe(200);
+    });
+    it("returns 200 for PUT", () => {
+        expect(inferExpectedStatus("PUT")).toBe(200);
+    });
+    it("returns 200 for PATCH", () => {
+        expect(inferExpectedStatus("PATCH")).toBe(200);
+    });
+});

package/build/utils/scenarioDrafting.js

@@ -1,14 +1,16 @@
 import { ScenarioSource } from "../types/RepositoryAnalysis.js";
 import { TestType } from "../types/TestTypes.js";
 import { CATEGORY_PRIORITY } from "../types/TestRecommendation.js";
-/**
- * Cap on drafted scenarios per category to prevent prompt bloat on large APIs.
- * Value of 4 balances coverage breadth (enough to surface patterns across
- * resources) with token budget (each scenario adds ~15-20 lines to the prompt).
- */
-const MAX_DRAFTED_SCENARIOS_PER_CATEGORY = 4;
+import { inferExpectedStatus } from "./httpDefaults.js";
 const ACTION_PATTERN = /^(me|merge|archive|search|login|logout|verify|forgot|reset|config|dashboard|webhook|migration|favicon|payment|health|status|ping|metrics|callback|confirm|activate|deactivate|subscribe|unsubscribe|unknown)$/i;
 const ACTION_VERB_HYPHEN = /^(forgot-|reset-|verify-|confirm-|send-|check-|get-|set-|update-|delete-|create-|trigger-|start-|stop-)/i;
+/**
+ * Returns true when `a` starts with `b` at a path-segment boundary.
+ * Plain `startsWith` is not sufficient — "/orders-archive".startsWith("/orders") is true
+ * even though they are different resources. Requiring the next character to be "/" or
+ * end-of-string ensures only genuine path prefixes are matched.
+ */
+const isSegmentPrefix = (a, b) => a.startsWith(b) && (a[b.length] === "/" || a[b.length] === undefined);
 export function isRealResource(r) {
     return !ACTION_PATTERN.test(r) && !ACTION_VERB_HYPHEN.test(r);
 }
@@ -142,13 +144,27 @@ export function draftScenariosFromEndpoints(endpoints, newEndpoints = []) {
         }
         const existing = resourceGroups.get(resource);
         if (existing) {
-            for (const m of ep.methods)
-                existing.methods.add(typeof m === "string" ? m : m.method);
-            if (basePath.split("/").length < existing.basePath.split("/").length) {
-                existing.basePath = basePath;
+            // Only merge if the paths are related at a segment boundary.
+            const related = isSegmentPrefix(basePath, existing.basePath) || isSegmentPrefix(existing.basePath, basePath);
+            if (related) {
+                for (const m of ep.methods)
+                    existing.methods.add(typeof m === "string" ? m : m.method);
+                if (basePath.split("/").length < existing.basePath.split("/").length) {
+                    existing.basePath = basePath;
+                }
+                if (paramPath && (!existing.paramPath || paramPath.split("/").length < existing.paramPath.split("/").length)) {
+                    existing.paramPath = paramPath;
+                }
             }
-            if (paramPath && (!existing.paramPath || paramPath.split("/").length < existing.paramPath.split("/").length)) {
-                existing.paramPath = paramPath;
+            else {
+                // Use the raw basePath as the disambiguating suffix — replacing "/" with "_" could
+                // produce collisions between e.g. /orders/search and /orders_search.
+                const disambiguatedKey = `${resource}::${basePath}`;
+                resourceGroups.set(disambiguatedKey, {
+                    basePath,
+                    methods: new Set(ep.methods.map((m) => typeof m === "string" ? m : m.method)),
+                    paramPath,
+                });
             }
         }
         else {
@@ -264,7 +280,7 @@ function diffDirectIntegration(method, resource, singular, group) {
     };
 }
 function diffDirectContract(method, path, resource) {
-    const expectedStatus = method === "POST" ? 201 : method === "DELETE" ? 204 : 200;
+    const expectedStatus = inferExpectedStatus(method);
     return {
         scenarioName: `${resource}-${method.toLowerCase()}-new-endpoint-contract`,
         description: `Contract: ${method} ${path} returns a schema-conformant response`,
@@ -520,6 +536,9 @@ export function draftDiffDirectScenarios(newEndpoints, resourceGroups) {
     for (const [epPath, methods] of grouped) {
         let resource = extractResourceName(epPath);
         let resolvedPath = epPath;
+        // The map key to use for the final resourceGroups lookup — may differ from `resource`
+        // when the entry was stored under a disambiguated "resource::basePath" key.
+        let resourceGroupKey = resource;
         // When resource was found but epPath may be router-relative (e.g. "/orders"
         // instead of "/api/v1/orders"), try to upgrade resolvedPath to the full path.
         if (resource) {
@@ -553,11 +572,14 @@ export function draftDiffDirectScenarios(newEndpoints, resourceGroups) {
             }
             if (!bestMatch)
                 continue;
-            resource = bestMatch.name;
+            // Keep the full map key for lookup — disambiguated keys use "resource::basePath" format.
+            // Use only the prefix before "::" as the resource name for scenario naming/singularization.
+            resourceGroupKey = bestMatch.name;
+            resource = resourceGroupKey.includes("::") ? resourceGroupKey.split("::")[0] : resourceGroupKey;
             // For prefix matches (action sub-paths), keep original path; for suffix matches, use resolved path
             resolvedPath = bestMatch.isPrefixMatch ? epPath : bestMatch.path;
         }
-        const group = resourceGroups.get(resource);
+        const group = resourceGroups.get(resourceGroupKey);
         if (!group)
             continue;
         const singular = singularize(resource);

package/build/utils/scenarioDrafting.test.js

@@ -577,3 +577,69 @@ describe("draftScenariosFromEndpoints — capScenarios hard limit", () => {
         expect(result.length).toBeGreaterThanOrEqual(4);
     });
 });
+describe("path collision fix — resourceGroups disambiguation", () => {
+    it("unrelated paths sharing a last segment do not overwrite each other", () => {
+        // /api/v1/orders/search and /api/v1/products/search share 'search' as last segment.
+        // Before the fix, the second overwrote the first in resourceGroups.
+        // The scenario must reference the orders/search path specifically, not products/search.
+        const endpoints = [
+            { path: "/api/v1/orders/search", methods: ["GET"] },
+            { path: "/api/v1/products/search", methods: ["GET"] },
+        ];
+        const newEndpoints = [{ method: "GET", path: "/api/v1/orders/search" }];
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
+        expect(result.length).toBeGreaterThanOrEqual(1);
+        const allPaths = result.flatMap((s) => (s.steps ?? []).map((step) => step.path ?? ""));
+        // Must contain orders/search
+        expect(allPaths.some((p) => p.includes("orders/search"))).toBe(true);
+        // Must NOT contain products/search — wrong path from a collision would appear here
+        expect(allPaths.some((p) => p.includes("products/search"))).toBe(false);
+    });
+    it("related paths (nested resources) still merge correctly", () => {
+        // /api/v1/users and /api/v1/users/{id} are related — should still merge
+        const endpoints = [
+            { path: "/api/v1/users", methods: ["GET", "POST"] },
+            { path: "/api/v1/users/{id}", methods: ["GET", "PUT", "DELETE"] },
+        ];
+        const newEndpoints = [{ method: "POST", path: "/api/v1/users" }];
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
+        expect(result.length).toBeGreaterThanOrEqual(1);
+    });
+    it("new endpoint under a disambiguated group is not silently dropped", () => {
+        // When two paths share a last segment, both are stored under disambiguated keys
+        // (e.g. "search::/api/v1/orders/search"). The fallback in draftDiffDirectScenarios
+        // must use the full key for resourceGroups.get(), not the stripped "search" name
+        // (which has no entry), otherwise the scenario is silently skipped.
+        const endpoints = [
+            { path: "/api/v1/orders/search", methods: ["GET"] },
+            { path: "/api/v1/products/search", methods: ["GET"] },
+            { path: "/api/v1/orders", methods: ["GET", "POST"] },
+            { path: "/api/v1/products", methods: ["GET", "POST"] },
+        ];
+        const newEndpoints = [
+            { method: "GET", path: "/api/v1/orders/search" },
+            { method: "GET", path: "/api/v1/products/search" },
+        ];
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
+        // Both new endpoints must produce at least one scenario each — neither should be dropped
+        const allPaths = result.flatMap((s) => (s.steps ?? []).map((step) => step.path ?? ""));
+        expect(allPaths.some((p) => p.includes("orders/search") || p.includes("orders"))).toBe(true);
+        expect(allPaths.some((p) => p.includes("products/search") || p.includes("products"))).toBe(true);
+    });
+    it("paths sharing a string prefix but different resource names are not merged", () => {
+        // /api/v1/orders and /api/v1/orders-archive start with the same string
+        // but are different resources. startsWith alone would incorrectly merge them.
+        const endpoints = [
+            { path: "/api/v1/orders", methods: ["GET", "POST"] },
+            { path: "/api/v1/orders-archive", methods: ["GET"] },
+        ];
+        const newEndpoints = [{ method: "POST", path: "/api/v1/orders" }];
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
+        expect(result.length).toBeGreaterThanOrEqual(1);
+        const allPaths = result.flatMap((s) => (s.steps ?? []).map((step) => step.path ?? ""));
+        // orders scenario must be present
+        expect(allPaths.some((p) => p.includes("/orders"))).toBe(true);
+        // orders-archive must not appear in scenarios targeting /orders
+        expect(allPaths.some((p) => p.includes("orders-archive"))).toBe(false);
+    });
+});

package/build/utils/telemetry.js

@@ -3,8 +3,9 @@
  * "testbot" when running as part of the GitHub Action test bot,
  * "mcp" for regular IDE/MCP usage.
  */
+import { isTestbotEnabled } from "./featureFlags.js";
 export function getEntryPoint() {
-    return process.env.SKYRAMP_FEATURE_TESTBOT === "1" ? "testbot" : "mcp";
+    return isTestbotEnabled() ? "testbot" : "mcp";
 }
 /**
  * Detects the CI/CD platform from environment variables.

package/build/utils/utils.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { isTestbotEnabled } from "./featureFlags.js";
 import { logger } from "./logger.js";
 export const OUTPUT_DIR_FIELD_NAME = "outputDir";
 export const TRACE_OUTPUT_FILE_FIELD_NAME = "traceOutputFile";
@@ -134,3 +135,25 @@ export function generateSkyrampHeader(language) {
     const commentPrefix = COMMENT_PREFIX_MAP[language] || "#";
     return `${commentPrefix} ${SKYRAMP_UTILS_HEADER} on ${timestamp} ${timezone}\n\n`;
 }
+/**
+ * Returns prompt phrasing for where the agent should find service details.
+ *
+ * - Testbot mode: agent receives a `<services>` XML block — no workspace.yml exists.
+ * - Normal MCP mode: agent reads `.skyramp/workspace.yml`.
+ */
+export function resolveServiceDetailsRef() {
+    if (isTestbotEnabled()) {
+        return {
+            testDirRef: "the `<output_dir>` from the `<services>` block",
+            frontendTestDirRef: "the **frontend** service's `<output_dir>` from the `<services>` block",
+            baseUrlRef: "the `<base_url>` from the `<services>` block",
+            authSourceRef: "the `<services>` block",
+        };
+    }
+    return {
+        testDirRef: "the `testDirectory` from `.skyramp/workspace.yml`",
+        frontendTestDirRef: "the **frontend** service's `testDirectory` from `.skyramp/workspace.yml`",
+        baseUrlRef: "the `api.baseUrl` from `.skyramp/workspace.yml`",
+        authSourceRef: "`.skyramp/workspace.yml`",
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",