codedna 0.2.0__py3-none-any.whl

codedna/interview.py

@@ -0,0 +1,298 @@
+"""
+Aday değerlendirme — kodbase anlama testi.
+
+ÖNEMLİ UYARI:
+  Bu araç insan değerlendirmesinin YERİNE GEÇMEZ. Tamamlayıcı bir sinyaldir.
+  Tek başına işe alım kararı için kullanılmamalıdır.
+  Otomatik puanlama bu fazda eklenmiyor — insan değerlendiricisi skorу manuel girer.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from codedna.db import get_connection
+
+# Zorluk → karmaşıklık skoru eşikleri
+_ZORLU_ESIKLER = {
+    "easy":   (0.0, 5.0),   # düşük karmaşıklık
+    "medium": (5.0, 15.0),  # orta karmaşıklık
+    "hard":   (15.0, 999.),  # yüksek karmaşıklık
+}
+
+# Anonimleştirme: yaygın tanımlayıcı kalıpları jenerik isimlerle değiştir
+_ANONIMLESTIME_KALIPLARI: list[tuple[str, str]] = [
+    (r'\b(payment|charge|invoice|billing)\b', 'transaction'),
+    (r'\b(user|account|customer|member)\b', 'entity'),
+    (r'\b(password|secret|token|key|credential)\b', 'credential'),
+    (r'\b(database|db|repository|repo|store)\b', 'storage'),
+    (r'\b(email|phone|address|contact)\b', 'contact_info'),
+]
+
+
+@dataclass
+class MulakatDosyasi:
+    """Mülakat için seçilmiş dosya bilgisi."""
+
+    dosya_yolu: str
+    anonimlestirilmis_kod: str
+    karmasiklik_skoru: float
+    zorluk: str
+    satir_sayisi: int
+
+
+def _kod_anonimize_et(kod: str) -> str:
+    """
+    Kaynak kodu anonimleştir — iş mantığını açık eden tanımlayıcıları
+    jenerik isimlerle değiştir. Kod yapısını ve mantığını korur.
+
+    Args:
+        kod: Ham kaynak kodu
+
+    Returns:
+        Anonimleştirilmiş kod
+    """
+    sonuc = kod
+    for kalip, yeni in _ANONIMLESTIME_KALIPLARI:
+        sonuc = re.sub(kalip, yeni, sonuc, flags=re.IGNORECASE)
+    return sonuc
+
+
+def select_candidate_file(
+    repo_path: Path,
+    db_path: Path,
+    difficulty: str = "medium",
+) -> Optional[MulakatDosyasi]:
+    """
+    Repo'dan mülakat için uygun bir dosya seç.
+
+    Seçim kriterleri:
+      - İstenen zorluk aralığındaki karmaşıklık skoru
+      - Korumalı modüller HİÇBİR ZAMAN seçilmez
+      - En az 20, en fazla 200 satır
+      - Desteklenen uzantı (.py, .js, .ts)
+
+    Args:
+        repo_path: Git repo kök dizini
+        db_path: SQLite veritabanı yolu
+        difficulty: "easy" | "medium" | "hard"
+
+    Returns:
+        MulakatDosyasi nesnesi veya uygun dosya yoksa None
+    """
+    from codedna.scorer import scan_repository
+    from codedna.protection import check_protected_modules
+
+    alt_esik, ust_esik = _ZORLU_ESIKLER.get(difficulty, _ZORLU_ESIKLER["medium"])
+
+    # Korumalı modülleri al — bunlar asla seçilmez
+    korunanlari = {
+        m.dosya_yolu
+        for m in check_protected_modules(db_path)
+    }
+
+    taranan = scan_repository(repo_path, max_files=200)
+
+    uygun = [
+        s for s in taranan
+        if alt_esik <= s.complexity_score < ust_esik
+        and s.file_path not in korunanlari
+        and 20 <= s.total_lines <= 200
+    ]
+
+    if not uygun:
+        return None
+
+    # En ortanca karmaşıklığa sahip dosyayı seç (çok kolay/zor olmasın)
+    uygun.sort(key=lambda s: abs(s.complexity_score - (alt_esik + ust_esik) / 2))
+    secilen = uygun[0]
+
+    try:
+        kod = Path(secilen.file_path).read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return None
+
+    anonimlestirilmis = _kod_anonimize_et(kod)
+
+    return MulakatDosyasi(
+        dosya_yolu=secilen.file_path,
+        anonimlestirilmis_kod=anonimlestirilmis,
+        karmasiklik_skoru=round(secilen.complexity_score, 1),
+        zorluk=difficulty,
+        satir_sayisi=secilen.total_lines,
+    )
+
+
+def generate_questions(code: str) -> list[str]:
+    """
+    Koddan otomatik 3 anlama sorusu üret.
+
+    Şablon tabanlı üretim — AI çağrısı gerektirmez, kod yapısından çıkarım.
+    Üretilen sorular her zaman genel, spesifik iş mantığına bağlı değil.
+
+    Args:
+        code: Kaynak kodu (anonimleştirilmiş olabilir)
+
+    Returns:
+        3 soruluk liste
+    """
+    satirlar = code.splitlines()
+    fonksiyon_sayisi = sum(
+        1 for s in satirlar
+        if re.match(r'\s*(def |function |async function )', s)
+    )
+    kos_sayisi = sum(
+        1 for s in satirlar
+        if re.search(r'\b(if|else|elif|for|while|try|except|catch)\b', s)
+    )
+    donduruyor_mu = any("return " in s for s in satirlar)
+
+    sorular = [
+        "Bu kodu okuduğunuzda ana fonksiyonun/metodun birincil amacı ne?",
+        f"Bu kod {fonksiyon_sayisi} fonksiyon/metod içeriyor. "
+        f"Hangisi en kritik iş mantığını taşıyor ve neden?",
+    ]
+
+    if kos_sayisi > 3:
+        sorular.append(
+            f"Kodda {kos_sayisi} dal/koşul var. Hangi koşul en önemli hata senaryosunu ele alıyor?"
+        )
+    elif donduruyor_mu:
+        sorular.append(
+            "Bu fonksiyon hangi koşulda beklenmedik bir değer döndürebilir? "
+            "Bu durumu nasıl debug ederdiniz?"
+        )
+    else:
+        sorular.append(
+            "Bu koda bir test yazmanız gerekse, önce hangi davranışı test ederdiniz?"
+        )
+
+    return sorular[:3]
+
+
+def start_session(
+    candidate_name: str,
+    file_path: str,
+    questions: list[str],
+    db_path: Path,
+    created_by: str = "system",
+) -> int:
+    """
+    Yeni mülakat oturumu başlat.
+
+    Args:
+        candidate_name: Aday adı
+        file_path: Test edilen dosyanın yolu
+        questions: Sorulan soru listesi
+        db_path: SQLite veritabanı yolu
+        created_by: Oturumu başlatan kişi
+
+    Returns:
+        Yeni oturum id'si
+    """
+    with get_connection(db_path) as conn:
+        cur = conn.execute(
+            """
+            INSERT INTO interview_sessions
+                (candidate_name, file_path, started_at, questions_json, created_by)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (
+                candidate_name,
+                file_path,
+                int(time.time()),
+                json.dumps(questions, ensure_ascii=False),
+                created_by,
+            ),
+        )
+        return cur.lastrowid or 0
+
+
+def submit_score(
+    session_id: int,
+    score: float,
+    evaluator_notes: str,
+    db_path: Path,
+) -> dict:
+    """
+    İnsan değerlendiricinin verdiği puanı kaydet.
+
+    Otomatik puanlama kasıtlı olarak yok — yanıltıcı olabileceğinden
+    bu fazda insan değerlendirmesi zorunlu tutulmuştur.
+
+    Args:
+        session_id: Oturum id'si
+        score: 0.0–5.0 arası puan
+        evaluator_notes: Değerlendirici notları
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        Güncellenen oturum özeti
+    """
+    if not (0.0 <= score <= 5.0):
+        raise ValueError(f"Skor 0.0–5.0 arasında olmalı, gelen: {score}")
+
+    su_an = int(time.time())
+    with get_connection(db_path) as conn:
+        cur = conn.execute(
+            """
+            UPDATE interview_sessions
+            SET comprehension_score = ?,
+                evaluator_notes     = ?,
+                completed_at        = ?
+            WHERE id = ?
+            """,
+            (score, evaluator_notes, su_an, session_id),
+        )
+        if cur.rowcount == 0:
+            raise ValueError(f"Oturum #{session_id} bulunamadı.")
+
+    return {
+        "session_id": session_id,
+        "comprehension_score": score,
+        "evaluator_notes": evaluator_notes,
+        "mesaj": "Değerlendirme kaydedildi.",
+    }
+
+
+def get_sessions(db_path: Path, limit: int = 20) -> list[dict]:
+    """Geçmiş mülakat oturumlarını döndür."""
+    try:
+        with get_connection(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT id, candidate_name, file_path, started_at, completed_at,
+                       comprehension_score, evaluator_notes, created_by
+                FROM interview_sessions
+                ORDER BY started_at DESC
+                LIMIT ?
+                """,
+                (limit,),
+            ).fetchall()
+    except Exception:
+        return []
+
+    def _ts(ts: Optional[int]) -> Optional[str]:
+        if not ts:
+            return None
+        from datetime import datetime
+        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")
+
+    return [
+        {
+            "id": r["id"],
+            "aday": r["candidate_name"],
+            "dosya_yolu": r["file_path"],
+            "baslangic": _ts(r["started_at"]),
+            "bitis": _ts(r["completed_at"]),
+            "skor": r["comprehension_score"],
+            "notlar": r["evaluator_notes"],
+            "olusturan": r["created_by"],
+        }
+        for r in rows
+    ]

codedna/onboarding.py

@@ -0,0 +1,195 @@
+"""Yeni katılan geliştiricilerin üretkenlik eğrisini ölçer."""
+
+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
+
+# Üretkenlik eşiği — bu skoru aşınca "ramp-up tamamlandı" sayılır
+_VARSAYILAN_ESIK = 3.5
+
+# Ramp-up tahmini için minimum commit sayısı
+_MIN_COMMIT = 5
+
+
+@dataclass
+class CommitNoktasi:
+    """Tek commit için anlama skoru verisi."""
+
+    commit_hash: str
+    commit_no: int           # yazar bazlı sıra numarası (1'den başlar)
+    tarih: datetime
+    understanding_score: Optional[float]
+    hafta_no: int            # ilk committen itibaren geçen hafta sayısı
+
+
+@dataclass
+class YazarEgri:
+    """Tek yazar için onboarding eğrisi."""
+
+    yazar: str
+    toplam_commit: int
+    anlama_skoru_olan: int
+    ramp_up_hafta: Optional[float]   # None = yeterli veri yok / eşik aşılmadı
+    son_ort_anlama: Optional[float]  # son 5 commit ortalaması
+    noktalar: list[CommitNoktasi]
+
+
+def get_author_timeline(author: str, db_path: Path) -> list[CommitNoktasi]:
+    """
+    Bir yazarın tüm commit'lerini kronolojik anlama skoruyla döndür.
+
+    Args:
+        author: Yazar adı (commits.author ile eşleşmeli)
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        CommitNoktasi listesi, tarih sırasıyla
+    """
+    try:
+        with get_connection(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT commit_hash, author, timestamp, understanding_score
+                FROM commits
+                WHERE author = ?
+                ORDER BY timestamp ASC
+                """,
+                (author,),
+            ).fetchall()
+    except Exception:
+        return []
+
+    if not rows:
+        return []
+
+    ilk_ts = rows[0]["timestamp"] or 0
+    noktalar: list[CommitNoktasi] = []
+
+    for i, r in enumerate(rows):
+        ts = r["timestamp"] or ilk_ts
+        hafta = int((ts - ilk_ts) / (7 * 24 * 3600))
+        noktalar.append(
+            CommitNoktasi(
+                commit_hash=r["commit_hash"] or "",
+                commit_no=i + 1,
+                tarih=datetime.fromtimestamp(ts),
+                understanding_score=(
+                    float(r["understanding_score"])
+                    if r["understanding_score"] is not None
+                    else None
+                ),
+                hafta_no=hafta,
+            )
+        )
+
+    return noktalar
+
+
+def estimate_ramp_up_weeks(
+    author: str,
+    db_path: Path,
+    threshold: float = _VARSAYILAN_ESIK,
+) -> Optional[float]:
+    """
+    Yazarın ortalama anlama skoru threshold'u aştığı ilk haftayı tahmin et.
+
+    Algoritma:
+      - Anlama skoru olan commit'ler 3'lü hareketli ortalama ile yumuşatılır
+      - Yumuşatılmış skor threshold'u aştığı ilk commit'in hafta numarası döndürülür
+      - Yeterli veri yoksa (< MIN_COMMIT anketli commit) None döndürülür
+
+    Args:
+        author: Yazar adı
+        db_path: SQLite veritabanı yolu
+        threshold: Üretkenlik eşiği (varsayılan 3.5/5)
+
+    Returns:
+        Ramp-up haftası veya None
+    """
+    noktalar = get_author_timeline(author, db_path)
+    anketli = [n for n in noktalar if n.understanding_score is not None]
+
+    if len(anketli) < _MIN_COMMIT:
+        return None
+
+    # 3'lü hareketli ortalama
+    skorlar = [n.understanding_score for n in anketli]  # type: ignore[misc]
+    for i in range(2, len(skorlar)):
+        pencere = skorlar[max(0, i - 2): i + 1]
+        ort = sum(pencere) / len(pencere)
+        if ort >= threshold:
+            return float(anketli[i].hafta_no)
+
+    return None  # eşik hiç aşılmadı
+
+
+def get_author_curve(author: str, db_path: Path) -> YazarEgri:
+    """
+    Tek yazar için tam onboarding eğrisi nesnesi oluştur.
+
+    Args:
+        author: Yazar adı
+        db_path: SQLite veritabanı yolu
+
+    Returns:
+        YazarEgri nesnesi
+    """
+    noktalar = get_author_timeline(author, db_path)
+    anketli = [n for n in noktalar if n.understanding_score is not None]
+
+    ramp_up = estimate_ramp_up_weeks(author, db_path)
+
+    son_5 = [n.understanding_score for n in anketli[-5:] if n.understanding_score]
+    son_ort = sum(son_5) / len(son_5) if son_5 else None
+
+    return YazarEgri(
+        yazar=author,
+        toplam_commit=len(noktalar),
+        anlama_skoru_olan=len(anketli),
+        ramp_up_hafta=round(ramp_up, 1) if ramp_up is not None else None,
+        son_ort_anlama=round(son_ort, 2) if son_ort is not None else None,
+        noktalar=noktalar,
+    )
+
+
+def get_all_authors(db_path: Path) -> list[str]:
+    """DB'deki tüm benzersiz yazar listesini döndür."""
+    try:
+        with get_connection(db_path) as conn:
+            rows = conn.execute(
+                "SELECT DISTINCT author FROM commits WHERE author IS NOT NULL ORDER BY author"
+            ).fetchall()
+        return [r["author"] for r in rows]
+    except Exception:
+        return []
+
+
+def team_onboarding_summary(db_path: Path) -> list[dict]:
+    """
+    Takımdaki tüm yazarlar için ramp-up süresi özeti döndür.
+
+    Returns:
+        Yazar bazlı özet dict listesi, ramp_up_hafta'ya göre sıralı
+    """
+    yazarlar = get_all_authors(db_path)
+    ozet: list[dict] = []
+
+    for yazar in yazarlar:
+        egri = get_author_curve(yazar, db_path)
+        ozet.append({
+            "yazar": yazar,
+            "toplam_commit": egri.toplam_commit,
+            "anlama_skoru_olan": egri.anlama_skoru_olan,
+            "ramp_up_hafta": egri.ramp_up_hafta,
+            "son_ort_anlama": egri.son_ort_anlama,
+            "yeterli_veri": egri.anlama_skoru_olan >= _MIN_COMMIT,
+        })
+
+    # Ramp-up süresi olan önce, sonra None olanlar
+    ozet.sort(key=lambda x: (x["ramp_up_hafta"] is None, x["ramp_up_hafta"] or 999))
+    return ozet

codedna/plan.py

@@ -0,0 +1,184 @@
+"""Plan yönetimi — lisans anahtarı ile plan seviyesi belirlenir."""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class Plan(str, Enum):
+    """Kullanılabilir plan seviyeleri."""
+
+    FREE = "free"
+    PRO = "pro"
+    TEAM = "team"
+    ENTERPRISE = "enterprise"
+
+
+# Lisans dosyası yolu
+_LISANS_YOLU = Path.home() / ".codedna" / "license.json"
+
+# Özellik → izin verilen planlar eşlemesi
+_OZELLIK_PLANLARI: dict[str, list[Plan]] = {
+    "unlimited_repos":  [Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+    "unlimited_files":  [Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+    "history_90d":      [Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+    "history_365d":     [Plan.TEAM, Plan.ENTERPRISE],
+    "dashboard_access": [Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+    "github_actions":   [Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+    "slack_notify":     [Plan.TEAM, Plan.ENTERPRISE],
+    "bus_factor":       [Plan.TEAM, Plan.ENTERPRISE],
+    "sprint_health":    [Plan.TEAM, Plan.ENTERPRISE],
+    "ai_comparison":    [Plan.ENTERPRISE],
+    "interview_tool":   [Plan.ENTERPRISE],
+    # NatureCo CLI entegrasyonu — Pro+ özellik
+    "natureco_integration": [Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+}
+
+# Tüm planlarda erişilebilen özellikler (varsayılan)
+_HERKESE_ACIK: set[str] = {
+    "scan", "history_7d", "cli_basic",
+}
+
+
+def get_current_plan() -> Plan:
+    """
+    ~/.codedna/license.json dosyasından plan oku.
+
+    Dosya yoksa FREE döndür.
+    Format: {"plan": "pro", "key": "...", "expires": "2027-01-01"}
+    """
+    if not _LISANS_YOLU.exists():
+        return Plan.FREE
+    try:
+        veri = json.loads(_LISANS_YOLU.read_text(encoding="utf-8"))
+        return Plan(veri.get("plan", "free"))
+    except Exception:
+        return Plan.FREE
+
+
+def is_feature_available(feature: str, plan: Optional[Plan] = None) -> bool:
+    """
+    Verilen özelliğin mevcut planda kullanılabilir olup olmadığını kontrol et.
+
+    Args:
+        feature: Kontrol edilecek özellik adı
+        plan: Plan seviyesi (None ise mevcut plan okunur)
+
+    Returns:
+        Özellik kullanılabilirse True
+    """
+    if plan is None:
+        plan = get_current_plan()
+
+    # Herkese açık özellikler
+    if feature in _HERKESE_ACIK:
+        return True
+
+    return plan in _OZELLIK_PLANLARI.get(
+        feature,
+        [Plan.FREE, Plan.PRO, Plan.TEAM, Plan.ENTERPRISE],
+    )
+
+
+def activate_license(key: str) -> Plan:
+    """
+    Lisans anahtarını doğrula ve aktif et.
+
+    Gerçek doğrulama Faz 9'da API üzerinden yapılacak.
+    Şimdilik anahtar formatına göre plan belirler:
+      - 'CDNA-PRO-...'  → pro
+      - 'CDNA-TEAM-...' → team
+      - 'CDNA-ENT-...'  → enterprise
+
+    Args:
+        key: Lisans anahtarı
+
+    Returns:
+        Aktif edilen plan seviyesi
+    """
+    anahtar = key.upper().strip()
+    if anahtar.startswith("CDNA-PRO"):
+        plan = Plan.PRO
+    elif anahtar.startswith("CDNA-TEAM"):
+        plan = Plan.TEAM
+    elif anahtar.startswith("CDNA-ENT"):
+        plan = Plan.ENTERPRISE
+    else:
+        raise ValueError(f"Geçersiz lisans anahtarı formatı: {key!r}")
+
+    # Lisans dosyasını yaz
+    _LISANS_YOLU.parent.mkdir(parents=True, exist_ok=True)
+    _LISANS_YOLU.write_text(
+        json.dumps({"plan": plan.value, "key": anahtar}, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    return plan
+
+
+def activate_demo_license(plan: Plan) -> Plan:
+    """
+    Demo lisansı aktif et — gerçek key gerekmeden.
+
+    Development, demo, CI/CD ve test için.
+    Süresi 7 gün, sonra tekrar `codedna plan demo` ile uzatılabilir.
+
+    Args:
+        plan: Hedef plan (free, pro, team, enterprise)
+
+    Returns:
+        Aktif edilen plan
+    """
+    import secrets as _secrets
+
+    su_an = int(__import__("time").time())
+    gecerli = su_an + (7 * 24 * 3600)  # 7 gün
+
+    # Rastgele demo key (gerçek formatı taklit eder)
+    demo_key = f"CDNA-{plan.value.upper()[:3]}-DEMO-{_secrets.token_urlsafe(16).upper()}"
+
+    _LISANS_YOLU.parent.mkdir(parents=True, exist_ok=True)
+    _LISANS_YOLU.write_text(
+        json.dumps(
+            {
+                "plan": plan.value,
+                "key": demo_key,
+                "expires": __import__("datetime").datetime.fromtimestamp(gecerli).strftime("%Y-%m-%d"),
+                "demo": True,
+                "activated_at": su_an,
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    return plan
+
+
+def get_plan_limits() -> dict[str, object]:
+    """Mevcut planın limit değerlerini döndür."""
+    plan = get_current_plan()
+    limitler: dict[str, object] = {
+        Plan.FREE: {
+            "max_repos": 1, "max_files_scan": 50, "history_days": 7,
+            "dashboard_access": False, "github_actions": False,
+        },
+        Plan.PRO: {
+            "max_repos": -1, "max_files_scan": -1, "history_days": 90,
+            "dashboard_access": True, "github_actions": True,
+        },
+        Plan.TEAM: {
+            "max_repos": -1, "max_files_scan": -1, "history_days": 365,
+            "dashboard_access": True, "github_actions": True,
+            "slack_notify": True, "bus_factor": True,
+        },
+        Plan.ENTERPRISE: {
+            "max_repos": -1, "max_files_scan": -1, "history_days": -1,
+            "dashboard_access": True, "github_actions": True,
+            "slack_notify": True, "bus_factor": True,
+            "sprint_health": True, "ai_comparison": True,
+        },
+    }
+    return limitler.get(plan, limitler[Plan.FREE])  # type: ignore[return-value]