deadpush 0.2.0__py3-none-any.whl

deadpush/languages/__init__.py

@@ -0,0 +1,143 @@
+"""
+deadpush language plugin registry.
+
+This central module makes adding + integrating new languages seamless:
+
+- All plugins are registered here (lazily imported to keep startup fast and
+  avoid requiring every tree-sitter-foo even if lang disabled).
+- get_enabled_plugins(config) returns only the active ones for the run.
+- Helpers for extensions, names, etc. are used by crawler, watch, ui etc.
+- To add a new language:
+    1. pip add the tree-sitter-xxx dep + update pyproject.toml
+    2. Implement xxx.py following the LanguagePlugin protocol (see base.py)
+    3. Add to LANGUAGE_REGISTRY below
+    4. (optional) update default list in config.py
+
+Plugins are structural (no inheritance required) but should implement the
+methods in base.LanguagePlugin .
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from .base import Import, CallSite, LanguagePlugin
+
+if TYPE_CHECKING:
+    from ..config import Config
+
+# ----------------------------------------------------------------------------
+# Registry: name -> (import_path, class_name)
+# Keep sorted for determinism. Lazy to support partial installs.
+# ----------------------------------------------------------------------------
+LANGUAGE_REGISTRY: dict[str, tuple[str, str]] = {
+    "python": (".python_", "PythonPlugin"),
+    "typescript": (".typescript", "TypeScriptPlugin"),
+    "javascript": (".javascript", "JavaScriptPlugin"),
+    "go": (".go_", "GoPlugin"),
+    "rust": (".rust", "RustPlugin"),
+    "cpp": (".cpp", "CppPlugin"),
+    "java": (".java", "JavaPlugin"),
+}
+
+# Common aliases users / config may use
+LANGUAGE_ALIASES: dict[str, str] = {
+    "py": "python",
+    "ts": "typescript",
+    "tsx": "typescript",
+    "js": "javascript",
+    "jsx": "javascript",
+    "c++": "cpp",
+    "cxx": "cpp",
+    "cc": "cpp",
+    "c": "cpp",  # treat C as cpp plugin for simplicity (overlapping extensions)
+}
+
+
+def _load_plugin_class(module_rel: str, class_name: str):
+    """Import and return the plugin class (lazy)."""
+    from importlib import import_module
+    mod = import_module(module_rel, package=__name__)
+    return getattr(mod, class_name)
+
+
+def get_plugin(name: str) -> LanguagePlugin | None:
+    """Return an instantiated plugin for a canonical language name, or None."""
+    canonical = LANGUAGE_ALIASES.get(name.lower(), name.lower())
+    if canonical not in LANGUAGE_REGISTRY:
+        return None
+    mod_rel, cls_name = LANGUAGE_REGISTRY[canonical]
+    try:
+        cls = _load_plugin_class(mod_rel, cls_name)
+        return cls()
+    except Exception as e:
+        # Fail gracefully so one bad language parser doesn't kill the run
+        import warnings
+        warnings.warn(f"Failed to load language plugin {name!r}: {e}")
+        return None
+
+
+def get_enabled_plugins(config: "Config") -> dict[str, LanguagePlugin]:
+    """Return {lang_name: plugin_instance, ...} for languages enabled in config."""
+    plugins: dict[str, LanguagePlugin] = {}
+    for name in config.languages:
+        canonical = LANGUAGE_ALIASES.get(name.lower(), name.lower())
+        if canonical in plugins:
+            continue
+        plug = get_plugin(canonical)
+        if plug:
+            plugins[canonical] = plug
+    # Also respect aliases that map into enabled set
+    for alias, canon in LANGUAGE_ALIASES.items():
+        if config.is_language_enabled(alias) and canon not in plugins:
+            plug = get_plugin(canon)
+            if plug:
+                plugins[canon] = plug
+    return plugins
+
+
+def get_all_plugins() -> dict[str, LanguagePlugin]:
+    """Return all known plugins (best effort; some may fail to import if deps missing)."""
+    plugins = {}
+    for name in list(LANGUAGE_REGISTRY.keys()):
+        p = get_plugin(name)
+        if p:
+            plugins[name] = p
+    return plugins
+
+
+def get_all_extensions() -> set[str]:
+    """Union of all file extensions known to any plugin (for filtering etc)."""
+    exts: set[str] = set()
+    for name in LANGUAGE_REGISTRY:
+        try:
+            p = get_plugin(name)
+            if p and hasattr(p, "extensions"):
+                exts.update(p.extensions)
+        except Exception:
+            pass
+    return exts
+
+
+def get_language_for_file(path: str | Path, plugins: dict[str, LanguagePlugin] | None = None) -> tuple[str, LanguagePlugin] | None:
+    """Given a path, return (lang_name, plugin) that claims its suffix, or None."""
+    suffix = Path(path).suffix.lower()
+    plugs = plugins or get_all_plugins()
+    for lang, plug in plugs.items():
+        if hasattr(plug, "extensions") and suffix in plug.extensions:
+            return lang, plug
+    return None
+
+
+# Re-export for convenience
+__all__ = [
+    "Import",
+    "CallSite",
+    "LanguagePlugin",
+    "LANGUAGE_REGISTRY",
+    "get_plugin",
+    "get_enabled_plugins",
+    "get_all_plugins",
+    "get_all_extensions",
+    "get_language_for_file",
+]

deadpush/languages/base.py

@@ -0,0 +1,70 @@
+"""
+Base types and protocol for deadpush language plugins.
+
+Defines the common Import representation and LanguagePlugin structural interface
+used by all language backends (rust, cpp, python, etc.).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass(frozen=True, slots=True)
+class Import:
+    """Normalized representation of an import/use statement.
+
+    - module: the module/package being imported (e.g. "std::io" or "crate")
+    - names: imported names or ["*"] for glob
+    - level: 0 for absolute, >0 indicates relative import depth (Python style)
+    """
+    module: str
+    names: list[str]
+    level: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class CallSite:
+    """Structured representation of a function/method call site.
+
+    This enables much better call-graph construction than raw text matching.
+    """
+    caller_id: str          # symbol id of the containing function/method
+    callee: str             # best-effort name of the callee (e.g. "findOne", "db.findOne")
+    line: int
+    column: int = 0
+    is_method: bool = False
+    receiver: str | None = None   # e.g. "db", "this", "Model" for method calls
+    raw_callee_text: str = ""     # original text for fallback
+
+
+@runtime_checkable
+class LanguagePlugin(Protocol):
+    """Structural protocol for language plugins.
+
+    Plugins are not required to inherit; they only need to provide the attributes
+    and methods with matching signatures. This enables static checking and
+    optional runtime isinstance checks.
+    """
+
+    extensions: list[str]
+    language: Any  # tree_sitter.Language
+
+    def get_parser(self) -> Any: ...
+
+    def parse(self, source: bytes, path: str) -> Any: ...
+
+    def extract_symbols(self, tree: Any, path: str) -> list[Any]: ...
+
+    def extract_call_sites(self, tree: Any, path: str) -> list[CallSite]: ...
+
+    def extract_imports(self, tree: Any, path: str) -> list[Import]: ...
+
+    def detect_entry_points(
+        self, tree: Any, path: str, config_dynamic_patterns: list[str]
+    ) -> list[str]: ...
+
+    def classify_dynamic_risk(self, tree: Any, path: str) -> float: ...
+
+    def supports_suppression_comment(self, line_text: str) -> bool: ...

deadpush/languages/cpp.py

@@ -0,0 +1,150 @@
+"""
+Production-grade C++ language plugin for deadpush.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tree_sitter import Language, Node, Tree
+import tree_sitter_cpp as tscpp
+
+from ..graph import Symbol, make_symbol_id
+from .base import Import, CallSite, LanguagePlugin
+
+CPP_LANGUAGE = Language(tscpp.language())
+
+
+class CppPlugin:
+    extensions = [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".h"]
+    language = CPP_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 in ("function_definition", "declaration"):
+                declarator = node.child_by_field_name("declarator")
+                if declarator:
+                    name_node = declarator.child_by_field_name("declarator") or declarator
+                    if hasattr(name_node, 'type') and name_node.type == "identifier":
+                        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 == "class_specifier":
+                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 C/C++ call extraction (best-effort due to complex grammar).
+
+        Captures function calls, method calls ( . and -> ), qualified names.
+        Note: templates, overloads, and full resolution are limited without
+        additional semantic 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):
+            if node.type in ("function_definition", "declaration"):
+                # rough current func from declarator
+                declarator = node.child_by_field_name("declarator")
+                if declarator:
+                    name_node = declarator.child_by_field_name("declarator") or declarator
+                    if get_text(name_node):
+                        current_func_id = make_symbol_id(path, get_text(name_node).split("(")[0].strip())
+
+            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
+                        field = func_node.child_by_field_name("field")
+                        value = func_node.child_by_field_name("argument")
+                        callee_name = get_text(field) if field else raw
+                        receiver = get_text(value) if value else None
+                    elif func_node.type in ("identifier", "qualified_identifier", "scoped_identifier"):
+                        parts = raw.split("::")
+                        callee_name = parts[-1]
+
+                    callee_name = callee_name.split("(")[0].strip()
+
+                    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 []
+
+    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 "int main(" in source[:600] or "void main(" in source[:600] 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 "virtual" in text or "override" in text:
+            risk += 0.2
+        if "#define" in text:
+            risk += 0.15
+        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/languages/go_.py

@@ -0,0 +1,177 @@
+"""
+Production-grade Go language plugin for deadpush.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tree_sitter import Language, Node, Tree
+import tree_sitter_go as tsgo
+
+from ..graph import Symbol, make_symbol_id
+from .base import Import, CallSite, LanguagePlugin
+
+GO_LANGUAGE = Language(tsgo.language())
+
+
+class GoPlugin:
+    extensions = [".go"]
+    language = GO_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_declaration":
+                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 == "method_declaration":
+                # receiver + name
+                name_node = node.child_by_field_name("name")
+                recv = node.child_by_field_name("receiver")
+                if name_node:
+                    name = name_node.text.decode("utf-8")
+                    # include receiver type in name for uniqueness e.g. (*Foo).Bar
+                    recv_text = ""
+                    if recv:
+                        for c in recv.children:
+                            if c.type in ("type_identifier", "pointer_type"):
+                                recv_text = c.text.decode("utf-8", "ignore").strip("*() ")
+                                break
+                    full = f"{recv_text}.{name}" if recv_text else name
+                    symbols.append(Symbol(
+                        id=make_symbol_id(path, full),
+                        name=full,
+                        kind="method",
+                        path=path,
+                        line=node.start_point[0] + 1,
+                    ))
+            elif node.type == "type_spec":
+                # struct or interface
+                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 Go call extraction.
+
+        Handles function calls, method calls on receivers (value/pointer),
+        qualified identifiers (pkg.Func), etc.
+        """
+        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 in ("function_declaration", "method_declaration"):
+                name_node = node.child_by_field_name("name")
+                func_name = get_text(name_node) if name_node else None
+                if func_name:
+                    current_func_id = make_symbol_id(path, func_name)
+
+            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 == "selector_expression":
+                        is_method = True
+                        sel = func_node.child_by_field_name("field")
+                        x = func_node.child_by_field_name("operand")
+                        callee_name = get_text(sel) if sel else raw
+                        receiver = get_text(x) if x else None
+                    elif func_node.type == "identifier":
+                        callee_name = raw
+
+                    callee_name = callee_name.split("(")[0].strip()
+
+                    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]:
+        imports: list[Import] = []
+        root = tree.root_node
+        for node in root.children:
+            if node.type == "import_declaration":
+                for spec in node.children:
+                    if spec.type == "import_spec":
+                        path_node = spec.child_by_field_name("path") or spec
+                        mod = path_node.text.decode("utf-8").strip('"')
+                        imports.append(Import(module=mod, names=["*"], level=0))
+        return imports or [Import(module="main", 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")
+        if 'package main' in src and 'func main()' in src:
+            return ["main"]
+        return ["main"] if "func main(" in src[:400] 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 or "reflect." in text:
+            risk += 0.35
+        if "go " in text and "func" in text:  # goroutines
+            risk += 0.15
+        return min(risk, 1.0)
+
+    def supports_suppression_comment(self, line_text: str) -> bool:
+        return "// deadpush: ignore" in line_text