codedna 0.2.0__py3-none-any.whl

codedna/integrations/github_bot.py

@@ -0,0 +1,259 @@
+"""GitHub PR'larına otomatik CodeDNA analiz yorumu bırakır."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Optional
+
+# GitHub API temel URL'i
+_GH_API = "https://api.github.com"
+
+# Yorumda kullanılan gizli marker — mevcut CodeDNA yorumunu bulmak için
+_YORUM_MARKERI = "<!-- codedna-bot-comment -->"
+
+# Güvenlik: token asla loglanmaz veya hata mesajlarında görünmez
+GITHUB_TOKEN_ENV = "GITHUB_TOKEN"
+
+
+# ---------------------------------------------------------------------------
+# Yorum formatlama
+# ---------------------------------------------------------------------------
+
+def format_pr_comment(
+    scan_sonuclari: list,
+    debt_ozeti: Optional[dict] = None,
+) -> str:
+    """
+    Analiz sonuçlarını GitHub Markdown yorumuna dönüştür.
+
+    Okunabilirlik için 2000 karakter altında tutulur.
+    ℹ️ teknik borç disclaimer'ı dahil.
+
+    Args:
+        scan_sonuclari: FileAnalysisResult listesi
+        debt_ozeti: RepoBorcu özeti (opsiyonel)
+
+    Returns:
+        Markdown formatında yorum metni
+    """
+    if not scan_sonuclari:
+        return f"{_YORUM_MARKERI}\n## 🧬 CodeDNA Analizi\n\nDeğişen dosya bulunamadı.\n"
+
+    toplam = len(scan_sonuclari)
+    ort_ai = sum(s.ai_probability for s in scan_sonuclari) / toplam
+    yuksek_risk = [s for s in scan_sonuclari if s.ai_probability >= 0.7]
+
+    # Risk seviyesi
+    if ort_ai >= 0.7:
+        risk_emoji = "🔴"
+        risk_label = "YÜKSEK"
+    elif ort_ai >= 0.4:
+        risk_emoji = "🟡"
+        risk_label = "ORTA"
+    else:
+        risk_emoji = "🟢"
+        risk_label = "DÜŞÜK"
+
+    satirlar = [
+        _YORUM_MARKERI,
+        "## 🧬 CodeDNA Analizi",
+        "",
+        f"| Metrik | Değer |",
+        f"|--------|-------|",
+        f"| Analiz edilen dosya | {toplam} |",
+        f"| Ort. AI olasılığı | %{ort_ai * 100:.0f} |",
+        f"| Risk seviyesi | {risk_emoji} {risk_label} |",
+        f"| Yüksek riskli dosya (≥%70) | {len(yuksek_risk)} |",
+        "",
+    ]
+
+    # En riskli 3 dosya
+    en_riskli = sorted(scan_sonuclari, key=lambda s: s.ai_probability, reverse=True)[:3]
+    if en_riskli:
+        satirlar.append("### ⚠️ Dikkat Gerektiren Dosyalar")
+        satirlar.append("")
+        satirlar.append("| Dosya | AI Olasılığı | Karmaşıklık |")
+        satirlar.append("|-------|-------------|------------|")
+        for s in en_riskli:
+            try:
+                from pathlib import Path
+                kisa_yol = "/".join(Path(s.file_path).parts[-2:])
+            except Exception:
+                kisa_yol = s.file_path[-40:]
+            satirlar.append(
+                f"| `{kisa_yol}` | %{s.ai_probability * 100:.0f} | {s.complexity_label} |"
+            )
+        satirlar.append("")
+
+    # Teknik borç (varsa)
+    if debt_ozeti:
+        toplam_saat = debt_ozeti.get("toplam_debt_saatleri", 0)
+        satirlar.append(f"### 💰 Teknik Borç Tahmini")
+        satirlar.append(f"")
+        satirlar.append(f"Tahmini borç: **{toplam_saat:.1f} saat**")
+        satirlar.append(f"")
+        satirlar.append(
+            "> ℹ️ *Bu bir tahmin modelidir — anlama skoru, AI olasılığı ve "
+            "karmaşıklık ağırlıklarına dayanır. Kesin muhasebe verisi değildir.*"
+        )
+        satirlar.append("")
+
+    # Footer
+    satirlar += [
+        "---",
+        "<sub>🧬 [CodeDNA](https://github.com/codedna/codedna) · "
+        "Detaylı analiz için `codedna dashboard` çalıştırın.</sub>",
+    ]
+
+    yorum = "\n".join(satirlar)
+
+    # 2000 karakter limitini aş
+    if len(yorum) > 2000:
+        ozet = "\n".join(satirlar[:20])
+        yorum = (
+            ozet + "\n\n"
+            "*... (kısaltıldı — tam rapor için CodeDNA dashboard'a bakın)*\n\n"
+            f"---\n<sub>🧬 CodeDNA</sub>\n{_YORUM_MARKERI}"
+        )
+
+    return yorum
+
+
+# ---------------------------------------------------------------------------
+# GitHub API işlemleri
+# ---------------------------------------------------------------------------
+
+def _gh_istek(
+    method: str,
+    url: str,
+    token: str,
+    veri: Optional[dict] = None,
+) -> dict:
+    """
+    GitHub API'ye kimlik doğrulamalı istek gönder.
+
+    Güvenlik: token sadece Authorization header'ında kullanılır,
+    asla loglanmaz veya hata mesajına eklenmez.
+    """
+    govde = json.dumps(veri).encode("utf-8") if veri else None
+    istek = urllib.request.Request(
+        url,
+        data=govde,
+        method=method,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+        },
+    )
+    try:
+        with urllib.request.urlopen(istek, timeout=15) as yanit:
+            return json.loads(yanit.read())
+    except urllib.error.HTTPError as e:
+        govde_str = e.read().decode("utf-8", errors="replace")
+        # Token'ı hata mesajına ASLA ekleme
+        raise RuntimeError(f"GitHub API hatası ({e.code}): {govde_str[:300]}")
+
+
+def find_existing_comment(
+    repo: str,
+    pr_number: int,
+    token: str,
+) -> Optional[int]:
+    """
+    Mevcut CodeDNA bot yorumunun ID'sini bul (marker ile).
+
+    Args:
+        repo: "owner/repo" formatında repo adı
+        pr_number: PR numarası
+        token: GitHub token
+
+    Returns:
+        Yorum ID'si veya yoksa None
+    """
+    url = f"{_GH_API}/repos/{repo}/issues/{pr_number}/comments?per_page=100"
+    try:
+        yorumlar = _gh_istek("GET", url, token)
+    except Exception:
+        return None
+
+    if not isinstance(yorumlar, list):
+        return None
+
+    for yorum in yorumlar:
+        body = yorum.get("body", "")
+        if _YORUM_MARKERI in body:
+            return yorum.get("id")
+
+    return None
+
+
+def post_or_update_comment(
+    repo: str,
+    pr_number: int,
+    body: str,
+    token: str,
+) -> dict:
+    """
+    PR'a CodeDNA yorumu gönder veya mevcut yorumu güncelle.
+
+    Spam önleme: Her push'ta yeni yorum açılmaz — mevcut CodeDNA
+    yorumu bulunur ve PATCH ile güncellenir. Yoksa yeni POST yapılır.
+
+    Args:
+        repo: "owner/repo" formatında repo adı
+        pr_number: PR numarası
+        body: Yorum metni (Markdown)
+        token: GitHub token
+
+    Returns:
+        GitHub API yanıtı
+    """
+    mevcut_id = find_existing_comment(repo, pr_number, token)
+
+    if mevcut_id:
+        # Mevcut yorumu güncelle — spam yaratma
+        url = f"{_GH_API}/repos/{repo}/issues/comments/{mevcut_id}"
+        return _gh_istek("PATCH", url, token, {"body": body})
+    else:
+        # İlk defa yorum bırak
+        url = f"{_GH_API}/repos/{repo}/issues/{pr_number}/comments"
+        return _gh_istek("POST", url, token, {"body": body})
+
+
+# ---------------------------------------------------------------------------
+# GitHub Actions ortamından PR bilgisi otomatik algıla
+# ---------------------------------------------------------------------------
+
+def github_actions_pr_bilgisi() -> Optional[tuple[str, int]]:
+    """
+    GitHub Actions ortamından repo adı ve PR numarasını otomatik algıla.
+
+    GITHUB_REPOSITORY ve GITHUB_EVENT_PATH ortam değişkenlerini kullanır.
+
+    Returns:
+        (repo, pr_number) çifti veya algılanamıyorsa None
+    """
+    repo = os.environ.get("GITHUB_REPOSITORY")
+    event_path = os.environ.get("GITHUB_EVENT_PATH")
+
+    if not repo or not event_path:
+        return None
+
+    try:
+        with open(event_path, encoding="utf-8") as f:
+            event_veri = json.load(f)
+        pr_number = (
+            event_veri.get("pull_request", {}).get("number")
+            or event_veri.get("number")
+        )
+        if pr_number:
+            return repo, int(pr_number)
+    except Exception:
+        pass
+
+    return None

codedna/integrations/jira.py

@@ -0,0 +1,166 @@
+"""Jira sprint verilerini CodeDNA sprint kayıtlarıyla eşleştirir."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import secrets
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+# Webhook secret dosyası
+_SECRET_DOSYASI = Path.home() / ".codedna" / "jira_secret.txt"
+
+
+# ---------------------------------------------------------------------------
+# Webhook Secret Yönetimi
+# ---------------------------------------------------------------------------
+
+def get_or_create_secret() -> str:
+    """
+    Jira webhook secret'ını oku veya yoksa yeni oluştur.
+
+    Returns:
+        Hex formatında 32-byte secret
+    """
+    if _SECRET_DOSYASI.exists():
+        return _SECRET_DOSYASI.read_text().strip()
+    secret = secrets.token_hex(32)
+    _SECRET_DOSYASI.parent.mkdir(parents=True, exist_ok=True)
+    _SECRET_DOSYASI.write_text(secret)
+    return secret
+
+
+def rotate_secret() -> str:
+    """Webhook secret'ı yenile ve yeni değeri döndür."""
+    yeni = secrets.token_hex(32)
+    _SECRET_DOSYASI.parent.mkdir(parents=True, exist_ok=True)
+    _SECRET_DOSYASI.write_text(yeni)
+    return yeni
+
+
+def verify_signature(payload_bytes: bytes, signature_header: str, secret: str) -> bool:
+    """
+    Jira webhook imzasını HMAC-SHA256 ile doğrula.
+
+    Jira imzası formatı: "sha256=<hex_digest>"
+
+    Args:
+        payload_bytes: Ham HTTP body
+        signature_header: X-Hub-Signature-256 başlık değeri
+        secret: Webhook secret
+
+    Returns:
+        İmza geçerliyse True
+    """
+    if not signature_header.startswith("sha256="):
+        return False
+    beklenen_imza = signature_header[7:]
+    hesaplanan = hmac.new(
+        secret.encode("utf-8"),
+        payload_bytes,
+        hashlib.sha256,
+    ).hexdigest()
+    return hmac.compare_digest(hesaplanan, beklenen_imza)
+
+
+# ---------------------------------------------------------------------------
+# Webhook İşleme
+# ---------------------------------------------------------------------------
+
+def handle_jira_webhook(payload: dict[str, Any], db_path: Path) -> dict[str, Any]:
+    """
+    Jira webhook payload'unu işle, sprint kaydı oluştur/güncelle.
+
+    Desteklenen event türleri:
+      - sprint_started:  Yeni sprint başladı → kayıt oluştur
+      - sprint_closed:   Sprint kapandı → sağlık skoru hesapla + güncelle
+
+    Args:
+        payload: Jira webhook JSON payload'u
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        İşlem sonucu sözlüğü
+    """
+    event_turu = payload.get("webhookEvent", "")
+    sprint_verisi = payload.get("sprint", {})
+
+    if not sprint_verisi:
+        return {"durum": "atlandı", "neden": "sprint verisi yok"}
+
+    sprint_adi = sprint_verisi.get("name", "Jira Sprint")
+    baslangic_str = sprint_verisi.get("startDate") or sprint_verisi.get("activatedDate")
+    bitis_str = sprint_verisi.get("endDate") or sprint_verisi.get("completeDate")
+
+    # Tarihleri parse et
+    baslangic = _tarih_parse(baslangic_str)
+    bitis = _tarih_parse(bitis_str)
+
+    if not baslangic or not bitis:
+        return {"durum": "hata", "neden": "tarih bilgisi eksik"}
+
+    if event_turu in ("sprint_started", "jira:sprint_created"):
+        # Sprint başladı — kayıt oluştur (sağlık skoru hesaplanmadı henüz)
+        from codedna.db import save_sprint
+        sprint_id = save_sprint(
+            sprint_name=sprint_adi,
+            start_date=int(baslangic.timestamp()),
+            end_date=int(bitis.timestamp()),
+            total_lines_ai=0,
+            total_lines_human=0,
+            avg_understanding=None,
+            debt_delta_hours=None,
+            health_score=None,
+            db_path=db_path,
+        )
+        return {
+            "durum": "oluşturuldu",
+            "sprint_id": sprint_id,
+            "sprint_adi": sprint_adi,
+        }
+
+    elif event_turu in ("sprint_closed", "jira:sprint_completed"):
+        # Sprint kapandı — sağlık skoru hesapla
+        from codedna.sprint_health import calculate_sprint_health, save_sprint_result
+        from codedna.git_hook import find_git_root
+
+        repo_koku = find_git_root() or Path.cwd()
+        try:
+            sonuc = calculate_sprint_health(repo_koku, db_path, baslangic, bitis, sprint_adi)
+            sprint_id = save_sprint_result(sonuc, db_path)
+            return {
+                "durum": "tamamlandı",
+                "sprint_id": sprint_id,
+                "sprint_adi": sprint_adi,
+                "health_score": sonuc.health_score,
+                "durum_etiketi": sonuc.durum,
+            }
+        except Exception as e:
+            return {"durum": "hata", "neden": str(e)}
+
+    return {"durum": "atlandı", "neden": f"desteklenmeyen event: {event_turu}"}
+
+
+def _tarih_parse(tarih_str: Optional[str]) -> Optional[datetime]:
+    """
+    Jira tarih string'lerini datetime'a çevir.
+    Desteklenen formatlar: ISO 8601 ile çeşitli varyantlar.
+    """
+    if not tarih_str:
+        return None
+    formatlar = [
+        "%Y-%m-%dT%H:%M:%S.%f%z",
+        "%Y-%m-%dT%H:%M:%S%z",
+        "%Y-%m-%dT%H:%M:%S.%f",
+        "%Y-%m-%dT%H:%M:%S",
+        "%Y-%m-%d",
+    ]
+    for fmt in formatlar:
+        try:
+            return datetime.strptime(tarih_str[:len(fmt) + 5], fmt)
+        except ValueError:
+            continue
+    return None

codedna/integrations/lemonsqueezy.py

@@ -0,0 +1,236 @@
+"""Lemon Squeezy checkout ve abonelik webhook entegrasyonu."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Ortam değişkenleri — koda gömülmez
+# ---------------------------------------------------------------------------
+
+LEMONSQUEEZY_API_KEY = os.environ.get("LEMONSQUEEZY_API_KEY")
+LEMONSQUEEZY_WEBHOOK_SECRET = os.environ.get("LEMONSQUEEZY_WEBHOOK_SECRET")
+LEMONSQUEEZY_STORE_ID = os.environ.get("LEMONSQUEEZY_STORE_ID")
+
+# Plan → Lemon Squeezy variant ID eşlemesi (gerçek ID'ler .env'den)
+PLAN_VARIANT_MAP: dict[str, Optional[str]] = {
+    "pro":        os.environ.get("LS_VARIANT_PRO"),
+    "team":       os.environ.get("LS_VARIANT_TEAM"),
+    "enterprise": os.environ.get("LS_VARIANT_ENTERPRISE"),
+}
+
+# Lemon Squeezy API temel URL'i
+_LS_API_BASE = "https://api.lemonsqueezy.com/v1"
+
+
+# ---------------------------------------------------------------------------
+# Webhook imza doğrulama
+# ---------------------------------------------------------------------------
+
+def verify_webhook_signature(payload: bytes, signature: str) -> bool:
+    """
+    Lemon Squeezy webhook imzasını HMAC-SHA256 ile doğrula.
+
+    Lemon Squeezy, X-Signature header'ında hex digest gönderir.
+    hmac.compare_digest ile timing-safe karşılaştırma yapılır.
+
+    Args:
+        payload: Ham HTTP body (bytes)
+        signature: X-Signature header değeri
+
+    Returns:
+        İmza geçerliyse True
+    """
+    secret = LEMONSQUEEZY_WEBHOOK_SECRET
+    if not secret:
+        return False
+
+    hesaplanan = hmac.new(
+        secret.encode("utf-8"),
+        payload,
+        hashlib.sha256,
+    ).hexdigest()
+
+    return hmac.compare_digest(hesaplanan, signature)
+
+
+# ---------------------------------------------------------------------------
+# Checkout URL oluşturma
+# ---------------------------------------------------------------------------
+
+def create_checkout_url(
+    plan: str,
+    user_email: str,
+    user_id: int,
+) -> str:
+    """
+    Lemon Squeezy Checkout API'sine istek at ve hosted checkout URL'ini döndür.
+
+    custom_data içine user_id gömülür — webhook'ta hangi kullanıcıya ait
+    olduğunu eşleştirmek için kullanılır.
+
+    Dokümantasyon: https://docs.lemonsqueezy.com/api/checkouts
+
+    Args:
+        plan: "pro" | "team" | "enterprise"
+        user_email: Kullanıcının e-posta adresi (checkout'ta ön doldurulur)
+        user_id: Kullanıcı ID'si (webhook eşleştirmesi için)
+
+    Returns:
+        Checkout URL string'i
+
+    Raises:
+        ValueError: API anahtarı veya variant ID eksikse
+        RuntimeError: API isteği başarısız olursa
+    """
+    import urllib.request
+
+    api_key = LEMONSQUEEZY_API_KEY
+    store_id = LEMONSQUEEZY_STORE_ID
+    variant_id = PLAN_VARIANT_MAP.get(plan)
+
+    if not api_key:
+        raise ValueError(
+            "LEMONSQUEEZY_API_KEY ortam değişkeni tanımlanmamış. "
+            ".env.example dosyasına bakın."
+        )
+    if not store_id:
+        raise ValueError("LEMONSQUEEZY_STORE_ID ortam değişkeni tanımlanmamış.")
+    if not variant_id:
+        raise ValueError(
+            f"LS_VARIANT_{plan.upper()} ortam değişkeni tanımlanmamış."
+        )
+
+    istek_govdesi = json.dumps({
+        "data": {
+            "type": "checkouts",
+            "attributes": {
+                "checkout_data": {
+                    "email": user_email,
+                    "custom": {"user_id": str(user_id)},
+                },
+            },
+            "relationships": {
+                "store": {
+                    "data": {"type": "stores", "id": str(store_id)}
+                },
+                "variant": {
+                    "data": {"type": "variants", "id": str(variant_id)}
+                },
+            },
+        }
+    }).encode("utf-8")
+
+    istek = urllib.request.Request(
+        f"{_LS_API_BASE}/checkouts",
+        data=istek_govdesi,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/vnd.api+json",
+            "Accept": "application/vnd.api+json",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(istek, timeout=10) as yanit:
+            veri = json.loads(yanit.read())
+            return veri["data"]["attributes"]["url"]
+    except urllib.error.HTTPError as e:
+        hata_govdesi = e.read().decode("utf-8", errors="replace")
+        raise RuntimeError(
+            f"Lemon Squeezy API hatası ({e.code}): {hata_govdesi}"
+        )
+    except Exception as e:
+        raise RuntimeError(f"Checkout URL oluşturulamadı: {e}")
+
+
+# ---------------------------------------------------------------------------
+# Webhook event işleme
+# ---------------------------------------------------------------------------
+
+# LS event → (plan, subscription_status) eşlemesi
+_EVENT_DURUM_MAP: dict[str, tuple[Optional[str], str]] = {
+    "subscription_created":        (None,   "active"),     # plan custom_data'dan alınır
+    "subscription_updated":        (None,   "active"),
+    "subscription_cancelled":      (None,   "cancelled"),  # plan hemen düşürülmez
+    "subscription_expired":        ("free", "none"),
+    "subscription_payment_failed": (None,   "past_due"),
+}
+
+
+def handle_subscription_webhook(
+    payload: dict,
+    db_path: Path,
+) -> dict:
+    """
+    Lemon Squeezy webhook event'lerini işle ve kullanıcı planını güncelle.
+
+    Tüm event'lerde custom_data.user_id ile kullanıcı eşleştirilir.
+
+    Args:
+        payload: Webhook JSON payload'u
+        db_path: Auth DB yolu
+
+    Returns:
+        İşlem sonucu sözlüğü
+    """
+    from codedna.auth import update_user_plan, init_auth_db
+
+    init_auth_db(db_path)
+
+    event_turu = payload.get("meta", {}).get("event_name", "")
+    if event_turu not in _EVENT_DURUM_MAP:
+        return {"durum": "atlandı", "event": event_turu}
+
+    # Kullanıcı ID'sini custom_data'dan al
+    custom_data = payload.get("meta", {}).get("custom_data", {})
+    user_id_str = custom_data.get("user_id") or custom_data.get("user_id")
+    if not user_id_str:
+        return {"durum": "hata", "neden": "custom_data.user_id eksik"}
+
+    try:
+        user_id = int(user_id_str)
+    except (ValueError, TypeError):
+        return {"durum": "hata", "neden": f"Geçersiz user_id: {user_id_str!r}"}
+
+    # Abonelik verilerini al
+    abonelik = payload.get("data", {}).get("attributes", {})
+    customer_id = str(abonelik.get("customer_id", "")) or None
+    subscription_id = str(payload.get("data", {}).get("id", "")) or None
+
+    # Planı belirle
+    yeni_plan, yeni_durum = _EVENT_DURUM_MAP[event_turu]
+
+    # subscription_created/updated için plan variant'tan belirle
+    if yeni_plan is None:
+        variant_id = str(abonelik.get("variant_id", ""))
+        # Variant ID → plan eşlemesi (ters yön)
+        for plan_adi, vid in PLAN_VARIANT_MAP.items():
+            if vid and vid == variant_id:
+                yeni_plan = plan_adi
+                break
+        if yeni_plan is None:
+            yeni_plan = "pro"  # bilinmeyen variant → pro varsayılan
+
+    update_user_plan(
+        user_id=user_id,
+        plan=yeni_plan,
+        subscription_status=yeni_durum,
+        customer_id=customer_id,
+        subscription_id=subscription_id,
+        db_path=db_path,
+    )
+
+    return {
+        "durum": "güncellendi",
+        "user_id": user_id,
+        "yeni_plan": yeni_plan,
+        "subscription_status": yeni_durum,
+        "event": event_turu,
+    }