feat: expand ingestion across GitHub/Jira/Slack with live-demo wiring (#6)

* feat: expand ingestion across GitHub/Jira/Slack with live-demo wiring

Progress log added: docs/ways-of-working/INGESTION_FEATURE_PROGRESS_2026-04-17.md

Includes backend adapters/routes, frontend controls, shared contract updates, and test coverage for partial-failure resilience.

Test results:

- backend: cd backend && .venv/bin/python -m pytest -q -> 40 passed

- frontend: cd frontend && npm run lint && npm run build -> passed

* chore: align systems lane boundaries and drop cross-lane files from pr6

Author: chiraghontec

backend/app/api/routes/ingestion.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+
+class GitHubClientError(RuntimeError):
+    pass
+
+
+class GitHubClient:
+    def __init__(
+        self,
+        *,
+        token: str,
+        api_base_url: str = "https://api.github.com",
+        timeout_seconds: float = 15.0,
+    ) -> None:
+        self.token = token
+        self.api_base_url = api_base_url.rstrip("/")
+        self.timeout_seconds = timeout_seconds
+
+    @classmethod
+    def from_env(cls) -> "GitHubClient":
+        token = os.getenv("GITHUB_TOKEN", "").strip()
+        api_base_url = os.getenv("GITHUB_API_BASE_URL", "https://api.github.com").strip()
+
+        if not token:
+            raise GitHubClientError("GITHUB_TOKEN is not configured")
+
+        return cls(token=token, api_base_url=api_base_url or "https://api.github.com")
+
+    def fetch_issue(self, *, repository: str, issue_number: int) -> dict[str, Any]:
+        normalized_repo = repository.strip()
+        if not normalized_repo:
+            raise GitHubClientError("repository is required")
+        if issue_number <= 0:
+            raise GitHubClientError("issue_number must be a positive integer")
+
+        url = f"{self.api_base_url}/repos/{normalized_repo}/issues/{issue_number}"
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+
+        try:
+            with httpx.Client(timeout=self.timeout_seconds) as client:
+                response = client.get(url, headers=headers)
+        except httpx.HTTPError as exc:
+            raise GitHubClientError(f"GitHub request failed: {exc}") from exc
+
+        if response.status_code in {401, 403}:
+            raise GitHubClientError("GitHub issue fetch failed: authentication or permission error")
+        if response.status_code == 404:
+            raise GitHubClientError(f"GitHub issue {normalized_repo}#{issue_number} was not found")
+        if response.status_code >= 500:
+            raise GitHubClientError(f"GitHub service error while fetching {normalized_repo}#{issue_number}")
+        if response.status_code >= 400:
+            raise GitHubClientError(f"GitHub issue fetch failed with status {response.status_code}")
+
+        body = response.json()
+        issue_url = str(body.get("html_url", "")).strip() or f"https://github.com/{normalized_repo}/issues/{issue_number}"
+        title = str(body.get("title", "")).strip()
+        state = str(body.get("state", "unknown")).strip() or "unknown"
+        issue_body = str(body.get("body", "")).strip()
+
+        return {
+            "repository": normalized_repo,
+            "number": issue_number,
+            "title": title,
+            "state": state,
+            "url": issue_url,
+            "body": issue_body,
+        }

backend/src/adapters/github_client.py

@@ -24,6 +24,13 @@ def __init__(
         self.verify_ssl = verify_ssl
         self.timeout_seconds = timeout_seconds
 
+    _SEVERITY_TO_ID = {
+        "critical": 1,
+        "high": 2,
+        "medium": 3,
+        "low": 4,
+    }
+
     @classmethod
     def from_env(cls) -> "IrisClient":
         base_url = os.getenv("IRIS_BASE_URL", "").strip()
@@ -44,6 +51,43 @@ def _headers(self) -> dict[str, str]:
             "Content-Type": "application/json",
         }
 
+    def _normalize_case_payload(
+        self,
+        *,
+        case_payload: dict[str, Any],
+        fallback_case_id: str,
+        fallback_case_name: str,
+        fallback_description: str,
+        fallback_severity: str,
+        fallback_tags: list[str] | None = None,
+    ) -> dict[str, Any]:
+        case_id = str(case_payload.get("case_id", case_payload.get("id", fallback_case_id)))
+        return {
+            "source_system": "iris",
+            "case_id": case_id,
+            "report_id": str(case_payload.get("report_id", case_payload.get("id", case_id))),
+            "report_url": case_payload.get("report_url") or f"{self.base_url}/case/{case_id}",
+            "ingested_at": case_payload.get("modification_date") or case_payload.get("created_at"),
+            "case_name": case_payload.get("case_name") or case_payload.get("name") or fallback_case_name,
+            "short_description": case_payload.get("case_description")
+            or case_payload.get("description")
+            or fallback_description,
+            "severity": str(case_payload.get("severity", fallback_severity)),
+            "tags": case_payload.get("tags") or fallback_tags or [],
+            "iocs": case_payload.get("iocs", []),
+            "timeline": case_payload.get("timeline", []),
+        }
+
+    def _severity_id_from_label(self, severity: str) -> int:
+        normalized = severity.strip().lower()
+        if normalized in self._SEVERITY_TO_ID:
+            return self._SEVERITY_TO_ID[normalized]
+
+        if normalized.isdigit() and int(normalized) > 0:
+            return int(normalized)
+
+        return self._SEVERITY_TO_ID["medium"]
+
     def _extract_case_payload(self, payload: Any, case_id: str) -> dict[str, Any]:
         if isinstance(payload, dict):
             data = payload.get("data", payload)
@@ -77,25 +121,83 @@ def fetch_case(self, case_id: str) -> dict[str, Any]:
 
                     payload = response.json()
                     case_payload = self._extract_case_payload(payload, case_id)
-                    return {
-                        "source_system": "iris",
-                        "case_id": str(case_payload.get("case_id", case_payload.get("id", case_id))),
-                        "report_id": str(case_payload.get("report_id", case_payload.get("id", case_id))),
-                        "report_url": case_payload.get("report_url") or f"{self.base_url}/case/{case_id}",
-                        "ingested_at": case_payload.get("modification_date") or case_payload.get("created_at"),
-                        "case_name": case_payload.get("case_name")
-                        or case_payload.get("name")
-                        or f"IRIS Case {case_id}",
-                        "short_description": case_payload.get("case_description")
-                        or case_payload.get("description")
-                        or "No case description provided.",
-                        "severity": str(case_payload.get("severity", "unknown")),
-                        "tags": case_payload.get("tags", []),
-                        "iocs": case_payload.get("iocs", []),
-                        "timeline": case_payload.get("timeline", []),
-                    }
+                    return self._normalize_case_payload(
+                        case_payload=case_payload,
+                        fallback_case_id=case_id,
+                        fallback_case_name=f"IRIS Case {case_id}",
+                        fallback_description="No case description provided.",
+                        fallback_severity="unknown",
+                    )
                 except (httpx.HTTPError, ValueError, IrisClientError) as exc:
                     last_error = str(exc)
                     continue
 
         raise IrisClientError(f"Failed to fetch case {case_id} from IRIS: {last_error or 'unknown error'}")
+
+    def create_incident(
+        self,
+        *,
+        case_name: str,
+        case_description: str,
+        severity: str = "medium",
+        tags: list[str] | None = None,
+        case_customer: int = 1,
+        case_soc_id: str = "",
+        classification_id: int | None = None,
+        case_template_id: str | None = None,
+        custom_attributes: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        normalized_name = case_name.strip()
+        normalized_description = case_description.strip()
+        if not normalized_name:
+            raise IrisClientError("case_name must be provided")
+        if not normalized_description:
+            raise IrisClientError("case_description must be provided")
+
+        payload: dict[str, Any] = {
+            "case_name": normalized_name,
+            "case_description": normalized_description,
+            "case_customer": case_customer,
+            "case_soc_id": case_soc_id,
+            "severity_id": self._severity_id_from_label(severity),
+        }
+
+        if tags:
+            payload["case_tags"] = ",".join(item.strip() for item in tags if item.strip())
+        if classification_id is not None:
+            payload["classification_id"] = classification_id
+        if case_template_id:
+            payload["case_template_id"] = str(case_template_id)
+        if custom_attributes is not None:
+            payload["custom_attributes"] = custom_attributes
+
+        endpoints: list[tuple[str, str]] = [
+            ("POST", "/manage/cases/add"),
+        ]
+
+        last_error: str | None = None
+        with httpx.Client(timeout=self.timeout_seconds, verify=self.verify_ssl) as client:
+            for method, path in endpoints:
+                url = f"{self.base_url}{path}"
+                try:
+                    response = client.request(method=method, url=url, json=payload, headers=self._headers())
+                    if response.status_code >= 400:
+                        last_error = f"{method} {path} returned {response.status_code}"
+                        continue
+
+                    body = response.json()
+                    case_payload = self._extract_case_payload(body, case_id="new")
+                    created_case_id = str(case_payload.get("case_id", case_payload.get("id", "new")))
+                    return self._normalize_case_payload(
+                        case_payload=case_payload,
+                        fallback_case_id=created_case_id,
+                        fallback_case_name=normalized_name,
+                        fallback_description=normalized_description,
+                        fallback_severity=severity,
+                        fallback_tags=tags,
+                    )
+                except (httpx.HTTPError, ValueError, IrisClientError) as exc:
+                    last_error = str(exc)
+                    continue
+
+        raise IrisClientError(f"Failed to create IRIS incident: {last_error or 'unknown error'}")

backend/src/adapters/iris_client.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import os
+import re
+from typing import Any
+
+import httpx
+
+
+class JiraClientError(RuntimeError):
+    pass
+
+
+JIRA_ISSUE_KEY_PATTERN = re.compile(r"^[A-Z][A-Z0-9]*-\d+$")
+
+
+class JiraClient:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        email: str,
+        api_token: str,
+        timeout_seconds: float = 15.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.email = email
+        self.api_token = api_token
+        self.timeout_seconds = timeout_seconds
+
+    @classmethod
+    def from_env(cls) -> "JiraClient":
+        base_url = os.getenv("JIRA_BASE_URL", "").strip()
+        email = os.getenv("JIRA_EMAIL", "").strip()
+        api_token = os.getenv("JIRA_API_TOKEN", "").strip()
+
+        if not base_url:
+            raise JiraClientError("JIRA_BASE_URL is not configured")
+        if not email:
+            raise JiraClientError("JIRA_EMAIL is not configured")
+        if not api_token:
+            raise JiraClientError("JIRA_API_TOKEN is not configured")
+
+        return cls(base_url=base_url, email=email, api_token=api_token)
+
+    def fetch_issue(self, *, issue_key: str) -> dict[str, Any]:
+        normalized_issue_key = issue_key.strip().upper()
+        if not normalized_issue_key:
+            raise JiraClientError("issue_key is required")
+        if not JIRA_ISSUE_KEY_PATTERN.match(normalized_issue_key):
+            raise JiraClientError(
+                f"issue_key '{issue_key}' does not match expected format PROJECT-123"
+            )
+
+        url = f"{self.base_url}/rest/api/3/issue/{normalized_issue_key}"
+        auth = httpx.BasicAuth(username=self.email, password=self.api_token)
+        params = {
+            "fields": "summary,status,priority,assignee,description",
+        }
+
+        try:
+            with httpx.Client(timeout=self.timeout_seconds) as client:
+                response = client.get(url, params=params, auth=auth)
+        except httpx.HTTPError as exc:
+            raise JiraClientError(f"Jira request failed: {exc}") from exc
+
+        if response.status_code in {401, 403}:
+            raise JiraClientError("Jira issue fetch failed: authentication or permission error")
+        if response.status_code == 404:
+            raise JiraClientError(f"Jira issue {normalized_issue_key} was not found")
+        if response.status_code >= 500:
+            raise JiraClientError(f"Jira service error while fetching {normalized_issue_key}")
+        if response.status_code >= 400:
+            raise JiraClientError(f"Jira issue fetch failed with status {response.status_code}")
+
+        body = response.json()
+        fields = body.get("fields", {})
+        if not isinstance(fields, dict):
+            fields = {}
+
+        status_block = fields.get("status", {})
+        priority_block = fields.get("priority", {})
+        assignee_block = fields.get("assignee", {})
+
+        status_name = str(status_block.get("name", "")) if isinstance(status_block, dict) else ""
+        priority_name = str(priority_block.get("name", "")) if isinstance(priority_block, dict) else ""
+        assignee_name = str(assignee_block.get("displayName", "")) if isinstance(assignee_block, dict) else ""
+        description = fields.get("description")
+
+        return {
+            "key": normalized_issue_key,
+            "summary": str(fields.get("summary", "")),
+            "status": status_name,
+            "priority": priority_name,
+            "assignee": assignee_name,
+            "description": description,
+            "url": f"{self.base_url}/browse/{normalized_issue_key}",
+        }