tree-sitter-analyzer 0.9.9__py3-none-any.whl → 1.1.0__py3-none-any.whl

tree_sitter_analyzer/__init__.py

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

tree_sitter_analyzer/api.py

@@ -126,11 +126,20 @@ def analyze_file(
     except FileNotFoundError as e:
         # Re-raise FileNotFoundError for tests that expect it
         raise e
+    except (ValueError, TypeError, OSError) as e:
+        # Handle specific expected errors
+        log_error(f"API analyze_file failed with {type(e).__name__}: {e}")
+        return {
+            "success": False,
+            "error": f"{type(e).__name__}: {str(e)}",
+            "file_info": {"path": str(file_path), "exists": Path(file_path).exists()},
+        }
     except Exception as e:
-        log_error(f"API analyze_file failed: {e}")
+        # Handle unexpected errors
+        log_error(f"API analyze_file failed with unexpected error: {e}")
         return {
             "success": False,
-            "error": str(e),
+            "error": f"Unexpected error: {str(e)}",
             "file_info": {"path": str(file_path), "exists": Path(file_path).exists()},
         }
 

tree_sitter_analyzer/cli/commands/base_command.py

@@ -54,9 +54,9 @@ class BaseCommand(ABC):
             output_error(f"Invalid file path: {error_msg}")
             return False
 
-        import os
+        from pathlib import Path
 
-        if not os.path.exists(self.args.file_path):
+        if not Path(self.args.file_path).exists():
             output_error("Invalid file path: file does not exist")
             return False
 

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -31,9 +31,9 @@ class PartialReadCommand(BaseCommand):
             output_error("File path not specified.")
             return False
 
-        import os
+        from pathlib import Path
 
-        if not os.path.exists(self.args.file_path):
+        if not Path(self.args.file_path).exists():
             from ...output_manager import output_error
 
             output_error(f"File not found: {self.args.file_path}")

tree_sitter_analyzer/cli/info_commands.py

@@ -112,10 +112,13 @@ class ShowExtensionsCommand(InfoCommand):
     def execute(self) -> int:
         output_list("Supported file extensions:")
         supported_extensions = detector.get_supported_extensions()
-        for i in range(0, len(supported_extensions), 8):
-            line = "  " + "  ".join(
-                f"{ext:<6}" for ext in supported_extensions[i : i + 8]
-            )
+        # Use more efficient chunking with itertools.islice
+        from itertools import islice
+
+        chunk_size = 8
+        for i in range(0, len(supported_extensions), chunk_size):
+            chunk = list(islice(supported_extensions, i, i + chunk_size))
+            line = "  " + "  ".join(f"{ext:<6}" for ext in chunk)
             output_list(line)
         output_info(f"\nTotal {len(supported_extensions)} extensions supported")
         return 0

tree_sitter_analyzer/cli_main.py

@@ -3,6 +3,7 @@
 
 import argparse
 import logging
+import os
 import sys
 from typing import Any
 
@@ -268,8 +269,6 @@ def handle_special_commands(args: argparse.Namespace) -> int | None:
 def main() -> None:
     """Main entry point for the CLI."""
     # Early check for quiet mode to set environment variable before any imports
-    import os
-
     if "--quiet" in sys.argv:
         os.environ["LOG_LEVEL"] = "ERROR"
     else:

tree_sitter_analyzer/core/analysis_engine.py

@@ -395,9 +395,9 @@ class UnifiedAnalysisEngine:
             Detected language name
         """
         # 簡易的な拡張子ベース検出
-        import os
+        from pathlib import Path
 
-        _, ext = os.path.splitext(file_path)
+        ext = Path(file_path).suffix
 
         language_map = {
             ".java": "java",

tree_sitter_analyzer/core/query_service.py

@@ -1,162 +1,162 @@
-#!/usr/bin/env python3
-"""
-Query Service
-
-Unified query service for both CLI and MCP interfaces to avoid code duplication.
-Provides core tree-sitter query functionality including predefined and custom queries.
-"""
-
-import logging
-from typing import Any
-
-from ..encoding_utils import read_file_safe
-from ..query_loader import query_loader
-from .parser import Parser
-from .query_filter import QueryFilter
-
-logger = logging.getLogger(__name__)
-
-
-class QueryService:
-    """Unified query service providing tree-sitter query functionality"""
-
-    def __init__(self, project_root: str | None = None) -> None:
-        """Initialize the query service"""
-        self.project_root = project_root
-        self.parser = Parser()
-        self.filter = QueryFilter()
-
-    async def execute_query(
-        self,
-        file_path: str,
-        language: str,
-        query_key: str | None = None,
-        query_string: str | None = None,
-        filter_expression: str | None = None,
-    ) -> list[dict[str, Any]] | None:
-        """
-        Execute a query
-
-        Args:
-            file_path: Path to the file to analyze
-            language: Programming language
-            query_key: Predefined query key (e.g., 'methods', 'class')
-            query_string: Custom query string (e.g., '(method_declaration) @method')
-            filter_expression: Filter expression (e.g., 'name=main', 'name=~get*,public=true')
-
-        Returns:
-            List of query results, each containing capture_name, node_type, start_line, end_line, content
-
-        Raises:
-            ValueError: If neither query_key nor query_string is provided
-            FileNotFoundError: If file doesn't exist
-            Exception: If query execution fails
-        """
-        if not query_key and not query_string:
-            raise ValueError("Must provide either query_key or query_string")
-
-        if query_key and query_string:
-            raise ValueError("Cannot provide both query_key and query_string")
-
-        try:
-            # Read file content
-            content, encoding = read_file_safe(file_path)
-
-            # Parse file
-            parse_result = self.parser.parse_code(content, language, file_path)
-            if not parse_result or not parse_result.tree:
-                raise Exception("Failed to parse file")
-
-            tree = parse_result.tree
-            language_obj = tree.language if hasattr(tree, "language") else None
-            if not language_obj:
-                raise Exception(f"Language object not available for {language}")
-
-            # Get query string
-            if query_key:
-                query_string = query_loader.get_query(language, query_key)
-                if not query_string:
-                    raise ValueError(
-                        f"Query '{query_key}' not found for language '{language}'"
-                    )
-
-            # Execute tree-sitter query
-            ts_query = language_obj.query(query_string)
-            captures = ts_query.captures(tree.root_node)
-
-            # Process capture results
-            results = []
-            if isinstance(captures, dict):
-                # New tree-sitter API returns dictionary
-                for capture_name, nodes in captures.items():
-                    for node in nodes:
-                        results.append(self._create_result_dict(node, capture_name))
-            else:
-                # Old tree-sitter API returns list of tuples
-                for capture in captures:
-                    if isinstance(capture, tuple) and len(capture) == 2:
-                        node, name = capture
-                        results.append(self._create_result_dict(node, name))
-
-            # Apply filters
-            if filter_expression and results:
-                results = self.filter.filter_results(results, filter_expression)
-
-            return results
-
-        except Exception as e:
-            logger.error(f"Query execution failed: {e}")
-            raise
-
-    def _create_result_dict(self, node: Any, capture_name: str) -> dict[str, Any]:
-        """
-        Create result dictionary from tree-sitter node
-
-        Args:
-            node: tree-sitter node
-            capture_name: capture name
-
-        Returns:
-            Result dictionary
-        """
-        return {
-            "capture_name": capture_name,
-            "node_type": node.type if hasattr(node, "type") else "unknown",
-            "start_line": (
-                node.start_point[0] + 1 if hasattr(node, "start_point") else 0
-            ),
-            "end_line": node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
-            "content": (
-                node.text.decode("utf-8", errors="replace")
-                if hasattr(node, "text") and node.text
-                else ""
-            ),
-        }
-
-    def get_available_queries(self, language: str) -> list[str]:
-        """
-        Get available query keys for specified language
-
-        Args:
-            language: Programming language
-
-        Returns:
-            List of available query keys
-        """
-        return query_loader.list_queries(language)
-
-    def get_query_description(self, language: str, query_key: str) -> str | None:
-        """
-        Get description for query key
-
-        Args:
-            language: Programming language
-            query_key: Query key
-
-        Returns:
-            Query description, or None if not found
-        """
-        try:
-            return query_loader.get_query_description(language, query_key)
-        except Exception:
-            return None
+#!/usr/bin/env python3
+"""
+Query Service
+
+Unified query service for both CLI and MCP interfaces to avoid code duplication.
+Provides core tree-sitter query functionality including predefined and custom queries.
+"""
+
+import logging
+from typing import Any
+
+from ..encoding_utils import read_file_safe
+from ..query_loader import query_loader
+from .parser import Parser
+from .query_filter import QueryFilter
+
+logger = logging.getLogger(__name__)
+
+
+class QueryService:
+    """Unified query service providing tree-sitter query functionality"""
+
+    def __init__(self, project_root: str | None = None) -> None:
+        """Initialize the query service"""
+        self.project_root = project_root
+        self.parser = Parser()
+        self.filter = QueryFilter()
+
+    async def execute_query(
+        self,
+        file_path: str,
+        language: str,
+        query_key: str | None = None,
+        query_string: str | None = None,
+        filter_expression: str | None = None,
+    ) -> list[dict[str, Any]] | None:
+        """
+        Execute a query
+
+        Args:
+            file_path: Path to the file to analyze
+            language: Programming language
+            query_key: Predefined query key (e.g., 'methods', 'class')
+            query_string: Custom query string (e.g., '(method_declaration) @method')
+            filter_expression: Filter expression (e.g., 'name=main', 'name=~get*,public=true')
+
+        Returns:
+            List of query results, each containing capture_name, node_type, start_line, end_line, content
+
+        Raises:
+            ValueError: If neither query_key nor query_string is provided
+            FileNotFoundError: If file doesn't exist
+            Exception: If query execution fails
+        """
+        if not query_key and not query_string:
+            raise ValueError("Must provide either query_key or query_string")
+
+        if query_key and query_string:
+            raise ValueError("Cannot provide both query_key and query_string")
+
+        try:
+            # Read file content
+            content, encoding = read_file_safe(file_path)
+
+            # Parse file
+            parse_result = self.parser.parse_code(content, language, file_path)
+            if not parse_result or not parse_result.tree:
+                raise Exception("Failed to parse file")
+
+            tree = parse_result.tree
+            language_obj = tree.language if hasattr(tree, "language") else None
+            if not language_obj:
+                raise Exception(f"Language object not available for {language}")
+
+            # Get query string
+            if query_key:
+                query_string = query_loader.get_query(language, query_key)
+                if not query_string:
+                    raise ValueError(
+                        f"Query '{query_key}' not found for language '{language}'"
+                    )
+
+            # Execute tree-sitter query
+            ts_query = language_obj.query(query_string)
+            captures = ts_query.captures(tree.root_node)
+
+            # Process capture results
+            results = []
+            if isinstance(captures, dict):
+                # New tree-sitter API returns dictionary
+                for capture_name, nodes in captures.items():
+                    for node in nodes:
+                        results.append(self._create_result_dict(node, capture_name))
+            else:
+                # Old tree-sitter API returns list of tuples
+                for capture in captures:
+                    if isinstance(capture, tuple) and len(capture) == 2:
+                        node, name = capture
+                        results.append(self._create_result_dict(node, name))
+
+            # Apply filters
+            if filter_expression and results:
+                results = self.filter.filter_results(results, filter_expression)
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Query execution failed: {e}")
+            raise
+
+    def _create_result_dict(self, node: Any, capture_name: str) -> dict[str, Any]:
+        """
+        Create result dictionary from tree-sitter node
+
+        Args:
+            node: tree-sitter node
+            capture_name: capture name
+
+        Returns:
+            Result dictionary
+        """
+        return {
+            "capture_name": capture_name,
+            "node_type": node.type if hasattr(node, "type") else "unknown",
+            "start_line": (
+                node.start_point[0] + 1 if hasattr(node, "start_point") else 0
+            ),
+            "end_line": node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+            "content": (
+                node.text.decode("utf-8", errors="replace")
+                if hasattr(node, "text") and node.text
+                else ""
+            ),
+        }
+
+    def get_available_queries(self, language: str) -> list[str]:
+        """
+        Get available query keys for specified language
+
+        Args:
+            language: Programming language
+
+        Returns:
+            List of available query keys
+        """
+        return query_loader.list_queries(language)
+
+    def get_query_description(self, language: str, query_key: str) -> str | None:
+        """
+        Get description for query key
+
+        Args:
+            language: Programming language
+            query_key: Query key
+
+        Returns:
+            Query description, or None if not found
+        """
+        try:
+            return query_loader.get_query_description(language, query_key)
+        except Exception:
+            return None

tree_sitter_analyzer/file_handler.py

@@ -5,7 +5,7 @@ File Handler Module
 This module provides file reading functionality with encoding detection and fallback.
 """
 
-import os
+from pathlib import Path
 
 from .encoding_utils import read_file_safe
 from .utils import log_error, log_info, log_warning
@@ -21,7 +21,7 @@ def detect_language_from_extension(file_path: str) -> str:
     Returns:
         Language name or 'unknown' if not recognized
     """
-    extension = os.path.splitext(file_path)[1].lower()
+    extension = Path(file_path).suffix.lower()
 
     extension_map = {
         ".java": "java",
@@ -56,7 +56,8 @@ def read_file_with_fallback(file_path: str) -> bytes | None:
         File content as bytes, or None if file doesn't exist
     """
     # Check file existence first
-    if not os.path.exists(file_path):
+    file_obj = Path(file_path)
+    if not file_obj.exists():
         log_error(f"File does not exist: {file_path}")
         return None
 
@@ -93,7 +94,8 @@ def read_file_partial(
         Selected content string, or None on error
     """
     # Check file existence
-    if not os.path.exists(file_path):
+    file_obj = Path(file_path)
+    if not file_obj.exists():
         log_error(f"File does not exist: {file_path}")
         return None
 

tree_sitter_analyzer/formatters/base_formatter.py

@@ -5,7 +5,6 @@ Base formatter for language-specific table formatting.
 
 import csv
 import io
-import os
 from abc import ABC, abstractmethod
 from typing import Any
 
@@ -18,12 +17,15 @@ class BaseTableFormatter(ABC):
 
     def _get_platform_newline(self) -> str:
         """Get platform-specific newline code"""
-        return os.linesep
+        import os
+
+        return "\r\n" if os.name == "nt" else "\n"  # Windows uses \r\n, others use \n
 
     def _convert_to_platform_newlines(self, text: str) -> str:
         """Convert regular \n to platform-specific newline code"""
-        if os.linesep != "\n":
-            return text.replace("\n", os.linesep)
+        platform_newline = self._get_platform_newline()
+        if platform_newline != "\n":
+            return text.replace("\n", platform_newline)
         return text
 
     def format_structure(self, structure_data: dict[str, Any]) -> str:

tree_sitter_analyzer/mcp/__init__.py

@@ -15,7 +15,7 @@ try:
     __version__ = main_version
 except ImportError:
     # Fallback version if main package not available
-    __version__ = "0.9.1"
+    __version__ = "1.1.0"
 
 __author__ = "Tree-sitter Analyzer Team"
 

tree_sitter_analyzer/mcp/resources/__init__.py

@@ -19,7 +19,7 @@ from .code_file_resource import CodeFileResource
 from .project_stats_resource import ProjectStatsResource
 
 # Resource metadata
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 __author__ = "Tree-Sitter Analyzer Team"
 
 # MCP Resource capabilities

tree_sitter_analyzer/mcp/resources/project_stats_resource.py

@@ -123,8 +123,8 @@ class ProjectStatsResource:
 
         self._project_path = project_path
 
-        # Initialize analyzers with the project path
-        self._advanced_analyzer = get_analysis_engine()
+        # Note: analysis_engine is already initialized in __init__
+        # No need to reinitialize here
 
         logger.debug(f"Set project path to: {project_path}")
 
@@ -336,16 +336,27 @@ class ProjectStatsResource:
 
                     # Use appropriate analyzer based on language
                     if language == "java":
-                        # Use advanced analyzer for Java
-                        # 使用 await 调用异步方法
-                        file_analysis = await self._advanced_analyzer.analyze_file(
+                        # Use analysis engine for Java
+                        file_analysis = await self.analysis_engine.analyze_file(
                             str(file_path)
                         )
                         if file_analysis and hasattr(file_analysis, "methods"):
+                            # Extract complexity from methods if available
                             complexity = sum(
                                 method.complexity_score or 0
                                 for method in file_analysis.methods
                             )
+                        elif file_analysis and hasattr(file_analysis, "elements"):
+                            # Extract complexity from elements for new architecture
+                            methods = [
+                                e
+                                for e in file_analysis.elements
+                                if hasattr(e, "complexity_score")
+                            ]
+                            complexity = sum(
+                                getattr(method, "complexity_score", 0) or 0
+                                for method in methods
+                            )
                         else:
                             complexity = 0
                     else:

tree_sitter_analyzer/mcp/server.py

@@ -11,6 +11,7 @@ import asyncio
 import json
 import os
 import sys
+from pathlib import Path as PathClass
 from typing import Any
 
 try:
@@ -141,15 +142,13 @@ class TreeSitterAnalyzerMCPServer:
         include_details = arguments.get("include_details", False)
 
         # Resolve relative path against project root for consistent behavior
-        import os
-
         base_root = getattr(
             getattr(self.security_validator, "boundary_manager", None),
             "project_root",
             None,
         )
-        if not os.path.isabs(file_path) and base_root:
-            resolved_path = os.path.realpath(os.path.join(base_root, file_path))
+        if not PathClass(file_path).is_absolute() and base_root:
+            resolved_path = str((PathClass(base_root) / file_path).resolve())
         else:
             resolved_path = file_path
 
@@ -159,13 +158,11 @@ class TreeSitterAnalyzerMCPServer:
             raise ValueError(f"Invalid file path: {error_msg}")
 
         # Use analysis engine directly
-        from pathlib import Path
-
         from ..core.analysis_engine import AnalysisRequest
         from ..language_detector import detect_language_from_file
 
         # Validate file exists
-        if not Path(resolved_path).exists():
+        if not PathClass(resolved_path).exists():
             raise FileNotFoundError(f"File not found: {file_path}")
 
         # Detect language if not specified
@@ -404,7 +401,7 @@ class TreeSitterAnalyzerMCPServer:
                         raise ValueError(
                             "project_path parameter is required and must be a string"
                         )
-                    if not os.path.isdir(project_path):
+                    if not PathClass(project_path).is_dir():
                         raise ValueError(f"Project path does not exist: {project_path}")
                     self.set_project_path(project_path)
                     result = {"status": "success", "project_root": project_path}
@@ -596,8 +593,12 @@ async def main() -> None:
         if args.project_root:
             project_root = args.project_root
         # Priority 2: Environment variable
-        elif os.getenv("TREE_SITTER_PROJECT_ROOT"):
-            project_root = os.getenv("TREE_SITTER_PROJECT_ROOT")
+        elif (
+            PathClass.cwd()
+            .joinpath(os.environ.get("TREE_SITTER_PROJECT_ROOT", ""))
+            .exists()
+        ):
+            project_root = os.environ.get("TREE_SITTER_PROJECT_ROOT")
         # Priority 3: Auto-detection from current directory
         else:
             project_root = detect_project_root()
@@ -608,7 +609,11 @@ async def main() -> None:
         )
 
         # Validate existence; if invalid, fall back to auto-detected root
-        if not project_root or invalid_placeholder or not os.path.isdir(project_root):
+        if (
+            not project_root
+            or invalid_placeholder
+            or not PathClass(project_root).is_dir()
+        ):
             detected = detect_project_root()
             try:
                 logger.warning(

tree_sitter_analyzer/mcp/tools/__init__.py

@@ -8,7 +8,7 @@ through the Model Context Protocol.
 
 from typing import Any
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 
 # Tool registry for easy access
 AVAILABLE_TOOLS: dict[str, dict[str, Any]] = {