@skyramp/mcp 0.0.59 → 0.0.60-rc.2

package/build/resources/analysisResources.js

@@ -0,0 +1,254 @@
+import * as fs from "fs";
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StateManager, getSessionFilePath, getRegisteredSessions, hasSessionData, getSessionData, } from "../utils/AnalysisStateManager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Register MCP Resources for analysis data access.
+ *
+ * Resources provide read-only, token-efficient access to analysis data
+ * via sessionId. The state file is an internal backing store.
+ *
+ * URI scheme:
+ *   skyramp://analysis/{sessionId}/summary
+ *   skyramp://analysis/{sessionId}/endpoints
+ *   skyramp://analysis/{sessionId}/endpoints/{+path}
+ *   skyramp://analysis/{sessionId}/endpoints/{+path}/{method}
+ *   skyramp://analysis/{sessionId}/scenarios
+ *   skyramp://analysis/{sessionId}/diff
+ */
+export function registerAnalysisResources(server) {
+    logger.info("Registering analysis resources");
+    async function loadAnalysis(sessionId) {
+        // Try process memory first (new flow — no state file needed)
+        if (hasSessionData(sessionId)) {
+            const memData = getSessionData(sessionId);
+            if (memData?.analysis) {
+                logger.debug("Loaded analysis from process memory for resource", { sessionId });
+                return memData;
+            }
+        }
+        // Fall back to state file for backward compatibility
+        const registeredPath = getSessionFilePath(sessionId);
+        const mgr = registeredPath
+            ? StateManager.fromStatePath(registeredPath)
+            : StateManager.fromSessionId(sessionId);
+        if (!mgr.exists()) {
+            throw new Error(`Analysis session "${sessionId}" not found or expired.`);
+        }
+        const data = await mgr.readData();
+        if (!data) {
+            throw new Error(`Analysis session "${sessionId}" has no data.`);
+        }
+        if (!data.analysis && data.apiEndpoints) {
+            logger.info("Detected unwrapped RepositoryAnalysis in resource handler — adapting");
+            return {
+                repositoryPath: data.metadata?.repositoryName || "unknown",
+                analysisScope: data.metadata?.analysisScope,
+                analysis: data,
+            };
+        }
+        if (!data.analysis) {
+            throw new Error(`Analysis session "${sessionId}" has no analysis data.`);
+        }
+        return data;
+    }
+    /**
+     * Shared list callback: returns resource URIs for sessions created by
+     * this process only (via the in-memory registry). No filesystem scan —
+     * eliminates cross-process leakage when multiple clients share /tmp.
+     */
+    function makeListCallback(suffix) {
+        return async () => {
+            const sessions = getRegisteredSessions();
+            const available = Array.from(sessions.entries()).filter(([sessionId, filePath]) => hasSessionData(sessionId) || fs.existsSync(filePath));
+            return {
+                resources: available.map(([sessionId]) => ({
+                    uri: `skyramp://analysis/${sessionId}/${suffix}`,
+                    name: `Analysis ${suffix} (${sessionId})`,
+                    mimeType: "application/json",
+                })),
+            };
+        };
+    }
+    // ── Summary ──
+    server.registerResource("analysis_summary", new ResourceTemplate("skyramp://analysis/{sessionId}/summary", {
+        list: makeListCallback("summary"),
+    }), {
+        title: "Analysis Summary",
+        description: "High-level overview: project type, tech stack, endpoint/scenario counts, coverage gaps.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis, repositoryPath, analysisScope } = await loadAnalysis(sessionId);
+        const summary = {
+            sessionId,
+            repositoryPath,
+            analysisScope: analysisScope || "full_repo",
+            metadata: analysis.metadata,
+            projectClassification: analysis.projectClassification,
+            technologyStack: {
+                languages: analysis.technologyStack.languages,
+                frameworks: analysis.technologyStack.frameworks,
+                runtime: analysis.technologyStack.runtime,
+            },
+            authentication: analysis.authentication,
+            infrastructure: analysis.infrastructure,
+            endpointStats: {
+                totalPaths: analysis.apiEndpoints.endpoints.length,
+                totalMethods: analysis.apiEndpoints.endpoints.reduce((sum, ep) => sum + ep.methods.length, 0),
+                totalInteractions: analysis.apiEndpoints.endpoints.reduce((sum, ep) => sum +
+                    ep.methods.reduce((msum, m) => msum + m.interactions.length, 0), 0),
+                baseUrl: analysis.apiEndpoints.baseUrl,
+            },
+            scenarioCount: analysis.businessContext.draftedScenarios.length,
+            existingTests: analysis.existingTests,
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(summary, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Endpoints (compact listing) ──
+    server.registerResource("analysis_endpoints", new ResourceTemplate("skyramp://analysis/{sessionId}/endpoints", {
+        list: makeListCallback("endpoints"),
+    }), {
+        title: "Endpoint Listing",
+        description: "Compact listing of all endpoints (path, methods, interaction counts). Use path-specific resources for full detail.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis } = await loadAnalysis(sessionId);
+        const compact = analysis.apiEndpoints.endpoints.map((ep) => ({
+            path: ep.path,
+            resourceGroup: ep.resourceGroup,
+            pathParams: ep.pathParams.map((p) => p.name),
+            methods: ep.methods.map((m) => ({
+                method: m.method,
+                authRequired: m.authRequired,
+                interactionCount: m.interactions.length,
+                interactionTypes: m.interactions.map((i) => i.type),
+                hasCookies: m.interactions.some((i) => (i.response.cookies?.length ?? 0) > 0),
+                hasResponseHeaders: m.interactions.some((i) => Object.keys(i.response.headers ?? {}).length > 0),
+                createsResource: m.createsResource,
+            })),
+        }));
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ baseUrl: analysis.apiEndpoints.baseUrl, endpoints: compact }, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Single Path Detail ──
+    // No list callback — these are parameterized drilldowns, not top-level resources.
+    server.registerResource("analysis_endpoint_path", new ResourceTemplate("skyramp://analysis/{sessionId}/endpoints/{+path}", { list: undefined }), {
+        title: "Endpoint Path Detail",
+        description: "Full detail for a specific path: all methods, interactions, params.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const endpointPath = "/" + params.path;
+        const { analysis } = await loadAnalysis(sessionId);
+        const ep = analysis.apiEndpoints.endpoints.find((e) => e.path === endpointPath);
+        if (!ep) {
+            throw new Error(`Endpoint path "${endpointPath}" not found in session "${sessionId}".`);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(ep, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Single Method Detail ──
+    server.registerResource("analysis_endpoint_method", new ResourceTemplate("skyramp://analysis/{sessionId}/endpoints/{+path}/{method}", { list: undefined }), {
+        title: "Endpoint Method Detail",
+        description: "Full detail for a specific method on a path: interactions, params, auth.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const endpointPath = "/" + params.path;
+        const method = params.method.toUpperCase();
+        const { analysis } = await loadAnalysis(sessionId);
+        const ep = analysis.apiEndpoints.endpoints.find((e) => e.path === endpointPath);
+        if (!ep) {
+            throw new Error(`Endpoint path "${endpointPath}" not found in session "${sessionId}".`);
+        }
+        const m = ep.methods.find((em) => em.method.toUpperCase() === method);
+        if (!m) {
+            throw new Error(`Method "${method}" not found on "${endpointPath}" in session "${sessionId}".`);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ path: ep.path, resourceGroup: ep.resourceGroup, pathParams: ep.pathParams, ...m }, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Scenarios ──
+    server.registerResource("analysis_scenarios", new ResourceTemplate("skyramp://analysis/{sessionId}/scenarios", {
+        list: makeListCallback("scenarios"),
+    }), {
+        title: "Drafted Scenarios",
+        description: "All drafted user-flow scenarios with steps, chaining, and priority.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis } = await loadAnalysis(sessionId);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(analysis.businessContext.draftedScenarios, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Branch Diff ──
+    server.registerResource("analysis_diff", new ResourceTemplate("skyramp://analysis/{sessionId}/diff", {
+        list: makeListCallback("diff"),
+    }), {
+        title: "Branch Diff Context",
+        description: "Branch diff context with new/modified endpoints (only present for current_branch_diff scope).",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis } = await loadAnalysis(sessionId);
+        if (!analysis.branchDiffContext) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ message: "No branch diff context (analysis scope was full_repo)." }, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(analysis.branchDiffContext, null, 2),
+                },
+            ],
+        };
+    });
+    logger.info("Analysis resources registered successfully");
+}

package/build/services/ScenarioGenerationService.js

@@ -7,18 +7,6 @@ export class ScenarioGenerationService {
             logger.info("Parsing scenario into API requests", {
                 scenarioName: params.scenarioName,
             });
-            // Check if we have API schema to work with
-            if (!params.apiSchema) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Please provide an API schema so that I can parse the scenario and map it to specific API endpoints.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
             // Generate a single trace request from the scenario
             const traceRequest = this.generateTraceRequestFromInput(params);
             if (!traceRequest) {
@@ -33,8 +21,6 @@ export class ScenarioGenerationService {
                 };
             }
             // Handle file writing
-            //add hyphen to the scenario name
-            //make file in tmp directory
             const scenarioName = params.scenarioName.replace(/ /g, "-").toLowerCase();
             const fileName = `scenario_${scenarioName}.json`;
             const filePath = path.join(params.outputDir, fileName);
@@ -118,27 +104,63 @@ ${JSON.stringify(traceRequest, null, 2)}
         }
     }
     generateTraceRequestFromInput(params) {
-        const destination = params.destination;
-        // Use AI-provided parameters instead of parsing
+        let destination = params.destination;
+        let scheme = "https";
+        let port = 443;
+        // Derive scheme, host, and port from baseURL when available
+        if (params.baseURL) {
+            try {
+                const parsed = new URL(params.baseURL);
+                scheme = parsed.protocol.replace(":", "");
+                destination = parsed.hostname;
+                port = parsed.port
+                    ? parseInt(parsed.port, 10)
+                    : scheme === "https"
+                        ? 443
+                        : 80;
+            }
+            catch {
+                logger.warning("Could not parse baseURL, using destination param", {
+                    baseURL: params.baseURL,
+                });
+            }
+        }
         const timestamp = new Date().toISOString();
         const method = params.method;
         const path = params.path;
-        const statusCode = params.statusCode ||
-            (method === "POST" ? 201 : method === "DELETE" ? 204 : 200);
+        const statusCode = params.statusCode;
         const requestBody = params.requestBody ||
             (method === "GET" || method === "DELETE" ? "" : "{}");
-        const responseBody = params.responseBody || (method === "DELETE" ? "" : "{}");
-        // Hardcode source IP and port for NLP consistency
+        let responseBody = params.responseBody;
+        if (!responseBody) {
+            if (method === "DELETE") {
+                responseBody = "";
+            }
+            else if (method === "POST" && requestBody && requestBody !== "{}") {
+                responseBody = this.synthesizePostResponse(requestBody);
+            }
+            else {
+                responseBody = "{}";
+            }
+        }
         const source = "192.168.65.1:39998";
+        // Build auth header from param or default to Bearer
+        const authHeaderName = params.authHeader || "Authorization";
+        const requestHeaders = {
+            "Content-Type": ["application/json"],
+        };
+        if (authHeaderName === "Cookie") {
+            requestHeaders["Cookie"] = ["session-token=demo-token"];
+        }
+        else {
+            requestHeaders[authHeaderName] = ["Bearer demo-token"];
+        }
         return {
             Source: source,
             Destination: destination,
             RequestBody: requestBody,
             ResponseBody: responseBody,
-            RequestHeaders: {
-                "Content-Type": ["application/json"],
-                Authorization: ["Bearer demo-token"],
-            },
+            RequestHeaders: requestHeaders,
             ResponseHeaders: {
                 "Content-Type": ["application/json"],
             },
@@ -146,9 +168,31 @@ ${JSON.stringify(traceRequest, null, 2)}
             Path: path,
             QueryParams: {},
             StatusCode: statusCode,
-            Port: 443,
+            Port: port,
             Timestamp: timestamp,
-            Scheme: "https",
+            Scheme: scheme,
         };
     }
+    /**
+     * Generate a synthetic POST response body that echoes the request body
+     * wrapped in a "response" envelope with an auto-incrementing "id".
+     * This gives the CLI response data to chain from (e.g., response.id).
+     */
+    synthesizePostResponse(requestBody) {
+        try {
+            const parsed = JSON.parse(requestBody);
+            const id = Date.now() % 100000;
+            if (Array.isArray(parsed)) {
+                const withIds = parsed.map((item, idx) => ({
+                    id: id + idx,
+                    ...item,
+                }));
+                return JSON.stringify({ response: withIds });
+            }
+            return JSON.stringify({ response: { id, ...parsed } });
+        }
+        catch {
+            return "{}";
+        }
+    }
 }

package/build/tools/generate-tests/generateIntegrationRestTool.js

@@ -17,7 +17,6 @@ const integrationTestSchema = z
         .describe("Path to the scenario file to be used for test generation. This file is generated by the skyramp_scenario_test_generation tool.")
         .optional(),
     ...codeRefactoringSchema.shape,
-    ...baseTestSchema,
     endpointURL: baseTestSchema.endpointURL.default(""),
 })
     .omit({ method: true }).shape;
@@ -26,6 +25,10 @@ export class IntegrationTestService extends TestGenerationService {
         return TestType.INTEGRATION;
     }
     buildGenerationOptions(params) {
+        if ((params.scenarioFile || params.trace) &&
+            !params.chainingKey) {
+            params.chainingKey = "response.id";
+        }
         return {
             ...super.buildBaseGenerationOptions(params),
             responseData: params.responseData,
@@ -33,6 +36,56 @@ export class IntegrationTestService extends TestGenerationService {
             scenarioFile: params.scenarioFile,
         };
     }
+    async generateTest(params) {
+        const result = await super.generateTest(params);
+        if (!result.isError && params.scenarioFile) {
+            const chainingInstructions = `
+
+⏭️ **CRITICAL NEXT STEP — Verify & Fix Chaining in Generated Test**
+
+The generated integration test uses \`chainingKey: "response.id"\` for all steps, but
+multi-resource workflows often need **different chaining per step**. You MUST:
+
+1. **Read the generated test file** in \`${params.outputDir}\`
+2. **Identify each API call** in the test (POST, GET, PUT, DELETE)
+3. **Verify chaining is correct** for each step:
+   - After each POST, the response ID must be extracted into a **uniquely named variable**
+     (e.g., \`product_id\`, \`order_id\`, \`review_id\` — NOT all named \`id\`)
+   - GET/PUT/DELETE calls that reference a resource must use the **correct** variable in their path
+     (e.g., \`/products/{product_id}\` uses the product's ID, not the order's ID)
+   - POST calls that create a child resource must include the **parent's ID** in the request body
+     or path (e.g., \`POST /orders\` body should include \`product_id\` from the products POST response)
+4. **Fix ONLY chaining** (path params AND request body ID references) — nothing else:
+   - Replace hardcoded path IDs (like \`/products/1\`) with the dynamic variable from the POST response
+   - Replace hardcoded IDs in request bodies (like \`"product_id": 1\`) with the dynamic variable
+     (use \`data_override\`/\`dataOverride\` or direct variable substitution)
+   - Rename duplicate variable names so each resource has its own ID variable
+   - For Python: use \`skyramp.get_response_value(response_N, "id")\` to extract and f-strings for paths
+   - For TypeScript: use \`getResponseValue(response, "response.id")\` or the appropriate accessor
+   ⚠️ **Preserve everything else exactly as generated** — do not add, remove, or modify
+   auth headers, cookies, tokens, env vars, imports, assertions, or non-chaining request body fields.
+   The CLI output for auth/headers is intentional.
+
+**Example fix for a products → orders workflow:**
+\`\`\`
+# Step 1: POST /products → extract product_id
+# Step 2: POST /orders with product_id in body → extract order_id  
+# Step 3: GET /orders/{order_id} → uses order_id (NOT product_id)
+# Step 4: DELETE /products/{product_id} → uses product_id (NOT order_id)
+\`\`\``;
+            const existingText = result.content[0] && "text" in result.content[0] ? result.content[0].text : "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: existingText + chainingInstructions,
+                    },
+                ],
+                isError: false,
+            };
+        }
+        return result;
+    }
     async handleApiAnalysis(params, generateOptions) {
         return null;
     }

package/build/tools/generate-tests/generateScenarioRestTool.js

@@ -11,7 +11,8 @@ const scenarioTestSchema = {
         .describe("Destination hostname or IP address for the test (e.g., api.example.com, localhost, 192.168.1.1). Do NOT include port numbers."),
     apiSchema: z
         .string()
-        .describe("MUST be absolute path (/path/to/openapi.json) to the OpenAPI/Swagger schema file or a URL to the OpenAPI/Swagger schema file (e.g. https://demoshop.skyramp.dev/openapi.json). Required for accurate API mapping."),
+        .optional()
+        .describe("MUST be absolute path(/path/to/openapi.json) to the OpenAPI/Swagger schema file or a URL to the OpenAPI/Swagger schema file(e.g. https://demoshop.skyramp.dev/openapi.json). DO NOT TRY TO ASSUME THE OPENAPI SCHEMA IF NOT PROVIDED. NOTE TO AI ASSISTANTS: You do not need to read the contents of this file - simply pass the file path as the backend will handle reading and processing it."),
     baseURL: z
         .string()
         .optional()
@@ -35,9 +36,13 @@ const scenarioTestSchema = {
         .describe("JSON string of the response body parsed by AI from the scenario"),
     statusCode: z
         .number()
-        .optional()
-        .describe("HTTP status code (e.g., 200, 201, 204) parsed by AI from the scenario"),
+        .describe("Expected HTTP status code. Read status codes from the API schema file else defaults: POST→201, DELETE→204, GET/PUT/PATCH→200."),
     outputDir: baseSchema.shape.outputDir,
+    authHeader: z
+        .string()
+        .optional()
+        .default("Authorization")
+        .describe("Name of the HTTP header to use for authorization. Use 'Cookie' for cookie-based auth (e.g., NextAuth), 'Authorization' for Bearer tokens, 'X-API-Key' for API keys. Defaults to 'Authorization'."),
 };
 const TOOL_NAME = "skyramp_scenario_test_generation";
 export function registerScenarioTestTool(server) {
@@ -77,8 +82,6 @@ The AI should parse the natural language scenario and provide:
 - AI-parsed HTTP method and path (required)
 - AI-parsed request/response bodies (optional)
 
-**IMPORTANT: If an apiSchema parameter (OpenAPI/Swagger file path or URL) is provided, DO NOT attempt to read or analyze the file contents. These files can be very large. Simply pass the path/URL to the tool - the backend will handle reading and processing the schema file.**
-
 **Note:** This tool generates one request at a time. Call multiple times for multi-step scenarios.
 
 **CRITICAL - Integration Test Generation After Scenario Creation:**

package/build/tools/submitReportTool.js

@@ -15,10 +15,32 @@ const newTestSchema = z.object({
     testType: z.string().describe("Type of test created: Smoke, Contract, Integration, etc."),
     endpoint: z.string().describe("HTTP verb and path, e.g. 'GET /api/v1/products'"),
     fileName: z.string().describe("Name of the generated test file"),
+    description: z.string().optional().describe("What the test scenario covers, e.g. 'Creates a collection, adds a link, then verifies the link exists'"),
+    scenarioFile: z.string().optional().describe("Path to the scenario JSON file if one was generated (e.g. 'tests/scenario_collections-links.json')"),
+    traceFile: z.string().optional().describe("Path to the backend trace file if used or created"),
+    frontendTrace: z.string().optional().describe("Path to the Playwright/UI trace file if used or created"),
 });
 const descriptionSchema = z.object({
     description: z.string().describe("One-line description"),
 });
+const scenarioStepSchema = z.object({
+    method: z.string().optional().describe("HTTP method (e.g. 'POST', 'GET'). Required for API steps, omit for UI/E2E actions."),
+    path: z.string().optional().describe("Endpoint or page path (e.g. '/api/v1/products' or '/products'). Required for API steps, omit for UI actions."),
+    description: z.string().describe("What this step does, e.g. 'Create a product' or 'Click checkout button and verify confirmation'"),
+    expectedStatusCode: z.number().optional().describe("Expected HTTP status code, e.g. 200, 201, 404"),
+    requestBody: z.record(z.any()).optional().describe("Example request body with realistic field values"),
+    responseBody: z.record(z.any()).optional().describe("Key response fields to verify, e.g. { id: 'number', name: 'string', in_stock: 'boolean?' }"),
+});
+const additionalRecommendationSchema = z.object({
+    testType: z.string().describe("Type of test: Integration, E2E, Fuzz, Contract, UI, etc."),
+    scenarioName: z.string().describe("Name of the scenario, e.g. 'products_orders_workflow'"),
+    steps: z.array(scenarioStepSchema).describe("Ordered sequence of API/UI steps in this test scenario"),
+    description: z.string().describe("Why this test is valuable and what it would cover"),
+    priority: z.string().describe("Priority level: high, medium, or low"),
+    openApiSpec: z.string().optional().describe("Path to OpenAPI/Swagger spec file if available, e.g. 'openapi.yaml'"),
+    backendTrace: z.string().optional().describe("Path to backend trace file if available, e.g. 'tests/skyramp-traces.json'. Used by integration and E2E tests."),
+    frontendTrace: z.string().optional().describe("Path to Playwright/UI trace file if available, e.g. 'tests/skyramp-playwright.zip'. UI tests need this; E2E tests need both frontend and backend traces."),
+});
 const testMaintenanceSchema = z.object({
     fileName: z.string().describe("Test file that was maintained, e.g. 'products_smoke_test.py'"),
     description: z.string().describe("What was changed and why"),
@@ -47,6 +69,11 @@ export function registerSubmitReportTool(server) {
             testResults: z
                 .array(testResultSchema)
                 .describe("List of ALL test execution results. One entry per test executed."),
+            additionalRecommendations: z
+                .array(additionalRecommendationSchema)
+                .optional()
+                .default([])
+                .describe("Recommended tests that were not generated (lower priority). Include the remaining recommendations from skyramp_recommend_tests that were not implemented."),
             issuesFound: z
                 .array(descriptionSchema)
                 .describe("List of issues, failures, or bugs found. Use empty array [] if none."),
@@ -68,6 +95,7 @@ export function registerSubmitReportTool(server) {
             newTestsCreated: params.newTestsCreated,
             testMaintenance: params.testMaintenance,
             testResults: params.testResults,
+            additionalRecommendations: params.additionalRecommendations ?? [],
             issuesFound: params.issuesFound,
             commitMessage: (params.commitMessage ?? "").replace(/[\r\n]+/g, " ").trim().slice(0, 72) || DEFAULT_COMMIT_MESSAGE,
         }, null, 2);

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

@@ -105,6 +105,14 @@ Information about state files and cleanup results.`,
                 const maxAgeHours = args.maxAgeHours || 24;
                 const deletedCount = await StateManager.cleanupOldStateFiles(maxAgeHours);
                 logger.info(`Cleaned up ${deletedCount} state files older than ${maxAgeHours} hours`);
+                if (deletedCount > 0) {
+                    try {
+                        await server.sendResourceListChanged();
+                    }
+                    catch {
+                        logger.debug("sendResourceListChanged not available");
+                    }
+                }
                 // Get remaining files
                 const remainingFiles = await StateManager.listStateFiles();
                 return {