patchi 0.7.5__py3-none-any.whl

patchi/core/brain/ast_utils/calls.py

@@ -0,0 +1,139 @@
+"""
+AST utilities — function/method call finding across languages.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from patchi.core.brain.languages import Lang, get_parser
+
+from .config import CALL_NODE_TYPES
+from .helpers import _leaf_name, child_by_field, children, node_text
+from .scan import scan_python
+
+_log = logging.getLogger("patchi.brain.calls")
+
+
+def find_calls(content: str, lang: Lang, names: set[str]) -> list[dict]:
+    """
+    Find all function/method calls in source whose name matches one of `names`.
+
+    Returns list of dicts with keys: name, line, col, full_text.
+
+    Python is served from the shared single-pass AST scan (one parse + walk
+    per file per process, cached) — repeated calls with different sink sets
+    no longer re-parse the file.
+    """
+    if lang == Lang.PYTHON:
+        return _find_calls_python(content, names)
+    parser = get_parser(lang)
+    if not parser:
+        return []
+    try:
+        tree = parser.parse(content.encode("utf-8"))
+    except Exception as e:
+        _log.warning("find_calls failed: %s", e)
+        return []
+    call_types = CALL_NODE_TYPES.get(lang, set())
+    results: list[dict] = []
+    _walk_calls(tree.root_node, call_types, names, results)
+    return results
+
+
+def _find_calls_python(content: str, names: set[str]) -> list[dict]:
+    """Filter the single-pass scan for matching call names."""
+    from pathlib import Path as _Path
+
+    scan = scan_python(content, file_path=_Path("<ast_utils>"))
+    results: list[dict] = []
+    for call in scan.get("calls", []):
+        fn = call.get("function", call.get("name", ""))
+        leaf = _leaf_name(fn)
+        if fn in names or leaf in names:
+            # Compute full text from source lines
+            line_no = call.get("line", 0)
+            full_text = ""
+            if content and line_no > 0:
+                src_lines = content.splitlines()
+                if 0 < line_no <= len(src_lines):
+                    full_text = src_lines[line_no - 1]
+            results.append(
+                {
+                    "name": fn,
+                    "line": line_no,
+                    "col": call.get("col", 0),
+                    "full_text": full_text,
+                }
+            )
+    return results
+
+
+def _extract_call_name(node: Any) -> str:
+    fn = child_by_field(node, "function") or child_by_field(node, "name")
+    if fn is not None:
+        return node_text(fn).split("(")[0].strip()
+    # Fallback: join all identifier/simple children before argument_list
+    parts: list[str] = []
+    for child in children(node):
+        if child.type in ("argument_list", "arguments", "value_arguments", "argument_part"):
+            break
+        txt = node_text(child)
+        if txt and txt not in ("(", ")", ".", "::"):
+            parts.append(txt)
+    if parts:
+        return ".".join(parts)
+    return ""
+
+
+def _walk_calls(node: Any, call_types: set[str], names: set[str], results: list[dict]) -> None:
+    try:
+        ntype = node.type if hasattr(node, "type") else ""
+    except Exception as e:
+        _log.warning("_walk_calls failed: %s", e)
+        return
+
+    if ntype in call_types:
+        fn = _extract_call_name(node)
+        if fn:
+            leaf = _leaf_name(fn)
+            if fn in names or leaf in names:
+                try:
+                    line = node.start_point[0] + 1 if node.start_point else 0
+                    col = node.start_point[1] if node.start_point else 0
+                except Exception as e:
+                    _log.warning("_walk_calls failed: %s", e)
+                    line, col = 0, 0
+                results.append(
+                    {
+                        "name": fn,
+                        "line": line,
+                        "col": col,
+                        "full_text": node_text(node),
+                    }
+                )
+
+        # For Ruby: also check call method name (avoid duplicate of existing match)
+        if ntype == "call" and not any(r["name"] == fn for r in results):
+            method = child_by_field(node, "method")
+            if method:
+                fn_name = node_text(method)
+                leaf = _leaf_name(fn_name)
+                if fn_name in names or leaf in names:
+                    try:
+                        line = node.start_point[0] + 1 if node.start_point else 0
+                    except Exception as e:
+                        _log.warning("_walk_calls failed: %s", e)
+                        line = 0
+                    results.append(
+                        {
+                            "name": fn_name,
+                            "line": line,
+                            "col": 0,
+                            "full_text": node_text(node),
+                        }
+                    )
+
+    for child in children(node):
+        _walk_calls(child, call_types, names, results)

patchi/core/brain/ast_utils/config.py

@@ -0,0 +1,132 @@
+"""
+AST utilities — per-language node type configs and common sink sets.
+
+Centralized configuration used by security agents, type checkers, and route
+detectors when walking tree-sitter parse trees or the Python `ast` module.
+"""
+
+from __future__ import annotations
+
+from patchi.core.brain.languages import Lang
+
+# ── Per-language node type config ─────────────────────────────────────────────
+
+# Languages in this codebase use tree-sitter (except Python which uses ast)
+CALL_NODE_TYPES: dict[Lang, set[str]] = {
+    Lang.PYTHON: set(),  # handled by ast
+    Lang.JAVASCRIPT: {"call_expression"},
+    Lang.TYPESCRIPT: {"call_expression"},
+    Lang.RUST: {"call_expression"},
+    Lang.JAVA: {"method_invocation"},
+    Lang.GO: {"call_expression"},
+    Lang.C: {"call_expression"},
+    Lang.CPP: {"call_expression"},
+    Lang.SWIFT: {"function_call_expression"},
+    Lang.RUBY: {"call"},
+    Lang.PHP: {"function_call_expression", "scoped_call_expression"},
+    Lang.C_SHARP: {"invocation_expression"},
+    Lang.KOTLIN: {"call_expression"},
+    Lang.DART: {"function_expression"},
+}
+
+IMPORT_NODE_TYPES: dict[Lang, set[str]] = {
+    Lang.PYTHON: set(),  # handled by ast
+    Lang.JAVASCRIPT: {"import_statement", "import_require_clause"},
+    Lang.TYPESCRIPT: {"import_statement", "import_require_clause"},
+    Lang.RUST: {"use_declaration"},
+    Lang.JAVA: {"import_declaration"},
+    Lang.GO: {"import_declaration"},
+    Lang.C: {"preproc_include"},
+    Lang.CPP: {"preproc_include"},
+    Lang.SWIFT: {"import_declaration"},
+    Lang.RUBY: {"call"},  # require/include are calls with specific names
+    Lang.PHP: {"namespace_use_declaration", "use_declaration"},
+    Lang.C_SHARP: {"using_directive"},
+    Lang.KOTLIN: {"import"},
+    Lang.DART: {"import"},
+}
+
+DECORATOR_NODE_TYPES: dict[Lang, set[str]] = {
+    Lang.PYTHON: set(),  # handled by ast
+    Lang.JAVA: {"marker_annotation", "annotation"},
+    Lang.C_SHARP: {"attribute"},
+    Lang.KOTLIN: {"annotation"},
+    Lang.PHP: {"attribute_group"},
+}
+
+# ── Common function names used across agents ─────────────────────────────────
+
+EXEC_SINKS = {
+    "execute",
+    "exec",
+    "eval",
+    "execScript",
+    "Runtime.getRuntime().exec",
+    "subprocess.call",
+    "subprocess.Popen",
+    "subprocess.run",
+    "subprocess.check_call",
+    "subprocess.check_output",
+    "os.system",
+    "os.popen",
+    "ProcessBuilder",
+    "shell_exec",
+    "system",
+    "passthru",
+    "exec_",
+    "child_process.exec",
+    "child_process.execSync",
+    "child_process.spawnSync",
+    "child_process.spawn",
+    "child_process.execFile",
+    "execSync",
+    "spawnSync",
+}
+
+SQL_SINKS = {
+    "execute",
+    "execute_query",
+    "executeQuery",
+    "executeUpdate",
+    "exec",
+    "query",
+    "raw_query",
+    "prepare",
+    "preparedStatement",
+    "cursor.execute",
+    "cursor.executemany",
+    "db.execute",
+    "session.execute",
+    "EntityManager.createQuery",
+    "entityManager.createQuery",
+    "JdbcTemplate.query",
+    "jdbcTemplate.query",
+}
+
+HTTP_CLIENTS = {
+    "requests.get",
+    "requests.post",
+    "requests.put",
+    "requests.delete",
+    "requests.patch",
+    "httpx.get",
+    "httpx.post",
+    "httpx.put",
+    "httpx.delete",
+    "httpx.patch",
+    "aiohttp.ClientSession.get",
+    "aiohttp.ClientSession.post",
+    "urllib.request.urlopen",
+    "urllib.request.Request",
+    "urllib3.request",
+    "curl",
+    "wget",
+    "fetch",
+    "axios.get",
+    "axios.post",
+    "axios.put",
+    "axios.delete",
+    "got",
+    "node-fetch",
+    "superagent",
+}

patchi/core/brain/ast_utils/control_flow.py

@@ -0,0 +1,74 @@
+"""
+AST utilities — control flow and data flow helpers.
+
+Provides generic building blocks used by taint tracking:
+  - tracking which variables are declared in which scope
+  - following a variable's aliases (a = b; c = a; use(c))
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from patchi.core.brain.languages import Lang
+
+from .helpers import children
+
+# Tree-sitter node types that open a new scope / block
+_SCOPE_NODE_TYPES = {
+    "block",
+    "function_declaration",
+    "function_item",
+    "method_declaration",
+    "function_definition",
+    "lambda_expression",
+    "arrow_function",
+    "class_declaration",
+    "class_definition",
+    "do_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "if_statement",
+    "compound_statement",
+    "method_definition",
+}
+
+
+def named_children_of_type(node: Any, type_name: str) -> list[Any]:
+    """Return immediate children whose type matches `type_name`."""
+    out = []
+    for child in children(node):
+        if getattr(child, "type", "") == type_name:
+            out.append(child)
+    return out
+
+
+def walk_blocks(node: Any, lang: Lang | None = None) -> Any:
+    """Yield every node in a tree (generic pre-order walk)."""
+    yield node
+    for child in children(node):
+        yield from walk_blocks(child, lang)
+
+
+def collect_call_arguments(call_node: Any) -> list[Any]:
+    """Return argument child nodes for a tree-sitter call/invocation node."""
+    args = (
+        child_by_field_any(call_node, "arguments")
+        or child_by_field_any(call_node, "argument_list")
+        or child_by_field_any(call_node, "value_arguments")
+        or child_by_field_any(call_node, "argument_part")
+    )
+    if args is None:
+        return []
+    return [c for c in children(args) if c.type not in ("(", ")", ",", "[", "]", "{", "}")]
+
+
+def child_by_field_any(node: Any, *fields: str) -> Any | None:
+    """child_by_field_name for the first matching field name."""
+    for f in fields:
+        if hasattr(node, "child_by_field_name"):
+            res = node.child_by_field_name(f)
+            if res is not None:
+                return res
+    return None

patchi/core/brain/ast_utils/dead_symbols.py

@@ -0,0 +1,205 @@
+"""
+AST utilities — intra-file dead-symbol detection across languages.
+
+Finds top-level (file-scope) functions / classes / methods / constants that are
+never referenced anywhere else in the same file. Cross-file references are the
+job of the import graph (file-level dead detection); this complements it with a
+symbol-level signal that works for every tree-sitter language without external
+tooling (vulture, ts-prune, etc.).
+
+Conservative by design — only flags file-scope symbols that:
+  - are not exported (no `export` / `pub` modifier),
+  - are not entry-point names (main/app/index/...),
+  - have a length >= 3 (avoids false positives on trivial names),
+  - never appear as an identifier/reference on any line other than their own.
+"""
+from __future__ import annotations
+
+import ast as _py_ast
+import logging
+
+from patchi.core.brain.languages import Lang, get_parser
+
+from .helpers import child_by_field, node_text
+
+# Node types that introduce a named symbol at file scope.
+_DEF_NODE_TYPES = {
+    "function_definition",
+    "function_declaration",
+    "function_item",
+    "function_method_definition",
+    "method_definition",
+    "method_declaration",
+    "method",
+    "class_definition",
+    "class_declaration",
+    "class_item",
+    "decorated_definition",
+    "lexical_declaration",
+    "variable_declaration",
+    "const_declaration",
+    "abstract_method_signature",
+}
+
+# Containers whose direct children may be top-level definitions.
+_ROOT_CONTAINERS = {
+    "program",
+    "source_file",
+    "module",
+    "translation_unit",
+    "compilation_unit",
+    "block",
+    "text",
+    "namespace_definition",
+}
+
+# Node types whose text counts as a reference to a name.
+_REF_NODE_TYPES = {
+    "identifier",
+    "name",
+    "property_identifier",
+    "field_identifier",
+    "type_identifier",
+    "shorthand_property_identifier",
+    "shorthand_property_identifier_pattern",
+}
+
+_ENTRY_NAMES = frozenset(
+    {
+        "main",
+        "app",
+        "index",
+        "run",
+        "start",
+        "server",
+        "init",
+        "__init__",
+        "setup",
+        "handler",
+    }
+)
+
+
+_log = logging.getLogger("patchi.brain.dead_symbols")
+
+
+def find_dead_symbols(content: str, lang: Lang, *, min_name_len: int = 3) -> list[dict]:
+    """
+    Return a list of intra-file dead symbols.
+
+    Each entry: {name, line, kind, file_scope}.
+    `file_scope` is True for module/file-level symbols (safe to report as dead),
+    False for nested symbols (report with care).
+    """
+    if lang == Lang.PYTHON:
+        return _find_dead_python(content, min_name_len)
+    parser = get_parser(lang)
+    if not parser:
+        return []
+    try:
+        tree = parser.parse(content.encode("utf-8"))
+    except Exception as e:
+        _log.warning("find_dead_symbols failed: %s", e)
+        return []
+
+    refs = _collect_refs(tree.root_node)
+    dead: list[dict] = []
+    _walk_defs(tree.root_node, refs, dead, min_name_len)
+    return dead
+
+
+# ── Python ─────────────────────────────────────────────────────────────────────
+
+
+def _find_dead_python(content: str, min_name_len: int) -> list[dict]:
+    try:
+        tree = _py_ast.parse(content)
+    except SyntaxError:
+        return []
+
+    def_lines: dict[str, int] = {}
+    for node in tree.body:
+        if isinstance(node, (_py_ast.FunctionDef, _py_ast.AsyncFunctionDef, _py_ast.ClassDef)):
+            if len(node.name) >= min_name_len and node.name not in _ENTRY_NAMES:
+                def_lines[node.name] = node.lineno
+
+    if not def_lines:
+        return []
+
+    ref_lines: dict[str, set[int]] = {}
+    for node in _py_ast.walk(tree):
+        if isinstance(node, _py_ast.Name):
+            ref_lines.setdefault(node.id, set()).add(getattr(node, "lineno", 0))
+
+    dead: list[dict] = []
+    for name, def_line in def_lines.items():
+        occurrences = ref_lines.get(name, set())
+        used = any(ln != def_line for ln in occurrences)
+        if not used:
+            dead.append(
+                {"name": name, "line": def_line, "kind": "function_or_class", "file_scope": True}
+            )
+    return dead
+
+
+# ── Tree-sitter (all other languages) ─────────────────────────────────────────
+
+
+def _collect_refs(node) -> dict[str, set[int]]:
+    """Map every identifier-like text to the set of lines it appears on."""
+    refs: dict[str, set[int]] = {}
+    stack = [node]
+    while stack:
+        cur = stack.pop()
+        if cur.type in _REF_NODE_TYPES:
+            text = cur.text.decode("utf-8", errors="replace")
+            if text:
+                refs.setdefault(text, set()).add(cur.start_point[0] + 1)
+        stack.extend(cur.children)
+    return refs
+
+
+def _def_name(node) -> str | None:
+    nf = child_by_field(node, "name")
+    if nf is not None:
+        return node_text(nf).strip()
+    # variable / const declarations carry a declarator with a `name` field
+    if node.type in ("lexical_declaration", "variable_declaration", "const_declaration"):
+        for child in node.children:
+            if child.type in ("variable_declarator", "declarator", "pair"):
+                name_node = child_by_field(child, "name")
+                if name_node is not None:
+                    return node_text(name_node).strip()
+    return None
+
+
+def _is_exported(line_text: str) -> bool:
+    stripped = line_text.lstrip()
+    return stripped.startswith("export") or " pub " in line_text or stripped.startswith("pub ")
+
+
+def _walk_defs(node, refs: dict[str, set[int]], dead: list[dict], min_name_len: int) -> None:
+    stack = [node]
+    while stack:
+        cur = stack.pop()
+        if cur.type in _DEF_NODE_TYPES:
+            name = _def_name(cur)
+            if name and len(name) >= min_name_len and name not in _ENTRY_NAMES:
+                line_no = cur.start_point[0] + 1
+                line_text = cur.text.decode("utf-8", errors="replace")
+                if _is_exported(line_text):
+                    stack.extend(cur.children)
+                    continue
+                occurrences = refs.get(name, set())
+                used = any(ln != line_no for ln in occurrences)
+                parent = cur.parent
+                file_scope = parent is not None and parent.type in _ROOT_CONTAINERS
+                if not used and file_scope:
+                    kind = "method" if cur.type == "method_definition" else cur.type
+                    dead.append({"name": name, "line": line_no, "kind": kind, "file_scope": True})
+            stack.extend(cur.children)
+        else:
+            stack.extend(cur.children)
+
+
+__all__ = ["find_dead_symbols"]

patchi/core/brain/ast_utils/decorators.py

@@ -0,0 +1,108 @@
+"""
+AST utilities — decorator/annotation finding across languages.
+"""
+
+from __future__ import annotations
+
+import ast as _py_ast
+import logging
+from typing import Any
+
+from patchi.core.brain.languages import Lang, get_parser
+
+from .config import DECORATOR_NODE_TYPES
+from .helpers import child_by_field, children, node_text
+
+_log = logging.getLogger("patchi.brain.decorators")
+
+
+def find_decorators(content: str, lang: Lang, names: set[str]) -> list[dict]:
+    """
+    Find all decorators/annotations matching one of `names`.
+    Returns list of dicts with keys: name, line, full_text.
+    """
+    if lang == Lang.PYTHON:
+        return _find_decorators_python(content, names)
+    parser = get_parser(lang)
+    if not parser:
+        return []
+    try:
+        tree = parser.parse(content.encode("utf-8"))
+    except Exception as e:
+        _log.warning("find_decorators failed: %s", e)
+        return []
+    dec_types = DECORATOR_NODE_TYPES.get(lang, set())
+    results: list[dict] = []
+    _walk_decorators(tree.root_node, dec_types, names, results)
+    return results
+
+
+def _find_decorators_python(content: str, names: set[str]) -> list[dict]:
+    results: list[dict] = []
+    try:
+        tree = _py_ast.parse(content)
+    except SyntaxError:
+        return results
+    for node in _py_ast.walk(tree):
+        if isinstance(node, (_py_ast.FunctionDef, _py_ast.AsyncFunctionDef, _py_ast.ClassDef)):
+            for dec in node.decorator_list:
+                dec_name = _py_decorator_name(dec)
+                if dec_name in names:
+                    results.append(
+                        {
+                            "name": dec_name,
+                            "line": getattr(dec, "lineno", getattr(node, "lineno", 0)),
+                            "full_text": _ast_text(dec, content) if content else "",
+                        }
+                    )
+    return results
+
+
+def _ast_text(node: _py_ast.AST, source: str) -> str:
+    try:
+        lines = source.splitlines()
+        start = getattr(node, "lineno", 1) - 1
+        end = getattr(node, "end_lineno", start + 1) - 1
+        return "\n".join(lines[start : end + 1])
+    except Exception as e:
+        _log.debug("_ast_text failed: %s", e)
+        return ""
+
+
+def _py_decorator_name(node: _py_ast.AST) -> str:
+    if isinstance(node, _py_ast.Name):
+        return node.id
+    if isinstance(node, _py_ast.Attribute):
+        return node.attr
+    if isinstance(node, _py_ast.Call):
+        return _py_decorator_name(node.func)
+    return ""
+
+
+def _walk_decorators(node: Any, dec_types: set[str], names: set[str], results: list[dict]) -> None:
+    try:
+        ntype = node.type if hasattr(node, "type") else ""
+    except Exception as e:
+        _log.warning("_walk_decorators failed: %s", e)
+        return
+
+    if ntype in dec_types:
+        name_node = child_by_field(node, "name") or child_by_field(node, "type")
+        if name_node:
+            dec_name = node_text(name_node)
+            if any(n in dec_name.lower() for n in names):
+                try:
+                    line = node.start_point[0] + 1 if node.start_point else 0
+                except Exception as e:
+                    _log.warning("_walk_decorators failed: %s", e)
+                    line = 0
+                results.append(
+                    {
+                        "name": dec_name,
+                        "line": line,
+                        "full_text": node_text(node),
+                    }
+                )
+
+    for child in children(node):
+        _walk_decorators(child, dec_types, names, results)