patchi 0.7.5__py3-none-any.whl

patchi/core/brain/code_query.py

@@ -0,0 +1,710 @@
+"""
+Shared syntax queries over tree-sitter — the replacement for per-agent regex.
+
+Agents used to detect code constructs (setInterval calls, `var` declarations,
+JSX text, `require()` …) with regular expressions, which misfire on comments,
+strings, and formatting variants. These helpers parse once with tree-sitter
+(error-tolerant: partial trees still yield captures) and answer structural
+questions. All functions are fail-open: unparseable input returns empty
+collections, never raises.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+_log = logging.getLogger("patchi.brain.code_query")
+
+
+@dataclass
+class JsCall:
+    """A call site: property name, full dotted callee, line, args, span text."""
+
+    name: str
+    line: int
+    arg_kinds: list[str] = field(default_factory=list)
+    full: str = ""
+    text: str = ""
+
+
+def _parser(lang: str):
+    try:
+        if lang == "tsx":
+            import tree_sitter_typescript as tsts
+            from tree_sitter import Language, Parser
+
+            return Parser(Language(tsts.language_tsx()))
+        from patchi.core.brain.languages import Lang, get_parser
+
+        return get_parser(Lang(lang))
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("code_query parser unavailable: %s", exc)
+        return None
+
+
+def _query_text(lang_obj, pattern: str, node):
+    from tree_sitter import Query, QueryCursor
+
+    try:
+        return QueryCursor(Query(lang_obj, pattern)).captures(node)
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("code_query pattern failed %r: %s", pattern, exc)
+        return {}
+
+
+def _lang_obj(lang: str):
+    from tree_sitter import Language
+
+    if lang == "typescript":
+        import tree_sitter_typescript as tsts
+
+        return Language(tsts.language_typescript())
+    if lang == "tsx":
+        import tree_sitter_typescript as tsts
+
+        return Language(tsts.language_tsx())
+    import tree_sitter_javascript as tsjs
+
+    return Language(tsjs.language())
+
+
+def lang_for_file(filename: str) -> str:
+    """Tree-sitter language key for a path (tsx needs its own grammar)."""
+    name = filename.lower()
+    if name.endswith(".tsx"):
+        return "tsx"
+    if name.endswith((".ts", ".mts", ".cts")):
+        return "typescript"
+    return "javascript"
+
+
+def _node_text(node) -> str:
+    t = node.text
+    if isinstance(t, bytes):
+        return t.decode("utf-8", errors="replace")
+    return str(t)
+
+
+def _line(node) -> int:
+    return node.start_point[0] + 1
+
+
+def parse_js(text: str, lang: str = "javascript"):
+    """Parse JS/JSX/TS/TSX source. Returns the tree or None (fail-open)."""
+    parser = _parser(lang)
+    if parser is None:
+        return None
+    try:
+        return parser.parse(text.encode("utf-8", errors="replace"))
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("code_query parse failed: %s", exc)
+        return None
+
+
+def _callee_name(call_node) -> str:
+    fn = call_node.child_by_field_name("function")
+    if fn is None:
+        return ""
+    if fn.type == "identifier":
+        return _node_text(fn)
+    if fn.type == "member_expression":
+        prop = fn.child_by_field_name("property")
+        if prop is not None:
+            return _node_text(prop)
+        text = _node_text(fn)
+        return text.rsplit(".", 1)[-1] if "." in text else text
+    return ""
+
+
+def js_calls(tree, lang: str = "javascript") -> list[JsCall]:
+    """Every call site with callee name, full dotted path, line, arg kinds."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[JsCall] = []
+    for nodes in _query_text(lang_obj, "(call_expression) @c", tree.root_node).values():
+        for node in nodes:
+            args = node.child_by_field_name("arguments")
+            kinds = [c.type for c in args.named_children] if args is not None else []
+            fn = node.child_by_field_name("function")
+            full = _node_text(fn) if fn is not None else ""
+            out.append(
+                JsCall(
+                    name=_callee_name(node),
+                    line=_line(node),
+                    arg_kinds=kinds,
+                    full=full,
+                    text=_node_text(node),
+                )
+            )
+    return out
+
+
+def js_useeffect_without_cleanup(tree, lang: str = "javascript") -> list[int]:
+    """Lines of useEffect calls whose callback has no return statement."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[int] = []
+    for nodes in _query_text(lang_obj, "(call_expression) @c", tree.root_node).values():
+        for node in nodes:
+            if _callee_name(node) != "useEffect":
+                continue
+            args = node.child_by_field_name("arguments")
+            if args is None:
+                continue
+            has_return = False
+            for arg in args.named_children:
+                if arg.type in ("arrow_function", "function_expression", "function"):
+                    ret = _query_text(lang_obj, "(return_statement) @r", arg)
+                    if any(ret.values()):
+                        has_return = True
+                        break
+            if not has_return:
+                out.append(_line(node))
+    return out
+
+
+def js_call_names(tree, lang: str = "javascript") -> set[str]:
+    """Set of callee names called anywhere in the file."""
+    return {c.name for c in js_calls(tree, lang) if c.name}
+
+
+def js_var_kinds(tree, lang: str = "javascript") -> list[tuple[str, int]]:
+    """(kind, line) for every var/let/const declaration."""
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, int]] = []
+    if tree is None:
+        return []
+    found = _query_text(
+        lang_obj, "[(variable_declaration) (lexical_declaration)] @d", tree.root_node
+    )
+    for nodes in found.values():
+        for node in nodes:
+            text = _node_text(node).lstrip()
+            kind = text.split(None, 1)[0] if text else ""
+            if kind in ("var", "let", "const"):
+                out.append((kind, _line(node)))
+    return out
+
+
+def js_has_await(tree, lang: str = "javascript") -> bool:
+    if tree is None:
+        return False
+    lang_obj = _lang_obj(lang)
+    return bool(_query_text(lang_obj, "(await_expression) @a", tree.root_node))
+
+
+def js_new_names(tree, lang: str = "javascript") -> set[str]:
+    """Constructor names from `new X(...)` expressions."""
+    lang_obj = _lang_obj(lang)
+    out: set[str] = set()
+    found = _query_text(lang_obj, "(new_expression constructor: (_) @c)", tree.root_node)
+    for nodes in found.values():
+        for node in nodes:
+            out.add(_node_text(node))
+    return out
+
+
+def js_jsx_texts(tree, lang: str = "javascript") -> list[tuple[str, int]]:
+    """Visible JSX text fragments with lines."""
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, int]] = []
+    for nodes in _query_text(lang_obj, "(jsx_text) @t", tree.root_node).values():
+        for node in nodes:
+            text = _node_text(node).strip()
+            if text:
+                out.append((text, _line(node)))
+    return out
+
+
+def js_class_heritages(tree, lang: str = "javascript") -> list[tuple[str, int]]:
+    """`extends ...` clause text with lines."""
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, int]] = []
+    for nodes in _query_text(lang_obj, "(class_heritage) @h", tree.root_node).values():
+        for node in nodes:
+            out.append((_node_text(node), _line(node)))
+    return out
+
+
+def js_identifiers(tree, lang: str = "javascript") -> set[str]:
+    """All identifier spellings (for $store-style prefix checks)."""
+    return {text for text, _line_no in js_identifier_lines(tree, lang)}
+
+
+def js_property_names(tree, lang: str = "javascript") -> set[str]:
+    """Object/dict key spellings (property_identifier nodes)."""
+    if tree is None:
+        return set()
+    lang_obj = _lang_obj(lang)
+    out: set[str] = set()
+    for nodes in _query_text(lang_obj, "(property_identifier) @p", tree.root_node).values():
+        for node in nodes:
+            out.add(_node_text(node))
+    return out
+
+
+def js_identifier_lines(tree, lang: str = "javascript") -> list[tuple[str, int]]:
+    """(identifier spelling, line) pairs."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, int]] = []
+    for nodes in _query_text(lang_obj, "(identifier) @i", tree.root_node).values():
+        for node in nodes:
+            out.append((_node_text(node), _line(node)))
+    return out
+
+
+def js_constructor_di_line(tree, lang: str = "javascript") -> int:
+    """Line of a constructor() with a private/parameter-property param, else 0."""
+    if tree is None:
+        return 0
+    lang_obj = _lang_obj(lang)
+    found = _query_text(lang_obj, "(method_definition) @m", tree.root_node)
+    for nodes in found.values():
+        for node in nodes:
+            name_node = node.child_by_field_name("name")
+            if name_node is None or _node_text(name_node) != "constructor":
+                continue
+            params = node.child_by_field_name("parameters")
+            if params is not None and "private" in _node_text(params):
+                return _line(node)
+    return 0
+
+
+def js_string_literals(tree, lang: str = "javascript") -> list[tuple[str, int]]:
+    """String literal contents with lines (quotes stripped)."""
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, int]] = []
+    for nodes in _query_text(lang_obj, "(string) @s", tree.root_node).values():
+        for node in nodes:
+            text = _node_text(node)
+            if len(text) >= 2 and text[0] == text[-1] and text[0] in "\"'`":
+                text = text[1:-1]
+            out.append((text, _line(node)))
+    return out
+
+
+def js_has_try(tree, lang: str = "javascript") -> bool:
+    if tree is None:
+        return False
+    lang_obj = _lang_obj(lang)
+    return bool(_query_text(lang_obj, "(try_statement) @t", tree.root_node))
+
+
+def _catch_in_subtree(lang_obj, node) -> bool:
+    sub = _query_text(lang_obj, "(call_expression) @c", node)
+    return any(_callee_name(n) == "catch" for ns in sub.values() for n in ns)
+
+
+def _assigned_name(stmt) -> str:
+    if stmt.type == "variable_declarator":
+        name_node = stmt.child_by_field_name("name")
+        if name_node is not None:
+            return _node_text(name_node)
+    return ""
+
+
+def js_new_without_catch(tree, names=("Promise",), lang: str = "javascript") -> list[int]:
+    """Lines of `new X(...)` with no `.catch` — same statement or later `v.catch`."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[int] = []
+    for nodes in _query_text(lang_obj, "(new_expression) @n", tree.root_node).values():
+        for node in nodes:
+            ctor = node.child_by_field_name("constructor")
+            cname = _node_text(ctor) if ctor is not None else ""
+            if cname not in names:
+                continue
+            stmt = node
+            var_name = ""
+            while stmt.parent is not None and stmt.type not in (
+                "expression_statement",
+                "variable_declaration",
+                "lexical_declaration",
+                "return_statement",
+            ):
+                if stmt.type == "variable_declarator" and not var_name:
+                    var_name = _assigned_name(stmt)
+                stmt = stmt.parent
+            if _catch_in_subtree(lang_obj, stmt):
+                continue
+            if var_name:
+                parent = stmt.parent
+                if parent is not None:
+                    kids = parent.named_children
+                    try:
+                        idx = kids.index(stmt)
+                    except ValueError:
+                        idx = -1
+                    handled = False
+                    for sib in kids[idx + 1 :]:
+                        sib_calls = _query_text(lang_obj, "(call_expression) @c", sib)
+                        for ns in sib_calls.values():
+                            for n in ns:
+                                fn = n.child_by_field_name("function")
+                                if (
+                                    fn is not None
+                                    and fn.type == "member_expression"
+                                    and _node_text(fn).startswith(var_name + ".")
+                                    and _callee_name(n) == "catch"
+                                ):
+                                    handled = True
+                                    break
+                            if handled:
+                                break
+                        if handled:
+                            break
+                    if handled:
+                        continue
+            out.append(_line(node))
+    return out
+
+
+def js_jsx_elements(tree, lang: str = "javascript") -> list[tuple[str, int]]:
+    """(tag, line) for every JSX opening element."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, int]] = []
+    found = _query_text(lang_obj, "(jsx_opening_element) @o", tree.root_node)
+    for nodes in found.values():
+        for node in nodes:
+            for child in node.named_children:
+                if child.type == "identifier":
+                    out.append((_node_text(child), _line(node)))
+                    break
+    return out
+
+
+def js_jsx_attributes(tree, lang: str = "javascript") -> list[tuple[str, str, int]]:
+    """(tag, attribute_name, line) for every JSX attribute."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, str, int]] = []
+    found = _query_text(lang_obj, "(jsx_opening_element) @o", tree.root_node)
+    for nodes in found.values():
+        for node in nodes:
+            tag = ""
+            for child in node.named_children:
+                if child.type == "identifier":
+                    tag = _node_text(child)
+                    break
+            for child in node.named_children:
+                if child.type == "jsx_attribute":
+                    name_node = child.child_by_field_name("name")
+                    if name_node is None and child.named_children:
+                        name_node = child.named_children[0]
+                    if name_node is not None:
+                        out.append((tag, _node_text(name_node), _line(child)))
+    return out
+
+
+def extract_script_blocks(text: str) -> list[str]:
+    """Raw JS from <script> blocks in SFC/HTML (for .vue/.svelte parsing)."""
+    from html.parser import HTMLParser
+
+    out: list[str] = []
+    current: list[str] | None = None
+
+    class _P(HTMLParser):
+        def handle_starttag(self, tag, attrs):
+            nonlocal current
+            if tag == "script":
+                current = []
+
+        def handle_endtag(self, tag):
+            nonlocal current
+            if tag == "script" and current is not None:
+                out.append("".join(current))
+                current = None
+
+        def handle_data(self, data):
+            if current is not None:
+                current.append(data)
+
+    try:
+        _P().feed(text)
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("script extract failed: %s", exc)
+    return out
+
+
+def vue_template_texts(text: str) -> list[tuple[str, int]]:
+    """Visible text nodes from Vue/SFC/HTML markup via html.parser."""
+    from html.parser import HTMLParser
+
+    out: list[tuple[str, int]] = []
+
+    class _P(HTMLParser):
+        def handle_data(self, data):
+            rest, chunks = data, []
+            while "{{" in rest and "}}" in rest:
+                before, _, rest = rest.partition("{{")
+                chunks.append(before)
+                _, _, rest = rest.partition("}}")
+            chunks.append(rest)
+            stripped = " ".join(chunks).strip()
+            if stripped:
+                line, _ = self.getpos()
+                out.append((stripped, line))
+
+    try:
+        _P().feed(text)
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("template text parse failed: %s", exc)
+    return out
+
+
+def string_literals(text: str, lang) -> list[tuple[str, int]]:
+    """(unquoted value, 1-based line) for string/symbol literals, any grammar.
+
+    Tries common string node types so one helper serves every installed
+    tree-sitter grammar. Fail-open: [] when the grammar is missing.
+    """
+    from tree_sitter import Query, QueryCursor
+
+    try:
+        from patchi.core.brain.languages import get_parser
+
+        parser = get_parser(lang)
+    except Exception:
+        return []
+    if parser is None:
+        return []
+    try:
+        tree = parser.parse(text.encode("utf-8", errors="replace"))
+    except Exception:
+        return []
+    try:
+        language = tree.language
+    except Exception:
+        return []
+    seen: set[tuple[str, int]] = set()
+    out: list[tuple[str, int]] = []
+    patterns = (
+        "(string) @s",
+        "(string_literal) @s",
+        "(interpreted_string_literal) @s",
+        "(raw_string_literal) @s",
+        "(encapsed_string) @s",
+        "(symbol) @s",
+    )
+    for pattern in patterns:
+        try:
+            found = QueryCursor(Query(language, pattern)).captures(tree.root_node)
+        except Exception:
+            continue
+        for nodes in found.values():
+            for node in nodes:
+                raw = _node_text(node)
+                val = raw.strip()
+                if len(val) >= 2 and val[0] == val[-1] and val[0] in "\"'`":
+                    val = val[1:-1]
+                val = val.lstrip(":")
+                if val:
+                    key = (val, _line(node))
+                    if key not in seen:
+                        seen.add(key)
+                        out.append(key)
+    return out
+
+
+def js_string_pairs(tree, lang: str = "javascript") -> list[tuple[str, str, int]]:
+    """(key, value, line) for object properties with string values."""
+    if tree is None:
+        return []
+    lang_obj = _lang_obj(lang)
+    out: list[tuple[str, str, int]] = []
+    for nodes in _query_text(lang_obj, "(pair) @p", tree.root_node).values():
+        for node in nodes:
+            key_node = node.child_by_field_name("key")
+            val_node = node.child_by_field_name("value")
+            if key_node is None or val_node is None:
+                continue
+            key = _node_text(key_node).strip("\"'`")
+            val = _node_text(val_node).strip()
+            if len(val) >= 2 and val[0] == val[-1] and val[0] in "\"'`":
+                val = val[1:-1]
+            out.append((key, val, _line(node)))
+    return out
+
+
+def member_paths(text: str, lang) -> list[tuple[str, int]]:
+    """(dotted member-access text, line) for attribute/subscript/member nodes.
+
+    `lang` is a languages.Lang enum member. Tries member-ish node types across
+    grammars (member_expression, attribute, subscript_expression, ...),
+    skipping types the grammar lacks. Fail-open: [] when unparseable.
+    """
+    from tree_sitter import Query, QueryCursor
+
+    try:
+        from patchi.core.brain.languages import get_parser
+
+        parser = get_parser(lang)
+    except Exception:
+        return []
+    if parser is None:
+        return []
+    try:
+        tree = parser.parse(text.encode("utf-8", errors="replace"))
+        language = tree.language
+    except Exception:
+        return []
+    seen: set[tuple[str, int]] = set()
+    out: list[tuple[str, int]] = []
+    for node_type in (
+        "member_expression",
+        "attribute",
+        "subscript_expression",
+        "member_access_expression",
+        "scoped_identifier",
+        "field_expression",
+    ):
+        try:
+            found = QueryCursor(Query(language, f"({node_type}) @m")).captures(
+                tree.root_node
+            )
+        except Exception:
+            continue
+        for nodes in found.values():
+            for node in nodes:
+                text_val = _node_text(node)
+                # Skip bare identifiers and call-covered nodes; keep dotted paths
+                if "." not in text_val and "[" not in text_val:
+                    continue
+                key = (text_val, _line(node))
+                if key not in seen:
+                    seen.add(key)
+                    out.append(key)
+    return out
+
+
+def calls_with_dynamic_arg(text: str, lang, names: set[str]) -> list[int]:
+    """Lines of calls to `names` whose arguments build strings dynamically.
+
+    Python: +/% BinOp, f-strings, .format() in call args (stdlib ast).
+    JS/TS: binary_expression / template_string in call args (tree-sitter).
+    `lang` is a languages.Lang enum member. Fail-open: [].
+    """
+    import ast as _ast
+
+    try:
+        from patchi.core.brain.languages import Lang
+    except Exception:
+        return []
+    wanted = {n.split(".")[-1] for n in names} | set(names)
+    if lang == Lang.PYTHON:
+        try:
+            tree = _ast.parse(text)
+        except SyntaxError:
+            return []
+        out: list[int] = []
+        for node in _ast.walk(tree):
+            if not isinstance(node, _ast.Call):
+                continue
+            func = node.func
+            if isinstance(func, _ast.Name):
+                dotted = func.id
+            elif isinstance(func, _ast.Attribute):
+                parts, cur = [], func
+                while isinstance(cur, _ast.Attribute):
+                    parts.append(cur.attr)
+                    cur = cur.value
+                if isinstance(cur, _ast.Name):
+                    parts.append(cur.id)
+                dotted = ".".join(reversed(parts))
+            else:
+                continue
+            if dotted not in names and dotted.split(".")[-1] not in wanted:
+                continue
+            dynamic = False
+            for arg in list(node.args) + [kw.value for kw in node.keywords]:
+                for sub in _ast.walk(arg):
+                    if isinstance(sub, (_ast.BinOp, _ast.JoinedStr)):
+                        dynamic = True
+                        break
+                    if isinstance(sub, _ast.Call):
+                        f = sub.func
+                        fn = f.id if isinstance(f, _ast.Name) else getattr(f, "attr", "")
+                        if fn == "format":
+                            dynamic = True
+                            break
+                if dynamic:
+                    break
+            if dynamic:
+                out.append(getattr(node, "lineno", 0))
+        return sorted(set(out))
+    # tree-sitter languages: dynamic = binary/template args in the call span
+    try:
+        from patchi.core.brain.languages import get_parser
+
+        parser = get_parser(lang)
+    except Exception:
+        return []
+    if parser is None:
+        return []
+    try:
+        parsed = parser.parse(text.encode("utf-8", errors="replace"))
+        language = parsed.language
+    except Exception:
+        return []
+    from tree_sitter import Query, QueryCursor
+
+    out = []
+    try:
+        found = QueryCursor(
+            Query(language, "(call_expression) @c")
+        ).captures(parsed.root_node)
+    except Exception:
+        return []
+    for nodes in found.values():
+        for node in nodes:
+            fn = node.child_by_field_name("function")
+            dotted = _node_text(fn) if fn is not None else ""
+            if dotted not in names and dotted.split(".")[-1] not in wanted:
+                continue
+            args = node.child_by_field_name("arguments")
+            if args is None:
+                continue
+            try:
+                dyn = QueryCursor(
+                    Query(
+                        language,
+                        "[(binary_expression) (template_string) (template_substitution)] @d",
+                    )
+                ).captures(args)
+            except Exception:
+                continue
+            if any(dyn.values()):
+                out.append(_line(node))
+    return sorted(set(out))
+
+
+def vue_template_attrs(text: str) -> list[tuple[str, str, int]]:
+    """(tag, attr_name, line) from Vue/SFC template markup via html.parser.
+
+    tree-sitter-javascript cannot parse HTML templates; the stdlib HTML parser
+    reads real tag structure instead of regexing angle brackets.
+    """
+    from html.parser import HTMLParser
+
+    out: list[tuple[str, str, int]] = []
+
+    class _P(HTMLParser):
+        def handle_starttag(self, tag, attrs):
+            line, _ = self.getpos()
+            for name, _value in attrs:
+                out.append((tag, name, line))
+
+    try:
+        _P().feed(text)
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("vue template parse failed: %s", exc)
+    return out