luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/analytics/smells.py

@@ -0,0 +1,316 @@
+"""Code smell detector — identifies common anti-patterns and quality issues."""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .scanner import ProjectMetrics, PYTHON_EXTENSIONS
+
+
+# ── Smell type definitions ───────────────────────────────────────────────────
+
+
+@dataclass
+class Smell:
+    """A detected code smell."""
+
+    file: str
+    line: int
+    kind: str  # e.g. "long_function", "deep_nesting", "large_file"
+    severity: str  # "info", "warning", "error"
+    message: str
+    suggestion: str = ""
+
+
+# ── Individual detectors ─────────────────────────────────────────────────────
+
+
+class SmellDetector:
+    """Detect code smells in files and projects."""
+
+    # Thresholds
+    LONG_FUNCTION_LINES = 50
+    LONG_FILE_LINES = 500
+    DEEP_NESTING = 4
+    HIGH_COMPLEXITY = 15
+    MANY_PARAMS = 6
+    FILE_SIZE_MB_WARNING = 0.5
+    DUPLICATION_MIN_LINES = 5
+    BIG_CLASS_LINES = 300
+
+    def __init__(self):
+        self.smells: list[Smell] = []
+
+    def detect_file(self, file_path: str, content: str | None = None) -> list[Smell]:
+        """Detect smells in a single file."""
+        self.smells = []
+        fp = Path(file_path)
+
+        if content is None:
+            try:
+                content = fp.read_text(encoding="utf-8", errors="replace")
+            except (OSError, UnicodeDecodeError):
+                return []
+
+        lines = content.splitlines()
+
+        # Large file
+        if len(lines) > self.LONG_FILE_LINES:
+            self.smells.append(Smell(
+                file=str(fp), line=len(lines),
+                kind="large_file", severity="warning",
+                message=f"File is {len(lines)} lines (threshold: {self.LONG_FILE_LINES})",
+                suggestion="Consider splitting into smaller modules.",
+            ))
+
+        # Very large file
+        if len(lines) > self.LONG_FILE_LINES * 2:
+            self.smells.append(Smell(
+                file=str(fp), line=len(lines),
+                kind="large_file", severity="error",
+                message=f"File is {len(lines)} lines — extremely large",
+                suggestion="Split into multiple files immediately.",
+            ))
+
+        # Detect long functions (Python-specific)
+        if fp.suffix.lower() in PYTHON_EXTENSIONS:
+            self._detect_python_smells(content, fp, lines)
+        else:
+            self._detect_generic_smells(content, fp, lines)
+
+        # Detect deep nesting
+        self._detect_deep_nesting(content, fp, lines)
+
+        # Check file size
+        try:
+            size_mb = fp.stat().st_size / (1024 * 1024)
+            if size_mb > self.FILE_SIZE_MB_WARNING:
+                self.smells.append(Smell(
+                    file=str(fp), line=1,
+                    kind="large_file_bytes", severity="warning",
+                    message=f"File size is {size_mb:.1f}MB",
+                    suggestion="Consider splitting or compressing assets.",
+                ))
+        except OSError:
+            pass
+
+        return self.smells
+
+    def _detect_python_smells(self, content: str, fp: Path, lines: list[str]):
+        """Python-specific smell detection."""
+        import ast
+
+        try:
+            tree = ast.parse(content, filename=str(fp))
+        except SyntaxError:
+            self.smells.append(Smell(
+                file=str(fp), line=1,
+                kind="syntax_error", severity="error",
+                message="File has a syntax error and cannot be parsed.",
+                suggestion="Fix the syntax error.",
+            ))
+            return
+
+        for node in ast.walk(tree):
+            # Long functions
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                func_lines = node.end_lineno - node.lineno if node.end_lineno else 0
+                if func_lines > self.LONG_FUNCTION_LINES:
+                    self.smells.append(Smell(
+                        file=str(fp), line=node.lineno,
+                        kind="long_function", severity="warning",
+                        message=f"'{node.name}' is {func_lines} lines long",
+                        suggestion=f"Break into smaller functions (<={self.LONG_FUNCTION_LINES} lines).",
+                    ))
+
+                # Many parameters
+                params = len(node.args.args)
+                if params > self.MANY_PARAMS:
+                    self.smells.append(Smell(
+                        file=str(fp), line=node.lineno,
+                        kind="too_many_params", severity="warning",
+                        message=f"'{node.name}' has {params} parameters",
+                        suggestion="Use a config object/dataclass or split the function.",
+                    ))
+
+            # Large classes
+            if isinstance(node, ast.ClassDef):
+                class_lines = node.end_lineno - node.lineno if node.end_lineno else 0
+                if class_lines > self.BIG_CLASS_LINES:
+                    self.smells.append(Smell(
+                        file=str(fp), line=node.lineno,
+                        kind="large_class", severity="warning",
+                        message=f"'{node.name}' is {class_lines} lines",
+                        suggestion="Split into smaller classes or use composition.",
+                    ))
+
+            # Bare except
+            if isinstance(node, ast.ExceptHandler):
+                if node.type is None:
+                    self.smells.append(Smell(
+                        file=str(fp), line=node.lineno,
+                        kind="bare_except", severity="warning",
+                        message="Bare 'except:' clause catches everything including SystemExit",
+                        suggestion="Specify exception types: 'except ValueError:'",
+                    ))
+
+            # Mutable default arguments
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                for default in node.args.defaults + node.args.kw_defaults:
+                    if isinstance(default, (ast.List, ast.Dict, ast.Set)):
+                        self.smells.append(Smell(
+                            file=str(fp), line=node.lineno,
+                            kind="mutable_default", severity="warning",
+                            message=(
+                                f"Mutable default argument in '{node.name}()' "
+                                f"({default.__class__.__name__.lower()})"
+                            ),
+                            suggestion="Use None as default and set the mutable value in the function body.",
+                        ))
+
+    def _detect_generic_smells(self, content: str, fp: Path, lines: list[str]):
+        """Generic smell detection for any language."""
+
+        # Long function detection via indentation heuristics
+        in_func = False
+        func_start = 0
+
+        # Function keyword regex
+        func_start_re = re.compile(
+            r"^\s*(?:def |async def |fn |func |function |pub fn )",
+        )
+
+        bare_except_re = re.compile(r"^\s*except\s*:", re.MULTILINE)
+        catch_all_re = re.compile(r"catch\s*\(", re.MULTILINE)
+
+        for i, line in enumerate(lines):
+            m = func_start_re.match(line)
+            if m:
+                # End previous function
+                if in_func and (i - func_start) > self.LONG_FUNCTION_LINES:
+                    self.smells.append(Smell(
+                        file=str(fp), line=func_start + 1,
+                        kind="long_function", severity="warning",
+                        message=f"Function is {i - func_start} lines long",
+                        suggestion=f"Break into smaller functions (<={self.LONG_FUNCTION_LINES} lines).",
+                    ))
+                in_func = True
+                func_start = i
+
+        # Check last function
+        if in_func and (len(lines) - func_start) > self.LONG_FUNCTION_LINES:
+            self.smells.append(Smell(
+                file=str(fp), line=func_start + 1,
+                kind="long_function", severity="warning",
+                message=f"Function is {len(lines) - func_start} lines long",
+                suggestion=f"Break into smaller functions (<={self.LONG_FUNCTION_LINES} lines).",
+            ))
+
+        # Bare except / catch-all
+        if bare_except_re.search(content):
+            self.smells.append(Smell(
+                file=str(fp), line=1,
+                kind="bare_except", severity="warning",
+                message="Bare 'except:' found (catches everything)",
+                suggestion="Specify exception types.",
+            ))
+        elif catch_all_re.search(content):
+            self.smells.append(Smell(
+                file=str(fp), line=1,
+                kind="bare_except", severity="warning",
+                message="Catch-all 'catch(' found (catches every exception)",
+                suggestion="Catch specific exception types.",
+            ))
+
+    def _detect_deep_nesting(self, content: str, fp: Path, lines: list[str]):
+        """Detect lines with deep indentation."""
+        for i, line in enumerate(lines):
+            if not line.strip():
+                continue
+            indent = len(line) - len(line.lstrip())
+            # Assume 4-space indentation
+            nesting_level = indent // 4
+            if nesting_level > self.DEEP_NESTING:
+                self.smells.append(Smell(
+                    file=str(fp), line=i + 1,
+                    kind="deep_nesting", severity="info",
+                    message=f"Nesting level {nesting_level} (>{self.DEEP_NESTING})",
+                    suggestion="Consider extracting nested logic or using early returns.",
+                ))
+                # Only report first few occurrences per file
+                if len([s for s in self.smells if s.kind == "deep_nesting" and s.file == str(fp)]) >= 3:
+                    break
+
+    def detect_project(self, pm: ProjectMetrics) -> list[Smell]:
+        """Detect smells across an entire project's metrics."""
+        smells = []
+
+        # Files with high complexity
+        for path, complexity in pm.complexity_breakdown.items():
+            if complexity > self.HIGH_COMPLEXITY:
+                smells.append(Smell(
+                    file=path, line=1,
+                    kind="high_complexity", severity="warning",
+                    message=f"Cyclomatic complexity is {complexity}",
+                    suggestion="Refactor to reduce branching and nesting.",
+                ))
+
+        # Files with high TODO density
+        for fm in pm.file_metrics:
+            if fm.lines_code > 0:
+                todo_density = fm.todo_count / (fm.lines_code / 100)
+                if todo_density > 10:
+                    smells.append(Smell(
+                        file=fm.path, line=1,
+                        kind="high_todo_density", severity="info",
+                        message=f"{fm.todo_count} TODOs in {fm.lines_code} lines",
+                        suggestion="Address or triage outstanding TODOs.",
+                    ))
+
+        # Empty files
+        for fm in pm.file_metrics:
+            if fm.lines_code == 0 and fm.lines_total > 0:
+                smells.append(Smell(
+                    file=fm.path, line=1,
+                    kind="empty_file", severity="info",
+                    message="File has no code lines",
+                    suggestion="Remove empty files or add content.",
+                ))
+
+        # Large files (project-level)
+        for fm in pm.file_metrics:
+            if fm.lines_total > self.LONG_FILE_LINES:
+                smells.append(Smell(
+                    file=fm.path, line=fm.lines_total,
+                    kind="large_file", severity="warning",
+                    message=f"File is {fm.lines_total} lines (threshold: {self.LONG_FILE_LINES})",
+                    suggestion="Consider splitting into smaller modules.",
+                ))
+
+        return smells + self.smells
+
+
+# ── Convenience ──────────────────────────────────────────────────────────────
+
+
+def detect_smells(path: str | None = None) -> list[Smell]:
+    """Convenience: detect smells in a file or project."""
+    detector = SmellDetector()
+
+    if path is None:
+        # Scan whole project
+        from .scanner import scan_project
+        pm = scan_project()
+        return detector.detect_project(pm)
+
+    fp = Path(path)
+    if fp.is_file():
+        return detector.detect_file(str(fp))
+
+    if fp.is_dir():
+        from .scanner import CodebaseScanner
+        scanner = CodebaseScanner(str(fp))
+        pm = scanner.scan()
+        return detector.detect_project(pm)
+
+    return []

luckyd_code/analytics/trends.py

@@ -0,0 +1,303 @@
+"""Trend tracking — snapshot project metrics over time and analyze changes."""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .scanner import ProjectMetrics, scan_project
+
+
+from .._data_dir import project_data_path
+
+
+def _get_db_path() -> Path:
+    """Get path to the analytics database file."""
+    p = project_data_path("analytics.json")
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+@dataclass
+class TrendPoint:
+    """A single snapshot in the trend history."""
+
+    timestamp: float
+    source_files: int
+    total_lines: int
+    total_code_lines: int
+    total_todos: int
+    total_fixmes: int
+    total_functions: int
+    total_classes: int
+    avg_complexity: float
+    health_score: float
+    total_size_bytes: int
+    languages: dict[str, int]
+
+    @classmethod
+    def from_metrics(cls, pm: ProjectMetrics) -> "TrendPoint":
+        return cls(
+            timestamp=pm.scanned_at,
+            source_files=pm.source_files,
+            total_lines=pm.total_lines,
+            total_code_lines=pm.total_code_lines,
+            total_todos=pm.total_todos,
+            total_fixmes=pm.total_fixmes,
+            total_functions=pm.total_functions,
+            total_classes=pm.total_classes,
+            avg_complexity=pm.avg_complexity,
+            health_score=pm.health_score,
+            total_size_bytes=pm.total_size_bytes,
+            languages=dict(pm.files_by_language),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "source_files": self.source_files,
+            "total_lines": self.total_lines,
+            "total_code_lines": self.total_code_lines,
+            "total_todos": self.total_todos,
+            "total_fixmes": self.total_fixmes,
+            "total_functions": self.total_functions,
+            "total_classes": self.total_classes,
+            "avg_complexity": self.avg_complexity,
+            "health_score": self.health_score,
+            "total_size_bytes": self.total_size_bytes,
+            "languages": self.languages,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "TrendPoint":
+        return cls(
+            timestamp=d["timestamp"],
+            source_files=d["source_files"],
+            total_lines=d["total_lines"],
+            total_code_lines=d["total_code_lines"],
+            total_todos=d["total_todos"],
+            total_fixmes=d["total_fixmes"],
+            total_functions=d["total_functions"],
+            total_classes=d["total_classes"],
+            avg_complexity=d["avg_complexity"],
+            health_score=d["health_score"],
+            total_size_bytes=d["total_size_bytes"],
+            languages=d.get("languages", {}),
+        )
+
+
+@dataclass
+class TrendReport:
+    """Analysis of changes between two snapshots."""
+
+    points: list[TrendPoint] = field(default_factory=list)
+    delta_files: int = 0
+    delta_lines: int = 0
+    delta_todos: int = 0
+    delta_fixmes: int = 0
+    delta_health: float = 0.0
+    delta_complexity: float = 0.0
+    direction: str = ""  # "improving", "declining", "stable"
+    summary: str = ""
+
+
+class TrendTracker:
+    """Track project metrics over time with snapshots."""
+
+    def __init__(self):
+        self.db_path = _get_db_path()
+        self._points: list[TrendPoint] | None = None
+
+    def load(self) -> list[TrendPoint]:
+        """Load all snapshots from disk."""
+        if self._points is not None:
+            return self._points
+
+        if self.db_path.exists():
+            try:
+                data = json.loads(self.db_path.read_text())
+                self._points = [TrendPoint.from_dict(p) for p in data.get("snapshots", [])]
+            except (json.JSONDecodeError, KeyError):
+                self._points = []
+        else:
+            self._points = []
+
+        return self._points
+
+    def save(self, points: list[TrendPoint] | None = None):
+        """Save snapshots to disk."""
+        if points is not None:
+            self._points = points
+
+        if self._points is None:
+            self._points = []
+
+        data = {
+            "snapshots": [p.to_dict() for p in self._points],
+            "updated_at": time.time(),
+        }
+        self.db_path.write_text(json.dumps(data, indent=2))
+
+    def snapshot(self) -> TrendPoint:
+        """Take a snapshot of the current project state."""
+        pm = scan_project()
+        point = TrendPoint.from_metrics(pm)
+
+        # Load existing
+        points = self.load()
+        points.append(point)
+        self.save(points)
+
+        return point
+
+    def get_all(self) -> list[TrendPoint]:
+        """Get all snapshots sorted by time."""
+        return sorted(self.load(), key=lambda p: p.timestamp)
+
+    def get_latest(self) -> TrendPoint | None:
+        """Get the most recent snapshot."""
+        points = self.get_all()
+        if points:
+            return points[-1]
+        return None
+
+    def compare(self, index_a: int = -2, index_b: int = -1) -> TrendReport:
+        """Compare two snapshots by index (default: last two)."""
+        points = self.get_all()
+
+        if len(points) < 2:
+            return TrendReport(
+                points=points,
+                direction="stable",
+                summary="Not enough data for comparison (need at least 2 snapshots).",
+            )
+
+        a = points[index_a]
+        b = points[index_b]
+
+        report = TrendReport(
+            points=[a, b],
+            delta_files=b.source_files - a.source_files,
+            delta_lines=b.total_code_lines - a.total_code_lines,
+            delta_todos=b.total_todos - a.total_todos,
+            delta_fixmes=b.total_fixmes - a.total_fixmes,
+            delta_health=b.health_score - a.health_score,
+            delta_complexity=b.avg_complexity - a.avg_complexity,
+        )
+
+        # Determine direction
+        improvements = []
+        declines = []
+
+        if report.delta_todos < 0:
+            improvements.append(f"TODOs decreased by {abs(report.delta_todos)}")
+        elif report.delta_todos > 0:
+            declines.append(f"TODOs increased by {report.delta_todos}")
+
+        if report.delta_fixmes < 0:
+            improvements.append(f"FIXMEs decreased by {abs(report.delta_fixmes)}")
+        elif report.delta_fixmes > 0:
+            declines.append(f"FIXMEs increased by {report.delta_fixmes}")
+
+        if report.delta_complexity < -0.5:
+            improvements.append(f"Avg complexity decreased ({report.delta_complexity:.1f})")
+        elif report.delta_complexity > 0.5:
+            declines.append(f"Avg complexity increased (+{report.delta_complexity:.1f})")
+
+        if report.delta_health > 1:
+            improvements.append(f"Health score improved (+{report.delta_health:.1f})")
+        elif report.delta_health < -1:
+            declines.append(f"Health score declined ({report.delta_health:.1f})")
+
+        if report.delta_lines > 0:
+            improvements.append(f"Codebase grew by {report.delta_lines:} lines")
+
+        if not improvements and not declines:
+            report.direction = "stable"
+            report.summary = "No significant changes detected."
+        elif len(improvements) >= len(declines):
+            report.direction = "improving"
+            report.summary = "Improvements: " + "; ".join(improvements)
+            if declines:
+                report.summary += " | Concerns: " + "; ".join(declines)
+        else:
+            report.direction = "declining"
+            report.summary = "Concerns: " + "; ".join(declines)
+            if improvements:
+                report.summary += " | Improvements: " + "; ".join(improvements)
+
+        return report
+
+    def trend_summary(self) -> str:
+        """Generate a human-readable trend summary."""
+        points = self.get_all()
+        if len(points) < 2:
+            return "Not enough data for trends (take at least 2 snapshots)."
+
+        first = points[0]
+        last = points[-1]
+
+        days_span = (last.timestamp - first.timestamp) / 86400
+
+        lines = []
+        lines.append("=== Project Trends ===")
+        lines.append(f"Snapshots: {len(points)} over {days_span:.1f} days")
+        lines.append("")
+
+        # File count
+        delta_files = last.source_files - first.source_files
+        lines.append(f"Source files: {first.source_files} -> {last.source_files} ({delta_files:+d})")
+
+        # Lines
+        delta_lines = last.total_code_lines - first.total_code_lines
+        lines.append(f"Code lines:   {first.total_code_lines:} -> {last.total_code_lines:} ({delta_lines:+})")
+
+        # TODOs
+        delta_todos = last.total_todos - first.total_todos
+        lines.append(f"TODOs:        {first.total_todos} -> {last.total_todos} ({delta_todos:+d})")
+
+        # FIXMEs
+        delta_fixmes = last.total_fixmes - first.total_fixmes
+        lines.append(f"FIXMEs:       {first.total_fixmes} -> {last.total_fixmes} ({delta_fixmes:+d})")
+
+        # Health
+        delta_health = last.health_score - first.health_score
+        direction = "improving" if delta_health > 0 else "declining"
+        lines.append(f"Health:       {first.health_score:.1f} -> {last.health_score:.1f} ({delta_health:+.1f}, {direction})")
+
+        # Complexity
+        delta_comp = last.avg_complexity - first.avg_complexity
+        lines.append(f"Avg complexity: {first.avg_complexity:.1f} -> {last.avg_complexity:.1f} ({delta_comp:+.1f})")
+
+        # Languages
+        all_langs = set(list(first.languages.keys()) + list(last.languages.keys()))
+        added = [l for l in all_langs if l not in first.languages]
+        removed = [l for l in all_langs if l not in last.languages]
+        if added:
+            lines.append(f"Languages added: {', '.join(added)}")
+        if removed:
+            lines.append(f"Languages removed: {', '.join(removed)}")
+
+        return "\n".join(lines)
+
+    def clear(self):
+        """Delete all snapshots."""
+        self._points = []
+        if self.db_path.exists():
+            self.db_path.unlink()
+
+
+# ── Convenience functions ───────────────────────────────────────────────────
+
+
+def snapshot_project() -> TrendPoint:
+    """Take a snapshot of the current project."""
+    tracker = TrendTracker()
+    return tracker.snapshot()
+
+
+def get_trends() -> str:
+    """Get a trend summary of the current project."""
+    tracker = TrendTracker()
+    return tracker.trend_summary()