codedna 0.2.0__py3-none-any.whl

codedna/auth.py

@@ -0,0 +1,372 @@
+"""Kullanıcı kimlik doğrulama — kayıt, giriş, JWT oturum yönetimi."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import time
+from pathlib import Path
+from typing import Optional
+
+import bcrypt
+import jwt
+
+from codedna.db import get_connection
+
+# ---------------------------------------------------------------------------
+# Yapılandırma
+# ---------------------------------------------------------------------------
+
+# JWT secret MUTLAKA ortam değişkeninden okunmalı — koda gömülmemeli
+JWT_SECRET: Optional[str] = os.environ.get("CODEDNA_JWT_SECRET")
+JWT_ALGORITHM = "HS256"
+JWT_EXPIRY_HOURS = 24 * 7   # 7 gün
+
+# Auth veritabanı yolu — repo db'sinden ayrı
+_AUTH_DB_VARSAYILAN = Path.home() / ".codedna" / "auth.db"
+
+
+def _auth_db() -> Path:
+    """Auth veritabanı yolunu döndür (ortam değişkeninden veya varsayılan)."""
+    env = os.environ.get("CODEDNA_AUTH_DB_PATH")
+    return Path(env).resolve() if env else _AUTH_DB_VARSAYILAN
+
+
+def _jwt_secret_kontrol() -> str:
+    """
+    JWT secret'ın var olduğunu doğrula.
+
+    Production'da secret olmadan uygulama başlamamalı.
+    Development/test için otomatik rastgele secret üretir (persistent değil).
+    """
+    secret = JWT_SECRET or os.environ.get("CODEDNA_JWT_SECRET")
+    if not secret:
+        # Development modunda otomatik dev secret üret (process başına)
+        # Production'da CODEDNA_JWT_SECRET environment variable tanımlanmalı
+        secret = os.environ.get("CODEDNA_JWT_DEV_SECRET")
+        if not secret:
+            import secrets
+            secret = "dev-" + secrets.token_urlsafe(48)
+            os.environ["CODEDNA_JWT_DEV_SECRET"] = secret
+            import warnings
+            warnings.warn(
+                "CODEDNA_JWT_SECRET tanımlı değil — development secret kullanılıyor. "
+                "Production için CODEDNA_JWT_SECRET environment variable tanımlayın.",
+                RuntimeWarning,
+                stacklevel=2
+            )
+    return secret
+
+
+# ---------------------------------------------------------------------------
+# Auth DB şeması
+# ---------------------------------------------------------------------------
+
+def init_auth_db(db_path: Optional[Path] = None) -> None:
+    """Kullanıcı ve oturum tablolarını oluştur (yoksa)."""
+    yol = db_path or _auth_db()
+    yol.parent.mkdir(parents=True, exist_ok=True)
+    with get_connection(yol) as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY,
+                email TEXT UNIQUE NOT NULL,
+                password_hash TEXT NOT NULL,
+                plan TEXT DEFAULT 'free',
+                lemonsqueezy_customer_id TEXT,
+                lemonsqueezy_subscription_id TEXT,
+                subscription_status TEXT DEFAULT 'none',
+                created_at INTEGER,
+                updated_at INTEGER
+            );
+
+            CREATE TABLE IF NOT EXISTS sessions (
+                id INTEGER PRIMARY KEY,
+                user_id INTEGER NOT NULL,
+                token_hash TEXT UNIQUE NOT NULL,
+                created_at INTEGER,
+                expires_at INTEGER,
+                FOREIGN KEY (user_id) REFERENCES users(id)
+            );
+        """)
+
+
+# ---------------------------------------------------------------------------
+# Şifre işlemleri
+# ---------------------------------------------------------------------------
+
+def hash_password(password: str) -> str:
+    """bcrypt ile şifreyi hash'le."""
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(password: str, password_hash: str) -> bool:
+    """Şifreyi hash ile güvenli biçimde karşılaştır."""
+    try:
+        return bcrypt.checkpw(password.encode("utf-8"), password_hash.encode("utf-8"))
+    except Exception:
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Token yardımcıları
+# ---------------------------------------------------------------------------
+
+def _token_hash(token: str) -> str:
+    """Token'ı SHA-256 ile hash'le — DB'de token'ın kendisi SAKLANMAZ."""
+    return hashlib.sha256(token.encode("utf-8")).hexdigest()
+
+
+def _jwt_olustur(user_id: int, email: str, plan: str) -> str:
+    """JWT token üret."""
+    secret = _jwt_secret_kontrol()
+    su_an = int(time.time())
+    payload = {
+        "sub": str(user_id),
+        "email": email,
+        "plan": plan,
+        "iat": su_an,
+        "exp": su_an + JWT_EXPIRY_HOURS * 3600,
+    }
+    return jwt.encode(payload, secret, algorithm=JWT_ALGORITHM)
+
+
+def _jwt_coz(token: str) -> Optional[dict]:
+    """JWT token'ı çöz, geçersizse None döndür."""
+    secret = _jwt_secret_kontrol()
+    try:
+        return jwt.decode(token, secret, algorithms=[JWT_ALGORITHM])
+    except jwt.ExpiredSignatureError:
+        return None
+    except jwt.InvalidTokenError:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Kayıt / Giriş / Çıkış
+# ---------------------------------------------------------------------------
+
+_EMAIL_REGEX = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
+
+
+def register_user(
+    email: str,
+    password: str,
+    db_path: Optional[Path] = None,
+) -> dict:
+    """
+    Yeni kullanıcı kaydı yap.
+
+    Kurallar:
+      - E-posta formatı geçerli olmalı
+      - Şifre en az 8 karakter
+      - E-posta zaten kayıtlıysa hata
+
+    Args:
+        email: Kullanıcı e-postası
+        password: Düz metin şifre (kayıt sonrası saklanmaz)
+        db_path: Auth DB yolu
+
+    Returns:
+        {"user_id", "token", "plan"} sözlüğü
+    """
+    yol = db_path or _auth_db()
+    init_auth_db(yol)
+
+    # Girdi doğrulama
+    email = email.strip().lower()
+    if not _EMAIL_REGEX.match(email):
+        raise ValueError("Geçersiz e-posta formatı.")
+    if len(password) < 8:
+        raise ValueError("Şifre en az 8 karakter olmalı.")
+
+    sifre_hash = hash_password(password)
+    su_an = int(time.time())
+
+    # Lisans dosyasından plan al (demo/single-tenant modu)
+    # Production'da plan satın alma üzerinden atanır
+    try:
+        from codedna.plan import get_current_plan
+        initial_plan = get_current_plan().value
+    except Exception:
+        initial_plan = "free"
+
+    try:
+        with get_connection(yol) as conn:
+            cur = conn.execute(
+                """
+                INSERT INTO users (email, password_hash, plan, subscription_status, created_at, updated_at)
+                VALUES (?, ?, ?, 'demo', ?, ?)
+                """,
+                (email, sifre_hash, initial_plan, su_an, su_an),
+            )
+            user_id = cur.lastrowid or 0
+    except Exception as e:
+        if "UNIQUE" in str(e).upper():
+            raise ValueError("Bu e-posta adresi zaten kayıtlı.")
+        raise
+
+    token = _jwt_olustur(user_id, email, initial_plan)
+    _oturum_kaydet(user_id, token, yol)
+
+    return {"user_id": user_id, "token": token, "plan": initial_plan}
+
+
+def login_user(
+    email: str,
+    password: str,
+    db_path: Optional[Path] = None,
+) -> dict:
+    """
+    Giriş yap ve JWT token üret.
+
+    Güvenlik notu: Başarısız girişlerde spesifik hata döndürme
+    (kullanıcı enumeration saldırısını önlemek için genel mesaj kullan).
+
+    Args:
+        email: Kullanıcı e-postası
+        password: Düz metin şifre
+
+    Returns:
+        {"user_id", "token", "plan", "subscription_status"} sözlüğü
+    """
+    yol = db_path or _auth_db()
+    init_auth_db(yol)
+
+    email = email.strip().lower()
+
+    with get_connection(yol) as conn:
+        kullanici = conn.execute(
+            "SELECT id, password_hash, plan, subscription_status FROM users WHERE email = ?",
+            (email,),
+        ).fetchone()
+
+    # Kullanıcı yoksa veya şifre yanlışsa AYNI hata — enumeration önlemi
+    if not kullanici or not verify_password(password, kullanici["password_hash"]):
+        raise ValueError("E-posta veya şifre hatalı.")
+
+    token = _jwt_olustur(kullanici["id"], email, kullanici["plan"])
+    _oturum_kaydet(kullanici["id"], token, yol)
+
+    return {
+        "user_id": kullanici["id"],
+        "token": token,
+        "plan": kullanici["plan"],
+        "subscription_status": kullanici["subscription_status"],
+    }
+
+
+def verify_token(
+    token: str,
+    db_path: Optional[Path] = None,
+) -> Optional[dict]:
+    """
+    JWT token'ı doğrula ve kullanıcı bilgisini döndür.
+
+    Hem JWT imzasını hem de oturum tablosundaki kaydı kontrol eder.
+
+    Returns:
+        Geçerliyse {"user_id", "email", "plan"}, değilse None
+    """
+    yol = db_path or _auth_db()
+    payload = _jwt_coz(token)
+    if not payload:
+        return None
+
+    token_h = _token_hash(token)
+    su_an = int(time.time())
+
+    with get_connection(yol) as conn:
+        oturum = conn.execute(
+            "SELECT id FROM sessions WHERE token_hash = ? AND expires_at > ?",
+            (token_h, su_an),
+        ).fetchone()
+
+    if not oturum:
+        return None
+
+    return {
+        "user_id": int(payload["sub"]),
+        "email": payload["email"],
+        "plan": payload["plan"],
+    }
+
+
+def logout_user(
+    token: str,
+    db_path: Optional[Path] = None,
+) -> bool:
+    """
+    Oturumu sonlandır — sessions tablosundan sil.
+
+    Returns:
+        Başarıyla silinirse True
+    """
+    yol = db_path or _auth_db()
+    token_h = _token_hash(token)
+    with get_connection(yol) as conn:
+        cur = conn.execute("DELETE FROM sessions WHERE token_hash = ?", (token_h,))
+    return cur.rowcount > 0
+
+
+def get_user_by_id(user_id: int, db_path: Optional[Path] = None) -> Optional[dict]:
+    """Kullanıcı bilgisini ID ile getir (şifre hash hariç)."""
+    yol = db_path or _auth_db()
+    with get_connection(yol) as conn:
+        row = conn.execute(
+            "SELECT id, email, plan, subscription_status, lemonsqueezy_customer_id FROM users WHERE id = ?",
+            (user_id,),
+        ).fetchone()
+    if not row:
+        return None
+    return {
+        "id": row["id"],
+        "email": row["email"],
+        "plan": row["plan"],
+        "subscription_status": row["subscription_status"],
+        "lemonsqueezy_customer_id": row["lemonsqueezy_customer_id"],
+    }
+
+
+def update_user_plan(
+    user_id: int,
+    plan: str,
+    subscription_status: str,
+    customer_id: Optional[str] = None,
+    subscription_id: Optional[str] = None,
+    db_path: Optional[Path] = None,
+) -> None:
+    """Kullanıcının plan ve abonelik durumunu güncelle."""
+    yol = db_path or _auth_db()
+    su_an = int(time.time())
+    with get_connection(yol) as conn:
+        conn.execute(
+            """
+            UPDATE users
+            SET plan = ?, subscription_status = ?,
+                lemonsqueezy_customer_id = COALESCE(?, lemonsqueezy_customer_id),
+                lemonsqueezy_subscription_id = COALESCE(?, lemonsqueezy_subscription_id),
+                updated_at = ?
+            WHERE id = ?
+            """,
+            (plan, subscription_status, customer_id, subscription_id, su_an, user_id),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Yardımcı — oturum kaydetme
+# ---------------------------------------------------------------------------
+
+def _oturum_kaydet(user_id: int, token: str, db_path: Path) -> None:
+    """Yeni oturumu DB'ye kaydet (token'ın hash'i saklanır)."""
+    su_an = int(time.time())
+    bitis = su_an + JWT_EXPIRY_HOURS * 3600
+    token_h = _token_hash(token)
+    with get_connection(db_path) as conn:
+        # Eski süresi dolmuş oturumları temizle
+        conn.execute("DELETE FROM sessions WHERE expires_at < ?", (su_an,))
+        conn.execute(
+            "INSERT OR IGNORE INTO sessions (user_id, token_hash, created_at, expires_at) VALUES (?, ?, ?, ?)",
+            (user_id, token_h, su_an, bitis),
+        )

codedna/bus_factor.py

@@ -0,0 +1,259 @@
+"""Bus factor hesaplama — bir dosyayı kaç kişi gerçekten anlıyor."""
+
+from __future__ import annotations
+
+import subprocess
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from codedna.db import get_file_ownership, upsert_file_ownership
+
+# Büyük repo uyarı eşiği
+_BUYUK_REPO_ESIGI = 500
+
+# Yeterli anlayış eşiği (bu skorun altındaki yazarlar "anlıyor" sayılmaz)
+_ANLAMA_ESIGI = 3.5
+
+# Birincil sahip sayılmak için gereken minimum satır yüzdesi
+_SAHIPLIK_ESIGI = 0.10  # %10 → o dosyada "ilgili" sayılır
+
+
+@dataclass
+class DosyaSahiplik:
+    """Tek bir dosyanın yazar bazlı sahiplik özeti."""
+
+    dosya_yolu: str
+    toplam_satir: int
+    yazarlar: dict[str, int] = field(default_factory=dict)  # yazar → satır sayısı
+
+    @property
+    def birincil_sahip(self) -> Optional[str]:
+        """En fazla satıra sahip yazarı döndür."""
+        if not self.yazarlar:
+            return None
+        return max(self.yazarlar, key=lambda y: self.yazarlar[y])
+
+    @property
+    def birincil_sahiplik_yuzdesi(self) -> float:
+        """Birincil sahibin sahiplik yüzdesi (0.0–1.0)."""
+        if not self.yazarlar or self.toplam_satir == 0:
+            return 0.0
+        birincil = self.birincil_sahip
+        return self.yazarlar.get(birincil or "", 0) / self.toplam_satir
+
+
+@dataclass
+class BusFaktorSonucu:
+    """Tek dosya için bus factor sonucu."""
+
+    dosya_yolu: str
+    bus_factor: int                  # kaç kişi bu dosyayı anlıyor
+    birincil_sahip: Optional[str]
+    sahiplik_yuzdesi: float          # birincil sahibin yüzdesi
+    risk: str                        # KRİTİK / RİSKLİ / GÜVENLİ
+    anlayan_yazarlar: list[str]      # anlama skoru >= eşik olan yazarlar
+    toplam_satir: int
+
+
+def _git_blame_calistir(dosya_yolu: Path, repo_koku: Path) -> dict[str, int]:
+    """
+    git blame --line-porcelain ile satır bazlı yazar tespiti yap.
+
+    Returns:
+        {yazar_adi: satir_sayisi} sözlüğü
+    """
+    try:
+        goreceli = dosya_yolu.relative_to(repo_koku)
+    except ValueError:
+        goreceli = dosya_yolu
+
+    try:
+        sonuc = subprocess.run(
+            ["git", "blame", "--line-porcelain", str(goreceli)],
+            cwd=str(repo_koku),
+            capture_output=True,
+            text=True,
+            timeout=30,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return {}
+
+    if sonuc.returncode != 0:
+        return {}
+
+    # Çıktıdan "author " satırlarını topla
+    yazar_satirlari: dict[str, int] = defaultdict(int)
+    for satir in sonuc.stdout.splitlines():
+        if satir.startswith("author "):
+            yazar = satir[7:].strip()
+            # Özel "Not Committed Yet" durumunu atla
+            if yazar and yazar != "Not Committed Yet":
+                yazar_satirlari[yazar] += 1
+
+    return dict(yazar_satirlari)
+
+
+def _dosya_listesi_al(repo_koku: Path, max_dosya: int = _BUYUK_REPO_ESIGI) -> list[Path]:
+    """
+    Git tarafından izlenen desteklenen kaynak dosyaları listele.
+
+    Args:
+        repo_koku: Git repo kök dizini
+        max_dosya: İşlenecek maksimum dosya sayısı (performans için)
+
+    Returns:
+        Mutlak Path listesi
+    """
+    desteklenen = {".py", ".js", ".jsx", ".ts", ".tsx"}
+
+    try:
+        sonuc = subprocess.run(
+            ["git", "ls-files"],
+            cwd=str(repo_koku),
+            capture_output=True,
+            text=True,
+            timeout=10,
+            encoding="utf-8",
+            errors="replace",
+        )
+        dosyalar = sonuc.stdout.strip().splitlines()
+    except Exception:
+        dosyalar = []
+
+    filtreli = [
+        repo_koku / d for d in dosyalar
+        if Path(d).suffix.lower() in desteklenen and (repo_koku / d).exists()
+    ]
+    return filtreli[:max_dosya]
+
+
+def calculate_bus_factor(
+    repo_path: Path,
+    db_path: Path,
+    max_dosya: int = _BUYUK_REPO_ESIGI,
+) -> list[BusFaktorSonucu]:
+    """
+    Repo genelinde her dosya için bus factor hesapla ve DB'ye kaydet.
+
+    Bus factor = o dosyanın %50'sinden fazlasına sahip OLAN
+    VE understanding_score >= 3.5 olan yazar sayısı.
+    Anlama skoru yoksa sahiplik oranı >= 10% yeterli sayılır.
+
+    Args:
+        repo_path: Git repo kök dizini
+        max_dosya: İşlenecek maksimum dosya sayısı
+
+    Returns:
+        BusFaktorSonucu listesi, bus_factor'a göre artan sırada
+    """
+    kok = Path(repo_path).resolve()
+    dosyalar = _dosya_listesi_al(kok, max_dosya)
+
+    # Mevcut anlama skorlarını DB'den tek sorguda çek
+    from codedna.db import get_connection
+    anlama_map: dict[tuple[str, str], float] = {}  # (dosya_yolu, yazar) → skor
+    try:
+        with get_connection(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT fo.file_path, fo.author, fo.avg_understanding
+                FROM file_ownership fo
+                WHERE fo.avg_understanding IS NOT NULL
+                """
+            ).fetchall()
+            for r in rows:
+                anlama_map[(r["file_path"], r["author"])] = float(r["avg_understanding"])
+    except Exception:
+        pass
+
+    sonuclar: list[BusFaktorSonucu] = []
+
+    for dosya in dosyalar:
+        yazar_satirlari = _git_blame_calistir(dosya, kok)
+        if not yazar_satirlari:
+            continue
+
+        toplam = sum(yazar_satirlari.values())
+        if toplam == 0:
+            continue
+
+        # DB'ye kaydet
+        for yazar, satir in yazar_satirlari.items():
+            anlama = anlama_map.get((str(dosya), yazar))
+            upsert_file_ownership(
+                file_path=str(dosya),
+                author=yazar,
+                lines_owned=satir,
+                last_touched=0,     # gelecekte git log ile doldurulacak
+                avg_understanding=anlama,
+                db_path=db_path,
+            )
+
+        # "Anlayan" yazarları belirle
+        anlayan: list[str] = []
+        for yazar, satir in yazar_satirlari.items():
+            yuzde = satir / toplam
+            # Anlama skoru varsa kontrol et, yoksa %10+ sahiplik yeterli
+            anlama_skoru = anlama_map.get((str(dosya), yazar))
+            if anlama_skoru is not None:
+                if anlama_skoru >= _ANLAMA_ESIGI and yuzde >= _SAHIPLIK_ESIGI:
+                    anlayan.append(yazar)
+            elif yuzde >= _SAHIPLIK_ESIGI:
+                # Anket verisi yoksa sahipliği baz al
+                anlayan.append(yazar)
+
+        bus_factor = max(len(anlayan), 1)
+        if bus_factor == 1:
+            risk = "KRİTİK"
+        elif bus_factor == 2:
+            risk = "RİSKLİ"
+        else:
+            risk = "GÜVENLİ"
+
+        # Birincil sahip
+        birincil = max(yazar_satirlari, key=lambda y: yazar_satirlari[y])
+        birincil_yuzde = yazar_satirlari[birincil] / toplam
+
+        # Göreli dosya yolu
+        try:
+            goreceli_yol = str(dosya.relative_to(kok))
+        except ValueError:
+            goreceli_yol = str(dosya)
+
+        sonuclar.append(
+            BusFaktorSonucu(
+                dosya_yolu=goreceli_yol,
+                bus_factor=bus_factor,
+                birincil_sahip=birincil,
+                sahiplik_yuzdesi=round(birincil_yuzde * 100, 1),
+                risk=risk,
+                anlayan_yazarlar=anlayan,
+                toplam_satir=toplam,
+            )
+        )
+
+    # Bus factor'a göre artan sıralama (KRİTİK önce)
+    sonuclar.sort(key=lambda s: s.bus_factor)
+    return sonuclar
+
+
+def get_at_risk_files(
+    repo_path: Path,
+    db_path: Path,
+) -> list[BusFaktorSonucu]:
+    """
+    bus_factor == 1 olan dosyaları döndür (KRİTİK liste).
+
+    Args:
+        repo_path: Git repo kök dizini
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        Kritik dosyaların BusFaktorSonucu listesi
+    """
+    tum = calculate_bus_factor(repo_path, db_path)
+    return [s for s in tum if s.bus_factor == 1]