codedna 0.2.0__py3-none-any.whl

codedna/protection.py

@@ -0,0 +1,211 @@
+"""Kritik modüller için anlama eşiği izleme — kod sahipliği sigortası."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from codedna.db import get_connection
+
+# Durum sabitleri
+_DURUM_IHLAL = "İHLAL"
+_DURUM_GUVENLI = "GÜVENLİ"
+_DURUM_BILINMIYOR = "BİLİNMİYOR"
+
+# Aynı modül için uyarılar arası minimum süre (spam önleme, saniye)
+_MIN_UYARI_ARASI = 3600  # 1 saat
+
+
+@dataclass
+class ModulDurumu:
+    """Tek korumalı modülün anlık durumu."""
+
+    dosya_yolu: str
+    etiket: str
+    esik: float
+    mevcut_skor: Optional[float]
+    durum: str   # İHLAL / GÜVENLİ / BİLİNMİYOR
+    aktif: bool
+
+
+def protect_module(
+    file_path: str,
+    threshold: float,
+    label: str,
+    author: str,
+    db_path: Path,
+) -> int:
+    """
+    Bir dosyayı korumalı modül olarak işaretle.
+
+    Args:
+        file_path: Korunacak dosyanın yolu
+        threshold: Minimum anlama skoru eşiği (1.0–5.0)
+        label: İnsan okunabilir etiket (örn. "Ödeme Sistemi")
+        author: Korumayı ekleyen kişi
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        Yeni kaydın id'si
+    """
+    with get_connection(db_path) as conn:
+        cur = conn.execute(
+            """
+            INSERT INTO protected_modules
+                (file_path, min_understanding_threshold, label, added_by, added_at, is_active)
+            VALUES (?, ?, ?, ?, ?, 1)
+            ON CONFLICT(file_path) DO UPDATE SET
+                min_understanding_threshold = excluded.min_understanding_threshold,
+                label     = excluded.label,
+                added_by  = excluded.added_by,
+                added_at  = excluded.added_at,
+                is_active = 1
+            """,
+            (file_path, threshold, label, author, int(time.time())),
+        )
+        return cur.lastrowid or 0
+
+
+def unprotect_module(file_path: str, db_path: Path) -> bool:
+    """
+    Korumayı kaldır (is_active = 0 yap, kaydı silme).
+
+    Args:
+        file_path: Koruma kaldırılacak dosya yolu
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        Kayıt bulunup güncellendiyse True
+    """
+    with get_connection(db_path) as conn:
+        cur = conn.execute(
+            "UPDATE protected_modules SET is_active = 0 WHERE file_path = ?",
+            (file_path,),
+        )
+        return cur.rowcount > 0
+
+
+def _dosya_mevcut_skoru(file_path: str, db_path: Path) -> Optional[float]:
+    """DB'den dosyanın en güncel anlama skorunu çek."""
+    try:
+        with get_connection(db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT fs.understanding_score
+                FROM file_scores fs
+                JOIN commits c ON fs.commit_hash = c.commit_hash
+                WHERE fs.file_path = ? AND fs.understanding_score IS NOT NULL
+                ORDER BY c.timestamp DESC
+                LIMIT 1
+                """,
+                (file_path,),
+            ).fetchone()
+        return float(row["understanding_score"]) if row else None
+    except Exception:
+        return None
+
+
+def check_protected_modules(db_path: Path) -> list[ModulDurumu]:
+    """
+    Tüm aktif korumalı modülleri kontrol et, anlama eşiğini aşıp aşmadığını belirle.
+
+    Returns:
+        ModulDurumu listesi
+    """
+    try:
+        with get_connection(db_path) as conn:
+            kayitlar = conn.execute(
+                """
+                SELECT file_path, min_understanding_threshold, label, is_active
+                FROM protected_modules
+                WHERE is_active = 1
+                ORDER BY label
+                """
+            ).fetchall()
+    except Exception:
+        return []
+
+    sonuclar: list[ModulDurumu] = []
+    for k in kayitlar:
+        mevcut = _dosya_mevcut_skoru(k["file_path"], db_path)
+
+        if mevcut is None:
+            durum = _DURUM_BILINMIYOR
+        elif mevcut >= k["min_understanding_threshold"]:
+            durum = _DURUM_GUVENLI
+        else:
+            durum = _DURUM_IHLAL
+
+        sonuclar.append(
+            ModulDurumu(
+                dosya_yolu=k["file_path"],
+                etiket=k["label"] or k["file_path"],
+                esik=k["min_understanding_threshold"],
+                mevcut_skor=round(mevcut, 2) if mevcut is not None else None,
+                durum=durum,
+                aktif=bool(k["is_active"]),
+            )
+        )
+
+    return sonuclar
+
+
+def get_violations(db_path: Path) -> list[ModulDurumu]:
+    """
+    Sadece eşik altına düşmüş (İHLAL durumundaki) modülleri döndür.
+
+    Returns:
+        İhlaldeki ModulDurumu listesi
+    """
+    return [m for m in check_protected_modules(db_path) if m.durum == _DURUM_IHLAL]
+
+
+def ihlal_uyarisi_goster(db_path: Path) -> list[str]:
+    """
+    Post-commit hook için ihlal uyarılarını döndür.
+    Spam önlemek için son 1 saat içinde uyarı verilen modülleri atla.
+
+    Returns:
+        Uyarı mesajı listesi (boşsa ihlal yok)
+    """
+    ihlaller = get_violations(db_path)
+    if not ihlaller:
+        return []
+
+    su_an = int(time.time())
+    uyarilar: list[str] = []
+
+    for ihlal in ihlaller:
+        # Son uyarı zamanını kontrol et
+        try:
+            with get_connection(db_path) as conn:
+                row = conn.execute(
+                    "SELECT last_alert_at FROM protected_modules WHERE file_path = ?",
+                    (ihlal.dosya_yolu,),
+                ).fetchone()
+            son_uyari = row["last_alert_at"] if row and row["last_alert_at"] else 0
+        except Exception:
+            son_uyari = 0
+
+        if su_an - son_uyari < _MIN_UYARI_ARASI:
+            continue
+
+        # Uyarı zamanını güncelle
+        try:
+            with get_connection(db_path) as conn:
+                conn.execute(
+                    "UPDATE protected_modules SET last_alert_at = ? WHERE file_path = ?",
+                    (su_an, ihlal.dosya_yolu),
+                )
+        except Exception:
+            pass
+
+        skor_str = f"{ihlal.mevcut_skor:.1f}" if ihlal.mevcut_skor else "?"
+        uyarilar.append(
+            f"⚠️  UYARI: {ihlal.dosya_yolu} artık güvenle değiştirilemiyor "
+            f"(anlama: {skor_str} < eşik: {ihlal.esik:.1f})"
+        )
+
+    return uyarilar

codedna/rate_limit.py

@@ -0,0 +1,83 @@
+"""
+Basit in-memory rate limiter — brute-force koruması için.
+
+Production-grade değil (çok process ortamında çalışmaz, sunucu yeniden
+başlatıldığında sıfırlanır). Temel bir koruma katmanı sağlar.
+Production için Redis tabanlı bir çözüm tercih edilmeli.
+"""
+
+from __future__ import annotations
+
+import time
+from collections import defaultdict
+from threading import Lock
+from typing import Optional
+
+
+# Yapılandırma
+_MAX_DENEME = 5        # Bu süre içinde maksimum başarısız deneme
+_PENCERE_SANIYE = 300  # 5 dakikalık pencere
+_KILIT_SANIYE = 60     # Kilitlenme süresi (saniye)
+
+
+class RateLimiter:
+    """Thread-safe in-memory rate limiter."""
+
+    def __init__(
+        self,
+        max_deneme: int = _MAX_DENEME,
+        pencere: int = _PENCERE_SANIYE,
+        kilit: int = _KILIT_SANIYE,
+    ) -> None:
+        self._max_deneme = max_deneme
+        self._pencere = pencere
+        self._kilit = kilit
+        # {anahtar: [(timestamp, basarisiz_mi), ...]}
+        self._kayitlar: dict[str, list[tuple[int, bool]]] = defaultdict(list)
+        self._kilitler: dict[str, int] = {}  # {anahtar: kilit_bitis_zamani}
+        self._lock = Lock()
+
+    def kontrol_et(self, anahtar: str) -> tuple[bool, Optional[int]]:
+        """
+        İsteğe izin verip vermeyeceğini kontrol et.
+
+        Args:
+            anahtar: IP adresi veya e-posta gibi tanımlayıcı
+
+        Returns:
+            (izin_var, kalan_saniye) — kilitliyse kalan_saniye > 0
+        """
+        su_an = int(time.time())
+        with self._lock:
+            # Kilit kontrolü
+            kilit_bitis = self._kilitler.get(anahtar, 0)
+            if su_an < kilit_bitis:
+                return False, kilit_bitis - su_an
+
+            # Eski kayıtları temizle
+            pencere_basi = su_an - self._pencere
+            self._kayitlar[anahtar] = [
+                (ts, basarisiz)
+                for ts, basarisiz in self._kayitlar[anahtar]
+                if ts > pencere_basi
+            ]
+            return True, None
+
+    def basarisiz_kaydet(self, anahtar: str) -> None:
+        """Başarısız denemeyi kaydet, gerekirse kilitle."""
+        su_an = int(time.time())
+        with self._lock:
+            self._kayitlar[anahtar].append((su_an, True))
+            basarisiz = sum(1 for _, b in self._kayitlar[anahtar] if b)
+            if basarisiz >= self._max_deneme:
+                self._kilitler[anahtar] = su_an + self._kilit
+
+    def basarili_kaydet(self, anahtar: str) -> None:
+        """Başarılı girişte kaydı sıfırla."""
+        with self._lock:
+            self._kayitlar[anahtar] = []
+            self._kilitler.pop(anahtar, None)
+
+
+# Global limiter instance — login endpoint'i için
+login_limiter = RateLimiter()

codedna/scorer.py

@@ -0,0 +1,221 @@
+"""Git geçmişinden single_commit_ratio hesaplama ve commit skorlama."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from git import InvalidGitRepositoryError, Repo
+from rich.console import Console
+
+from codedna.analyzer import FileAnalysisResult, analyze_file
+
+console = Console()
+
+
+def get_repo(path: Optional[Path] = None) -> Optional[Repo]:
+    """Git repo nesnesini döndür, bulunamazsa None."""
+    try:
+        return Repo(path or Path.cwd(), search_parent_directories=True)
+    except InvalidGitRepositoryError:
+        return None
+
+
+def calculate_single_commit_ratio(repo: Repo, file_path: str) -> float:
+    """
+    Dosyanın kaç satırının tek bir commit'te eklendiğini hesapla.
+
+    Stratejisi: Dosyanın geçmiş commit'lerinde en büyük tek commit
+    katkısının toplam satıra oranını döndür.
+
+    Args:
+        repo: Git repo nesnesi
+        file_path: Repo köküne göre dosya yolu
+
+    Returns:
+        0.0 ile 1.0 arasında oran
+    """
+    try:
+        # Dosyayla ilgili commit geçmişini al
+        commitler = list(repo.iter_commits(paths=file_path, max_count=50))
+        if not commitler:
+            return 0.0
+
+        # Her commit'teki satır ekleme sayısını topla
+        commit_katkilar: list[int] = []
+        for commit in commitler:
+            try:
+                if commit.parents:
+                    diff = commit.parents[0].diff(commit, paths=[file_path])
+                else:
+                    # İlk commit
+                    diff = commit.diff(None, paths=[file_path])
+
+                for d in diff:
+                    if d.a_blob or d.b_blob:
+                        # Eklenen satır sayısını tahmin et
+                        try:
+                            stats = commit.stats.files.get(file_path, {})
+                            eklenen = stats.get("insertions", 0)
+                            commit_katkilar.append(eklenen)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        if not commit_katkilar:
+            # Fallback: tek commit varsa %100 say
+            return 1.0 if len(commitler) == 1 else 0.5
+
+        toplam = sum(commit_katkilar)
+        if toplam == 0:
+            return 0.0
+
+        en_buyuk = max(commit_katkilar)
+        return min(en_buyuk / toplam, 1.0)
+
+    except Exception:
+        return 0.0
+
+
+def scan_repository(
+    repo_path: Optional[Path] = None,
+    max_files: int = 200,
+) -> list[FileAnalysisResult]:
+    """
+    Repo'daki desteklenen tüm dosyaları tara.
+
+    Önemli: Git reposu varsa SADECE git'in izlediği dosyalar taranır.
+    Bu sayede .gitignore'daki build çıktıları (`.next/`, `out/`,
+    `node_modules/` vb.) otomatik olarak dışarıda kalır.
+    Git reposu yoksa (henüz `git init` edilmemiş dizin) eski davranışa
+    devam edilir — dizin bazlı filtreleme uygulanır.
+
+    Args:
+        repo_path: Repo kök dizini (None ise mevcut dizin)
+        max_files: Maksimum taranacak dosya sayısı
+
+    Returns:
+        FileAnalysisResult listesi
+    """
+    kok = Path(repo_path or Path.cwd()).resolve()
+    repo = get_repo(kok)
+
+    desteklenen_uzantilar = {".py", ".js", ".jsx", ".ts", ".tsx"}
+
+    # Dizin bazlı kara liste — git olmayan repolar + ekstra güvenlik katmanı
+    atlanan_dizinler = {
+        ".git", "__pycache__", "node_modules", ".venv", "venv",
+        "dist", "build", ".mypy_cache", ".pytest_cache",
+        ".next",      # Next.js build çıktısı
+        "out",        # Next.js static export / tsc çıktısı
+        ".turbo",     # Turborepo önbelleği
+        ".parcel-cache",
+        "coverage",
+        ".nyc_output",
+    }
+
+    # Git'in izlediği dosyalar — bu liste asıl filtre olarak kullanılır
+    izlenen_dosyalar: set[str] = set()
+    if repo:
+        try:
+            izlenen_dosyalar = {item for item in repo.git.ls_files().splitlines()}
+        except Exception:
+            pass
+
+    sonuclar: list[FileAnalysisResult] = []
+    sayac = 0
+
+    for dosya in kok.rglob("*"):
+        if sayac >= max_files:
+            break
+
+        # Kara listedeki dizinleri geç (git olmayan repolar için de çalışır)
+        parcalar = dosya.parts
+        if any(atla in parcalar for atla in atlanan_dizinler):
+            continue
+
+        if not dosya.is_file():
+            continue
+
+        if dosya.suffix.lower() not in desteklenen_uzantilar:
+            continue
+
+        goreceli_yol = str(dosya.relative_to(kok))
+
+        # Asıl fix: Git reposu varsa SADECE git'in takip ettiği dosyaları tara.
+        # Bu, .gitignore'daki tüm build/üretilen dosyaları otomatik dışlar.
+        # Git yoksa bu filtreyi atla — dizin kara listesi yeterli koruma sağlar.
+        if repo and izlenen_dosyalar and goreceli_yol not in izlenen_dosyalar:
+            continue
+
+        # single_commit_ratio hesapla (git izliyorsa)
+        tek_commit_orani = 0.0
+        if repo and goreceli_yol in izlenen_dosyalar:
+            tek_commit_orani = calculate_single_commit_ratio(repo, goreceli_yol)
+
+        sonuc = analyze_file(dosya, single_commit_ratio=tek_commit_orani)
+        if not sonuc.desteklenmiyor and sonuc.hata is None:
+            sonuclar.append(sonuc)
+            sayac += 1
+
+    return sonuclar
+
+
+def get_commit_files(repo: Repo, commit_hash: Optional[str] = None) -> list[str]:
+    """
+    Belirli bir commit'teki (ya da HEAD'deki) değişen dosyaları listele.
+
+    Args:
+        repo: Git repo nesnesi
+        commit_hash: İncelenecek commit hash'i (None ise HEAD)
+
+    Returns:
+        Değişen dosyaların yol listesi
+    """
+    try:
+        if commit_hash:
+            commit = repo.commit(commit_hash)
+        else:
+            commit = repo.head.commit
+
+        return list(commit.stats.files.keys())
+    except Exception:
+        return []
+
+
+def score_latest_commit(repo_path: Optional[Path] = None) -> tuple[Optional[str], list[FileAnalysisResult]]:
+    """
+    Son commit'teki dosyaları analiz et.
+
+    Returns:
+        (commit_hash, sonuç_listesi) çifti
+    """
+    kok = Path(repo_path or Path.cwd()).resolve()
+    repo = get_repo(kok)
+    if not repo:
+        return None, []
+
+    try:
+        commit = repo.head.commit
+        commit_hash = commit.hexsha
+        dosyalar = get_commit_files(repo, commit_hash)
+    except Exception:
+        return None, []
+
+    sonuclar: list[FileAnalysisResult] = []
+    desteklenen_uzantilar = {".py", ".js", ".jsx", ".ts", ".tsx"}
+
+    for dosya_yolu in dosyalar:
+        tam_yol = kok / dosya_yolu
+        if not tam_yol.exists():
+            continue
+        if tam_yol.suffix.lower() not in desteklenen_uzantilar:
+            continue
+
+        tek_commit_orani = calculate_single_commit_ratio(repo, dosya_yolu)
+        sonuc = analyze_file(tam_yol, single_commit_ratio=tek_commit_orani)
+        if not sonuc.desteklenmiyor and sonuc.hata is None:
+            sonuclar.append(sonuc)
+
+    return commit_hash, sonuclar

codedna/sprint_health.py

@@ -0,0 +1,187 @@
+"""Sprint bazlı kod sağlığı skoru hesaplama."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from codedna.db import get_connection, get_sprint_history, save_sprint
+
+# Sağlık skoru eşikleri (0-100)
+_SAGLIKLI_ESIK = 80
+_DIKKAT_ESIK = 50
+
+# Yüksek riskli AI eşiği
+_YUKSEK_RISK_AI = 0.7
+
+
+@dataclass
+class SprintSonucu:
+    """Tek sprint'in sağlık analizi."""
+
+    sprint_adi: str
+    baslangic: datetime
+    bitis: datetime
+    health_score: float            # 0-100
+    durum: str                     # SAĞLIKLI / DİKKAT / RİSKLİ
+    avg_understanding: Optional[float]
+    ai_orani: float                # yüksek riskli AI dosyalarının oranı
+    debt_delta_saati: float        # borç değişimi (+ = arttı, - = azaldı)
+    toplam_commit: int
+    ai_satir: int
+    insan_satir: int
+
+    @property
+    def ai_insan_orani_str(self) -> str:
+        """AI/insan oranını yüzde string olarak döndür."""
+        toplam = self.ai_satir + self.insan_satir
+        if toplam == 0:
+            return "N/A"
+        ai_pct = self.ai_satir / toplam * 100
+        return f"%{ai_pct:.0f} AI / %{100-ai_pct:.0f} İnsan"
+
+
+def _durum_belirle(skor: float) -> str:
+    """Skor aralığına göre durum etiketi döndür."""
+    if skor >= _SAGLIKLI_ESIK:
+        return "SAĞLIKLI"
+    elif skor >= _DIKKAT_ESIK:
+        return "DİKKAT"
+    return "RİSKLİ"
+
+
+def calculate_sprint_health(
+    repo_path: Path,
+    db_path: Path,
+    start_date: datetime,
+    end_date: datetime,
+    sprint_adi: str = "Sprint",
+) -> SprintSonucu:
+    """
+    Verilen tarih aralığındaki commitleri analiz edip sprint sağlık skoru üret.
+
+    Health score formülü (0-100):
+      - anlama_puani = (avg_understanding / 5) * 40       max 40 puan
+      - ai_dengesi   = (1 - yüksek_riskli_ai_orani) * 30  max 30 puan
+      - borc_trendi  = max(0, 1 - delta_oran) * 30         max 30 puan
+
+    Args:
+        repo_path: Git repo kök dizini
+        db_path: SQLite veritabanı yolu
+        start_date: Sprint başlangıç tarihi
+        end_date: Sprint bitiş tarihi
+        sprint_adi: Sprint ismi
+
+    Returns:
+        SprintSonucu nesnesi
+    """
+    start_ts = int(start_date.timestamp())
+    end_ts = int(end_date.timestamp())
+
+    # Sprint tarih aralığındaki commit'leri ve dosya skorlarını çek
+    try:
+        with get_connection(db_path) as conn:
+            commitler = conn.execute(
+                """
+                SELECT c.commit_hash, c.understanding_score, c.timestamp
+                FROM commits c
+                WHERE c.timestamp >= ? AND c.timestamp <= ?
+                ORDER BY c.timestamp ASC
+                """,
+                (start_ts, end_ts),
+            ).fetchall()
+    except Exception:
+        commitler = []
+
+    toplam_commit = len(commitler)
+
+    # Dosya skorlarını topla
+    ai_skorlari: list[float] = []
+    anlama_skorlari: list[float] = []
+
+    try:
+        with get_connection(db_path) as conn:
+            for commit in commitler:
+                dosyalar = conn.execute(
+                    """
+                    SELECT ai_probability, understanding_score
+                    FROM file_scores
+                    WHERE commit_hash = ?
+                    """,
+                    (commit["commit_hash"],),
+                ).fetchall()
+                for d in dosyalar:
+                    if d["ai_probability"] is not None:
+                        ai_skorlari.append(float(d["ai_probability"]))
+                    if d["understanding_score"] is not None:
+                        anlama_skorlari.append(float(d["understanding_score"]))
+    except Exception:
+        pass
+
+    # Ortalama anlama skoru
+    avg_anlama = (
+        sum(anlama_skorlari) / len(anlama_skorlari)
+        if anlama_skorlari else None
+    )
+
+    # Yüksek riskli AI oranı (>= 0.7)
+    yuksek_riskli = sum(1 for a in ai_skorlari if a >= _YUKSEK_RISK_AI)
+    ai_orani = yuksek_riskli / len(ai_skorlari) if ai_skorlari else 0.0
+
+    # AI / insan satır tahmini (AI skoru > 0.5 → AI satır sayılır)
+    ai_satir = sum(1 for a in ai_skorlari if a > 0.5) * 50  # yaklaşık
+    insan_satir = max(len(ai_skorlari) * 50 - ai_satir, 0)
+
+    # Teknik borç delta'sı — tüm repo borcu hesapla (sprint başı/sonu farkı yok,
+    # mevcut durumu baz al, negatif = borç azaldı yorumu)
+    from codedna.tech_debt import calculate_repo_debt
+    try:
+        ozet = calculate_repo_debt(repo_path, db_path)
+        debt_delta = ozet.toplam_debt_saatleri / max(toplam_commit, 1)
+    except Exception:
+        debt_delta = 0.0
+
+    # ---- Health score hesapla ----
+    # 1. Anlama puanı (max 40)
+    anlama_puani = ((avg_anlama / 5.0) * 40.0) if avg_anlama is not None else 20.0
+
+    # 2. AI denge puanı (max 30)
+    ai_dengesi = (1.0 - ai_orani) * 30.0
+
+    # 3. Borç trendi puanı (max 30) — debt_delta küçükse iyi
+    delta_oran = min(debt_delta / 10.0, 1.0)   # 10 saate normalize
+    borc_trendi = max(0.0, 1.0 - delta_oran) * 30.0
+
+    health_score = round(anlama_puani + ai_dengesi + borc_trendi, 1)
+    durum = _durum_belirle(health_score)
+
+    return SprintSonucu(
+        sprint_adi=sprint_adi,
+        baslangic=start_date,
+        bitis=end_date,
+        health_score=health_score,
+        durum=durum,
+        avg_understanding=round(avg_anlama, 2) if avg_anlama is not None else None,
+        ai_orani=round(ai_orani, 3),
+        debt_delta_saati=round(debt_delta, 2),
+        toplam_commit=toplam_commit,
+        ai_satir=ai_satir,
+        insan_satir=insan_satir,
+    )
+
+
+def save_sprint_result(sonuc: SprintSonucu, db_path: Path) -> int:
+    """Sprint sonucunu DB'ye kaydet, yeni id döndür."""
+    return save_sprint(
+        sprint_name=sonuc.sprint_adi,
+        start_date=int(sonuc.baslangic.timestamp()),
+        end_date=int(sonuc.bitis.timestamp()),
+        total_lines_ai=sonuc.ai_satir,
+        total_lines_human=sonuc.insan_satir,
+        avg_understanding=sonuc.avg_understanding,
+        debt_delta_hours=sonuc.debt_delta_saati,
+        health_score=sonuc.health_score,
+        db_path=db_path,
+    )