codedna-analyzer 1.4.0__py3-none-any.whl

codedna/analyzers/dna_generator.py

@@ -0,0 +1,308 @@
+"""DNA Generator — aggregates all analysis results into a final DNA profile."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+
+from codedna import __version__
+
+
+class DNAGenerator:
+    """Produces the final DNA profile summary from all analysis modules."""
+
+    def generate(
+        self,
+        repo_source: str,
+        languages: dict,
+        structure: dict,
+        dependencies: dict,
+        architecture: dict,
+        smells: dict,
+        developers: dict,
+        evolution: dict,
+        security: dict = None,
+        github: dict = None,
+        mermaid_graph: str = "",
+    ) -> dict:
+        """Aggregate all analysis into a DNA profile.
+
+        Returns:
+            Complete DNA profile dict.
+        """
+        # Compute overall health
+        health = self._compute_overall_health(smells, dependencies, architecture, security)
+
+        # Build risk signals
+        risks = self._extract_risks(smells, dependencies, security)
+
+        # Build DNA signature
+        signature = self._build_signature(languages, architecture, developers, structure)
+
+        return {
+            "metadata": {
+                "source": repo_source,
+                "analyzed_at": datetime.now().isoformat(),
+                "version": __version__,
+            },
+            "signature": signature,
+            "system_type": architecture.get("primary_pattern", "Unknown"),
+            "languages": languages,
+            "architecture": architecture,
+            "structure_stats": {
+                "total_files": structure.get("total_files", 0),
+                "total_dirs": structure.get("total_dirs", 0),
+                "max_depth": structure.get("max_depth", 0),
+                "modules": len(structure.get("modules", [])),
+            },
+            "dependencies": {
+                "total_modules": dependencies.get("total_modules", 0),
+                "total_edges": dependencies.get("total_edges", 0),
+                "density": dependencies.get("density", 0),
+                "has_circular_deps": dependencies.get("has_circular_deps", False),
+                "circular_count": len(dependencies.get("cycles", [])),
+            },
+            "health": health,
+            "risks": risks,
+            "developer_genome": {
+                "total_contributors": developers.get("total_contributors", 0),
+                "bus_factor": developers.get("bus_factor", 0),
+                "primary_architect": (
+                    developers["contributors"][0]["name"]
+                    if developers.get("contributors")
+                    else "Unknown"
+                ),
+                "top_contributors": [
+                    {"name": c["name"], "role": c["role"], "commits": c["commits"]}
+                    for c in developers.get("contributors", [])[:5]
+                ],
+            },
+            "evolution": {
+                "total_commits": evolution.get("total_commits", 0),
+                "first_commit": evolution.get("first_commit"),
+                "last_commit": evolution.get("last_commit"),
+                "patterns": evolution.get("patterns", []),
+            },
+            "complexity": smells.get("complexity", {}) if isinstance(smells, dict) else {},
+            "security": security or {"vulnerabilities": [], "total_critical": 0, "has_secrets": False},  # noqa: E501
+            "github": github or {},
+            "mermaid_graph": mermaid_graph,
+        }
+
+    def to_markdown(self, profile: dict) -> str:
+        """Convert DNA profile to a markdown report."""
+        lines = []
+        lines.append("# 🧬 CodeDNA Profile\n")
+        lines.append(f"> Analyzed: `{profile['metadata']['source']}`")
+        lines.append(f"> Date: {profile['metadata']['analyzed_at'][:10]}")
+
+        if profile.get("github", {}).get("is_github"):
+            gh = profile["github"]
+            def _fmt_num(val):
+                if isinstance(val, str):
+                    try:
+                        val = float(val)
+                        if val.is_integer():
+                            val = int(val)
+                    except ValueError:
+                        pass
+                return f"{val:,}" if isinstance(val, (int, float)) else str(val)
+
+            stars_str = _fmt_num(gh.get('stars', 0))
+            forks_str = _fmt_num(gh.get('forks', 0))
+            issues_str = _fmt_num(gh.get('issues', 0))
+
+            lines.append(f"> ⭐️ {stars_str} Stars | 🔱 {forks_str} Forks | 🐛 {issues_str} Issues\n")  # noqa: E501
+        else:
+            lines.append("\n")
+
+        lines.append("---\n")
+
+        # System Type
+        lines.append(f"## 🏗️ System Type: **{profile['system_type']}**\n")
+
+        # Architecture
+        arch = profile["architecture"]
+        if arch.get("detected_patterns"):
+            lines.append("### Architecture Patterns Detected")
+            for p in arch["detected_patterns"]:
+                bar = "█" * int(p["confidence"] * 10)
+                lines.append(f"- **{p['pattern']}** ({int(p['confidence']*100)}%) `{bar}`")
+            lines.append("")
+
+        if arch.get("traits"):
+            lines.append("### Infrastructure Traits")
+            for t in arch["traits"]:
+                lines.append(f"- ✅ {t}")
+            lines.append("")
+
+        # Languages
+        lang_data = profile["languages"]
+        if lang_data.get("languages"):
+            lines.append("## 📊 Language Distribution\n")
+            lines.append("| Language | Files | Lines | Share |")
+            lines.append("|----------|-------|-------|-------|")
+            for lang, data in lang_data["languages"].items():
+                bar = "█" * max(1, int(data["percentage"] / 5))
+                lines_val = data['lines']
+                if isinstance(lines_val, str):
+                    try:
+                        lines_val = float(lines_val)
+                        if lines_val.is_integer():
+                            lines_val = int(lines_val)
+                    except ValueError:
+                        pass
+                lines_str = f"{lines_val:,}" if isinstance(lines_val, (int, float)) else str(lines_val)
+                lines.append(f"| {lang} | {data['files']} | {lines_str} | {data['percentage']}% `{bar}` |")  # noqa: E501
+            lines.append("")
+
+        # Health
+        lines.append(f"## 🩺 Health Score: **{profile['health']['overall']}**\n")
+        counts = profile["health"]["severity_counts"]
+        lines.append(f"- 🔴 Critical: {counts.get('critical', 0)}")
+        lines.append(f"- 🟡 Warning: {counts.get('warning', 0)}")
+        lines.append(f"- 🔵 Info: {counts.get('info', 0)}")
+        lines.append("")
+
+        # Complexity & Maintainability
+        cmp = profile.get("complexity", {})
+        if cmp and cmp.get("total_functions_analyzed", 0) > 0:
+            lines.append("## ⚙️ Maintainability & Cognitive Complexity\n")
+            lines.append(f"- Maintainability Index: **{cmp.get('maintainability_index', 0.0)}/100 (Rank {cmp.get('maintainability_rank', 'N/A')})**")
+            lines.append(f"- Average Cyclomatic Complexity: **{cmp.get('average_cyclomatic_complexity', 1.0)}**")
+            lines.append(f"- Peak Cyclomatic Complexity: **{cmp.get('max_cyclomatic_complexity', 1)}**")
+            lines.append(f"- Average Cognitive Complexity: **{cmp.get('average_cognitive_complexity', 0.0)}**")
+            lines.append(f"- Functions Analyzed: **{cmp.get('total_functions_analyzed', 0)}**\n")
+
+        # Risks
+        if profile["risks"]:
+            lines.append("## ⚠️ Risk Signals\n")
+            for risk in profile["risks"][:8]:
+                lines.append(f"- {risk}")
+            lines.append("")
+
+        # Dependencies
+        deps = profile["dependencies"]
+        lines.append("## 🔗 Dependency Graph\n")
+        lines.append(f"- Modules: **{deps['total_modules']}**")
+        lines.append(f"- Connections: **{deps['total_edges']}**")
+        lines.append(f"- Density: **{deps['density']}**")
+        lines.append(f"- Circular Dependencies: **{'Yes ⚠️' if deps['has_circular_deps'] else 'None ✅'}**\n")  # noqa: E501
+
+        if profile.get("mermaid_graph"):
+            lines.append("```mermaid\n" + profile["mermaid_graph"] + "\n```\n")
+
+        # Developer Genome
+        dev = profile["developer_genome"]
+        lines.append("## 👥 Developer Genome\n")
+        lines.append(f"- Contributors: **{dev['total_contributors']}**")
+        lines.append(f"- Bus Factor: **{dev['bus_factor']}**")
+        lines.append(f"- Primary Architect: **{dev['primary_architect']}**\n")
+
+        if dev["top_contributors"]:
+            lines.append("| Developer | Role | Commits |")
+            lines.append("|-----------|------|---------|")
+            for c in dev["top_contributors"]:
+                lines.append(f"| {c['name']} | {c['role']} | {c['commits']} |")
+            lines.append("")
+
+        # Evolution
+        evo = profile["evolution"]
+        lines.append("## 📈 Evolution\n")
+        lines.append(f"- Total Commits: **{evo['total_commits']}**")
+        if evo.get("first_commit"):
+            lines.append(f"- First Commit: {evo['first_commit'][:10]}")
+        if evo.get("patterns"):
+            lines.append(f"- Patterns: {', '.join(evo['patterns'])}")
+        lines.append("")
+
+        # DNA Signature
+        lines.append("## 🧬 DNA Signature\n")
+        lines.append(f"```\n{profile['signature']}\n```\n")
+
+        lines.append("---")
+        lines.append("*Generated by [CodeDNA](https://github.com/shenald-dev/codedna)*")
+
+        return "\n".join(lines)
+
+    def to_json(self, profile: dict) -> str:
+        """Convert DNA profile to JSON."""
+        return json.dumps(profile, indent=2, default=str)
+
+    def _compute_overall_health(self, smells: dict, deps: dict, arch: dict, security: dict = None) -> dict:  # noqa: E501
+        """Compute overall health assessment."""
+        severity = smells.get("severity_counts", {})
+        health_score = smells.get("health_score", "Unknown")
+
+        if security and security.get("has_secrets"):
+            health_score = "Critical"
+
+        return {
+            "overall": health_score,
+            "severity_counts": severity,
+            "coupling": arch.get("coupling", "Unknown"),
+            "circular_deps": deps.get("has_circular_deps", False),
+        }
+
+    def _extract_risks(self, smells: dict, deps: dict, security: dict = None) -> list[str]:
+        """Extract top risk signals from analysis."""
+        risks = []
+
+        if security:
+            for vuln in security.get("vulnerabilities", []):
+                risks.append(f"🔴 {vuln['type']} in `{vuln['file']}`: {vuln['detail']}")
+
+        for smell in smells.get("smells", []):
+            if smell["severity"] == "critical":
+                risks.append(f"🔴 {smell['type']} in `{smell['file']}`: {smell['detail']}")
+
+        if deps.get("has_circular_deps"):
+            cycle_count = len(deps.get("cycles", []))
+            risks.append(f"🔴 {cycle_count} circular dependencies detected")
+
+        for smell in smells.get("smells", []):
+            if smell["severity"] == "warning" and len(risks) < 10:
+                risks.append(f"🟡 {smell['type']} in `{smell['file']}`")
+
+        return risks[:10]
+
+    def _build_signature(self, languages: dict, architecture: dict, developers: dict, structure: dict) -> str:  # noqa: E501
+        """Build a DNA-style signature string."""
+        parts = []
+
+        # Language gene
+        primary = languages.get("primary", "?")
+        parts.append(f"LANG:{primary[:3].upper()}")
+
+        # Architecture gene
+        arch = architecture.get("primary_pattern", "MON")[:3].upper()
+        parts.append(f"ARCH:{arch}")
+
+        # Size gene
+        files = structure.get("total_files", 0)
+        if files > 1000:
+            size = "XL"
+        elif files > 100:
+            size = "LG"
+        elif files > 20:
+            size = "MD"
+        else:
+            size = "SM"
+        parts.append(f"SIZE:{size}")
+
+        # Team gene
+        contribs = developers.get("total_contributors", 0)
+        if contribs > 20:
+            team = "ENTERPRISE"
+        elif contribs > 5:
+            team = "TEAM"
+        elif contribs > 1:
+            team = "DUO"
+        else:
+            team = "SOLO"
+        parts.append(f"TEAM:{team}")
+
+        # Health gene
+        parts.append(f"HEALTH:{developers.get('bus_factor', 0)}")
+
+        return " | ".join(parts)

codedna/analyzers/evolution_engine.py

@@ -0,0 +1,193 @@
+"""Evolution Engine — tracks how the codebase architecture changed over time."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+from git import Repo
+from git.exc import InvalidGitRepositoryError
+
+
+class EvolutionEngine:
+    """Analyzes codebase evolution across Git commit history."""
+
+    def analyze(self, repo_path: Path, snapshots: int = 6) -> dict:
+        """Track how the codebase evolved over time.
+
+        Args:
+            repo_path: Path to the repository.
+            snapshots: Number of time-points to analyze.
+
+        Returns:
+            Dict with growth timeline, churn hotspots, and evolution patterns.
+        """
+
+        try:
+            repo = Repo(str(repo_path))
+        except InvalidGitRepositoryError:
+            return {"error": "Not a Git repository", "timeline": []}
+
+        try:
+            log_output = repo.git.log(
+                "--format=tformat:COMMIT::%H::%cI::%cd::%s",
+                "--date=short",
+                "--shortstat",
+                "-n", "500"
+            )
+        except Exception:
+            log_output = ""
+
+        commits = []
+        current_commit = {}
+        for line in log_output.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith("COMMIT::"):
+                if current_commit:
+                    commits.append(current_commit)
+                parts = line.split("::", 4)
+                current_commit = {
+                    "hexsha": parts[1] if len(parts) > 1 else "",
+                    "iso_date": parts[2] if len(parts) > 2 else "",
+                    "date": parts[3] if len(parts) > 3 else "",
+                    "message": parts[4].strip().split("\n")[0][:60] if len(parts) > 4 else "",
+                    "additions": 0,
+                    "deletions": 0,
+                }
+            elif current_commit and ("files changed" in line or "file changed" in line):
+                ins_match = re.search(r'(\d+)\s+insertion', line)
+                del_match = re.search(r'(\d+)\s+deletion', line)
+                if ins_match:
+                    current_commit["additions"] = int(ins_match.group(1))
+                if del_match:
+                    current_commit["deletions"] = int(del_match.group(1))
+
+        if current_commit:
+            commits.append(current_commit)
+
+        if not commits:
+            return {"timeline": [], "patterns": []}
+
+        # Build timeline snapshots
+        timeline = self._build_timeline(commits, snapshots, repo)
+
+        # Detect churn (files that change most frequently)
+        churn = self._compute_churn(repo)
+
+        # Detect evolution patterns
+        patterns = self._detect_patterns(timeline)
+
+        return {
+            "total_commits": len(commits),
+            "first_commit": commits[-1]["iso_date"] if commits else None,
+            "last_commit": commits[0]["iso_date"] if commits else None,
+            "timeline": timeline,
+            "churn_hotspots": churn[:10],
+            "patterns": patterns,
+        }
+
+    def _build_timeline(self, commits: list[dict], snapshots: int, repo: 'Repo') -> list[dict]:
+        """Build time-based snapshots of the project's evolution."""
+        if len(commits) < 2:
+            return []
+
+        step = max(1, len(commits) // snapshots)
+        timeline = []
+
+        for i in range(0, len(commits), step):
+            commit = commits[i]
+
+            # Count files at this point
+            try:
+                output = repo.git.ls_tree("-r", commit["hexsha"])
+                file_count = output.count('\n') + 1 if output else 0
+            except Exception:
+                file_count = 0
+
+            timeline.append({
+                "date": commit["date"],
+                "commit": commit["hexsha"][:8],
+                "message": commit["message"],
+                "file_count": file_count,
+                "additions": commit["additions"],
+                "deletions": commit["deletions"],
+            })
+
+        return timeline[:snapshots]
+
+    def _compute_churn(self, repo: 'Repo') -> list[dict]:
+        """Find files with the highest change frequency (churn)."""
+        file_changes: Counter = Counter()
+        file_additions: defaultdict = defaultdict(int)
+        file_deletions: defaultdict = defaultdict(int)
+
+        try:
+            # Note: Explicit tformat: prefix is required by newer Git versions for custom strings
+            output = repo.git.log(
+                "--numstat",
+                "--format=tformat:COMMIT",
+                "-n 200",
+                "--no-renames"
+            )
+
+            for line in output.split('\n'):
+                line = line.strip()
+                if not line or line == "COMMIT":
+                    continue
+
+                parts = line.split('\t')
+                if len(parts) >= 3:
+                    ins, dels, filepath = parts[0], parts[1], parts[2]
+                    try:
+                        ins_int = int(ins) if ins != '-' else 0
+                        del_int = int(dels) if dels != '-' else 0
+                    except ValueError:
+                        ins_int, del_int = 0, 0
+
+                    file_changes[filepath] += 1
+                    file_additions[filepath] += ins_int
+                    file_deletions[filepath] += del_int
+        except Exception:
+            pass
+
+        return [
+            {
+                "file": f,
+                "changes": c,
+                "total_additions": file_additions[f],
+                "total_deletions": file_deletions[f],
+            }
+            for f, c in file_changes.most_common(15)
+        ]
+
+    def _detect_patterns(self, timeline: list[dict]) -> list[str]:
+        """Detect evolutionary patterns from the timeline."""
+        patterns = []
+
+        if len(timeline) < 2:
+            return ["Insufficient data"]
+
+        # Check for rapid growth
+        file_counts = [t["file_count"] for t in timeline if t["file_count"] > 0]
+        if len(file_counts) >= 2 and file_counts[0] > 0:
+            growth_ratio = file_counts[-1] / file_counts[0] if file_counts[0] else 1
+            if growth_ratio > 3:
+                patterns.append("Rapid Growth")
+            elif growth_ratio > 1.5:
+                patterns.append("Steady Growth")
+            elif growth_ratio < 0.8:
+                patterns.append("Code Consolidation")
+
+        # Check for high churn
+        total_additions = sum(t["additions"] for t in timeline)
+        total_deletions = sum(t["deletions"] for t in timeline)
+        if total_deletions > 0 and total_additions / max(total_deletions, 1) < 1.5:
+            patterns.append("High Refactoring Activity")
+
+        if not patterns:
+            patterns.append("Stable Evolution")
+
+        return patterns

codedna/analyzers/github_analyzer.py

@@ -0,0 +1,86 @@
+"""GitHub Analyzer — fetches community stats for GitHub repositories."""
+
+from __future__ import annotations
+
+import json
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+
+from .cache_manager import CacheManager
+
+
+class GitHubAnalyzer:
+    """Fetches metadata and community stats from GitHub API."""
+
+    def analyze(self, source: str) -> dict:
+        """Fetch repository stats if the source is a GitHub URL.
+
+        Args:
+            source: The repository source (local path or URL).
+
+        Returns:
+            Dict containing GitHub stats if available, otherwise empty.
+        """
+        stats = {
+            "is_github": False,
+            "stars": 0,
+            "forks": 0,
+            "issues": 0,
+            "description": "",
+            "homepage": "",
+        }
+
+        try:
+            parsed = urlparse(source)
+        except Exception:
+            return stats
+
+        if parsed.scheme not in ("http", "https") or parsed.hostname != "github.com":
+            return stats
+
+        # Check Cache
+        cache = CacheManager()
+        cached_stats = cache.get("github_api", source)
+        if cached_stats:
+            return cached_stats
+
+        # Extract owner/repo from path (e.g., /owner/repo)
+        path_parts = [p for p in parsed.path.split("/") if p]
+        if len(path_parts) >= 2:
+            owner, repo = path_parts[0], path_parts[1]
+            if repo.endswith(".git"):
+                repo = repo[:-4]
+
+            # Validate that owner and repo are safe strings
+            def is_valid_identifier(s):
+                return s and s not in ("..", ".") and all(c.isalnum() or c in "-_." for c in s)
+
+            if not is_valid_identifier(owner) or not is_valid_identifier(repo):
+                return stats
+
+            api_url = f"https://api.github.com/repos/{owner}/{repo}"
+
+            try:
+                req = Request(
+                    api_url,
+                    headers={"User-Agent": "CodeDNA-Analyzer"}
+                )
+                with urlopen(req, timeout=5) as response:
+                    data = json.loads(response.read().decode())
+
+                    stats.update({
+                        "is_github": True,
+                        "stars": data.get("stargazers_count", 0),
+                        "forks": data.get("forks_count", 0),
+                        "issues": data.get("open_issues_count", 0),
+                        "description": data.get("description", "") or "",
+                        "homepage": data.get("homepage", "") or "",
+                    })
+                    # Save to cache
+                    cache.set("github_api", source, stats)
+            except (URLError, HTTPError):
+                # Fail gracefully if offline or rate limited
+                pass
+
+        return stats