tree-sitter-analyzer 1.9.1__py3-none-any.whl → 1.9.3__py3-none-any.whl

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.9.1"
+__version__ = "1.9.3"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/api.py

@@ -85,7 +85,8 @@ def analyze_file(
 
         # Add elements if requested and available
         if include_elements and hasattr(analysis_result, "elements"):
-            result["elements"] = []
+            elements_list: list[dict[str, Any]] = []
+            result["elements"] = elements_list
             for elem in analysis_result.elements:
                 elem_dict = {
                     "name": elem.name,
@@ -145,7 +146,7 @@ def analyze_file(
                     else:
                         elem_dict["class_name"] = None
 
-                result["elements"].append(elem_dict)
+                elements_list.append(elem_dict)
 
         # Add query results if requested and available
         if include_queries and hasattr(analysis_result, "query_results"):
@@ -219,7 +220,8 @@ def analyze_code(
 
         # Add elements if requested and available
         if include_elements and hasattr(analysis_result, "elements"):
-            result["elements"] = []
+            elements_list: list[dict[str, Any]] = []
+            result["elements"] = elements_list
             for elem in analysis_result.elements:
                 elem_dict = {
                     "name": elem.name,
@@ -279,7 +281,7 @@ def analyze_code(
                     else:
                         elem_dict["class_name"] = None
 
-                result["elements"].append(elem_dict)
+                elements_list.append(elem_dict)
 
         # Add query results if requested and available
         if include_queries and hasattr(analysis_result, "query_results"):
@@ -454,8 +456,10 @@ def validate_file(file_path: str | Path) -> dict[str, Any]:
 
         # Check if file is readable
         try:
-            with open(file_path, encoding="utf-8") as f:
-                f.read(100)  # Read first 100 chars to test
+            from .encoding_utils import read_file_safe
+
+            # Test file readability by reading it
+            read_file_safe(file_path)
             result["readable"] = True
             result["size"] = file_path.stat().st_size
         except Exception as e:

tree_sitter_analyzer/cli/argument_validator.py

@@ -11,7 +11,7 @@ from typing import Any
 class CLIArgumentValidator:
     """Validator for CLI argument combinations."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the validator."""
         pass
 

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -49,8 +49,9 @@ class AdvancedCommand(BaseCommand):
             Dictionary containing file metrics
         """
         try:
-            with open(file_path, encoding="utf-8") as f:
-                content = f.read()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(file_path)
 
             lines = content.split("\n")
             total_lines = len(lines)
@@ -111,10 +112,6 @@ class AdvancedCommand(BaseCommand):
                     if "-->" not in stripped:
                         in_multiline_comment = True
                     continue
-                elif in_multiline_comment and "-->" in stripped:
-                    comment_lines += 1
-                    in_multiline_comment = False
-                    continue
 
                 # If not a comment, it's code
                 code_lines += 1

tree_sitter_analyzer/cli/commands/query_command.py

@@ -5,6 +5,8 @@ Query Command
 Handles query execution functionality.
 """
 
+from typing import Any
+
 from ...core.query_service import QueryService
 from ...output_manager import output_data, output_error, output_info, output_json
 from .base_command import BaseCommand
@@ -13,7 +15,7 @@ from .base_command import BaseCommand
 class QueryCommand(BaseCommand):
     """Command for executing queries."""
 
-    def __init__(self, args):
+    def __init__(self, args: Any) -> None:
         """Initialize the query command with QueryService."""
         super().__init__(args)
         self.query_service = QueryService()

tree_sitter_analyzer/cli/commands/table_command.py

@@ -25,7 +25,7 @@ from .base_command import BaseCommand
 class TableCommand(BaseCommand):
     """Command for generating table format output."""
 
-    def __init__(self, args):
+    def __init__(self, args: Any) -> None:
         """Initialize the table command."""
         super().__init__(args)
 
@@ -56,10 +56,10 @@ class TableCommand(BaseCommand):
 
             # Create table formatter
             include_javadoc = getattr(self.args, "include_javadoc", False)
-            formatter = create_table_formatter(
+            table_formatter: Any = create_table_formatter(
                 self.args.table, language, include_javadoc
             )
-            table_output = formatter.format_structure(structure_result)
+            table_output = table_formatter.format_structure(structure_result)
 
             # Output table
             self._output_table(table_output)

tree_sitter_analyzer/constants.py

@@ -5,6 +5,8 @@ Constants for tree-sitter-analyzer
 This module defines constants used throughout the project to ensure consistency.
 """
 
+from typing import Any, cast
+
 # Element types for unified element management system
 ELEMENT_TYPE_CLASS = "class"
 ELEMENT_TYPE_FUNCTION = "function"
@@ -34,7 +36,7 @@ LEGACY_CLASS_MAPPING = {
 }
 
 
-def get_element_type(element) -> str:
+def get_element_type(element: Any) -> str:
     """
     Get the element type from an element object.
 
@@ -45,7 +47,7 @@ def get_element_type(element) -> str:
         Standardized element type string
     """
     if hasattr(element, "element_type"):
-        return element.element_type
+        return cast(str, element.element_type)
 
     if hasattr(element, "__class__") and hasattr(element.__class__, "__name__"):
         class_name = element.__class__.__name__
@@ -54,7 +56,7 @@ def get_element_type(element) -> str:
     return "unknown"
 
 
-def is_element_of_type(element, element_type: str) -> bool:
+def is_element_of_type(element: Any, element_type: str) -> bool:
     """
     Check if an element is of a specific type.
 

tree_sitter_analyzer/core/analysis_engine.py

@@ -218,7 +218,7 @@ class UnifiedAnalysisEngine:
                     instance = super().__new__(cls)
                     cls._instances[instance_key] = instance
                     # Mark as not initialized for this instance
-                    instance._initialized: bool = False
+                    instance._initialized = False
 
         return cls._instances[instance_key]
 

tree_sitter_analyzer/core/cache_service.py

@@ -18,7 +18,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Any
 
-from cachetools import LRUCache, TTLCache
+from cachetools import LRUCache, TTLCache  # type: ignore[import-untyped]
 
 from ..utils import log_debug, log_info
 

tree_sitter_analyzer/core/engine.py

@@ -535,7 +535,7 @@ class AnalysisEngine:
             logger.error(f"Error getting extensions for {language}: {e}")
             return []
 
-    def get_registry_info(self) -> dict:
+    def get_registry_info(self) -> dict[str, Any]:
         """
         Get registry information (compatibility method)
 

tree_sitter_analyzer/core/query.py

@@ -64,7 +64,6 @@ class QueryExecutor:
             # Validate inputs
             if tree is None:
                 return self._create_error_result("Tree is None", query_name=query_name)
-
             if language is None:
                 return self._create_error_result(  # type: ignore[unreachable]
                     "Language is None", query_name=query_name
@@ -166,7 +165,6 @@ class QueryExecutor:
             # Validate inputs
             if tree is None:
                 return self._create_error_result("Tree is None")
-
             if language is None:
                 return self._create_error_result("Language is None")  # type: ignore[unreachable]
 

tree_sitter_analyzer/exceptions.py

@@ -616,7 +616,7 @@ def create_mcp_error_response(
 
 def _sanitize_error_context(context: dict[str, Any]) -> dict[str, Any]:
     """Sanitize sensitive information from error context."""
-    sanitized = {}
+    sanitized: dict[str, Any] = {}
     sensitive_keys = {
         "password",
         "token",

tree_sitter_analyzer/file_handler.py

@@ -14,19 +14,19 @@ from .utils import setup_logger
 logger = setup_logger(__name__)
 
 
-def log_error(message: str, *args, **kwargs) -> None:
+def log_error(message: str, *args: object, **kwargs: object) -> None:
     """Log error message"""
-    logger.error(message, *args, **kwargs)
+    logger.error(message, *args, **kwargs)  # type: ignore[arg-type]
 
 
-def log_info(message: str, *args, **kwargs) -> None:
+def log_info(message: str, *args: object, **kwargs: object) -> None:
     """Log info message"""
-    logger.info(message, *args, **kwargs)
+    logger.info(message, *args, **kwargs)  # type: ignore[arg-type]
 
 
-def log_warning(message: str, *args, **kwargs) -> None:
+def log_warning(message: str, *args: object, **kwargs: object) -> None:
     """Log warning message"""
-    logger.warning(message, *args, **kwargs)
+    logger.warning(message, *args, **kwargs)  # type: ignore[arg-type]
 
 
 def detect_language_from_extension(file_path: str) -> str:

tree_sitter_analyzer/formatters/base_formatter.py

@@ -13,7 +13,7 @@ class BaseFormatter(ABC):
     """Base class for language-specific formatters"""
 
     @abstractmethod
-    def __init__(self):
+    def __init__(self) -> None:
         pass
 
     @abstractmethod

tree_sitter_analyzer/formatters/html_formatter.py

@@ -17,7 +17,7 @@ from .formatter_registry import IFormatter
 class HtmlFormatter(BaseFormatter, IFormatter):
     """HTML-specific formatter for MarkupElement and StyleElement"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize HTML formatter"""
         pass
 
@@ -37,7 +37,7 @@ class HtmlFormatter(BaseFormatter, IFormatter):
         # Handle both CodeElement objects and dictionaries
         markup_elements = []
         style_elements = []
-        other_elements = []
+        other_elements: list[dict[str, Any]] = []
 
         for e in elements:
             if isinstance(e, MarkupElement):
@@ -54,7 +54,7 @@ class HtmlFormatter(BaseFormatter, IFormatter):
                 else:
                     other_elements.append(e)
             else:
-                other_elements.append(e)
+                other_elements.append(self._element_to_dict(e))
 
         # Format markup elements
         if markup_elements:
@@ -114,7 +114,7 @@ class HtmlFormatter(BaseFormatter, IFormatter):
         elements = analysis_result.get("elements", [])
 
         if table_type == "compact":
-            formatter = HtmlCompactFormatter()
+            formatter: IFormatter = HtmlCompactFormatter()
             return formatter.format(elements)
         elif table_type == "json":
             formatter = HtmlJsonFormatter()
@@ -130,7 +130,7 @@ class HtmlFormatter(BaseFormatter, IFormatter):
         lines.append("")
 
         # Group by element class
-        element_groups = {}
+        element_groups: dict[str, list[MarkupElement]] = {}
         for element in elements:
             element_class = element.element_class or "unknown"
             if element_class not in element_groups:
@@ -217,7 +217,7 @@ class HtmlFormatter(BaseFormatter, IFormatter):
         lines.append("")
 
         # Group by element class
-        element_groups = {}
+        element_groups: dict[str, list[StyleElement]] = {}
         for element in elements:
             element_class = element.element_class or "unknown"
             if element_class not in element_groups:
@@ -280,30 +280,30 @@ class HtmlFormatter(BaseFormatter, IFormatter):
         lines.append("")
         return lines
 
-    def _dict_to_markup_element(self, data: dict):
+    def _dict_to_markup_element(self, data: dict) -> Any:
         """Convert dictionary to MarkupElement-like object"""
 
         # Create a mock MarkupElement-like object
         class MockMarkupElement:
-            def __init__(self, data):
+            def __init__(self, data: dict[str, Any]) -> None:
                 self.name = data.get("name", "unknown")
                 self.tag_name = data.get("tag_name", data.get("name", "unknown"))
                 self.element_class = data.get("element_class", "unknown")
                 self.start_line = data.get("start_line", 0)
                 self.end_line = data.get("end_line", 0)
                 self.attributes = data.get("attributes", {})
-                self.children = []
+                self.children: list[MockMarkupElement] = []
                 self.parent = None
                 self.language = data.get("language", "html")
 
         return MockMarkupElement(data)
 
-    def _dict_to_style_element(self, data: dict):
+    def _dict_to_style_element(self, data: dict) -> Any:
         """Convert dictionary to StyleElement-like object"""
 
         # Create a mock StyleElement-like object
         class MockStyleElement:
-            def __init__(self, data):
+            def __init__(self, data: dict[str, Any]) -> None:
                 self.name = data.get("name", "unknown")
                 self.selector = data.get("selector", data.get("name", "unknown"))
                 self.element_class = data.get("element_class", "unknown")
@@ -314,6 +314,16 @@ class HtmlFormatter(BaseFormatter, IFormatter):
 
         return MockStyleElement(data)
 
+    def _element_to_dict(self, element: CodeElement) -> dict[str, Any]:
+        """Convert generic CodeElement to dictionary"""
+        return {
+            "name": element.name,
+            "type": getattr(element, "element_type", "unknown"),
+            "start_line": element.start_line,
+            "end_line": element.end_line,
+            "language": element.language,
+        }
+
 
 class HtmlJsonFormatter(IFormatter):
     """JSON formatter specifically for HTML elements"""
@@ -324,7 +334,7 @@ class HtmlJsonFormatter(IFormatter):
 
     def format(self, elements: list[CodeElement]) -> str:
         """Format HTML elements as JSON with hierarchy"""
-        result = {
+        result: dict[str, Any] = {
             "html_analysis": {
                 "total_elements": len(elements),
                 "markup_elements": [],
@@ -468,10 +478,10 @@ class HtmlCompactFormatter(IFormatter):
                         info += f" .{attributes['class']}"
                 elif "selector" in element or element_type in ["rule", "style"]:
                     symbol = "🎨"
-                    info = element.get("selector", name)
+                    info = str(element.get("selector", name))
                 else:
                     symbol = "📄"
-                    info = element_type
+                    info = str(element_type)
             else:
                 symbol = "📄"
                 info = getattr(element, "element_type", "unknown")

tree_sitter_analyzer/formatters/javascript_formatter.py

@@ -15,15 +15,15 @@ from .base_formatter import BaseTableFormatter
 class JavaScriptTableFormatter(BaseTableFormatter):
     """Table formatter specialized for JavaScript"""
 
-    def format(self, data: dict[str, Any], format_type: str = None) -> str:
+    def format(self, data: dict[str, Any] | None, format_type: str = "full") -> str:
         """Format data using the configured format type"""
-        # Handle None data
+        # Handle None data gracefully
         if data is None:
-            return "# No data available\n"
+            data = {}
 
         # Ensure data is a dictionary
         if not isinstance(data, dict):
-            return f"# Invalid data type: {type(data)}\n"
+            raise TypeError(f"Expected dict, got {type(data)}")
 
         if format_type:
             # Check for supported format types
@@ -47,11 +47,8 @@ class JavaScriptTableFormatter(BaseTableFormatter):
 
     def _format_full_table(self, data: dict[str, Any]) -> str:
         """Full table format for JavaScript"""
-        if data is None:
-            return "# No data available\n"
-
         if not isinstance(data, dict):
-            return f"# Invalid data type: {type(data)}\n"
+            raise TypeError(f"Expected dict, got {type(data)}")
 
         lines = []
 
@@ -243,16 +240,26 @@ class JavaScriptTableFormatter(BaseTableFormatter):
             lines.append("| Export | Type | Name | Default |")
             lines.append("|--------|------|------|---------|")
 
-            for export in exports:
-                export_type = self._get_export_type(export)
-                if isinstance(export, dict):
-                    name = str(export.get("name", ""))
-                    is_default = "✓" if export.get("is_default", False) else "-"
-                else:
-                    name = str(export)
-                    is_default = "-"
-
-                lines.append(f"| {export_type} | {name} | {is_default} |")
+            # Handle malformed exports data
+            if isinstance(exports, list):
+                for export in exports:
+                    try:
+                        export_type = self._get_export_type(export)
+                        if isinstance(export, dict):
+                            name = str(export.get("name", ""))
+                            is_default = "✓" if export.get("is_default", False) else "-"
+                        else:
+                            name = str(export)
+                            is_default = "-"
+                            export_type = "unknown"
+
+                        lines.append(f"| {export_type} | {name} | {is_default} |")
+                    except (TypeError, AttributeError):
+                        # Handle malformed export data gracefully
+                        lines.append(f"| unknown | {str(export)} | - |")
+            else:
+                # Handle case where exports is not a list (malformed data)
+                lines.append(f"| unknown | {str(exports)} | - |")
             lines.append("")
 
         # Trim trailing blank lines
@@ -526,7 +533,7 @@ class JavaScriptTableFormatter(BaseTableFormatter):
         else:
             return "unknown"
 
-    def _get_export_type(self, export: dict[str, Any]) -> str:
+    def _get_export_type(self, export: Any) -> str:
         """Get export type"""
         if not isinstance(export, dict):
             return "unknown"
@@ -551,10 +558,10 @@ class JavaScriptTableFormatter(BaseTableFormatter):
     def _get_class_info(self, cls: dict[str, Any]) -> str:
         """Get class information as formatted string"""
         if cls is None:
-            return "Unknown (0 methods)"
+            raise TypeError("Cannot format None data")
 
         if not isinstance(cls, dict):
-            return f"{str(cls)} (0 methods)"
+            raise TypeError(f"Expected dict, got {type(cls)}")
 
         name = str(cls.get("name", "Unknown"))
         methods = cls.get("methods", [])

tree_sitter_analyzer/formatters/language_formatter_factory.py

@@ -32,8 +32,7 @@ class LanguageFormatterFactory:
         formatter_class = cls._formatters.get(language.lower())
 
         if formatter_class is None:
-            # Return None for unsupported languages
-            return None
+            raise ValueError(f"Unsupported language: {language}")
 
         return formatter_class()
 
@@ -74,7 +73,7 @@ class LanguageFormatterFactory:
         return language.lower() in cls._formatters
 
 
-def create_language_formatter(language: str) -> BaseFormatter:
+def create_language_formatter(language: str) -> BaseFormatter | None:
     """
     Create language formatter (function for compatibility)
 
@@ -84,4 +83,8 @@ def create_language_formatter(language: str) -> BaseFormatter:
     Returns:
         Language formatter or None if not supported
     """
-    return LanguageFormatterFactory.create_formatter(language)
+    try:
+        return LanguageFormatterFactory.create_formatter(language)
+    except ValueError:
+        # Return None for unsupported languages instead of raising exception
+        return None

tree_sitter_analyzer/formatters/markdown_formatter.py

@@ -14,8 +14,7 @@ from .base_formatter import BaseFormatter
 class MarkdownFormatter(BaseFormatter):
     """Formatter specialized for Markdown documents"""
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self) -> None:
         self.language = "markdown"
 
     def format_summary(self, analysis_result: dict[str, Any]) -> str:
@@ -624,8 +623,9 @@ class MarkdownFormatter(BaseFormatter):
             return counts
 
         try:
-            with open(file_path, encoding="utf-8", errors="replace") as f:
-                content = f.read()
+            from ..encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(file_path)
         except Exception:
             return counts
 

tree_sitter_analyzer/formatters/python_formatter.py

@@ -30,10 +30,10 @@ class PythonTableFormatter(BaseTableFormatter):
     def _format_full_table(self, data: dict[str, Any]) -> str:
         """Full table format for Python"""
         if data is None:
-            return "# No data available\n"
+            raise TypeError("Cannot format None data")
 
         if not isinstance(data, dict):
-            return f"# Invalid data type: {type(data)}\n"
+            raise TypeError(f"Expected dict, got {type(data)}")
 
         lines = []
 
@@ -300,7 +300,7 @@ class PythonTableFormatter(BaseTableFormatter):
     def _create_compact_signature(self, method: dict[str, Any]) -> str:
         """Create compact method signature for Python"""
         if method is None or not isinstance(method, dict):
-            return "(Any,Any):A"
+            raise TypeError(f"Expected dict, got {type(method)}")
 
         params = method.get("parameters", [])
         param_types = []
@@ -387,7 +387,7 @@ class PythonTableFormatter(BaseTableFormatter):
 
                 # Single line docstring
                 if stripped.count(quote_type) >= 2:
-                    return stripped.replace(quote_type, "").strip()
+                    return str(stripped.replace(quote_type, "").strip())
 
                 # Multi-line docstring
                 docstring_lines = [stripped.replace(quote_type, "")]

tree_sitter_analyzer/formatters/typescript_formatter.py

@@ -462,7 +462,7 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         elif element_type == "import":
             return "Import"
         else:
-            return element_type.title()
+            return str(element_type.title())
 
     def _format_element_details(self, element: dict[str, Any]) -> str:
         """Format TypeScript-specific element details"""

tree_sitter_analyzer/interfaces/mcp_adapter.py

@@ -32,8 +32,10 @@ def handle_mcp_resource_request(uri: str) -> dict[str, Any]:
 def read_file_safe(file_path: str) -> str:
     """Read file safely for MCP resource requests."""
     try:
-        with open(file_path, encoding="utf-8") as f:
-            return f.read()
+        from ..encoding_utils import read_file_safe
+
+        content, _ = read_file_safe(file_path)
+        return content
     except Exception as e:
         raise FileNotFoundError(f"Could not read file {file_path}: {e}") from e
 

tree_sitter_analyzer/interfaces/mcp_server.py

@@ -25,23 +25,23 @@ except ImportError:
     MCP_AVAILABLE = False
 
     # Fallback types for development without MCP
-    class Server:
+    class Server:  # type: ignore
         pass
 
-    class InitializationOptions:
+    class InitializationOptions:  # type: ignore
         def __init__(self, **kwargs: Any) -> None:
             pass
 
-    class Tool:
+    class Tool:  # type: ignore
         pass
 
-    class Resource:
+    class Resource:  # type: ignore
         pass
 
-    class TextContent:
+    class TextContent:  # type: ignore
         pass
 
-    def stdio_server() -> None:
+    def stdio_server() -> None:  # type: ignore[misc]
         pass
 
 
@@ -337,13 +337,13 @@ class TreeSitterAnalyzerMCPServer:
             """List available resources."""
             return [
                 Resource(
-                    uri="code://file/{file_path}",  # type: ignore
+                    uri="code://file/{file_path}",  # type: ignore[arg-type]
                     name="Code File Analysis",
                     description="Access to code file content and analysis",
                     mimeType="application/json",
                 ),
                 Resource(
-                    uri="code://stats/{stats_type}",  # type: ignore
+                    uri="code://stats/{stats_type}",  # type: ignore[arg-type]
                     name="Project Statistics",
                     description="Access to project statistics and analysis data",
                     mimeType="application/json",
@@ -389,7 +389,7 @@ class TreeSitterAnalyzerMCPServer:
 
         self.server = server
         log_info("MCP server created successfully")
-        return server  # type: ignore
+        return server  # type: ignore[no-any-return]
 
     async def run(self) -> None:
         """Run the MCP server."""
@@ -399,7 +399,7 @@ class TreeSitterAnalyzerMCPServer:
         options = InitializationOptions(
             server_name=self.name,
             server_version=self.version,
-            capabilities={"tools": {}, "resources": {}},  # type: ignore
+            capabilities={"tools": {}, "resources": {}},  # type: ignore[arg-type]
         )
 
         log_info(f"Starting MCP server: {self.name} v{self.version}")