luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/agent.py

@@ -0,0 +1,38 @@
+"""Sub-agent support — spawn child agents for parallel work."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .config import Config
+from .context import ConversationContext
+from .tools import get_default_registry
+from ._agent_loop import run_agent_loop
+
+__all__ = ["SubAgent"]
+
+
+class SubAgent:
+    """A lightweight agent that runs independently with its own context."""
+
+    def __init__(self, config: Config, task: str,
+                 tools: Optional[List[Dict[str, Any]]] = None):
+        self.config = config
+        self.task = task
+        self.tools = tools
+        self.context = ConversationContext(
+            config.system_prompt,
+            max_messages=20,
+        )
+        self.registry = get_default_registry()
+
+    def run(self) -> str:
+        """Run the sub-agent synchronously and return its final response."""
+        self.context.add_user_message(self.task)
+        return run_agent_loop(
+            context=self.context,
+            config=self.config,
+            tools=self.tools or self.registry.list_tools(),
+            registry=self.registry,
+            label="sub-agent",
+        )

luckyd_code/analytics/__init__.py

@@ -0,0 +1,18 @@
+"""Codebase Health & Analytics - scan, measure, report, and track code quality."""
+
+from .scanner import CodebaseScanner, scan_project
+from .reporter import ReportGenerator, generate_report
+from .trends import TrendTracker, snapshot_project, get_trends
+from .smells import SmellDetector, detect_smells
+
+__all__ = [
+    "CodebaseScanner",
+    "scan_project",
+    "ReportGenerator",
+    "generate_report",
+    "TrendTracker",
+    "snapshot_project",
+    "get_trends",
+    "SmellDetector",
+    "detect_smells",
+]

luckyd_code/analytics/reporter.py

@@ -0,0 +1,195 @@
+"""Report generation for codebase analytics."""
+
+import json
+import time
+from dataclasses import asdict
+from pathlib import Path
+
+
+
+def _format_size(b):
+    for u in ["B", "KB", "MB", "GB"]:
+        if b < 1024:
+            return f"{b:.1f} {u}"
+        b /= 1024
+    return f"{b:.1f} TB"
+
+
+class ReportGenerator:
+    """Generate reports in multiple formats from scan results."""
+
+    def __init__(self, pm, smells=None):
+        self.pm = pm
+        self.smells = smells or []
+
+    def terminal(self):
+        pm = self.pm
+        l = []
+        l.append("")
+        l.append("=== CODEBASE HEALTH REPORT ===")
+        l.append(f"Project: {pm.root}")
+        l.append(f"Health Score: {pm.health_score}/100")
+        l.append("")
+        l.append("-- Summary --")
+        l.append(f"Source files:     {pm.source_files}")
+        l.append(f"Total lines:      {pm.total_lines:}")
+        l.append(f"Code lines:       {pm.total_code_lines:}")
+        l.append(f"Total size:       {_format_size(pm.total_size_bytes)}")
+        l.append(f"Functions:        {pm.total_functions}")
+        l.append(f"Classes:          {pm.total_classes}")
+        l.append(f"TODOs:            {pm.total_todos}")
+        l.append(f"FIXMEs:           {pm.total_fixmes}")
+        l.append(f"Avg complexity:   {pm.avg_complexity:.1f}")
+
+        if pm.files_by_language:
+            l.append("")
+            l.append("-- Languages --")
+            for lang, count in sorted(pm.files_by_language.items(), key=lambda x: -x[1]):
+                l.append(f"  {lang:<12} {count:>4} files")
+
+        top = sorted(pm.complexity_breakdown.items(), key=lambda x: -x[1])[:10]
+        if top:
+            l.append("")
+            l.append("-- Top Complexity --")
+            for fp, c in top:
+                l.append(f"  {c:>4}  {fp}")
+
+        if pm.todos:
+            l.append("")
+            l.append(f"-- TODOs & FIXMEs ({len(pm.todos)}) --")
+            for t in pm.todos[:20]:
+                l.append(f"  [{t['kind']}] {t['file']}:{t['line']}  {t['text'][:80]}")
+
+        if self.smells:
+            l.append("")
+            l.append(f"-- Code Smells ({len(self.smells)}) --")
+            for s in self.smells[:30]:
+                l.append(f"  [{s.severity}] {s.kind}: {s.file}:{s.line}")
+                if s.message:
+                    l.append(f"    {s.message}")
+                if s.suggestion:
+                    l.append(f"    -> {s.suggestion}")
+
+        # Files needing attention
+        issues = []
+        for fm in pm.file_metrics:
+            score = 0
+            if fm.lines_code > 300:
+                score += 1
+            if fm.complexity > 20:
+                score += 2
+            if fm.todo_count > 5:
+                score += 1
+            if fm.fixme_count > 2:
+                score += 2
+            if score > 0:
+                issues.append((fm, score))
+
+        if issues:
+            issues.sort(key=lambda x: -x[1])
+            l.append("")
+            l.append("-- Files Needing Attention --")
+            for fm, score in issues[:10]:
+                l.append(
+                    f"  {fm.path}  "
+                    f"(lines={fm.lines_code}, complexity={fm.complexity}, "
+                    f"todos={fm.todo_count}, fixmes={fm.fixme_count})"
+                )
+
+        l.append("")
+        return "\n".join(l)
+
+    def markdown(self):
+        pm = self.pm
+        m = []
+        m.append("# Codebase Health Report\n")
+        m.append(f"**Project:** `{pm.root}`  ")
+        m.append(f"**Health Score: {pm.health_score}/100**\n")
+
+        m.append("## Summary\n")
+        m.append("| Metric | Value |")
+        m.append("|--------|-------|")
+        m.append(f"| Source files | {pm.source_files} |")
+        m.append(f"| Total lines | {pm.total_lines:} |")
+        m.append(f"| Code lines | {pm.total_code_lines:} |")
+        m.append(f"| Total size | {_format_size(pm.total_size_bytes)} |")
+        m.append(f"| Functions | {pm.total_functions} |")
+        m.append(f"| Classes | {pm.total_classes} |")
+        m.append(f"| Avg complexity | {pm.avg_complexity:.1f} |")
+        m.append(f"| TODOs | {pm.total_todos} |")
+        m.append(f"| FIXMEs | {pm.total_fixmes} |")
+        m.append("")
+
+        if pm.files_by_language:
+            m.append("## Languages\n")
+            for lang, cnt in sorted(pm.files_by_language.items(), key=lambda x: -x[1]):
+                m.append(f"- **{lang}**: {cnt} files")
+            m.append("")
+
+        top = sorted(pm.complexity_breakdown.items(), key=lambda x: -x[1])[:10]
+        if top:
+            m.append("## Top Complexity\n")
+            for fp, c in top:
+                m.append(f"- `{fp}`: {c}")
+            m.append("")
+
+        if pm.todos:
+            m.append(f"## TODOs & FIXMEs ({len(pm.todos)})\n")
+            m.append("| Kind | File | Line | Description |")
+            m.append("|------|------|------|-------------|")
+            for t in pm.todos[:30]:
+                m.append(f"| {t['kind']} | `{t['file']}` | {t['line']} | {t['text'][:100]} |")
+            m.append("")
+
+        if self.smells:
+            m.append(f"## Code Smells ({len(self.smells)})\n")
+            for s in self.smells[:30]:
+                m.append(f"- **{s.kind}** `{s.file}:{s.line}` ({s.severity}): {s.message}")
+
+        m.append("\n---\n*Report generated by DeepSeek Code Analytics*")
+        return "\n".join(m)
+
+    def json_report(self):
+        return json.dumps({
+            "project": self.pm.to_dict(),
+            "smells": [asdict(s) for s in self.smells],
+            "generated_at": time.time(),
+        }, indent=2)
+
+    def html(self):
+        md = self.markdown()
+        return (
+            "<!DOCTYPE html><html><head><meta charset=UTF-8>"
+            "<title>Health Report</title>"
+            "<style>body{font-family:sans-serif;max-width:900px;margin:auto;padding:2rem}"
+            "table{border-collapse:collapse;width:100%}"
+            "th,td{border:1px solid #ddd;padding:8px;text-align:left}"
+            "th{background:#f5f5f5}code{background:#f0f0f0;padding:2px 6px}</style>"
+            "</head><body><pre>" + md + "</pre></body></html>"
+        )
+
+
+def generate_report(pm=None, smells=None, fmt="terminal", output_path=None):
+    """Generate a report from metrics. Scans if none provided."""
+    if pm is None:
+        from .scanner import scan_project
+        pm = scan_project()
+
+    if smells is None:
+        smells = []
+
+    gen = ReportGenerator(pm, smells)
+    report = gen.terminal()
+
+    if fmt == "markdown":
+        report = gen.markdown()
+    elif fmt == "json":
+        report = gen.json_report()
+    elif fmt == "html":
+        report = gen.html()
+
+    if output_path:
+        Path(output_path).write_text(report, encoding="utf-8")
+        return f"Report written to {output_path}"
+
+    return report

luckyd_code/analytics/scanner.py

@@ -0,0 +1,443 @@
+"""Codebase scanner — collects metrics across an entire project tree."""
+
+import ast
+import os
+import re
+import time
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import Any
+
+from ..log import get_logger
+
+logger = get_logger()
+
+# ── Constants ────────────────────────────────────────────────────────────────
+
+SKIP_DIRS = {
+    ".git", "__pycache__", "node_modules", ".venv", "venv", "env",
+    ".tox", ".eggs", "dist", "build", ".next", ".nuxt", "target",
+    "vendor", ".bundle", ".claude", ".deepseek-code", ".vscode", ".idea",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache", ".svn", ".hg",
+    "egg-info", ".pixi",
+}
+
+PYTHON_EXTENSIONS = {".py", ".pyw", ".pyi"}
+JS_EXTENSIONS = {".js", ".jsx", ".mjs", ".cjs"}
+TS_EXTENSIONS = {".ts", ".tsx", ".mts", ".cts"}
+GO_EXTENSIONS = {".go"}
+RUST_EXTENSIONS = {".rs"}
+KNOWN_EXTENSIONS = PYTHON_EXTENSIONS | JS_EXTENSIONS | TS_EXTENSIONS | GO_EXTENSIONS | RUST_EXTENSIONS
+
+TODO_RE = re.compile(r"(?:TODO|FIXME|HACK|XXX|BUG|OPTIMIZE|NOTE)[\s:]*(.*?)(?:\n|$)", re.IGNORECASE)
+COMMENT_RE = re.compile(r"(#|//|/\*|<!--)\s*")
+FUNC_RE = re.compile(
+    r"^\s*(?:def |async def |fn |func |function |pub fn |pub async fn )",
+    re.MULTILINE,
+)
+CLASS_RE = re.compile(
+    r"^\s*(?:class |struct |impl |enum |interface |type )",
+    re.MULTILINE,
+)
+RETURN_RE = re.compile(r"\breturn\b")
+
+
+# ── Data classes ─────────────────────────────────────────────────────────────
+
+
+@dataclass
+class FileMetrics:
+    """Metrics for a single source file."""
+
+    path: str
+    language: str = ""
+    size_bytes: int = 0
+    lines_total: int = 0
+    lines_code: int = 0
+    lines_blank: int = 0
+    lines_comment: int = 0
+    todo_count: int = 0
+    fixme_count: int = 0
+    function_count: int = 0
+    class_count: int = 0
+    complexity: int = 0  # rough cyclomatic
+    max_indent: int = 0
+    imports_count: int = 0
+
+
+@dataclass
+class ProjectMetrics:
+    """Aggregate metrics for an entire project."""
+
+    root: str
+    scanned_at: float = field(default_factory=time.time)
+    total_files: int = 0
+    source_files: int = 0
+    total_lines: int = 0
+    total_code_lines: int = 0
+    total_todos: int = 0
+    total_fixmes: int = 0
+    total_functions: int = 0
+    total_classes: int = 0
+    total_complexity: int = 0
+    total_size_bytes: int = 0
+    file_metrics: list[FileMetrics] = field(default_factory=list)
+    todos: list[dict[str, Any]] = field(default_factory=list)
+    files_by_language: dict[str, int] = field(default_factory=dict)
+    complexity_breakdown: dict[str, int] = field(default_factory=dict)
+    smells: list[dict[str, Any]] = field(default_factory=list)
+
+    @property
+    def avg_complexity(self) -> float:
+        if self.total_functions == 0:
+            return 0.0
+        return self.total_complexity / self.total_functions
+
+    @property
+    def todo_rate(self) -> float:
+        if self.total_code_lines == 0:
+            return 0.0
+        return self.total_todos / (self.total_code_lines / 1000)
+
+    @property
+    def health_score(self) -> float:
+        """Heuristic health score from 0 (worst) to 100 (best)."""
+        score = 100.0
+        # Penalize high TODO rates
+        score -= min(15, self.todo_rate * 5)
+        # Penalize high complexity
+        score -= min(15, max(0, self.avg_complexity - 5) * 2)
+        # Penalize large files
+        if self.source_files > 0:
+            avg_lines = self.total_lines / self.source_files
+            score -= min(10, max(0, (avg_lines - 300) / 50))
+        # Penalize very large codebases with no organization
+        if self.source_files > 100 and len(self.files_by_language) < 2:
+            score -= 5
+        return max(0, round(score, 1))
+
+    def to_dict(self) -> dict[str, Any]:
+        d = asdict(self)
+        d["avg_complexity"] = self.avg_complexity
+        d["todo_rate"] = self.todo_rate
+        d["health_score"] = self.health_score
+        return d
+
+
+# ── Scanner helpers ──────────────────────────────────────────────────────────
+
+
+def _detect_language(file_path: Path) -> str:
+    suffix = file_path.suffix.lower()
+    if suffix in PYTHON_EXTENSIONS:
+        return "python"
+    if suffix in JS_EXTENSIONS:
+        return "javascript"
+    if suffix in TS_EXTENSIONS:
+        return "typescript"
+    if suffix in GO_EXTENSIONS:
+        return "go"
+    if suffix in RUST_EXTENSIONS:
+        return "rust"
+    if suffix in {".c", ".h"}:
+        return "c"
+    if suffix in {".cpp", ".cc", ".cxx", ".hpp", ".hxx"}:
+        return "c++"
+    if suffix in {".java"}:
+        return "java"
+    if suffix in {".rb"}:
+        return "ruby"
+    if suffix in {".php"}:
+        return "php"
+    if suffix in {".swift"}:
+        return "swift"
+    if suffix in {".kt", ".kts"}:
+        return "kotlin"
+    if suffix in {".sh", ".bash", ".zsh"}:
+        return "shell"
+    if suffix in {".md", ".mdx"}:
+        return "markdown"
+    if suffix in {".json"}:
+        return "json"
+    if suffix in {".yaml", ".yml"}:
+        return "yaml"
+    if suffix in {".toml"}:
+        return "toml"
+    if suffix in {".cfg", ".ini"}:
+        return "config"
+    return "unknown"
+
+
+def _count_lines(content: str) -> tuple[int, int, int]:
+    """Count total, code, and blank lines."""
+    total = 0
+    blank = 0
+    for line in content.splitlines():
+        total += 1
+        stripped = line.strip()
+        if not stripped:
+            blank += 1
+    code = total - blank
+    return total, code, blank
+
+
+def _count_comment_lines(content: str, language: str) -> int:
+    """Rough count of comment lines."""
+    count = 0
+    in_block = False
+    for line in content.splitlines():
+        stripped = line.strip()
+        if language in ("python", "ruby", "shell", "yaml", "toml", "config"):
+            if stripped.startswith("#"):
+                count += 1
+        elif language in ("javascript", "typescript", "go", "rust", "c", "c++",
+                          "java", "kotlin", "swift", "php"):
+            if in_block:
+                count += 1
+                if "*/" in stripped:
+                    in_block = False
+                continue
+            if stripped.startswith("//"):
+                count += 1
+            elif stripped.startswith("/*"):
+                count += 1
+                if "*/" not in stripped:
+                    in_block = True
+    return count
+
+
+def _python_complexity(tree: ast.AST) -> int:
+    """Cyclomatic complexity for Python via AST."""
+    complexity = 1  # base path
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.If, ast.While, ast.For, ast.AsyncFor,
+                              ast.ExceptHandler, ast.With, ast.AsyncWith,
+                              ast.Assert)):
+            complexity += 1
+        elif isinstance(node, ast.BoolOp):
+            complexity += len(node.values) - 1
+        elif isinstance(node, ast.Match):
+            complexity += 1  # each case adds at walk level
+        elif isinstance(node, ast.match_case):
+            complexity += 1
+    return complexity
+
+
+def _generic_complexity(content: str) -> int:
+    """Regex-based complexity approximation for non-Python languages."""
+    complexity = 1
+    for pattern in [
+        r"\bif\b", r"\belse if\b", r"\bwhile\b", r"\bfor\b",
+        r"\bcatch\b", r"\bexcept\b", r"\bmatch\b", r"\bswitch\b",
+        r"\bcase\b", r"\b&&\b", r"\b\|\|\b", r"\?\s*[^?:]",
+    ]:
+        complexity += len(re.findall(pattern, content, re.IGNORECASE))
+    return complexity
+
+
+def _max_indent(content: str) -> int:
+    """Find the maximum indentation level."""
+    max_indent = 0
+    for line in content.splitlines():
+        if line.strip():
+            indent = len(line) - len(line.lstrip())
+            max_indent = max(max_indent, indent)
+    return max_indent
+
+
+def _scan_python(path: Path, content: str) -> FileMetrics:
+    """Deep scan of a Python file."""
+    fm = FileMetrics(path=str(path), language="python")
+
+    # AST analysis
+    try:
+        tree = ast.parse(content, filename=str(path))
+    except SyntaxError:
+        tree = None
+
+    # Line counts
+    total, code, blank = _count_lines(content)
+    fm.lines_total = total
+    fm.lines_code = code
+    fm.lines_blank = blank
+    fm.lines_comment = _count_comment_lines(content, "python")
+
+    # Max indent
+    fm.max_indent = _max_indent(content)
+
+    # Functions and classes
+    if tree is not None:
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                fm.function_count += 1
+            elif isinstance(node, ast.ClassDef):
+                fm.class_count += 1
+            elif isinstance(node, (ast.Import, ast.ImportFrom)):
+                fm.imports_count += 1
+
+        fm.complexity = _python_complexity(tree)
+    else:
+        # Fallback regex counts
+        fm.function_count = len(FUNC_RE.findall(content))
+        fm.class_count = len(CLASS_RE.findall(content))
+        fm.complexity = _generic_complexity(content)
+
+    return fm
+
+
+def _scan_generic(path: Path, content: str) -> FileMetrics:
+    """Scan a non-Python source file with regex-based metrics."""
+    language = _detect_language(path)
+    fm = FileMetrics(path=str(path), language=language)
+
+    total, code, blank = _count_lines(content)
+    fm.lines_total = total
+    fm.lines_code = code
+    fm.lines_blank = blank
+    fm.lines_comment = _count_comment_lines(content, language)
+
+    fm.max_indent = _max_indent(content)
+    fm.function_count = len(FUNC_RE.findall(content))
+    fm.class_count = len(CLASS_RE.findall(content))
+    fm.complexity = _generic_complexity(content)
+    fm.imports_count = len(re.findall(r"^\s*(?:import|from|require|use|#include)\b",
+                                       content, re.MULTILINE))
+
+    return fm
+
+
+def _extract_todos(content: str, file_path: str) -> list[dict[str, Any]]:
+    """Extract TODO/FIXME items with context."""
+    items = []
+    lines = content.splitlines()
+    for i, line in enumerate(lines):
+        m = TODO_RE.search(line)
+        if m:
+            kind = m.group(0).split(":")[0].split()[0].upper().strip(":")
+            if kind in ("NOTE", "OPTIMIZE"):
+                continue  # less critical
+            items.append({
+                "file": file_path,
+                "line": i + 1,
+                "kind": kind,
+                "text": m.group(1).strip() if m.group(1) else "",
+                "context": line.strip()[:120],
+            })
+    return items
+
+
+def _should_skip_dir(dirname: str) -> bool:
+    return dirname in SKIP_DIRS or dirname.startswith(".")
+
+
+def _should_scan_file(file_path: Path) -> bool:
+    """Check if this file should be scanned."""
+    if file_path.suffix.lower() not in KNOWN_EXTENSIONS:
+        return False
+    # Skip very large files (>2MB)
+    try:
+        if file_path.stat().st_size > 2 * 1024 * 1024:
+            return False
+    except OSError:
+        return False
+    return True
+
+
+# ── Main scanner ─────────────────────────────────────────────────────────────
+
+
+class CodebaseScanner:
+    """Scan a directory tree and produce comprehensive metrics."""
+
+    def __init__(self, root: str | None = None):
+        self.root = Path(root) if root else Path.cwd()
+
+    def scan(self) -> ProjectMetrics:
+        """Run a full scan and return aggregated metrics."""
+        pm = ProjectMetrics(root=str(self.root))
+
+        for dirpath, dirnames, filenames in os.walk(self.root):
+            # Skip hidden / known dirs
+            dirnames[:] = [
+                d for d in dirnames
+                if not _should_skip_dir(d)
+            ]
+
+            for fname in sorted(filenames):
+                file_path = Path(dirpath) / fname
+                if not _should_scan_file(file_path):
+                    continue
+
+                try:
+                    content = file_path.read_text(encoding="utf-8", errors="replace")
+                except (OSError, UnicodeDecodeError):
+                    continue
+
+                language = _detect_language(file_path)
+
+                # Choose scan strategy
+                if language == "python":
+                    fm = _scan_python(file_path, content)
+                else:
+                    fm = _scan_generic(file_path, content)
+
+                fm.size_bytes = file_path.stat().st_size
+                fm.todo_count = len(re.findall(r"\bTODO\b", content, re.IGNORECASE))
+                fm.fixme_count = len(re.findall(r"\bFIXME\b", content, re.IGNORECASE))
+
+                pm.file_metrics.append(fm)
+                pm.source_files += 1
+                pm.total_lines += fm.lines_total
+                pm.total_code_lines += fm.lines_code
+                pm.total_todos += fm.todo_count
+                pm.total_fixmes += fm.fixme_count
+                pm.total_functions += fm.function_count
+                pm.total_classes += fm.class_count
+                pm.total_complexity += fm.complexity
+                pm.total_size_bytes += fm.size_bytes
+
+                # Language breakdown
+                lang = fm.language
+                pm.files_by_language[lang] = pm.files_by_language.get(lang, 0) + 1
+
+                # Complexity breakdown
+                if fm.complexity > 0:
+                    pm.complexity_breakdown[str(file_path)] = fm.complexity
+
+                # Extract TODOs
+                todos = _extract_todos(content, str(file_path))
+                pm.todos.extend(todos)
+
+            pm.total_files += len(filenames)
+
+        return pm
+
+    def scan_file(self, file_path: str) -> FileMetrics | None:
+        """Scan a single file and return its metrics."""
+        fp = Path(file_path)
+        if not fp.exists() or not fp.is_file():
+            return None
+        try:
+            content = fp.read_text(encoding="utf-8", errors="replace")
+        except (OSError, UnicodeDecodeError):
+            return None
+
+        language = _detect_language(fp)
+        if language == "python":
+            fm = _scan_python(fp, content)
+        else:
+            fm = _scan_generic(fp, content)
+
+        fm.size_bytes = fp.stat().st_size
+        fm.todo_count = len(re.findall(r"\bTODO\b", content, re.IGNORECASE))
+        fm.fixme_count = len(re.findall(r"\bFIXME\b", content, re.IGNORECASE))
+        return fm
+
+
+# ── Convenience ──────────────────────────────────────────────────────────────
+
+
+def scan_project(root: str | None = None) -> ProjectMetrics:
+    """Convenience: scan a project directory and return metrics."""
+    scanner = CodebaseScanner(root)
+    return scanner.scan()