tree-sitter-analyzer 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

tree_sitter_analyzer/formatters/typescript_formatter.py

@@ -0,0 +1,432 @@
+#!/usr/bin/env python3
+"""
+TypeScript-specific table formatter.
+
+Provides specialized formatting for TypeScript code analysis results,
+handling TypeScript-specific features like interfaces, type aliases, enums,
+generics, decorators, and modern JavaScript features with type annotations.
+"""
+
+from typing import Any
+
+from .base_formatter import BaseTableFormatter
+
+
+class TypeScriptTableFormatter(BaseTableFormatter):
+    """Table formatter specialized for TypeScript"""
+
+    def format(self, data: dict[str, Any]) -> str:
+        """Format data using the configured format type"""
+        return self.format_structure(data)
+
+    def _format_full_table(self, data: dict[str, Any]) -> str:
+        """Full table format for TypeScript"""
+        lines = []
+
+        # Header - TypeScript (module/file based)
+        file_path = data.get("file_path", "Unknown")
+        file_name = file_path.split("/")[-1].split("\\")[-1]
+        module_name = (
+            file_name.replace(".ts", "").replace(".tsx", "").replace(".d.ts", "")
+        )
+
+        # Check if this is a module (has exports, classes, interfaces, or functions)
+        exports = data.get("exports", [])
+        classes = data.get("classes", [])
+        interfaces = data.get("interfaces", [])
+        functions = data.get("functions", [])
+        is_module = len(exports) > 0 or len(classes) > 0 or len(interfaces) > 0 or len(functions) > 0
+        is_declaration_file = file_name.endswith(".d.ts")
+        is_tsx = file_name.endswith(".tsx")
+
+        if is_declaration_file:
+            lines.append(f"# Declaration File: {module_name}")
+        elif is_tsx:
+            lines.append(f"# TSX Module: {module_name}")
+        elif is_module:
+            lines.append(f"# TypeScript Module: {module_name}")
+        else:
+            lines.append(f"# TypeScript Script: {module_name}")
+        lines.append("")
+
+        # Imports
+        imports = data.get("imports", [])
+        if imports:
+            lines.append("## Imports")
+            lines.append("```typescript")
+            for imp in imports:
+                import_statement = imp.get("statement", "")
+                if not import_statement:
+                    # Construct import statement from parts
+                    source = imp.get("source", "")
+                    name = imp.get("name", "")
+                    is_type_import = imp.get("is_type_import", False)
+                    if name and source:
+                        type_prefix = "type " if is_type_import else ""
+                        import_statement = f"import {type_prefix}{name} from {source};"
+                lines.append(import_statement)
+            lines.append("```")
+            lines.append("")
+
+        # Module Info
+        stats = data.get("statistics", {})
+        classes = data.get("classes", [])
+        interfaces = [c for c in classes if c.get("class_type") == "interface"]
+        type_aliases = [c for c in classes if c.get("class_type") == "type"]
+        enums = [c for c in classes if c.get("class_type") == "enum"]
+        actual_classes = [c for c in classes if c.get("class_type") in ["class", "abstract_class"]]
+
+        lines.append("## Module Info")
+        lines.append("| Property | Value |")
+        lines.append("|----------|-------|")
+        lines.append(f"| File | {file_name} |")
+        lines.append(f"| Type | {'Declaration File' if is_declaration_file else 'TSX Module' if is_tsx else 'TypeScript Module' if is_module else 'TypeScript Script'} |")
+        lines.append(f"| Functions | {stats.get('function_count', 0)} |")
+        lines.append(f"| Classes | {len(actual_classes)} |")
+        lines.append(f"| Interfaces | {len(interfaces)} |")
+        lines.append(f"| Type Aliases | {len(type_aliases)} |")
+        lines.append(f"| Enums | {len(enums)} |")
+        lines.append(f"| Variables | {stats.get('variable_count', 0)} |")
+        lines.append(f"| Exports | {len(exports)} |")
+        lines.append("")
+
+        # Interfaces (TypeScript specific)
+        if interfaces:
+            lines.append("## Interfaces")
+            lines.append("| Interface | Extends | Lines | Properties | Methods | Generics |")
+            lines.append("|-----------|---------|-------|------------|---------|----------|")
+
+            for interface in interfaces:
+                name = str(interface.get("name", "Unknown"))
+                extends = ", ".join(interface.get("interfaces", [])) or "-"
+                line_range = interface.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                
+                # Count properties and methods within the interface
+                interface_properties = [
+                    v for v in data.get("variables", [])
+                    if line_range.get("start", 0) <= v.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    and v.get("declaration_kind") == "property_signature"
+                ]
+                
+                interface_methods = [
+                    m for m in data.get("methods", [])
+                    if line_range.get("start", 0) <= m.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    and m.get("is_signature", False)
+                ]
+                
+                generics = ", ".join(interface.get("generics", [])) or "-"
+
+                lines.append(f"| {name} | {extends} | {lines_str} | {len(interface_properties)} | {len(interface_methods)} | {generics} |")
+            lines.append("")
+
+        # Type Aliases (TypeScript specific)
+        if type_aliases:
+            lines.append("## Type Aliases")
+            lines.append("| Type | Lines | Generics | Definition |")
+            lines.append("|------|-------|----------|------------|")
+
+            for type_alias in type_aliases:
+                name = str(type_alias.get("name", "Unknown"))
+                line_range = type_alias.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                generics = ", ".join(type_alias.get("generics", [])) or "-"
+                
+                # Extract type definition from raw text
+                raw_text = type_alias.get("raw_text", "")
+                if "=" in raw_text:
+                    definition = raw_text.split("=", 1)[1].strip().rstrip(";")[:50]
+                    if len(definition) > 47:
+                        definition = definition[:47] + "..."
+                else:
+                    definition = "-"
+
+                lines.append(f"| {name} | {lines_str} | {generics} | {definition} |")
+            lines.append("")
+
+        # Enums (TypeScript specific)
+        if enums:
+            lines.append("## Enums")
+            lines.append("| Enum | Lines | Values |")
+            lines.append("|------|-------|--------|")
+
+            for enum in enums:
+                name = str(enum.get("name", "Unknown"))
+                line_range = enum.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                
+                # Count enum values (simplified)
+                raw_text = enum.get("raw_text", "")
+                value_count = raw_text.count(",") + 1 if raw_text.count("{") > 0 else 0
+
+                lines.append(f"| {name} | {lines_str} | {value_count} |")
+            lines.append("")
+
+        # Classes
+        if actual_classes:
+            lines.append("## Classes")
+            lines.append("| Class | Type | Extends | Implements | Lines | Methods | Properties | Generics |")
+            lines.append("|-------|------|---------|------------|-------|---------|------------|----------|")
+
+            for class_info in actual_classes:
+                name = str(class_info.get("name", "Unknown"))
+                class_type = class_info.get("class_type", "class")
+                extends = str(class_info.get("superclass", "")) or "-"
+                implements = ", ".join(class_info.get("interfaces", [])) or "-"
+                line_range = class_info.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                generics = ", ".join(class_info.get("generics", [])) or "-"
+
+                # Count methods within the class
+                class_methods = [
+                    m for m in data.get("functions", [])
+                    if (line_range.get("start", 0) <= m.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                        and m.get("is_method", False)
+                        and not m.get("is_signature", False))
+                ]
+
+                # Count properties (class fields)
+                class_properties = [
+                    v for v in data.get("variables", [])
+                    if line_range.get("start", 0) <= v.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    and v.get("declaration_kind") == "property"
+                ]
+
+                lines.append(f"| {name} | {class_type} | {extends} | {implements} | {lines_str} | {len(class_methods)} | {len(class_properties)} | {generics} |")
+            lines.append("")
+
+        # Functions
+        functions = data.get("functions", [])
+        if functions:
+            lines.append("## Functions")
+            lines.append("| Function | Type | Return Type | Parameters | Async | Generic | Lines | Complexity |")
+            lines.append("|----------|------|-------------|------------|-------|---------|-------|------------|")
+
+            for func in functions:
+                name = str(func.get("name", "Unknown"))
+                func_type = "arrow" if func.get("is_arrow") else "method" if func.get("is_method") else "function"
+                return_type = str(func.get("return_type", "any"))
+                params = func.get("parameters", [])
+                param_count = len(params)
+                is_async = "✓" if func.get("is_async") else ""
+                has_generics = "✓" if func.get("generics") else ""
+                line_range = func.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                complexity = func.get("complexity_score", 1)
+
+                lines.append(f"| {name} | {func_type} | {return_type} | {param_count} | {is_async} | {has_generics} | {lines_str} | {complexity} |")
+            lines.append("")
+
+        # Variables/Properties
+        variables = data.get("variables", [])
+        if variables:
+            lines.append("## Variables & Properties")
+            lines.append("| Name | Type | Kind | Visibility | Static | Optional | Lines |")
+            lines.append("|------|------|------|------------|--------|----------|-------|")
+
+            for var in variables:
+                name = str(var.get("name", "Unknown"))
+                var_type = str(var.get("variable_type", "any"))
+                kind = var.get("declaration_kind", "variable")
+                visibility = var.get("visibility", "public")
+                is_static = "✓" if var.get("is_static") else ""
+                is_optional = "✓" if var.get("is_optional") else ""
+                line_range = var.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+                lines.append(f"| {name} | {var_type} | {kind} | {visibility} | {is_static} | {is_optional} | {lines_str} |")
+            lines.append("")
+
+        # Exports
+        if exports:
+            lines.append("## Exports")
+            lines.append("| Export | Type | Default |")
+            lines.append("|--------|------|---------|")
+
+            for export in exports:
+                names = export.get("names", [])
+                export_type = export.get("type", "unknown")
+                is_default = "✓" if export.get("is_default") else ""
+
+                for name in names:
+                    lines.append(f"| {name} | {export_type} | {is_default} |")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_compact_table(self, data: dict[str, Any]) -> str:
+        """Compact table format for TypeScript"""
+        lines = []
+
+        # Header
+        file_path = data.get("file_path", "Unknown")
+        file_name = file_path.split("/")[-1].split("\\")[-1]
+        lines.append(f"# {file_name}")
+        lines.append("")
+
+        # Summary
+        stats = data.get("statistics", {})
+        classes = data.get("classes", [])
+        functions = data.get("functions", [])
+        variables = data.get("variables", [])
+
+        interfaces = len([c for c in classes if c.get("class_type") == "interface"])
+        type_aliases = len([c for c in classes if c.get("class_type") == "type"])
+        enums = len([c for c in classes if c.get("class_type") == "enum"])
+        actual_classes = len([c for c in classes if c.get("class_type") in ["class", "abstract_class"]])
+
+        lines.append("## Summary")
+        lines.append(f"- **Classes**: {actual_classes}")
+        lines.append(f"- **Interfaces**: {interfaces}")
+        lines.append(f"- **Type Aliases**: {type_aliases}")
+        lines.append(f"- **Enums**: {enums}")
+        lines.append(f"- **Functions**: {len(functions)}")
+        lines.append(f"- **Variables**: {len(variables)}")
+        lines.append("")
+
+        # Main elements
+        if classes:
+            lines.append("## Types")
+            for class_info in classes:
+                name = class_info.get("name", "Unknown")
+                class_type = class_info.get("class_type", "class")
+                line_range = class_info.get("line_range", {})
+                lines_str = f"L{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                lines.append(f"- **{name}** ({class_type}) - {lines_str}")
+            lines.append("")
+
+        if functions:
+            lines.append("## Functions")
+            for func in functions:
+                name = func.get("name", "Unknown")
+                return_type = func.get("return_type", "any")
+                line_range = func.get("line_range", {})
+                lines_str = f"L{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                async_marker = " (async)" if func.get("is_async") else ""
+                lines.append(f"- **{name}**(): {return_type}{async_marker} - {lines_str}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_csv(self, data: dict[str, Any]) -> str:
+        """CSV format for TypeScript"""
+        lines = []
+
+        # Header
+        lines.append("Type,Name,Kind,Return/Type,Lines,Visibility,Static,Async,Generic")
+
+        # Classes, interfaces, types, enums
+        classes = data.get("classes", [])
+        for class_info in classes:
+            name = class_info.get("name", "")
+            class_type = class_info.get("class_type", "class")
+            line_range = class_info.get("line_range", {})
+            lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+            visibility = class_info.get("visibility", "public")
+            is_static = "true" if class_info.get("is_static") else "false"
+            has_generics = "true" if class_info.get("generics") else "false"
+
+            lines.append(f"Class,{name},{class_type},,{lines_str},{visibility},{is_static},,{has_generics}")
+
+        # Functions
+        functions = data.get("functions", [])
+        for func in functions:
+            name = func.get("name", "")
+            func_type = "arrow" if func.get("is_arrow") else "method" if func.get("is_method") else "function"
+            return_type = func.get("return_type", "any")
+            line_range = func.get("line_range", {})
+            lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+            visibility = func.get("visibility", "public")
+            is_static = "true" if func.get("is_static") else "false"
+            is_async = "true" if func.get("is_async") else "false"
+            has_generics = "true" if func.get("generics") else "false"
+
+            lines.append(f"Function,{name},{func_type},{return_type},{lines_str},{visibility},{is_static},{is_async},{has_generics}")
+
+        # Variables
+        variables = data.get("variables", [])
+        for var in variables:
+            name = var.get("name", "")
+            kind = var.get("declaration_kind", "variable")
+            var_type = var.get("variable_type", "any")
+            line_range = var.get("line_range", {})
+            lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+            visibility = var.get("visibility", "public")
+            is_static = "true" if var.get("is_static") else "false"
+
+            lines.append(f"Variable,{name},{kind},{var_type},{lines_str},{visibility},{is_static},,")
+
+        return "\n".join(lines)
+
+    def _get_element_type_name(self, element: dict[str, Any]) -> str:
+        """Get human-readable type name for TypeScript elements"""
+        element_type = element.get("element_type", "unknown")
+        
+        if element_type == "class":
+            class_type = element.get("class_type", "class")
+            if class_type == "interface":
+                return "Interface"
+            elif class_type == "type":
+                return "Type Alias"
+            elif class_type == "enum":
+                return "Enum"
+            elif class_type == "abstract_class":
+                return "Abstract Class"
+            else:
+                return "Class"
+        elif element_type == "function":
+            if element.get("is_arrow"):
+                return "Arrow Function"
+            elif element.get("is_method"):
+                return "Method"
+            elif element.get("is_constructor"):
+                return "Constructor"
+            else:
+                return "Function"
+        elif element_type == "variable":
+            kind = element.get("declaration_kind", "variable")
+            if kind == "property":
+                return "Property"
+            elif kind == "property_signature":
+                return "Property Signature"
+            else:
+                return "Variable"
+        elif element_type == "import":
+            return "Import"
+        else:
+            return element_type.title()
+
+    def _format_element_details(self, element: dict[str, Any]) -> str:
+        """Format TypeScript-specific element details"""
+        details = []
+        
+        # Type annotations
+        if element.get("has_type_annotations"):
+            details.append("typed")
+        
+        # Generics
+        if element.get("generics"):
+            generics = ", ".join(element.get("generics", []))
+            details.append(f"<{generics}>")
+        
+        # Visibility
+        visibility = element.get("visibility")
+        if visibility and visibility != "public":
+            details.append(visibility)
+        
+        # Modifiers
+        if element.get("is_static"):
+            details.append("static")
+        if element.get("is_async"):
+            details.append("async")
+        if element.get("is_abstract"):
+            details.append("abstract")
+        if element.get("is_optional"):
+            details.append("optional")
+        
+        # Framework specific
+        framework = element.get("framework_type")
+        if framework:
+            details.append(f"{framework}")
+        
+        return " ".join(details) if details else ""

tree_sitter_analyzer/language_detector.py

@@ -23,7 +23,7 @@ class LanguageDetector:
         ".js": "javascript",
         ".jsx": "jsx",
         ".ts": "typescript",
-        ".tsx": "tsx",
+        ".tsx": "typescript",  # TSX files are TypeScript with JSX
         ".mjs": "javascript",
         ".cjs": "javascript",
         # Python系

tree_sitter_analyzer/languages/java_plugin.py

@@ -201,9 +201,12 @@ class JavaElementExtractor(ElementExtractor):
                         import_name = static_match.group(1)
                         if import_content.endswith(".*"):
                             import_name = import_name.replace(".*", "")
-                            parts = import_name.split(".")
-                            if len(parts) > 1:
-                                import_name = ".".join(parts[:-1])
+                        
+                        # For static imports, extract the class name (remove method/field name)
+                        parts = import_name.split(".")
+                        if len(parts) > 1:
+                            # Remove the last part (method/field name) to get class name
+                            import_name = ".".join(parts[:-1])
 
                         imports.append(
                             Import(
@@ -255,6 +258,10 @@ class JavaElementExtractor(ElementExtractor):
         packages: list[Package] = []
 
         # Extract package declaration
+        if tree is None or tree.root_node is None:
+            log_debug("Tree or root_node is None, returning empty packages list")
+            return packages
+            
         for child in tree.root_node.children:
             if child.type == "package_declaration":
                 package_info = self._extract_package_element(child)
@@ -1054,10 +1061,12 @@ class JavaElementExtractor(ElementExtractor):
                     # Handle wildcard case
                     if import_content.endswith(".*"):
                         import_name = import_name.replace(".*", "")
-                        # For static wildcard, remove last element
-                        parts = import_name.split(".")
-                        if len(parts) > 1:
-                            import_name = ".".join(parts[:-1])
+                    
+                    # For static imports, extract the class name (remove method/field name)
+                    parts = import_name.split(".")
+                    if len(parts) > 1:
+                        # Remove the last part (method/field name) to get class name
+                        import_name = ".".join(parts[:-1])
 
                     return Import(
                         name=import_name,
@@ -1099,6 +1108,20 @@ class JavaElementExtractor(ElementExtractor):
             log_error(f"Unexpected error in import extraction: {e}")
         return None
 
+    def extract_elements(self, tree: "tree_sitter.Tree", source_code: str) -> list:
+        """Extract elements from source code using tree-sitter AST"""
+        elements = []
+        
+        try:
+            elements.extend(self.extract_functions(tree, source_code))
+            elements.extend(self.extract_classes(tree, source_code))
+            elements.extend(self.extract_variables(tree, source_code))
+            elements.extend(self.extract_imports(tree, source_code))
+        except Exception as e:
+            log_error(f"Failed to extract elements: {e}")
+        
+        return elements
+
 
 class JavaPlugin(LanguagePlugin):
     """Java language plugin for the new architecture"""
@@ -1107,6 +1130,12 @@ class JavaPlugin(LanguagePlugin):
         """Initialize the Java plugin"""
         super().__init__()
         self._language_cache: tree_sitter.Language | None = None
+        self._extractor: Optional[JavaElementExtractor] = None
+        
+        # Legacy attributes for backward compatibility with tests
+        self.language = "java"
+        self.extractor = self.create_extractor()
+        self.supported_extensions = self.get_file_extensions()
 
     def get_language_name(self) -> str:
         """Return the name of the programming language this plugin supports"""
@@ -1120,6 +1149,12 @@ class JavaPlugin(LanguagePlugin):
         """Create and return an element extractor for this language"""
         return JavaElementExtractor()
 
+    def get_extractor(self) -> ElementExtractor:
+        """Get the cached extractor instance, creating it if necessary"""
+        if self._extractor is None:
+            self._extractor = JavaElementExtractor()
+        return self._extractor
+
     def get_tree_sitter_language(self) -> Optional["tree_sitter.Language"]:
         """Get the Tree-sitter language object for Java"""
         if self._language_cache is None:
@@ -1270,3 +1305,29 @@ class JavaPlugin(LanguagePlugin):
                 success=False,
                 error_message=str(e),
             )
+
+    def extract_elements(self, tree: "tree_sitter.Tree", source_code: str) -> dict[str, list[CodeElement]]:
+        """Legacy method for backward compatibility with tests"""
+        if not tree or not tree.root_node:
+            return {
+                "packages": [],
+                "functions": [],
+                "classes": [],
+                "variables": [],
+                "imports": [],
+                "annotations": []
+            }
+        
+        extractor = self.create_extractor()
+        
+        # Extract all types of elements and return as dictionary
+        result = {
+            "packages": extractor.extract_packages(tree, source_code),
+            "functions": extractor.extract_functions(tree, source_code),
+            "classes": extractor.extract_classes(tree, source_code),
+            "variables": extractor.extract_variables(tree, source_code),
+            "imports": extractor.extract_imports(tree, source_code),
+            "annotations": extractor.extract_annotations(tree, source_code)
+        }
+        
+        return result

tree_sitter_analyzer/languages/javascript_plugin.py

@@ -558,7 +558,8 @@ class JavaScriptElementExtractor(ElementExtractor):
                 elif child.type == "class_heritage":
                     # Extract extends clause
                     heritage_text = self._get_node_text_optimized(child)
-                    match = re.search(r"extends\s+(\w+)", heritage_text)
+                    # Support both simple names (Component) and dotted names (React.Component)
+                    match = re.search(r"extends\s+([\w.]+)", heritage_text)
                     if match:
                         superclass = match.group(1)
 
@@ -1217,6 +1218,20 @@ class JavaScriptElementExtractor(ElementExtractor):
         else:
             return "unknown"
 
+    def extract_elements(self, tree: "tree_sitter.Tree", source_code: str) -> list:
+        """Extract elements from source code using tree-sitter AST"""
+        elements = []
+        
+        try:
+            elements.extend(self.extract_functions(tree, source_code))
+            elements.extend(self.extract_classes(tree, source_code))
+            elements.extend(self.extract_variables(tree, source_code))
+            elements.extend(self.extract_imports(tree, source_code))
+        except Exception as e:
+            log_error(f"Failed to extract elements: {e}")
+        
+        return elements
+
     def _get_variable_kind(self, var_data: dict | str) -> str:
         """Get variable declaration kind from variable data or raw text"""
         if isinstance(var_data, dict):
@@ -1344,6 +1359,11 @@ class JavaScriptPlugin(LanguagePlugin):
     def __init__(self) -> None:
         self._extractor = JavaScriptElementExtractor()
         self._language: tree_sitter.Language | None = None
+        
+        # Legacy compatibility attributes for tests
+        self.language = "javascript"
+        self.extractor = self._extractor
+        self.supported_extensions = [".js", ".mjs", ".jsx", ".es6", ".es", ".cjs"]
 
     @property
     def language_name(self) -> str:
@@ -1495,3 +1515,25 @@ class JavaScriptPlugin(LanguagePlugin):
                 success=False,
                 error_message=str(e),
             )
+
+    def extract_elements(self, tree: "tree_sitter.Tree", source_code: str) -> dict:
+        """Extract elements from source code using tree-sitter AST"""
+        try:
+            if tree is None or not hasattr(tree, 'root_node') or tree.root_node is None:
+                return {"functions": [], "classes": [], "variables": [], "imports": [], "exports": []}
+            
+            functions = self._extractor.extract_functions(tree, source_code)
+            classes = self._extractor.extract_classes(tree, source_code)
+            variables = self._extractor.extract_variables(tree, source_code)
+            imports = self._extractor.extract_imports(tree, source_code)
+            
+            return {
+                "functions": functions,
+                "classes": classes,
+                "variables": variables,
+                "imports": imports,
+                "exports": []  # TODO: Implement exports extraction
+            }
+        except Exception as e:
+            log_error(f"Failed to extract elements: {e}")
+            return {"functions": [], "classes": [], "variables": [], "imports": [], "exports": []}