patchi 0.7.5__py3-none-any.whl

patchi/core/brain/route_detector/go.py

@@ -0,0 +1,152 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_GO_HTTP_METHODS = {"get", "post", "put", "delete", "patch", "head", "options"}
+
+_GIN_PATTERNS = {"r", "router", "engine"}
+_ECHO_PATTERNS = {"e", "echo"}
+_FIBER_PATTERNS = {"app"}
+
+_FRAMEWORK_MAP: list[tuple[set[str], str]] = [
+    (_GIN_PATTERNS, "Gin"),
+    (_ECHO_PATTERNS, "Echo"),
+    (_FIBER_PATTERNS, "Fiber"),
+]
+
+
+_log = logging.getLogger("patchi.brain.go")
+
+
+@register_detector("go")
+class GoRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes = self._detect_ts(content, file_path)
+        if routes:
+            return routes
+        return self._detect_fallback(content, file_path)
+
+    def _detect_ts(self, content: str, file_path: str) -> list[dict] | None:
+        try:
+            from patchi.core.brain.languages import Lang, _build_parser
+
+            parser = _build_parser(Lang.GO)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("GoRouteDetector._detect_ts failed: %s", e)
+            return None
+
+        routes: list[dict] = []
+        self._walk(tree.root_node, bytes(content, "utf-8"), content, file_path, routes)
+        return routes
+
+    def _walk(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        ntype = getattr(node, "type", "")
+        if ntype == "call_expression":
+            self._check_call(node, buf, content, file_path, routes)
+        for child in getattr(node, "named_children", None) or getattr(node, "children", []):
+            self._walk(child, buf, content, file_path, routes)
+
+    def _check_call(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        func = self._child_by_field(node, "function")
+        if func is None or getattr(func, "type", "") != "selector_expression":
+            return
+
+        operand = self._child_by_field(func, "operand")
+        field = self._child_by_field(func, "field")
+        if operand is None or field is None:
+            return
+
+        obj_name = self._node_text(operand).lower()
+        method_name = self._node_text(field).lower()
+
+        if method_name not in _GO_HTTP_METHODS:
+            return
+
+        framework = ""
+        for patterns, fw in _FRAMEWORK_MAP:
+            if obj_name in patterns:
+                framework = fw
+                break
+        if not framework:
+            return
+
+        args = self._child_by_field(node, "arguments")
+        path = ""
+        if args and getattr(args, "named_child_count", 0) > 0:
+            first = args.named_child(0)
+            if first and first.type in (
+                "interpreted_string_literal",
+                "raw_string_literal",
+                "string_literal",
+            ):
+                raw = self._node_text(first)
+                path = raw.strip('"`')
+
+        if not path:
+            return
+
+        handler = ""
+        if args and getattr(args, "named_child_count", 0) >= 2:
+            second = args.named_child(1)
+            if second and second.type == "identifier":
+                handler = self._node_text(second)
+
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+        routes.append(
+            self._make_route(
+                method_name.upper(), path, handler, file_path, line, framework=framework
+            )
+        )
+
+    def _child_by_field(self, node: object, field: str) -> object | None:
+        if hasattr(node, "child_by_field_name"):
+            return node.child_by_field_name(field)
+        return None
+
+    def _node_text(self, node: object) -> 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("GoRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        http = "|".join(m.upper() for m in _GO_HTTP_METHODS)
+        for patterns, framework in _FRAMEWORK_MAP:
+            for obj in patterns:
+                pat = re.compile(
+                    rf"""{re.escape(obj)}\.({http})\s*\(\s*["']([^"']+)["']""",
+                    re.IGNORECASE,
+                )
+                for i, line in enumerate(content.splitlines(), 1):
+                    m = pat.search(line)
+                    if not m:
+                        continue
+                    handler = ""
+                    hm = re.search(
+                        r""",\s*(\w+)\s*\)""", line[m.end() :] if m.end() < len(line) else line
+                    )
+                    if hm:
+                        handler = hm.group(1)
+                    routes.append(
+                        self._make_route(
+                            m.group(1).upper(),
+                            m.group(2),
+                            handler,
+                            file_path,
+                            i,
+                            framework=framework,
+                        )
+                    )
+        return routes

patchi/core/brain/route_detector/java.py

@@ -0,0 +1,195 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_SPRING_MAPPINGS = {
+    "getmapping": "GET",
+    "postmapping": "POST",
+    "putmapping": "PUT",
+    "deletemapping": "DELETE",
+    "patchmapping": "PATCH",
+    "requestmapping": "ANY",
+}
+_SPRING_AUTH_ANNOTATIONS = {"preauthorize", "secured", "rolesallowed"}
+
+
+_log = logging.getLogger("patchi.brain.java")
+
+
+@register_detector("java")
+class JavaRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes = self._detect_ts(content, file_path)
+        if routes:
+            return routes
+        return self._detect_fallback(content, file_path)
+
+    def _detect_ts(self, content: str, file_path: str) -> list[dict] | None:
+        try:
+            from patchi.core.brain.languages import Lang, _build_parser
+
+            parser = _build_parser(Lang.JAVA)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("JavaRouteDetector._detect_ts failed: %s", e)
+            return None
+
+        routes: list[dict] = []
+        self._walk(tree.root_node, bytes(content, "utf-8"), content, file_path, routes)
+        return routes
+
+    def _walk(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        ntype = getattr(node, "type", "")
+        if ntype in ("marker_annotation", "annotation"):
+            self._check_annotation(node, buf, content, file_path, routes)
+
+        for child in getattr(node, "named_children", None) or getattr(node, "children", []):
+            self._walk(child, buf, content, file_path, routes)
+
+    def _check_annotation(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        name_node = self._child_by_field(node, "name") or node
+        try:
+            ann_name = self._node_text(name_node).lower()
+        except Exception as e:
+            _log.warning("JavaRouteDetector._check_annotation failed: %s", e)
+            return
+
+        method = _SPRING_MAPPINGS.get(ann_name)
+        if method is None:
+            return
+
+        path = ""
+        args_node = self._child_by_field(node, "arguments")
+        if args_node:
+            try:
+                for child in getattr(args_node, "named_children", None) or getattr(
+                    args_node, "children", []
+                ):
+                    if child.type in ("string_literal", "string"):
+                        raw = self._node_text(child)
+                        path = raw.strip('"')
+                        break
+            except Exception as e:
+                _log.warning("JavaRouteDetector._check_annotation failed: %s", e)
+
+        if not path:
+            path = ""
+
+        handler = self._find_method_name(node)
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+
+        auth = self._check_auth_annotations(node)
+
+        routes.append(
+            self._make_route(
+                method,
+                path,
+                handler,
+                file_path,
+                line,
+                framework="Spring Boot",
+                auth_required=auth if auth else None,
+            )
+        )
+
+    def _find_method_name(self, node: object) -> str:
+        cur = node
+        for _ in range(10):
+            cur = getattr(cur, "parent", None)
+            if cur is None:
+                break
+            if getattr(cur, "type", "") == "method_declaration":
+                name_node = self._child_by_field(cur, "name")
+                if name_node:
+                    return self._node_text(name_node)
+        return ""
+
+    def _check_auth_annotations(self, node: object) -> bool:
+        cur = node
+        for _ in range(15):
+            cur = getattr(cur, "parent", None)
+            if cur is None:
+                break
+            if getattr(cur, "type", "") == "class_declaration":
+                for child in getattr(cur, "named_children", None) or getattr(cur, "children", []):
+                    if child.type in ("marker_annotation", "annotation"):
+                        try:
+                            name = self._node_text(
+                                self._child_by_field(child, "name") or child
+                            ).lower()
+                            if any(a in name for a in _SPRING_AUTH_ANNOTATIONS):
+                                return True
+                        except Exception as e:
+                            _log.warning("JavaRouteDetector._check_auth_annotations failed: %s", e)
+                break
+        for child in getattr(node, "named_children", None) or getattr(node, "children", []):
+            if child.type in ("marker_annotation", "annotation"):
+                try:
+                    name = self._node_text(self._child_by_field(child, "name") or child).lower()
+                    if name in _SPRING_AUTH_ANNOTATIONS:
+                        return True
+                except Exception as e:
+                    _log.warning("JavaRouteDetector._check_auth_annotations failed: %s", e)
+        return False
+
+    def _child_by_field(self, node: object, field: str) -> object | None:
+        if hasattr(node, "child_by_field_name"):
+            return node.child_by_field_name(field)
+        return None
+
+    def _node_text(self, node: object) -> 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("JavaRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        ann_names = "|".join(_SPRING_MAPPINGS)
+        pat = re.compile(
+            rf"""@({ann_names})\s*\(\s*["']([^"']+)["']""",
+            re.IGNORECASE,
+        )
+        auth_pat = re.compile(r"@PreAuthorize|@Secured|@RolesAllowed", re.IGNORECASE)
+
+        lines = content.splitlines()
+        for i, line in enumerate(lines, 1):
+            m = pat.search(line)
+            if not m:
+                continue
+            method_str = m.group(1).upper()
+            path = m.group(2)
+            method = "ANY" if method_str == "REQUESTMAPPING" else method_str.replace("MAPPING", "")
+
+            handler = ""
+            for j in range(i, min(i + 5, len(lines) + 1)):
+                hm = re.match(r"\s*(?:public\s+)?\w+\s+(\w+)\s*\(", lines[j - 1])
+                if hm:
+                    handler = hm.group(1)
+                    break
+
+            ctx = "\n".join(lines[i : min(i + 5, len(lines))])
+            auth = bool(auth_pat.search(ctx))
+
+            routes.append(
+                self._make_route(
+                    method,
+                    path,
+                    handler,
+                    file_path,
+                    i,
+                    framework="Spring Boot",
+                    auth_required=auth if auth else None,
+                )
+            )
+        return routes

patchi/core/brain/route_detector/javascript.py

@@ -0,0 +1,197 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_AUTH_MIDDLEWARE = {"auth", "authenticate", "requireauth", "verifytoken", "isauthenticated"}
+
+_EXPRESS_OBJECTS = {"app", "router", "route"}
+_FASTIFY_OBJECTS = {"fastify"}
+_HTTP_METHODS = {"get", "post", "put", "delete", "patch", "all", "use", "head", "options"}
+
+
+_log = logging.getLogger("patchi.brain.javascript")
+
+
+@register_detector("javascript")
+@register_detector("typescript")
+class JavaScriptRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes = self._detect_ts(content, file_path)
+        if routes:
+            return routes
+
+        routes = self._detect_ts_fallback(content, file_path)
+        return routes
+
+    def _detect_ts(self, content: str, file_path: str) -> list[dict] | None:
+        try:
+            from patchi.core.brain.languages import Lang, _build_parser
+
+            parser = _build_parser(Lang.TYPESCRIPT)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("JavaScriptRouteDetector._detect_ts failed: %s", e)
+            return None
+
+        routes: list[dict] = []
+        self._walk(tree.root_node, bytes(content, "utf-8"), content, file_path, routes)
+        return routes
+
+    def _walk(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        ntype = getattr(node, "type", "")
+        if ntype == "call_expression":
+            self._check_call(node, buf, content, file_path, routes)
+
+        for child in getattr(node, "named_children", None) or getattr(node, "children", []):
+            self._walk(child, buf, content, file_path, routes)
+
+    def _check_call(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        func = self._child_by_field(node, "function")
+        if func is None:
+            return
+
+        obj_name, method_name = self._get_member_expression(func)
+        if obj_name is None or method_name is None:
+            return
+
+        method_lower = method_name.lower()
+        if method_lower not in _HTTP_METHODS:
+            return
+
+        if obj_name in _EXPRESS_OBJECTS:
+            framework = "Express"
+        elif obj_name in _FASTIFY_OBJECTS:
+            framework = "Fastify"
+        else:
+            return
+
+        args = self._child_by_field(node, "arguments")
+        path = ""
+        if args and getattr(args, "named_child_count", 0) > 0:
+            first_arg = args.named_child(0)
+            if first_arg and first_arg.type in ("string", "template_string", "string_fragment"):
+                try:
+                    raw = buf[first_arg.start_byte : first_arg.end_byte].decode(
+                        "utf-8", errors="replace"
+                    )
+                    path = raw.strip("'\"`")
+                except Exception as e:
+                    _log.warning("JavaScriptRouteDetector._check_call failed: %s", e)
+                    path = ""
+
+        if not path:
+            return
+
+        handler = self._extract_handler(args, buf, content) if args else ""
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+        auth = self._check_auth(args, content) if args else False
+
+        routes.append(
+            self._make_route(
+                method=method_lower.upper(),
+                path=path,
+                handler=handler,
+                file_path=file_path,
+                line=line,
+                framework=framework,
+                auth_required=auth if auth else None,
+            )
+        )
+
+    def _get_member_expression(self, func: object) -> tuple[str | None, str | None]:
+        ftype = getattr(func, "type", "")
+        if ftype == "member_expression":
+            obj = self._child_by_field(func, "object")
+            prop = self._child_by_field(func, "property")
+            if obj and prop:
+                obj_name = self._node_text(obj) if hasattr(obj, "text") else ""
+                prop_name = self._node_text(prop) if hasattr(prop, "text") else ""
+                return obj_name, prop_name
+        return None, None
+
+    def _child_by_field(self, node: object, field: str) -> object | None:
+        if hasattr(node, "child_by_field_name"):
+            return node.child_by_field_name(field)
+        return None
+
+    def _node_text(self, node: object) -> 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("JavaScriptRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _extract_handler(self, args: object, buf: bytes, content: str) -> str:
+        try:
+            for i in range(getattr(args, "named_child_count", 0)):
+                child = args.named_child(i)
+                if child and child.type == "identifier":
+                    return self._node_text(child)
+            for i in range(getattr(args, "named_child_count", 0)):
+                child = args.named_child(i)
+                if child and child.type == "arrow_function":
+                    parent = getattr(child, "parent", None)
+                    if parent and parent.type == "variable_declarator":
+                        name_node = self._child_by_field(parent, "name")
+                        if name_node:
+                            return self._node_text(name_node)
+        except Exception as e:
+            _log.warning("JavaScriptRouteDetector._extract_handler failed: %s", e)
+        return ""
+
+    def _check_auth(self, args: object, content: str) -> bool:
+        try:
+            for i in range(getattr(args, "named_child_count", 0)):
+                child = args.named_child(i)
+                if child and child.type == "identifier":
+                    name = self._node_text(child).lower()
+                    if name in _AUTH_MIDDLEWARE:
+                        return True
+        except Exception as e:
+            _log.warning("JavaScriptRouteDetector._check_auth failed: %s", e)
+        return False
+
+    def _detect_ts_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        for obj in _EXPRESS_OBJECTS | _FASTIFY_OBJECTS:
+            framework = "Express" if obj in _EXPRESS_OBJECTS else "Fastify"
+            pat = re.compile(
+                rf"""{re.escape(obj)}\.({"|".join(_HTTP_METHODS)})\s*\(\s*["'`]([^"'`]+)["'`]""",
+                re.IGNORECASE,
+            )
+            for i, line in enumerate(content.splitlines(), 1):
+                m = pat.search(line)
+                if not m:
+                    continue
+                method = m.group(1).upper()
+                path = m.group(2)
+                handler = ""
+                hm = re.search(r""",\s*(?:async\s+)?(\w+)\s*\)?\s*$""", line)
+                if hm and hm.group(1) not in {"function", "async", "req", "res", "next"}:
+                    handler = hm.group(1)
+                auth = bool(
+                    re.search(
+                        r"(?:auth|authenticate|requireAuth|verifyToken|isAuthenticated)", line
+                    )
+                )
+                routes.append(
+                    self._make_route(
+                        method,
+                        path,
+                        handler,
+                        file_path,
+                        i,
+                        framework=framework,
+                        auth_required=auth if auth else None,
+                    )
+                )
+        return routes