@qa-gentic/stlc-agents 1.0.16 → 1.0.18

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
 # ---------------------------------------------------------------------------