igel-qe-core 1.0.3 → 1.0.7

package/{knowledge_base → src}/connectors/confluence_connector.py

@@ -8,8 +8,8 @@ from urllib.parse import unquote_plus
 
 import httpx
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
+from src.config import cfg
+from src.connectors.base import BaseConnector
 
 logger = logging.getLogger(__name__)
 
@@ -140,7 +140,7 @@ class ConfluenceConnector(BaseConnector):
     def ingest_to_kg(self, items: list[dict]) -> int:
         if not items:
             return 0
-        from knowledge_base.db.client import get_conn
+        from src.db.client import get_conn
         import json
         count = 0
         with get_conn() as conn:
@@ -161,5 +161,5 @@ class ConfluenceConnector(BaseConnector):
         return count
 
     def ingest_to_rag(self, items: list[dict]) -> int:
-        from knowledge_base.ingestion.web_ingest import ingest_web_items
+        from src.ingestion.web_ingest import ingest_web_items
         return ingest_web_items(items, source_label="confluence")

package/{knowledge_base → src}/connectors/jira_connector.py

@@ -7,8 +7,8 @@ from datetime import datetime
 
 import httpx
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
+from src.config import cfg
+from src.connectors.base import BaseConnector
 
 logger = logging.getLogger(__name__)
 
@@ -112,13 +112,13 @@ class JiraConnector(BaseConnector):
             logger.warning("JIRA sync failed: %s", exc)
             return []
 
-    def get_test_requirement(self, jira_key: str) -> 'knowledge_base.models.test_requirement.TestRequirement':
+    def get_test_requirement(self, jira_key: str) -> 'src.models.test_requirement.TestRequirement':
         """Fetch a specific Jira issue and parse its manual Xray test steps."""
         if not self.connect():
             raise Exception("Jira is not configured or disabled.")
             
         # We import here to avoid circular imports during init
-        from knowledge_base.models.test_requirement import TestRequirement, TestStep
+        from src.models.test_requirement import TestRequirement, TestStep
         
         try:
             with httpx.Client(timeout=30.0) as client:
@@ -179,15 +179,11 @@ class JiraConnector(BaseConnector):
         except Exception as exc:
             logger.error(f"Failed to get test requirement {jira_key}: {exc}")
             raise
-        except Exception as exc:
-            logger.warning("JIRA sync failed: %s", exc)
-            raise
-        return items
 
     def ingest_to_kg(self, items: list[dict]) -> int:
         if not items:
             return 0
-        from knowledge_base.db.client import get_conn
+        from src.db.client import get_conn
         count = 0
         with get_conn() as conn:
             with conn.cursor() as cur:
@@ -220,7 +216,7 @@ class JiraConnector(BaseConnector):
                 resp = client.get(
                     f"{cfg.JIRA_URL.rstrip('/')}/rest/api/2/issue/{key}",
                     params={"fields": "summary,description,status,issuetype,comment"},
-                    auth=(cfg.JIRA_USERNAME, cfg.JIRA_API_TOKEN),
+                    **self._get_auth_kwargs(),
                 )
                 resp.raise_for_status()
                 data = resp.json()
@@ -243,7 +239,7 @@ class JiraConnector(BaseConnector):
             return None
 
     def ingest_to_rag(self, items: list[dict]) -> int:
-        from knowledge_base.ingestion.web_ingest import ingest_web_items
+        from src.ingestion.web_ingest import ingest_web_items
         web_items = []
         for item in items:
             web_items.append({

package/{knowledge_base → src}/connectors/kb_igel_connector.py

@@ -7,10 +7,10 @@ from datetime import datetime
 from typing import Any
 from urllib.parse import urlparse
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
-from knowledge_base.connectors.web_fetcher import fetch_url, search_confluence_site
-from knowledge_base.parsers.html_parser import parse_html_page
+from src.config import cfg
+from src.connectors.base import BaseConnector
+from src.connectors.web_fetcher import fetch_url, search_confluence_site
+from src.parsers.html_parser import parse_html_page
 
 logger = logging.getLogger(__name__)
 
@@ -117,7 +117,7 @@ class KbIgelConnector(BaseConnector):
     def ingest_to_kg(self, items: list[dict]) -> int:
         if not items:
             return 0
-        from knowledge_base.db.client import get_conn
+        from src.db.client import get_conn
         import json
         count = 0
         with get_conn() as conn:
@@ -140,6 +140,6 @@ class KbIgelConnector(BaseConnector):
         return count
 
     def ingest_to_rag(self, items: list[dict]) -> int:
-        from knowledge_base.ingestion.web_ingest import ingest_web_items
+        from src.ingestion.web_ingest import ingest_web_items
 
         return ingest_web_items(items, source_label="kb.igel.com")

package/{knowledge_base → src}/connectors/query_bridge.py

@@ -6,9 +6,9 @@ import logging
 from dataclasses import dataclass, field
 from time import perf_counter
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
-from knowledge_base.core.circuit_breaker import is_open, record_failure, record_success
+from src.config import cfg
+from src.connectors.base import BaseConnector
+from src.core.circuit_breaker import is_open, record_failure, record_success
 
 logger = logging.getLogger(__name__)
 
@@ -41,28 +41,28 @@ def _mcp_sources() -> list[str]:
 def _connector_for(name: str):
     # Keep this registry aligned with sync_scheduler CONNECTORS.
     if name == "jira":
-        from knowledge_base.connectors.jira_connector import JiraConnector
+        from src.connectors.jira_connector import JiraConnector
         return JiraConnector()
     if name == "confluence":
-        from knowledge_base.connectors.confluence_connector import ConfluenceConnector
+        from src.connectors.confluence_connector import ConfluenceConnector
         return ConfluenceConnector()
     if name == "bitbucket":
-        from knowledge_base.connectors.bitbucket_connector import BitbucketConnector
+        from src.connectors.bitbucket_connector import BitbucketConnector
         return BitbucketConnector()
     if name == "teamcity":
-        from knowledge_base.connectors.teamcity_connector import TeamCityConnector
+        from src.connectors.teamcity_connector import TeamCityConnector
         return TeamCityConnector()
     if name == "testrail":
-        from knowledge_base.connectors.testRail_connector import TestRailConnector
+        from src.connectors.testRail_connector import TestRailConnector
         return TestRailConnector()
     if name == "servicenow":
-        from knowledge_base.connectors.serviceNow_connector import ServiceNowConnector
+        from src.connectors.serviceNow_connector import ServiceNowConnector
         return ServiceNowConnector()
     if name == "kb_igel":
-        from knowledge_base.connectors.kb_igel_connector import KbIgelConnector
+        from src.connectors.kb_igel_connector import KbIgelConnector
         return KbIgelConnector()
     if name == "community":
-        from knowledge_base.connectors.community_connector import CommunityConnector
+        from src.connectors.community_connector import CommunityConnector
         return CommunityConnector()
     logger.warning("Unsupported MCP source configured: %s", name)
     return None

package/{knowledge_base → src}/connectors/search_backends.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass, field
 from typing import Any
 from urllib.parse import quote_plus, urlparse
 
-from knowledge_base.config import cfg
+from src.config import cfg
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/connectors/serviceNow_connector.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
+from src.config import cfg
+from src.connectors.base import BaseConnector
 
 
 class ServiceNowConnector(BaseConnector):

package/{knowledge_base → src}/connectors/sync_scheduler.py

@@ -8,16 +8,17 @@ import sys
 import time
 from datetime import datetime, timezone
 
-from knowledge_base.connectors.bitbucket_connector import BitbucketConnector
-from knowledge_base.connectors.community_connector import CommunityConnector
-from knowledge_base.connectors.confluence_connector import ConfluenceConnector
-from knowledge_base.connectors.jira_connector import JiraConnector
-from knowledge_base.connectors.kb_igel_connector import KbIgelConnector
-from knowledge_base.connectors.serviceNow_connector import ServiceNowConnector
-from knowledge_base.connectors.teamcity_connector import TeamCityConnector
-from knowledge_base.connectors.testRail_connector import TestRailConnector
-from knowledge_base.db.client import init_pool
-from knowledge_base.db.connector_sync import get_last_sync, update_sync_state
+from src.connectors.bitbucket_connector import BitbucketConnector
+from src.connectors.community_connector import CommunityConnector
+from src.connectors.confluence_connector import ConfluenceConnector
+from src.connectors.jira_connector import JiraConnector
+from src.connectors.kb_igel_connector import KbIgelConnector
+from src.connectors.serviceNow_connector import ServiceNowConnector
+from src.connectors.teamcity_connector import TeamCityConnector
+from src.connectors.testRail_connector import TestRailConnector
+from src.connectors.xray_connector import XrayConnector
+from src.db.client import init_pool
+from src.db.connector_sync import get_last_sync, update_sync_state
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +26,7 @@ CONNECTORS = {
     "jira": JiraConnector,
     "confluence": ConfluenceConnector,
     "bitbucket": BitbucketConnector,
+    "xray": XrayConnector,
     "teamcity": TeamCityConnector,
     "testrail": TestRailConnector,
     "servicenow": ServiceNowConnector,

package/{knowledge_base → src}/connectors/teamcity_connector.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
+from src.config import cfg
+from src.connectors.base import BaseConnector
 
 
 class TeamCityConnector(BaseConnector):

package/{knowledge_base → src}/connectors/testRail_connector.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from knowledge_base.config import cfg
-from knowledge_base.connectors.base import BaseConnector
+from src.config import cfg
+from src.connectors.base import BaseConnector
 
 
 class TestRailConnector(BaseConnector):

package/{knowledge_base → src}/connectors/web_fetcher.py

@@ -11,7 +11,7 @@ from threading import Lock
 from typing import Optional
 from urllib.parse import quote_plus, urljoin, urlparse
 
-from knowledge_base.config import cfg
+from src.config import cfg
 
 logger = logging.getLogger(__name__)
 

package/src/connectors/xray_connector.py

@@ -0,0 +1,337 @@
+"""Xray connector — Cloud (OAuth2 client credentials) + Server/DC (API token).
+
+Supports:
+  - Xray Cloud:      client_id + client_secret → JWT token via /api/v2/authenticate
+  - Xray Server/DC:  XRAY_API_TOKEN or falls back to JIRA_API_TOKEN (Basic Auth)
+"""
+from __future__ import annotations
+
+import logging
+import time
+from datetime import datetime
+from typing import Optional
+
+import httpx
+
+from src.config import cfg
+from src.connectors.base import BaseConnector
+
+logger = logging.getLogger(__name__)
+
+_XRAY_CLOUD_AUTH_URL = "https://xray.cloud.getxray.app/api/v2/authenticate"
+_XRAY_CLOUD_BASE_URL = "https://xray.cloud.getxray.app/api/v2"
+
+
+class XrayConnector(BaseConnector):
+    """Xray test management connector (Cloud + Server/DC)."""
+
+    name = "xray"
+    enabled = cfg.XRAY_ENABLED
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._token: str | None = None
+        self._token_expiry: float = 0.0
+        self._is_cloud: bool = bool(
+            getattr(cfg, "XRAY_CLIENT_ID", "") and getattr(cfg, "XRAY_CLIENT_SECRET", "")
+        )
+
+    # ──────────────────────────────────────────────────────────────────
+    # Authentication
+    # ──────────────────────────────────────────────────────────────────
+
+    def _authenticate_cloud(self) -> str | None:
+        """Fetch a Xray Cloud JWT token using client_id + client_secret."""
+        client_id = getattr(cfg, "XRAY_CLIENT_ID", "")
+        client_secret = getattr(cfg, "XRAY_CLIENT_SECRET", "")
+        auth_url = getattr(cfg, "XRAY_CLOUD_AUTH_URL", _XRAY_CLOUD_AUTH_URL)
+
+        if not client_id or not client_secret:
+            logger.error("XRAY_CLIENT_ID or XRAY_CLIENT_SECRET not set")
+            return None
+
+        try:
+            with httpx.Client(timeout=15.0) as client:
+                resp = client.post(
+                    auth_url,
+                    json={"client_id": client_id, "client_secret": client_secret},
+                    headers={"Content-Type": "application/json"},
+                )
+                resp.raise_for_status()
+                # Xray returns a raw quoted JWT string
+                token = resp.text.strip().strip('"')
+                logger.info("Xray Cloud token obtained successfully")
+                # Xray Cloud JWT tokens are valid for 24 hours
+                self._token = token
+                self._token_expiry = time.time() + 23 * 3600
+                return token
+        except httpx.HTTPStatusError as e:
+            logger.error("Xray Cloud auth failed: HTTP %s — %s", e.response.status_code, e.response.text)
+            return None
+        except Exception as e:
+            logger.error("Xray Cloud auth error: %s", e)
+            return None
+
+    def _get_token(self) -> str | None:
+        """Return a valid token, refreshing if expired."""
+        if self._is_cloud:
+            if not self._token or time.time() >= self._token_expiry:
+                self._authenticate_cloud()
+            return self._token
+        # Server/DC: use XRAY_API_TOKEN or JIRA_API_TOKEN
+        return getattr(cfg, "XRAY_API_TOKEN", "") or cfg.JIRA_API_TOKEN
+
+    def _get_headers(self) -> dict:
+        token = self._get_token()
+        if token:
+            return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        return {"Content-Type": "application/json"}
+
+    def _base_url(self) -> str:
+        if self._is_cloud:
+            return getattr(cfg, "XRAY_CLOUD_BASE_URL", _XRAY_CLOUD_BASE_URL).rstrip("/")
+        # Server/DC uses Jira's REST namespace
+        return f"{cfg.JIRA_URL.rstrip('/')}/rest/raven/1.0/api"
+
+    def connect(self) -> bool:
+        if not self.enabled:
+            return False
+        token = self._get_token()
+        if not token:
+            logger.warning("Xray: no valid token available")
+            return False
+        return True
+
+    # ──────────────────────────────────────────────────────────────────
+    # Test Retrieval
+    # ──────────────────────────────────────────────────────────────────
+
+    def get_test(self, issue_key: str) -> Optional["src.models.test_requirement.TestRequirement"]:
+        """Fetch Xray test issue and parse its steps into a TestRequirement."""
+        if not self.connect():
+            logger.warning("Xray not connected; cannot fetch test %s", issue_key)
+            return None
+
+        from src.models.test_requirement import TestRequirement, TestStep
+
+        try:
+            with httpx.Client(timeout=20.0, headers=self._get_headers()) as client:
+                if self._is_cloud:
+                    # Xray Cloud: use GraphQL
+                    return self._get_test_cloud(client, issue_key)
+                else:
+                    # Server/DC: use Raven REST API
+                    return self._get_test_server(client, issue_key)
+        except Exception as e:
+            logger.error("Failed to fetch Xray test %s: %s", issue_key, e)
+            return None
+
+    def _get_test_server(self, client: httpx.Client, issue_key: str):
+        """Fetch test steps via Xray Server/DC REST API."""
+        from src.models.test_requirement import TestRequirement, TestStep
+
+        step_resp = client.get(f"{self._base_url()}/test/{issue_key}/step")
+        step_resp.raise_for_status()
+        steps_data = step_resp.json()
+
+        steps = []
+        for i, s in enumerate(steps_data, start=1):
+            steps.append(TestStep(
+                step_number=i,
+                action=s.get("action", {}).get("raw", "") if isinstance(s.get("action"), dict) else str(s.get("action", "")),
+                test_data=s.get("data", {}).get("raw", "") if isinstance(s.get("data"), dict) else str(s.get("data", "")),
+                expected_result=s.get("result", {}).get("raw", "") if isinstance(s.get("result"), dict) else str(s.get("result", "")),
+            ))
+
+        return TestRequirement(
+            jira_key=issue_key,
+            summary=issue_key,
+            description="",
+            steps=steps,
+        )
+
+    def _get_test_cloud(self, client: httpx.Client, issue_key: str):
+        """Fetch test steps via Xray Cloud GraphQL API."""
+        from src.models.test_requirement import TestRequirement, TestStep
+
+        query = """
+        query GetTest($issueId: String!) {
+            getTest(issueId: $issueId) {
+                issueId
+                testType { name }
+                steps {
+                    id
+                    action
+                    data
+                    result
+                }
+            }
+        }
+        """
+        resp = client.post(
+            f"{self._base_url()}/graphql",
+            json={"query": query, "variables": {"issueId": issue_key}},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        test_data = (data.get("data") or {}).get("getTest") or {}
+        raw_steps = test_data.get("steps") or []
+
+        steps = [
+            TestStep(
+                step_number=i + 1,
+                action=s.get("action") or "",
+                test_data=s.get("data") or "",
+                expected_result=s.get("result") or "",
+            )
+            for i, s in enumerate(raw_steps)
+        ]
+
+        return TestRequirement(
+            jira_key=issue_key,
+            summary=issue_key,
+            description="",
+            steps=steps,
+        )
+
+    # ──────────────────────────────────────────────────────────────────
+    # Test Execution Management
+    # ──────────────────────────────────────────────────────────────────
+
+    def create_test_execution(self, test_keys: list[str], summary: str = "AI-Generated Execution") -> str | None:
+        """Create a new Xray Test Execution issue and return the execution key."""
+        if not self.connect():
+            return None
+        try:
+            with httpx.Client(timeout=20.0, headers=self._get_headers()) as client:
+                payload = {
+                    "fields": {
+                        "summary": summary,
+                        "issuetype": {"name": "Test Execution"},
+                    }
+                }
+                if not self._is_cloud:
+                    resp = client.post(
+                        f"{cfg.JIRA_URL.rstrip('/')}/rest/api/2/issue",
+                        json=payload,
+                    )
+                    resp.raise_for_status()
+                    exec_key = resp.json().get("key")
+                    # Associate tests
+                    if exec_key and test_keys:
+                        client.post(
+                            f"{self._base_url()}/testexec/{exec_key}/test",
+                            json=test_keys,
+                        )
+                    return exec_key
+                else:
+                    # Xray Cloud: create via GraphQL
+                    mutation = """
+                    mutation CreateTestExecution($summary: String!, $testKeys: [String!]!) {
+                        createTestExecution(
+                            summary: $summary
+                            tests: $testKeys
+                        ) { issueId key }
+                    }
+                    """
+                    resp = client.post(
+                        f"{self._base_url()}/graphql",
+                        json={"query": mutation, "variables": {"summary": summary, "testKeys": test_keys}},
+                    )
+                    resp.raise_for_status()
+                    result = (resp.json().get("data") or {}).get("createTestExecution") or {}
+                    return result.get("key")
+        except Exception as e:
+            logger.error("Failed to create test execution: %s", e)
+            return None
+
+    def update_test_run(self, execution_key: str, test_key: str, status: str) -> bool:
+        """Update a test run result. Status: PASS | FAIL | TODO | EXECUTING | ABORTED."""
+        if not self.connect():
+            return False
+        valid_statuses = {"PASS", "FAIL", "TODO", "EXECUTING", "ABORTED"}
+        if status.upper() not in valid_statuses:
+            logger.warning("Invalid Xray status: %s. Must be one of %s", status, valid_statuses)
+            return False
+        try:
+            with httpx.Client(timeout=20.0, headers=self._get_headers()) as client:
+                if not self._is_cloud:
+                    resp = client.put(
+                        f"{self._base_url()}/testrun",
+                        json={
+                            "testExecIssueKey": execution_key,
+                            "testIssueKey": test_key,
+                            "status": status.upper(),
+                        },
+                    )
+                    resp.raise_for_status()
+                    return True
+                else:
+                    mutation = """
+                    mutation UpdateTestRun($executionId: String!, $testKey: String!, $status: TestRunStatusType!) {
+                        updateTestRunStatus(
+                            testExecIssueId: $executionId
+                            testIssueId: $testKey
+                            status: $status
+                        )
+                    }
+                    """
+                    resp = client.post(
+                        f"{self._base_url()}/graphql",
+                        json={
+                            "query": mutation,
+                            "variables": {
+                                "executionId": execution_key,
+                                "testKey": test_key,
+                                "status": status.upper(),
+                            },
+                        },
+                    )
+                    resp.raise_for_status()
+                    return True
+        except Exception as e:
+            logger.error("Failed to update test run %s/%s: %s", execution_key, test_key, e)
+            return False
+
+    def export_cucumber(self, test_keys: list[str]) -> str:
+        """Export Xray tests as Cucumber feature file content."""
+        if not self.connect():
+            return ""
+        try:
+            keys_param = ";".join(test_keys)
+            with httpx.Client(timeout=30.0, headers=self._get_headers()) as client:
+                if not self._is_cloud:
+                    resp = client.get(
+                        f"{self._base_url()}/test/export/cucumber",
+                        params={"keys": keys_param},
+                    )
+                else:
+                    resp = client.get(
+                        f"{self._base_url()}/export/cucumber",
+                        params={"keys": keys_param},
+                    )
+                resp.raise_for_status()
+                return resp.text
+        except Exception as e:
+            logger.error("Failed to export cucumber features: %s", e)
+            return ""
+
+    # ──────────────────────────────────────────────────────────────────
+    # BaseConnector interface
+    # ──────────────────────────────────────────────────────────────────
+
+    def sync(self, since: datetime | None = None) -> list[dict]:
+        """Not used for Xray — test data is fetched on-demand by jira_key."""
+        return []
+
+    def ingest_to_kg(self, items: list[dict]) -> int:
+        return 0
+
+    def ingest_to_rag(self, items: list[dict]) -> int:
+        return 0
+
+    def search(self, query: str, limit: int = 5, timeout: float | None = None) -> list[str]:
+        """Search Xray tests by summary (delegates to Jira connector search)."""
+        from src.connectors.jira_connector import JiraConnector
+        jira = JiraConnector()
+        return jira.search(f'issuetype = Test AND text ~ "{query}"', limit=limit, timeout=timeout)

package/{knowledge_base → src}/core/__init__.py

@@ -1,6 +1,6 @@
 """Core scoring and precedence rules."""
 
-from knowledge_base.core.confidence import flatten_confidence_for_api, score_generation
+from src.core.confidence import flatten_confidence_for_api, score_generation
 
 __all__ = [
     "flatten_confidence_for_api",