tree-sitter-analyzer 1.9.2__py3-none-any.whl → 1.9.4__py3-none-any.whl

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -374,8 +374,9 @@ class TableFormatTool(BaseMCPTool):
 
         # Write content to file
         try:
-            with open(output_path, "w", encoding="utf-8") as f:
-                f.write(content)
+            from ...encoding_utils import write_file_safe
+
+            write_file_safe(output_path, content)
             self.logger.info(f"Output written to file: {output_path}")
             return output_path
         except Exception as e:
@@ -471,19 +472,23 @@ class TableFormatTool(BaseMCPTool):
                 try:
                     if FormatterRegistry.is_format_supported(format_type):
                         # Use new FormatterRegistry
-                        formatter = FormatterRegistry.get_formatter(format_type)
-                        table_output = formatter.format(structure_result.elements)
+                        registry_formatter = FormatterRegistry.get_formatter(
+                            format_type
+                        )
+                        table_output = registry_formatter.format(
+                            structure_result.elements
+                        )
                     else:
                         # Fallback to legacy TableFormatter for backward compatibility
-                        formatter: Any = TableFormatter(format_type)
-                        table_output = formatter.format_structure(structure_dict)  # type: ignore[attr-defined]
+                        legacy_formatter: Any = TableFormatter(format_type)
+                        table_output = legacy_formatter.format_structure(structure_dict)
                 except Exception as e:
                     # If FormatterRegistry fails, fallback to legacy TableFormatter
                     logger.warning(
                         f"FormatterRegistry failed, using legacy formatter: {e}"
                     )
-                    formatter: Any = TableFormatter(format_type)
-                    table_output = formatter.format_structure(structure_dict)  # type: ignore[attr-defined]
+                    fallback_formatter: Any = TableFormatter(format_type)
+                    table_output = fallback_formatter.format_structure(structure_dict)
 
                 # Ensure output format matches CLI exactly
                 # Fix line ending differences: normalize to Unix-style LF (\n)

tree_sitter_analyzer/mcp/utils/file_output_manager.py

@@ -36,7 +36,7 @@ class FileOutputManager:
             project_root: Optional project root directory for fallback output path
         """
         self.project_root = project_root
-        self._output_path = None
+        self._output_path: str | None = None
         self._initialize_output_path()
 
     @classmethod
@@ -252,6 +252,10 @@ class FileOutputManager:
             output_file = output_path / filename
         else:
             # Generate filename with appropriate extension
+            if base_name is None:
+                raise ValueError(
+                    "base_name cannot be None when filename is not provided"
+                )
             generated_filename = self.generate_output_filename(base_name, content)
             output_file = output_path / generated_filename
 
@@ -260,8 +264,9 @@ class FileOutputManager:
 
         # Write content to file
         try:
-            with open(output_file, "w", encoding="utf-8") as f:
-                f.write(content)
+            from ...encoding_utils import write_file_safe
+
+            write_file_safe(output_file, content)
 
             logger.info(f"Content saved to file: {output_file}")
             return str(output_file)

tree_sitter_analyzer/mcp/utils/gitignore_detector.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 class GitignoreDetector:
     """Detects .gitignore interference with file searches"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.common_ignore_patterns = {
             # Directory patterns that commonly cause search issues
             "build/*",
@@ -116,8 +116,10 @@ class GitignoreDetector:
             current_search_dir: Directory where the search is being performed
         """
         try:
-            with open(gitignore_file, encoding="utf-8", errors="ignore") as f:
-                lines = f.readlines()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(gitignore_file)
+            lines = content.splitlines()
 
             for line in lines:
                 line = line.strip()
@@ -257,14 +259,14 @@ class GitignoreDetector:
 
     def get_detection_info(
         self, roots: list[str], project_root: str | None = None
-    ) -> dict:
+    ) -> dict[str, object]:
         """
         Get detailed information about gitignore detection
 
         Returns:
             Dictionary with detection details for debugging/logging
         """
-        info = {
+        info: dict[str, object] = {
             "should_use_no_ignore": False,
             "detected_gitignore_files": [],
             "interfering_patterns": [],
@@ -294,13 +296,21 @@ class GitignoreDetector:
                     gitignore_file, gitignore_dir, project_path
                 )
                 if patterns:
-                    info["interfering_patterns"].extend(patterns)
-
-            if info["interfering_patterns"]:
+                    existing_patterns = info.get("interfering_patterns", [])
+                    if isinstance(existing_patterns, list):
+                        info["interfering_patterns"] = existing_patterns + patterns
+                    else:
+                        info["interfering_patterns"] = patterns
+
+            interfering_patterns = info.get("interfering_patterns", [])
+            if interfering_patterns:
                 info["should_use_no_ignore"] = True
-                info["reason"] = (
-                    f"Found {len(info['interfering_patterns'])} interfering patterns"
+                pattern_count = (
+                    len(interfering_patterns)
+                    if isinstance(interfering_patterns, list)
+                    else 0
                 )
+                info["reason"] = f"Found {pattern_count} interfering patterns"
 
         except Exception as e:
             info["reason"] = f"Error during detection: {e}"
@@ -314,8 +324,10 @@ class GitignoreDetector:
         interfering = []
 
         try:
-            with open(gitignore_file, encoding="utf-8", errors="ignore") as f:
-                lines = f.readlines()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(gitignore_file)
+            lines = content.splitlines()
 
             for line in lines:
                 line = line.strip()

tree_sitter_analyzer/mcp/utils/path_resolver.py

@@ -52,7 +52,7 @@ def _normalize_path_cross_platform(path_str: str) -> str:
             from ctypes import wintypes
 
             # GetLongPathNameW function
-            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW  # type: ignore[attr-defined]
+            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW
             _GetLongPathNameW.argtypes = [
                 wintypes.LPCWSTR,
                 wintypes.LPWSTR,
@@ -110,7 +110,7 @@ class PathResolver:
             project_root: Optional project root directory for resolving relative paths
         """
         self.project_root = None
-        self._cache = {}  # Simple cache for resolved paths
+        self._cache: dict[str, str] = {}  # Simple cache for resolved paths
         self._cache_size_limit = 100  # Limit cache size to prevent memory issues
 
         if project_root:

tree_sitter_analyzer/models.py

@@ -45,6 +45,14 @@ class CodeElement(ABC):
     raw_text: str = ""
     language: str = "unknown"
     docstring: str | None = None  # JavaDoc/docstring for this element
+    element_type: str = "unknown"
+
+    def to_summary_item(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": self.element_type,
+            "lines": {"start": self.start_line, "end": self.end_line},
+        }
 
 
 @dataclass(frozen=False)
@@ -341,6 +349,14 @@ class JavaPackage:
     start_line: int = 0
     end_line: int = 0
 
+    def to_summary_item(self) -> dict[str, Any]:
+        """Return dictionary for summary item"""
+        return {
+            "name": self.name,
+            "type": "package",
+            "lines": {"start": self.start_line, "end": self.end_line},
+        }
+
 
 @dataclass(frozen=False)
 class AnalysisResult:

tree_sitter_analyzer/mypy_current_errors.txt

@@ -0,0 +1,2 @@
+mcp\server.py: error: Source file found twice under different module names:
+"tree_sitter_analyzer.mcp.server" and "mcp.server"

tree_sitter_analyzer/plugins/base.py

@@ -34,6 +34,10 @@ class ElementExtractor(ABC):
     meaningful code elements like functions, classes, variables, etc.
     """
 
+    def __init__(self) -> None:
+        """Initialize the element extractor."""
+        self.current_file: str = ""  # Current file being processed
+
     @abstractmethod
     def extract_functions(
         self, tree: "tree_sitter.Tree", source_code: str
@@ -98,6 +102,36 @@ class ElementExtractor(ABC):
         """
         pass
 
+    def extract_packages(self, tree: "tree_sitter.Tree", source_code: str) -> list[Any]:
+        """
+        Extract package declarations from the syntax tree.
+
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+
+        Returns:
+            List of extracted package objects
+        """
+        # Default implementation returns empty list
+        return []
+
+    def extract_annotations(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> list[Any]:
+        """
+        Extract annotations from the syntax tree.
+
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+
+        Returns:
+            List of extracted annotation objects
+        """
+        # Default implementation returns empty list
+        return []
+
     def extract_all_elements(
         self, tree: "tree_sitter.Tree", source_code: str
     ) -> list[CodeElement]:
@@ -123,6 +157,38 @@ class ElementExtractor(ABC):
 
         return elements
 
+    def extract_html_elements(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> list[Any]:
+        """
+        Extract HTML elements from the syntax tree.
+
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+
+        Returns:
+            List of extracted HTML elements
+        """
+        # Default implementation returns empty list
+        return []
+
+    def extract_css_rules(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> list[Any]:
+        """
+        Extract CSS rules from the syntax tree.
+
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+
+        Returns:
+            List of extracted CSS rules
+        """
+        # Default implementation returns empty list
+        return []
+
 
 class LanguagePlugin(ABC):
     """

tree_sitter_analyzer/queries/java.py

@@ -107,10 +107,16 @@ JAVA_QUERIES: dict[str, str] = {
       name: (identifier) @name
       body: (block) @body) @method_with_body
     """,
+    # Fixed: Match methods WITH annotations (at least one required)
+    # Uses alternation [(annotation) (marker_annotation)] to match both types:
+    # - marker_annotation: Annotations without parameters (e.g., @Override)
+    # - annotation: Annotations with parameters (e.g., @SuppressWarnings("unchecked"))
+    # The + quantifier requires at least one annotation
     "method_with_annotations": """
     (method_declaration
-      (modifiers (annotation) @annotation)*
-      name: (identifier) @name) @method_with_annotations
+      (modifiers
+        [(annotation) (marker_annotation)]+ @annotation)
+      name: (identifier) @name) @method
     """,
     # --- Inheritance Relations ---
     "extends_clause": """
@@ -181,7 +187,7 @@ JAVA_QUERIES: dict[str, str] = {
     # --- Structural Information Extraction Queries ---
     "javadoc_comment": """
     (block_comment) @javadoc_comment
-    (#match? @javadoc_comment "^/\\*\\*")
+    (#match? @javadoc_comment "^/\\\\\\\\\\\\*\\\\\\\\\\\\*")
     """,
     "class_with_javadoc": """
     (class_declaration

tree_sitter_analyzer/queries/javascript.py

@@ -56,13 +56,13 @@ JAVASCRIPT_QUERIES: dict[str, str] = {
     "class_declaration": """
     (class_declaration
         name: (identifier) @class_name
-        superclass: (class_heritage)? @superclass
+        (class_heritage)? @superclass
         body: (class_body) @body) @class_declaration
     """,
     "class_expression": """
     (class_expression
         name: (identifier)? @class_name
-        superclass: (class_heritage)? @superclass
+        (class_heritage)? @superclass
         body: (class_body) @body) @class_expression
     """,
     "class_method": """
@@ -542,13 +542,8 @@ FUNCTIONS = """
 CLASSES = """
 (class_declaration
     name: (identifier) @class.name
-    superclass: (class_heritage)? @class.superclass
+    (class_heritage)? @class.superclass
     body: (class_body) @class.body) @class.declaration
-
-(class_expression
-    name: (identifier)? @class.name
-    superclass: (class_heritage)? @class.superclass
-    body: (class_body) @class.body) @class.expression
 """
 
 VARIABLES = """

tree_sitter_analyzer/queries/markdown.py

@@ -176,7 +176,7 @@ def get_available_queries() -> list[str]:
     return sorted(queries + aliases)
 
 
-def get_query_info(query_name: str) -> dict[str, str]:
+def get_query_info(query_name: str) -> dict[str, str | bool]:
     """
     Get information about a query
 

tree_sitter_analyzer/queries/python.py

@@ -40,7 +40,7 @@ IMPORTS = """
 
 (import_from_statement
     module_name: (dotted_name)? @import.module
-    name: (import_list) @import.list) @import.from_list
+    name: (aliased_import) @import.aliased_item) @import.from_aliased
 
 (aliased_import
     name: (dotted_name) @import.name
@@ -335,7 +335,7 @@ PYTHON_QUERIES: dict[str, str] = {
     "import_from_list": """
     (import_from_statement
         module_name: (dotted_name)? @module_name
-        name: (import_list) @import_list) @import_from_list
+        name: (aliased_import) @import_item) @import_from_list
     """,
     "aliased_import": """
     (aliased_import

tree_sitter_analyzer/security/boundary_manager.py

@@ -45,8 +45,6 @@ class ProjectBoundaryManager:
             # Handle both string and Path objects
             if isinstance(project_root, str):
                 project_path = Path(project_root)
-            elif isinstance(project_root, Path):
-                project_path = project_root
             else:
                 raise SecurityError(f"Invalid project root type: {type(project_root)}")
 
@@ -150,18 +148,17 @@ class ProjectBoundaryManager:
             real_path = Path(file_path).resolve()
             try:
                 rel_path = real_path.relative_to(Path(self.project_root))
-                rel_path = str(rel_path)
             except ValueError:
                 # Path is not relative to project root
                 log_warning(f"Path not relative to project root: {file_path}")
                 return None
 
             # Ensure relative path doesn't start with ..
-            if rel_path.startswith(".."):
+            if str(rel_path).startswith(".."):
                 log_warning(f"Relative path calculation failed: {rel_path}")
                 return None
 
-            return rel_path
+            return str(rel_path)
 
         except Exception as e:
             log_warning(f"Relative path calculation error: {e}")

tree_sitter_analyzer/security/regex_checker.py

@@ -219,9 +219,9 @@ class RegexSafetyChecker:
 
             # Calculate complexity score
             metrics["complexity_score"] = (
-                metrics["length"] * 0.1
+                int(metrics["length"] * 0.1)
                 + metrics["quantifiers"] * 2
-                + metrics["groups"] * 1.5
+                + int(metrics["groups"] * 1.5)
                 + metrics["alternations"] * 3
                 + metrics["character_classes"] * 1
             )

tree_sitter_analyzer/security/validator.py

@@ -36,6 +36,8 @@ class SecurityValidator:
         Args:
             project_root: Optional project root directory for boundary checks
         """
+        self.boundary_manager: ProjectBoundaryManager | None
+
         # Ensure project_root is properly resolved if provided
         if project_root:
             try:
@@ -488,7 +490,9 @@ class SecurityValidator:
                 or "CI" in os.environ
                 or "GITHUB_ACTIONS" in os.environ
                 or any(
-                    "test" in arg.lower() for arg in os.sys.argv if hasattr(os, "sys")
+                    "test" in arg.lower()
+                    for arg in getattr(getattr(os, "sys", None), "argv", [])
+                    if hasattr(os, "sys")
                 )
             )
 

tree_sitter_analyzer/table_formatter.py

@@ -665,7 +665,7 @@ class TableFormatter:
 
         # Map<String,Object> -> M<S,O>
         if "Map<" in type_name:
-            return (
+            return str(
                 type_name.replace("Map<", "M<")
                 .replace("String", "S")
                 .replace("Object", "O")
@@ -673,17 +673,17 @@ class TableFormatter:
 
         # List<String> -> L<S>
         if "List<" in type_name:
-            return type_name.replace("List<", "L<").replace("String", "S")
+            return str(type_name.replace("List<", "L<").replace("String", "S"))
 
         # String[] -> S[]
         if "[]" in type_name:
             base_type = type_name.replace("[]", "")
             if base_type:
-                return type_mapping.get(base_type, base_type[0].upper()) + "[]"
+                return str(type_mapping.get(base_type, base_type[0].upper())) + "[]"
             else:
                 return "O[]"
 
-        return type_mapping.get(type_name, type_name)
+        return str(type_mapping.get(type_name, type_name))
 
     def _convert_visibility(self, visibility: str) -> str:
         """Convert visibility to symbol"""

tree_sitter_analyzer/utils/__init__.py

@@ -3,132 +3,38 @@
 Utilities package for tree_sitter_analyzer.
 
 This package contains utility modules for various functionality
-including tree-sitter API compatibility.
+including tree-sitter API compatibility and logging.
 """
 
 # Import from tree-sitter compatibility module
 from .tree_sitter_compat import TreeSitterQueryCompat, get_node_text_safe, log_api_info
 
-
-# Re-export logging functions from the parent utils module
-# We need to import these dynamically to avoid circular imports
-def _import_logging_functions():
-    """Dynamically import logging functions to avoid circular imports."""
-    import importlib.util
-    import os
-
-    # Import the utils.py file from the parent directory
-    parent_dir = os.path.dirname(os.path.dirname(__file__))
-    utils_path = os.path.join(parent_dir, "utils.py")
-    spec = importlib.util.spec_from_file_location(
-        "tree_sitter_analyzer_utils", utils_path
-    )
-    utils_module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(utils_module)
-
-    return (
-        utils_module.setup_logger,
-        utils_module.log_debug,
-        utils_module.log_error,
-        utils_module.log_warning,
-        utils_module.log_info,
-        utils_module.log_performance,
-        utils_module.QuietMode,
-        utils_module.safe_print,
-        utils_module.LoggingContext,
-        utils_module.setup_performance_logger,
-        utils_module.create_performance_logger,
-    )
-
-
-# Import logging functions
-try:
-    (
-        setup_logger,
-        log_debug,
-        log_error,
-        log_warning,
-        log_info,
-        log_performance,
-        QuietMode,
-        safe_print,
-        LoggingContext,
-        setup_performance_logger,
-        create_performance_logger,
-    ) = _import_logging_functions()
-except Exception:
-    # Fallback logging functions if import fails
-    def setup_logger(name="tree_sitter_analyzer", level=30):
-        import logging
-
-        logger = logging.getLogger(name)
-        if not logger.handlers:
-            handler = logging.StreamHandler()
-            formatter = logging.Formatter(
-                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            )
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-        logger.setLevel(level)
-        return logger
-
-    def log_debug(msg, *args, **kwargs):
-        pass
-
-    def log_error(msg, *args, **kwargs):
-        print(f"ERROR: {msg}", *args)
-
-    def log_warning(msg, *args, **kwargs):
-        print(f"WARNING: {msg}", *args)
-
-    def log_info(msg, *args, **kwargs):
-        print(f"INFO: {msg}", *args)
-
-    def log_performance(operation, execution_time=None, details=None):
-        pass
-
-    # Fallback QuietMode class
-    class QuietMode:
-        def __init__(self, enabled=True):
-            self.enabled = enabled
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc_val, exc_tb):
-            pass
-
-    # Fallback LoggingContext class
-    class LoggingContext:
-        def __init__(self, enabled=True, level=None):
-            self.enabled = enabled
-            self.level = level
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc_val, exc_tb):
-            pass
-
-    def setup_performance_logger():
-        import logging
-
-        return logging.getLogger("performance")
-
-    def create_performance_logger(name):
-        import logging
-
-        return logging.getLogger(f"{name}.performance")
-
-    def safe_print(message, level="info", quiet=False):
-        if not quiet:
-            print(message)
-
+# Import logging functions directly from logging module
+from .logging import (
+    LoggingContext,
+    QuietMode,
+    SafeStreamHandler,
+    create_performance_logger,
+    log_debug,
+    log_error,
+    log_info,
+    log_performance,
+    log_warning,
+    logger,
+    perf_logger,
+    safe_print,
+    setup_logger,
+    setup_performance_logger,
+    setup_safe_logging_shutdown,
+    suppress_output,
+)
 
 __all__ = [
+    # Tree-sitter compatibility
     "TreeSitterQueryCompat",
     "get_node_text_safe",
     "log_api_info",
+    # Logging functionality
     "setup_logger",
     "log_debug",
     "log_error",
@@ -140,4 +46,9 @@ __all__ = [
     "LoggingContext",
     "setup_performance_logger",
     "create_performance_logger",
+    "SafeStreamHandler",
+    "setup_safe_logging_shutdown",
+    "suppress_output",
+    "logger",
+    "perf_logger",
 ]

tree_sitter_analyzer/{utils.py → utils/logging.py}

@@ -154,7 +154,7 @@ class SafeStreamHandler(logging.StreamHandler):
     A StreamHandler that safely handles closed streams
     """
 
-    def __init__(self, stream=None):
+    def __init__(self, stream: Any = None) -> None:
         # Default to sys.stderr to keep stdout clean for MCP stdio
         super().__init__(stream if stream is not None else sys.stderr)
 
@@ -449,4 +449,4 @@ class LoggingContext:
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         if self.enabled and self.old_level is not None:
             # Always restore the saved level
-            self.target_logger.setLevel(self.old_level)
+            self.target_logger.setLevel(self.old_level)

tree_sitter_analyzer/utils/tree_sitter_compat.py

@@ -235,7 +235,7 @@ def get_node_text_safe(node: Any, source_code: str, encoding: str = "utf-8") ->
                     line = lines[start_point[0]]
                     start_col = max(0, min(start_point[1], len(line)))
                     end_col = max(start_col, min(end_point[1], len(line)))
-                    return line[start_col:end_col]
+                    return str(line[start_col:end_col])
                 else:
                     # Multiple lines
                     result_lines = []
@@ -258,7 +258,7 @@ def get_node_text_safe(node: Any, source_code: str, encoding: str = "utf-8") ->
         return ""
 
 
-def log_api_info():
+def log_api_info() -> None:
     """Log information about available tree-sitter APIs."""
     try:
         import tree_sitter