codedna 0.8.4__tar.gz → 0.9.0__tar.gz

{codedna-0.8.4 → codedna-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.8.4
+Version: 0.9.0
 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.8.4 → codedna-0.9.0}/codedna/__init__.py

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

{codedna-0.8.4 → codedna-0.9.0}/codedna/analyzer.py

@@ -7,6 +7,41 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
+
+CONVENTIONAL_COMMIT_PATTERNS = {
+    "feat": "Feature",
+    "fix": "Bug Fix",
+    "docs": "Documentation",
+    "refactor": "Refactor",
+    "style": "Style",
+    "test": "Test",
+    "chore": "Chore",
+    "ci": "CI",
+    "build": "Build",
+    "perf": "Performance",
+    "revert": "Revert",
+    "wip": "WIP",
+    "merge": "Merge",
+    "release": "Release",
+}
+
+COMMIT_QUALITY_MAP = {
+    "Feature": 4.5,
+    "Bug Fix": 4.0,
+    "Refactor": 3.5,
+    "Documentation": 3.5,
+    "Style": 2.0,
+    "Test": 4.0,
+    "Chore": 2.5,
+    "CI": 3.0,
+    "Build": 3.0,
+    "Performance": 4.5,
+    "Revert": 1.0,
+    "WIP": 1.5,
+    "Merge": 2.0,
+    "Release": 3.5,
+}
+
 import tree_sitter_python as tspython
 import tree_sitter_javascript as tsjavascript
 from tree_sitter import Language, Parser, Node
@@ -46,6 +81,9 @@ class FileAnalysisResult:
     function_count: int = 0
     unsupported: bool = False   # kept for internal use
     error: Optional[str] = None     # kept for internal use
+    explanation: list[str] = field(default_factory=list)
+    commit_type: Optional[str] = None
+    commit_quality: float = 2.5
 
     @property
     def complexity_label(self) -> str:
@@ -210,9 +248,132 @@ def analyze_file(
     # Calculate AI probability
     result.ai_probability = _calculate_ai_probability(result)
 
+    # Generate explanation
+    result.explanation = explain_ai_score(result)
+
+    return result
+
+
+def analyze_commit_message(message: str) -> dict:
+    """
+    Analyze a commit message and return:
+      - type: conventional commit type (feat, fix, etc.)
+      - category: human-readable category
+      - quality_score: estimated quality (0-5)
+      - has_ticket: whether it references a ticket (JIRA/GitHub issue)
+      - is_conventional: whether it follows conventional commit format
+      - scope: the scope if present (e.g. "auth" in "feat(auth): ...")
+    """
+    result = {
+        "type": None,
+        "category": None,
+        "quality_score": 2.5,
+        "has_ticket": False,
+        "is_conventional": False,
+        "scope": None,
+    }
+
+    if not message:
+        return result
+
+    first_line = message.strip().split("\n")[0]
+
+    # Ticket reference detection
+    ticket_patterns = [
+        r"[A-Z]+-\d+",           # JIRA: PROJ-123
+        r"#\d+",                 # GitHub: #42
+        r"gh-\d+",               # GitHub CLI: gh-42
+    ]
+    for pat in ticket_patterns:
+        if re.search(pat, first_line, re.IGNORECASE):
+            result["has_ticket"] = True
+            break
+
+    # Conventional commit: type(scope): description
+    conv_match = re.match(
+        r"^(fix|feat|docs|refactor|style|test|chore|ci|build|perf|revert)"
+        r"(\(([^)]+)\))?\s*:\s*(.+)",
+        first_line,
+        re.IGNORECASE,
+    )
+    if conv_match:
+        result["is_conventional"] = True
+        result["type"] = conv_match.group(1).lower()
+        result["scope"] = conv_match.group(3)
+        raw_type = conv_match.group(1).lower()
+        category = CONVENTIONAL_COMMIT_PATTERNS.get(raw_type, "Unknown")
+        result["category"] = category
+        result["quality_score"] = COMMIT_QUALITY_MAP.get(category, 2.5)
+
+        # Bonus for having a scope
+        if result["scope"]:
+            result["quality_score"] = min(result["quality_score"] + 0.5, 5.0)
+
+        # Bonus for having a ticket reference
+        if result["has_ticket"]:
+            result["quality_score"] = min(result["quality_score"] + 0.5, 5.0)
+    else:
+        # Non-conventional message — estimate quality
+        words = len(first_line.split())
+        if words < 3:
+            result["quality_score"] = 1.0
+            result["category"] = "Vague"
+        elif first_line.startswith("Merge"):
+            result["category"] = "Merge"
+            result["quality_score"] = 2.0
+        elif "wip" in first_line.lower() or "work in progress" in first_line.lower():
+            result["category"] = "WIP"
+            result["quality_score"] = 1.5
+        elif words > 10:
+            result["quality_score"] = 3.5
+            result["category"] = "Descriptive"
+        else:
+            result["category"] = "Standard"
+            result["quality_score"] = 2.5
+
     return result
 
 
+def explain_ai_score(result: FileAnalysisResult) -> list[str]:
+    """
+    Generate human-readable explanations for the AI probability score.
+    Returns a list of reasons why the file scored as it did.
+    """
+    reasons: list[str] = []
+
+    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)"
+        )
+
+    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)"
+        )
+
+    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)"
+        )
+
+    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)"
+        )
+
+    if result.function_count == 0:
+        reasons.append("No functions detected — may be a config/data file")
+
+    if not reasons:
+        reasons.append("All metrics within normal range — likely human-written code")
+
+    return reasons
+
+
 def _calculate_ai_probability(result: FileAnalysisResult) -> float:
     """
     Calculate a rule-based AI probability score (0.0 – 1.0).

{codedna-0.8.4 → codedna-0.9.0}/codedna/api.py

@@ -16,9 +16,11 @@ from pydantic import BaseModel
 
 from codedna import __version__
 from codedna.db import (
+    export_all_data as _export_all_data,
     get_commit_history,
     get_db_path,
     get_file_scores_for_commit,
+    import_data as _import_data,
     init_db,
     update_understanding_score,
 )
@@ -576,6 +578,178 @@ def _build_html_report(
 </html>"""
 
 
+# ---------------------------------------------------------------------------
+# Export/Import endpoints
+# ---------------------------------------------------------------------------
+
+@app.get("/export", tags=["Export"])
+async def export_data_endpoint() -> dict:
+    """Export all database data as JSON."""
+    db = _db_path()
+    init_db(db)
+    return _export_all_data(db_path=db)
+
+
+@app.post("/import", tags=["Export"])
+async def import_data_endpoint(data: dict) -> dict:
+    """Import previously exported data."""
+    db = _db_path()
+    init_db(db)
+    counts = _import_data(data, db_path=db)
+    return {"status": "imported", **counts}
+
+
+# ---------------------------------------------------------------------------
+# Trend data endpoints
+# ---------------------------------------------------------------------------
+
+@app.get("/trends", tags=["Trends"])
+async def trends(
+    limit: int = Query(30, ge=1, le=365, description="Number of days to return"),
+) -> dict:
+    """Return day-by-day trend data for AI score and understanding over time."""
+    db = _db_path()
+    init_db(db)
+    try:
+        from codedna.db import get_trend_data
+        rows = get_trend_data(db_path=db, limit=limit)
+    except Exception:
+        rows = []
+    return {"total_days": len(rows), "trends": rows}
+
+
+@app.get("/trends/commits", tags=["Trends"])
+async def commit_trends(
+    limit: int = Query(50, ge=1, le=500, description="Number of commits"),
+) -> dict:
+    """Return commit-level trend data (AI score, understanding per commit)."""
+    db = _db_path()
+    init_db(db)
+    commits = get_commit_history(limit=limit, db_path=db)
+    items = []
+    for c in commits:
+        files = get_file_scores_for_commit(c["commit_hash"], db_path=db)
+        ai_scores = [float(f["ai_probability"]) for f in files if f["ai_probability"] is not None]
+        avg_ai = sum(ai_scores) / len(ai_scores) if ai_scores else None
+        items.append({
+            "commit_hash": c["commit_hash"][:8] if c["commit_hash"] else "",
+            "author": c["author"],
+            "date": datetime.fromtimestamp(c["timestamp"]).strftime("%Y-%m-%d") if c["timestamp"] else None,
+            "avg_ai_score": round(avg_ai, 3) if avg_ai else None,
+            "understanding_score": round(float(c["understanding_score"]), 2) if c["understanding_score"] is not None else None,
+        })
+    return {"total": len(items), "trends": list(reversed(items))}
+
+
+# ---------------------------------------------------------------------------
+# Feedback endpoints
+# ---------------------------------------------------------------------------
+
+FEEDBACK_PATH = Path.home() / ".codedna" / "feedback.json"
+
+
+@app.post("/feedback", tags=["Feedback"])
+async def save_feedback(data: dict) -> dict:
+    """Save user feedback on AI analysis accuracy."""
+    db = _db_path()
+    init_db(db)
+    feedback_file = FEEDBACK_PATH
+
+    feedback_file.parent.mkdir(parents=True, exist_ok=True)
+    existing = []
+    if feedback_file.exists():
+        try:
+            existing = json.loads(feedback_file.read_text())
+        except Exception:
+            existing = []
+
+    entry = {
+        "id": len(existing) + 1,
+        "timestamp": datetime.utcnow().isoformat(),
+        "file_path": data.get("file_path", ""),
+        "commit_hash": data.get("commit_hash", ""),
+        "ai_probability": data.get("ai_probability"),
+        "user_rating": data.get("rating"),  # "correct", "incorrect", "unsure"
+        "user_note": data.get("note", ""),
+    }
+    existing.append(entry)
+    feedback_file.write_text(json.dumps(existing, indent=2))
+    return {"status": "saved", "id": entry["id"]}
+
+
+@app.get("/feedback", tags=["Feedback"])
+async def list_feedback(limit: int = Query(50, ge=1, le=500)) -> dict:
+    """Return user feedback entries."""
+    feedback_file = FEEDBACK_PATH
+    if not feedback_file.exists():
+        return {"total": 0, "feedback": []}
+    try:
+        items = json.loads(feedback_file.read_text())
+    except Exception:
+        items = []
+    return {"total": len(items), "feedback": items[-limit:]}
+
+
+# ---------------------------------------------------------------------------
+# Multi-repo endpoints
+# ---------------------------------------------------------------------------
+
+MULTI_REPO_PATH = Path.home() / ".codedna" / "repos.json"
+
+
+@app.get("/repos", tags=["Multi-Repo"])
+async def list_repos() -> dict:
+    """Return configured multi-repo list."""
+    repos_file = MULTI_REPO_PATH
+    if not repos_file.exists():
+        return {"total": 0, "repos": []}
+    try:
+        items = json.loads(repos_file.read_text())
+    except Exception:
+        items = []
+    return {"total": len(items), "repos": items}
+
+
+@app.post("/repos", tags=["Multi-Repo"])
+async def add_repo(data: dict) -> dict:
+    """Add a repository to the multi-repo config."""
+    repos_file = MULTI_REPO_PATH
+    repos_file.parent.mkdir(parents=True, exist_ok=True)
+    existing = []
+    if repos_file.exists():
+        try:
+            existing = json.loads(repos_file.read_text())
+        except Exception:
+            existing = []
+
+    new_repo = {
+        "id": len(existing) + 1,
+        "name": data.get("name", ""),
+        "path": data.get("path", ""),
+        "added_at": datetime.utcnow().isoformat(),
+    }
+    existing.append(new_repo)
+    repos_file.write_text(json.dumps(existing, indent=2))
+    return {"status": "added", "repo": new_repo}
+
+
+@app.delete("/repos/{repo_id}", tags=["Multi-Repo"])
+async def remove_repo(repo_id: int) -> dict:
+    """Remove a repository from the multi-repo config."""
+    repos_file = MULTI_REPO_PATH
+    if not repos_file.exists():
+        raise HTTPException(status_code=404, detail="No repos configured.")
+    try:
+        items = json.loads(repos_file.read_text())
+    except Exception:
+        items = []
+    filtered = [r for r in items if r.get("id") != repo_id]
+    if len(filtered) == len(items):
+        raise HTTPException(status_code=404, detail=f"Repo #{repo_id} not found.")
+    repos_file.write_text(json.dumps(filtered, indent=2))
+    return {"status": "removed", "repo_id": repo_id}
+
+
 # ---------------------------------------------------------------------------
 # Helper: plan 403 response
 # ---------------------------------------------------------------------------