codedna-analyzer 1.4.0__py3-none-any.whl

codedna/__init__.py

@@ -0,0 +1,3 @@
+"""CodeDNA — A genetic analyzer for software."""
+
+__version__ = "1.4.0"

codedna/analyzers/__init__.py

@@ -0,0 +1 @@
+"""CodeDNA analyzers — core analysis modules."""

codedna/analyzers/ai_analyzer.py

@@ -0,0 +1,111 @@
+"""AI Analyzer — synthesizes a natural language Executive Summary from the raw DNA profile."""
+
+from __future__ import annotations
+
+import copy
+import json
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AIResult:
+    executive_summary: str
+    refactoring_recommendations: list[str]
+    success: bool
+    error_message: Optional[str] = None
+
+
+class AIAnalyzer:
+    """Uses an LLM to generate insights from the CodeDNA profile."""
+
+    def __init__(self):
+        self.api_key = os.environ.get("OPENAI_API_KEY")
+
+    def synthesize(self, raw_dna_profile: dict) -> AIResult:
+        """Sends the raw DNA profile to the LLM and parses the response.
+
+        Args:
+            raw_dna_profile: The JSON-serializable dictionary of all generated metrics.
+
+        Returns:
+            An AIResult containing the summary and recommendations.
+        """
+        if not self.api_key:
+            return AIResult(
+                executive_summary="AI Analysis skipped. Set the `OPENAI_API_KEY` environment variable to enable intelligent synthesis.",  # noqa: E501
+                refactoring_recommendations=[],
+                success=False,
+                error_message="Missing OPENAI_API_KEY"
+            )
+
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=self.api_key)
+        except ImportError:
+            return AIResult(
+                executive_summary="AI Analysis skipped. The `openai` python package is not installed.",  # noqa: E501
+                refactoring_recommendations=[],
+                success=False,
+                error_message="Missing openai package"
+            )
+
+        # Truncate profile elements if they are too large to fit in context
+        safe_profile = self._minimize_payload(raw_dna_profile)
+
+        system_prompt = (
+            "You are CodeDNA, an expert software architect and senior code reviewer. "
+            "You are provided with a 'DNA Profile' of a codebase containing metrics about languages, "  # noqa: E501
+            "architecture, dependencies, developers, and code smells. "
+            "Your task is to synthesize this raw data into a brilliant, concise 'Executive Summary' (2-3 paragraphs) "  # noqa: E501
+            "and extract EXACTLY 3 major 'Refactoring Recommendations' based on the worst code smells or architectural flaws detected.\n\n"  # noqa: E501
+            "Format the output strictly as a JSON object with two keys:\n"
+            '{"executive_summary": "...", "refactoring_recommendations": ["...", "...", "..."]}'
+        )
+
+        try:
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": json.dumps(safe_profile, default=str)}
+                ],
+                response_format={"type": "json_object"},
+                timeout=30.0
+            )
+
+            raw_response = response.choices[0].message.content
+            parsed = json.loads(raw_response)
+
+            return AIResult(
+                executive_summary=parsed.get("executive_summary", "Synthesis failed structurally."),
+                refactoring_recommendations=parsed.get("refactoring_recommendations", []),
+                success=True
+            )
+
+        except Exception as e:
+            return AIResult(
+                executive_summary="AI Analysis failed due to an API error.",
+                refactoring_recommendations=[],
+                success=False,
+                error_message=str(e)
+            )
+
+    def _minimize_payload(self, profile: dict) -> dict:
+        """Removes large arrays or deeply nested structures before sending to LLM."""
+        clone = copy.deepcopy(profile)
+        # Drop raw file lists if they exist
+        if "structure_stats" in clone and "modules" in clone["structure_stats"]:
+            if isinstance(clone["structure_stats"]["modules"], list):
+                clone["structure_stats"]["modules"] = len(clone["structure_stats"]["modules"])
+
+        # Keep only top 5 risks to avoid blowing up context token limits
+        if "risks" in clone:
+            clone["risks"] = clone["risks"][:5]
+
+        # Strip out massive raw graphs
+        if "mermaid_graph" in clone:
+            del clone["mermaid_graph"]
+
+        return clone

codedna/analyzers/architecture_detector.py

@@ -0,0 +1,150 @@
+"""Architecture Detector — identifies architecture patterns via rule-based heuristics."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .language_detector import IGNORE_DIRS
+
+# Architecture pattern definitions
+PATTERNS = {
+    "MVC": {
+        "indicators": ["models", "views", "controllers", "templates"],
+        "min_matches": 3,
+    },
+    "Layered": {
+        "indicators": ["api", "services", "repositories", "models", "controllers", "routes"],
+        "min_matches": 3,
+    },
+    "Microservices": {
+        "indicators": ["docker-compose", "gateway", "services", "api-gateway"],
+        "min_matches": 2,
+    },
+    "Plugin Architecture": {
+        "indicators": ["plugins", "extensions", "addons", "hooks", "middleware"],
+        "min_matches": 2,
+    },
+    "Event-Driven": {
+        "indicators": ["events", "handlers", "listeners", "subscribers", "queues", "consumers"],
+        "min_matches": 2,
+    },
+    "Monorepo": {
+        "indicators": ["packages", "apps", "libs", "workspaces"],
+        "min_matches": 2,
+    },
+    "CLI Tool": {
+        "indicators": ["cli", "commands", "bin"],
+        "min_matches": 2,
+    },
+    "Clean Architecture / Hexagonal": {
+        "indicators": ["domain", "core", "ports", "adapters", "usecases", "entities"],
+        "min_matches": 3,
+    },
+    "CQRS / Event-Sourced": {
+        "indicators": ["commands", "queries", "events", "handlers", "projections", "aggregates"],
+        "min_matches": 3,
+    },
+    "Serverless": {
+        "indicators": ["functions", "lambdas", "serverless.yml", "serverless.ts", "sam.yaml"],
+        "min_matches": 2,
+    },
+}
+
+# File/config indicators
+CONFIG_PATTERNS = {
+    "Containerized": ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"],
+    "CI/CD Enabled": [".github/workflows", ".gitlab-ci.yml", "Jenkinsfile", ".circleci"],
+    "Tested": ["tests", "test", "__tests__", "spec", "pytest.ini", "jest.config"],
+    "Documented": ["docs", "documentation", "wiki", "ARCHITECTURE.md"],
+    "Type-Safe": ["tsconfig.json", "mypy.ini", ".mypy.ini", "pyproject.toml"],
+    "Cloud Native": ["k8s", "kubernetes", "helm", "terraform", "main.tf"],
+    "Security Hardened": [".snyk", "security.md", "trivy.yaml", ".gitleaks.toml"],
+}
+
+
+class ArchitectureDetector:
+    """Detects software architecture patterns through directory and file analysis."""
+
+    def detect(self, repo_path: Path) -> dict:
+        """Identify architecture patterns in the repository.
+
+        Returns:
+            Dict with detected patterns, traits, and confidence scores.
+        """
+        all_names = set()
+        total_src_dir_depth = 0
+        src_dir_count = 0
+
+        for item, depth in self._walk(repo_path):
+            if item.is_dir():
+                all_names.add(item.name.lower())
+                if item.name not in IGNORE_DIRS:
+                    total_src_dir_depth += depth
+                    src_dir_count += 1
+            else:
+                all_names.add(item.name.lower())
+        # Detect architecture patterns
+        detected = []
+        for pattern_name, config in PATTERNS.items():
+            indicators = config["indicators"]
+            matches = [ind for ind in indicators if ind in all_names]
+            if len(matches) >= config["min_matches"]:
+                confidence = round(len(matches) / len(indicators), 2)
+                detected.append({
+                    "pattern": pattern_name,
+                    "confidence": confidence,
+                    "matched_indicators": matches,
+                })
+
+        # Detect infrastructure traits
+        traits = []
+        for trait_name, indicators in CONFIG_PATTERNS.items():
+            for ind in indicators:
+                ind_path = repo_path / ind
+                if ind_path.exists() or ind.lower() in all_names:
+                    traits.append(trait_name)
+                    break
+
+        # Determine coupling level
+        if src_dir_count == 0:
+            coupling = "Unknown"
+        else:
+            avg_depth = total_src_dir_depth / src_dir_count
+            if avg_depth > 4:
+                coupling = "High"
+            elif avg_depth > 2.5:
+                coupling = "Moderate"
+            else:
+                coupling = "Low"
+
+        # Sort by confidence
+        detected.sort(key=lambda x: x["confidence"], reverse=True)
+
+        primary_pattern = detected[0]["pattern"] if detected else "Monolith"
+
+        return {
+            "primary_pattern": primary_pattern,
+            "detected_patterns": detected,
+            "traits": traits,
+            "coupling": coupling,
+        }
+
+    def _walk(self, root: Path, max_depth: int = 5):
+        stack = [(root, 0)]
+        while stack:
+            current_dir, current_depth = stack.pop()
+            if current_depth >= max_depth:
+                continue
+            try:
+                with os.scandir(current_dir) as it:
+                    for entry in it:
+                        if entry.name in IGNORE_DIRS or entry.name.startswith("."):
+                            continue
+                        # Yield entry along with its effective depth (child depth is current_depth + 1)
+                        # to avoid redundant O(N) recomputation using `item.relative_to` in callers
+                        yield entry, current_depth + 1
+                        if entry.is_dir():
+                            stack.append((Path(entry.path), current_depth + 1))
+            except (PermissionError, FileNotFoundError):
+                pass

codedna/analyzers/cache_manager.py

@@ -0,0 +1,70 @@
+"""Cache Manager — handles disk-based caching for computationally expensive operations."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+class CacheManager:
+    """Manages local disk cache for CodeDNA analysis results."""
+
+    def __init__(self, cache_dir: Path | str = ".codedna_cache"):
+        self.cache_dir = Path(cache_dir)
+        self.ttl = timedelta(days=1)
+        self._ensure_cache_dir()
+
+    def _ensure_cache_dir(self):
+        """Ensure the cache directory exists."""
+        if not self.cache_dir.exists():
+            try:
+                self.cache_dir.mkdir(parents=True, exist_ok=True)
+                # Add out to .gitignore mechanism usually, but keep it local
+                ignore_file = self.cache_dir / ".gitignore"
+                if not ignore_file.exists():
+                    ignore_file.write_text("*\n!.gitignore\n", encoding="utf-8")
+            except Exception:
+                pass
+
+    def _get_cache_key(self, scope: str, identifier: str) -> str:
+        """Generate a consistent cache key."""
+        raw = f"{scope}::{identifier}"
+        return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+    def get(self, scope: str, identifier: str) -> dict | None:
+        """Retrieve a value from the cache if it exists and is not expired."""
+        key = self._get_cache_key(scope, identifier)
+        cache_file = self.cache_dir / f"{key}.json"
+
+        if not cache_file.exists():
+            return None
+
+        try:
+            data = json.loads(cache_file.read_text(encoding="utf-8"))
+            timestamp = datetime.fromisoformat(data["_cached_at"])
+
+            # Check expiration
+            if datetime.now() - timestamp > self.ttl:
+                return None
+
+            return data["payload"]
+        except Exception:
+            return None
+
+    def set(self, scope: str, identifier: str, payload: dict) -> bool:
+        """Store a value in the cache."""
+        key = self._get_cache_key(scope, identifier)
+        cache_file = self.cache_dir / f"{key}.json"
+
+        data = {
+            "_cached_at": datetime.now().isoformat(),
+            "payload": payload
+        }
+
+        try:
+            cache_file.write_text(json.dumps(data), encoding="utf-8")
+            return True
+        except Exception:
+            return False

codedna/analyzers/code_smell_detector.py

@@ -0,0 +1,302 @@
+"""Code Smell Detector — identifies structural design problems in codebases."""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .complexity_analyzer import ComplexityAnalyzer
+from .language_detector import IGNORE_DIRS
+
+if TYPE_CHECKING:
+    from codedna.config import CodeDNAConfig
+
+try:
+    MAX_FILE_SIZE = int(os.environ.get("CODEDNA_MAX_FILE_SIZE", 5 * 1024 * 1024))
+except ValueError:
+    logging.getLogger(__name__).warning("Invalid CODEDNA_MAX_FILE_SIZE value. Using default 5MB.")
+    MAX_FILE_SIZE = 5 * 1024 * 1024
+
+# Default Thresholds
+MAX_FILE_LINES = 500
+MAX_FUNCTION_LINES = 80
+GOD_CLASS_METHODS = 15
+LARGE_MODULE_FILES = 20
+HUB_NODE_IMPORTS = 15
+
+# Pre-compiled Regular Expressions for performance
+MARKER_PATTERN = re.compile(r"(TODO|FIXME|HACK|XXX)", re.IGNORECASE)
+PY_METHOD_PATTERN = re.compile(r"^[ \t]*def\s+\w+", re.MULTILINE)
+JS_METHOD_PATTERN = re.compile(r"(?:\bfunction\s+\w+)|(?:=>\s*\{)|(?:\b[a-zA-Z_$][\w$]*\s*\([^)]*\)\s*\{)")
+JAVA_METHOD_PATTERN = re.compile(r"(?:\bpublic|\bprivate|\bprotected)\s+\w+\s+\w+\s*\(")
+IMPORT_PATTERN = re.compile(r"^(?:import|from)\s+([A-Za-z0-9_.]+)", re.MULTILINE)
+
+
+class CodeSmellDetector:
+    """Detects common code smells and structural issues."""
+
+    def __init__(self, config: CodeDNAConfig | None = None) -> None:
+        self.config = config
+
+    def detect(self, repo_path: Path, config: CodeDNAConfig | None = None) -> dict:
+        """Scan for code smells in the repository.
+
+        Returns:
+            Dict with categorized smells and severity ratings.
+        """
+        active_config = config or self.config
+        smells: list[dict] = []
+        source_exts = {".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs", ".rb"}
+
+        # Dynamic thresholds
+        max_file_lines = active_config.max_file_lines if active_config else MAX_FILE_LINES
+        max_func_lines = active_config.max_function_lines if active_config else MAX_FUNCTION_LINES
+        god_methods = active_config.god_class_methods if active_config else GOD_CLASS_METHODS
+        large_mod_files = active_config.large_module_files if active_config else LARGE_MODULE_FILES
+
+        stack = [repo_path]
+        while stack:
+            current = stack.pop()
+            try:
+                file_count = 0
+                for item in current.iterdir():
+                    if item.name in IGNORE_DIRS or item.is_symlink():
+                        continue
+                    if item.is_dir():
+                        stack.append(item)
+                    elif item.is_file():
+                        file_count += 1
+                        if item.suffix.lower() in source_exts:
+                            try:
+                                rel = str(item.relative_to(repo_path))
+                                if active_config and active_config.is_path_ignored(rel):
+                                    continue
+                                if item.stat().st_size <= MAX_FILE_SIZE:
+                                    self._analyze_file(
+                                        item, repo_path, smells,
+                                        max_file_lines=max_file_lines,
+                                        max_func_lines=max_func_lines,
+                                        god_methods=god_methods,
+                                    )
+                            except OSError:
+                                pass
+
+                # ── Large Modules ──
+                if file_count > large_mod_files and current != repo_path:
+                    try:
+                        rel = str(current.relative_to(repo_path))
+                        if not (active_config and active_config.is_path_ignored(rel)):
+                            smells.append({
+                                "type": "Large Module",
+                                "severity": "warning",
+                                "file": rel,
+                                "line": 1,
+                                "detail": f"{file_count} files in module (threshold: {large_mod_files})",
+                            })
+                    except ValueError:
+                        pass
+            except PermissionError:
+                pass
+
+        # ── Complexity & Maintainability Analysis ──
+        complexity_data = {}
+        try:
+            complexity_data = ComplexityAnalyzer().analyze(repo_path, config=active_config)
+            for fn in complexity_data.get("complex_functions", []):
+                # High Cyclomatic Complexity
+                if fn.get("cyclomatic_complexity", 0) > 10:
+                    sev = "critical" if fn["cyclomatic_complexity"] > 20 else "warning"
+                    smells.append({
+                        "type": "High Cyclomatic Complexity",
+                        "severity": sev,
+                        "file": f"{fn['file']}:{fn['line']}",
+                        "line": fn["line"],
+                        "detail": f"Function '{fn['name']}' has Cyclomatic Complexity {fn['cyclomatic_complexity']} (threshold: 10)",
+                    })
+                # High Cognitive Complexity
+                if fn.get("cognitive_complexity", 0) > 15:
+                    sev = "critical" if fn["cognitive_complexity"] > 25 else "warning"
+                    smells.append({
+                        "type": "High Cognitive Complexity",
+                        "severity": sev,
+                        "file": f"{fn['file']}:{fn['line']}",
+                        "line": fn["line"],
+                        "detail": f"Function '{fn['name']}' has Cognitive Complexity {fn['cognitive_complexity']} (threshold: 15)",
+                    })
+        except Exception:
+            pass
+
+        # Summary
+        severity_counts = {"critical": 0, "warning": 0, "info": 0}
+        for smell in smells:
+            severity_counts[smell["severity"]] += 1
+
+        return {
+            "smells": smells,
+            "total": len(smells),
+            "severity_counts": severity_counts,
+            "health_score": self._compute_health(severity_counts),
+            "complexity": complexity_data,
+        }
+
+    def _analyze_file(
+        self,
+        item: Path,
+        repo_path: Path,
+        smells: list[dict],
+        max_file_lines: int = MAX_FILE_LINES,
+        max_func_lines: int = MAX_FUNCTION_LINES,
+        god_methods: int = GOD_CLASS_METHODS,
+    ) -> None:
+        """Analyze a single file for code smells."""
+        try:
+            content = item.read_text(encoding="utf-8", errors="ignore")
+            relative = str(item.relative_to(repo_path))
+        except (OSError, ValueError):
+            return
+
+        # ── Large File ──
+        line_count = content.count('\n') + 1
+        if line_count > max_file_lines:
+            smells.append({
+                "type": "Large File",
+                "severity": "warning" if line_count < 1000 else "critical",
+                "file": relative,
+                "line": 1,
+                "detail": f"{line_count} lines (threshold: {max_file_lines})",
+            })
+
+        # ── God Class ──
+        if item.suffix in (".py", ".java", ".ts", ".js"):
+            method_count = self._count_methods(content, item.suffix)
+            if method_count > god_methods:
+                smells.append({
+                    "type": "God Class",
+                    "severity": "critical",
+                    "file": relative,
+                    "line": 1,
+                    "detail": f"{method_count} methods detected (threshold: {god_methods})",
+                })
+
+        # ── Long Functions ──
+        long_funcs = self._detect_long_functions(content, item.suffix, max_func_lines=max_func_lines)
+        for func_name, length, start_line in long_funcs:
+            smells.append({
+                "type": "Long Function",
+                "severity": "warning",
+                "file": relative,
+                "line": start_line,
+                "detail": f"'{func_name}' has {length} lines (threshold: {max_func_lines})",
+            })
+
+        # ── Spaghetti Hub Node (Excessive Coupling) ──
+        if item.suffix == ".py":
+            imports_found = set(IMPORT_PATTERN.findall(content))
+            if len(imports_found) > HUB_NODE_IMPORTS:
+                smells.append({
+                    "type": "Spaghetti Hub Node",
+                    "severity": "warning",
+                    "file": relative,
+                    "line": 1,
+                    "detail": f"{len(imports_found)} distinct imports (threshold: {HUB_NODE_IMPORTS}) — high coupling risk",
+                })
+
+        # ── TODO/FIXME/HACK markers ──
+        if MARKER_PATTERN.search(content):
+            last_idx = 0
+            current_line = 1
+            for match in MARKER_PATTERN.finditer(content):
+                start_idx = match.start()
+                current_line += content.count('\n', last_idx, start_idx)
+                last_idx = start_idx
+
+                # Extract up to 80 chars of the line containing the marker
+                line_start = content.rfind('\n', 0, start_idx) + 1
+                line_end = content.find('\n', start_idx)
+                if line_end == -1:
+                    line_end = len(content)
+                line_text = content[line_start:line_end].strip()[:80]
+
+                smells.append({
+                    "type": "Code Marker",
+                    "severity": "info",
+                    "file": f"{relative}:{current_line}",
+                    "line": current_line,
+                    "detail": f"{match.group(1).upper()} found: {line_text}",
+                })
+
+    def _count_methods(self, content: str, ext: str) -> int:
+        """Count method/function definitions in a file."""
+        if ext == ".py":
+            return len(PY_METHOD_PATTERN.findall(content))
+        elif ext in (".js", ".ts", ".jsx", ".tsx"):
+            return len(JS_METHOD_PATTERN.findall(content))
+        elif ext == ".java":
+            return len(JAVA_METHOD_PATTERN.findall(content))
+        return 0
+
+    def _detect_long_functions(
+        self,
+        content: str,
+        ext: str,
+        max_func_lines: int = MAX_FUNCTION_LINES,
+    ) -> list[tuple[str, int, int]]:
+        """Detect functions exceeding the line threshold."""
+        results = []
+
+        if ext == ".py":
+            active_funcs = []
+            pattern = re.compile(r"^[ \t]*(def\s+(\w+)|class\s+\w+)", re.MULTILINE)
+
+            last_idx = 0
+            current_line = 0
+
+            for match in pattern.finditer(content):
+                start_idx = match.start()
+
+                # count newlines between last match and this match
+                current_line += content.count('\n', last_idx, start_idx)
+                last_idx = start_idx
+
+                # find indent
+                j = start_idx
+                while j < len(content) and content[j] in ' \t':
+                    j += 1
+                indent = j - start_idx
+
+                is_def = match.group(1).startswith("def")
+
+                while active_funcs and active_funcs[-1][0] >= indent:
+                    _, prev_name, prev_start = active_funcs.pop()
+                    func_lines = current_line - prev_start - 1
+                    if func_lines > max_func_lines:
+                        results.append((prev_name, func_lines, prev_start + 1))
+
+                if is_def:
+                    name = match.group(2)
+                    active_funcs.append((indent, name, current_line))
+
+            if active_funcs:
+                total_lines = current_line + content.count('\n', last_idx)
+                if content and not content.endswith('\n'):
+                    total_lines += 1
+
+                for _, name, start in active_funcs:
+                    func_lines = total_lines - start - 1
+                    if func_lines > max_func_lines:
+                        results.append((name, func_lines, start + 1))
+
+        return results
+
+    def _compute_health(self, counts: dict) -> str:
+        """Compute overall health score."""
+        if counts["critical"] > 5:
+            return "Critical"
+        elif counts["critical"] > 0 or counts["warning"] > 10:
+            return "Needs Attention"
+        elif counts["warning"] > 3:
+            return "Fair"
+        return "Healthy"