codedna 0.2.0__py3-none-any.whl

codedna/__init__.py

@@ -0,0 +1,4 @@
+"""CodeDNA — AI Kod Şeffaflık Aracı."""
+
+__version__ = "0.1.0"
+__app_name__ = "codedna"

codedna/ai_fingerprint.py

@@ -0,0 +1,223 @@
+"""
+Farklı AI kod asistanlarının bıraktığı örüntüleri ayırt eder.
+
+ÖNEMLİ UYARI:
+  Bu kesin bir tespit DEĞİL — örüntü tabanlı sezgisel bir TAHMİN modelidir.
+  Sonuçlar yanlış pozitif/negatif içerebilir. Kesinlik iddia edilmez.
+  Kullanıcıya bu bağlamda sunulmalıdır.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from codedna.db import get_connection
+
+
+# ---------------------------------------------------------------------------
+# Araç örüntü tanımları — sezgisel, savunulabilir ama kesin değil
+# ---------------------------------------------------------------------------
+
+# Her araç için ağırlıklı örüntü listesi: (regex_pattern, ağırlık)
+_ARAC_ORNUNTULERI: dict[str, list[tuple[str, float]]] = {
+    "copilot": [
+        # GitHub Copilot: kısa, özlü satır içi yorumlar, tip bildirimleri yok
+        (r"#\s+[A-Z][a-z].{5,40}$", 0.15),           # tek satır başlık yorum
+        (r"def \w+\([^)]{0,30}\):\s*$", 0.10),        # parametresiz/minimal fonksiyon
+        (r"#\s+TODO:", 0.10),                          # TODO yorumları
+        (r"^\s{4}pass\s*$", 0.08),                     # pass ile biten fonksiyonlar
+        (r"return \w+\.get\(", 0.07),                  # .get() pattern
+    ],
+    "cursor": [
+        # Cursor: detaylı docstring, tip ipucu zenginliği
+        (r'"""[\s\S]{20,200}"""', 0.20),               # uzun docstring
+        (r":\s*(str|int|float|bool|list|dict|Optional)", 0.15),  # tip ipuçları
+        (r"->.*:\s*$", 0.12),                          # dönüş tipi bildirimi
+        (r"from typing import", 0.10),                 # typing modülü
+        (r"@dataclass", 0.10),                         # dataclass kullanımı
+    ],
+    "claude": [
+        # Claude: yapılandırılmış çok satırlı açıklamalar, Türkçe/çok dilli yorum
+        (r"#\s+\d+\.\s+\w", 0.18),                    # numaralı adım yorumları
+        (r"\"\"\"[\s\S]*Args:[\s\S]*Returns:", 0.20),  # Args/Returns docstring
+        (r"#\s+─{3,}", 0.15),                          # ayırıcı çizgi yorumlar
+        (r"raise \w+Error\(f[\"']", 0.10),             # f-string hata mesajları
+        (r"from __future__ import annotations", 0.12), # modern annotation
+    ],
+}
+
+# Minimum güven eşiği — altındaysa "unknown" döndür
+_MIN_GUVEN = 0.15
+
+
+@dataclass
+class AIAracTahmini:
+    """Tek dosya için AI araç tahmini."""
+
+    arac: str              # "copilot" | "cursor" | "claude" | "unknown"
+    guven: float           # 0.0–1.0
+    puan_detayi: dict[str, float]  # araç → ham puan
+    uyari: str = (
+        "Bu tespit örüntü tabanlı bir tahmindir — kesin değildir."
+    )
+
+
+def guess_ai_tool(file_path: str, code: str) -> AIAracTahmini:
+    """
+    Dosya için olası AI aracı tahmini ve güven skoru döndür.
+
+    Strateji:
+      Her araç için tanımlı regex örüntüleri koda uygulanır, ağırlıklı
+      eşleşme sayısına göre toplam puan hesaplanır. En yüksek puanlı
+      araç, minimum güven eşiğini geçiyorsa seçilir.
+
+    Args:
+        file_path: Dosya yolu (uzantı filtresi için kullanılır)
+        code: Dosyanın kaynak kodu
+
+    Returns:
+        AIAracTahmini nesnesi
+    """
+    satirlar = code.splitlines()
+    puan: dict[str, float] = {arac: 0.0 for arac in _ARAC_ORNUNTULERI}
+
+    for arac, ornuntular in _ARAC_ORNUNTULERI.items():
+        for desen, agirlik in ornuntular:
+            eslesme_sayisi = sum(
+                1 for satir in satirlar if re.search(desen, satir)
+            )
+            # Satır sayısına normalize et (büyük dosyalarda haksız avantajı engelle)
+            norm = eslesme_sayisi / max(len(satirlar), 1)
+            puan[arac] += norm * agirlik * 10  # 0-10 arası ölçek
+
+    # Normalize et — toplam puana göre güven hesapla
+    toplam = sum(puan.values())
+    if toplam < 0.01:
+        return AIAracTahmini(
+            arac="unknown",
+            guven=0.0,
+            puan_detayi={k: round(v, 3) for k, v in puan.items()},
+        )
+
+    en_iyi_arac = max(puan, key=lambda k: puan[k])
+    guven = puan[en_iyi_arac] / toplam
+
+    # Minimum eşiği geçemiyen → unknown
+    if guven < _MIN_GUVEN:
+        en_iyi_arac = "unknown"
+
+    return AIAracTahmini(
+        arac=en_iyi_arac,
+        guven=round(guven, 3),
+        puan_detayi={k: round(v, 3) for k, v in puan.items()},
+    )
+
+
+def analyze_repo_tools(
+    repo_path: Path,
+    db_path: Path,
+) -> dict[str, dict[str, float]]:
+    """
+    Repo genelinde araç bazlı dosya analizi yap ve sonuçları DB'ye kaydet.
+
+    Returns:
+        {arac: {"dosya_sayisi": N, "avg_ai_probability": X}} sözlüğü
+    """
+    from codedna.scorer import scan_repository
+    from codedna.db import get_connection
+
+    desteklenen = {".py", ".js", ".jsx", ".ts", ".tsx"}
+    sonuclar = scan_repository(repo_path, max_files=200)
+
+    # Araç sayaçları
+    arac_istatistik: dict[str, dict[str, list]] = {
+        "copilot": {"ai_prob": [], "understanding": []},
+        "cursor":  {"ai_prob": [], "understanding": []},
+        "claude":  {"ai_prob": [], "understanding": []},
+        "unknown": {"ai_prob": [], "understanding": []},
+    }
+
+    for sonuc in sonuclar:
+        if Path(sonuc.file_path).suffix.lower() not in desteklenen:
+            continue
+        try:
+            kod = Path(sonuc.file_path).read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+
+        tahmin = guess_ai_tool(sonuc.file_path, kod)
+
+        # DB'ye kaydet — en son file_score kaydını güncelle
+        try:
+            with get_connection(db_path) as conn:
+                conn.execute(
+                    """
+                    UPDATE file_scores
+                    SET ai_tool_guess = ?
+                    WHERE file_path = ?
+                      AND id = (
+                          SELECT id FROM file_scores
+                          WHERE file_path = ?
+                          ORDER BY id DESC LIMIT 1
+                      )
+                    """,
+                    (tahmin.arac, sonuc.file_path, sonuc.file_path),
+                )
+        except Exception:
+            pass
+
+        if tahmin.arac in arac_istatistik:
+            arac_istatistik[tahmin.arac]["ai_prob"].append(sonuc.ai_probability)
+        else:
+            arac_istatistik["unknown"]["ai_prob"].append(sonuc.ai_probability)
+
+    # DB'den anlama skorlarını araç bazlı topla
+    try:
+        with get_connection(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT fs.ai_tool_guess, fs.understanding_score
+                FROM file_scores fs
+                WHERE fs.ai_tool_guess IS NOT NULL
+                  AND fs.understanding_score IS NOT NULL
+                """
+            ).fetchall()
+            for r in rows:
+                arac = r["ai_tool_guess"] or "unknown"
+                if arac in arac_istatistik:
+                    arac_istatistik[arac]["understanding"].append(
+                        float(r["understanding_score"])
+                    )
+    except Exception:
+        pass
+
+    # Sonuçları hesapla
+    cikti: dict[str, dict[str, float]] = {}
+    for arac, veri in arac_istatistik.items():
+        if not veri["ai_prob"]:
+            continue
+        avg_ai = sum(veri["ai_prob"]) / len(veri["ai_prob"])
+        avg_und = (
+            sum(veri["understanding"]) / len(veri["understanding"])
+            if veri["understanding"] else None
+        )
+        cikti[arac] = {
+            "dosya_sayisi": len(veri["ai_prob"]),
+            "avg_ai_probability": round(avg_ai, 3),
+            "avg_understanding": round(avg_und, 2) if avg_und is not None else None,
+        }
+
+    return cikti
+
+
+def compare_tools_in_repo(repo_path: Path, db_path: Path) -> dict:
+    """
+    Repo genelinde araç bazlı ortalama anlama skoru ve AI olasılığı karşılaştırması.
+
+    Returns:
+        {"copilot": {...}, "cursor": {...}, ...} sözlüğü
+    """
+    return analyze_repo_tools(repo_path, db_path)

codedna/analyzer.py

@@ -0,0 +1,245 @@
+"""AST analizi ve AI imza tespiti modülü."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import tree_sitter_python as tspython
+import tree_sitter_javascript as tsjavascript
+from tree_sitter import Language, Parser, Node
+
+# TypeScript parser — kurulu değilse JS parser'a geri dön
+try:
+    import tree_sitter_typescript as tstypescript
+    _TS_LANG = tstypescript.language_typescript()
+    _TSX_LANG = tstypescript.language_tsx()
+    _TS_AVAILABLE = True
+except Exception:
+    _TS_LANG = tsjavascript.language()
+    _TSX_LANG = tsjavascript.language()
+    _TS_AVAILABLE = False
+
+# Desteklenen dil eşlemesi
+LANGUAGE_MAP: dict[str, tuple] = {
+    ".py":  ("python",     tspython.language()),
+    ".js":  ("javascript", tsjavascript.language()),
+    ".jsx": ("javascript", tsjavascript.language()),
+    ".ts":  ("typescript", _TS_LANG),
+    ".tsx": ("tsx",        _TSX_LANG),
+}
+
+
+@dataclass
+class FileAnalysisResult:
+    """Tek bir dosyanın analiz sonucu."""
+
+    file_path: str
+    ai_probability: float = 0.0
+    complexity_score: float = 0.0
+    comment_ratio: float = 0.0
+    avg_function_length: float = 0.0
+    single_commit_ratio: float = 0.0
+    total_lines: int = 0
+    function_count: int = 0
+    desteklenmiyor: bool = False
+    hata: Optional[str] = None
+
+    @property
+    def complexity_label(self) -> str:
+        """Karmaşıklık seviyesini metin olarak döndür."""
+        if self.complexity_score < 5:
+            return "Düşük"
+        elif self.complexity_score < 15:
+            return "Orta"
+        else:
+            return "Yüksek"
+
+    @property
+    def ai_color(self) -> str:
+        """AI olasılığına göre renk emojisi döndür."""
+        if self.ai_probability >= 0.7:
+            return "🔴"
+        elif self.ai_probability >= 0.4:
+            return "🟡"
+        else:
+            return "🟢"
+
+
+def _build_parser(ext: str) -> Optional[Parser]:
+    """Dosya uzantısına göre tree-sitter parser oluştur."""
+    if ext not in LANGUAGE_MAP:
+        return None
+    _, lang_obj = LANGUAGE_MAP[ext]
+    language = Language(lang_obj)
+    parser = Parser(language)
+    return parser
+
+
+def _count_lines(source: str) -> tuple[int, int]:
+    """Toplam satır ve yorum satırı sayısını döndür (toplam, yorum)."""
+    lines = source.splitlines()
+    toplam = len(lines)
+    yorum = 0
+    for line in lines:
+        stripped = line.strip()
+        # Python, JS, TS tek satır yorumları
+        if stripped.startswith("#") or stripped.startswith("//"):
+            yorum += 1
+        # Çok satırlı yorum içinde olup olmadığını basit regex ile yakala
+        elif stripped.startswith("*") or stripped.startswith("/*") or stripped.startswith('"""') or stripped.startswith("'''"):
+            yorum += 1
+    return toplam, yorum
+
+
+def _collect_functions(node: Node, functions: list[Node]) -> None:
+    """Ağaç içindeki tüm fonksiyon düğümlerini özyinelemeli topla."""
+    fonksiyon_tipleri = {
+        "function_definition",      # Python
+        "function_declaration",     # JS/TS
+        "method_definition",        # JS/TS class method
+        "method_signature",         # TS interface method
+        "abstract_method_signature",# TS abstract
+        "arrow_function",           # JS/TS arrow
+        "function_expression",      # JS/TS
+        "generator_function",       # JS/TS generator
+        "generator_function_declaration",
+    }
+    if node.type in fonksiyon_tipleri:
+        functions.append(node)
+    for child in node.children:
+        _collect_functions(child, functions)
+
+
+def _calculate_cyclomatic_complexity(node: Node) -> float:
+    """
+    Basit cyclomatic complexity hesapla.
+    Karar noktalarını (if, for, while, case, &&, ||) say.
+    """
+    karar_tipleri = {
+        "if_statement", "elif_clause", "for_statement", "while_statement",
+        "with_statement", "try_statement", "except_clause",
+        "if_expression",  # Python ternary
+        "switch_case", "case_clause",
+        # JS/TS
+        "if", "for", "while", "switch", "catch",
+        "ternary_expression",
+        "&&", "||", "??",
+    }
+    sayac = 1  # Temel yol
+
+    def _gez(n: Node) -> None:
+        nonlocal sayac
+        if n.type in karar_tipleri:
+            sayac += 1
+        # Mantıksal operatörler
+        if n.type in {"boolean_operator", "logical_expression"}:
+            sayac += 1
+        for child in n.children:
+            _gez(child)
+
+    _gez(node)
+    return float(sayac)
+
+
+def analyze_file(
+    file_path: Path,
+    single_commit_ratio: float = 0.0,
+) -> FileAnalysisResult:
+    """
+    Dosyayı AST ile analiz et ve AI imza metriklerini hesapla.
+
+    Args:
+        file_path: Analiz edilecek dosyanın yolu
+        single_commit_ratio: Tek commit'te gelen satır oranı (dışarıdan verilir)
+
+    Returns:
+        FileAnalysisResult nesnesi
+    """
+    sonuc = FileAnalysisResult(
+        file_path=str(file_path),
+        single_commit_ratio=single_commit_ratio,
+    )
+
+    # Dosya okunabilir mi?
+    try:
+        kaynak = file_path.read_text(encoding="utf-8", errors="replace")
+    except Exception as e:
+        sonuc.hata = f"Dosya okunamadı: {e}"
+        return sonuc
+
+    ext = file_path.suffix.lower()
+    parser = _build_parser(ext)
+
+    if parser is None:
+        sonuc.desteklenmiyor = True
+        return sonuc
+
+    # Satır sayıları
+    toplam_satir, yorum_satir = _count_lines(kaynak)
+    sonuc.total_lines = toplam_satir
+    sonuc.comment_ratio = (yorum_satir / toplam_satir) if toplam_satir > 0 else 0.0
+
+    # AST parse
+    try:
+        tree = parser.parse(bytes(kaynak, "utf8"))
+    except Exception as e:
+        sonuc.hata = f"AST parse hatası: {e}"
+        return sonuc
+
+    # Fonksiyon analizi
+    fonksiyonlar: list[Node] = []
+    _collect_functions(tree.root_node, fonksiyonlar)
+    sonuc.function_count = len(fonksiyonlar)
+
+    if fonksiyonlar:
+        uzunluklar = [
+            f.end_point[0] - f.start_point[0] + 1
+            for f in fonksiyonlar
+        ]
+        sonuc.avg_function_length = sum(uzunluklar) / len(uzunluklar)
+    else:
+        # Fonksiyon yoksa toplam satırı tek blok say
+        sonuc.avg_function_length = float(toplam_satir)
+
+    # Cyclomatic complexity (tüm dosya üzerinden)
+    sonuc.complexity_score = _calculate_cyclomatic_complexity(tree.root_node)
+
+    # AI olasılığı hesapla
+    sonuc.ai_probability = _calculate_ai_probability(sonuc)
+
+    return sonuc
+
+
+def _calculate_ai_probability(sonuc: FileAnalysisResult) -> float:
+    """
+    Kural tabanlı AI olasılığı skoru hesapla (0.0 – 1.0).
+
+    Kurallar:
+      - comment_ratio > 0.3       → +0.20
+      - avg_function_length > 50  → +0.15
+      - single_commit_ratio > 0.7 → +0.30
+      - complexity yüksek & tek commit → +0.25
+    """
+    skor = 0.0
+
+    # Kural 1: Aşırı yorum oranı (AI kodu genelde çok yorum yazar)
+    if sonuc.comment_ratio > 0.3:
+        skor += 0.20
+
+    # Kural 2: Uzun fonksiyonlar (AI genelde büyük bloklar üretir)
+    if sonuc.avg_function_length > 50:
+        skor += 0.15
+
+    # Kural 3: Tek commit'te büyük değişiklik (toplu yapıştırma işareti)
+    if sonuc.single_commit_ratio > 0.7:
+        skor += 0.30
+
+    # Kural 4: Yüksek karmaşıklık + tek seferlik commit
+    if sonuc.complexity_score > 10 and sonuc.single_commit_ratio > 0.5:
+        skor += 0.25
+
+    # 0.0 – 1.0 arasına normalize et
+    return min(skor, 1.0)