codedna 0.9.4__tar.gz → 0.9.6__tar.gz

{codedna-0.9.4 → codedna-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.9.4
+Version: 0.9.6
 Summary: AI Code Transparency Tool — detect AI-written code, analyze commit quality, track understanding debt, sprint health, bus factor, and more
 Project-URL: Homepage, https://codedna.dev
 Project-URL: Repository, https://github.com/natureco-official/codedna
@@ -41,8 +41,6 @@ Requires-Dist: tree-sitter-typescript>=0.23.2
 Requires-Dist: tree-sitter>=0.25.2
 Requires-Dist: typer>=0.26.7
 Requires-Dist: uvicorn[standard]>=0.49.0
-Provides-Extra: dashboard
-Requires-Dist: next-cmd>=0.5.0; extra == 'dashboard'
 Provides-Extra: dev
 Requires-Dist: black>=26.5.1; extra == 'dev'
 Requires-Dist: pytest-cov>=7.1.0; extra == 'dev'

{codedna-0.9.4 → codedna-0.9.6}/codedna/__init__.py

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

{codedna-0.9.4 → codedna-0.9.6}/codedna/analyzer.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import math
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -75,6 +76,8 @@ class FileAnalysisResult:
     comment_ratio: float = 0.0
     avg_function_length: float = 0.0
     single_commit_ratio: float = 0.0
+    content_ai_signal: float = 0.0   # content-based AI signal (code patterns, 0–1)
+    understanding_estimate: float = 0.0   # auto-estimated team understanding (1–5), 0 = not computed
     total_lines: int = 0
     function_count: int = 0
     unsupported: bool = False   # kept for internal use
@@ -243,8 +246,8 @@ def analyze_file(
     # Cyclomatic complexity (whole file)
     result.complexity_score = _calculate_cyclomatic_complexity(tree.root_node)
 
-    # Calculate AI probability
-    result.ai_probability = _calculate_ai_probability(result)
+    # Calculate AI probability (continuous + content-based)
+    result.ai_probability = _calculate_ai_probability(result, source)
 
     # Generate explanation
     result.explanation = explain_ai_score(result)
@@ -339,28 +342,35 @@ def explain_ai_score(result: FileAnalysisResult) -> list[str]:
     """
     reasons: list[str] = []
 
+    if result.content_ai_signal >= 0.15:
+        pct = int(result.content_ai_signal * 100)
+        reasons.append(
+            f"Code carries AI-style patterns ({pct}% content signal) — e.g. type hints, "
+            f"defensive boilerplate, 'step' comments, emoji"
+        )
+
     if result.comment_ratio > 0.3:
         pct = int(result.comment_ratio * 100)
         reasons.append(
-            f"High comment ratio ({pct}%) — AI-generated code tends to over-comment (+0.20)"
+            f"High comment ratio ({pct}%) — AI-generated code tends to over-comment"
         )
 
     if result.avg_function_length > 50:
         reasons.append(
             f"Long avg. function length ({result.avg_function_length:.0f} lines) — "
-            f"AI tends to produce larger blocks (+0.15)"
+            f"AI tends to produce larger blocks"
         )
 
     if result.single_commit_ratio > 0.7:
         pct = int(result.single_commit_ratio * 100)
         reasons.append(
-            f"High single-commit ratio ({pct}%) — bulk paste indicator (+0.30)"
+            f"High single-commit ratio ({pct}%) — bulk paste indicator"
         )
 
     if result.complexity_score > 10 and result.single_commit_ratio > 0.5:
         reasons.append(
             f"High complexity ({result.complexity_score:.0f}) combined with bulk change — "
-            f"complex AI-generated code pattern (+0.25)"
+            f"complex AI-generated code pattern"
         )
 
     if result.function_count == 0:
@@ -372,33 +382,104 @@ def explain_ai_score(result: FileAnalysisResult) -> list[str]:
     return reasons
 
 
-def _calculate_ai_probability(result: FileAnalysisResult) -> float:
+def _smoothstep(x: float, lo: float, hi: float) -> float:
+    """Continuous 0→1 ramp between lo and hi (replaces hard thresholds so scores
+    are file-specific and granular instead of clustering on a few binned values)."""
+    if hi <= lo:
+        return 1.0 if x >= hi else 0.0
+    t = max(0.0, min(1.0, (x - lo) / (hi - lo)))
+    return t * t * (3.0 - 2.0 * t)
+
+
+# Content-based AI-authorship patterns (regex, weight). These look at what the code
+# actually *is* — the stylistic fingerprints AI assistants tend to leave — rather than
+# only git history. Density of matches feeds the score directly.
+_AI_CONTENT_PATTERNS: list[tuple[str, float]] = [
+    (r"#\s*(Step\s*\d|Initialize|Return the|Create the|Loop through|Iterate over|Handle the|Validate|Check if|Set up|Ensure|First,|Finally,)", 1.0),
+    (r"//\s*(Step\s*\d|Initialize|Return the|Create the|Handle the|Validate|Check if|Set up|Ensure)", 1.0),
+    (r'"""', 0.25),                                      # docstrings (AI documents everything)
+    (r"->\s*[A-Za-z_\[\"']", 0.45),                     # return type hints
+    (r":\s*(str|int|float|bool|list|dict|tuple|Optional|Any|Dict|List|Union)\b", 0.35),  # param type hints
+    (r"^\s*try:\s*$", 0.4),                              # defensive try/except everywhere
+    (r"if\s+\w+\s+is\s+None", 0.4),                      # explicit None guards
+    (r"except\s+Exception\b", 0.35),                     # broad catch-alls
+    (r"[\U0001F300-\U0001FAFF☀-➿←-⇿✓✗]", 0.6),  # emoji/✓/✗/→ in code
+    (r"\b(helper|handler|wrapper|manager|processor|validator)\b", 0.2),  # generic role names
+    (r"console\.(log|error)\(.*(✓|✗|→|✅|❌|🧬|⚠)", 0.5),
+]
+
+
+def _content_ai_signal(source: str) -> float:
+    """A content-based AI signal in [0,1], independent of git history: how strongly
+    the code carries the stylistic fingerprints AI assistants tend to leave."""
+    lines = source.splitlines()
+    n = max(len(lines), 1)
+    total = 0.0
+    for pattern, weight in _AI_CONTENT_PATTERNS:
+        try:
+            matches = sum(1 for line in lines if re.search(pattern, line))
+        except re.error:
+            continue
+        total += (matches / n) * weight
+    # Saturating density → [0,1]; small densities still register, high ones plateau.
+    return 1.0 - math.exp(-4.0 * total)
+
+
+def estimate_understanding(
+    ai_probability: float,
+    complexity_score: float,
+    author_count: int,
+    days_since_last: float,
+    top_author_share: float,
+) -> float:
+    """Auto-estimate how well a file is likely understood by the team (1.0–5.0,
+    higher = better understood) — no manual survey required.
+
+    The 'understanding debt' insight: code that is AI-heavy, complex, stale and
+    owned by a single person is code nobody really understands — i.e. real risk.
+    This is what sets CodeDNA apart from plain "% AI" detectors: it answers
+    "AI wrote it, but does anyone on the team actually understand it?".
     """
-    Calculate a rule-based AI probability score (0.0 – 1.0).
-
-    Rules:
-      - comment_ratio > 0.3       → +0.20  (AI tends to over-comment)
-      - avg_function_length > 50  → +0.15  (AI tends to produce large blocks)
-      - single_commit_ratio > 0.7 → +0.30  (bulk paste indicator)
-      - high complexity + single commit → +0.25
+    complexity_norm = _smoothstep(complexity_score, 6.0, 30.0)
+    staleness = _smoothstep(days_since_last, 30.0, 365.0)   # ramps over a month → a year
+    solo = top_author_share >= 0.85 or author_count <= 1
+
+    score = 5.0
+    score -= 2.3 * ai_probability          # AI-heavy → likely unreviewed / not internalized
+    score -= 1.0 * complexity_norm         # complex → harder to hold in one's head
+    score -= 1.3 * staleness               # untouched for ages → knowledge decays
+    if solo:
+        score -= 0.7 * (0.4 + 0.6 * staleness)   # bus-factor-of-1; worse when also stale
+    if author_count >= 3:
+        score += 0.4                       # shared across the team → better understood
+    return round(max(1.0, min(5.0, score)), 2)
+
+
+def _calculate_ai_probability(result: FileAnalysisResult, source: str = "") -> float:
+    """Continuous, content-aware AI probability score (0.0 – 1.0).
+
+    Combines graded structural signals (comments, function size, cyclomatic
+    complexity), git-history signals (bulk single-commit paste) and a
+    content-based fingerprint of AI code style. Unlike the previous four binary
+    rules, every input is continuous so scores reflect each file individually.
     """
-    score = 0.0
-
-    # Rule 1: Excessive comment ratio (AI code tends to over-comment)
-    if result.comment_ratio > 0.3:
-        score += 0.20
-
-    # Rule 2: Long functions (AI tends to produce large blocks)
-    if result.avg_function_length > 50:
-        score += 0.15
-
-    # Rule 3: Large change in a single commit (bulk paste indicator)
-    if result.single_commit_ratio > 0.7:
-        score += 0.30
-
-    # Rule 4: High complexity + single-commit
-    if result.complexity_score > 10 and result.single_commit_ratio > 0.5:
-        score += 0.25
-
-    # Normalize to 0.0 – 1.0
-    return min(score, 1.0)
+    # Graded structural / history signals — smooth ramps, not on/off thresholds.
+    comment = _smoothstep(result.comment_ratio, 0.12, 0.45)
+    func_len = _smoothstep(result.avg_function_length, 25.0, 90.0)
+    bulk = _smoothstep(result.single_commit_ratio, 0.35, 0.90)
+    complexity = _smoothstep(result.complexity_score, 6.0, 25.0)
+
+    # Content fingerprint — the actual code style (strongest single signal).
+    content = _content_ai_signal(source) if source else 0.0
+    result.content_ai_signal = round(content, 4)
+
+    # Weighted blend (weights sum to 1.0). Content carries the most weight because
+    # it inspects what the code *is*, not just how it landed in git.
+    score = (
+        0.14 * comment
+        + 0.12 * func_len
+        + 0.20 * bulk
+        + 0.12 * (complexity * bulk)   # complexity matters most when bulk-committed
+        + 0.42 * content
+    )
+    return round(min(max(score, 0.0), 1.0), 4)

{codedna-0.9.4 → codedna-0.9.6}/codedna/cli.py

@@ -244,7 +244,8 @@ def scan(
                     "ai_probability": round(s.ai_probability, 4),
                     "complexity": s.complexity_label,
                     "lines": s.total_lines,
-                    "understanding": understanding_scores_map.get(s.file_path),
+                    "understanding": understanding_scores_map.get(s.file_path),          # survey-confirmed (1–5) or null
+                    "understanding_estimate": s.understanding_estimate or None,           # auto-estimated (1–5)
                 }
                 for s in results
             ],
@@ -277,11 +278,15 @@ def scan(
         else:
             complexity = "[green]Low[/green]"
 
-        # Read understanding score from the single-query map
+        # Understanding: survey-confirmed score if we have one, else the auto-estimate.
         understanding_score = understanding_scores_map.get(s.file_path)
         if understanding_score is not None:
             color = "green" if understanding_score >= 4.0 else "yellow" if understanding_score >= 2.5 else "red"
             understanding = f"[{color}]✅ {understanding_score:.1f}/5[/{color}]"
+        elif s.understanding_estimate:
+            est = s.understanding_estimate
+            color = "green" if est >= 4.0 else "yellow" if est >= 2.5 else "red"
+            understanding = f"[{color}]~{est:.1f}/5[/{color}]"   # ~ = auto-estimated
         else:
             understanding = "[dim]⚠️  Unknown[/dim]"
 
@@ -296,12 +301,36 @@ def scan(
     avg_ai = (total_ai / len(results)) * 100 if results else 0
     risk_label, risk_color = _risk_label(avg_ai)
 
+    est_scores = [s.understanding_estimate for s in results if s.understanding_estimate]
+    avg_understanding = (sum(est_scores) / len(est_scores)) if est_scores else None
+    understanding_txt = (
+        f" · Avg. understanding: [bold]{avg_understanding:.1f}/5[/bold]" if avg_understanding is not None else ""
+    )
     console.print(
         f"\n[bold]Repo Summary:[/bold] {len(results)} files scanned · "
-        f"Avg. AI probability: [bold]{avg_ai:.0f}[/bold] · "
+        f"Avg. AI probability: [bold]{avg_ai:.0f}[/bold]{understanding_txt} · "
         f"Risk: [bold {risk_color}]{risk_label}[/bold {risk_color}]\n"
     )
 
+    # Understanding debt — CodeDNA's differentiator: AI-heavy code the team likely
+    # doesn't understand (auto-estimated from git ownership, recency, AI, complexity).
+    debt = [
+        s for s in results
+        if s.understanding_estimate and s.understanding_estimate < 3.0 and s.ai_probability >= 0.3
+    ]
+    if debt:
+        debt.sort(key=lambda s: (s.understanding_estimate, -s.ai_probability))
+        console.print("[bold]🧠 Understanding Debt[/bold] [dim](AI-heavy code the team likely doesn't understand)[/dim]")
+        for s in debt[:5]:
+            rel_path = _shorten_path(s.file_path, str(root))
+            console.print(
+                f"  [red]~{s.understanding_estimate:.1f}/5[/red]  {rel_path}  "
+                f"[dim](AI %{s.ai_probability * 100:.0f})[/dim]"
+            )
+        if len(debt) > 5:
+            console.print(f"  [dim]... and {len(debt) - 5} more[/dim]")
+        console.print()
+
     # AI explanations for high-risk files
     high_risk = [s for s in results if s.ai_probability >= 0.4]
     if high_risk and len(high_risk) <= 5:

{codedna-0.9.4 → codedna-0.9.6}/codedna/scorer.py

@@ -8,7 +8,7 @@ from typing import Optional
 from git import InvalidGitRepositoryError, Repo
 from rich.console import Console
 
-from codedna.analyzer import FileAnalysisResult, analyze_file
+from codedna.analyzer import FileAnalysisResult, analyze_file, estimate_understanding
 
 console = Console()
 
@@ -79,6 +79,32 @@ def calculate_single_commit_ratio(repo: Repo, file_path: str) -> float:
         return 0.0
 
 
+def file_git_signals(repo: Repo, file_path: str) -> dict:
+    """Lightweight per-file git signals for the understanding estimate:
+    distinct author count, days since the last commit, and the top author's
+    share of commits (ownership concentration / bus-factor proxy)."""
+    import time
+
+    fallback = {"author_count": 0, "days_since_last": 9999.0, "top_author_share": 1.0}
+    try:
+        commits = list(repo.iter_commits(paths=file_path, max_count=100))
+        if not commits:
+            return fallback
+        authors: dict[str, int] = {}
+        for c in commits:
+            name = c.author.name or c.author.email or "unknown"
+            authors[name] = authors.get(name, 0) + 1
+        total = sum(authors.values()) or 1
+        last_ts = commits[0].committed_date  # iter_commits yields newest first
+        return {
+            "author_count": len(authors),
+            "days_since_last": max(0.0, (time.time() - last_ts) / 86400.0),
+            "top_author_share": max(authors.values()) / total,
+        }
+    except Exception:
+        return fallback
+
+
 def scan_repository(
     repo_path: Optional[Path] = None,
     max_files: int = 200,
@@ -160,6 +186,16 @@ def scan_repository(
 
         result = analyze_file(file, single_commit_ratio=single_commit_ratio)
         if not result.unsupported and result.error is None:
+            # Auto-estimate team understanding from git ownership + recency + AI/complexity
+            if repo and relative_path in tracked_files:
+                sig = file_git_signals(repo, relative_path)
+                result.understanding_estimate = estimate_understanding(
+                    result.ai_probability,
+                    result.complexity_score,
+                    sig["author_count"],
+                    sig["days_since_last"],
+                    sig["top_author_share"],
+                )
             results.append(result)
             count += 1
 

{codedna-0.9.4 → codedna-0.9.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codedna"
-version = "0.9.4"
+version = "0.9.6"
 description = "AI Code Transparency Tool — detect AI-written code, analyze commit quality, track understanding debt, sprint health, bus factor, and more"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -47,9 +47,6 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dashboard = [
-    "next-cmd>=0.5.0",  # Next.js process management
-]
 nl = [
     "huggingface_hub",
     "pyarrow>=14,<18",