@skyramp/mcp 0.0.24 → 0.0.26

package/build/prompts/modularization-prompts.js

@@ -13,12 +13,35 @@ Only if NO existing function can be reused:
 4. Parameterize the test function(s) with meaningful parameters to make it more flexible. Preserve the original order of code lines within each function.
 5. Only extract reusable logical sections into helper functions. Use inline parameter types instead of creating interfaces or type definitions.
 
+**IMPORT CLEANUP AFTER MODULARIZATION:**
+After applying modularization principles:
+1. **Analyze Remaining Imports**: Review all import statements at the top of the file
+2. **Identify Unused Imports**: Check which imported modules, functions, or classes are no longer referenced in the modularized code
+3. **Remove Unused Imports**: Delete any import statements that are not used in the final modularized code
+4. **Preserve Required Imports**: Keep all imports that are actually used by the modularized functions
+5. **Maintain Import Order**: Preserve the original ordering of remaining imports for consistency
+
+**IMPORT REMOVAL RULES:**
+- Only remove imports that are completely unused after modularization
+- Keep imports used by any function, even if usage decreased
+- Preserve imports for types used in function parameters (inline types)
+- Do not remove imports for testing frameworks or utilities
+- Maintain proper import syntax and formatting
+
+**LANGUAGE-SPECIFIC IMPORT HANDLING:**
+- **Python**: Remove unused import and from...import statements
+- **JavaScript/TypeScript**: Remove unused import and require() statements
+- **Java**: Remove unused import statements
+- **All Languages**: Preserve framework-specific imports (testing libraries, etc.)
+
 **CRITICAL CONSTRAINTS:**
 - NO interfaces, classes, types, or data structures
 - NO new test cases or logic
 - NO additional files
 - ONLY helper functions with inline types
 - PRESERVE original functionality exactly
+- REMOVE unused imports after modularization
+- DO NOT CREATE/UPDATE package.json or requirements.txt or pom.xml or build.gradle file
 
 **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**
 `;
@@ -30,11 +53,20 @@ export function getFixErrorsPrompt() {
 1. **Parameter Passing:** Identify functions using variables from outside scope (like 'page' object). Pass these as parameters.
 2. **Validate Correctness:** Ensure code is free of reference errors, undefined variables, runtime issues.
 3. **Import Paths:** Ensure import paths are correct and there are no circular imports.
-4. **UI State Management:** Check for UI state conflicts, modal interference, or element interaction issues.
-5. **Sequential Operations:** Ensure UI operations don't interfere with each other when called in sequence.
+4. **Import Validation:** Ensure all remaining imports are necessary and no missing imports cause reference errors.
+5. **Unused Import Cleanup:** Verify that unused imports were properly removed without breaking functionality.
+6. **UI State Management:** Check for UI state conflicts, modal interference, or element interaction issues.
+7. **Sequential Operations:** Ensure UI operations don't interfere with each other when called in sequence.
+
+**IMPORT ERROR DEBUGGING:**
+- Check for missing imports that cause undefined reference errors
+- Verify that import removal didn't break existing functionality
+- Ensure all imported modules are actually available in the project
+- Confirm that import syntax is correct for the target language
 
 **KEY: Variables not defined within function scope MUST be passed as parameters.**
 **UI KEY: Helper functions that perform UI operations must be self-contained and not leave modals/dialogs open.**
+**IMPORT KEY: All imports must be either used in the code or properly removed.**
 `;
 }
 export function getModularizationPromptForUI(filePath, language) {
@@ -49,6 +81,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 +90,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 +123,56 @@ 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
+
+**IMPORT CLEANUP AFTER MODULARIZATION:**
+After applying modularization principles:
+1. **Analyze Remaining Imports**: Review all import statements at the top of the file
+2. **Identify Unused Imports**: Check which imported modules, functions, or classes are no longer referenced in the modularized code
+3. **Remove Unused Imports**: Delete any import statements that are not used in the final modularized code
+4. **Preserve Required Imports**: Keep all imports that are actually used by the modularized functions
+5. **Maintain Import Order**: Preserve the original ordering of remaining imports for consistency
+
+**UI-SPECIFIC IMPORT CONSIDERATIONS:**
+- Preserve all Playwright/testing framework imports (page, expect, test, etc.)
+- Keep UI-specific utility imports even if usage appears reduced
+- Maintain browser-specific imports that may be needed for UI operations
+- Do not remove imports for UI components or page object models
+- Preserve imports for locators, selectors, and UI interaction utilities
+
+**IMPORT REMOVAL RULES FOR UI TESTS:**
+- Only remove imports that are completely unused after modularization
+- Keep imports used by any function, even if usage decreased
+- Preserve imports for types used in function parameters (inline types)
+- Do not remove imports for testing frameworks or utilities
+- Maintain proper import syntax and formatting
+- Be extra cautious with UI framework imports - they may be used in ways not immediately obvious
+
+**LANGUAGE-SPECIFIC UI IMPORT HANDLING:**
+- **Python**: Remove unused import and from...import statements, but keep pytest, playwright imports
+- **JavaScript/TypeScript**: Remove unused import and require() statements, but preserve @playwright/test imports
+- **Java**: Remove unused import statements, but keep testing framework imports
+- **All Languages**: Always preserve UI testing framework and browser automation imports
 
 **CRITICAL CONSTRAINTS:**
 - NO interfaces, classes, types, or data structures
+- DO NOT CREATE/UPDATE package.json or requirements.txt or pom.xml or build.gradle file
 - 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
+- REMOVE unused imports after modularization (following UI-specific import rules)
 
-**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 +185,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 +199,28 @@ 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. **Import Validation**: Ensure all remaining imports are necessary and no missing imports cause reference errors.
+12. **Unused Import Cleanup**: Verify that unused imports were properly removed without breaking UI test functionality.
+13. **UI Framework Import Preservation**: Ensure that critical UI testing imports (Playwright, testing frameworks) were not accidentally removed.
+14. **Validate Correctness**: Ensure code is free of reference errors, undefined variables, runtime issues.
+15. **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 +235,41 @@ 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?
+
+**IMPORT ERROR DEBUGGING CHECKLIST:**
+- Are there any undefined reference errors due to missing imports?
+- Were any critical UI framework imports (page, expect, test) accidentally removed?
+- Do all remaining imports correspond to actually used functionality?
+- Are import paths correct and accessible in the project structure?
+- Were any imports removed that are used in non-obvious ways (like in string templates)?
+
+**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 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
 
-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 import or reference errors:
+- Check if critical UI framework imports were accidentally removed
+- Verify all remaining imports are necessary and properly used
+- Restore any imports needed for UI interactions, even if usage seems minimal
+- Confirm import paths match the project structure
 
 **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.**
+**IMPORT KEY: All necessary imports must be preserved, especially UI framework imports.**
 `;
 }

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.26",
   "main": "build/index.js",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.11.4",
-    "@skyramp/skyramp": "^1.2.18",
+    "@skyramp/skyramp": "^1.2.19",
     "dockerode": "^4.0.6",
     "zod": "^3.25.3"
   },