codedna 0.9.5__tar.gz → 0.9.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.9.5
+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

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

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

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

@@ -77,6 +77,7 @@ class FileAnalysisResult:
     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
@@ -424,6 +425,36 @@ def _content_ai_signal(source: str) -> float:
     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?".
+    """
+    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).
 

{codedna-0.9.5 → 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.5 → 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.5 → codedna-0.9.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codedna"
-version = "0.9.5"
+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"