@skyramp/mcp 0.0.64-rc.9 → 0.0.64

package/node_modules/playwright/lib/mcp/skyramp/traceRecordingBackend.js

@@ -102,7 +102,10 @@ class TraceRecordingBackend {
         rootPath: this._outputDir,
         harPath: this._harPath
       });
-      return handler(parsed);
+      const exportResult = await handler(parsed);
+      if (!exportResult.isError)
+        this._trackedActions = [];
+      return exportResult;
     }
     if (name === import_assertTool.assertToolSchema.name) {
       const parsed = import_assertTool.assertToolSchema.inputSchema.parse(args || {});
@@ -149,6 +152,36 @@ class TraceRecordingBackend {
     const result = await this._browserBackend.callTool("browser_select_option", args);
     const resultText = result.content?.[0]?.type === "text" ? result.content[0].text : "";
     if (!result.isError) {
+      const code = (0, import_response.parseResponse)(result)?.code ?? "";
+      const hasCssSelector = code.includes("page.locator('select") || code.includes('page.locator("select') || code.includes(".selectOption(") && !code.includes("getByTestId") && !code.includes("getByRole") && !code.includes("getByLabel");
+      if (hasCssSelector && args.ref) {
+        traceDebug("selectOption used CSS selector, trying to resolve a better one via hover");
+        const hoverResult = await this._browserBackend.callTool("browser_hover", {
+          element: args.element || "select",
+          ref: args.ref
+        });
+        if (!hoverResult.isError) {
+          const hoverCode = (0, import_response.parseResponse)(hoverResult)?.code ?? "";
+          const locatorMatch = hoverCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+          if (locatorMatch) {
+            const locatorExpr = locatorMatch[1].trim();
+            const parsed = this._codeToLocator(locatorExpr);
+            if (parsed && parsed.locator.kind !== "text") {
+              const values2 = args.values || [];
+              const selectCode = `await page.${locatorExpr}.selectOption(${JSON.stringify(values2.length === 1 ? values2[0] : values2)});`;
+              traceDebug(`Improved select selector: ${selectCode}`);
+              const timestamp = Date.now();
+              this._trackedActions.push({
+                toolName: "browser_select_option",
+                args,
+                code: selectCode,
+                timestamp
+              });
+              return result;
+            }
+          }
+        }
+      }
       this._maybeTrackAction("browser_select_option", args, result);
       return result;
     }
@@ -232,18 +265,26 @@ Could not resolve element ref=${params.ref}. ${errText}` }], isError: true };
 Could not extract selector from hover result.` }], isError: true };
     }
     const locatorExpr = locatorMatch[1].trim();
-    const parsed = this._codeToLocator(locatorExpr);
+    let parsed = this._codeToLocator(locatorExpr);
     if (!parsed) {
       return { content: [{ type: "text", text: `### Assertion Failed
 Could not parse locator: ${locatorExpr}` }], isError: true };
     }
     const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
     const snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
-    const refLine = snapText.split("\n").find((l) => l.includes(`[ref=${params.ref}]`)) || "";
+    const snapLines = snapText.split("\n");
+    const refLine = snapLines.find((l) => l.includes(`[ref=${params.ref}]`)) || "";
     const textMatch = refLine.match(/^\s*-\s*\w+\s+"([^"]*)"/);
     const elementText = textMatch?.[1] || "";
     const valueMatch = refLine.match(/\]:\s*(.+)$/);
     const elementValue = valueMatch?.[1]?.trim() || "";
+    if (parsed.locator.kind === "text") {
+      const improved = await this._improveTextSelector(snapLines, params.ref, parsed);
+      if (improved) {
+        traceDebug(`Improved ambiguous text selector to: ${improved.selector}`);
+        parsed = improved;
+      }
+    }
     let passed = false;
     let details = "";
     if (params.type === "text") {
@@ -254,14 +295,19 @@ Could not parse locator: ${locatorExpr}` }], isError: true };
       details = passed ? `Value assertion passed: "${params.element}" has value "${params.expected}".` : `Value assertion FAILED: "${params.element}" has value "${elementValue}", expected "${params.expected}".`;
     }
     if (passed) {
-      const assertName = params.type === "value" ? "assertValue" : "assertText";
-      this._trackedActions.push({
-        toolName: "browser_assert",
-        args: { type: params.type, ref: params.ref, expected: params.expected },
-        code: `${assertName}:${parsed.selector}:${params.expected}${params.type === "text" ? ":" + params.substring : ""}`,
-        timestamp
-      });
-      traceDebug(`Assert: ${assertName} with selector ${parsed.selector}`);
+      const selectorText = parsed.locator.kind === "text" ? parsed.locator.body : parsed.locator.next?.kind === "text" ? parsed.locator.next.body : parsed.locator.options?.name ?? null;
+      if (selectorText && selectorText === params.expected) {
+        traceDebug(`Skipped tautological assertion: selector already matches "${params.expected}"`);
+      } else {
+        const assertName = params.type === "value" ? "assertValue" : "assertText";
+        this._trackedActions.push({
+          toolName: "browser_assert",
+          args: { type: params.type, ref: params.ref, expected: params.expected },
+          code: `${assertName}:${parsed.selector}:${params.expected}${params.type === "text" ? ":" + params.substring : ""}`,
+          timestamp
+        });
+        traceDebug(`Assert: ${assertName} with selector ${parsed.selector}`);
+      }
     }
     return {
       content: [{ type: "text", text: `### ${passed ? "Assertion Passed" : "Assertion Failed"}
@@ -304,6 +350,66 @@ ${details}` }]
     }
     return null;
   }
+  /**
+   * When hover resolves to a text-based locator (e.g. getByText("$849.98")),
+   * check if that text appears multiple times in the snapshot (ambiguous) and
+   * hover ancestor refs to find a parent with a test-id, producing a chained
+   * selector like `testid >> text` that uniquely identifies the element.
+   */
+  async _improveTextSelector(snapLines, ref, original) {
+    const textBody = original.locator.body;
+    const occurrences = snapLines.filter((l) => l.includes(textBody)).length;
+    if (occurrences <= 1)
+      return null;
+    traceDebug(`Text "${textBody}" appears ${occurrences} times in snapshot \u2014 looking for parent test-id`);
+    const refPattern = `[ref=${ref}]`;
+    const refIdx = snapLines.findIndex((l) => l.includes(refPattern));
+    if (refIdx < 0)
+      return null;
+    const refIndent = snapLines[refIdx].match(/^(\s*)/)?.[1]?.length ?? 0;
+    for (let i = refIdx - 1; i >= 0; i--) {
+      const line = snapLines[i];
+      const indent = line.match(/^(\s*)/)?.[1]?.length ?? 0;
+      if (indent >= refIndent)
+        continue;
+      const ancestorRefMatch = line.match(/\[ref=(\w+)\]/);
+      if (!ancestorRefMatch)
+        continue;
+      const ancestorRef = ancestorRefMatch[1];
+      try {
+        const ancestorHover = await this._browserBackend.callTool("browser_hover", {
+          element: "parent element",
+          ref: ancestorRef
+        });
+        if (!ancestorHover.isError) {
+          const ancestorCode = (0, import_response.parseResponse)(ancestorHover)?.code ?? "";
+          const ancestorLocatorMatch = ancestorCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+          if (ancestorLocatorMatch) {
+            const ancestorExpr = ancestorLocatorMatch[1].trim();
+            const testidMatch = ancestorExpr.match(/getByTestId\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (testidMatch) {
+              const testid = testidMatch[1];
+              const chainedSelector = `internal:testid=[data-testid="${testid}"s] >> internal:text="${textBody}"i`;
+              traceDebug(`Improved to chained selector: ${chainedSelector}`);
+              return {
+                selector: chainedSelector,
+                locator: {
+                  kind: "test-id",
+                  body: testid,
+                  options: {},
+                  next: { kind: "text", body: textBody, options: { exact: false } }
+                }
+              };
+            }
+          }
+        }
+      } catch {
+      }
+      if (indent === 0)
+        break;
+    }
+    return null;
+  }
   static {
     /** Extract selector and locator info from a snapshot line for assertion tracking. */
     // Roles that map to valid Playwright getByRole() selectors.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.64-rc.9",
+  "version": "0.0.64",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.16",
+    "@skyramp/skyramp": "1.3.17",
     "dockerode": "^4.0.6",
     "fast-glob": "^3.3.3",
     "playwright": "file:vendor/skyramp-playwright-1.58.2-skyramp.8.9.0.tgz",

package/build/tools/test-recommendation/recommendTestsTool.js

@@ -1,274 +0,0 @@
-import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
-import { z } from "zod";
-import { simpleGit } from "simple-git";
-import { StateManager, getSessionFilePath, getRegisteredSessions, getSessionData, hasSessionData, normalizeRecommendationState, } from "../../utils/AnalysisStateManager.js";
-import { logger } from "../../utils/logger.js";
-import { ANALYSIS_URI_PREFIX } from "../../resources/analysisResources.js";
-import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-recommendation/recommendationSections.js";
-import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { buildRecommendationPrompt } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
-import { repositoryAnalysisSchema } from "../../types/RepositoryAnalysis.js";
-import { parsePRComments } from "../../utils/pr-comment-parser.js";
-import { getWorkspaceAuthConfig } from "../../utils/workspaceAuth.js";
-/**
- * Extract GitHub owner/repo from the origin remote URL.
- * Handles both SSH (git@github.com:owner/repo.git) and
- * HTTPS (https://github.com/owner/repo.git) formats.
- */
-async function getGitHubSlug(repoPath) {
-    try {
-        const git = simpleGit(repoPath);
-        const remotes = await git.getRemotes(true);
-        const origin = remotes.find((r) => r.name === "origin");
-        const url = origin?.refs?.fetch;
-        if (!url)
-            return null;
-        const sshMatch = url.match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-        if (sshMatch)
-            return { owner: sshMatch[1], repo: sshMatch[2] };
-        const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
-        if (httpsMatch)
-            return { owner: httpsMatch[1], repo: httpsMatch[2] };
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-const recommendTestsSchema = {
-    sessionId: completable(z.string().optional().describe("Session ID from skyramp_analyze_repository. Optional if prNumber and repositoryPath are provided."), async (value) => {
-        return Array.from(getRegisteredSessions().keys()).filter((id) => id.startsWith(value?.toString() || ""));
-    }),
-    repositoryPath: z
-        .string()
-        .optional()
-        .describe("Absolute path to the repository. Required if sessionId is missing."),
-    topN: z
-        .number()
-        .default(MAX_RECOMMENDATIONS)
-        .describe(`Number of recommendations. Defaults to ${MAX_RECOMMENDATIONS}.`),
-    prNumber: z
-        .number()
-        .optional()
-        .describe("GitHub PR number. When provided, fetches previous TestBot comments to use as baseline recommendations."),
-};
-const TOOL_NAME = "skyramp_recommend_tests";
-export function registerRecommendTestsTool(server) {
-    server.registerTool(TOOL_NAME, {
-        description: `Generate actionable test recommendations based on enriched repository analysis.
-
-**PREREQUISITE**: Call skyramp_analyze_repository first to get the sessionId.
-
-This tool reads the enriched analysis (endpoints with interactions, drafted scenarios)
-and generates prioritized test recommendations using LLM reasoning over the actual data.
-
-For each recommended test, you'll get:
-- Priority (high/medium/low) with reasoning based on actual endpoint data
-- Specific test referencing concrete interactions (request→response pairs)
-- For integration/E2E: references to draftedScenarios by scenarioName
-- Which Skyramp tool to call for generation
-
-**Output guidelines:**
-- Use "high", "medium", or "low" for priority.
-- Never mark a test as blocked — recommend it with instructions for missing artifacts.
-- Reference specific interactions by description for contract/fuzz tests.
-- Reference draftedScenarios by scenarioName for integration/E2E tests.
-
-** This tool is currently in Early Preview stage. Please verify the results. **`,
-        inputSchema: recommendTestsSchema,
-    }, async (params) => {
-        let errorResult;
-        try {
-            logger.info("Recommend tests tool invoked", {
-                sessionId: params.sessionId,
-                topN: params.topN,
-                prNumber: params.prNumber,
-            });
-            let stateData = null;
-            let prContext = null;
-            let repositoryPath = params.repositoryPath || "";
-            let analysisScope = "current_branch_diff";
-            if (params.sessionId) {
-                // Load session data: try process memory first, then fall back to state file
-                if (hasSessionData(params.sessionId)) {
-                    stateData = getSessionData(params.sessionId);
-                    logger.info("Loaded analysis from process memory", { sessionId: params.sessionId });
-                }
-                else {
-                    // Fall back to state file for backward compatibility
-                    const registeredPath = getSessionFilePath(params.sessionId);
-                    const stateManager = registeredPath
-                        ? StateManager.fromStatePath(registeredPath)
-                        : StateManager.fromSessionId(params.sessionId);
-                    if (stateManager.exists()) {
-                        stateData = await stateManager.readData();
-                        logger.info("Loaded analysis from state file (legacy)", { sessionId: params.sessionId });
-                    }
-                }
-                if (!stateData) {
-                    throw new Error(`Analysis session not found: ${params.sessionId}.`);
-                }
-                stateData = normalizeRecommendationState(stateData);
-                repositoryPath = stateData.repositoryPath;
-                analysisScope = stateData.analysisScope;
-                prContext = stateData.prContext;
-            }
-            else if (params.prNumber && params.repositoryPath) {
-                // No sessionId provided — fetch PR context directly to use as baseline
-                const slug = await getGitHubSlug(params.repositoryPath);
-                if (slug) {
-                    try {
-                        prContext = await parsePRComments(slug.owner, slug.repo, params.prNumber);
-                        logger.info("Fetched PR context for baseline recommendations", { prNumber: params.prNumber });
-                    }
-                    catch (err) {
-                        throw new Error(`Failed to fetch PR context for baseline: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-                else {
-                    throw new Error(`Could not determine GitHub repository slug for ${params.repositoryPath}`);
-                }
-                if (!prContext || prContext.previousRecommendations.length === 0) {
-                    throw new Error(`No previous recommendations found for PR #${params.prNumber}. A full analysis is required first.`);
-                }
-                // Build a minimal "analysis" from the previous recommendations to satisfy the prompt builder
-                stateData = {
-                    repositoryPath: params.repositoryPath,
-                    analysisScope: "current_branch_diff",
-                    analysis: {
-                        metadata: { repositoryName: slug.repo, analysisDate: new Date().toISOString(), scanDepth: "full", analysisScope: "current_branch_diff" },
-                        projectClassification: { projectType: "REST API", primaryLanguage: "unknown", primaryFramework: "unknown", deploymentPattern: "monolith" },
-                        technologyStack: { languages: [], frameworks: [], runtime: "", keyDependencies: [] },
-                        businessContext: { mainPurpose: "", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-                        apiEndpoints: { totalCount: 0, baseUrl: "", endpoints: [] },
-                        authentication: { method: "none", configLocation: "", envVarsRequired: [], setupExample: "" },
-                        infrastructure: { isContainerized: false, hasDockerCompose: false, hasKubernetes: false, hasCiCd: false },
-                        existingTests: { frameworks: [], coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 }, testLocations: {}, hasCoverageReports: false },
-                    },
-                };
-            }
-            else {
-                throw new Error("Either sessionId or (prNumber and repositoryPath) must be provided.");
-            }
-            if (!stateData) {
-                throw new Error(`Failed to read analysis session: ${params.sessionId}. Run skyramp_analyze_repository first.`);
-            }
-            stateData = normalizeRecommendationState(stateData);
-            analysisScope = stateData.analysisScope;
-            repositoryPath = stateData.repositoryPath;
-            const { analysis } = stateData;
-            if (!analysis) {
-                throw new Error("Session is missing analysis data.");
-            }
-            // Validate analysis against the Zod schema to catch malformed LLM output early
-            const parseResult = repositoryAnalysisSchema.safeParse(analysis);
-            if (!parseResult.success) {
-                const issues = parseResult.error.issues.slice(0, 5).map((i) => `${i.path.join(".")}: ${i.message}`);
-                logger.warning("Analysis data has schema issues (proceeding with best-effort)", {
-                    issueCount: parseResult.error.issues.length,
-                    sample: issues,
-                });
-            }
-            // Guard critical nested fields the prompt builder accesses
-            if (!analysis.apiEndpoints?.endpoints) {
-                analysis.apiEndpoints = { totalCount: 0, baseUrl: "", endpoints: [] };
-            }
-            if (!analysis.businessContext?.draftedScenarios) {
-                analysis.businessContext = {
-                    ...(analysis.businessContext || { mainPurpose: "", userFlows: [], dataFlows: [], integrationPatterns: [] }),
-                    draftedScenarios: analysis.businessContext?.draftedScenarios || [],
-                };
-            }
-            if (!analysis.authentication) {
-                analysis.authentication = { method: "none", configLocation: "", envVarsRequired: [], setupExample: "" };
-            }
-            if (!analysis.existingTests) {
-                analysis.existingTests = {
-                    frameworks: [], coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 },
-                    testLocations: {}, hasCoverageReports: false,
-                };
-            }
-            const scope = analysisScope || "full_repo";
-            const effectiveTopN = params.topN ?? MAX_RECOMMENDATIONS;
-            // Fetch PR context when prNumber is provided and in diff scope (if not already fetched)
-            if (!prContext && params.prNumber && scope === "current_branch_diff") {
-                const slug = await getGitHubSlug(repositoryPath);
-                if (slug) {
-                    try {
-                        prContext = await parsePRComments(slug.owner, slug.repo, params.prNumber);
-                    }
-                    catch (err) {
-                        logger.warning("Failed to fetch PR context", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                }
-                else {
-                    logger.debug("Could not determine GitHub owner/repo from git remotes — skipping PR context");
-                }
-            }
-            const wsAuthConfig = repositoryPath
-                ? await getWorkspaceAuthConfig(repositoryPath)
-                : {};
-            const prompt = buildRecommendationPrompt(analysis, scope, effectiveTopN, prContext, wsAuthConfig.authHeader, wsAuthConfig.authType);
-            // H3: Mode-specific output header
-            const modeLabel = scope === "current_branch_diff" ? "PR Mode" : "Repo Mode";
-            const modeDesc = scope === "current_branch_diff"
-                ? `Focused on branch changes. Top ${effectiveTopN} recommendations — top 4 will be generated, remaining reported.`
-                : `Comprehensive test strategy. Top ${effectiveTopN} tests across the entire application.`;
-            // J4: PR awareness messaging
-            let prAwareness = "";
-            if (prContext && prContext.previousRecommendations.length > 0) {
-                const implemented = prContext.previousRecommendations.filter((r) => r.status === "implemented").length;
-                const pending = prContext.previousRecommendations.filter((r) => r.status === "recommended").length;
-                prAwareness = `\n**PR History**: ${implemented} tests already implemented, ${pending} previously recommended.`;
-                if (implemented > 0) {
-                    prAwareness += ` Building on existing coverage — new recommendations complement what\'s already been added.`;
-                }
-            }
-            // G4: Include totalConsidered instruction in output
-            const totalEndpointMethods = analysis.apiEndpoints.endpoints.reduce((acc, ep) => acc + (ep.methods?.length || 0), 0);
-            const totalInteractions = analysis.apiEndpoints.endpoints.reduce((acc, ep) => acc + (ep.methods || []).reduce((a2, m) => a2 + (m.interactions?.length || 0), 0), 0);
-            const totalScenarios = analysis.businessContext.draftedScenarios.length;
-            const resourcesSection = params.sessionId ? `
-## Available Resources
-- Summary: \`${ANALYSIS_URI_PREFIX}/${params.sessionId}/summary\`
-- Endpoints: \`${ANALYSIS_URI_PREFIX}/${params.sessionId}/endpoints\`
-- Scenarios: \`${ANALYSIS_URI_PREFIX}/${params.sessionId}/scenarios\`
-` : '';
-            const output = `# Test Recommendations (${modeLabel})
-
-${params.sessionId ? `**Session**: \`${params.sessionId}\`\n` : ''}**Repository**: \`${repositoryPath}\`
-**Mode**: ${modeLabel} — ${modeDesc}${prAwareness}
-**Catalog**: ${totalEndpointMethods} endpoint methods, ${totalInteractions} interactions, ${totalScenarios} scenarios
-**Target**: Top ${effectiveTopN} recommendations ranked by value. Top ${MAX_TESTS_TO_GENERATE} = generate & execute. #${MAX_TESTS_TO_GENERATE + 1}-#${effectiveTopN} = report as additional recommendations.
-${resourcesSection}
----
-
-${prompt}
-
-** This tool is currently in Early Preview stage. Please verify the results. **`;
-            return {
-                content: [{ type: "text", text: output }],
-                isError: false,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error("Recommend tests tool failed", { error: errorMessage });
-            errorResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error generating recommendations: ${errorMessage}`,
-                    },
-                ],
-                isError: true,
-            };
-            return errorResult;
-        }
-        finally {
-            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {});
-        }
-    });
-}