devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/alerts/jira.py

@@ -0,0 +1,96 @@
+import base64
+import json
+import urllib.request
+import urllib.error
+
+from .base import AlertChannel, AlertEnvelope, AlertSeverity, DeliveryResult
+
+
+class JiraChannel(AlertChannel):
+    channel_name = "jira"
+
+    def __init__(self, url: str, project_key: str, api_token: str, email: str) -> None:
+        self.url = url.rstrip("/")
+        self.project_key = project_key
+        self.api_token = api_token
+        self.email = email
+
+    def _build_issue_body(self, envelope: AlertEnvelope) -> dict:
+        """Build Jira issue creation request body."""
+        issue_type = "Bug" if envelope.severity == AlertSeverity.CRITICAL else "Task"
+        summary = f"[DevTorch] {envelope.title}"
+
+        # ADF (Atlassian Document Format) — plain text wrapped in doc node
+        description_adf = {
+            "version": 1,
+            "type": "doc",
+            "content": [
+                {
+                    "type": "paragraph",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": envelope.body,
+                        }
+                    ],
+                },
+                {
+                    "type": "paragraph",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"Branch: {envelope.branch} | Commit: {envelope.commit_id} | Event: {envelope.event_type}",
+                        }
+                    ],
+                },
+            ],
+        }
+
+        return {
+            "fields": {
+                "project": {"key": self.project_key},
+                "summary": summary,
+                "description": description_adf,
+                "issuetype": {"name": issue_type},
+            }
+        }
+
+    def deliver(self, envelope: AlertEnvelope) -> DeliveryResult:
+        """POST to Jira REST API v3. Basic auth with email:token."""
+        try:
+            body = self._build_issue_body(envelope)
+            data = json.dumps(body).encode("utf-8")
+
+            credentials = f"{self.email}:{self.api_token}"
+            encoded = base64.b64encode(credentials.encode("utf-8")).decode("utf-8")
+
+            api_url = f"{self.url}/rest/api/3/issue"
+            req = urllib.request.Request(
+                api_url,
+                data=data,
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Basic {encoded}",
+                    "Accept": "application/json",
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return DeliveryResult(
+                    channel=self.channel_name,
+                    success=True,
+                    response_code=resp.status,
+                )
+        except urllib.error.HTTPError as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=f"HTTP {exc.code}: {exc.reason}",
+                response_code=exc.code,
+            )
+        except Exception as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=str(exc),
+            )

devtorch_core/alerts/linear.py

@@ -0,0 +1,72 @@
+import json
+import urllib.request
+import urllib.error
+
+from .base import AlertChannel, AlertEnvelope, AlertSeverity, DeliveryResult
+
+
+class LinearChannel(AlertChannel):
+    channel_name = "linear"
+
+    def __init__(self, api_token: str, team_id: str) -> None:
+        self.api_token = api_token
+        self.team_id = team_id
+
+    def _build_issue_input(self, envelope: AlertEnvelope) -> dict:
+        """Build Linear GraphQL issue create input."""
+        priority_map = {
+            AlertSeverity.CRITICAL: 1,
+            AlertSeverity.WARNING: 2,
+            AlertSeverity.INFO: 3,
+        }
+        title = f"[DevTorch] {envelope.title}"
+        description = (
+            f"{envelope.body}\n\n"
+            f"Event: {envelope.event_type}\n"
+            f"Branch: {envelope.branch}\n"
+            f"Commit: {envelope.commit_id}"
+        )
+        return {
+            "title": title,
+            "description": description,
+            "teamId": self.team_id,
+            "priority": priority_map.get(envelope.severity, 3),
+        }
+
+    def deliver(self, envelope: AlertEnvelope) -> DeliveryResult:
+        """Create a Linear issue via GraphQL API."""
+        try:
+            issue = self._build_issue_input(envelope)
+            query = {
+                "query": "mutation IssueCreate($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id identifier } } }",
+                "variables": {"input": issue},
+            }
+            data = json.dumps(query).encode("utf-8")
+            req = urllib.request.Request(
+                "https://api.linear.app/graphql",
+                data=data,
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": self.api_token,
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return DeliveryResult(
+                    channel=self.channel_name,
+                    success=True,
+                    response_code=resp.status,
+                )
+        except urllib.error.HTTPError as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=f"HTTP {exc.code}: {exc.reason}",
+                response_code=exc.code,
+            )
+        except Exception as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=str(exc),
+            )

devtorch_core/alerts/pagerduty.py

@@ -0,0 +1,66 @@
+import json
+import urllib.request
+import urllib.error
+
+from .base import AlertChannel, AlertEnvelope, AlertSeverity, DeliveryResult
+
+_PD_SEVERITY_MAP = {
+    AlertSeverity.CRITICAL: "critical",
+    AlertSeverity.WARNING: "warning",
+    AlertSeverity.INFO: "info",
+}
+
+
+class PagerDutyChannel(AlertChannel):
+    channel_name = "pagerduty"
+    EVENTS_API_URL = "https://events.pagerduty.com/v2/enqueue"
+
+    def __init__(self, routing_key: str) -> None:
+        self.routing_key = routing_key
+
+    def _build_payload(self, envelope: AlertEnvelope) -> dict:
+        """Build PagerDuty Events API v2 payload."""
+        event_action = "trigger" if envelope.severity == AlertSeverity.CRITICAL else "acknowledge"
+        pd_severity = _PD_SEVERITY_MAP.get(envelope.severity, "info")
+
+        return {
+            "routing_key": self.routing_key,
+            "event_action": event_action,
+            "payload": {
+                "summary": envelope.title,
+                "severity": pd_severity,
+                "source": "devtorch",
+                "custom_details": envelope.metadata,
+            },
+        }
+
+    def deliver(self, envelope: AlertEnvelope) -> DeliveryResult:
+        """POST to PagerDuty Events API. Never raises."""
+        try:
+            payload = self._build_payload(envelope)
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(
+                self.EVENTS_API_URL,
+                data=data,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return DeliveryResult(
+                    channel=self.channel_name,
+                    success=True,
+                    response_code=resp.status,
+                )
+        except urllib.error.HTTPError as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=f"HTTP {exc.code}: {exc.reason}",
+                response_code=exc.code,
+            )
+        except Exception as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=str(exc),
+            )

devtorch_core/alerts/slack.py

@@ -0,0 +1,81 @@
+import json
+import urllib.request
+import urllib.error
+from typing import Any
+
+from .base import AlertChannel, AlertEnvelope, AlertSeverity, DeliveryResult
+
+_SEVERITY_EMOJI = {
+    AlertSeverity.CRITICAL: "🔴",
+    AlertSeverity.WARNING: "🟡",
+    AlertSeverity.INFO: "🔵",
+}
+
+
+class SlackChannel(AlertChannel):
+    channel_name = "slack"
+
+    def __init__(self, webhook_url: str) -> None:
+        self.webhook_url = webhook_url
+
+    def _build_payload(self, envelope: AlertEnvelope) -> dict:
+        """Build Slack Block Kit payload."""
+        emoji = _SEVERITY_EMOJI.get(envelope.severity, "🔵")
+        blocks: list[dict[str, Any]] = [
+            {
+                "type": "header",
+                "text": {
+                    "type": "plain_text",
+                    "text": f"{emoji} {envelope.severity.value.upper()}: {envelope.event_type}",
+                    "emoji": True,
+                },
+            },
+            {
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"*{envelope.title}*\n{envelope.body}",
+                },
+            },
+            {
+                "type": "context",
+                "elements": [
+                    {
+                        "type": "mrkdwn",
+                        "text": f"Branch: `{envelope.branch}` | Commit: `{envelope.commit_id}`",
+                    }
+                ],
+            },
+        ]
+        return {"blocks": blocks}
+
+    def deliver(self, envelope: AlertEnvelope) -> DeliveryResult:
+        """POST to Slack webhook. Uses urllib (no requests dependency)."""
+        try:
+            payload = self._build_payload(envelope)
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(
+                self.webhook_url,
+                data=data,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return DeliveryResult(
+                    channel=self.channel_name,
+                    success=True,
+                    response_code=resp.status,
+                )
+        except urllib.error.HTTPError as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=f"HTTP {exc.code}: {exc.reason}",
+                response_code=exc.code,
+            )
+        except Exception as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=str(exc),
+            )

devtorch_core/alerts/teams.py

@@ -0,0 +1,70 @@
+import json
+import urllib.request
+import urllib.error
+
+from .base import AlertChannel, AlertEnvelope, AlertSeverity, DeliveryResult
+
+
+class MicrosoftTeamsChannel(AlertChannel):
+    channel_name = "teams"
+
+    def __init__(self, webhook_url: str) -> None:
+        self.webhook_url = webhook_url
+
+    def _build_payload(self, envelope: AlertEnvelope) -> dict:
+        """Build a simple MessageCard payload for Microsoft Teams connectors."""
+        color = {
+            AlertSeverity.CRITICAL: "ff0000",
+            AlertSeverity.WARNING: "ffff00",
+            AlertSeverity.INFO: "0000ff",
+        }.get(envelope.severity, "0000ff")
+
+        return {
+            "@type": "MessageCard",
+            "@context": "https://schema.org/extensions",
+            "themeColor": color,
+            "summary": f"{envelope.severity.value.upper()}: {envelope.title}",
+            "sections": [
+                {
+                    "activityTitle": f"DevTorch {envelope.severity.value.upper()} alert",
+                    "activitySubtitle": envelope.event_type,
+                    "facts": [
+                        {"name": "Title", "value": envelope.title},
+                        {"name": "Branch", "value": envelope.branch},
+                        {"name": "Commit", "value": envelope.commit_id},
+                    ],
+                    "text": envelope.body,
+                }
+            ],
+        }
+
+    def deliver(self, envelope: AlertEnvelope) -> DeliveryResult:
+        """POST to Microsoft Teams webhook."""
+        try:
+            payload = self._build_payload(envelope)
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(
+                self.webhook_url,
+                data=data,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return DeliveryResult(
+                    channel=self.channel_name,
+                    success=True,
+                    response_code=resp.status,
+                )
+        except urllib.error.HTTPError as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=f"HTTP {exc.code}: {exc.reason}",
+                response_code=exc.code,
+            )
+        except Exception as exc:
+            return DeliveryResult(
+                channel=self.channel_name,
+                success=False,
+                error=str(exc),
+            )

devtorch_core/audit/__init__.py

@@ -0,0 +1,43 @@
+"""Sprint 30 — Trust, Compliance & Security audit primitives.
+
+Provides:
+
+* PII/secrets scrubbing (regex-based default, optional presidio).
+* Privacy policy enforcement stored in `.GCC/privacy.json`.
+* Exportable, filterable audit reports from `.GCC/events.log.jsonl`.
+* Optional Ed25519 tamper-evident signing of exported JSON.
+
+Design decisions
+----------------
+* Regex-based redaction is the default so the OSS core stays lightweight and
+  does not pull heavy ML models (spacy/presidio) unless explicitly requested.
+* Privacy configuration is a simple JSON file under `.GCC/` so it is versioned
+  with the repository and discoverable by the CLI and MCP server.
+* Export signing uses asymmetric Ed25519 (via optional ``cryptography``) so a
+  report can be verified by anyone holding the public key, without access to the
+  private signing key.
+"""
+
+from __future__ import annotations
+
+from .scrubber import Scrubber, RegexScrubber, make_scrubber
+from .privacy import PrivacyConfig, load_privacy_config, save_privacy_config, apply_privacy_policy
+from .exporter import AuditFilters, AuditExporter, export_audit
+from .signing import ExportSigner, AuditSignatureError
+from .service import AuditService
+
+__all__ = [
+    "Scrubber",
+    "RegexScrubber",
+    "make_scrubber",
+    "PrivacyConfig",
+    "load_privacy_config",
+    "save_privacy_config",
+    "apply_privacy_policy",
+    "AuditFilters",
+    "AuditExporter",
+    "export_audit",
+    "ExportSigner",
+    "AuditSignatureError",
+    "AuditService",
+]