@skyramp/mcp 0.0.24 → 0.0.25

package/build/prompts/modularization-prompts.js

@@ -49,6 +49,8 @@ export function getModularizationPromptForUI(filePath, language) {
 
 **COMMON CALCULATION FAILURE: UI tests fail when complex logic patterns (loops, conditionals, array handling) are incorrectly generalized in helper functions, causing wrong quantities, prices, or missing operations.**
 
+**COMMON SELECTOR FAILURE: UI tests fail when specific selectors are generalized into generic ones, causing wrong elements to be clicked.**
+
 **MANDATORY ANALYSIS BEFORE MODULARIZATION:**
 Before creating any helper functions, identify ALL critical patterns in the original test:
 - Look for patterns like: page.getByTestId("navbar-*").click()
@@ -56,24 +58,28 @@ Before creating any helper functions, identify ALL critical patterns in the orig
 - Look for patterns like: page.goBack()
 - Look for complex loops with conditionals or null handling
 - Look for unique sequences that differ between similar operations
+- Look for specific selector chains that target exact elements
 - These MUST remain in the main test function in their EXACT original positions and logic
 
 **CRITICAL RULE: If the original test performs operations in a specific sequence with unique logic for each step, DO NOT generalize this into a loop or helper function. Keep the exact original sequence.**
 
+**SELECTOR PRESERVATION RULE: If the original test uses specific selector chains, DO NOT generalize them into generic selectors. Preserve the exact selector specificity.**
+
 STEPS:
 1. **PRESERVE EXACT UI SEQUENCE**: For UI TESTS, maintain the EXACT sequence of UI interactions. Do NOT extract steps that break the natural flow.
 2. **CAREFUL EXTRACTION**: Only extract helper functions for COMPLETE, REPEATABLE workflows that do NOT include navigation between different pages/sections and do NOT contain complex conditional logic.
 3. **PRESERVE UNIQUE STEPS**: If a workflow has unique steps (like clicking specific labels), DO NOT extract it into a generic helper function.
 4. **PRESERVE COMPLEX LOGIC**: If the original test has loops, conditionals, or array processing with unique patterns, DO NOT generalize these - keep them exactly as written.
-5. **RESPONSE PROMISES**: Maintain the exact timing of response promise creation and awaiting. Do not move these into helper functions unless the entire request-response cycle is contained.
-6. **PARAMETERIZATION**: When creating helper functions, ensure ALL required parameters (page, data objects, response promises) are passed correctly.
-7. **VALIDATION**: Each extracted function must work independently without relying on external scope variables.
-8. **PRESERVE ORIGINAL FLOW**: If the original code has different patterns for similar operations (like product creation), preserve those differences - they exist for a reason.
-9. **NAVIGATION PRESERVATION**: CRITICAL - If the original test has navigation steps between similar operations (like clicking "navbar-products" between product creations), these MUST be preserved in the main test flow, NOT moved into helper functions.
+5. **PRESERVE SPECIFIC SELECTORS**: If the original test uses specific selector chains, maintain the exact same selectors in helper functions. Do not make them more generic.
+6. **RESPONSE PROMISES**: Maintain the exact timing of response promise creation and awaiting. Do not move these into helper functions unless the entire request-response cycle is contained.
+7. **PARAMETERIZATION**: When creating helper functions, ensure ALL required parameters (page, data objects, response promises) are passed correctly.
+8. **VALIDATION**: Each extracted function must work independently without relying on external scope variables.
+9. **PRESERVE ORIGINAL FLOW**: If the original code has different patterns for similar operations (like product creation), preserve those differences - they exist for a reason.
+10. **NAVIGATION PRESERVATION**: CRITICAL - If the original test has navigation steps between similar operations (like clicking "navbar-products" between product creations), these MUST be preserved in the main test flow, NOT moved into helper functions.
 
 **WHAT SHOULD BE EXTRACTED (SAFE TO EXTRACT):**
 - Simple form filling sequences within a single page/modal
-- Basic button clicking sequences within a single workflow
+- Basic button clicking sequences within a single workflow that use the same specific selectors
 - Simple data entry that doesn't change page state
 - Basic assertions and validations within the same page context
 
@@ -85,21 +91,25 @@ STEPS:
 - Complex loops with conditionals or special handling
 - Operations with unique patterns that differ between similar workflows
 - Array processing with null handling or special indexing
+- Button clicks with complex selector chains that are unique to specific contexts
 
 **CRITICAL CONSTRAINTS:**
 - NO interfaces, classes, types, or data structures
 - NO changes to the core UI interaction sequence
 - NO extraction of partial workflows that depend on external state
 - NO generalization of complex logic patterns into loops or helper functions
+- NO generalization of specific selectors into generic ones
 - ONLY extract COMPLETE, self-contained operations that occur within the same page context
 - PRESERVE original functionality exactly
 - DO NOT extract steps that have unique UI interactions
 - DO NOT move navigation steps (like navbar clicks) into helper functions - keep them in the main test flow
 - PRESERVE all navigation between similar operations exactly as in the original test
+- PRESERVE all specific selector chains exactly as in the original test
 - NAVIGATION STEPS MUST REMAIN IN THE MAIN TEST FUNCTION TO MAINTAIN PROPER PAGE STATE
 - COMPLEX LOGIC PATTERNS MUST REMAIN IN THE MAIN TEST FUNCTION TO MAINTAIN EXACT BEHAVIOR
+- SPECIFIC SELECTORS MUST BE PRESERVED TO ENSURE CORRECT ELEMENT TARGETING
 
-**BEFORE SUBMITTING: Double-check that every navigation step and complex operation from the original test appears in the same position with the same logic in the main test function.**
+**BEFORE SUBMITTING: Double-check that every navigation step, complex operation, and specific selector from the original test appears in the same position with the same logic in the main test function.**
 
 **CRITICAL: If you skip any step, the modularization is incomplete. You MUST complete all steps before proceeding.FIX ERRORS IN MODULARIZED CODE USING skyramp_fix_errors TOOL**
 `;
@@ -112,6 +122,8 @@ export function getFixErrorsPromptForUI() {
 
 **COMMON UI TEST CALCULATION ERROR: Order totals, quantities, or other calculated values may be incorrect if the original test's unique logic was incorrectly generalized in helper functions.**
 
+**COMMON UI TEST SELECTOR ERROR: Tests fail when specific selectors are replaced with generic ones, causing wrong elements to be clicked or interacted with.**
+
 **IMMEDIATE TIMEOUT DEBUGGING STEPS:**
 1. Compare the original test and modularized test side by side
 2. Identify every navigation step in the original (navbar clicks, page.goto, etc.)
@@ -124,18 +136,25 @@ export function getFixErrorsPromptForUI() {
 3. Verify that loops and conditional logic in helper functions match the original exactly
 4. Look for cases where null/empty values in data arrays are handled differently
 
+**IMMEDIATE SELECTOR ERROR DEBUGGING STEPS:**
+1. Compare selectors in the original vs modularized test
+2. Check if specific selector chains were replaced with generic selectors
+3. Verify that helper functions use the same exact selectors as the original
+4. Look for cases where container-specific selectors were made too generic
+
 **DETAILED FIX STEPS:**
 1. **UI Sequence Validation**: Verify that the exact UI interaction sequence from the original test is preserved. Check for missing clicks, form openings, or navigation steps.
 2. **Navigation Step Preservation**: CRITICAL - Ensure all navigation steps between similar operations (like "navbar-products" clicks between product creations) are preserved in the main test flow, not moved into helper functions.
 3. **Page State Debugging**: If test is timing out on element interactions, check if the page is in the expected state. Often this means navigation steps were incorrectly extracted.
 4. **Logic Preservation**: If test has incorrect calculations or missing operations, check if helper functions are generalizing logic that should remain unique to each operation.
-5. **Parameter Passing**: Identify functions using variables from outside scope (like 'page' object, response promises, test data). Pass these as parameters.
-6. **Response Promise Timing**: Ensure response promises are created and awaited at the exact same points as the original test.
-7. **Unique Workflow Preservation**: If the original test has unique steps for similar operations, ensure these are preserved and not generalized incorrectly.
-8. **Complete Workflow Validation**: Ensure that extracted helper functions contain COMPLETE workflows, not partial steps that depend on external state.
-9. **Page State Management**: Verify that helper functions don't assume specific page states - the main test should handle navigation between different pages/states.
-10. **Validate Correctness**: Ensure code is free of reference errors, undefined variables, runtime issues.
-11. **Import Paths**: Ensure import paths are correct and there are no circular imports.
+5. **Selector Preservation**: If test is clicking wrong elements or failing to find elements, check if specific selectors were made too generic in helper functions.
+6. **Parameter Passing**: Identify functions using variables from outside scope (like 'page' object, response promises, test data). Pass these as parameters.
+7. **Response Promise Timing**: Ensure response promises are created and awaited at the exact same points as the original test.
+8. **Unique Workflow Preservation**: If the original test has unique steps for similar operations, ensure these are preserved and not generalized incorrectly.
+9. **Complete Workflow Validation**: Ensure that extracted helper functions contain COMPLETE workflows, not partial steps that depend on external state.
+10. **Page State Management**: Verify that helper functions don't assume specific page states - the main test should handle navigation between different pages/states.
+11. **Validate Correctness**: Ensure code is free of reference errors, undefined variables, runtime issues.
+12. **Import Paths**: Ensure import paths are correct and there are no circular imports.
 
 **TIMEOUT DEBUGGING CHECKLIST:**
 - Are all navigation steps (navbar clicks, page.goto) in the main test function?
@@ -150,20 +169,27 @@ export function getFixErrorsPromptForUI() {
 - Are loops and conditionals in helper functions exact matches to the original logic?
 - Are quantities, prices, and other data values being processed identically?
 
-**SPECIFIC FIX FOR COMMON ERROR:**
-If you see timeout on "Add Product" button after product creation:
-- Check if navbar-products click was moved into a helper function
-- Move it back to the main test function between product creation calls
-- The page must navigate back to products listing before trying to add another product
+**SELECTOR ERROR DEBUGGING CHECKLIST:**
+- Are all selectors in helper functions exactly the same as in the original test?
+- Were any specific container-based selectors replaced with generic ones?
+- Do button clicks use the same selector specificity as the original?
+- Are there any ambiguous selectors that could match multiple elements?
+
+**SPECIFIC FIX FOR COMMON ERRORS:**
+If you see timeout on button clicks or element interactions:
+- Check if navigation steps were moved into helper functions and move them back to main test
+- Check if specific selectors were made generic and restore original selector specificity
+- Verify the page is in the expected state before each interaction
 
-If you see incorrect order totals or missing items:
-- Check if the original test has unique patterns for adding items that were incorrectly generalized
-- Verify that all items from the original test are being added in the modularized version
-- Look for cases where null values or special array handling was changed
+If you see incorrect calculations or missing operations:
+- Check if unique logic patterns were incorrectly generalized
+- Verify all operations from original test are present in modularized version
+- Look for null value handling differences
 
 **KEY: Every UI interaction from the original test must be present in the modularized version.**
 **CRITICAL: Helper functions should only contain COMPLETE, self-contained workflows.**
 **NAVIGATION KEY: Navigation steps between operations must remain in the main test flow to maintain proper page state.**
 **CALCULATION KEY: Unique logic patterns should not be generalized if they produce different results.**
+**SELECTOR KEY: Specific selectors must be preserved to ensure correct element targeting.**
 `;
 }

package/build/prompts/testGenerationPrompt.js

@@ -15,6 +15,7 @@ export function registerTestGenerationPrompt(mcpServer) {
 - Provide clear execution instructions for generated tests
 - Answer questions about Skyramp capabilities and testing concepts
 - ALWAYS SHOW STEPS TO GENERATE TEST USING MCP TOOLS AND NEVER SHOW THE CLI COMMANDS.
+- CRITICAL: UI, INTEGRATION, E2E TESTS MUST BE MODULARIZED USING skyramp_modularization TOOL. ALWAYS ADD A TASK TO MODULARIZE THE TEST USING skyramp_modularization TOOL AFTER GENERATING THESE(UI, INTEGRATION, E2E) TESTS.
 
 **CONTRACT TEST:**
 - Purpose: Ensures a service is properly communicating with another service

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "main": "build/index.js",
   "type": "module",
   "bin": {