@ash-mallick/browserstack-sync 1.1.2 → 1.1.4

package/lib/ai-analyzer.js

@@ -14,44 +14,137 @@ const OLLAMA_HOST = process.env.OLLAMA_HOST || 'http://localhost:11434';
 /**
  * System prompt for the AI to understand what we want.
  */
-const SYSTEM_PROMPT = `You are a test automation expert. Your job is to analyze Playwright or Cypress test code and extract human-readable test steps.
-
-For each test, output a JSON array of steps. Each step should have:
-- "step": A clear, human-readable action (e.g., "Navigate to /login page", "Enter 'test@example.com' in the email field")
-- "result": The expected result or assertion for this step (e.g., "Login form is displayed", "Error message 'Invalid credentials' appears")
-
-Rules:
-1. Convert code actions to plain English that a manual tester could follow
-2. For page.goto(url) -> "Navigate to <url>"
-3. For page.fill(selector, value) or getByLabel().fill() -> "Enter '<value>' in the <field name> field"
-4. For page.click() or getByRole().click() -> "Click the '<button/link name>' button/link"
-5. For expect() assertions -> This becomes the "result" of the previous step
-6. If there's no explicit assertion, the result should describe the expected state
-7. Be concise but clear
-8. Group related actions if they form one logical step
-
-Output ONLY valid JSON array, no markdown, no explanation. Example:
+const SYSTEM_PROMPT = `You are a QA expert creating manual test steps from automated test code.
+
+CRITICAL RULES:
+1. Generate steps ONLY for what is explicitly in the test code provided
+2. DO NOT add steps for things not in the code
+3. DO NOT hallucinate or assume content - use ONLY text/values from the code
+4. Each expect() or assertion = one verification step
+5. Output ONLY valid JSON array, nothing else
+
+STEP FORMAT:
+{
+  "step": "Numbered action description with exact element and location",
+  "result": "Expected outcome using exact text from the code"
+}
+
+MAPPING CODE TO STEPS:
+
+1. getByTestId('section-name') → "Locate the section with test ID 'section-name'"
+2. locator('.class-name') → "Find the element with class 'class-name'"
+3. getByRole('link', { name: /text/i }) → "Find the link labeled 'text'"
+4. expect(element).toBeVisible() → Result: "The element is visible"
+5. expect(element).toContainText('exact text') → Result: "The element displays 'exact text'"
+6. expect(element).toHaveText('exact text') → Result: "The element shows exactly 'exact text'"
+7. expect(link).toHaveAttribute('href', '/path') → Result: "The link href is '/path'"
+8. scrollIntoViewIfNeeded() → "Scroll to bring the element into view"
+
+EXAMPLE - For this code:
+  const scope = page.getByTestId("success-stories");
+  await expect(scope.locator(".band__headline")).toHaveText("Success stories");
+  
+OUTPUT:
 [
-  {"step": "Navigate to /login page", "result": "Login page loads successfully"},
-  {"step": "Enter 'user@test.com' in the Email field", "result": "Email is entered"},
-  {"step": "Enter 'password123' in the Password field", "result": "Password is masked and entered"},
-  {"step": "Click the 'Sign In' button", "result": "User is redirected to /dashboard"}
-]`;
+  {"step": "1. Locate the section with test ID 'success-stories' on the page.", "result": "The success-stories section is found."},
+  {"step": "2. In the success-stories section, find the element with class 'band__headline'. Verify its text content.", "result": "The headline displays exactly 'Success stories'."}
+]
+
+REMEMBER:
+- ONLY use text/values that appear in the test code
+- DO NOT make up text or values
+- Number steps 1, 2, 3...
+- Be precise and specific`;
 
 /**
  * Build the user prompt for AI analysis.
  */
 function buildUserPrompt(testTitle, testCode) {
-  return `Analyze this Playwright/Cypress test and extract the test steps:
+  return `Convert this automated test into manual test steps.
 
-Test Title: ${testTitle}
+TEST: "${testTitle}"
 
-Test Code:
-\`\`\`
+CODE:
 ${testCode}
-\`\`\`
 
-Return a JSON array of steps with "step" and "result" fields.`;
+INSTRUCTIONS:
+1. Create one step for EACH expect() assertion in the code
+2. Use ONLY the exact text strings that appear in the code (in quotes or regex)
+3. For each getByTestId(), locator(), or getByRole() - describe THAT element
+4. For each .toContainText('X') or .toHaveText('X') - the expected result is "displays 'X'"
+5. For each .toHaveAttribute('href', 'Y') - the expected result is "href is 'Y'"
+6. DO NOT add extra text or values that are not in the code
+
+Example mapping:
+- expect(page.getByTestId("masthead")).toBeVisible() 
+  → Step: "Locate the element with test ID 'masthead'." Result: "The masthead element is visible."
+
+- expect(el).toContainText("Hello World")
+  → Step: "Verify the element's text content." Result: "The element contains 'Hello World'."
+
+- expect(link).toHaveAttribute("href", "/contact")
+  → Step: "Check the link's href attribute." Result: "The link href is '/contact'."
+
+OUTPUT: Return ONLY a JSON array of {step, result} objects. No other text.`;
+}
+
+/**
+ * Attempt to repair truncated JSON array.
+ * Handles cases where the response was cut off mid-array.
+ */
+function repairTruncatedJSON(jsonStr) {
+  // First, try parsing as-is
+  try {
+    return JSON.parse(jsonStr);
+  } catch (_) {
+    // Continue with repair attempts
+  }
+
+  // Try to find the last complete object in the array
+  // Pattern: find all complete {"step": "...", "result": "..."} objects
+  const objectPattern = /\{\s*"step"\s*:\s*"(?:[^"\\]|\\.)*"\s*,\s*"result"\s*:\s*"(?:[^"\\]|\\.)*"\s*\}/g;
+  const matches = jsonStr.match(objectPattern);
+  
+  if (matches && matches.length > 0) {
+    // Reconstruct a valid JSON array from complete objects
+    const reconstructed = '[' + matches.join(',') + ']';
+    try {
+      return JSON.parse(reconstructed);
+    } catch (_) {
+      // Fall through
+    }
+  }
+
+  // Try removing the last incomplete object and close the array
+  let trimmed = jsonStr.trim();
+  
+  // If it starts with [, try to close it properly
+  if (trimmed.startsWith('[')) {
+    // Find the last complete }, before truncation
+    const lastCompleteObj = trimmed.lastIndexOf('},');
+    if (lastCompleteObj > 0) {
+      const fixedJson = trimmed.slice(0, lastCompleteObj + 1) + ']';
+      try {
+        return JSON.parse(fixedJson);
+      } catch (_) {
+        // Fall through
+      }
+    }
+    
+    // Try finding the last }
+    const lastBrace = trimmed.lastIndexOf('}');
+    if (lastBrace > 0) {
+      const fixedJson = trimmed.slice(0, lastBrace + 1) + ']';
+      try {
+        return JSON.parse(fixedJson);
+      } catch (_) {
+        // Fall through
+      }
+    }
+  }
+
+  // Last resort: throw the original error
+  return JSON.parse(jsonStr);
 }
 
 /**
@@ -71,15 +164,22 @@ function parseAIResponse(content) {
 
   // Also try to extract JSON array from anywhere in the response
   if (!jsonStr.startsWith('[')) {
-    const arrayMatch = jsonStr.match(/\[[\s\S]*\]/);
+    const arrayMatch = jsonStr.match(/\[[\s\S]*?\](?=[^}\]]*$)?/);
     if (arrayMatch) {
       jsonStr = arrayMatch[0];
     }
   }
 
+  // Try to find just the array portion if there's extra text
+  const arrayStart = jsonStr.indexOf('[');
+  if (arrayStart > 0) {
+    jsonStr = jsonStr.slice(arrayStart);
+  }
+
   let steps;
   try {
-    steps = JSON.parse(jsonStr);
+    // Use repair function to handle truncated responses
+    steps = repairTruncatedJSON(jsonStr);
   } catch (parseError) {
     throw new Error(`Failed to parse AI response as JSON: ${parseError.message}. Response: ${content.slice(0, 200)}`);
   }
@@ -88,10 +188,13 @@ function parseAIResponse(content) {
     throw new Error('AI response is not an array');
   }
 
-  return steps.map((s) => ({
-    step: String(s.step || ''),
-    result: String(s.result || ''),
-  }));
+  // Filter out any empty or invalid steps
+  return steps
+    .filter((s) => s && (s.step || s.result))
+    .map((s) => ({
+      step: String(s.step || '').trim(),
+      result: String(s.result || '').trim(),
+    }));
 }
 
 /**
@@ -136,7 +239,9 @@ async function analyzeWithOllama(testTitle, testCode, model) {
       { role: 'user', content: buildUserPrompt(testTitle, testCode) },
     ],
     options: {
-      temperature: 0.2,
+      temperature: 0.1,      // Lower temperature for more consistent, focused output
+      num_predict: 8192,     // Increased max tokens for detailed step descriptions
+      num_ctx: 8192,         // Context window for longer test code input
     },
   });
 
@@ -176,47 +281,131 @@ export async function analyzeTestWithAI(testTitle, testCode, apiKey, options = {
  */
 export function extractStepsWithRegex(testCode, isCypress = false) {
   const steps = [];
+  let stepNum = 1;
 
-  // Common Playwright patterns
+  // Helper to clean up regex patterns from text
+  const cleanText = (text) => text?.replace(/\\?\//gi, '').replace(/\^|\$/g, '').trim() || '';
+
+  // Common Playwright patterns - order matters for sequential extraction
   const patterns = [
     // page.goto or cy.visit
     {
-      regex: /(?:page\.goto|cy\.visit)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
-      format: (match) => ({ step: `Navigate to ${match[1]}`, result: 'Page loads successfully' }),
+      regex: /(?:page\.goto|cy\.visit)\s*\(\s*(?:process\.env\.[A-Z_]+\s*\+\s*)?['"`]([^'"`]+)['"`]/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Open the browser and navigate to the URL: ${match[1] || '/'}. Wait for the page to fully load.`,
+        result: 'The page loads successfully and all elements are visible.',
+      }),
     },
-    // page.fill or cy.get().type() with getByLabel
+    // getByTestId - identify section
     {
-      regex: /(?:getByLabel|getByPlaceholder)\s*\([^)]+\)\.fill\s*\(\s*['"`]([^'"`]+)['"`]/gi,
-      format: (match) => {
-        const labelMatch = match.input.match(/(?:getByLabel|getByPlaceholder)\s*\(\s*['"`/]([^'"`/]+)/i);
-        const label = labelMatch ? labelMatch[1].replace(/\\?\/i$/, '') : 'field';
-        return { step: `Enter '${match[1]}' in the ${label} field`, result: 'Value is entered' };
-      },
+      regex: /(?:page\.|await\s+)getByTestId\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Locate the section/component with test ID "${match[1]}" on the page.`,
+        result: `The "${match[1]}" section is found and visible on the page.`,
+      }),
+    },
+    // locator with class or selector
+    {
+      regex: /\.locator\s*\(\s*['"`]\.([^'"`]+)['"`]\s*\)(?:\.first\(\))?/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Within the current section, find the element with class "${match[1]}".`,
+        result: `Element with class "${match[1]}" is located.`,
+      }),
+    },
+    // getByRole with name - link
+    {
+      regex: /getByRole\s*\(\s*['"`]link['"`]\s*,\s*\{[^}]*name:\s*['"`/]([^'"`/]+)/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Find the link labeled "${cleanText(match[1])}" on the page.`,
+        result: `The "${cleanText(match[1])}" link is visible and clickable.`,
+      }),
+    },
+    // getByRole with name - button
+    {
+      regex: /getByRole\s*\(\s*['"`]button['"`]\s*,\s*\{[^}]*name:\s*['"`/]([^'"`/]+)/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Locate the button labeled "${cleanText(match[1])}" on the page.`,
+        result: `The "${cleanText(match[1])}" button is displayed and enabled.`,
+      }),
     },
-    // page.click or getByRole().click()
+    // scrollIntoViewIfNeeded
     {
-      regex: /getByRole\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*\{[^}]*name:\s*['"`/]([^'"`/]+)/gi,
-      format: (match) => ({ step: `Click the '${match[2].replace(/\\?\/i$/, '')}' ${match[1]}`, result: `${match[1]} is clicked` }),
+      regex: /scrollIntoViewIfNeeded\s*\(\s*\)/gi,
+      format: () => ({
+        step: `${stepNum++}. Scroll the page until the target element is visible in the viewport.`,
+        result: 'The element scrolls into view successfully.',
+      }),
     },
     // expect toBeVisible
     {
-      regex: /expect\s*\([^)]+\)\.toBeVisible\s*\(\s*\)/gi,
-      format: () => ({ step: 'Verify element is visible', result: 'Element is visible on the page' }),
+      regex: /expect\s*\([^)]+\)\.toBeVisible\s*\(/gi,
+      format: () => ({
+        step: `${stepNum++}. Verify that the element is visible on the page.`,
+        result: 'The element is confirmed to be visible and displayed.',
+      }),
+    },
+    // expect toContainText with text
+    {
+      regex: /expect\s*\([^)]+\)\.toContainText\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Verify the element contains the text "${match[1]}".`,
+        result: `The text "${match[1]}" is displayed within the element.`,
+      }),
+    },
+    // expect toHaveText with text
+    {
+      regex: /expect\s*\([^)]+\)\.toHaveText\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+      format: (match) => ({
+        step: `${stepNum++}. Verify the element has the exact text "${match[1]}".`,
+        result: `The element displays exactly: "${match[1]}".`,
+      }),
+    },
+    // expect toHaveAttribute href - capture full URL including slashes
+    {
+      regex: /expect\s*\([^)]+\)\.toHaveAttribute\s*\(\s*['"`]href['"`]\s*,\s*(?:\/)?['"`]?([^'"`\)]+?)['"`]?\s*\)/gi,
+      format: (match) => {
+        const url = match[1]?.trim().replace(/^\/|\/$/g, '') || '';
+        return {
+          step: `${stepNum++}. Verify the link has an href attribute pointing to "${url}".`,
+          result: `The link's href contains or matches "${url}".`,
+        };
+      },
     },
     // expect toHaveURL
     {
       regex: /expect\s*\([^)]+\)\.toHaveURL\s*\(\s*['"`/]([^'"`/]+)/gi,
-      format: (match) => ({ step: 'Verify URL', result: `URL matches ${match[1]}` }),
+      format: (match) => ({
+        step: `${stepNum++}. Verify the browser URL matches "${cleanText(match[1])}".`,
+        result: `The URL is confirmed to contain/match "${cleanText(match[1])}".`,
+      }),
+    },
+    // page.fill or getByLabel().fill()
+    {
+      regex: /(?:getByLabel|getByPlaceholder)\s*\([^)]+\)\.fill\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+      format: (match) => {
+        const labelMatch = match.input.match(/(?:getByLabel|getByPlaceholder)\s*\(\s*['"`/]([^'"`/]+)/i);
+        const label = cleanText(labelMatch?.[1]) || 'input field';
+        return {
+          step: `${stepNum++}. Locate the "${label}" input field and enter the value "${match[1]}".`,
+          result: `The value "${match[1]}" is entered in the "${label}" field.`,
+        };
+      },
     },
-    // expect toHaveText or toContainText
+    // .click()
     {
-      regex: /expect\s*\([^)]+\)\.(?:toHaveText|toContainText)\s*\(\s*['"`/]([^'"`/]+)/gi,
-      format: (match) => ({ step: 'Verify text content', result: `Text '${match[1]}' is displayed` }),
+      regex: /\.click\s*\(\s*\)/gi,
+      format: () => ({
+        step: `${stepNum++}. Click on the identified element.`,
+        result: 'The click action is performed successfully.',
+      }),
     },
     // cy.get().should()
     {
       regex: /cy\.get\s*\([^)]+\)\.should\s*\(\s*['"`]([^'"`]+)['"`]/gi,
-      format: (match) => ({ step: 'Verify element state', result: `Element should ${match[1]}` }),
+      format: (match) => ({
+        step: `${stepNum++}. Verify the element state using Cypress assertion.`,
+        result: `Element assertion "${match[1]}" passes.`,
+      }),
     },
   ];
 
@@ -239,8 +428,8 @@ export function extractStepsWithRegex(testCode, isCypress = false) {
   if (steps.length === 0) {
     const fw = isCypress ? 'Cypress' : 'Playwright';
     steps.push({
-      step: `Execute ${fw} automated test`,
-      result: 'Test passes with all assertions verified',
+      step: `1. Execute the "${testTitle}" automated test using ${fw}.`,
+      result: 'Test completes successfully with all assertions verified.',
     });
   }
 

package/lib/browserstack.js

@@ -112,32 +112,91 @@ export async function updateTestCase(projectId, testCaseId, testCase, auth) {
 
 /** Match existing BS test case to our local case: by title or by our TC-xxx tag */
 function findExisting(existingList, localCase) {
-  const byTitle = existingList.find((t) => (t.title || '').trim() === (localCase.title || '').trim());
+  const byTitle = existingList.find((t) => (t.name || t.title || '').trim() === (localCase.title || '').trim());
   if (byTitle) return byTitle;
   const byTag = existingList.find((t) => (t.tags || []).includes(localCase.id));
   return byTag;
 }
 
+/**
+ * Compare local test case with existing BrowserStack test case.
+ * Returns true if content has changed and update is needed.
+ */
+function hasContentChanged(existing, localCase) {
+  // Compare steps - this is the main content that changes
+  const existingSteps = existing.test_case_steps || [];
+  const localSteps = Array.isArray(localCase.steps) ? localCase.steps : [];
+  
+  // Different number of steps = changed
+  if (existingSteps.length !== localSteps.length) {
+    return true;
+  }
+  
+  // Compare each step
+  for (let i = 0; i < localSteps.length; i++) {
+    const existingStep = existingSteps[i] || {};
+    const localStep = localSteps[i] || {};
+    
+    const existingStepText = (existingStep.step || '').trim();
+    const localStepText = (localStep.step || '').trim();
+    const existingResult = (existingStep.result || '').trim();
+    const localResult = (localStep.result || '').trim();
+    
+    if (existingStepText !== localStepText || existingResult !== localResult) {
+      return true;
+    }
+  }
+  
+  // Compare title
+  const existingTitle = (existing.name || existing.title || '').trim();
+  const localTitle = (localCase.title || '').trim();
+  if (existingTitle !== localTitle) {
+    return true;
+  }
+  
+  // No changes detected
+  return false;
+}
+
 export async function syncToBrowserStack(specsMap, projectId, auth) {
   console.log('\nSyncing to BrowserStack project', projectId);
+  
+  let totalCreated = 0;
+  let totalUpdated = 0;
+  let totalSkipped = 0;
+  
   for (const [baseName, { specFile, cases }] of specsMap) {
     const folderName = baseName;
     const folderId = await ensureFolder(projectId, folderName, null, auth);
     const existing = await getTestCasesInFolder(projectId, folderId, auth);
-    console.log('Folder:', folderName, '(id:', folderId, ')');
+    console.log('Folder:', folderName, '(id:', folderId, ') -', cases.length, 'test(s)');
+    
     for (const tc of cases) {
       try {
         const found = findExisting(existing, tc);
         if (found) {
-          await updateTestCase(projectId, found.identifier, tc, auth);
-          console.log('  Updated', tc.id, tc.title, '->', found.identifier);
+          // Check if content has actually changed before updating
+          if (hasContentChanged(found, tc)) {
+            await updateTestCase(projectId, found.identifier, tc, auth);
+            console.log('  ✓ Updated', tc.id, tc.title, '->', found.identifier);
+            totalUpdated++;
+          } else {
+            console.log('  ○ Skipped', tc.id, tc.title, '(no changes)');
+            totalSkipped++;
+          }
         } else {
           const id = await createTestCase(projectId, folderId, tc, auth);
-          console.log('  Created', tc.id, tc.title, '->', id);
+          console.log('  + Created', tc.id, tc.title, '->', id);
+          totalCreated++;
         }
       } catch (e) {
-        console.error('  Failed', tc.id, tc.title, e.message);
+        console.error('  ✗ Failed', tc.id, tc.title, e.message);
       }
     }
   }
+  
+  console.log('\nSync summary:');
+  console.log(`  Created: ${totalCreated} test case(s)`);
+  console.log(`  Updated: ${totalUpdated} test case(s)`);
+  console.log(`  Skipped: ${totalSkipped} test case(s) (no changes)`);
 }

package/lib/enrich.js

@@ -40,6 +40,46 @@ function inferTags(specBaseName, title, isCypress) {
   return tags;
 }
 
+/**
+ * Count the number of expect() assertions in test code.
+ */
+function countAssertions(code) {
+  const expectMatches = code.match(/expect\s*\(/g) || [];
+  return expectMatches.length;
+}
+
+/**
+ * Merge AI steps with regex steps to ensure completeness.
+ * If AI generated fewer steps than assertions, supplement with unique regex steps.
+ */
+function mergeStepsForCompleteness(aiSteps, regexSteps, assertionCount) {
+  if (!aiSteps || aiSteps.length === 0) {
+    return regexSteps;
+  }
+  
+  // If AI generated enough steps, use AI steps
+  if (aiSteps.length >= assertionCount * 0.7) { // 70% coverage threshold
+    return aiSteps;
+  }
+  
+  // If AI generated too few steps, supplement with unique regex steps
+  const aiStepTexts = new Set(aiSteps.map(s => s.step.toLowerCase()));
+  const supplementalSteps = regexSteps.filter(rs => {
+    // Only add regex steps that aren't similar to existing AI steps
+    const rsLower = rs.step.toLowerCase();
+    return !Array.from(aiStepTexts).some(aiText => 
+      aiText.includes(rsLower.slice(0, 30)) || rsLower.includes(aiText.slice(0, 30))
+    );
+  });
+  
+  // Combine and renumber
+  const combined = [...aiSteps, ...supplementalSteps];
+  return combined.map((step, idx) => ({
+    step: step.step.replace(/^\d+\.\s*/, `${idx + 1}. `),
+    result: step.result,
+  }));
+}
+
 /**
  * Enrich a single case with state, case_type, steps, expected_results, jira_issues, automation_status, tags, description.
  * @param {Object} case_ - Test case with id, title, code
@@ -54,13 +94,19 @@ export function enrichCase(case_, specBaseName, isCypress = false, aiSteps = nul
   const fw = isCypress ? FRAMEWORK.cypress : FRAMEWORK.playwright;
   const tags = inferTags(specBaseName, title, isCypress);
 
-  // Determine steps: AI steps > regex-extracted steps > default
+  // Count assertions in code for completeness check
+  const assertionCount = code ? countAssertions(code) : 0;
+  
+  // Get regex-based steps as fallback/supplement
+  const regexSteps = code ? extractStepsWithRegex(code, isCypress) : [];
+
+  // Determine steps: merge AI + regex for completeness, or use regex only
   let steps;
   if (aiSteps && aiSteps.length > 0) {
-    steps = aiSteps;
-  } else if (code) {
-    // Try regex-based extraction from code
-    steps = extractStepsWithRegex(code, isCypress);
+    // Merge AI steps with regex steps to ensure we don't miss assertions
+    steps = mergeStepsForCompleteness(aiSteps, regexSteps, assertionCount);
+  } else if (regexSteps.length > 0) {
+    steps = regexSteps;
   } else {
     // Fallback to generic step
     steps = [{ step: fw.step, result: DEFAULT_EXPECTED_RESULT }];

package/lib/index.js

@@ -38,35 +38,47 @@ export async function runSync(options = {}) {
     return;
   }
 
-  // Enrich with AI-powered step analysis (falls back to regex if no API key)
+  // Filter specs BEFORE AI analysis (to avoid analyzing specs we don't need)
+  if (options.spec && options.spec.length > 0) {
+    const set = new Set(options.spec);
+    // Match by exact name, base name, or partial match
+    specsMap = new Map([...specsMap].filter(([name]) => {
+      // Check exact match
+      if (set.has(name)) return true;
+      // Check if any spec pattern matches this name
+      for (const pattern of options.spec) {
+        if (name.includes(pattern) || pattern.includes(name)) return true;
+        // Also try without extension
+        const patternBase = pattern.replace(/\.(spec|test|cy)\.(js|ts)$/i, '');
+        const nameBase = name.replace(/\.(spec|test|cy)$/i, '');
+        if (nameBase.includes(patternBase) || patternBase.includes(nameBase)) return true;
+      }
+      return false;
+    }));
+    if (specsMap.size === 0) {
+      console.log('No matching spec files for:', options.spec.join(', '));
+      console.log('Available specs:', [...analyzeSpecs(e2eDir).keys()].join(', '));
+      return;
+    }
+  } else if (!options.all && !csvOnly && options.interactive !== false && process.stdin.isTTY) {
+    // Interactive selection BEFORE AI analysis
+    const selected = await promptSpecSelection(specsMap);
+    if (selected === null) {
+      // user chose "all"
+    } else if (selected.size === 0) {
+      console.log('No spec files selected. Exiting.');
+      return;
+    } else {
+      specsMap = new Map([...specsMap].filter(([name]) => selected.has(name)));
+    }
+  }
+
+  // Enrich with AI-powered step analysis (only for filtered specs)
   await enrichSpecsMapWithAI(specsMap, {
     useAI,
     model: options.model,
   });
 
-  if (!csvOnly) {
-    if (options.all) {
-      // sync all, no prompt
-    } else if (options.spec && options.spec.length > 0) {
-      const set = new Set(options.spec);
-      specsMap = new Map([...specsMap].filter(([name]) => set.has(name)));
-      if (specsMap.size === 0) {
-        console.log('No matching spec files for:', options.spec.join(', '));
-        return;
-      }
-    } else if (options.interactive !== false && process.stdin.isTTY) {
-      const selected = await promptSpecSelection(specsMap);
-      if (selected === null) {
-        // user chose "all"
-      } else if (selected.size === 0) {
-        console.log('No spec files selected. Exiting.');
-        return;
-      } else {
-        specsMap = new Map([...specsMap].filter(([name]) => selected.has(name)));
-      }
-    }
-  }
-
   writeCsvFiles(specsMap, csvOutputDir);
 
   if (csvOnly) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ash-mallick/browserstack-sync",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Sync Playwright & Cypress e2e specs to CSV and BrowserStack Test Management with FREE AI-powered test step extraction using Ollama (local)",
   "author": "Ashutosh Mallick",
   "type": "module",
@@ -42,6 +42,7 @@
     "url": ""
   },
   "dependencies": {
+    "@ash-mallick/browserstack-sync": "^1.1.3",
     "dotenv": "^16.4.5",
     "ollama": "^0.6.3"
   },