@skyramp/mcp 0.0.32 → 0.0.33

package/build/index.js

@@ -61,6 +61,20 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logger.info("MCP Server started successfully");
+    // Listen for stdin closure (parent process disconnected)
+    process.stdin.on("end", () => {
+        logger.info("STDIN closed, parent process disconnected. Exiting...");
+        process.exit(0);
+    });
+    // Handle process termination signals
+    process.on("SIGTERM", () => {
+        logger.info("Received SIGTERM, shutting down gracefully...");
+        process.exit(0);
+    });
+    process.on("SIGINT", () => {
+        logger.info("Received SIGINT, shutting down gracefully...");
+        process.exit(0);
+    });
 }
 main().catch((error) => {
     logger.critical("Fatal error in main()", {

package/build/prompts/code-reuse.js

@@ -1,79 +1,118 @@
 import { generateSkyrampHeader, SKYRAMP_UTILS_HEADER } from "../utils/utils.js";
-const LANGUAGE_EXTENSION_MAP = {
-    python: "py",
-    java: "java",
-    javascript: "js",
-    typescript: "ts",
+const LANGUAGE_MAP = {
+    python: {
+        extension: "py",
+        fileName: "SkyrampUtils.py",
+    },
+    java: {
+        extension: "java",
+        fileName: "SkyrampUtils.java",
+    },
+    javascript: {
+        extension: "js",
+        fileName: "skyrampUtils.js",
+    },
+    typescript: {
+        extension: "ts",
+        fileName: "skyrampUtils.ts",
+    },
 };
-export function getCodeReusePrompt(testFile, language, modularizeCode) {
-    const ext = LANGUAGE_EXTENSION_MAP[language] || "ts";
-    return `# CODE REUSE - 6 CLEAR STEPS
+export function getCodeReusePrompt(testFile, language) {
+    const ext = LANGUAGE_MAP[language].extension || "py";
+    const fileName = LANGUAGE_MAP[language].fileName || "SkyrampUtils.py";
+    return `# CODE REUSE - 6 CLEAR STEPS 
+**CRITICAL WARNING: VIOLATION OF THESE RULES WILL RESULT IN ERROR**
+
+## DEFINITIONS (READ FIRST):
+**What is a "Helper Function"?**
+- A helper function is a STANDALONE, DISTINCT function that is ALREADY DEFINED in the code
+- It has a clear function signature (e.g., \`async function createProduct(page, data) { ... }\`)
+- It is NOT just repetitive inline test code or patterns
+- Example of helper function: \`async function loginUser(page, email, password) { ... }\`
+- Example of NOT a helper function: Repetitive \`await page.click()\` statements scattered in test
+
+**What is "Repetitive Code Pattern"?**
+- Sequential test steps that look similar but are NOT extracted into standalone functions
+- Example: Multiple sequences of \`await page.fill()\`, \`await page.click()\` directly in test body
+- These patterns should NOT be extracted during code reuse - that's what modularization is for
+
+🚨 **CODE REUSE ≠ REFACTORING** 🚨
+- Code reuse = Finding EXISTING helper functions and reusing them
+- Refactoring = Creating NEW helper functions from patterns (handled by modularization tool)
 
 ## STEP 1: READ TEST FILE
-Read ${testFile} and identify what helper functions it needs.
+Read ${testFile} and look for ALREADY DEFINED helper functions (not just repetitive patterns).
 
 ## STEP 2: FIND EXISTING UTILS
 Use the Grep tool to search for files containing "${SKYRAMP_UTILS_HEADER}":
 - Pattern: "${SKYRAMP_UTILS_HEADER}"
 - Type: "${ext}"
 - Output mode: "files_with_matches"
-
 **CRITICAL: Only look for util files with header ${SKYRAMP_UTILS_HEADER}** - exclude test files (files with "test", "spec", ".test.", ".spec." in the name).
+Read the matching non-test files and check if any helpers can be reused in ${testFile}.
 
-Then read the matching non-test files and check if any helpers can be reused in ${testFile}.
-
-## STEP 3: USE EXISTING HELPERS FROM UTILS SOURCE FILES
-If helpers exist in util files:
+## STEP 3: USE EXISTING HELPERS FROM UTILS SOURCE FILES FOUND IN STEP 2
+If helpers exist in util file that can be reused in ${testFile} without modifying them:
 - Import them into ${testFile}
 - Remove any duplicate code in ${testFile}
 - Test that ${testFile} still works without any errors and logical is same as original test file.
 
-## STEP 4: FIND LOCAL HELPERS IN OTHER TEST SOURCE FILES THAT HAS HEADER ${SKYRAMP_UTILS_HEADER}
+## STEP 4: FIND LOCAL HELPERS IN OTHER TEST SOURCE FILES THAT HAS HEADER ${SKYRAMP_UTILS_HEADER} 
 Use the Grep tool to search for other test files containing "${SKYRAMP_UTILS_HEADER}":
 - Pattern: "${SKYRAMP_UTILS_HEADER}"
 - Type: "${ext}"
 - Output mode: "files_with_matches"
-
 **CRITICAL: Exclude ${testFile} from the results** - only look at OTHER test files, not the current file.
 
+🚨 **STOP HERE IF NO OTHER TEST FILES FOUND** 🚨
 **IF NO OTHER TEST FILES ARE FOUND, SKIP TO STEP 6 - DO NOT CREATE ANY UTILS FILES.**
 
-If other test files are found, read those files and identify helper functions that can be reused in ${testFile}.
-Look for patterns like: Form filling utilities, Navigation helpers, Authentication helpers, Data validation functions.
+If other test files are found, read those files and look for ALREADY DEFINED helper functions with clear function signatures.
+
+**How to identify helper functions in other test files:**
+✅ HELPER FUNCTION (move to utils):
+   - Has function signature: \`async function doSomething(params) { ... }\`
+   - Can be called multiple times with different parameters
+   - Example: \`async function fillProductForm(page, product) { ... }\`
+
+❌ NOT A HELPER FUNCTION (do not extract):
+   - Just repetitive inline test code in test body
+   - No function definition/signature
+   - Example: Multiple \`await page.getByTestId("xyz").click()\` directly in test
+
+🚨 **IF OTHER TEST FILES ONLY CONTAIN REPETITIVE PATTERNS (NO ACTUAL HELPER FUNCTIONS), SKIP TO STEP 6** 🚨
+🚨 **IF OTHER TEST FILES ARE ESSENTIALLY IDENTICAL TO CURRENT FILE, SKIP TO STEP 6** 🚨
 
 ## STEP 5: IF LOCAL HELPERS ARE FOUND IN STEP 4 THAT CAN BE REUSED in ${testFile}, MOVE THOSE LOCAL HELPERS TO UTILS SOURCE FILES AND USE THEM
-**ONLY PROCEED WITH STEP 5 IF:**
-- You found OTHER test files in STEP 4 (not just ${testFile})
-- Those test files contain helper functions that can be reused in ${testFile}
 
-**IF NO REUSABLE HELPERS WERE FOUND, SKIP TO STEP 6 - DO NOT CREATE ANY UTILS FILES.**
+🚨 **ONLY PROCEED WITH STEP 5 IF ALL CONDITIONS ARE MET:** 🚨
+- ✅ You found OTHER test files in STEP 4 (not just ${testFile})
+- ✅ Those test files contain ACTUAL HELPER FUNCTIONS with function signatures (not just repetitive patterns)
+- ✅ The helper functions are ALREADY IMPLEMENTED and working in those OTHER test files
+- ✅ The helper functions are DIFFERENT from the current file (not just identical patterns)
+
+🚨 **IF ANY CONDITION IS NOT MET, SKIP TO STEP 6 - DO NOT CREATE ANY UTILS FILES.** 🚨
+
+**Examples of when to SKIP STEP 5:**
+- ❌ Other test files have identical repetitive code but no helper functions
+- ❌ Other test files are generated from same template and look identical
+- ❌ You see patterns but no actual function definitions
+- ❌ You would need to CREATE new functions to extract the patterns
 
 **CRITICAL:** For helpers found in STEP 4:
-1. **CREATE** \`skyramp_utils.${ext}\` file if it doesn't exist with the following header:
+1. **CREATE** \`${fileName}\` file if it doesn't exist with the following header:
    \`\`\`${ext}
    ${generateSkyrampHeader(language)}
    \`\`\`
-2. **COPY** those local helper functions from original test source files to \`utils.${ext}\` without modifying them
+**CRITICAL: IF \`${fileName}\` is already big, create a new file with a different name and add the header to the new file.**
+2. **COPY** those local helper functions from original test source files to \`${fileName}\` without modifying them
 3. **DELETE** those local helper functions from test source files (REMOVE THEM COMPLETELY) WITHOUT ANY OTHER CHANGES.
-4. **IMPORT** those local helper functions from \`utils.${ext}\` back into test source files WITHOUT MAKING ANY OTHER CHANGE.
-5. **IMPORT** those local helper functions from \`utils.${ext}\` into ${testFile}
+4. **IMPORT** those local helper functions from \`${fileName}\` back into test source files WITHOUT MAKING ANY OTHER CHANGE.
+5. **IMPORT** those local helper functions from \`${fileName}\` into ${testFile}
 6. **REPLACE** duplicate code in ${testFile} with calls to imported helper functions WITHOUT MAKING ANY OTHER CHANGE.
 
-**CRITICAL: DO NOT CREATE UNNECESSARY HELPER FUNCTIONS**
-- **ONLY** extract functions that are actually duplicated and used in multiple places
-- **DO NOT** create granular helper functions that duplicate functionality already covered by existing helpers
-- **DO NOT** create functions that break down existing functionality into smaller pieces just for modularity
-- **ONLY** create helpers that eliminate actual code duplication, not just for the sake of modularity
-- **VERIFY** that each helper function serves a clear purpose and is actually used in the refactored code
-
-**CRITICAL: EXPLICIT RULES FOR SOURCE TEST FILES:**
-- **ONLY** remove the helper function definitions (the actual function code) that are needed for ${testFile}
-- **ONLY** add import statements for the helper functions
-- **DO NOT** change any other code in the source test files
-- **DO NOT** change the test logic, test steps, or test flow
-- **DO NOT** add new helper functions that weren't in the original file
-- **DO NOT** modify existing function calls or test assertions
-- **DO NOT** change variable names, test data, or test structure
+🚨 **CRITICAL: DO NOT CREATE UNNECESSARY HELPER FUNCTIONS** 🚨
+🚨 **DO NOT CREATE HELPERS BASED ON PATTERNS IN THE CURRENT FILE** 🚨
 
 ## STEP 6: VERIFY AND VALIDATE
 1. **BEFORE** making any changes, read the original test file and identify ALL helper functions
@@ -87,15 +126,26 @@ Look for patterns like: Form filling utilities, Navigation helpers, Authenticati
 9. **NEVER** refactor, reorganize, or restructure existing source test files beyond moving helpers
 10. **RUN TESTS** to ensure functionality is preserved after refactoring
 
-**WORKFLOW SUMMARY:**
-1. Check existing utils with header ${SKYRAMP_UTILS_HEADER} → reuse if found WITHOUT ANY OTHER CHANGES
-2. Search OTHER test files (not ${testFile}) for local helpers with header ${SKYRAMP_UTILS_HEADER}
-3. **ONLY IF** reusable helpers are found in OTHER test files → move to utils and update imports
-4. **IF NO** existing utils or reusable helpers are found in test files then reuse is complete, without creating any files or changes to the test files
-5. Verify no duplicate code remains and tests work as expected${modularizeCode
-        ? "\n6. **IMPORTANT**: After code reuse is complete, proceed to modularization by calling skyramp_modularization tool"
-        : ""}
+🚨 **FINAL REMINDER: DO NOT CREATE HELPER FUNCTIONS FROM SCRATCH** 🚨
+🚨 **ONLY MOVE EXISTING HELPERS FROM OTHER TEST FILES** 🚨
+
+**IMPORTANT NOTES:**
+- The process is designed to REUSE existing helper functions, not create new ones
+- If no existing helpers are found, the test file should remain unchanged
+- Code reuse is about moving existing, working helper functions between files
+- Never create helper functions based on patterns you see in the current test file
+- Helper functions must have explicit function signatures/definitions
+- Repetitive inline test code is NOT a helper function
+
+**DECISION TREE:**
+1. Found existing utils file with helpers? → Import and use them (Step 3)
+2. Found other test files with ACTUAL helper functions? → Move to utils (Step 5)
+3. Found other test files with only repetitive patterns? → SKIP to Step 6, NO utils file
+4. Found no other test files? → SKIP to Step 6, NO utils file
+5. Other test files identical to current? → SKIP to Step 6, NO utils file
+
+**MANDATORY**: After code reuse is complete, proceed to modularization by calling skyramp_modularization tool
 
-SUMMARY: THE LLM SHOULD SUMMARIZE THE CODE REUSE PROCESS AND THE RESULTS.
+SUMMARIZE THE CODE REUSE PROCESS AND THE RESULTS.
 `;
 }

package/build/prompts/modularization/ui-test-modularization.js

@@ -4,14 +4,14 @@ export function getModularizationPrompt(filePath) {
 **WRITE MODULARIZED CODE TO: ${filePath}**
 
 **ABSOLUTELY FORBIDDEN:**
-- DO NOT CREATE INTERFACES, CLASSES, TYPES, OR NEW DATA STRUCTURES
+- DO NOT CREATE INTERFACES, CLASSES, TYPES, NEW FILES, OR NEW DATA STRUCTURES
 - DO NOT CHANGE TEST LOGIC, DATA VALUES, CALCULATIONS, OR ASSERTIONS
-- DO NOT CREATE/UPDATE package.json, requirements.txt, pom.xml, build.gradle file
+- DO NOT CREATE/UPDATE  DEPENDENCY FILES package.json, requirements.txt, pom.xml, build.gradle file
 
 ## STEP 1: READ THE ORIGINAL TEST
 Read ${filePath} completely and identify:
 - All test data values (names, prices, quantities, totals)
-- All calculations and expected results
+- All test data including calculations and expected results 
 - The exact test flow
 - **Check if code is already modularized** (e.g., \`breakpoint_section_0\`, \`breakpoint_section_1\` functions)
 
@@ -37,13 +37,12 @@ Extract code in TWO scenarios:
 - Don't try to "unify" variations with conditional logic
 
 **B) LOGICAL SECTIONS** - Self-contained operations (5+ lines) that improve readability
-- Examples: "create product", "fill order form", "verify result"
+- Examples: "create product", "fill form", "verify result"
 - Must be cohesive - related operations that achieve one goal
 
 **Don't extract:**
 - Code less than 5 lines (unless highly repetitive)
 - Navigation sequences (\`navbar-\` clicks, \`page.goto\`)
-- Single operations with no repetition
 
 ## STEP 3: EXTRACT INTO HELPERS
 
@@ -125,18 +124,6 @@ await addItem(page, "item1");
 await addItem(page, "item2");
 await addItem(page, "item3");
 
-// ✅ CORRECT - One helper handles all cases
-async function createOrder(page, email, items) {
-  // ... setup
-  for (const item of items) {  // Loop OK if items explicit at call site
-    await addItem(page, item.name, item.quantity);
-  }
-}
-// Call with explicit items:
-await createOrder(page, "test@email.com", [
-  { name: "item1", quantity: 1 },
-  { name: "item2", quantity: 2 }
-]);
 \`\`\`
 
 ## STEP 4: CALL HELPERS WITH EXACT SAME VALUES

package/build/services/TestGenerationService.js

@@ -35,24 +35,12 @@ export class TestGenerationService {
             });
             // Orchestrate code optimization workflow based on flags
             let postGenerationMessage = "";
-            if (params.codeReuse && params.modularizeCode) {
-                // Both enabled: Run in sequence (reuse first, then modularize)
-                postGenerationMessage += `
-✅ Test generated successfully!
-
-📋 **Optimization Workflow:**
-1. **Code Reuse Analysis** - Will identify and extract reusable code patterns
-2. **Code Modularization** - Will then organize code for better maintainability
-
-⏭️  Next: Running code reuse analysis with skyramp_code_reuse tool...
-`;
-            }
-            else if (params.codeReuse) {
+            if (params.codeReuse) {
                 // Only code reuse
                 postGenerationMessage += `
 ✅ Test generated successfully!
 
-⏭️  Next: Running code reuse analysis with skyramp_code_reuse tool...
+⏭️**CRITICAL NEXT STEP**: Running code reuse analysis with skyramp_reuse_code tool.
 `;
             }
             else if (params.modularizeCode) {
@@ -60,7 +48,7 @@ export class TestGenerationService {
                 postGenerationMessage += `
 ✅ Test generated successfully!
 
-⏭️  Next: Running modularization with skyramp_modularization tool...
+⏭️**CRITICAL NEXT STEP**: Running modularization with skyramp_modularization tool.
 `;
             }
             return {

package/build/tools/codeReuseTool.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { getCodeReusePrompt } from "../prompts/code-reuse.js";
 import { codeRefactoringSchema, languageSchema } from "../types/TestTypes.js";
+import { SKYRAMP_UTILS_HEADER } from "../utils/utils.js";
 const codeReuseSchema = z.object({
     testFile: z
         .string()
@@ -14,8 +15,35 @@ const codeReuseSchema = z.object({
         .describe("The code content to analyze and optimize for code reuse"),
 });
 export function registerCodeReuseTool(server) {
-    server.registerTool("skyramp_code_reuse", {
-        description: `Analyzes code for reuse opportunities and enforces code reuse principles. This tool helps identify duplicate code patterns and provides guidance on importing and reusing existing helper functions from other test files.`,
+    server.registerTool("skyramp_reuse_code", {
+        description: `Analyzes code for reuse opportunities and enforces code reuse principles. 
+      
+      This tool helps identify and reuse ONLY EXISTING helper functions from other test files (grep based on "${SKYRAMP_UTILS_HEADER}"). 
+      
+      **CRITICAL RULES - VIOLATION WILL RESULT IN ERROR:**
+      1. DO NOT create new helper functions - only find and reuse existing ones
+      2. ONLY create a utils file if ACTUAL helper functions (with signatures) exist in OTHER test files
+      3. DO NOT create utils files for repetitive patterns - that's refactoring, not reuse
+      4. DO NOT extract patterns from current or other test files - only move existing functions
+      5. If other test files are identical/similar with no helper functions, DO NOTHING
+      6. Helper functions must have explicit function definitions, not just patterns
+      7. If no existing helper functions found, test file remains unchanged
+      
+
+      **WORKFLOW SUMMARY:**
+      1. Check existing utils with header ${SKYRAMP_UTILS_HEADER} → reuse if found WITHOUT ANY OTHER CHANGES
+      2. Search OTHER test files (not current test file) for local helpers with header ${SKYRAMP_UTILS_HEADER}
+      3. **ONLY IF** reusable helpers are found in OTHER test files → move to utils and update imports
+      4. **IF NO** existing utils or reusable helpers are found in test files then reuse is complete, without creating any files or changes to the test files
+      5. Verify no duplicate code remains and tests work as expected
+      6. **MANDATORY**: After code reuse is complete, proceed to modularization by calling skyramp_modularization tool
+      
+      **WHEN TO SKIP (DO NOTHING):**
+      - Other test files only have repetitive patterns, no helper functions
+      - Other test files are essentially identical to current file
+      - No actual function definitions found in other test files
+      
+      The tool will provide step-by-step instructions that MUST be followed exactly.`,
         inputSchema: codeReuseSchema.shape,
         annotations: {
             keywords: [
@@ -32,7 +60,7 @@ export function registerCodeReuseTool(server) {
             language: params.language,
             framework: params.framework,
         });
-        const codeReusePrompt = getCodeReusePrompt(params.testFile, params.language, params.modularizeCode);
+        const codeReusePrompt = getCodeReusePrompt(params.testFile, params.language);
         return {
             content: [
                 {

package/build/tools/generateE2ERestTool.js

@@ -2,12 +2,12 @@ import { z } from "zod";
 import { baseSchema, baseTraceSchema, TestType, codeRefactoringSchema, } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 const e2eTestSchema = {
-    ...baseSchema.shape,
     ...baseTraceSchema.shape,
     playwrightInput: z
         .string()
         .describe("MUST be absolute path to the playwright input file like /path/to/playwright-ui-test.zip and MUST be a zip file captured using start_trace_collection tool"),
     ...codeRefactoringSchema.shape,
+    ...baseSchema.shape,
 };
 export class E2ETestService extends TestGenerationService {
     getTestType() {

package/package.json

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