patchi 0.7.5__py3-none-any.whl

patchi/core/brain/ast_utils/helpers.py

@@ -0,0 +1,144 @@
+"""
+AST utilities — generic tree-sitter node helpers.
+"""
+
+from __future__ import annotations
+
+import ast as _py_ast
+import logging
+from typing import Any
+
+from patchi.core.brain.languages import Lang, get_parser
+
+_log = logging.getLogger("patchi.brain.helpers")
+
+
+def _py_call_name(node: _py_ast.Call) -> str:
+    """Full dotted name of a Python ``Call`` node's function.
+
+    Single source of truth shared by ``calls.find_calls`` and the cached
+    single-pass scan (``scan.scan_python``) so name resolution can never
+    drift between the two.
+    """
+    if isinstance(node.func, _py_ast.Name):
+        return node.func.id
+    if isinstance(node.func, _py_ast.Attribute):
+        parts = []
+        cur = node.func
+        while isinstance(cur, _py_ast.Attribute):
+            parts.append(cur.attr)
+            cur = cur.value
+        if isinstance(cur, _py_ast.Name):
+            parts.append(cur.id)
+        return ".".join(reversed(parts))
+    return ""
+
+
+def _py_assign_target_name(node: _py_ast.AST) -> str:
+    """Dotted name of a Python assignment target.
+
+    Single source of truth shared by ``assignments.find_assignments`` and the
+    cached single-pass scan.
+    """
+    if isinstance(node, _py_ast.Name):
+        return node.id
+    if isinstance(node, _py_ast.Attribute):
+        parts = []
+        cur = node
+        while isinstance(cur, _py_ast.Attribute):
+            parts.append(cur.attr)
+            cur = cur.value
+        if isinstance(cur, _py_ast.Name):
+            parts.append(cur.id)
+        return ".".join(reversed(parts))
+    return ""
+
+
+def parse_source(content: str, lang: Lang) -> Any | None:
+    """Parse `content` with the tree-sitter parser for `lang`.
+
+    Returns the parse tree (with `.root_node`) or None if no parser is
+    available or parsing fails. All languages use tree-sitter so callers
+    can walk a uniform node interface.
+    """
+    parser = get_parser(lang)
+    if not parser:
+        return None
+    try:
+        return parser.parse(content.encode("utf-8"))
+    except Exception as e:
+        _log.debug("parse_source failed: %s", e)
+        return None
+
+
+def node_text(node: Any) -> str:
+    try:
+        raw = getattr(node, "text", b"")
+        if isinstance(raw, bytes):
+            return raw.decode("utf-8", errors="replace")
+        return str(raw)
+    except Exception as e:
+        _log.debug("node_text failed: %s", e)
+        return ""
+
+
+def child_by_field(node: Any, field: str) -> Any | None:
+    if hasattr(node, "child_by_field_name"):
+        return node.child_by_field_name(field)
+    return None
+
+
+def children(node: Any) -> list[Any]:
+    try:
+        return list(node.children) if hasattr(node, "children") else []
+    except Exception as e:
+        _log.debug("children failed: %s", e)
+        return []
+
+
+def named_children(node: Any) -> list[Any]:
+    try:
+        return list(node.named_children) if hasattr(node, "named_children") else []
+    except Exception as e:
+        _log.debug("named_children failed: %s", e)
+        return []
+
+
+def _leaf_name(fn: str) -> str:
+    """Extract the leaf symbol from a possibly dotted / scoped name.
+
+    Handles both `.` (Python, JS, Java) and `::` (Rust, C++) separators.
+    """
+    for sep in (".", "::"):
+        if sep in fn:
+            return fn.split(sep)[-1]
+    return fn
+
+
+def get_call_arg(call_full_text: str, position: int = 0) -> str:
+    """Extract the positional argument at `position` from a call text."""
+    try:
+        paren = call_full_text.index("(")
+        rest = call_full_text[paren + 1 :]
+        depth = 0
+        arg_start = 0
+        arg_idx = 0
+        for i, ch in enumerate(rest):
+            if ch in ("(", "[", "{"):
+                depth += 1
+            elif ch in (")", "]", "}"):
+                depth -= 1
+                if depth < 0:
+                    if arg_idx == position:
+                        return rest[arg_start:i].strip()
+                    break
+            elif ch == "," and depth == 0:
+                if arg_idx == position:
+                    return rest[arg_start:i].strip()
+                arg_start = i + 1
+                arg_idx += 1
+        if arg_idx == position:
+            return rest[arg_start:].strip().rstrip(")")
+    except (ValueError, IndexError):
+        pass
+    return ""

patchi/core/brain/ast_utils/imports.py

@@ -0,0 +1,169 @@
+"""
+AST utilities — import statement 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 IMPORT_NODE_TYPES
+from .helpers import child_by_field, children, node_text
+
+_log = logging.getLogger("patchi.brain.imports")
+
+
+def find_imports(content: str, lang: Lang, names: set[str]) -> list[dict]:
+    """
+    Find all import statements matching one of `names`.
+    Returns list of dicts with keys: name, line, full_text.
+    """
+    if lang == Lang.PYTHON:
+        return _find_imports_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_imports failed: %s", e)
+        return []
+    import_types = IMPORT_NODE_TYPES.get(lang, set())
+    results: list[dict] = []
+    _walk_imports(tree.root_node, import_types, names, results, lang)
+    return results
+
+
+def _find_imports_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.Import):
+            for alias in node.names:
+                if alias.name in names:
+                    results.append(
+                        {
+                            "name": alias.name,
+                            "line": getattr(node, "lineno", 0),
+                            "full_text": _ast_text(node, content),
+                        }
+                    )
+        elif isinstance(node, _py_ast.ImportFrom):
+            if node.module and node.module in names:
+                results.append(
+                    {
+                        "name": node.module,
+                        "line": getattr(node, "lineno", 0),
+                        "full_text": _ast_text(node, content),
+                    }
+                )
+    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 _walk_imports(
+    node: Any, import_types: set[str], names: set[str], results: list[dict], lang: Lang
+) -> None:
+    try:
+        ntype = node.type if hasattr(node, "type") else ""
+    except Exception as e:
+        _log.warning("_walk_imports failed: %s", e)
+        return
+
+    if ntype in import_types:
+        imp_name = _extract_import_name(node, lang)
+        if imp_name and any(n in imp_name for n in names):
+            try:
+                line = node.start_point[0] + 1 if node.start_point else 0
+            except Exception as e:
+                _log.warning("_walk_imports failed: %s", e)
+                line = 0
+            results.append(
+                {
+                    "name": imp_name,
+                    "line": line,
+                    "full_text": node_text(node),
+                }
+            )
+
+    for child in children(node):
+        _walk_imports(child, import_types, names, results, lang)
+
+
+def _extract_import_name(node: Any, lang: Lang) -> str:
+    if lang in (Lang.JAVASCRIPT, Lang.TYPESCRIPT):
+        source = child_by_field(node, "source")
+        if source:
+            return node_text(source).strip("\"'")
+        return ""
+    if lang in (Lang.RUST, Lang.JAVA, Lang.GO, Lang.SWIFT, Lang.C_SHARP, Lang.KOTLIN, Lang.DART):
+        # Try named fields first
+        src = (
+            child_by_field(node, "source")
+            or child_by_field(node, "name")
+            or child_by_field(node, "alias")
+        )
+        if src:
+            return node_text(src).strip("\"'<>")
+        # Walk children for identifier / scoped_identifier / string
+        for child in children(node):
+            ct = child.type
+            if ct == "scoped_identifier":
+                return node_text(child)
+            if ct in ("identifier", "name"):
+                return node_text(child)
+            if lang == Lang.GO and ct == "import_spec":
+                for c2 in children(child):
+                    if c2.type == "interpreted_string_literal":
+                        return node_text(c2).strip('"')
+            if lang in (Lang.C_SHARP,) and ct == "string_literal":
+                return node_text(child).strip("\"'")
+            if lang == Lang.C_SHARP and ct == "alias_qualified_name":
+                for c2 in children(child):
+                    if c2.type == "identifier":
+                        return node_text(c2)
+        return ""
+    if lang in (Lang.C, Lang.CPP):
+        for child in children(node):
+            if child.type == "string_literal":
+                return node_text(child).strip('"<>')
+        return ""
+    if lang == Lang.RUBY:
+        for child in children(node):
+            if child.type in ("string", "simple_symbol"):
+                return node_text(child).strip("\"':")
+            if child.type == "argument_list":
+                for c2 in children(child):
+                    if c2.type in ("string", "simple_symbol"):
+                        return node_text(c2).strip("\"':")
+        return ""
+    if lang == Lang.PHP:
+        name_node = child_by_field(node, "name")
+        if name_node:
+            return node_text(name_node)
+        for child in children(node):
+            ct = child.type
+            if ct == "namespace_use_clause":
+                for c2 in children(child):
+                    if c2.type == "qualified_name":
+                        return node_text(c2)
+            if ct in ("namespace_name", "name", "qualified_name"):
+                return node_text(child)
+        return ""
+    return ""

patchi/core/brain/ast_utils/scan.py

@@ -0,0 +1,143 @@
+"""
+AST scanning utilities for Patchi.
+Provides tree-sitter based code scanning capabilities.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _slice(node: Any, source: str) -> str:
+    """Extract source code slice for a tree-sitter node."""
+    try:
+        return source[node.start_byte : node.end_byte]
+    except Exception:
+        return ""
+
+
+def scan_python(
+    source: str,
+    file_path: Path,
+) -> dict[str, Any]:
+    """
+    Scan Python source code and extract structured information.
+
+    Returns a dictionary with:
+    - functions: list of function definitions
+    - classes: list of class definitions
+    - imports: list of imports
+    - calls: function/method calls
+    """
+    try:
+        import ast
+    except ImportError:
+        logger.warning("ast module not available")
+        return {"functions": [], "classes": [], "imports": [], "calls": []}
+
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        logger.warning(f"Syntax error in {file_path}: {e}")
+        return {"functions": [], "classes": [], "imports": [], "calls": []}
+
+    functions = []
+    classes = []
+    imports = []
+    calls = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            functions.append(
+                {
+                    "name": node.name,
+                    "line": node.lineno,
+                    "end_line": getattr(node, "end_lineno", node.lineno),
+                    "args": [a.arg for a in node.args.args],
+                    "returns": ast.unparse(node.returns) if node.returns else None,
+                }
+            )
+        elif isinstance(node, ast.ClassDef):
+            classes.append(
+                {
+                    "name": node.name,
+                    "line": node.lineno,
+                    "end_line": getattr(node, "end_lineno", node.lineno),
+                    "bases": [ast.unparse(b) for b in node.bases],
+                }
+            )
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append(
+                    {
+                        "name": alias.name,
+                        "alias": alias.asname,
+                        "line": node.lineno,
+                    }
+                )
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                imports.append(
+                    {
+                        "name": f"{node.module}.{alias.name}" if node.module else alias.name,
+                        "alias": alias.asname,
+                        "line": node.lineno,
+                    }
+                )
+        elif isinstance(node, ast.Call):
+            # Full dotted name via the shared helper (single source of truth
+            # with calls.find_calls) — leaf-only names broke deep dotted
+            # matching like a.b.c.execute().
+            from .helpers import _py_call_name
+
+            func_name = _py_call_name(node)
+            calls.append(
+                {
+                    "function": func_name,
+                    "line": node.lineno,
+                }
+            )
+
+    return {
+        "functions": functions,
+        "classes": classes,
+        "imports": imports,
+        "calls": calls,
+    }
+
+
+def scan_generic(source: str, file_path: Path) -> dict[str, Any]:
+    """
+    Generic scanner for non-Python files.
+    Returns basic structural information.
+    """
+    return {
+        "functions": [],
+        "classes": [],
+        "imports": [],
+        "calls": [],
+    }
+
+
+def scan_file(file_path: Path) -> dict[str, Any]:
+    """
+    Scan a file and return structured information.
+    """
+    try:
+        source = file_path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as e:
+        logger.warning(f"Failed to read {file_path}: {e}")
+        return {"functions": [], "classes": [], "imports": [], "calls": []}
+
+    suffix = file_path.suffix.lower()
+    if suffix == ".py":
+        return scan_python(source, file_path)
+    else:
+        return scan_generic(source, file_path)
+
+
+def scan_python_file(file_path: Path) -> dict[str, Any]:
+    """Convenience function to scan a Python file."""
+    return scan_python(file_path.read_text(encoding="utf-8"), file_path)