tree-sitter-analyzer 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

tree_sitter_analyzer/languages/java_plugin.py

@@ -12,10 +12,11 @@ from typing import TYPE_CHECKING, Any, Optional
 if TYPE_CHECKING:
     import tree_sitter
 
-    from ..models import AnalysisRequest, AnalysisResult
+    from ..core.analysis_engine import AnalysisRequest
+    from ..models import AnalysisResult
 
 from ..encoding_utils import extract_text_slice, safe_encode
-from ..models import Class, Function, Import, Package, Variable
+from ..models import Class, CodeElement, Function, Import, Package, Variable
 from ..plugins.base import ElementExtractor, LanguagePlugin
 from ..utils import log_debug, log_error, log_warning
 
@@ -209,7 +210,7 @@ class JavaElementExtractor(ElementExtractor):
         Uses batch processing for optimal performance
         """
         if not root_node:
-            return
+            return  # type: ignore[unreachable]
 
         # Target node types for extraction
         target_node_types = set(extractors.keys())
@@ -611,6 +612,9 @@ class JavaElementExtractor(ElementExtractor):
                     "void_type",
                     "primitive_type",
                     "integral_type",
+                    "boolean_type",
+                    "floating_point_type",
+                    "array_type",
                 ]:
                     return_type = self._get_node_text_optimized(child)
                     break
@@ -650,7 +654,15 @@ class JavaElementExtractor(ElementExtractor):
             # Extract type (exactly as in AdvancedAnalyzer)
             field_type = None
             for child in node.children:
-                if child.type in ["type_identifier", "primitive_type", "integral_type"]:
+                if child.type in [
+                    "type_identifier",
+                    "primitive_type",
+                    "integral_type",
+                    "generic_type",
+                    "boolean_type",
+                    "floating_point_type",
+                    "array_type",
+                ]:
                     field_type = self._get_node_text_optimized(child)
                     break
 
@@ -784,38 +796,44 @@ class JavaElementExtractor(ElementExtractor):
         return complexity
 
     def _extract_javadoc_for_line(self, target_line: int) -> str | None:
-        """Extract JavaDoc comment immediately before the specified line (from AdvancedAnalyzer)"""
+        """Extract JavaDoc comment immediately before the specified line"""
         try:
+            if not self.content_lines or target_line <= 1:
+                return None
+
             # Search backwards from target_line
             javadoc_lines = []
             current_line = target_line - 1
 
             # Skip empty lines
-            while current_line > 0 and current_line <= len(self.content_lines):
+            while current_line > 0:
                 line = self.content_lines[current_line - 1].strip()
                 if line:
                     break
                 current_line -= 1
 
             # Check for JavaDoc end
-            if current_line > 0 and current_line <= len(self.content_lines):
+            if current_line > 0:
                 line = self.content_lines[current_line - 1].strip()
                 if line.endswith("*/"):
-                    javadoc_lines.append(line)
+                    # This might be a JavaDoc comment
+                    javadoc_lines.append(self.content_lines[current_line - 1])
                     current_line -= 1
 
                     # Collect JavaDoc content
                     while current_line > 0:
-                        line = self.content_lines[current_line - 1].strip()
-                        javadoc_lines.append(line)
-                        if line.startswith("/**"):
-                            break
-                        current_line -= 1
+                        line_content = self.content_lines[current_line - 1]
+                        line_stripped = line_content.strip()
+                        javadoc_lines.append(line_content)
 
-                    if javadoc_lines and javadoc_lines[-1].startswith("/**"):
-                        # Reverse to correct order
-                        javadoc_lines.reverse()
-                        return "\n".join(javadoc_lines)
+                        if line_stripped.startswith("/**"):
+                            # Found the start of JavaDoc
+                            javadoc_lines.reverse()
+                            javadoc_text = "\n".join(javadoc_lines)
+
+                            # Clean up the JavaDoc
+                            return self._clean_javadoc(javadoc_text)
+                        current_line -= 1
 
             return None
 
@@ -823,6 +841,31 @@ class JavaElementExtractor(ElementExtractor):
             log_debug(f"Failed to extract JavaDoc: {e}")
             return None
 
+    def _clean_javadoc(self, javadoc_text: str) -> str:
+        """Clean JavaDoc text by removing comment markers"""
+        if not javadoc_text:
+            return ""
+
+        lines = javadoc_text.split("\n")
+        cleaned_lines = []
+
+        for line in lines:
+            # Remove leading/trailing whitespace
+            line = line.strip()
+
+            # Remove comment markers
+            if line.startswith("/**"):
+                line = line[3:].strip()
+            elif line.startswith("*/"):
+                line = line[2:].strip()
+            elif line.startswith("*"):
+                line = line[1:].strip()
+
+            if line:  # Only add non-empty lines
+                cleaned_lines.append(line)
+
+        return " ".join(cleaned_lines) if cleaned_lines else ""
+
     def _is_nested_class(self, node: "tree_sitter.Node") -> bool:
         """Check if this is a nested class (from AdvancedAnalyzer)"""
         current = node.parent
@@ -991,7 +1034,7 @@ class JavaPlugin(LanguagePlugin):
             try:
                 import tree_sitter_java as tsjava
 
-                self._language_cache = tsjava.language()
+                self._language_cache = tsjava.language()  # type: ignore
             except ImportError:
                 log_error("tree-sitter-java not available")
                 return None
@@ -1069,32 +1112,34 @@ class JavaPlugin(LanguagePlugin):
             # Extract elements
             extractor = self.create_extractor()
 
-            log_debug("Java Plugin: Extracting annotations...")
-            annotations = extractor.extract_annotations(parse_result.tree, source_code)
-            log_debug(f"Java Plugin: Found {len(annotations)} annotations")
-
-            log_debug("Java Plugin: Extracting packages...")
-            packages = extractor.extract_packages(parse_result.tree, source_code)
-            log_debug(f"Java Plugin: Found {len(packages)} packages")
-
-            log_debug("Java Plugin: Extracting functions...")
-            functions = extractor.extract_functions(parse_result.tree, source_code)
-            log_debug(f"Java Plugin: Found {len(functions)} functions")
+            if parse_result.tree:
+                log_debug("Java Plugin: Extracting functions...")
+                functions = extractor.extract_functions(parse_result.tree, source_code)
+                log_debug(f"Java Plugin: Found {len(functions)} functions")
 
-            log_debug("Java Plugin: Extracting classes...")
-            classes = extractor.extract_classes(parse_result.tree, source_code)
-            log_debug(f"Java Plugin: Found {len(classes)} classes")
+                log_debug("Java Plugin: Extracting classes...")
+                classes = extractor.extract_classes(parse_result.tree, source_code)
+                log_debug(f"Java Plugin: Found {len(classes)} classes")
 
-            log_debug("Java Plugin: Extracting variables...")
-            variables = extractor.extract_variables(parse_result.tree, source_code)
-            log_debug(f"Java Plugin: Found {len(variables)} variables")
+                log_debug("Java Plugin: Extracting variables...")
+                variables = extractor.extract_variables(parse_result.tree, source_code)
+                log_debug(f"Java Plugin: Found {len(variables)} variables")
 
-            log_debug("Java Plugin: Extracting imports...")
-            imports = extractor.extract_imports(parse_result.tree, source_code)
-            log_debug(f"Java Plugin: Found {len(imports)} imports")
-
-            # Combine all elements (annotations are stored in extractor for cross-referencing)
-            all_elements = packages + functions + classes + variables + imports
+                log_debug("Java Plugin: Extracting imports...")
+                imports = extractor.extract_imports(parse_result.tree, source_code)
+                log_debug(f"Java Plugin: Found {len(imports)} imports")
+            else:
+                functions = []
+                classes = []
+                variables = []
+                imports = []
+
+            # Combine all elements
+            all_elements: list[CodeElement] = []
+            all_elements.extend(functions)
+            all_elements.extend(classes)
+            all_elements.extend(variables)
+            all_elements.extend(imports)
             log_debug(f"Java Plugin: Total elements: {len(all_elements)}")
 
             return AnalysisResult(

tree_sitter_analyzer/{plugins → languages}/javascript_plugin.py

@@ -19,9 +19,9 @@ except ImportError:
 
 from ..core.analysis_engine import AnalysisRequest
 from ..language_loader import loader
-from ..models import AnalysisResult, Class, Function, Import, Variable
+from ..models import AnalysisResult, Class, CodeElement, Function, Import, Variable
+from ..plugins.base import ElementExtractor, LanguagePlugin
 from ..utils import log_error, log_warning
-from . import ElementExtractor, LanguagePlugin
 
 
 class JavaScriptElementExtractor(ElementExtractor):
@@ -416,7 +416,7 @@ class JavaScriptPlugin(LanguagePlugin):
             tree = parser.parse(bytes(source_code, "utf8"))
 
             extractor = self.create_extractor()
-            elements = []
+            elements: list[CodeElement] = []
             elements.extend(extractor.extract_functions(tree, source_code))
             elements.extend(extractor.extract_classes(tree, source_code))
             elements.extend(extractor.extract_variables(tree, source_code))

tree_sitter_analyzer/languages/python_plugin.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     from ..core.analysis_engine import AnalysisRequest
     from ..models import AnalysisResult
 
-from ..models import Class, Function, Import, Variable
+from ..models import Class, CodeElement, Function, Import, Variable
 from ..plugins.base import ElementExtractor, LanguagePlugin
 from ..utils import log_error, log_warning
 
@@ -677,13 +677,23 @@ class PythonPlugin(LanguagePlugin):
 
             # Extract elements
             extractor = self.create_extractor()
-            functions = extractor.extract_functions(parse_result.tree, source_code)
-            classes = extractor.extract_classes(parse_result.tree, source_code)
-            variables = extractor.extract_variables(parse_result.tree, source_code)
-            imports = extractor.extract_imports(parse_result.tree, source_code)
+            if parse_result.tree:
+                functions = extractor.extract_functions(parse_result.tree, source_code)
+                classes = extractor.extract_classes(parse_result.tree, source_code)
+                variables = extractor.extract_variables(parse_result.tree, source_code)
+                imports = extractor.extract_imports(parse_result.tree, source_code)
+            else:
+                functions = []
+                classes = []
+                variables = []
+                imports = []
 
             # Combine all elements
-            all_elements = functions + classes + variables + imports
+            all_elements: list[CodeElement] = []
+            all_elements.extend(functions)
+            all_elements.extend(classes)
+            all_elements.extend(variables)
+            all_elements.extend(imports)
 
             return AnalysisResult(
                 file_path=file_path,

tree_sitter_analyzer/mcp/resources/code_file_resource.py

@@ -59,9 +59,6 @@ class CodeFileResource:
         Returns:
             True if the URI matches the code file pattern
         """
-        if not isinstance(uri, str):
-            return False
-
         return bool(self._uri_pattern.match(uri))
 
     def _extract_file_path(self, uri: str) -> str:

tree_sitter_analyzer/mcp/resources/project_stats_resource.py

@@ -83,9 +83,6 @@ class ProjectStatsResource:
         Returns:
             True if the URI matches the project stats pattern
         """
-        if not isinstance(uri, str):
-            return False
-
         return bool(self._uri_pattern.match(uri))
 
     def _extract_stats_type(self, uri: str) -> str:
@@ -336,8 +333,6 @@ class ProjectStatsResource:
                     # Use appropriate analyzer based on language
                     if language == "java":
                         # Use advanced analyzer for Java
-                        if self._advanced_analyzer is None:
-                            self._advanced_analyzer = get_analysis_engine()
                         # 使用 await 调用异步方法
                         file_analysis = await self._advanced_analyzer.analyze_file(
                             str(file_path)

tree_sitter_analyzer/mcp/server.py

@@ -93,7 +93,7 @@ class TreeSitterAnalyzerMCPServer:
         server: Server = Server(self.name)
 
         # Register tools
-        @server.list_tools()
+        @server.list_tools()  # type: ignore
         async def handle_list_tools() -> list[Tool]:
             """List available tools."""
             tools = [
@@ -144,7 +144,7 @@ class TreeSitterAnalyzerMCPServer:
 
             return tools
 
-        @server.call_tool()
+        @server.call_tool()  # type: ignore
         async def handle_call_tool(
             name: str, arguments: dict[str, Any]
         ) -> list[TextContent]:
@@ -201,7 +201,7 @@ class TreeSitterAnalyzerMCPServer:
                 ]
 
         # Register resources
-        @server.list_resources()
+        @server.list_resources()  # type: ignore
         async def handle_list_resources() -> list[Resource]:
             """List available resources."""
             return [
@@ -225,7 +225,7 @@ class TreeSitterAnalyzerMCPServer:
                 ),
             ]
 
-        @server.read_resource()
+        @server.read_resource()  # type: ignore
         async def handle_read_resource(uri: str) -> str:
             """Read resource content."""
             try:

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -214,7 +214,7 @@ class AnalyzeScaleTool:
         Returns:
             Dictionary containing LLM guidance
         """
-        guidance = {
+        guidance: dict[str, Any] = {
             "analysis_strategy": "",
             "recommended_tools": [],
             "key_areas": [],
@@ -417,35 +417,47 @@ class AnalyzeScaleTool:
                         "classes": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Class"
                             ]
                         ),
                         "methods": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Function"
                             ]
                         ),
                         "fields": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Variable"
                             ]
                         ),
                         "imports": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Import"
                             ]
                         ),
-                        "annotations": len(getattr(analysis_result, "annotations", [])),
+                        "annotations": len(
+                            getattr(analysis_result, "annotations", [])
+                            if analysis_result
+                            else []
+                        ),
                         "package": (
                             analysis_result.package.name
-                            if analysis_result.package
+                            if analysis_result and analysis_result.package
                             else None
                         ),
                     },
@@ -458,20 +470,27 @@ class AnalyzeScaleTool:
                 # Add detailed information if requested (backward compatibility)
                 if include_details:
                     result["detailed_analysis"] = {
-                        "statistics": analysis_result.get_statistics(),
+                        "statistics": (
+                            analysis_result.get_statistics() if analysis_result else {}
+                        ),
                         "classes": [
                             {
                                 "name": cls.name,
-                                "type": cls.class_type,
-                                "visibility": cls.visibility,
-                                "extends": cls.extends_class,
-                                "implements": cls.implements_interfaces,
-                                "annotations": [ann.name for ann in cls.annotations],
+                                "type": getattr(cls, "class_type", "unknown"),
+                                "visibility": getattr(cls, "visibility", "unknown"),
+                                "extends": getattr(cls, "extends_class", None),
+                                "implements": getattr(cls, "implements_interfaces", []),
+                                "annotations": [
+                                    getattr(ann, "name", str(ann))
+                                    for ann in getattr(cls, "annotations", [])
+                                ],
                                 "lines": f"{cls.start_line}-{cls.end_line}",
                             }
                             for cls in [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Class"
                             ]
                         ],
@@ -479,35 +498,49 @@ class AnalyzeScaleTool:
                             {
                                 "name": method.name,
                                 "file_path": getattr(method, "file_path", file_path),
-                                "visibility": method.visibility,
-                                "return_type": method.return_type,
-                                "parameters": len(method.parameters),
-                                "annotations": [ann.name for ann in method.annotations],
-                                "is_constructor": method.is_constructor,
-                                "is_static": method.is_static,
-                                "complexity": method.complexity_score,
+                                "visibility": getattr(method, "visibility", "unknown"),
+                                "return_type": getattr(
+                                    method, "return_type", "unknown"
+                                ),
+                                "parameters": len(getattr(method, "parameters", [])),
+                                "annotations": [
+                                    getattr(ann, "name", str(ann))
+                                    for ann in getattr(method, "annotations", [])
+                                ],
+                                "is_constructor": getattr(
+                                    method, "is_constructor", False
+                                ),
+                                "is_static": getattr(method, "is_static", False),
+                                "complexity": getattr(method, "complexity_score", 0),
                                 "lines": f"{method.start_line}-{method.end_line}",
                             }
                             for method in [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Function"
                             ]
                         ],
                         "fields": [
                             {
                                 "name": field.name,
-                                "type": field.field_type,
+                                "type": getattr(field, "field_type", "unknown"),
                                 "file_path": getattr(field, "file_path", file_path),
-                                "visibility": field.visibility,
-                                "is_static": field.is_static,
-                                "is_final": field.is_final,
-                                "annotations": [ann.name for ann in field.annotations],
+                                "visibility": getattr(field, "visibility", "unknown"),
+                                "is_static": getattr(field, "is_static", False),
+                                "is_final": getattr(field, "is_final", False),
+                                "annotations": [
+                                    getattr(ann, "name", str(ann))
+                                    for ann in getattr(field, "annotations", [])
+                                ],
                                 "lines": f"{field.start_line}-{field.end_line}",
                             }
                             for field in [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Variable"
                             ]
                         ],
@@ -517,14 +550,14 @@ class AnalyzeScaleTool:
                 classes_count = len(
                     [
                         e
-                        for e in analysis_result.elements
+                        for e in (analysis_result.elements if analysis_result else [])
                         if e.__class__.__name__ == "Class"
                     ]
                 )
                 methods_count = len(
                     [
                         e
-                        for e in analysis_result.elements
+                        for e in (analysis_result.elements if analysis_result else [])
                         if e.__class__.__name__ == "Function"
                     ]
                 )

tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py

@@ -8,7 +8,7 @@ that matches the CLI --advanced --statistics output exactly.
 
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from ...core.analysis_engine import get_analysis_engine
 from ...language_detector import detect_language_from_file
@@ -104,8 +104,10 @@ class AnalyzeScaleToolCLICompatible:
             # Use AdvancedAnalyzer for comprehensive analysis
             analysis_result = await self.analysis_engine.analyze_file(file_path)
 
-            if analysis_result is None:
-                # Return CLI-compatible error format
+            # Handle potential None result (for testing purposes with mocked engine)
+            # This can only happen in tests where the engine is mocked to return None
+            # Use cast to tell MyPy this is possible in testing scenarios
+            if cast(Any, analysis_result) is None:
                 return {
                     "file_path": file_path,
                     "success": False,
@@ -129,7 +131,10 @@ class AnalyzeScaleToolCLICompatible:
                 "file_path": file_path,
                 "success": True,
                 "package_name": (
-                    analysis_result.package.name if analysis_result.package else None
+                    analysis_result.package.name
+                    if analysis_result.package
+                    and hasattr(analysis_result.package, "name")
+                    else None
                 ),
                 "element_counts": {
                     "imports": len(analysis_result.imports),

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -157,7 +157,7 @@ class TableFormatTool:
         # Fallback to original conversion method
         return self._convert_parameters(parameters)
 
-    def _get_field_modifiers(self, field) -> list:
+    def _get_field_modifiers(self, field: Any) -> list[str]:
         """Extract field modifiers as a list"""
         modifiers = []
 
@@ -172,7 +172,7 @@ class TableFormatTool:
             modifiers.append("final")
         return modifiers
 
-    def _convert_analysis_result_to_dict(self, result) -> dict[str, Any]:
+    def _convert_analysis_result_to_dict(self, result: Any) -> dict[str, Any]:
         """Convert AnalysisResult to dictionary format expected by TableFormatter"""
         # Extract elements by type
         classes = [e for e in result.elements if e.__class__.__name__ == "Class"]

tree_sitter_analyzer/mcp/utils/__init__.py

@@ -9,6 +9,8 @@ Note: Cache and performance monitoring functionality has been moved to
 the unified core services for better architecture.
 """
 
+from typing import Any
+
 # Export main utility classes and functions
 from .error_handler import (
     AnalysisError,
@@ -50,36 +52,36 @@ try:
     class BackwardCompatibleCacheManager:
         """Backward compatible cache manager wrapper"""
 
-        def __init__(self):
+        def __init__(self) -> None:
             self._cache_service = UnifiedCacheService()
 
-        def clear_all_caches(self):
+        def clear_all_caches(self) -> None:
             """Backward compatibility: clear all caches"""
             return self._cache_service.clear()
 
-        def get_cache_stats(self):
+        def get_cache_stats(self) -> dict[str, Any]:
             """Backward compatibility: get cache statistics"""
             return self._cache_service.get_stats()
 
-        def __getattr__(self, name):
+        def __getattr__(self, name: str) -> Any:
             """Delegate other methods to the cache service"""
             return getattr(self._cache_service, name)
 
-    def get_cache_manager():
+    def get_cache_manager() -> Any:
         """Backward compatibility: Get unified cache service"""
         return BackwardCompatibleCacheManager()
 
-    def get_performance_monitor():
+    def get_performance_monitor() -> Any:
         """Backward compatibility: Get unified analysis engine for performance monitoring"""
         return UnifiedAnalysisEngine()
 
 except ImportError:
     # Fallback if core services are not available
-    def get_cache_manager():
+    def get_cache_manager() -> Any:
         """Fallback cache manager"""
         return None
 
-    def get_performance_monitor():
+    def get_performance_monitor() -> Any:
         """Fallback performance monitor"""
         return None
 

tree_sitter_analyzer/models.py

@@ -378,7 +378,7 @@ class AnalysisResult:
                 package_info = {"name": str(self.package)}
 
         # 安全なアイテム処理ヘルパー関数
-        def safe_get_attr(obj, attr, default=""):
+        def safe_get_attr(obj: Any, attr: str, default: Any = "") -> Any:
             if hasattr(obj, attr):
                 return getattr(obj, attr)
             elif isinstance(obj, dict):

tree_sitter_analyzer/output_manager.py

@@ -159,11 +159,8 @@ class OutputManager:
 
     def output_queries(self, queries: list[str]) -> None:
         """Output available queries"""
-        if isinstance(queries, list):
-            query_dict = {q: f"Query {q}" for q in queries}
-            self.query_list(query_dict, "All")
-        else:
-            self.query_list(queries, "All")
+        query_dict = {q: f"Query {q}" for q in queries}
+        self.query_list(query_dict, "All")
 
     def output_extensions(self, extensions: list[str]) -> None:
         """Output file extensions"""
@@ -244,11 +241,8 @@ def output_languages(
 
 def output_queries(queries: list[str], language: str = "All") -> None:
     """Output available queries"""
-    if isinstance(queries, list):
-        query_dict = {q: f"Query {q}" for q in queries}
-        _output_manager.query_list(query_dict, language)
-    else:
-        _output_manager.query_list(queries, language)
+    query_dict = {q: f"Query {q}" for q in queries}
+    _output_manager.query_list(query_dict, language)
 
 
 def output_extensions(extensions: list[str]) -> None: