codedna 0.2.21__tar.gz → 0.2.23__tar.gz

{codedna-0.2.21 → codedna-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.2.21
+Version: 0.2.23
 Summary: AI Code Transparency Tool - detect AI-written code and measure developer understanding
 Project-URL: Homepage, https://codedna.dev
 Project-URL: Repository, https://github.com/natureco-official/codedna

codedna-0.2.23/codedna/__init__.py

@@ -0,0 +1,4 @@
+"""CodeDNA — AI Code Transparency Tool."""
+
+__version__ = "0.2.23"
+__app_name__ = "codedna"

{codedna-0.2.21 → codedna-0.2.23}/codedna/ai.py

@@ -1,12 +1,12 @@
 """
-AI Analiz Katmanı - Kullanici komut sonuclarini AI ile yorumlar.
+AI Analysis Layer - Interprets user command outputs using AI.
 
-Desteklenen provider'lar:
+Supported providers:
   - Anthropic (Claude)
   - MiniMax
   - OpenAI
 
-Key sadece analiz icin kullanilir, sohbet/tamamlama yok.
+The key is used only for analysis, no chat/completion.
 """
 import base64
 import json
@@ -19,17 +19,17 @@ from typing import Optional
 
 AI_CONFIG_PATH = Path.home() / ".codedna" / "ai_config.json"
 
-# Provider listesi
+# Provider list
 PROVIDERS = ["anthropic", "minimax", "openai"]
 
-# Default modeller
+# Default models
 DEFAULT_MODELS = {
     "anthropic": "claude-sonnet-4-20250514",
     "minimax": "MiniMax-M2.5",
     "openai": "gpt-4o-mini",
 }
 
-# Provider API endpoint
+# Provider API endpoints
 API_ENDPOINTS = {
     "anthropic": "https://api.anthropic.com/v1/messages",
     "minimax": "https://api.minimax.io/v1/text/chatcompletion_v2",
@@ -39,7 +39,7 @@ API_ENDPOINTS = {
 
 @dataclass
 class AIConfig:
-    """AI analiz konfigurasyonu."""
+    """AI analysis configuration."""
     provider: str
     api_key: str
     model: str
@@ -47,7 +47,7 @@ class AIConfig:
 
     @classmethod
     def load(cls) -> Optional["AIConfig"]:
-        """Config dosyasindan yukle."""
+        """Load from config file."""
         if not AI_CONFIG_PATH.exists():
             return None
         try:
@@ -62,7 +62,7 @@ class AIConfig:
             return None
 
     def save(self) -> None:
-        """Config'i dosyaya yaz."""
+        """Write config to file."""
         AI_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
         data = {
             "provider": self.provider,
@@ -78,19 +78,17 @@ class AIConfig:
 
     @classmethod
     def clear(cls) -> None:
-        """Config'i sil."""
+        """Delete the config file."""
         if AI_CONFIG_PATH.exists():
             AI_CONFIG_PATH.unlink()
 
 
 def _call_anthropic(api_key: str, model: str, prompt: str) -> str:
-    """Anthropic Claude API cagirisi."""
+    """Call the Anthropic Claude API."""
     payload = {
         "model": model,
         "max_tokens": 500,
-        "messages": [
-            {"role": "user", "content": prompt}
-        ],
+        "messages": [{"role": "user", "content": prompt}],
     }
     req = urllib.request.Request(
         API_ENDPOINTS["anthropic"],
@@ -104,16 +102,15 @@ def _call_anthropic(api_key: str, model: str, prompt: str) -> str:
     )
     with urllib.request.urlopen(req, timeout=30) as resp:
         result = json.loads(resp.read())
-        # Response: {content: [{text: "..."}], ...}
         return result.get("content", [{}])[0].get("text", "")
 
 
 def _call_minimax(api_key: str, model: str, prompt: str) -> str:
-    """MiniMax API cagirisi."""
+    """Call the MiniMax API."""
     payload = {
         "model": model,
         "messages": [
-            {"role": "system", "content": "Sen CodeDNA'nin AI analiz asistanisin. Kullanici komut ciktilarini yorumlarsin. Sohbet etme, sadece analiz ve oneriler sun."},
+            {"role": "system", "content": "You are CodeDNA's AI analysis assistant. You interpret user command outputs. Do not chat — only provide analysis and insights."},
             {"role": "user", "content": prompt}
         ],
     }
@@ -132,12 +129,12 @@ def _call_minimax(api_key: str, model: str, prompt: str) -> str:
 
 
 def _call_openai(api_key: str, model: str, prompt: str) -> str:
-    """OpenAI API cagirisi."""
+    """Call the OpenAI API."""
     payload = {
         "model": model,
         "max_tokens": 500,
         "messages": [
-            {"role": "system", "content": "Sen CodeDNA'nin AI analiz asistanisin. Kullanici komut ciktilarini yorumlarsin. Sohbet etme, sadece analiz ve oneriler sun."},
+            {"role": "system", "content": "You are CodeDNA's AI analysis assistant. You interpret user command outputs. Do not chat — only provide analysis and insights."},
             {"role": "user", "content": prompt}
         ],
     }
@@ -157,38 +154,36 @@ def _call_openai(api_key: str, model: str, prompt: str) -> str:
 
 def ai_analyze(command: str, output: str, config: Optional[AIConfig] = None, extra_context: str = "") -> Optional[str]:
     """
-    Komut ciktisini AI ile analiz et.
+    Analyze command output using AI.
 
     Args:
-        command: Calistirilan komut
-        output: Komut ciktisi
-        config: AI konfigurasyonu
-        extra_context: Ek baglam (dosya icerikleri vs)
+        command: Command that was run
+        output: Command output
+        config: AI configuration
+        extra_context: Additional context (file contents, etc.)
 
     Returns:
-        Analiz metni veya None
+        Analysis text or None
     """
     if config is None:
         config = AIConfig.load()
     if config is None or not config.enabled or not config.api_key:
         return None
 
-    # Plan kontrolu - sadece Pro+ kullanicilar AI analiz kullanabilir
+    # Plan check — only Pro+ users can use AI analysis
     try:
         from codedna.plan import get_current_plan, Plan as PlanEnum
         plan = get_current_plan()
         if plan == PlanEnum.FREE:
-            return None  # Free planda AI analiz yok
+            return None  # No AI analysis on free plan
     except Exception:
-        return None  # Plan yuklenemedi, gosterme
+        return None  # Cannot load plan, skip
 
-    # Yeni prompt - dosyalari oku, dogrula, analiz et (oneri degil)
-    # Prompt her zaman Ingilizce - AI daha iyi analiz eder
-    baglam = f"\n\nFILE CONTENTS:\n{extra_context}" if extra_context else ""
+    context_block = f"\n\nFILE CONTENTS:\n{extra_context}" if extra_context else ""
     prompt = f"""You are CodeDNA's code verification assistant. NEVER give general recommendations, only analyze.
 
 OUTPUT:
-{output[:3000]}{baglam[:4000]}
+{output[:3000]}{context_block[:4000]}
 
 Respond in this exact format:
 
@@ -227,11 +222,11 @@ Rules:
         else:
             return None
     except Exception as e:
-        return f"AI analiz hatasi: {type(e).__name__}"
+        return f"AI analysis error: {type(e).__name__}"
 
 
 def is_enabled() -> bool:
-    """AI analiz aktif mi? (Sadece Pro+ uyeler)"""
+    """Is AI analysis active? (Pro+ users only)"""
     config = AIConfig.load()
     if config is None or not config.enabled or not config.api_key:
         return False

{codedna-0.2.21 → codedna-0.2.23}/codedna/ai_box.py

@@ -1,6 +1,6 @@
 """
-AI analiz kutusunu CLI komut çiktilarina ekle.
-Her komut çiktisindan sonra AI analiz kutusu göster.
+Append AI analysis box to CLI command outputs.
+Show AI analysis box after each command output.
 """
 from rich.panel import Panel
 from rich.console import Console
@@ -13,12 +13,12 @@ console = Console()
 
 def print_ai_box(command_name: str, output: str, width: int = 80) -> None:
     """
-    Komut çiktisindan sonra AI analiz kutusu yazdir.
+    Print AI analysis box after command output.
 
     Args:
-        command_name: Çalistirilan komut (örn: "codedna scan")
-        output: Komut çiktisi (raw text)
-        width: Panel genisligi
+        command_name: Command that was run (e.g. "codedna scan")
+        output: Command output (raw text)
+        width: Panel width
     """
     try:
         from codedna.ai import ai_analyze, is_enabled
@@ -26,26 +26,26 @@ def print_ai_box(command_name: str, output: str, width: int = 80) -> None:
         return
 
     if not is_enabled():
-        return  # AI kapaliysa gösterme
+        return  # AI is disabled, skip
 
-    # AI analiz al
+    # Get AI analysis
     ai_response = ai_analyze(command_name, output)
 
     if not ai_response:
         return
 
-    # Hata durumunda sessizce gec (AI analizi opsiyonel)
-    if ai_response.startswith("AI analiz hatasi"):
+    # Silently skip on error (AI analysis is optional)
+    if ai_response.startswith("AI analysis error"):
         return
 
-    # Renk ve icon
+    # Color and icon
     border_style = "magenta"
-    title = "[bold magenta]🤖 AI Analiz (Pro+)[/bold magenta]"
+    title = "[bold magenta]🤖 AI Analysis (Pro+)[/bold magenta]"
 
-    # Maksimum 60 satir göster
+    # Show maximum 60 lines
     lines = ai_response.strip().split("\n")
     if len(lines) > 60:
-        lines = lines[:58] + ["... (kisaltildi)"]
+        lines = lines[:58] + ["... (truncated)"]
     content = "\n".join(lines)
 
     panel = Panel(
@@ -64,14 +64,14 @@ def print_ai_box(command_name: str, output: str, width: int = 80) -> None:
 
 def capture_and_analyze(command_name: str, run_func, *args, **kwargs) -> None:
     """
-    Bir komutu çalistir, çiktiyi yakala, sonra AI analiz göster.
+    Run a command, capture its output, then show AI analysis.
 
     Args:
-        command_name: Komut adi (analiz için)
-        run_func: Çalistirilacak fonksiyon
-        *args, **kwargs: Fonksiyona geçilecek argümanlar
+        command_name: Command name (for analysis)
+        run_func: Function to run
+        *args, **kwargs: Arguments to pass to the function
     """
-    # Çiktiyi yakala
+    # Capture output
     old_stdout = sys.stdout
     sys.stdout = buffer = StringIO()
 
@@ -81,14 +81,14 @@ def capture_and_analyze(command_name: str, run_func, *args, **kwargs) -> None:
         pass
     except Exception as e:
         sys.stdout = old_stdout
-        console.print(f"[red]Hata: {e}[/red]")
+        console.print(f"[red]Error: {e}[/red]")
         return
     finally:
         output = buffer.getvalue()
         sys.stdout = old_stdout
 
-    # Orijinal çiktiyi göster
+    # Show original output
     console.print(output, end="")
 
-    # AI analiz
+    # AI analysis
     print_ai_box(command_name, output)

codedna-0.2.23/codedna/ai_fingerprint.py

@@ -0,0 +1,220 @@
+"""
+Distinguishes patterns left by different AI code assistants.
+
+IMPORTANT WARNING:
+  This is NOT a definitive detection — it is a pattern-based heuristic ESTIMATION model.
+  Results may contain false positives/negatives. No certainty is claimed.
+  Must be presented to users with this context.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from codedna.db import get_connection
+
+
+# ---------------------------------------------------------------------------
+# Tool pattern definitions — heuristic, defensible but not definitive
+# ---------------------------------------------------------------------------
+
+# Weighted pattern list per tool: (regex_pattern, weight)
+_TOOL_PATTERNS: dict[str, list[tuple[str, float]]] = {
+    "copilot": [
+        # GitHub Copilot: short inline comments, no type declarations
+        (r"#\s+[A-Z][a-z].{5,40}$", 0.15),           # single-line title comment
+        (r"def \w+\([^)]{0,30}\):\s*$", 0.10),        # no-param / minimal function
+        (r"#\s+TODO:", 0.10),                          # TODO comments
+        (r"^\s{4}pass\s*$", 0.08),                     # functions ending with pass
+        (r"return \w+\.get\(", 0.07),                  # .get() pattern
+    ],
+    "cursor": [
+        # Cursor: detailed docstrings, rich type hints
+        (r'"""[\s\S]{20,200}"""', 0.20),               # long docstring
+        (r":\s*(str|int|float|bool|list|dict|Optional)", 0.15),  # type hints
+        (r"->.*:\s*$", 0.12),                          # return type declaration
+        (r"from typing import", 0.10),                 # typing module
+        (r"@dataclass", 0.10),                         # dataclass usage
+    ],
+    "claude": [
+        # Claude: structured multi-line comments, Args/Returns docstrings
+        (r"#\s+\d+\.\s+\w", 0.18),                    # numbered step comments
+        (r"\"\"\"[\s\S]*Args:[\s\S]*Returns:", 0.20),  # Args/Returns docstring
+        (r"#\s+─{3,}", 0.15),                          # separator line comments
+        (r"raise \w+Error\(f[\"']", 0.10),             # f-string error messages
+        (r"from __future__ import annotations", 0.12), # modern annotation
+    ],
+}
+
+# Minimum confidence threshold — returns "unknown" if below this
+_MIN_CONFIDENCE = 0.15
+
+
+@dataclass
+class AIToolGuess:
+    """AI tool guess for a single file."""
+
+    arac: str              # "copilot" | "cursor" | "claude" | "unknown" (kept for compat)
+    guven: float           # 0.0–1.0 (kept for compat)
+    puan_detayi: dict[str, float]  # tool → raw score (kept for compat)
+    uyari: str = (
+        "This detection is pattern-based estimation — not definitive."
+    )
+
+
+def guess_ai_tool(file_path: str, code: str) -> AIToolGuess:
+    """
+    Return a probable AI tool guess and confidence score for a file.
+
+    Strategy:
+      Defined regex patterns for each tool are applied to the code.
+      A total score is computed based on weighted match counts.
+      The highest-scoring tool is selected if it exceeds the minimum confidence threshold.
+
+    Args:
+        file_path: File path (used for extension filtering)
+        code: Source code of the file
+
+    Returns:
+        AIToolGuess object
+    """
+    lines = code.splitlines()
+    scores: dict[str, float] = {tool: 0.0 for tool in _TOOL_PATTERNS}
+
+    for tool, patterns in _TOOL_PATTERNS.items():
+        for pattern, weight in patterns:
+            match_count = sum(1 for line in lines if re.search(pattern, line))
+            # Normalize by line count (prevents unfair advantage in large files)
+            norm = match_count / max(len(lines), 1)
+            scores[tool] += norm * weight * 10  # scale to 0–10
+
+    # Normalize — calculate confidence relative to total score
+    total = sum(scores.values())
+    if total < 0.01:
+        return AIToolGuess(
+            arac="unknown",
+            guven=0.0,
+            puan_detayi={k: round(v, 3) for k, v in scores.items()},
+        )
+
+    best_tool = max(scores, key=lambda k: scores[k])
+    confidence = scores[best_tool] / total
+
+    # Below minimum threshold → unknown
+    if confidence < _MIN_CONFIDENCE:
+        best_tool = "unknown"
+
+    return AIToolGuess(
+        arac=best_tool,
+        guven=round(confidence, 3),
+        puan_detayi={k: round(v, 3) for k, v in scores.items()},
+    )
+
+
+def analyze_repo_tools(
+    repo_path: Path,
+    db_path: Path,
+) -> dict[str, dict[str, float]]:
+    """
+    Run a tool-based file analysis across the repo and save results to DB.
+
+    Returns:
+        {tool: {"dosya_sayisi": N, "avg_ai_probability": X}} dict
+    """
+    from codedna.scorer import scan_repository
+
+    supported = {".py", ".js", ".jsx", ".ts", ".tsx"}
+    results = scan_repository(repo_path, max_files=200)
+
+    # Tool counters
+    tool_stats: dict[str, dict[str, list]] = {
+        "copilot": {"ai_prob": [], "understanding": []},
+        "cursor":  {"ai_prob": [], "understanding": []},
+        "claude":  {"ai_prob": [], "understanding": []},
+        "unknown": {"ai_prob": [], "understanding": []},
+    }
+
+    for result in results:
+        if Path(result.file_path).suffix.lower() not in supported:
+            continue
+        try:
+            code = Path(result.file_path).read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+
+        guess = guess_ai_tool(result.file_path, code)
+
+        # Save to DB — update the most recent file_score record
+        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
+                      )
+                    """,
+                    (guess.arac, result.file_path, result.file_path),
+                )
+        except Exception:
+            pass
+
+        if guess.arac in tool_stats:
+            tool_stats[guess.arac]["ai_prob"].append(result.ai_probability)
+        else:
+            tool_stats["unknown"]["ai_prob"].append(result.ai_probability)
+
+    # Collect understanding scores per tool from DB
+    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:
+                tool = r["ai_tool_guess"] or "unknown"
+                if tool in tool_stats:
+                    tool_stats[tool]["understanding"].append(
+                        float(r["understanding_score"])
+                    )
+    except Exception:
+        pass
+
+    # Compute output
+    output: dict[str, dict[str, float]] = {}
+    for tool, data in tool_stats.items():
+        if not data["ai_prob"]:
+            continue
+        avg_ai = sum(data["ai_prob"]) / len(data["ai_prob"])
+        avg_und = (
+            sum(data["understanding"]) / len(data["understanding"])
+            if data["understanding"] else None
+        )
+        output[tool] = {
+            "dosya_sayisi": len(data["ai_prob"]),  # kept for API compat
+            "avg_ai_probability": round(avg_ai, 3),
+            "avg_understanding": round(avg_und, 2) if avg_und is not None else None,
+        }
+
+    return output
+
+
+def compare_tools_in_repo(repo_path: Path, db_path: Path) -> dict:
+    """
+    Compare average understanding scores and AI probabilities per tool across the repo.
+
+    Returns:
+        {"copilot": {...}, "cursor": {...}, ...} dict
+    """
+    return analyze_repo_tools(repo_path, db_path)