deadpush 0.2.0__py3-none-any.whl

deadpush/languages/rust.py

@@ -0,0 +1,147 @@
+"""
+Production-grade Rust language plugin for deadpush.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tree_sitter import Language, Node, Tree
+import tree_sitter_rust as tsrust
+
+from ..graph import Symbol, make_symbol_id
+from .base import Import, CallSite, LanguagePlugin
+
+RUST_LANGUAGE = Language(tsrust.language())
+
+
+class RustPlugin:
+    extensions = [".rs"]
+    language = RUST_LANGUAGE
+
+    def get_parser(self):
+        from tree_sitter import Parser
+        return Parser(self.language)
+
+    def parse(self, source: bytes, path: str) -> Tree:
+        return self.get_parser().parse(source)
+
+    def extract_symbols(self, tree: Tree, path: str) -> list[Symbol]:
+        symbols: list[Symbol] = []
+        root = tree.root_node
+
+        def walk(node: Node):
+            if node.type == "function_item":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    name = name_node.text.decode("utf-8")
+                    symbols.append(Symbol(
+                        id=make_symbol_id(path, name),
+                        name=name,
+                        kind="function",
+                        path=path,
+                        line=node.start_point[0] + 1,
+                        is_entry_point=(name == "main"),
+                    ))
+            elif node.type == "struct_item":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbols.append(Symbol(
+                        id=make_symbol_id(path, name_node.text.decode("utf-8")),
+                        name=name_node.text.decode("utf-8"),
+                        kind="class",
+                        path=path,
+                        line=node.start_point[0] + 1,
+                    ))
+            elif node.type == "impl_item":
+                for child in node.children:
+                    if child.type == "function_item":
+                        walk(child)
+
+            for child in node.children:
+                walk(child)
+
+        walk(root)
+
+        symbols.append(Symbol(
+            id=make_symbol_id(path, Path(path).name),
+            name=Path(path).name,
+            kind="file",
+            path=path,
+            line=1
+        ))
+        return symbols
+
+    def extract_call_sites(self, tree: Tree, path: str) -> list[CallSite]:
+        """Exhaustive Rust call site extraction.
+
+        Handles function calls, method calls (via field_expression or UFCS),
+        associated functions, macros (basic), turbofish ignored.
+        """
+        calls: list[CallSite] = []
+        root = tree.root_node
+
+        def get_text(n: Node | None) -> str:
+            if not n:
+                return ""
+            return n.text.decode("utf-8", errors="ignore").strip()
+
+        def walk(node: Node, current_func_id: str | None = None):
+            if node.type == "function_item":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    current_func_id = make_symbol_id(path, get_text(name_node))
+
+            if node.type == "call_expression":
+                func_node = node.child_by_field_name("function")
+                if func_node and current_func_id:
+                    raw = get_text(func_node)
+                    callee_name = raw
+                    receiver = None
+                    is_method = False
+
+                    if func_node.type == "field_expression":
+                        is_method = True
+                        value = func_node.child_by_field_name("value")
+                        field = func_node.child_by_field_name("field")
+                        callee_name = get_text(field) if field else raw
+                        receiver = get_text(value) if value else None
+                    elif func_node.type in ("identifier", "scoped_identifier"):
+                        callee_name = raw.split("::")[-1]
+
+                    callee_name = callee_name.split("(")[0].strip().split("::<")[0]
+
+                    call = CallSite(
+                        caller_id=current_func_id,
+                        callee=callee_name,
+                        line=node.start_point[0] + 1,
+                        is_method=is_method,
+                        receiver=receiver,
+                        raw_callee_text=raw
+                    )
+                    calls.append(call)
+
+            for child in node.children:
+                walk(child, current_func_id)
+
+        walk(root)
+        return calls
+
+    def extract_imports(self, tree: Tree, path: str) -> list[Import]:
+        return [Import(module="crate", names=["*"], level=0)]
+
+    def detect_entry_points(self, tree: Tree, path: str, config_dynamic_patterns: list[str]) -> list[str]:
+        source = tree.root_node.text.decode("utf-8", errors="ignore")
+        return ["main"] if "fn main(" in source[:800] else []
+
+    def classify_dynamic_risk(self, tree: Tree, path: str) -> float:
+        text = tree.root_node.text.decode("utf-8", errors="ignore").lower()
+        risk = 0.0
+        if "unsafe" in text:
+            risk += 0.45
+        if "dyn " in text:
+            risk += 0.25
+        return min(risk, 1.0)
+
+    def supports_suppression_comment(self, line_text: str) -> bool:
+        return "// deadpush: ignore" in line_text

deadpush/languages/typescript.py

@@ -0,0 +1,192 @@
+"""
+Production-grade TypeScript (and TSX) language plugin for deadpush.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tree_sitter import Language, Node, Tree
+import tree_sitter_typescript as tsts
+
+from ..graph import Symbol, make_symbol_id
+from .base import Import, CallSite, LanguagePlugin
+
+TS_LANGUAGE = Language(tsts.language_typescript())
+TSX_LANGUAGE = Language(tsts.language_tsx())
+
+
+def _pick_language(path: str) -> Language:
+    return TSX_LANGUAGE if Path(path).suffix.lower() == ".tsx" else TS_LANGUAGE
+
+
+class TypeScriptPlugin:
+    extensions = [".ts", ".tsx", ".mts", ".cts"]
+    # language attr is set per instance in practice; we pick default TS
+    language = TS_LANGUAGE
+
+    def get_parser(self, path: str | None = None):
+        from tree_sitter import Parser
+        lang = _pick_language(path or "") if path else self.language
+        return Parser(lang)
+
+    def parse(self, source: bytes, path: str) -> Tree:
+        return self.get_parser(path).parse(source)
+
+    def extract_symbols(self, tree: Tree, path: str) -> list[Symbol]:
+        symbols: list[Symbol] = []
+        root = tree.root_node
+
+        def walk(node: Node):
+            if node.type in ("function_declaration", "method_definition", "arrow_function"):
+                name_node = node.child_by_field_name("name") or node.child_by_field_name("property_identifier")
+                if not name_node:
+                    # arrow assigned to var, rough scan siblings/parent
+                    for sib in (node.parent.children if node.parent else []):
+                        if sib.type == "identifier":
+                            name_node = sib
+                            break
+                if name_node:
+                    name = name_node.text.decode("utf-8")
+                    kind = "function"
+                    if node.type == "method_definition":
+                        kind = "method"
+                    symbols.append(Symbol(
+                        id=make_symbol_id(path, name),
+                        name=name,
+                        kind=kind,
+                        path=path,
+                        line=node.start_point[0] + 1,
+                        is_entry_point=(name in ("main", "default", "index")),
+                    ))
+            elif node.type in ("class_declaration", "interface_declaration", "type_alias_declaration"):
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbols.append(Symbol(
+                        id=make_symbol_id(path, name_node.text.decode("utf-8")),
+                        name=name_node.text.decode("utf-8"),
+                        kind="class",
+                        path=path,
+                        line=node.start_point[0] + 1,
+                    ))
+
+            for child in node.children:
+                walk(child)
+
+        walk(root)
+
+        symbols.append(Symbol(
+            id=make_symbol_id(path, Path(path).name),
+            name=Path(path).name,
+            kind="file",
+            path=path,
+            line=1
+        ))
+        return symbols
+
+    def extract_call_sites(self, tree: Tree, path: str) -> list[CallSite]:
+        """Exhaustive call site extraction for TypeScript/TSX.
+
+        Similar structure to JS but handles TS-specific nodes (e.g. type arguments are ignored).
+        Captures direct calls, member calls, new, with receiver info.
+        """
+        calls: list[CallSite] = []
+        root = tree.root_node
+
+        def get_text(n: Node | None) -> str:
+            if not n:
+                return ""
+            return n.text.decode("utf-8", errors="ignore").strip()
+
+        def walk(node: Node, current_func_id: str | None = None, current_func_name: str | None = None):
+            if node.type in ("function_declaration", "method_definition", "arrow_function", "function_expression"):
+                name_node = node.child_by_field_name("name") or node.child_by_field_name("property_identifier")
+                func_name = get_text(name_node) if name_node else current_func_name
+                if not func_name:
+                    # assigned to variable
+                    parent = node.parent
+                    if parent and parent.type in ("variable_declarator", "assignment_expression"):
+                        for c in parent.children:
+                            if c.type == "identifier":
+                                func_name = get_text(c)
+                                break
+                current_func_id = make_symbol_id(path, func_name) if func_name else current_func_id
+                current_func_name = func_name
+
+            if node.type in ("call_expression", "new_expression"):
+                func_node = node.child_by_field_name("function")
+                if func_node and current_func_id:
+                    raw = get_text(func_node)
+                    is_new = node.type == "new_expression"
+                    callee_name = raw
+                    receiver = None
+                    is_method = False
+
+                    if func_node.type == "member_expression":
+                        is_method = True
+                        prop = func_node.child_by_field_name("property")
+                        obj = func_node.child_by_field_name("object")
+                        callee_name = get_text(prop) if prop else raw
+                        receiver = get_text(obj) if obj else None
+                    elif func_node.type == "identifier":
+                        callee_name = raw
+                    else:
+                        callee_name = raw.split(".")[-1].split("(")[0].strip() or raw
+
+                    callee_name = callee_name.split("(")[0].strip().rstrip(".")
+
+                    call = CallSite(
+                        caller_id=current_func_id,
+                        callee=callee_name,
+                        line=node.start_point[0] + 1,
+                        column=node.start_point[1] + 1,
+                        is_method=is_method or is_new,
+                        receiver=receiver,
+                        raw_callee_text=raw
+                    )
+                    calls.append(call)
+
+            for child in node.children:
+                walk(child, current_func_id, current_func_name)
+
+        walk(root)
+        return calls
+
+    def extract_imports(self, tree: Tree, path: str) -> list[Import]:
+        imports: list[Import] = []
+        root = tree.root_node
+        for node in root.children:
+            if node.type == "import_statement":
+                # import foo from "bar" or import {x} from "bar"
+                source_node = None
+                for c in node.children:
+                    if c.type == "string":
+                        source_node = c
+                if source_node:
+                    mod = source_node.text.decode("utf-8").strip('"\'')
+                    imports.append(Import(module=mod, names=["*"], level=0))
+            elif node.type == "import_clause":
+                pass  # covered above
+        return imports or [Import(module=".", names=["*"], level=0)]
+
+    def detect_entry_points(self, tree: Tree, path: str, config_dynamic_patterns: list[str]) -> list[str]:
+        src = tree.root_node.text.decode("utf-8", errors="ignore")[:800]
+        if "export default" in src or "function main" in src:
+            return ["default", "main"]
+        if "app.listen" in src or "server.listen" in src:
+            return ["app"]
+        return ["main"] if "main(" in src else []
+
+    def classify_dynamic_risk(self, tree: Tree, path: str) -> float:
+        text = tree.root_node.text.decode("utf-8", errors="ignore").lower()
+        risk = 0.0
+        if "eval(" in text or "new Function(" in text:
+            risk += 0.40
+        if "require(" in text and "dynamic" in text:
+            risk += 0.15
+        if "process.env" in text:  # config surface
+            risk += 0.10
+        return min(risk, 1.0)
+
+    def supports_suppression_comment(self, line_text: str) -> bool:
+        return "// deadpush: ignore" in line_text or "/* deadpush: ignore */" in line_text

deadpush/layers.py

@@ -0,0 +1,197 @@
+"""
+Architecture Layer Enforcer — validates import dependencies between layers.
+
+AI agents frequently bypass architectural boundaries, creating direct coupling
+between layers that should remain separate (e.g., views importing models directly).
+This module enforces user-defined layer rules during scans.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class LayerRule:
+    """A single architectural layer definition."""
+    name: str
+    paths: list[str]
+    allowed_imports: list[str]
+    disallowed_imports: list[str] = field(default_factory=list)
+
+
+@dataclass
+class LayerViolation:
+    """An import that violates architecture layer rules."""
+    file: str
+    line: int
+    layer: str
+    imported_module: str
+    rule_type: str  # "disallowed" | "outside_layer"
+    description: str
+    confidence: float = 0.95
+
+
+# Default layer rules for common architectures
+DEFAULT_LAYERS: list[LayerRule] = [
+    LayerRule(
+        name="views/presentation",
+        paths=["**/views/**", "**/templates/**", "**/pages/**", "**/components/**"],
+        allowed_imports=["controllers", "services", "utils", "helpers"],
+        disallowed_imports=["models", "db", "database", "repositories"],
+    ),
+    LayerRule(
+        name="controllers/handlers",
+        paths=["**/controllers/**", "**/handlers/**", "**/routes/**"],
+        allowed_imports=["services", "models", "utils"],
+        disallowed_imports=[],
+    ),
+    LayerRule(
+        name="services",
+        paths=["**/services/**", "**/use_cases/**", "**/domain/**"],
+        allowed_imports=["models", "repositories", "utils", "infrastructure"],
+        disallowed_imports=["views", "templates", "ui"],
+    ),
+    LayerRule(
+        name="models/entities",
+        paths=["**/models/**", "**/entities/**"],
+        allowed_imports=["utils"],
+        disallowed_imports=["views", "controllers", "services", "ui"],
+    ),
+]
+
+
+class LayerEnforcer:
+    """Enforces architectural layer import rules."""
+
+    def __init__(self, layers: list[LayerRule] | None = None):
+        self.layers = layers or DEFAULT_LAYERS
+
+    def _get_layer_for_file(self, rel_path: str) -> LayerRule | None:
+        """Find which layer a file belongs to based on its path."""
+        rp = rel_path.replace("\\", "/")
+        for layer in self.layers:
+            for pat in layer.paths:
+                if fnmatch(rp, pat) or fnmatch(rp, "**/" + pat):
+                    return layer
+        return None
+
+    def _is_import_allowed(self, import_module: str, layer: LayerRule) -> bool:
+        """Check if an import is allowed from the given layer."""
+        imp = import_module.lower().replace("_", "").replace("-", "").replace(".", "/")
+
+        # Check explicit disallow list
+        for disallowed in layer.disallowed_imports:
+            d = disallowed.lower().replace("_", "").replace("-", "")
+            if d in imp:
+                return False
+
+        # Check allow list — if empty, everything is allowed (catch-all layer)
+        if not layer.allowed_imports:
+            return True
+
+        for allowed in layer.allowed_imports:
+            a = allowed.lower().replace("_", "").replace("-", "")
+            if a in imp:
+                return True
+
+        # Relative imports from same layer are allowed
+        return False
+
+    def analyze_imports(
+        self,
+        rel_path: str,
+        imports: list[tuple[str, int]],  # (module_name, line_number)
+    ) -> list[LayerViolation]:
+        """Check a file's imports against layer rules."""
+        violations: list[LayerViolation] = []
+        layer = self._get_layer_for_file(rel_path)
+        if layer is None:
+            return violations
+
+        for module, line in imports:
+            # Skip relative imports
+            if module.startswith(".") or module.startswith(".."):
+                continue
+
+            if not self._is_import_allowed(module, layer):
+                violations.append(LayerViolation(
+                    file=rel_path,
+                    line=line,
+                    layer=layer.name,
+                    imported_module=module,
+                    rule_type="disallowed",
+                    description=f"'{rel_path}' ({layer.name}) imports '{module}' which is outside its allowed dependencies",
+                ))
+
+        return violations
+
+    def analyze_batch(self, files: list[Any]) -> list[LayerViolation]:
+        """Analyze all source files for layer violations.
+
+        Uses regex import extraction on each file, then checks against layer rules.
+        """
+        violations: list[LayerViolation] = []
+
+        for f in files:
+            if not getattr(f, "is_text", True):
+                continue
+            rel_path = str(getattr(f, "rel_path", f.path))
+            try:
+                source = f.path.read_text(encoding="utf-8", errors="ignore")
+                imports_list = self.extract_imports_regex(source, f.path.suffix)
+                if imports_list:
+                    violations.extend(self.analyze_imports(rel_path, imports_list))
+            except Exception:
+                pass
+
+        return violations
+
+    def extract_imports_regex(self, source: str, suffix: str) -> list[tuple[str, int]]:
+        """Extract import statements from source text using regex."""
+        imports: list[tuple[str, int]] = []
+        lines = source.splitlines()
+
+        if suffix == ".py":
+            for i, line in enumerate(lines, 1):
+                m = re.match(r'^\s*import\s+(\S+)', line)
+                if m:
+                    imports.append((m.group(1).split(".")[0], i))
+                m = re.match(r'^\s*from\s+(\S+)\s+import', line)
+                if m:
+                    imports.append((m.group(1).split(".")[0], i))
+        elif suffix in (".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"):
+            for i, line in enumerate(lines, 1):
+                m = re.match(r'^\s*import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+[\'"]([^\'"]+)[\'"]', line)
+                if m:
+                    mod = m.group(1).split("/")[0]
+                    if mod.startswith("."):
+                        continue
+                    imports.append((mod, i))
+                m = re.match(r'^\s*(?:const|let|var)\s+\w+\s*=\s*require\s*\([\'"]([^\'"]+)[\'"]', line)
+                if m:
+                    mod = m.group(1).split("/")[0]
+                    if mod.startswith("."):
+                        continue
+                    imports.append((mod, i))
+        elif suffix == ".go":
+            for i, line in enumerate(lines, 1):
+                m = re.match(r'^\s*import\s+[\'"]', line)
+                if m:
+                    continue  # handled by next lines
+                m = re.match(r'^\s*[\'"](\S+)[\'"]', line)
+                if m:
+                    mod = m.group(1).split("/")[0]
+                    imports.append((mod, i))
+        elif suffix == ".rs":
+            for i, line in enumerate(lines, 1):
+                m = re.match(r'^\s*use\s+(\S+)', line)
+                if m:
+                    mod = m.group(1).split("::")[0]
+                    imports.append((mod, i))
+
+        return imports