@skyramp/mcp 0.0.63 → 0.0.64-rc.2

package/build/utils/scenarioDrafting.test.js

@@ -1,5 +1,5 @@
 // @ts-ignore
-import { isRealResource, draftScenariosFromEndpoints, draftUniqueConstraintScenarios, draftCascadeDeleteScenarios, draftPermissionBoundaryScenarios, } from "./scenarioDrafting.js";
+import { isRealResource, draftScenariosFromEndpoints, draftDiffDirectScenarios, draftUniqueConstraintScenarios, draftCascadeDeleteScenarios, draftPermissionBoundaryScenarios, inferResourceRelationships, } from "./scenarioDrafting.js";
 describe("isRealResource", () => {
     it("accepts normal resource names", () => {
         expect(isRealResource("users")).toBe(true);
@@ -36,6 +36,36 @@ describe("isRealResource", () => {
         expect(isRealResource("Forgot-Password")).toBe(false);
     });
 });
+describe("draftScenariosFromEndpoints — irregular plural singularization", () => {
+    it("uses 'category' (not 'categorie') in FK field names for -ies plurals", () => {
+        const endpoints = [
+            { path: "/api/categories", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/categories/{id}", methods: [{ method: "GET" }, { method: "PUT" }, { method: "DELETE" }] },
+            { path: "/api/items", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/items/{id}", methods: [{ method: "GET" }, { method: "DELETE" }] },
+        ];
+        const scenarios = draftScenariosFromEndpoints(endpoints);
+        const allText = JSON.stringify(scenarios);
+        expect(allText).not.toContain("categorie_id");
+        expect(allText).not.toContain("\"categorie\"");
+        // The CRUD scenario description should use "category"
+        const crudScenario = scenarios.find((s) => s.scenarioName === "categories-crud-lifecycle");
+        expect(crudScenario).toBeDefined();
+        expect(crudScenario.steps[0].description).toContain("category");
+    });
+    it("uses 'status' (not 'statu') in FK field names for -ses plurals", () => {
+        const endpoints = [
+            { path: "/api/statuses", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/statuses/{id}", methods: [{ method: "GET" }, { method: "DELETE" }] },
+        ];
+        const scenarios = draftScenariosFromEndpoints(endpoints);
+        const allText = JSON.stringify(scenarios);
+        expect(allText).not.toContain("statu_id");
+        const crudScenario = scenarios.find((s) => s.scenarioName === "statuses-crud-lifecycle");
+        expect(crudScenario).toBeDefined();
+        expect(crudScenario.steps[0].description).toContain("status");
+    });
+});
 describe("draftScenariosFromEndpoints", () => {
     it("returns empty array for no endpoints", () => {
         expect(draftScenariosFromEndpoints([])).toEqual([]);
@@ -124,11 +154,11 @@ describe("draftCascadeDeleteScenarios", () => {
         const scenarios = draftCascadeDeleteScenarios(groups);
         expect(scenarios).toHaveLength(2);
         expect(scenarios[0].scenarioName).toContain("cascade-delete");
-        expect(scenarios[1].scenarioName).toContain("delete-blocked");
         expect(scenarios[0].category).toBe("data_integrity");
         // Cascade: step 4 expects 404
         expect(scenarios[0].steps[3].expectedStatusCode).toBe(404);
         // Blocked: step 3 expects 409, step 4 expects 200
+        expect(scenarios[1].scenarioName).toContain("delete-blocked");
         expect(scenarios[1].steps[2].expectedStatusCode).toBe(409);
         expect(scenarios[1].steps[3].expectedStatusCode).toBe(200);
     });
@@ -191,3 +221,161 @@ describe("draftPermissionBoundaryScenarios", () => {
         expect(draftPermissionBoundaryScenarios(groups).length).toBeLessThanOrEqual(4);
     });
 });
+describe("inferResourceRelationships", () => {
+    it("returns empty map for endpoints with no nesting or FK fields", () => {
+        const endpoints = [
+            { path: "/api/users", methods: [{ method: "GET" }] },
+            { path: "/api/products", methods: [{ method: "GET" }] },
+        ];
+        expect(inferResourceRelationships(endpoints).size).toBe(0);
+    });
+    it("detects parent→child relationship from path nesting (/parent/{id}/child)", () => {
+        const endpoints = [
+            { path: "/api/collections/{id}/links", methods: [{ method: "GET" }] },
+        ];
+        const rel = inferResourceRelationships(endpoints);
+        expect(rel.has("links")).toBe(true);
+        expect(rel.get("links").has("collections")).toBe(true);
+    });
+    it("detects FK relationship from request body field ({resource}_id)", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: [{ method: "POST", interactions: [{ request: { body: { product_id: "abc" } } }] }] },
+            { path: "/api/products", methods: [{ method: "GET" }] },
+        ];
+        const rel = inferResourceRelationships(endpoints);
+        expect(rel.has("orders")).toBe(true);
+        expect(rel.get("orders").has("products")).toBe(true);
+    });
+    it("does not create self-reference", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: [{ method: "POST", interactions: [{ request: { body: { order_id: "abc" } } }] }] },
+        ];
+        const rel = inferResourceRelationships(endpoints);
+        // orders should not reference itself
+        expect(rel.get("orders")?.has("orders")).toBeFalsy();
+    });
+    it("ignores FK fields that point to unknown resources", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: [{ method: "POST", interactions: [{ request: { body: { nonexistent_resource_id: "abc" } } }] }] },
+        ];
+        const rel = inferResourceRelationships(endpoints);
+        // nonexistent_resource is not a known endpoint resource, should be ignored
+        expect(rel.get("orders")?.size ?? 0).toBe(0);
+    });
+});
+describe("draftCascadeDeleteScenarios — with relationships parameter", () => {
+    function makeGroups(resources) {
+        const map = new Map();
+        for (const [name, info] of Object.entries(resources)) {
+            map.set(name, { basePath: info.basePath, methods: new Set(info.methods), paramPath: info.paramPath });
+        }
+        return map;
+    }
+    it("skips pairs with no detected relationship when a non-empty relationships map is provided", () => {
+        const groups = makeGroups({
+            users: { basePath: "/api/users", methods: ["POST", "DELETE"], paramPath: "/api/users/{id}" },
+            products: { basePath: "/api/products", methods: ["POST", "DELETE"], paramPath: "/api/products/{id}" },
+        });
+        // Non-empty map that knows about orders→users but says nothing about products↔users
+        const rel = new Map();
+        rel.set("orders", new Set(["users"])); // unrelated to our test pair
+        expect(draftCascadeDeleteScenarios(groups, rel)).toHaveLength(0);
+    });
+    it("uses heuristic pairing (first=parent) when relationships map is empty", () => {
+        const groups = makeGroups({
+            users: { basePath: "/api/users", methods: ["POST", "DELETE"], paramPath: "/api/users/{id}" },
+            products: { basePath: "/api/products", methods: ["POST", "DELETE"], paramPath: "/api/products/{id}" },
+        });
+        const rel = new Map();
+        // Empty map → falls back to heuristic: generates scenarios for all pairs
+        expect(draftCascadeDeleteScenarios(groups, rel).length).toBeGreaterThan(0);
+    });
+    it("uses relationship direction to set correct parent→child order", () => {
+        const groups = makeGroups({
+            users: { basePath: "/api/users", methods: ["POST", "DELETE"], paramPath: "/api/users/{id}" },
+            orders: { basePath: "/api/orders", methods: ["POST", "DELETE"], paramPath: "/api/orders/{id}" },
+        });
+        // orders depends on users (orders is the child)
+        const rel = new Map();
+        rel.set("orders", new Set(["users"]));
+        const scenarios = draftCascadeDeleteScenarios(groups, rel);
+        expect(scenarios.length).toBeGreaterThan(0);
+        // Parent should be users, child should be orders
+        expect(scenarios[0].scenarioName).toContain("users");
+        expect(scenarios[0].scenarioName).toContain("orders");
+        expect(scenarios[0].steps[0].path).toBe("/api/users"); // POST parent first
+    });
+});
+describe("draftDiffDirectScenarios", () => {
+    const makeGroups = (defs) => new Map(Object.entries(defs).map(([k, v]) => [k, { ...v, methods: new Set(v.methods) }]));
+    it("returns empty array when newEndpoints is empty", () => {
+        const groups = makeGroups({ orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" } });
+        expect(draftDiffDirectScenarios([], groups)).toEqual([]);
+    });
+    it("generates new_endpoint-category scenarios for a new PUT endpoint", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT"], paramPath: "/api/orders/{order_id}" },
+        });
+        const scenarios = draftDiffDirectScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }], groups);
+        expect(scenarios.length).toBeGreaterThanOrEqual(2);
+        for (const s of scenarios) {
+            expect(s.category).toBe("new_endpoint");
+        }
+        // Integration happy path includes the PUT step
+        const integration = scenarios.find(s => s.testType === "integration");
+        expect(integration).toBeDefined();
+        expect(integration.steps.some(st => st.method === "PUT")).toBe(true);
+        // Description prompts LLM to discover prerequisites from source code
+        expect(integration.description).toContain("prerequisites");
+        // Contract test
+        const contract = scenarios.find(s => s.testType === "contract" && s.steps[0].expectedStatusCode === 200);
+        expect(contract).toBeDefined();
+        // Not-found edge case
+        const notFound = scenarios.find(s => s.steps.some(st => st.expectedStatusCode === 404));
+        expect(notFound).toBeDefined();
+    });
+    it("integration scenario minimum steps: POST resource then PUT — LLM discovers prereqs from source code", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT"], paramPath: "/api/orders/{order_id}" },
+        });
+        const scenarios = draftDiffDirectScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }], groups);
+        const integration = scenarios.find(s => s.testType === "integration");
+        expect(integration).toBeDefined();
+        // Minimum steps: create the resource + call the new endpoint
+        expect(integration.steps.some(st => st.method === "POST" && st.path === "/api/orders")).toBe(true);
+        expect(integration.steps.some(st => st.method === "PUT")).toBe(true);
+        // No prerequisite steps pre-computed — LLM is instructed to discover them
+        expect(integration.steps[0].path).toBe("/api/orders"); // first step is the resource itself, not a prereq
+    });
+    it("generates 3 scenarios for a new POST endpoint", () => {
+        const groups = makeGroups({
+            products: { basePath: "/api/products", methods: ["GET", "POST"], paramPath: "/api/products/{id}" },
+        });
+        const scenarios = draftDiffDirectScenarios([{ method: "POST", path: "/api/products" }], groups);
+        expect(scenarios.length).toBe(3); // integration, contract, validation
+        const types = scenarios.map(s => s.testType);
+        expect(types).toContain("integration");
+        expect(types).toContain("contract");
+        // validation error scenario (422)
+        expect(scenarios.some(s => s.steps.some(st => st.expectedStatusCode === 422))).toBe(true);
+    });
+    it("ignores unknown paths and skips action-verb segments", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["POST", "DELETE"], paramPath: "/api/orders/{id}" },
+        });
+        const scenarios = draftDiffDirectScenarios([{ method: "POST", path: "/api/health" }], // 'health' is not a real resource
+        groups);
+        expect(scenarios).toEqual([]);
+    });
+    it("draftScenariosFromEndpoints passes newEndpoints through to diff-direct scenarios", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: ["GET", "POST", "PUT"] },
+            { path: "/api/orders/{order_id}", methods: ["GET", "PUT", "DELETE"] },
+        ];
+        const newEndpoints = [{ method: "PUT", path: "/api/orders/{order_id}" }];
+        const scenarios = draftScenariosFromEndpoints(endpoints, newEndpoints);
+        const diffDirect = scenarios.filter(s => s.category === "new_endpoint");
+        expect(diffDirect.length).toBeGreaterThan(0);
+        expect(diffDirect.some(s => s.steps.some(st => st.method === "PUT"))).toBe(true);
+    });
+});

package/build/utils/trace-parser.js

@@ -3,6 +3,7 @@
  * structured entries for analysis enrichment.
  */
 import * as fs from "fs";
+import * as path from "path";
 const FLOW_GAP_MS = 30_000;
 const SENSITIVE_HEADER = /^(authorization|cookie|x-api-key|x-auth-token|set-cookie)/i;
 function groupIntoFlows(entries) {
@@ -154,34 +155,60 @@ export async function parseTraceFile(filePath) {
     const userFlows = groupIntoFlows(entries);
     return { entries, userFlows, format };
 }
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", "coverage", "__pycache__", ".venv", "venv"]);
 /**
- * Discover trace files in a repository path.
+ * Recursively scan a directory for files matching a predicate, up to maxDepth levels.
+ */
+function scanDir(dir, predicate, maxDepth, results) {
+    if (maxDepth < 0)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name)) {
+                scanDir(path.join(dir, entry.name), predicate, maxDepth - 1, results);
+            }
+        }
+        else if (entry.isFile() && predicate(entry.name)) {
+            results.push(path.join(dir, entry.name));
+        }
+    }
+}
+/**
+ * Discover trace JSON files in a repository path.
  */
 export function discoverTraceFiles(repositoryPath) {
-    const candidates = [
-        "skyramp_traces.json",
-        "traces.json",
-        "trace.json",
-        "traces.har",
-        "trace.har",
-    ];
     const found = [];
-    for (const name of candidates) {
+    // Fixed-name candidates at repo root
+    for (const name of ["skyramp_traces.json", "traces.json", "trace.json", "traces.har", "trace.har"]) {
         const full = `${repositoryPath}/${name}`;
         if (fs.existsSync(full))
             found.push(full);
     }
-    const skyrampDir = `${repositoryPath}/.skyramp`;
-    if (fs.existsSync(skyrampDir)) {
-        try {
-            const files = fs.readdirSync(skyrampDir);
-            for (const f of files) {
-                if (/\.(json|har)$/i.test(f) && /trace/i.test(f)) {
-                    found.push(`${skyrampDir}/${f}`);
-                }
-            }
-        }
-        catch { /* dir not readable */ }
-    }
-    return found;
+    // Recursive scan: any *trace*.json|har, but exclude scenario files and test output files
+    const isTraceJson = (name) => /\.(json|har)$/i.test(name) &&
+        /trace/i.test(name) &&
+        !/^scenario_/i.test(name) &&
+        !/_test\.(json|har)$/i.test(name);
+    scanDir(repositoryPath, isTraceJson, 5, found);
+    // Deduplicate and sort for deterministic ordering
+    return [...new Set(found)].sort();
+}
+/**
+ * Discover Playwright recording zip files in a repository path.
+ */
+export function discoverPlaywrightZips(repositoryPath) {
+    const found = [];
+    // Match: *playwright*.zip OR *_trace.zip (skyramp_export_zip output) OR trace.zip
+    const isPlaywrightZip = (name) => /\.zip$/i.test(name) && (/playwright/i.test(name) ||
+        /_trace\.zip$/i.test(name) ||
+        name.toLowerCase() === "trace.zip");
+    scanDir(repositoryPath, isPlaywrightZip, 5, found);
+    return [...new Set(found)].sort();
 }