adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/detectors/imports.py

@@ -0,0 +1,132 @@
+"""Import pattern detectors.
+
+Analyzes import structure, unused imports, circular dependencies.
+"""
+
+from __future__ import annotations
+
+from typing import List, Dict, Any, Set
+from pathlib import Path
+from tree_sitter import Node, Tree
+
+from adl_drift.detectors.base import BaseDetector
+from adl_drift.utils.types import Pattern, PatternCategory
+from adl_drift.parser.core import PythonParser
+
+
+class ImportDetector(BaseDetector):
+    """Detects and analyzes import patterns."""
+
+    STDLIB_MODULES = {
+        "os", "sys", "json", "re", "collections", "itertools", "functools",
+        "pathlib", "typing", "dataclasses", "enum", "abc", "inspect",
+        "threading", "multiprocessing", "asyncio", "unittest", "logging",
+        "hashlib", "random", "datetime", "time", "math", "statistics",
+    }
+
+    def __init__(self, parser: PythonParser):
+        super().__init__(parser)
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.IMPORTS
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        patterns = []
+
+        for node in self._walk(tree.root_node):
+            if node.type == "import_statement":
+                patterns.extend(self._analyze_import(node, source_bytes, file_path))
+            elif node.type == "import_from_statement":
+                patterns.extend(self._analyze_from_import(node, source_bytes, file_path))
+
+        return patterns
+
+    def _analyze_import(self, node: Node, source: bytes, path: Path) -> List[Pattern]:
+        patterns = []
+
+        for child in node.children:
+            if child.type == "dotted_name":
+                name = self.parser.node_text(child, source)
+                top_module = name.split(".")[0]
+                category = self._classify_module(top_module)
+
+                patterns.append(self._make_pattern(
+                    name=f"import:{category}",
+                    description=f"Import {category}: {name}",
+                    node=node,
+                    file_path=path,
+                    confidence=0.95,
+                    metadata={
+                        "import_type": category,
+                        "module": name,
+                        "top_module": top_module,
+                    }
+                ))
+
+        return patterns
+
+    def _analyze_from_import(self, node: Node, source: bytes, path: Path) -> List[Pattern]:
+        patterns = []
+
+        module_node = node.child_by_field_name("module_name")
+        module = self.parser.node_text(module_node, source) if module_node else ""
+
+        node_text = self.parser.node_text(node, source)
+        if "import *" in node_text:
+            patterns.append(self._make_pattern(
+                name="star_import",
+                description=f"Star import from {module} (pollutes namespace)",
+                node=node,
+                file_path=path,
+                confidence=0.9,
+                metadata={
+                    "import_type": "star",
+                    "module": module,
+                    "severity": "warning",
+                }
+            ))
+
+        if module.startswith("."):
+            patterns.append(self._make_pattern(
+                name="relative_import",
+                description=f"Relative import: {module}",
+                node=node,
+                file_path=path,
+                confidence=0.95,
+                metadata={
+                    "import_type": "relative",
+                    "module": module,
+                }
+            ))
+
+        top_module = module.lstrip(".").split(".")[0] if module else ""
+        category = self._classify_module(top_module)
+
+        patterns.append(self._make_pattern(
+            name=f"from_import:{category}",
+            description=f"From import {category}: {module}",
+            node=node,
+            file_path=path,
+            confidence=0.9,
+            metadata={
+                "import_type": category,
+                "module": module,
+                "top_module": top_module,
+            }
+        ))
+
+        return patterns
+
+    def _classify_module(self, name: str) -> str:
+        if name in self.STDLIB_MODULES:
+            return "stdlib"
+        elif name in {"__future__"}:
+            return "future"
+        else:
+            return "third_party"
+
+    def _walk(self, node):
+        yield node
+        for child in node.children:
+            yield from self._walk(child)

package/adl_drift/detectors/logging_patterns.py

@@ -0,0 +1,108 @@
+"""Logging detector — print(), logger calls, eager-format anti-pattern."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional
+
+from tree_sitter import Node, Tree
+
+from adl_drift.detectors.base import BaseDetector
+from adl_drift.utils.types import Pattern, PatternCategory
+
+
+LOG_LEVELS = {"debug", "info", "warning", "warn", "error", "critical", "exception"}
+
+
+class LoggingDetector(BaseDetector):
+    """Flags print, logger calls, and f-string args to logger methods."""
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.LOGGING
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        patterns: List[Pattern] = []
+        has_logger_init = False
+
+        for node in self._walk(tree.root_node):
+            if node.type != "call":
+                continue
+            func = node.child_by_field_name("function")
+            if func is None:
+                continue
+            func_text = self.parser.node_text(func, source_bytes).strip()
+
+            if func_text == "print":
+                patterns.append(self._make_pattern(
+                    name="print_call",
+                    description="print() — prefer logger",
+                    node=node, file_path=file_path, confidence=0.5,
+                    metadata={"severity": "LOW"},
+                ))
+                continue
+
+            if func_text == "logging.getLogger":
+                has_logger_init = True
+                continue
+
+            level = self._level_from_attr(func, source_bytes)
+            if level is None:
+                continue
+            eager = self._has_fstring_arg(node, source_bytes)
+            name = "logger_fstring" if eager else "logger_call"
+            desc = (
+                f"logger.{level}(f\"...\") — eager-format anti-pattern"
+                if eager else f"logger.{level}() call"
+            )
+            patterns.append(self._make_pattern(
+                name=name,
+                description=desc,
+                node=node, file_path=file_path,
+                confidence=0.7 if eager else 0.6,
+                metadata={"level": level, "eager_format": eager},
+            ))
+
+        if has_logger_init:
+            patterns.append(self._make_pattern(
+                name="logger_init",
+                description="Module initializes a logger via logging.getLogger",
+                node=tree.root_node, file_path=file_path, confidence=0.95,
+                metadata={"role": "logger_module"},
+            ))
+        return patterns
+
+    def _level_from_attr(self, func_node: Node, source: bytes) -> Optional[str]:
+        if func_node.type != "attribute":
+            return None
+        attr = func_node.child_by_field_name("attribute")
+        if attr is None:
+            return None
+        name = self.parser.node_text(attr, source)
+        if name in LOG_LEVELS:
+            obj = func_node.child_by_field_name("object")
+            if obj is not None:
+                obj_text = self.parser.node_text(obj, source)
+                if obj_text in {"logger", "log", "logging", "LOG", "LOGGER"} or \
+                   obj_text.endswith("_logger") or obj_text.endswith(".logger"):
+                    return name
+        return None
+
+    def _has_fstring_arg(self, call_node: Node, source: bytes) -> bool:
+        args = call_node.child_by_field_name("arguments")
+        if args is None:
+            return False
+        for c in args.children:
+            if c.type == "string":
+                # tree-sitter-python uses interpolation child for f-strings
+                for sub in c.children:
+                    if sub.type == "interpolation":
+                        return True
+                if self.parser.node_text(c, source).lstrip().startswith(("f'", 'f"', "rf", "fr")):
+                    return True
+        return False
+
+    def _walk(self, node: Node):
+        yield node
+        for child in node.children:
+            yield from self._walk(child)

package/adl_drift/detectors/routes.py

@@ -0,0 +1,257 @@
+"""HTTP route detectors for Flask, FastAPI, Django.
+
+Finds URL endpoints and their handler functions.
+"""
+
+from __future__ import annotations
+
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from tree_sitter import Node, Tree
+
+from adl_drift.detectors.base import BaseDetector
+from adl_drift.utils.types import Pattern, PatternCategory, Symbol
+from adl_drift.parser.core import PythonParser
+
+
+class RouteDetector(BaseDetector):
+    """Detects HTTP route definitions across frameworks.
+
+    Handles:
+    - Flask: @app.route("/path")
+    - FastAPI: @app.get("/path"), @router.post("/path")
+    - Django: path("/path", views.handler) in urls.py
+    - Starlette: @app.route("/path")
+    """
+
+    # Known HTTP method names used by frameworks
+    HTTP_METHODS = {
+        "route", "get", "post", "put", "patch", "delete",
+        "head", "options", "trace", "connect",
+        "api_route", "include_router",
+    }
+
+    def __init__(self, parser: PythonParser):
+        super().__init__(parser)
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.ROUTES
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        patterns = []
+
+        for node in self._walk(tree.root_node):
+            if node.type != "function_definition":
+                continue
+
+            decorators = []
+            seen = set()
+            # tree-sitter-python wraps decorators in decorated_definition; they are siblings
+            for dec_node in (node.prev_sibling, *node.children):
+                if dec_node is None:
+                    continue
+                if dec_node.type == "decorator":
+                    dec_info = self._parse_decorator(dec_node, source_bytes)
+                    if dec_info and dec_info.get("is_route"):
+                        key = dec_info.get("raw", "")
+                        if key not in seen:
+                            seen.add(key)
+                            decorators.append(dec_info)
+                # Also walk up to parent decorated_definition to catch all decorators
+                if node.parent and node.parent.type == "decorated_definition":
+                    for sib in node.parent.children:
+                        if sib.type == "decorator" and sib is not dec_node:
+                            dec_info = self._parse_decorator(sib, source_bytes)
+                            if dec_info and dec_info.get("is_route"):
+                                key = dec_info.get("raw", "")
+                                if key not in seen:
+                                    seen.add(key)
+                                    decorators.append(dec_info)
+
+            if not decorators:
+                continue
+
+            func_name = self._get_func_name(node, source_bytes)
+
+            for dec in decorators:
+                pattern = self._make_pattern(
+                    name=f"route:{dec.get('method', 'unknown').upper()}",
+                    description=f"HTTP {dec.get('method', 'unknown').upper()} {dec.get('path', '/')} -> {func_name}",
+                    node=node,
+                    file_path=file_path,
+                    confidence=0.95,
+                    metadata={
+                        "framework": dec.get("framework", "unknown"),
+                        "http_method": dec.get("method", "get"),
+                        "route_path": dec.get("path", "/"),
+                        "handler": func_name,
+                        "decorator": dec.get("raw", ""),
+                    }
+                )
+                patterns.append(pattern)
+
+        return patterns
+
+    def _parse_decorator(self, node: Node, source: bytes) -> Optional[Dict[str, Any]]:
+        """Parse a decorator node to see if it's a route definition."""
+        text = self.parser.node_text(node, source).strip()
+
+        call_node = None
+        for child in node.children:
+            if child.type == "call":
+                call_node = child
+                break
+
+        if not call_node:
+            return None
+
+        func_node = call_node.child_by_field_name("function")
+        if not func_node:
+            return None
+
+        func_text = self.parser.node_text(func_node, source)
+
+        method = None
+        framework = None
+
+        if func_node.type == "attribute":
+            obj_node = func_node.child_by_field_name("object")
+            attr_node = func_node.child_by_field_name("attribute")
+
+            if obj_node and attr_node:
+                obj_name = self.parser.node_text(obj_node, source)
+                attr_name = self.parser.node_text(attr_node, source)
+
+                if attr_name.lower() in self.HTTP_METHODS:
+                    method = attr_name.lower()
+                    framework = self._detect_framework(obj_name, source)
+        elif func_node.type == "identifier":
+            name = self.parser.node_text(func_node, source)
+            if name.lower() in self.HTTP_METHODS:
+                method = name.lower()
+                framework = "unknown"
+
+        if not method:
+            return None
+
+        args_node = call_node.child_by_field_name("arguments")
+        path = "/"
+        if args_node:
+            for arg in args_node.children:
+                if arg.type == "string":
+                    path = self.parser.node_text(arg, source).strip("'\"")
+                    break
+
+        # If the decorator is `@app.route(...)` (generic), look for a
+        # `methods=[...]` keyword arg and use the first listed method.
+        if method == "route" and args_node:
+            for arg in args_node.children:
+                if arg.type != "keyword_argument":
+                    continue
+                name_node = arg.child_by_field_name("name")
+                value_node = arg.child_by_field_name("value")
+                if not (name_node and value_node):
+                    continue
+                if self.parser.node_text(name_node, source) != "methods":
+                    continue
+                for v in value_node.children:
+                    if v.type == "string":
+                        verb = self.parser.node_text(v, source).strip("'\"").lower()
+                        if verb in self.HTTP_METHODS:
+                            method = verb
+                            break
+                break
+
+        return {
+            "is_route": True,
+            "method": method,
+            "path": path,
+            "framework": framework,
+            "raw": text,
+        }
+
+    def _detect_framework(self, obj_name: str, source: bytes) -> str:
+        """Guess framework from app variable name."""
+        if obj_name in {"app", "application"}:
+            return "flask_or_fastapi"
+        elif obj_name == "router":
+            return "fastapi"
+        elif obj_name == "blueprint":
+            return "flask"
+        return "unknown"
+
+    def _get_func_name(self, node: Node, source: bytes) -> str:
+        """Extract function name from definition node."""
+        name_node = node.child_by_field_name("name")
+        if name_node:
+            return self.parser.node_text(name_node, source)
+        return "<anonymous>"
+
+    def _walk(self, node: Node):
+        yield node
+        for child in node.children:
+            yield from self._walk(child)
+
+
+class DjangoURLDetector(BaseDetector):
+    """Detects Django URL patterns in urls.py files."""
+
+    def __init__(self, parser: PythonParser):
+        super().__init__(parser)
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.ROUTES
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        patterns = []
+        if file_path.name != "urls.py":
+            return patterns
+
+        for node in self._walk(tree.root_node):
+            if node.type != "call":
+                continue
+
+            func_node = node.child_by_field_name("function")
+            if not func_node:
+                continue
+
+            func_name = self.parser.node_text(func_node, source_bytes)
+            if func_name not in {"path", "re_path", "url"}:
+                continue
+
+            args_node = node.child_by_field_name("arguments")
+            if not args_node or len(args_node.children) < 2:
+                continue
+
+            route = "/"
+            view = "unknown"
+
+            for arg in args_node.children:
+                if arg.type == "string":
+                    route = self.parser.node_text(arg, source_bytes).strip("'""")
+                elif arg.type in ("identifier", "attribute"):
+                    view = self.parser.node_text(arg, source_bytes)
+
+            pattern = self._make_pattern(
+                name=f"django_url:{func_name}",
+                description=f"Django URL: {route} -> {view}",
+                node=node,
+                file_path=file_path,
+                confidence=0.9,
+                metadata={
+                    "framework": "django",
+                    "url_type": func_name,
+                    "route": route,
+                    "view": view,
+                }
+            )
+            patterns.append(pattern)
+
+        return patterns
+
+    def _walk(self, node):
+        yield node
+        for child in node.children:
+            yield from self._walk(child)