@qa-gentic/stlc-agents 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qa-gentic/stlc-agents",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "QA STLC Agents — MCP servers + skills for AI-powered test case, Gherkin, and Playwright generation against Azure DevOps. Works with Claude Code, GitHub Copilot, Cursor, Windsurf.",
   "keywords": [
     "playwright",

package/src/stlc_agents/agent_helix_writer/tools/helix_write.py

@@ -27,10 +27,19 @@ Infrastructure file protection
 Within-file deduplication
   For locators.ts  : new const-object entries are merged; duplicate keys skipped.
   For *.steps.ts   : new step blocks are appended; duplicate regex patterns skipped.
+                     Cross-file deduplication is also applied: before writing any
+                     *.steps.ts, ALL other *.steps.ts files in src/test/steps/ are
+                     scanned for existing patterns.  A pattern already defined in
+                     any sibling file is treated as a duplicate — the block is
+                     dropped from the incoming content.  This prevents the
+                     "Multiple step definitions match" Cucumber error.
   For *.page.ts    : new async methods are appended; duplicate method names skipped.
   For *.feature    : new Scenario blocks are appended; duplicate titles skipped.
-                     When a title matches, the existing scenario (and its original step
-                     wording) is kept — the generated version is dropped entirely.
+                     Cross-file deduplication is also applied: before writing any
+                     *.feature file, ALL other *.feature files in
+                     src/test/features/ are scanned for existing scenario titles.
+                     A title already present in any sibling file is treated as a
+                     duplicate and dropped from the incoming content.
 
 Interface adapter
   The generator emits repo.updateHealed / repo.incrementSuccess / repo.getBBox etc.
@@ -211,9 +220,53 @@ def _merge_locators(existing: str, generated: str) -> tuple[str, list[str], list
     return merged, added, skipped
 
 
-def _merge_steps(existing: str, generated: str) -> tuple[str, list[str], list[str]]:
-    """Append step blocks whose regex pattern is not already in existing."""
+def _collect_all_scenario_titles(features_dir: Path, exclude_file: Path | None = None) -> set[str]:
+    """Return every scenario title (lower-cased) defined in all *.feature files
+    in features_dir, optionally excluding one file (the one currently being written)."""
+    _title_re = re.compile(
+        r"^\s*Scenario(?:\s+Outline)?\s*:\s*(.+)$", re.MULTILINE | re.IGNORECASE
+    )
+    titles: set[str] = set()
+    if not features_dir.is_dir():
+        return titles
+    for f in features_dir.glob("*.feature"):
+        if exclude_file and f.resolve() == exclude_file.resolve():
+            continue
+        try:
+            titles.update(
+                m.group(1).strip().lower()
+                for m in _title_re.finditer(f.read_text(encoding="utf-8"))
+            )
+        except OSError:
+            pass
+    return titles
+
+
+
+    """Return every /^pattern$/ defined in all *.steps.ts files in steps_dir,
+    optionally excluding one file (the one currently being written)."""
+    patterns: set[str] = set()
+    if not steps_dir.is_dir():
+        return patterns
+    for f in steps_dir.glob("*.steps.ts"):
+        if exclude_file and f.resolve() == exclude_file.resolve():
+            continue
+        try:
+            patterns.update(re.findall(r"/\^([^/]+)\$/", f.read_text(encoding="utf-8")))
+        except OSError:
+            pass
+    return patterns
+
+
+def _merge_steps(
+    existing: str,
+    generated: str,
+    cross_file_patterns: set[str] | None = None,
+) -> tuple[str, list[str], list[str]]:
+    """Append step blocks whose regex pattern is not already in existing or in
+    any sibling step file (cross_file_patterns)."""
     existing_patterns = set(re.findall(r"/\^([^/]+)\$/", existing))
+    forbidden = existing_patterns | (cross_file_patterns or set())
 
     step_block_re = re.compile(r"^(Given|When|Then)\(", re.MULTILINE)
     parts = step_block_re.split(generated)
@@ -233,11 +286,14 @@ def _merge_steps(existing: str, generated: str) -> tuple[str, list[str], list[st
     for _kw, block in blocks:
         pat_match = re.search(r"/\^([^/]+)\$/", block)
         pattern = pat_match.group(1) if pat_match else block[:40]
-        if pattern in existing_patterns:
+        if pattern in forbidden:
             skipped.append(pattern)
         else:
             new_blocks.append(block)
             added.append(pattern)
+            # Track newly added so subsequent blocks in the same batch
+            # don't get written twice either
+            forbidden.add(pattern)
 
     merged = existing.rstrip() + ("\n\n" + "\n".join(new_blocks) if new_blocks else "") + "\n"
     return merged, added, skipped
@@ -302,9 +358,14 @@ def _parse_feature_blocks(content: str) -> tuple[str, list[str]]:
     return "".join(header), blocks
 
 
-def _merge_feature_scenarios(existing: str, generated: str) -> tuple[str, list[str], list[str]]:
+def _merge_feature_scenarios(
+    existing: str,
+    generated: str,
+    cross_file_titles: set[str] | None = None,
+) -> tuple[str, list[str], list[str]]:
     """
-    Append Scenario / Scenario Outline blocks whose titles are not already present.
+    Append Scenario / Scenario Outline blocks whose titles are not already present
+    in this file or in any sibling feature file (cross_file_titles).
 
     Deduplication is by title (case-insensitive exact match).  When a collision is
     found the existing scenario — including its original step wording — is kept and
@@ -322,6 +383,7 @@ def _merge_feature_scenarios(existing: str, generated: str) -> tuple[str, list[s
     existing_titles = {
         m.group(1).strip().lower() for m in _scenario_title_re.finditer(existing)
     }
+    forbidden = existing_titles | (cross_file_titles or set())
 
     _, gen_blocks = _parse_feature_blocks(generated)
 
@@ -334,11 +396,12 @@ def _merge_feature_scenarios(existing: str, generated: str) -> tuple[str, list[s
         if not title_match:
             continue
         title = title_match.group(1).strip()
-        if title.lower() in existing_titles:
+        if title.lower() in forbidden:
             skipped.append(title)
         else:
             new_blocks.append(block.rstrip())
             added.append(title)
+            forbidden.add(title.lower())
 
     if not new_blocks:
         return existing, added, skipped
@@ -596,7 +659,9 @@ def write_files_to_helix(
             try:
                 if dest.exists():
                     existing_text = dest.read_text(encoding="utf-8")
-                    merged, added, dup = _merge_feature_scenarios(existing_text, content)
+                    features_dir = root / "src" / "test" / "features"
+                    cross = _collect_all_scenario_titles(features_dir, exclude_file=dest)
+                    merged, added, dup = _merge_feature_scenarios(existing_text, content, cross)
                     deduplication[dest_rel] = {
                         "type": "feature",
                         "added_scenarios":   added,
@@ -629,7 +694,9 @@ def write_files_to_helix(
                     "type": "locators", "added_keys": added, "skipped_keys": dup,
                 }
             elif _STEPS_RE.search(file_key):
-                merged, added, dup = _merge_steps(existing_text, content)
+                steps_dir = root / "src" / "test" / "steps"
+                cross = _collect_all_step_patterns(steps_dir, exclude_file=dest)
+                merged, added, dup = _merge_steps(existing_text, content, cross)
                 deduplication[dest_rel] = {
                     "type": "steps", "added_patterns": added, "skipped_patterns": dup,
                 }
@@ -731,21 +798,28 @@ def update_helix_file(
             merged, added, dup = _merge_locators(existing_text, adapted)
             dedup = {"type": "locators", "added_keys": added, "skipped_keys": dup}
         elif _STEPS_RE.search(file_key):
-            merged, added, dup = _merge_steps(existing_text, adapted)
+            steps_dir = root / "src" / "test" / "steps"
+            cross = _collect_all_step_patterns(steps_dir, exclude_file=target)
+            merged, added, dup = _merge_steps(existing_text, adapted, cross)
             dedup = {"type": "steps", "added_patterns": added, "skipped_patterns": dup}
         elif _PAGE_RE.search(file_key):
             merged, added, dup = _merge_page_methods(existing_text, adapted)
             dedup = {"type": "page", "added_methods": added, "skipped_methods": dup}
         elif _FEATURE_RE.search(file_key):
-            # Feature files are the Gherkin source of truth — always overwrite
-            target.write_text(adapted, encoding="utf-8")
-            return {
-                "success": True,
-                "path": dest_rel,
-                "action": "overwritten",
-                "bytes": len(adapted.encode()),
-                "deduplication": None,
-            }
+            features_dir = root / "src" / "test" / "features"
+            cross = _collect_all_scenario_titles(features_dir, exclude_file=target)
+            if not target.exists():
+                target.write_text(adapted, encoding="utf-8")
+                return {
+                    "success": True,
+                    "path": dest_rel,
+                    "action": "created",
+                    "bytes": len(adapted.encode()),
+                    "deduplication": None,
+                }
+            existing_text = target.read_text(encoding="utf-8")
+            merged, added, dup = _merge_feature_scenarios(existing_text, adapted, cross)
+            dedup = {"type": "feature", "added_scenarios": added, "skipped_scenarios": dup}
         else:
             merged = adapted
             dedup  = {"type": "unknown", "action": "overwritten"}