commiter-cli 0.3.0__py3-none-any.whl

commiter/adapters/fastapi.py

@@ -0,0 +1,170 @@
+"""FastAPI adapter — recognizes FastAPI route patterns."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from commiter.adapters.base import BaseAdapter, RouteMatch
+from commiter.parser import node_text, find_nodes_by_type
+
+if TYPE_CHECKING:
+    from tree_sitter import Node, Tree
+
+# Matches FastAPI route decorators: @app.get, @router.post, etc.
+ROUTE_DECORATOR_RE = re.compile(
+    r"^(\w+)\.(get|post|put|delete|patch)\s*\("
+)
+
+# Path parameters: {item_id} or {item_id:int}
+PATH_PARAM_RE = re.compile(r"\{(\w+)(?::\w+)?\}")
+
+# Common FastAPI auth dependency patterns
+AUTH_PATTERNS = {
+    "Depends(get_current_user", "Depends(require_auth",
+    "Depends(authenticate", "Security(",
+}
+
+
+class FastAPIAdapter(BaseAdapter):
+    framework_name = "fastapi"
+    language = "python"
+
+    def find_route_definitions(self, tree: Tree, source: bytes) -> list[RouteMatch]:
+        routes = []
+        root = tree.root_node
+
+        for child in root.children:
+            if child.type != "decorated_definition":
+                continue
+
+            decorators = []
+            func_node = None
+            for sub in child.children:
+                if sub.type == "decorator":
+                    decorators.append(sub)
+                elif sub.type == "function_definition":
+                    func_node = sub
+
+            if func_node is None:
+                continue
+
+            for dec_node in decorators:
+                dec_text = node_text(dec_node, source).lstrip("@").strip()
+                match = ROUTE_DECORATOR_RE.match(dec_text)
+                if not match:
+                    continue
+
+                router_var_name = match.group(1)
+                method = match.group(2).upper()
+                route_pattern = self._extract_route_string(dec_node, source)
+                if not route_pattern:
+                    continue
+
+                handler_name = self._get_func_name(func_node, source)
+
+                routes.append(RouteMatch(
+                    http_method=method,
+                    route_pattern=route_pattern,
+                    handler_name=handler_name,
+                    handler_node=func_node,
+                    decorator_nodes=decorators,
+                    line=func_node.start_point[0] + 1,
+                    router_var=router_var_name,
+                ))
+
+        return routes
+
+    def extract_auth_info(self, route: RouteMatch, source: bytes) -> list[str]:
+        """Detect Depends() auth patterns in function parameters."""
+        auth = []
+        # Check decorators
+        for dec_node in route.decorator_nodes:
+            dec_text = node_text(dec_node, source)
+            for pattern in AUTH_PATTERNS:
+                if pattern in dec_text:
+                    auth.append(dec_text.lstrip("@").strip())
+
+        # Check function parameters for Depends(get_current_user)
+        params_node = route.handler_node.child_by_field_name("parameters")
+        if params_node:
+            params_text = node_text(params_node, source)
+            for pattern in AUTH_PATTERNS:
+                if pattern in params_text:
+                    auth.append(pattern.rstrip("("))
+
+        return auth
+
+    def extract_request_body_fields(self, route: RouteMatch, source: bytes,
+                                     type_definitions: dict | None = None) -> list[str]:
+        """Extract field names from Pydantic model type hints in parameters.
+
+        If type_definitions is provided (same-file type info), resolves model fields.
+        """
+        fields = []
+        body_type = None
+        params_node = route.handler_node.child_by_field_name("parameters")
+        if not params_node:
+            return fields
+
+        params_text = node_text(params_node, source)
+
+        for match in re.finditer(r'(\w+)\s*:\s*(\w+)', params_text):
+            param_name = match.group(1)
+            type_name = match.group(2)
+            if type_name in ("str", "int", "float", "bool", "list", "dict", "Optional", "Request", "Response"):
+                continue
+            if param_name in ("self", "request", "response", "db", "session"):
+                continue
+            if type_name[0].isupper():
+                body_type = type_name
+                # Try to resolve the model's fields from same-file definitions
+                if type_definitions and type_name in type_definitions:
+                    for tf in type_definitions[type_name]:
+                        opt = "?" if tf.optional else ""
+                        fields.append(f"{tf.name}: {tf.type_str}{opt}")
+                else:
+                    fields.append(f"{param_name}: {type_name}")
+
+        # Store the body type name on the route for the extractor to pick up
+        if body_type:
+            route.param_types["_request_body_type"] = body_type
+
+        return fields
+
+    def extract_response_fields(self, route: RouteMatch, source: bytes) -> list[str]:
+        """Extract response fields from return dicts or response_model."""
+        fields = []
+        body_text = node_text(route.handler_node, source)
+
+        # Match dict literal keys in return statements
+        for match in re.finditer(r'["\'](\w+)["\']\s*:', body_text):
+            key = match.group(1)
+            if key not in fields:
+                fields.append(key)
+
+        # Check decorator for response_model
+        for dec_node in route.decorator_nodes:
+            dec_text = node_text(dec_node, source)
+            rm_match = re.search(r'response_model\s*=\s*(\w+)', dec_text)
+            if rm_match:
+                fields.insert(0, f"response_model: {rm_match.group(1)}")
+
+        return fields
+
+    def extract_path_params(self, route_pattern: str) -> list[str]:
+        return PATH_PARAM_RE.findall(route_pattern)
+
+    def _extract_route_string(self, dec_node: Node, source: bytes) -> str | None:
+        call_nodes = find_nodes_by_type(dec_node, "string")
+        if call_nodes:
+            text = node_text(call_nodes[0], source)
+            if len(text) >= 2:
+                return text[1:-1]
+        return None
+
+    def _get_func_name(self, func_node: Node, source: bytes) -> str:
+        name_node = func_node.child_by_field_name("name")
+        if name_node:
+            return node_text(name_node, source)
+        return "<anonymous>"

commiter/adapters/flask.py

@@ -0,0 +1,169 @@
+"""Flask adapter — recognizes Flask route patterns."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from commiter.adapters.base import BaseAdapter, RouteMatch
+from commiter.parser import node_text, find_nodes_by_type
+
+if TYPE_CHECKING:
+    from tree_sitter import Node, Tree
+
+# Matches Flask route decorators: @app.route, @bp.route, @blueprint.route
+ROUTE_DECORATOR_RE = re.compile(
+    r"^(\w+)\.(route|get|post|put|delete|patch)\s*\("
+)
+
+# Extracts path parameters like <item_id> or <int:item_id>
+PATH_PARAM_RE = re.compile(r"<(?:\w+:)?(\w+)>")
+
+# HTTP method names
+METHOD_MAP = {
+    "get": "GET",
+    "post": "POST",
+    "put": "PUT",
+    "delete": "DELETE",
+    "patch": "PATCH",
+    "route": None,  # determined by methods= kwarg
+}
+
+# Common Flask auth decorator patterns
+AUTH_DECORATORS = {
+    "login_required", "require_auth", "auth_required",
+    "jwt_required", "token_required", "requires_auth",
+}
+
+
+class FlaskAdapter(BaseAdapter):
+    framework_name = "flask"
+    language = "python"
+
+    def find_route_definitions(self, tree: Tree, source: bytes) -> list[RouteMatch]:
+        routes = []
+        root = tree.root_node
+
+        for child in root.children:
+            if child.type != "decorated_definition":
+                continue
+
+            decorators = []
+            func_node = None
+            for sub in child.children:
+                if sub.type == "decorator":
+                    decorators.append(sub)
+                elif sub.type == "function_definition":
+                    func_node = sub
+
+            if func_node is None:
+                continue
+
+            for dec_node in decorators:
+                dec_text = node_text(dec_node, source).lstrip("@").strip()
+                match = ROUTE_DECORATOR_RE.match(dec_text)
+                if not match:
+                    continue
+
+                router_var_name = match.group(1)
+                method_shorthand = match.group(2)
+                route_pattern = self._extract_route_string(dec_node, source)
+                if not route_pattern:
+                    continue
+
+                methods = self._extract_methods(dec_node, source, method_shorthand)
+                handler_name = self._get_func_name(func_node, source)
+
+                for method in methods:
+                    routes.append(RouteMatch(
+                        http_method=method,
+                        route_pattern=route_pattern,
+                        handler_name=handler_name,
+                        handler_node=func_node,
+                        decorator_nodes=decorators,
+                        line=func_node.start_point[0] + 1,
+                        router_var=router_var_name,
+                    ))
+
+        return routes
+
+    def extract_auth_info(self, route: RouteMatch, source: bytes) -> list[str]:
+        auth = []
+        for dec_node in route.decorator_nodes:
+            dec_text = node_text(dec_node, source).lstrip("@").strip()
+            # Check if any known auth decorator name appears
+            for auth_name in AUTH_DECORATORS:
+                if auth_name in dec_text:
+                    auth.append(dec_text)
+                    break
+        return auth
+
+    def extract_request_body_fields(self, route: RouteMatch, source: bytes) -> list[str]:
+        """Find request.json["field"] and request.form["field"] accesses."""
+        fields = []
+        body = route.handler_node
+        body_text = node_text(body, source)
+
+        # Match request.json["field"], request.json.get("field"), request.form["field"]
+        for match in re.finditer(r'request\.(?:json|form)(?:\[(["\'])(\w+)\1\]|\.get\(["\'](\w+)["\'])', body_text):
+            field_name = match.group(2) or match.group(3)
+            if field_name and field_name not in fields:
+                fields.append(field_name)
+
+        return fields
+
+    def extract_response_fields(self, route: RouteMatch, source: bytes) -> list[str]:
+        """Find keys in jsonify({...}) or return {...} dicts."""
+        fields = []
+        body_text = node_text(route.handler_node, source)
+
+        # Match jsonify(key=value) pattern
+        for match in re.finditer(r'jsonify\s*\(([^)]+)\)', body_text):
+            args = match.group(1)
+            for kv in re.finditer(r'(\w+)\s*=', args):
+                key = kv.group(1)
+                if key not in fields:
+                    fields.append(key)
+
+        # Match jsonify({"key": ...}) pattern
+        for match in re.finditer(r'["\'](\w+)["\']\s*:', body_text):
+            key = match.group(1)
+            if key not in fields:
+                fields.append(key)
+
+        return fields
+
+    def extract_path_params(self, route_pattern: str) -> list[str]:
+        return PATH_PARAM_RE.findall(route_pattern)
+
+    def _extract_route_string(self, dec_node: Node, source: bytes) -> str | None:
+        """Extract the route pattern string from a decorator."""
+        # Find the first string argument in the decorator call
+        call_nodes = find_nodes_by_type(dec_node, "string")
+        if call_nodes:
+            text = node_text(call_nodes[0], source)
+            # Strip quotes
+            if len(text) >= 2:
+                return text[1:-1]
+        return None
+
+    def _extract_methods(self, dec_node: Node, source: bytes, method_shorthand: str) -> list[str]:
+        """Extract HTTP methods from the decorator."""
+        if method_shorthand != "route":
+            mapped = METHOD_MAP.get(method_shorthand)
+            return [mapped] if mapped else ["GET"]
+
+        # For @app.route(..., methods=["GET", "POST"])
+        dec_text = node_text(dec_node, source)
+        methods_match = re.search(r'methods\s*=\s*\[([^\]]+)\]', dec_text)
+        if methods_match:
+            raw = methods_match.group(1)
+            return [m.strip().strip("\"'").upper() for m in raw.split(",")]
+
+        return ["GET"]
+
+    def _get_func_name(self, func_node: Node, source: bytes) -> str:
+        name_node = func_node.child_by_field_name("name")
+        if name_node:
+            return node_text(name_node, source)
+        return "<anonymous>"

commiter/adapters/nextjs.py

@@ -0,0 +1,180 @@
+"""Next.js adapter — recognizes API routes and page components."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from commiter.adapters.base import BaseAdapter, RouteMatch
+from commiter.parser import node_text, find_nodes_by_type
+
+if TYPE_CHECKING:
+    from tree_sitter import Node, Tree
+
+# HTTP method export names in App Router route.ts files
+APP_ROUTER_METHODS = {"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"}
+
+
+class NextJSAdapter(BaseAdapter):
+    framework_name = "nextjs"
+    language = "typescript"  # also handles tsx, js, jsx via can_handle_language
+
+    _file_path: str = ""
+
+    def can_handle_language(self, language: str) -> bool:
+        return language in ("typescript", "tsx", "javascript")
+
+    def find_route_definitions(self, tree: Tree, source: bytes, file_path: str = "") -> list[RouteMatch]:
+        """Detect Next.js API routes from file conventions."""
+        self._file_path = file_path
+
+        if self._is_app_router_route(file_path):
+            return self._find_app_router_routes(tree, source, file_path)
+        elif self._is_pages_api_route(file_path):
+            return self._find_pages_api_routes(tree, source, file_path)
+        return []
+
+    def _is_app_router_route(self, file_path: str) -> bool:
+        """Check if this is an App Router route file (app/**/route.ts)."""
+        name = Path(file_path).stem
+        return name == "route" and "/app/" in file_path
+
+    def _is_pages_api_route(self, file_path: str) -> bool:
+        """Check if this is a Pages Router API route (pages/api/**/*.ts)."""
+        return "/pages/api/" in file_path
+
+    def _find_app_router_routes(self, tree: Tree, source: bytes, file_path: str) -> list[RouteMatch]:
+        """Find named exports like `export async function GET(request) {...}`."""
+        routes = []
+        route_pattern = self._path_to_route(file_path, "app")
+
+        root = tree.root_node
+        for child in root.children:
+            if child.type != "export_statement":
+                continue
+
+            # Look for function declarations inside exports
+            for sub in child.children:
+                func_node = None
+                if sub.type == "function_declaration":
+                    func_node = sub
+                elif sub.type == "lexical_declaration":
+                    # const GET = async (...) => {...}
+                    for decl in sub.children:
+                        if decl.type == "variable_declarator":
+                            name_node = decl.child_by_field_name("name")
+                            if name_node:
+                                name = node_text(name_node, source)
+                                if name in APP_ROUTER_METHODS:
+                                    routes.append(RouteMatch(
+                                        http_method=name,
+                                        route_pattern=route_pattern,
+                                        handler_name=name,
+                                        handler_node=decl,
+                                        line=decl.start_point[0] + 1,
+                                    ))
+
+                if func_node:
+                    name_node = func_node.child_by_field_name("name")
+                    if name_node:
+                        name = node_text(name_node, source)
+                        if name in APP_ROUTER_METHODS:
+                            routes.append(RouteMatch(
+                                http_method=name,
+                                route_pattern=route_pattern,
+                                handler_name=name,
+                                handler_node=func_node,
+                                line=func_node.start_point[0] + 1,
+                            ))
+
+        return routes
+
+    def _find_pages_api_routes(self, tree: Tree, source: bytes, file_path: str) -> list[RouteMatch]:
+        """Find default export handler in pages/api/ files."""
+        routes = []
+        route_pattern = self._path_to_route(file_path, "pages")
+        root = tree.root_node
+
+        # Look for `export default function handler(req, res)` or
+        # `export default async (req, res) => {}`
+        for child in root.children:
+            if child.type != "export_statement":
+                continue
+
+            text = node_text(child, source)
+            if "default" not in text:
+                continue
+
+            for sub in child.children:
+                if sub.type in ("function_declaration", "arrow_function", "function_expression"):
+                    handler_name = "handler"
+                    if sub.type == "function_declaration":
+                        name_node = sub.child_by_field_name("name")
+                        if name_node:
+                            handler_name = node_text(name_node, source)
+
+                    # Pages API routes handle all methods — check for req.method inside
+                    methods = self._detect_methods_from_body(sub, source)
+                    if not methods:
+                        methods = ["ALL"]
+
+                    for method in methods:
+                        routes.append(RouteMatch(
+                            http_method=method,
+                            route_pattern=route_pattern,
+                            handler_name=handler_name,
+                            handler_node=sub,
+                            line=sub.start_point[0] + 1,
+                        ))
+
+        return routes
+
+    def _detect_methods_from_body(self, node: Node, source: bytes) -> list[str]:
+        """Check for req.method === 'GET' patterns inside handler."""
+        body_text = node_text(node, source)
+        methods = []
+        for method in ("GET", "POST", "PUT", "DELETE", "PATCH"):
+            if f'"{method}"' in body_text or f"'{method}'" in body_text:
+                methods.append(method)
+        return methods
+
+    def _path_to_route(self, file_path: str, router_type: str) -> str:
+        """Convert file path to API route pattern.
+
+        app/api/users/[id]/route.ts -> /api/users/[id]
+        pages/api/users/[id].ts -> /api/users/[id]
+        """
+        path = Path(file_path)
+        parts = path.parts
+
+        # Find the router root
+        try:
+            if router_type == "app":
+                idx = parts.index("app")
+                route_parts = parts[idx + 1:]
+                # Remove the "route.ts" file
+                route_parts = route_parts[:-1]
+            else:
+                idx = parts.index("pages")
+                route_parts = parts[idx + 1:]
+                # Remove file extension from last part
+                last = Path(route_parts[-1]).stem
+                route_parts = list(route_parts[:-1]) + [last]
+                # Remove "index" from the end
+                if route_parts and route_parts[-1] == "index":
+                    route_parts = route_parts[:-1]
+        except (ValueError, IndexError):
+            return file_path
+
+        route = "/" + "/".join(route_parts)
+        # Convert [param] to :param for display consistency
+        route = re.sub(r"\[\.\.\.(\w+)\]", r"*\1", route)  # catch-all
+        route = re.sub(r"\[(\w+)\]", r":\1", route)
+        return route
+
+    def extract_path_params(self, route_pattern: str) -> list[str]:
+        """Extract params from Next.js patterns like :id or [id]."""
+        params = re.findall(r":(\w+)", route_pattern)
+        params += re.findall(r"\[(\w+)\]", route_pattern)
+        return params

commiter/adapters/prisma.py

@@ -0,0 +1,76 @@
+"""Prisma adapter — detects Prisma ORM database operations."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from commiter.adapters.base import DBAdapter, DBOpMatch
+
+if TYPE_CHECKING:
+    from tree_sitter import Tree
+
+# Prisma methods to operation types
+PRISMA_OP_MAP = {
+    "findUnique": "select",
+    "findFirst": "select",
+    "findMany": "select",
+    "create": "insert",
+    "createMany": "insert",
+    "update": "update",
+    "updateMany": "update",
+    "upsert": "upsert",
+    "delete": "delete",
+    "deleteMany": "delete",
+    "count": "select",
+    "aggregate": "select",
+    "groupBy": "select",
+}
+
+
+class PrismaAdapter(DBAdapter):
+    orm_name = "prisma"
+    language = "javascript"  # TypeScript too
+
+    def find_db_operations(self, tree: Tree, source: bytes) -> list[DBOpMatch]:
+        ops = []
+        text = source.decode("utf-8", errors="replace")
+
+        # Match: prisma.user.findMany(...), prisma.post.create(...)
+        for match in re.finditer(
+            r'(?:prisma|db|client)\s*\.\s*(\w+)\s*\.\s*(\w+)\s*\(',
+            text,
+        ):
+            model_name = match.group(1)
+            method = match.group(2)
+
+            # Skip non-model methods
+            if model_name.startswith("$") or model_name in ("_", "use"):
+                continue
+
+            op_type = PRISMA_OP_MAP.get(method)
+            if not op_type:
+                continue
+
+            line = text[:match.start()].count("\n") + 1
+            filters = self._extract_where_fields(text, match.end())
+
+            ops.append(DBOpMatch(
+                operation_type=op_type,
+                table_name=model_name,
+                call_node=tree.root_node,
+                line=line,
+                filters=filters,
+            ))
+
+        return ops
+
+    def _extract_where_fields(self, text: str, start: int) -> list[str]:
+        """Extract field names from where: { field: ... } clauses."""
+        filters = []
+        remaining = text[start:start + 500]
+        where_match = re.search(r'where\s*:\s*\{([^}]+)\}', remaining)
+        if where_match:
+            for field in re.finditer(r'(\w+)\s*:', where_match.group(1)):
+                filters.append(field.group(1))
+        return filters