patchi 0.7.5__py3-none-any.whl

patchi/core/brain/route_detector/rust.py

@@ -0,0 +1,216 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_RUST_HTTP_METHODS = {
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "head",
+    "options",
+    "connect",
+    "trace",
+    "any",
+}
+
+
+_log = logging.getLogger("patchi.brain.rust")
+
+
+@register_detector("rust")
+class RustRouteDetector(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.RUST)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("RustRouteDetector._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 == "attribute_item":
+            self._check_actix_attr(node, buf, content, file_path, routes)
+        elif ntype == "call_expression":
+            self._check_axum_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_actix_attr(
+        self, node: object, buf: bytes, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        attr = self._child_by_field(node, "attribute")
+        if attr is None:
+            return
+        attr_type = getattr(attr, "type", "")
+        if attr_type != "attribute":
+            return
+
+        path_node = self._child_by_field(attr, "path") or self._child_by_field(attr, "name")
+        if path_node is None:
+            return
+        try:
+            raw = self._node_text(path_node).lower()
+        except Exception as e:
+            _log.warning("RustRouteDetector._check_actix_attr failed: %s", e)
+            return
+
+        if raw not in _RUST_HTTP_METHODS:
+            return
+
+        args = self._child_by_field(attr, "arguments")
+        path = ""
+        if args:
+            for child in getattr(args, "named_children", None) or getattr(args, "children", []):
+                if child.type in ("string_literal", "raw_string_literal"):
+                    raw = self._node_text(child)
+                    path = raw.strip('"')
+                    break
+
+        handler = self._find_fn_name(node)
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+
+        routes.append(
+            self._make_route(raw.upper(), path, handler, file_path, line, framework="Actix Web")
+        )
+
+    def _check_axum_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
+        if getattr(func, "type", "") != "field_expression":
+            return
+        method_name = self._child_by_field(func, "field")
+        if method_name is None or self._node_text(method_name) != "route":
+            return
+
+        args = self._child_by_field(node, "arguments")
+        if args is None or getattr(args, "named_child_count", 0) < 2:
+            return
+
+        path = ""
+        first = args.named_child(0)
+        if first and first.type in ("string_literal", "raw_string_literal"):
+            path = self._node_text(first).strip('"')
+        if not path:
+            return
+
+        second = args.named_child(1)
+        http_method = ""
+        handler = ""
+        if second and second.type == "call_expression":
+            inner_fn = self._child_by_field(second, "function")
+            if inner_fn and inner_fn.type == "identifier":
+                http_method = self._node_text(inner_fn).lower()
+                if http_method in _RUST_HTTP_METHODS:
+                    inner_args = self._child_by_field(second, "arguments")
+                    if inner_args and inner_args.named_child_count > 0:
+                        h = inner_args.named_child(0)
+                        if h and h.type == "identifier":
+                            handler = self._node_text(h)
+
+        if not http_method:
+            return
+
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+        routes.append(
+            self._make_route(http_method.upper(), path, handler, file_path, line, framework="Axum")
+        )
+
+    def _find_fn_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", "") == "function_item":
+                name_node = self._child_by_field(cur, "name")
+                if name_node:
+                    return self._node_text(name_node)
+        return ""
+
+    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("RustRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        http = "|".join(_RUST_HTTP_METHODS)
+
+        actix_pat = re.compile(
+            rf"#\[\s*({http})\s*\(\s*\"([^\"]+)\"\s*\)",
+            re.IGNORECASE,
+        )
+        lines = content.splitlines()
+        for i, line in enumerate(lines, 1):
+            m = actix_pat.search(line)
+            if not m:
+                continue
+            method = m.group(1).upper()
+            path = m.group(2)
+            handler = ""
+            for j in range(i, min(i + 5, len(lines) + 1)):
+                hline = lines[j - 1].strip()
+                if not hline or hline.startswith("#["):
+                    continue
+                hm = re.match(r"\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)", hline)
+                if hm:
+                    handler = hm.group(1)
+                    break
+            routes.append(
+                self._make_route(method, path, handler, file_path, i, framework="Actix Web")
+            )
+
+        axum_pat = re.compile(
+            rf"""\.route\s*\(\s*["']([^"']+)["']\s*,\s*({http})\s*\(""",
+            re.IGNORECASE,
+        )
+        for i, line in enumerate(lines, 1):
+            m = axum_pat.search(line)
+            if not m:
+                continue
+            path = m.group(1)
+            method = m.group(2).upper()
+            handler = ""
+            hm = re.search(
+                rf"""({http})\s*\(\s*(\w+)""",
+                line[m.end() :] if m.end() < len(line) else line,
+                re.IGNORECASE,
+            )
+            if hm:
+                handler = hm.group(2)
+            routes.append(self._make_route(method, path, handler, file_path, i, framework="Axum"))
+
+        return routes

patchi/core/brain/route_detector/swift.py

@@ -0,0 +1,118 @@
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_SWIFT_HTTP_METHODS = {"get", "post", "put", "patch", "delete", "options"}
+
+
+_log = logging.getLogger("patchi.brain.swift")
+
+
+@register_detector("swift")
+class SwiftRouteDetector(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.SWIFT)
+            tree = parser.parse(bytes(content, "utf-8"))
+        except Exception as e:
+            _log.warning("SwiftRouteDetector._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 == "function_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") or self._child_by_field(node, "name")
+        if func is None:
+            return
+
+        ftype = getattr(func, "type", "")
+        if ftype == "member_access_expression":
+            obj = self._child_by_field(func, "object")
+            member = self._child_by_field(func, "member") or self._child_by_field(func, "name")
+            if obj is None or member is None:
+                return
+            obj_name = self._node_text(obj).lower()
+            if obj_name != "app":
+                return
+            method_name = self._node_text(member).lower()
+        elif ftype == "identifier":
+            method_name = self._node_text(func).lower()
+            if method_name not in _SWIFT_HTTP_METHODS:
+                return
+        else:
+            return
+
+        if method_name not in _SWIFT_HTTP_METHODS:
+            return
+
+        args = self._child_by_field(node, "arguments")
+        path = ""
+        if args:
+            for child in getattr(args, "named_children", None) or getattr(args, "children", []):
+                if child.type == "string_literal":
+                    path = self._node_text(child).strip('"')
+                    break
+
+        if not path:
+            return
+
+        line = getattr(node, "start_point", (0, 0))[0] + 1
+        routes.append(
+            self._make_route(method_name.upper(), path, "", file_path, line, framework="Vapor")
+        )
+
+    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("SwiftRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        http = "|".join(_SWIFT_HTTP_METHODS)
+        pat = re.compile(
+            rf"""app\.({http})\s*\(\s*["']([^"']+)["']""",
+            re.IGNORECASE,
+        )
+        for i, line in enumerate(content.splitlines(), 1):
+            m = pat.search(line)
+            if not m:
+                continue
+            routes.append(
+                self._make_route(
+                    m.group(1).upper(), m.group(2), "", file_path, i, framework="Vapor"
+                )
+            )
+        return routes

patchi/core/brain/route_mapper.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from patchi.core.brain.framework import StackInfo
+    from patchi.core.brain.scanner import FileInfo
+
+
+@dataclass
+class RouteInfo:
+    method: str
+    path: str
+    handler: str
+    file: str
+    line: int
+    middleware: list[str] = field(default_factory=list)
+    auth_required: bool | None = None
+    framework: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "method": self.method,
+            "path": self.path,
+            "handler": self.handler,
+            "file": self.file,
+            "line": self.line,
+            "middleware": self.middleware,
+            "auth_required": self.auth_required,
+            "framework": self.framework,
+        }
+
+
+_LANG_FW_MAP: dict[str, set[str]] = {
+    "python": {"FastAPI", "Flask", "Django", "Starlette"},
+    "javascript": {"Express", "Fastify", "Next.js", "Nuxt", "SvelteKit"},
+    "typescript": {"Express", "Fastify", "Next.js", "Nuxt", "SvelteKit"},
+    "java": {"Spring Boot"},
+    "go": {"Gin", "Echo", "Fiber"},
+    "rust": {"Actix Web", "Axum", "Rocket"},
+    "swift": {"Vapor"},
+    "ruby": {"Ruby on Rails", "Sinatra", "Grape"},
+    "php": {"Laravel"},
+    "c_sharp": {"ASP.NET Core"},
+}
+
+
+class RouteMapper:
+    def __init__(self, root: Path, stack: StackInfo):
+        self.root = root
+        self.stack = stack
+
+    def extract(self, file_infos: list[FileInfo]) -> list[RouteInfo]:
+        from patchi.core.brain.route_detector.csharp import CSharpRouteDetector
+        from patchi.core.brain.route_detector.file_based import (
+            NextJsRouteDetector,
+            NuxtRouteDetector,
+            SvelteKitRouteDetector,
+        )
+        from patchi.core.brain.route_detector.go import GoRouteDetector
+        from patchi.core.brain.route_detector.java import JavaRouteDetector
+        from patchi.core.brain.route_detector.javascript import JavaScriptRouteDetector
+        from patchi.core.brain.route_detector.php import PhpRouteDetector
+        from patchi.core.brain.route_detector.python import PythonRouteDetector
+        from patchi.core.brain.route_detector.ruby import RubyRouteDetector
+        from patchi.core.brain.route_detector.rust import RustRouteDetector
+        from patchi.core.brain.route_detector.swift import SwiftRouteDetector
+
+        active_fw = {f.name for f in self.stack.frameworks}
+
+        # Map from language to list of (default_fw_str, route_dicts)
+        detector_map: dict[str, list] = {}
+        for lang, frameworks in _LANG_FW_MAP.items():
+            matched = frameworks & active_fw
+            if not matched:
+                continue
+            detectors = []
+            if lang == "python":
+                detectors.append(("", PythonRouteDetector()))
+            elif lang in ("javascript", "typescript"):
+                detectors.append(("", JavaScriptRouteDetector()))
+                if "Next.js" in matched:
+                    detectors.append(("Next.js", NextJsRouteDetector()))
+                if "Nuxt" in matched:
+                    detectors.append(("Nuxt", NuxtRouteDetector()))
+                if "SvelteKit" in matched:
+                    detectors.append(("SvelteKit", SvelteKitRouteDetector()))
+            elif lang == "java":
+                detectors.append(("", JavaRouteDetector()))
+            elif lang == "go":
+                detectors.append(("", GoRouteDetector()))
+            elif lang == "rust":
+                detectors.append(("", RustRouteDetector()))
+            elif lang == "swift":
+                detectors.append(("", SwiftRouteDetector()))
+            elif lang == "ruby":
+                detectors.append(("", RubyRouteDetector()))
+            elif lang == "php":
+                detectors.append(("", PhpRouteDetector()))
+            elif lang == "c_sharp":
+                detectors.append(("", CSharpRouteDetector()))
+            if detectors:
+                detector_map[lang] = detectors
+
+        routes: list[RouteInfo] = []
+
+        for fi in file_infos:
+            lang = fi.language.value
+            detectors = detector_map.get(lang)
+            if not detectors:
+                continue
+
+            try:
+                content = (self.root / fi.path).read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+
+            for _fw_prefix, detector in detectors:
+                dicts = detector.detect(content, str(fi.path))
+                for d in dicts:
+                    routes.append(
+                        RouteInfo(
+                            method=d.get("method", "GET"),
+                            path=d.get("path", "/"),
+                            handler=d.get("handler", ""),
+                            file=d.get("file", str(fi.path)),
+                            line=d.get("line", 0),
+                            middleware=d.get("middleware", []),
+                            auth_required=d.get("auth_required"),
+                            framework=d.get("framework", _fw_prefix),
+                        )
+                    )
+
+        seen: set[tuple] = set()
+        unique: list[RouteInfo] = []
+        for r in routes:
+            key = (r.method, r.path, r.file)
+            if key not in seen:
+                seen.add(key)
+                unique.append(r)
+        return unique
+
+
+# ── Backward-compat extractors for tests ─────────────────────────────────────
+
+
+def _extract_fastapi(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.python import PythonRouteDetector
+
+    return [RouteInfo(**d) for d in PythonRouteDetector().detect(content, file_path)]
+
+
+def _extract_flask(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.python import PythonRouteDetector
+
+    return [RouteInfo(**d) for d in PythonRouteDetector().detect(content, file_path)]
+
+
+def _extract_django(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.python import PythonRouteDetector
+
+    return [RouteInfo(**d) for d in PythonRouteDetector().detect(content, file_path)]
+
+
+def _extract_express(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.javascript import JavaScriptRouteDetector
+
+    return [RouteInfo(**d) for d in JavaScriptRouteDetector().detect(content, file_path)]
+
+
+def _extract_fastify(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.javascript import JavaScriptRouteDetector
+
+    return [RouteInfo(**d) for d in JavaScriptRouteDetector().detect(content, file_path)]
+
+
+def _extract_laravel(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.php import PhpRouteDetector
+
+    return [RouteInfo(**d) for d in PhpRouteDetector().detect(content, file_path)]
+
+
+def _extract_spring(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.java import JavaRouteDetector
+
+    return [RouteInfo(**d) for d in JavaRouteDetector().detect(content, file_path)]
+
+
+def _extract_gin(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.go import GoRouteDetector
+
+    return [RouteInfo(**d) for d in GoRouteDetector().detect(content, file_path)]
+
+
+def _extract_echo(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.go import GoRouteDetector
+
+    return [RouteInfo(**d) for d in GoRouteDetector().detect(content, file_path)]
+
+
+def _extract_fiber(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.go import GoRouteDetector
+
+    return [RouteInfo(**d) for d in GoRouteDetector().detect(content, file_path)]
+
+
+def _extract_actix(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.rust import RustRouteDetector
+
+    return [RouteInfo(**d) for d in RustRouteDetector().detect(content, file_path)]
+
+
+def _extract_axum(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.rust import RustRouteDetector
+
+    return [RouteInfo(**d) for d in RustRouteDetector().detect(content, file_path)]
+
+
+def _extract_rocket(content: str, file_path: str) -> list[RouteInfo]:
+    routes = _extract_actix(content, file_path)
+    for r in routes:
+        r.framework = "Rocket"
+    return routes
+
+
+def _extract_vapor(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.swift import SwiftRouteDetector
+
+    return [RouteInfo(**d) for d in SwiftRouteDetector().detect(content, file_path)]
+
+
+def _extract_rails(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.ruby import RubyRouteDetector
+
+    return [RouteInfo(**d) for d in RubyRouteDetector().detect(content, file_path)]
+
+
+def _extract_sinatra(content: str, file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.ruby import RubyRouteDetector
+
+    return [RouteInfo(**d) for d in RubyRouteDetector().detect(content, file_path)]
+
+
+def _extract_grape(content: str, file_path: str) -> list[RouteInfo]:
+    return _extract_sinatra(content, file_path)
+
+
+def _extract_nextjs_file_routes(file_path: str, root: Path | None = None) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.file_based import NextJsRouteDetector
+
+    return [RouteInfo(**d) for d in NextJsRouteDetector().detect("", file_path)]
+
+
+def _extract_nuxt_file_routes(file_path: str, root: Path | None = None) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.file_based import NuxtRouteDetector
+
+    return [RouteInfo(**d) for d in NuxtRouteDetector().detect("", file_path)]
+
+
+def _extract_sveltekit_file_routes(file_path: str) -> list[RouteInfo]:
+    from patchi.core.brain.route_detector.file_based import SvelteKitRouteDetector
+
+    return [RouteInfo(**d) for d in SvelteKitRouteDetector().detect("", file_path)]