graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/infrastructure/parsing/tree_sitter_typescript_parser.py

@@ -0,0 +1,600 @@
+"""TreeSitterTypeScriptParser - Tree-sitter based TypeScript/JavaScript AST parser.
+
+Uses tree-sitter and tree-sitter-typescript for precise AST parsing via tree traversal.
+Supports dual grammars: TypeScript (.ts, .js) and TSX (.tsx, .jsx).
+"""
+from pathlib import Path
+
+from tree_sitter import Language, Parser, Node
+
+from src.domain.repositories.i_code_parser import ICodeParser, ParseResult
+
+
+class ParseError(Exception):
+    """Exception raised when parsing fails."""
+    pass
+
+
+class TreeSitterTypeScriptParser:
+    """
+    TypeScript/JavaScript parser implementation using Tree-sitter library.
+
+    Implements ICodeParser interface for consistency with Java parser.
+    Uses two internal parser instances: one for TypeScript (.ts, .js),
+    one for TSX (.tsx, .jsx).
+    """
+
+    # File extensions mapped to grammars
+    TS_EXTENSIONS = {'.ts', '.js'}
+    TSX_EXTENSIONS = {'.tsx', '.jsx'}
+
+    def __init__(self):
+        """Initialize Tree-sitter parsers with TypeScript and TSX grammars."""
+        self.ts_language = self._load_language('typescript')
+        self.ts_parser = Parser(self.ts_language)
+
+        self.tsx_language = self._load_language('tsx')
+        self.tsx_parser = Parser(self.tsx_language)
+
+    def _load_language(self, grammar_type: str) -> Language:
+        """
+        Load Tree-sitter language grammar.
+
+        Args:
+            grammar_type: 'typescript' or 'tsx'
+
+        Returns:
+            Language instance
+
+        Raises:
+            ParseError: If grammar loading fails
+        """
+        try:
+            import tree_sitter_typescript
+
+            if grammar_type == 'typescript':
+                return Language(tree_sitter_typescript.language_typescript())
+            elif grammar_type == 'tsx':
+                return Language(tree_sitter_typescript.language_tsx())
+            else:
+                raise ValueError(f"Unknown grammar type: {grammar_type}")
+
+        except ImportError as e:
+            raise ParseError(
+                f"Failed to load tree-sitter-typescript: {e}. "
+                "Install with: pip install tree-sitter-typescript"
+            )
+        except Exception as e:
+            raise ParseError(f"Failed to load {grammar_type} grammar: {e}")
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        """
+        Parse TypeScript/JavaScript file and extract AST structures.
+
+        Args:
+            file_path: Path to .ts/.tsx/.js/.jsx file
+
+        Returns:
+            ParseResult with extracted structures
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ParseError: If parsing fails
+        """
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Read file content
+        try:
+            code_bytes = file_path.read_bytes()
+            code_str = code_bytes.decode('utf-8')
+        except UnicodeDecodeError as e:
+            raise ParseError(f"Failed to read file {file_path}: Invalid UTF-8 encoding")
+        except Exception as e:
+            raise ParseError(f"Failed to read file {file_path}: {e}")
+
+        # Select appropriate parser based on file extension
+        parser = self._select_parser(file_path)
+
+        # Parse with tree-sitter
+        tree = parser.parse(code_bytes)
+
+        # Check for parse errors
+        if tree.root_node.has_error:
+            raise ParseError(f"Syntax errors in TypeScript/JavaScript file: {file_path}")
+
+        # Extract structures via tree traversal
+        imports = self._extract_imports(tree.root_node, code_str)
+        methods = self._extract_components(tree.root_node, code_str)  # Tasks 1.3-1.5
+        method_calls = self._extract_function_calls(tree.root_node, code_str)  # Task 1.6
+        string_literals = self._extract_string_literals(tree.root_node, code_str)  # Task 1.6
+
+        return ParseResult(
+            file_path=file_path,
+            classes=[],  # TypeScript doesn't use classes in Java sense
+            methods=methods,
+            imports=imports,
+            method_calls=method_calls,
+            string_literals=string_literals
+        )
+
+    def _select_parser(self, file_path: Path) -> Parser:
+        """
+        Select appropriate parser based on file extension.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            Parser instance (ts_parser or tsx_parser)
+        """
+        extension = file_path.suffix.lower()
+
+        if extension in self.TSX_EXTENSIONS:
+            return self.tsx_parser
+        else:
+            # Default to TypeScript parser for .ts, .js, and unknown extensions
+            return self.ts_parser
+
+    def _extract_imports(self, root_node: Node, code: str) -> list[dict]:
+        """
+        Extract import statements from AST.
+
+        Args:
+            root_node: Root AST node
+            code: Source code string
+
+        Returns:
+            List of import dictionaries with metadata
+        """
+        imports = []
+        self._find_imports_recursive(root_node, code, imports)
+        return imports
+
+    def _find_imports_recursive(self, node: Node, code: str, results: list):
+        """Recursively find import_statement nodes."""
+        if node.type == "import_statement":
+            import_data = self._parse_import_statement(node, code)
+            if import_data:
+                results.append(import_data)
+
+        for child in node.children:
+            self._find_imports_recursive(child, code, results)
+
+    def _parse_import_statement(self, node: Node, code: str) -> dict | None:
+        """
+        Parse an import_statement node.
+
+        Args:
+            node: import_statement AST node
+            code: Source code string
+
+        Returns:
+            Dictionary with import metadata or None
+        """
+        module_path = None
+        default_import = None
+        imported_names = []
+        namespace_import = None
+        import_type = None
+
+        # Find module path (string node)
+        for child in node.children:
+            if child.type == "string":
+                module_path = self._extract_string_value(child, code)
+            elif child.type == "import_clause":
+                # Parse import_clause to determine type and bindings
+                default_import, imported_names, namespace_import = self._parse_import_clause(child, code)
+
+        if not module_path:
+            return None
+
+        # Determine import type
+        if default_import and imported_names:
+            import_type = "mixed"
+        elif default_import:
+            import_type = "default"
+        elif namespace_import:
+            import_type = "namespace"
+        elif imported_names:
+            import_type = "named"
+        else:
+            import_type = "side-effect"
+
+        return {
+            "module_path": module_path,
+            "import_type": import_type,
+            "default_import": default_import,
+            "imported_names": imported_names,
+            "namespace_import": namespace_import,
+            "line": node.start_point[0] + 1
+        }
+
+    def _parse_import_clause(self, node: Node, code: str) -> tuple[str | None, list[str], str | None]:
+        """
+        Parse import_clause node to extract bindings.
+
+        Args:
+            node: import_clause AST node
+            code: Source code string
+
+        Returns:
+            Tuple of (default_import, named_imports_list, namespace_import)
+        """
+        default_import = None
+        named_imports = []
+        namespace_import = None
+
+        for child in node.children:
+            if child.type == "identifier":
+                # Direct identifier = default import
+                default_import = self._get_node_text(child, code)
+            elif child.type == "named_imports":
+                # Named imports: { foo, bar }
+                named_imports = self._parse_named_imports(child, code)
+            elif child.type == "namespace_import":
+                # Namespace import: * as utils
+                namespace_import = self._parse_namespace_import(child, code)
+
+        return default_import, named_imports, namespace_import
+
+    def _parse_named_imports(self, node: Node, code: str) -> list[str]:
+        """Extract names from named_imports node."""
+        names = []
+        for child in node.children:
+            if child.type == "import_specifier":
+                # import_specifier contains identifier
+                for subchild in child.children:
+                    if subchild.type == "identifier":
+                        names.append(self._get_node_text(subchild, code))
+                        break  # Only take first identifier (imported name)
+        return names
+
+    def _parse_namespace_import(self, node: Node, code: str) -> str | None:
+        """Extract namespace name from namespace_import node (* as name)."""
+        for child in node.children:
+            if child.type == "identifier":
+                return self._get_node_text(child, code)
+        return None
+
+    def _extract_string_value(self, node: Node, code: str) -> str:
+        """Extract string value without quotes."""
+        text = self._get_node_text(node, code)
+        # Remove surrounding quotes
+        if text.startswith('"') and text.endswith('"'):
+            return text[1:-1]
+        if text.startswith("'") and text.endswith("'"):
+            return text[1:-1]
+        return text
+
+    def _get_node_text(self, node: Node, code: str) -> str:
+        """Get text content of a node."""
+        return code[node.start_byte:node.end_byte]
+
+    def _extract_components(self, root_node: Node, code: str) -> list[dict]:
+        """
+        Extract React/Angular/Vue components from AST.
+
+        Args:
+            root_node: Root AST node
+            code: Source code string
+
+        Returns:
+            List of component dictionaries
+        """
+        components = []
+        self._find_components_recursive(root_node, code, components)
+        return components
+
+    def _find_components_recursive(self, node: Node, code: str, results: list):
+        """Recursively find component declarations."""
+        # React function components (arrow functions with JSX)
+        if node.type == "variable_declarator":
+            component = self._parse_react_function_component(node, code)
+            if component:
+                results.append(component)
+
+        # React class components
+        elif node.type == "class_declaration":
+            component = self._parse_react_class_component(node, code)
+            if component:
+                results.append(component)
+
+        # Angular components (export with decorator)
+        elif node.type == "export_statement":
+            component = self._parse_angular_component(node, code)
+            if component:
+                results.append(component)
+
+        for child in node.children:
+            self._find_components_recursive(child, code, results)
+
+    def _parse_react_function_component(self, node: Node, code: str) -> dict | None:
+        """Parse React function component from variable_declarator."""
+        name = None
+        has_jsx = False
+        jsx_children = []
+
+        for child in node.children:
+            if child.type == "identifier":
+                name = self._get_node_text(child, code)
+            elif child.type == "arrow_function":
+                has_jsx, jsx_children = self._check_jsx_in_function(child, code)
+
+        if name and has_jsx:
+            return {
+                "name": name,
+                "type": "function_component",
+                "framework": "react",
+                "has_jsx": True,
+                "jsx_children": jsx_children,
+                "line": node.start_point[0] + 1
+            }
+        return None
+
+    def _parse_react_class_component(self, node: Node, code: str) -> dict | None:
+        """Parse React class component."""
+        name = None
+        extends = None
+
+        for child in node.children:
+            if child.type == "type_identifier":
+                name = self._get_node_text(child, code)
+            elif child.type == "class_heritage":
+                # Extract extends clause
+                for subchild in child.children:
+                    if subchild.type == "extends_clause":
+                        for expr_child in subchild.children:
+                            if expr_child.type == "member_expression":
+                                extends = self._get_node_text(expr_child, code)
+
+        # Only treat as React component if extends React.Component or React.PureComponent
+        if name and extends and "React." in extends:
+            return {
+                "name": name,
+                "type": "class_component",
+                "framework": "react",
+                "extends": extends,
+                "line": node.start_point[0] + 1
+            }
+        return None
+
+    def _check_jsx_in_function(self, node: Node, code: str) -> tuple[bool, list[str]]:
+        """Check if function body contains JSX and extract child components."""
+        has_jsx = False
+        jsx_children = set()
+
+        def traverse(n):
+            nonlocal has_jsx
+            if n.type == "jsx_element" or n.type == "jsx_self_closing_element":
+                has_jsx = True
+                # Extract JSX element name
+                for child in n.children:
+                    if child.type == "jsx_opening_element":
+                        for subchild in child.children:
+                            if subchild.type == "identifier":
+                                tag_name = self._get_node_text(subchild, code)
+                                # Custom components start with uppercase
+                                if tag_name and tag_name[0].isupper():
+                                    jsx_children.add(tag_name)
+                    elif child.type == "identifier":
+                        tag_name = self._get_node_text(child, code)
+                        if tag_name and tag_name[0].isupper():
+                            jsx_children.add(tag_name)
+            for c in n.children:
+                traverse(c)
+
+        traverse(node)
+        return has_jsx, list(jsx_children)
+
+    def _parse_angular_component(self, node: Node, code: str) -> dict | None:
+        """Parse Angular @Component decorator."""
+        has_component_decorator = False
+        class_name = None
+        selector = None
+        standalone = False
+        imports = []
+
+        # Check for @Component decorator
+        for child in node.children:
+            if child.type == "decorator":
+                decorator_name, metadata = self._parse_decorator(child, code)
+                if decorator_name == "Component":
+                    has_component_decorator = True
+                    selector = metadata.get("selector")
+                    standalone = metadata.get("standalone", False)
+                    imports = metadata.get("imports", [])
+
+            elif child.type == "class_declaration":
+                for subchild in child.children:
+                    if subchild.type == "type_identifier":
+                        class_name = self._get_node_text(subchild, code)
+
+        if has_component_decorator and class_name:
+            result = {
+                "name": class_name,
+                "type": "angular_component",
+                "framework": "angular",
+                "selector": selector,
+                "line": node.start_point[0] + 1
+            }
+            if standalone:
+                result["standalone"] = True
+                result["imports"] = imports
+            return result
+        return None
+
+    def _parse_decorator(self, node: Node, code: str) -> tuple[str | None, dict]:
+        """Parse decorator and extract metadata."""
+        decorator_name = None
+        metadata = {}
+
+        for child in node.children:
+            if child.type == "call_expression":
+                # Get decorator name
+                for subchild in child.children:
+                    if subchild.type == "identifier":
+                        decorator_name = self._get_node_text(subchild, code)
+                    elif subchild.type == "arguments":
+                        # Extract metadata from object argument
+                        metadata = self._parse_decorator_metadata(subchild, code)
+
+        return decorator_name, metadata
+
+    def _parse_decorator_metadata(self, node: Node, code: str) -> dict:
+        """Parse decorator metadata object."""
+        metadata = {}
+
+        for child in node.children:
+            if child.type == "object":
+                for obj_child in child.children:
+                    if obj_child.type == "pair":
+                        key, value = self._parse_object_pair(obj_child, code)
+                        if key:
+                            metadata[key] = value
+
+        return metadata
+
+    def _parse_object_pair(self, node: Node, code: str) -> tuple[str | None, any]:
+        """Parse object key-value pair."""
+        key = None
+        value = None
+
+        children = list(node.children)
+        for i, child in enumerate(children):
+            if child.type == "property_identifier":
+                key = self._get_node_text(child, code)
+            elif child.type == "string":
+                value = self._extract_string_value(child, code)
+            elif child.type == "true":
+                value = True
+            elif child.type == "false":
+                value = False
+            elif child.type == "array":
+                value = self._parse_array(child, code)
+
+        return key, value
+
+    def _parse_array(self, node: Node, code: str) -> list:
+        """Parse array literal."""
+        items = []
+        for child in node.children:
+            if child.type == "identifier":
+                items.append(self._get_node_text(child, code))
+        return items
+
+    def _extract_function_calls(self, root_node: Node, code: str) -> list[dict]:
+        """
+        Extract function calls from AST (Task 1.6).
+
+        Args:
+            root_node: Root AST node
+            code: Source code string
+
+        Returns:
+            List of function call dictionaries
+        """
+        calls = []
+        self._find_function_calls_recursive(root_node, code, calls)
+        return calls
+
+    def _find_function_calls_recursive(self, node: Node, code: str, results: list):
+        """Recursively find call_expression nodes."""
+        if node.type == "call_expression":
+            call_data = self._parse_call_expression(node, code)
+            if call_data:
+                results.append(call_data)
+
+        for child in node.children:
+            self._find_function_calls_recursive(child, code, results)
+
+    # Known HTTP client wrapper function names to detect as API calls
+    HTTP_WRAPPERS = {
+        "getJSON", "postJSON", "putJSON", "patchJSON", "deleteJSON",
+        "requestJSON", "getBlob", "requestBlob", "postFormDataJSON",
+        "fetch", "get", "post", "put", "patch", "delete", "request",
+    }
+    # Member-expression prefixes that indicate HTTP clients (e.g. axios.get)
+    HTTP_PREFIXES = {"axios", "http", "httpClient", "api", "client", "this.http", "this.client"}
+
+    def _parse_call_expression(self, node: Node, code: str) -> dict | None:
+        """Parse a call_expression node, detecting HTTP wrapper calls."""
+        callee = None
+        first_string_arg: str | None = None
+
+        for child in node.children:
+            if child.type == "identifier":
+                callee = self._get_node_text(child, code)
+            elif child.type == "member_expression":
+                callee = self._get_node_text(child, code)
+            elif child.type == "arguments" and first_string_arg is None:
+                first_string_arg = self._extract_first_string_arg(child, code)
+
+        if not callee:
+            return None
+
+        # Determine if this is an HTTP wrapper call
+        is_api_call = False
+        callee_name = callee.split(".")[-1]  # last segment: axios.get -> get
+        callee_prefix = callee.split(".")[0] if "." in callee else ""
+
+        if callee_name in self.HTTP_WRAPPERS or callee_prefix in self.HTTP_PREFIXES:
+            is_api_call = True
+
+        result: dict = {"callee": callee, "line": node.start_point[0] + 1}
+        if is_api_call and first_string_arg and self._is_api_path(first_string_arg):
+            result["is_api_call"] = True
+            result["api_path"] = first_string_arg
+        return result
+
+    # HTTP method verbs that are NOT API paths
+    _HTTP_VERBS = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}
+
+    def _is_api_path(self, value: str) -> bool:
+        """Return True if the string looks like an API path, not an HTTP verb or other arg."""
+        if not value:
+            return False
+        if value.upper() in self._HTTP_VERBS:
+            return False
+        # Must contain at least one slash or letter (e.g. 'user/profile', '/api/v1/items')
+        if "/" not in value and not value.replace("-", "").replace("_", "").isalpha():
+            return False
+        # Reject content-type strings
+        if "content-type" in value.lower() or "application/" in value.lower():
+            return False
+        return True
+
+    def _extract_first_string_arg(self, arguments_node: Node, code: str) -> str | None:
+        """Extract the first string literal from a call's arguments node."""
+        for child in arguments_node.children:
+            if child.type == "string":
+                return self._extract_string_value(child, code)
+            # Template literal — skip (dynamic)
+            if child.type == "template_string":
+                return None
+        return None
+
+    def _extract_string_literals(self, root_node: Node, code: str) -> list[str]:
+        """
+        Extract string literals from AST (Task 1.6).
+
+        Args:
+            root_node: Root AST node
+            code: Source code string
+
+        Returns:
+            List of string literal values
+        """
+        literals = []
+        self._find_string_literals_recursive(root_node, code, literals)
+        return literals
+
+    def _find_string_literals_recursive(self, node: Node, code: str, results: list):
+        """Recursively find string nodes."""
+        if node.type == "string":
+            value = self._extract_string_value(node, code)
+            if value:
+                results.append(value)
+
+        for child in node.children:
+            self._find_string_literals_recursive(child, code, results)