@qa-gentic/stlc-agents 1.0.16 → 1.0.17

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

@@ -40,6 +40,10 @@ Within-file deduplication
                      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.
+  For cucumber.config.ts : new profiles are appended ONLY if the file already exists.
+                     If the file does not exist, the profile is skipped entirely.
+                     This prevents orphaned config files from being created when
+                     no Cucumber config yet exists on disk.
 
 Interface adapter
   The generator emits repo.updateHealed / repo.incrementSuccess / repo.getBBox etc.
@@ -140,11 +144,26 @@ def _adapt_to_helix_interface(content: str) -> str:
         'import { EnvironmentManager } from "@helper/environment/environmentManager.util";',
         'import { environment } from "@config/environment";',
     )
+    # If content uses environment.getConfig() but lacks the import, add it after the last import line
+    if "environment.getConfig()" in content and 'from "@config/environment"' not in content:
+        import_insert = 'import { environment } from "@config/environment";'
+        # Insert after the last import statement
+        last_import = content.rfind("\nimport ")
+        if last_import != -1:
+            end_of_line = content.find("\n", last_import + 1)
+            if end_of_line != -1:
+                content = content[:end_of_line + 1] + import_insert + "\n" + content[end_of_line + 1:]
     content = re.sub(r"\s*this\.env\s*=\s*new EnvironmentManager\(\);?\s*\n", "\n", content)
     content = content.replace("new EnvironmentManager()", "environment")
     content = content.replace("this.env.getBaseUrl()",    "environment.getConfig().baseUrl")
     content = re.sub(r"this\.env\.getPath\(['\"]([^'\"]+)['\"]\)", r'"\1"', content)
 
+    # Fix super() — cannot access this before super() in TS
+    content = content.replace(
+        "super(page ?? this.page);",
+        "super(page ?? fixture().page);",
+    )
+
     return content
 
 
@@ -162,11 +181,22 @@ def _resolve_destination(helix_root: Path, file_key: str) -> Path:
     if _STEPS_RE.search(key):
         return helix_root / "src" / "test" / "steps" / Path(key).name
     if _LOCATOR_RE.search(key):
-        parts = Path(key).parts
-        stem = next(
-            (p for p in parts if p not in ("src", "pages", "locators", "utils") and not p.endswith(".ts")),
-            "page",
-        )
+        # Extract the page/feature name from the path
+        # Input: src/pages/login-page/locators.ts or src/locators/login-page.locators.ts
+        # Output stem: login-page
+        path_obj = Path(key)
+        
+        # First try: if filename is exactly 'locators.ts', use parent directory name
+        if path_obj.name == "locators.ts" and path_obj.parent.name:
+            stem = path_obj.parent.name
+        else:
+            # Otherwise extract stem from filename
+            fname = path_obj.name
+            stem = re.sub(r"\.locators\.ts$", "", fname)
+            stem = re.sub(r"\.ts$", "", stem)
+            if not stem or stem in ("src", "locators", "pages", "utils"):
+                stem = "page"
+        
         return helix_root / "src" / "locators" / f"{stem}.locators.ts"
     if _PAGE_RE.search(key):
         return helix_root / "src" / "pages" / Path(key).name
@@ -242,7 +272,7 @@ def _collect_all_scenario_titles(features_dir: Path, exclude_file: Path | None =
     return titles
 
 
-
+def _collect_all_step_patterns(steps_dir: Path, exclude_file: Path | None = None) -> set[str]:
     """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()
@@ -627,29 +657,31 @@ def write_files_to_helix(
                 skipped.append({"file_key": file_key, "dest": dest_rel, "reason": str(exc)})
             continue
 
-        # ── Cucumber config: append profile, skip duplicate ────────────────
+        # ── Cucumber config: append profile only if file exists, never create ────────────
         if _CUCUMBER_RE.search(file_key):
+            if not dest.exists():
+                # RULE: if cucumber config does not exist, skip creation
+                skipped.append({
+                    "file_key": file_key, "dest": dest_rel,
+                    "reason": "cucumber.config.ts does not exist; only append to existing configs",
+                })
+                continue
             try:
-                if dest.exists():
-                    existing_text  = dest.read_text(encoding="utf-8")
-                    profile_match  = re.match(r"\s*(\w+)\s*:", content.strip())
-                    profile_name   = profile_match.group(1) if profile_match else None
-                    if profile_name and profile_name in existing_text:
-                        skipped.append({
-                            "file_key": file_key, "dest": dest_rel,
-                            "reason": f"profile '{profile_name}' already exists in cucumber.config.ts",
-                        })
-                        continue
-                    dest.write_text(
-                        existing_text.rstrip() + "\n\n// --- generated profile ---\n" + content,
-                        encoding="utf-8",
-                    )
-                    written.append({"file_key": file_key, "dest": dest_rel,
-                                    "bytes": len(content.encode()), "action": "appended"})
-                else:
-                    dest.write_text(content, encoding="utf-8")
-                    written.append({"file_key": file_key, "dest": dest_rel,
-                                    "bytes": len(content.encode()), "action": "created"})
+                existing_text  = dest.read_text(encoding="utf-8")
+                profile_match  = re.match(r"\s*(\w+)\s*:", content.strip())
+                profile_name   = profile_match.group(1) if profile_match else None
+                if profile_name and profile_name in existing_text:
+                    skipped.append({
+                        "file_key": file_key, "dest": dest_rel,
+                        "reason": f"profile '{profile_name}' already exists in cucumber.config.ts",
+                    })
+                    continue
+                dest.write_text(
+                    existing_text.rstrip() + "\n\n// --- generated profile ---\n" + content,
+                    encoding="utf-8",
+                )
+                written.append({"file_key": file_key, "dest": dest_rel,
+                                "bytes": len(content.encode()), "action": "appended"})
             except OSError as exc:
                 skipped.append({"file_key": file_key, "dest": dest_rel, "reason": str(exc)})
             continue
@@ -867,4 +899,4 @@ def list_helix_tree(helix_root: str) -> dict[str, Any]:
         else:
             tree["other"].append(rel)
 
-    return {"success": True, "helix_root": str(root), "tree": tree}
+    return {"success": True, "helix_root": str(root), "tree": tree}

package/src/stlc_agents/agent_jira_manager/server.py

@@ -34,6 +34,7 @@ from stlc_agents.agent_jira_manager.tools.jira_workitem import (
     create_test_case as _create_test_case,
     link_test_cases_to_issue as _link_test_cases,
     get_linked_test_cases as _get_linked_test_cases,
+    attach_gherkin_to_issue as _attach_gherkin,
 )
 
 load_dotenv()
@@ -148,9 +149,25 @@ def _validate_linked_test_cases_response(result: dict) -> dict:
 
 
 # ---------------------------------------------------------------------------
-# Tool definitions
+# Deduplication helper
 # ---------------------------------------------------------------------------
 
+_TC_STOP_WORDS = frozenset({
+    "verify", "ensure", "validate", "check", "test", "the", "a", "an",
+    "that", "is", "are", "can", "user", "should", "able", "to", "with",
+})
+
+
+def _normalise_summary(summary: str) -> str:
+    """Lowercase, strip punctuation, remove stop words — for dedup comparison."""
+    import re
+    cleaned = re.sub(r"[^a-z0-9\s]", "", summary.lower())
+    tokens = [w for w in cleaned.split() if w not in _TC_STOP_WORDS]
+    return " ".join(tokens)
+
+
+
+
 @app.list_tools()
 async def list_tools() -> list[types.Tool]:
     return [
@@ -275,6 +292,116 @@ async def list_tools() -> list[types.Tool]:
                 "required": ["issue_key"],
             },
         ),
+        types.Tool(
+            name="attach_gherkin_to_jira_issue",
+            description=(
+                "Upload a validated .feature file as an attachment on a Jira issue. "
+                "Use this after generate_gherkin + validate_gherkin_content to link the "
+                "Gherkin artefact back to the source Jira issue — mirrors the ADO "
+                "attach_gherkin_to_work_item / attach_gherkin_to_feature tools. "
+                "File is named {issue_key}_{summary_kebab}_regression.feature automatically. "
+                "Requires the Jira OAuth token to have 'write:jira-work' scope."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "issue_key": {
+                        "type": "string",
+                        "description": "Jira issue key, e.g. 'PROJ-123'",
+                    },
+                    "gherkin_content": {
+                        "type": "string",
+                        "description": "Complete validated .feature file content",
+                    },
+                    "cloud_id": {
+                        "type": "string",
+                        "description": "Atlassian cloud ID. Leave blank to use JIRA_CLOUD_ID env var.",
+                    },
+                },
+                "required": ["issue_key", "gherkin_content"],
+            },
+        ),
+        types.Tool(
+            name="create_deduped_test_cases",            description=(
+                "Create test cases in Jira, skipping any whose summary already exists as a "
+                "linked test case on the issue. "
+                "Internally calls get_linked_test_cases, filters the incoming batch against "
+                "existing summaries (case-insensitive, stop-word-normalised), then calls "
+                "create_and_link_test_cases on the net-new subset only. "
+                "Use this instead of create_and_link_test_cases for webhook/headless runs "
+                "where re-triggers would otherwise produce duplicates. "
+                "Returns skipped_count, created_count, and the full create result."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "issue_key": {
+                        "type": "string",
+                        "description": "Jira issue key to link test cases to, e.g. 'PROJ-123'",
+                    },
+                    "cloud_id": {
+                        "type": "string",
+                        "description": "Atlassian cloud ID. Leave blank to use JIRA_CLOUD_ID env var.",
+                    },
+                    "test_cases": {
+                        "type": "array",
+                        "description": "Full proposed test case batch (duplicates will be filtered out)",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "summary": {"type": "string", "description": "Test case title/summary"},
+                                "priority": {"type": "string", "description": "Highest|High|Medium|Low|Lowest"},
+                                "steps": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "action": {"type": "string"},
+                                            "expected_result": {"type": "string"},
+                                        },
+                                        "required": ["action", "expected_result"],
+                                    },
+                                },
+                            },
+                            "required": ["summary", "steps"],
+                        },
+                    },
+                },
+                "required": ["issue_key", "test_cases"],
+            },
+        ),
+        types.Tool(
+            name="attach_gherkin_to_issue",
+            description=(
+                "Upload and attach a validated .feature file to a Jira issue as an attachment. "
+                "File is named {issue_key}_{summary_kebab}_regression.feature automatically. "
+                "Use this after validate_gherkin_content passes. "
+                "Called by the pipeline's Jira Gherkin path to link the .feature back to "
+                "the Jira issue instead of saving to disk only."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "issue_key": {
+                        "type": "string",
+                        "description": "Jira issue key, e.g. 'PROJ-123'",
+                    },
+                    "gherkin_content": {
+                        "type": "string",
+                        "description": "Validated .feature file content",
+                    },
+                    "issue_summary": {
+                        "type": "string",
+                        "description": "Issue summary used in the filename (optional)",
+                    },
+                    "cloud_id": {
+                        "type": "string",
+                        "description": "Atlassian cloud ID. Leave blank to use JIRA_CLOUD_ID env var.",
+                    },
+                },
+                "required": ["issue_key", "gherkin_content"],
+            },
+        ),
     ]
 
 
@@ -420,6 +547,26 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
                 },
             }
 
+        elif name == "attach_gherkin_to_jira_issue":
+            issue_key = arguments["issue_key"]
+            gherkin_content = arguments["gherkin_content"]
+
+            # Fetch issue summary for filename (best-effort)
+            issue_summary = ""
+            try:
+                peek = await asyncio.to_thread(_fetch_work_item, cloud_id, issue_key)
+                issue_summary = (peek.get("work_item") or {}).get("summary", "")
+            except Exception:
+                pass
+
+            result = await asyncio.to_thread(
+                _attach_gherkin,
+                cloud_id,
+                issue_key,
+                gherkin_content,
+                issue_summary,
+            )
+
         elif name == "get_linked_test_cases":
             result = await asyncio.to_thread(
                 _get_linked_test_cases,
@@ -428,6 +575,66 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
             )
             result["_validation"] = _validate_linked_test_cases_response(result)
 
+        elif name == "create_deduped_test_cases":
+            issue_key = arguments["issue_key"]
+            proposed = arguments["test_cases"]
+
+            # Normalise title/summary on input
+            for tc in proposed:
+                if "title" in tc and "summary" not in tc:
+                    tc["summary"] = tc.pop("title")
+
+            # Step 1: fetch existing linked TCs
+            existing_result = await asyncio.to_thread(
+                _get_linked_test_cases, cloud_id, issue_key
+            )
+            existing_summaries: set[str] = {
+                _normalise_summary(tc.get("summary", ""))
+                for tc in existing_result.get("test_cases", [])
+            }
+
+            # Step 2: filter — keep only net-new
+            net_new = [
+                tc for tc in proposed
+                if _normalise_summary(tc.get("summary", "")) not in existing_summaries
+            ]
+            skipped = len(proposed) - len(net_new)
+
+            if not net_new:
+                result = {
+                    "status": "all_duplicates",
+                    "skipped_count": skipped,
+                    "created_count": 0,
+                    "message": (
+                        f"All {skipped} proposed test case(s) already exist as linked "
+                        "test cases on this issue. Nothing was created."
+                    ),
+                }
+            else:
+                # Step 3: delegate to create_and_link_test_cases
+                create_result_raw = await call_tool("create_and_link_test_cases", {
+                    "issue_key":  issue_key,
+                    "cloud_id":   cloud_id,
+                    "test_cases": net_new,
+                    "confirmed":  True,
+                })
+                inner = json.loads(create_result_raw[0].text)
+                result = {
+                    "status": "ok",
+                    "skipped_count": skipped,
+                    "created_count": len(net_new),
+                    "create_result": inner,
+                }
+
+        elif name == "attach_gherkin_to_issue":
+            result = await asyncio.to_thread(
+                _attach_gherkin,
+                cloud_id,
+                arguments["issue_key"],
+                arguments["gherkin_content"],
+                arguments.get("issue_summary", ""),
+            )
+
         else:
             result = {"error": f"Unknown tool: {name}"}
 
@@ -465,4 +672,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/src/stlc_agents/agent_jira_manager/tools/jira_workitem.py

@@ -8,6 +8,7 @@ Public API:
   create_test_case(cloud_id, project_key, title, steps, priority, labels, epic_link) -> dict
   link_test_cases_to_issue(cloud_id, issue_key, tc_keys)  -> dict
   get_linked_test_cases(cloud_id, issue_key)              -> dict
+  attach_gherkin_to_issue(cloud_id, issue_key, gherkin_content, file_name) -> dict
 
 Jira REST v3 base: https://api.atlassian.com/ex/jira/{cloudId}/rest/api/3
 """
@@ -280,6 +281,41 @@ def get_linked_test_cases(cloud_id: str, issue_key: str) -> dict:
     }
 
 
+# ---------------------------------------------------------------------------
+# attach_gherkin_to_issue
+# ---------------------------------------------------------------------------
+
+def attach_gherkin_to_issue(cloud_id: str, issue_key: str, gherkin_content: str, file_name: str = "feature.feature") -> dict:
+    """Attach a .feature file to a Jira issue.
+    
+    Args:
+        cloud_id: Jira cloud ID
+        issue_key: Issue key (e.g. PROJ-123)
+        gherkin_content: Full Gherkin feature file content
+        file_name: Name of the file to attach (default: feature.feature)
+    
+    Returns:
+        dict with attachment metadata
+    """
+    headers = get_auth_headers()
+    
+    # Upload attachment
+    url = f"{_base(cloud_id)}/issue/{issue_key}/attachments"
+    files = {"file": (file_name, gherkin_content, "text/plain")}
+    
+    resp = requests.post(url, headers=headers, files=files, timeout=30)
+    resp.raise_for_status()
+    data = resp.json()
+    
+    attachment = (data.get("results") or [{}])[0] if data.get("results") else {}
+    return {
+        "issue_key": issue_key,
+        "file_name": file_name,
+        "attachment_id": attachment.get("id", ""),
+        "success": bool(attachment.get("id")),
+    }
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------