tree-sitter-analyzer 1.2.5__py3-none-any.whl → 1.3.2__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.1.1"
+__version__ = "1.3.2"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/mcp/tools/fd_rg_utils.py

@@ -147,15 +147,16 @@ def build_fd_command(
     if limit is not None:
         cmd += ["--max-results", str(limit)]
 
-    # Add search paths using --search-path option for better reliability
-    # This avoids conflicts between pattern and path arguments
-    if roots:
-        for root in roots:
-            cmd += ["--search-path", root]
-
-    # Pattern goes last if specified
+    # Pattern goes before roots if present
+    # If no pattern is specified, use '.' to match all files
     if pattern:
         cmd.append(pattern)
+    else:
+        cmd.append(".")
+
+    # Append roots - these are search directories, not patterns
+    if roots:
+        cmd += roots
 
     return cmd
 
@@ -517,6 +518,28 @@ def parse_rg_count_output(stdout_bytes: bytes) -> dict[str, int]:
     return results
 
 
+def extract_file_list_from_count_data(count_data: dict[str, int]) -> list[str]:
+    """Extract file list from count data, excluding the special __total__ key."""
+    return [file_path for file_path in count_data.keys() if file_path != "__total__"]
+
+
+def create_file_summary_from_count_data(count_data: dict[str, int]) -> dict[str, Any]:
+    """Create a file summary structure from count data."""
+    file_list = extract_file_list_from_count_data(count_data)
+    total_matches = count_data.get("__total__", 0)
+
+    return {
+        "success": True,
+        "total_matches": total_matches,
+        "file_count": len(file_list),
+        "files": [
+            {"file": file_path, "match_count": count_data[file_path]}
+            for file_path in file_list
+        ],
+        "derived_from_count": True,  # 标识这是从count数据推导的
+    }
+
+
 @dataclass
 class TempFileList:
     path: str

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -7,14 +7,18 @@ Safely list files/directories based on name patterns and constraints, using fd.
 
 from __future__ import annotations
 
+import logging
 import time
 from pathlib import Path
 from typing import Any
 
 from ..utils.error_handler import handle_mcp_errors
+from ..utils.gitignore_detector import get_default_detector
 from . import fd_rg_utils
 from .base_tool import BaseMCPTool
 
+logger = logging.getLogger(__name__)
+
 
 class ListFilesTool(BaseMCPTool):
     """MCP tool that wraps fd to list files with safety limits."""
@@ -176,6 +180,25 @@ class ListFilesTool(BaseMCPTool):
             fd_rg_utils.MAX_RESULTS_HARD_CAP,
         )
 
+        # Smart .gitignore detection
+        no_ignore = bool(arguments.get("no_ignore", False))
+        if not no_ignore:
+            # Auto-detect if we should use --no-ignore
+            detector = get_default_detector()
+            original_roots = arguments.get("roots", [])
+            should_ignore = detector.should_use_no_ignore(
+                original_roots, self.project_root
+            )
+            if should_ignore:
+                no_ignore = True
+                # Log the auto-detection for debugging
+                detection_info = detector.get_detection_info(
+                    original_roots, self.project_root
+                )
+                logger.info(
+                    f"Auto-enabled --no-ignore due to .gitignore interference: {detection_info['reason']}"
+                )
+
         cmd = fd_rg_utils.build_fd_command(
             pattern=arguments.get("pattern"),
             glob=bool(arguments.get("glob", False)),
@@ -185,7 +208,7 @@ class ListFilesTool(BaseMCPTool):
             depth=arguments.get("depth"),
             follow_symlinks=bool(arguments.get("follow_symlinks", False)),
             hidden=bool(arguments.get("hidden", False)),
-            no_ignore=bool(arguments.get("no_ignore", False)),
+            no_ignore=no_ignore,  # Use the potentially auto-detected value
             size=arguments.get("size"),
             changed_within=arguments.get("changed_within"),
             changed_before=arguments.get("changed_before"),

tree_sitter_analyzer/mcp/tools/search_content_tool.py

@@ -7,18 +7,36 @@ Search content in files under roots or an explicit file list using ripgrep --jso
 
 from __future__ import annotations
 
+import logging
 import time
 from pathlib import Path
 from typing import Any
 
 from ..utils.error_handler import handle_mcp_errors
+from ..utils.gitignore_detector import get_default_detector
+from ..utils.search_cache import get_default_cache
 from . import fd_rg_utils
 from .base_tool import BaseMCPTool
 
+logger = logging.getLogger(__name__)
+
 
 class SearchContentTool(BaseMCPTool):
     """MCP tool that wraps ripgrep to search content with safety limits."""
 
+    def __init__(
+        self, project_root: str | None = None, enable_cache: bool = True
+    ) -> None:
+        """
+        Initialize the search content tool.
+
+        Args:
+            project_root: Optional project root directory
+            enable_cache: Whether to enable search result caching (default: True)
+        """
+        super().__init__(project_root)
+        self.cache = get_default_cache() if enable_cache else None
+
     def get_tool_definition(self) -> dict[str, Any]:
         return {
             "name": "search_content",
@@ -209,8 +227,50 @@ class SearchContentTool(BaseMCPTool):
                     raise ValueError(f"{key} must be an array of strings")
         return True
 
+    def _determine_requested_format(self, arguments: dict[str, Any]) -> str:
+        """Determine the requested output format based on arguments."""
+        if arguments.get("total_only", False):
+            return "total_only"
+        elif arguments.get("count_only_matches", False):
+            return "count_only"
+        elif arguments.get("summary_only", False):
+            return "summary"
+        elif arguments.get("group_by_file", False):
+            return "group_by_file"
+        else:
+            return "normal"
+
+    def _create_count_only_cache_key(
+        self, total_only_cache_key: str, arguments: dict[str, Any]
+    ) -> str | None:
+        """
+        Create a count_only_matches cache key from a total_only cache key.
+
+        This enables cross-format caching where total_only results can serve
+        future count_only_matches queries.
+        """
+        if not self.cache:
+            return None
+
+        # Create modified arguments with count_only_matches instead of total_only
+        count_only_args = arguments.copy()
+        count_only_args.pop("total_only", None)
+        count_only_args["count_only_matches"] = True
+
+        # Generate cache key for count_only_matches version
+        cache_params = {
+            k: v
+            for k, v in count_only_args.items()
+            if k not in ["query", "roots", "files"]
+        }
+
+        roots = arguments.get("roots", [])
+        return self.cache.create_cache_key(
+            query=arguments["query"], roots=roots, **cache_params
+        )
+
     @handle_mcp_errors("search_content")
-    async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+    async def execute(self, arguments: dict[str, Any]) -> dict[str, Any] | int:
         self.validate_arguments(arguments)
 
         roots = arguments.get("roots")
@@ -220,6 +280,31 @@ class SearchContentTool(BaseMCPTool):
         if files:
             files = self._validate_files(files)
 
+        # Check cache if enabled
+        cache_key = None
+        if self.cache:
+            # Create cache key with relevant parameters (excluding 'query' and 'roots' from kwargs)
+            cache_params = {
+                k: v
+                for k, v in arguments.items()
+                if k not in ["query", "roots", "files"]
+            }
+            cache_key = self.cache.create_cache_key(
+                query=arguments["query"], roots=roots or [], **cache_params
+            )
+
+            # Try smart cross-format caching first
+            requested_format = self._determine_requested_format(arguments)
+            cached_result = self.cache.get_compatible_result(
+                cache_key, requested_format
+            )
+            if cached_result is not None:
+                # Add cache hit indicator to result
+                if isinstance(cached_result, dict):
+                    cached_result = cached_result.copy()
+                    cached_result["cache_hit"] = True
+                return cached_result
+
         # Clamp counts to safety limits
         max_count = fd_rg_utils.clamp_int(
             arguments.get("max_count"),
@@ -247,6 +332,26 @@ class SearchContentTool(BaseMCPTool):
         )
         summary_only = bool(arguments.get("summary_only", False))
 
+        # Smart .gitignore detection
+        no_ignore = bool(arguments.get("no_ignore", False))
+        if not no_ignore and roots:  # Only for roots mode, not files mode
+            # Auto-detect if we should use --no-ignore
+            detector = get_default_detector()
+            original_roots = arguments.get("roots", [])
+            should_ignore = detector.should_use_no_ignore(
+                original_roots, self.project_root
+            )
+            if should_ignore:
+                no_ignore = True
+                # Log the auto-detection for debugging
+                # Logger already defined at module level
+                detection_info = detector.get_detection_info(
+                    original_roots, self.project_root
+                )
+                logger.info(
+                    f"Auto-enabled --no-ignore due to .gitignore interference: {detection_info['reason']}"
+                )
+
         # Roots mode
         cmd = fd_rg_utils.build_rg_command(
             query=arguments["query"],
@@ -258,7 +363,7 @@ class SearchContentTool(BaseMCPTool):
             exclude_globs=arguments.get("exclude_globs"),
             follow_symlinks=bool(arguments.get("follow_symlinks", False)),
             hidden=bool(arguments.get("hidden", False)),
-            no_ignore=bool(arguments.get("no_ignore", False)),
+            no_ignore=no_ignore,  # Use the potentially auto-detected value
             max_filesize=arguments.get("max_filesize"),
             context_before=arguments.get("context_before"),
             context_after=arguments.get("context_after"),
@@ -283,14 +388,43 @@ class SearchContentTool(BaseMCPTool):
         if total_only:
             # Parse count output and return only the total
             file_counts = fd_rg_utils.parse_rg_count_output(out)
-            total_matches = file_counts.pop("__total__", 0)
+            total_matches = file_counts.get("__total__", 0)
+
+            # Cache the FULL count data for future cross-format optimization
+            # This allows count_only_matches queries to be served from this cache
+            if self.cache and cache_key:
+                # Cache both the simple total and the detailed count structure
+                self.cache.set(cache_key, total_matches)
+
+                # Also cache the equivalent count_only_matches result for cross-format optimization
+                count_only_cache_key = self._create_count_only_cache_key(
+                    cache_key, arguments
+                )
+                if count_only_cache_key:
+                    # Create a copy of file_counts without __total__ for the detailed result
+                    file_counts_copy = {
+                        k: v for k, v in file_counts.items() if k != "__total__"
+                    }
+                    detailed_count_result = {
+                        "success": True,
+                        "count_only": True,
+                        "total_matches": total_matches,
+                        "file_counts": file_counts_copy,  # Keep the file-level data (without __total__)
+                        "elapsed_ms": elapsed_ms,
+                        "derived_from_total_only": True,  # Mark as derived
+                    }
+                    self.cache.set(count_only_cache_key, detailed_count_result)
+                    logger.debug(
+                        "Cross-cached total_only result as count_only_matches for future optimization"
+                    )
+
             return total_matches
 
         # Handle count-only mode
         if count_only_matches:
             file_counts = fd_rg_utils.parse_rg_count_output(out)
             total_matches = file_counts.pop("__total__", 0)
-            return {
+            result = {
                 "success": True,
                 "count_only": True,
                 "total_matches": total_matches,
@@ -298,6 +432,12 @@ class SearchContentTool(BaseMCPTool):
                 "elapsed_ms": elapsed_ms,
             }
 
+            # Cache the result
+            if self.cache and cache_key:
+                self.cache.set(cache_key, result)
+
+            return result
+
         # Handle normal mode
         matches = fd_rg_utils.parse_rg_json_lines_to_matches(out)
         truncated = len(matches) >= fd_rg_utils.MAX_RESULTS_HARD_CAP
@@ -312,12 +452,18 @@ class SearchContentTool(BaseMCPTool):
         # Apply file grouping if requested (takes priority over other formats)
         group_by_file = arguments.get("group_by_file", False)
         if group_by_file and matches:
-            return fd_rg_utils.group_matches_by_file(matches)
+            result = fd_rg_utils.group_matches_by_file(matches)
+
+            # Cache the result
+            if self.cache and cache_key:
+                self.cache.set(cache_key, result)
+
+            return result
 
         # Handle summary mode
         if summary_only:
             summary = fd_rg_utils.summarize_search_results(matches)
-            return {
+            result = {
                 "success": True,
                 "count": len(matches),
                 "truncated": truncated,
@@ -325,10 +471,22 @@ class SearchContentTool(BaseMCPTool):
                 "summary": summary,
             }
 
-        return {
+            # Cache the result
+            if self.cache and cache_key:
+                self.cache.set(cache_key, result)
+
+            return result
+
+        result = {
             "success": True,
             "count": len(matches),
             "truncated": truncated,
             "elapsed_ms": elapsed_ms,
             "results": matches,
         }
+
+        # Cache the result
+        if self.cache and cache_key:
+            self.cache.set(cache_key, result)
+
+        return result

tree_sitter_analyzer/mcp/utils/gitignore_detector.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Gitignore Detection Utility
+
+Intelligently detects when .gitignore rules might interfere with file searches
+and suggests using --no-ignore option when appropriate.
+"""
+
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class GitignoreDetector:
+    """Detects .gitignore interference with file searches"""
+
+    def __init__(self):
+        self.common_ignore_patterns = {
+            # Directory patterns that commonly cause search issues
+            "build/*",
+            "dist/*",
+            "node_modules/*",
+            "__pycache__/*",
+            "target/*",
+            ".git/*",
+            ".svn/*",
+            ".hg/*",
+            "code/*",
+            "src/*",
+            "lib/*",
+            "app/*",  # Added code/* which is our case
+        }
+
+    def should_use_no_ignore(
+        self, roots: list[str], project_root: str | None = None
+    ) -> bool:
+        """
+        Determine if --no-ignore should be used based on search context
+
+        Args:
+            roots: List of root directories to search
+            project_root: Optional project root directory
+
+        Returns:
+            True if --no-ignore should be used
+        """
+        # Only apply auto-detection for root directory searches
+        if not (len(roots) == 1 and roots[0] in [".", "./"]):
+            return False
+
+        if not project_root:
+            return False
+
+        try:
+            project_path = Path(project_root).resolve()
+
+            # Check for .gitignore files that might interfere
+            gitignore_files = self._find_gitignore_files(project_path)
+
+            for gitignore_file in gitignore_files:
+                # Use the directory containing the .gitignore as the reference point
+                gitignore_dir = gitignore_file.parent
+                if self._has_interfering_patterns(
+                    gitignore_file, gitignore_dir, project_path
+                ):
+                    logger.debug(
+                        f"Found interfering .gitignore patterns in {gitignore_file}"
+                    )
+                    return True
+
+            return False
+
+        except Exception as e:
+            logger.warning(f"Error detecting .gitignore interference: {e}")
+            return False
+
+    def _find_gitignore_files(self, project_path: Path) -> list[Path]:
+        """Find .gitignore files in project hierarchy"""
+        gitignore_files = []
+
+        # Check current directory and parent directories
+        current = project_path
+        max_depth = 3  # Limit search depth
+
+        for _ in range(max_depth):
+            gitignore_path = current / ".gitignore"
+            if gitignore_path.exists():
+                gitignore_files.append(gitignore_path)
+
+            parent = current.parent
+            if parent == current:  # Reached root
+                break
+            current = parent
+
+        return gitignore_files
+
+    def _has_interfering_patterns(
+        self, gitignore_file: Path, gitignore_dir: Path, current_search_dir: Path
+    ) -> bool:
+        """
+        Check if .gitignore file has patterns that might interfere with searches
+
+        Args:
+            gitignore_file: Path to the .gitignore file
+            gitignore_dir: Directory containing the .gitignore file
+            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()
+
+            for line in lines:
+                line = line.strip()
+
+                # Skip comments and empty lines
+                if not line or line.startswith("#"):
+                    continue
+
+                # Check for patterns that commonly cause search issues
+                if self._is_interfering_pattern(
+                    line, gitignore_dir, current_search_dir
+                ):
+                    logger.debug(f"Found interfering pattern: {line}")
+                    return True
+
+            return False
+
+        except Exception as e:
+            logger.warning(f"Error reading .gitignore file {gitignore_file}: {e}")
+            return False
+
+    def _is_interfering_pattern(
+        self, pattern: str, gitignore_dir: Path, current_search_dir: Path
+    ) -> bool:
+        """
+        Check if a gitignore pattern is likely to interfere with searches
+
+        Args:
+            pattern: The gitignore pattern
+            gitignore_dir: Directory containing the .gitignore file
+            current_search_dir: Directory where the search is being performed
+        """
+        # Remove leading slash
+        pattern = pattern.lstrip("/")
+
+        # Check for broad directory exclusions that contain searchable files
+        if pattern.endswith("/*") or pattern.endswith("/"):
+            dir_name = pattern.rstrip("/*")
+
+            # Check if the pattern affects the current search directory
+            pattern_dir = gitignore_dir / dir_name
+
+            # If we're searching in a subdirectory that would be ignored by this pattern
+            if self._is_search_dir_affected_by_pattern(
+                current_search_dir, pattern_dir, gitignore_dir
+            ):
+                if pattern_dir.exists() and pattern_dir.is_dir():
+                    # Check if this directory contains searchable files
+                    if self._directory_has_searchable_files(pattern_dir):
+                        logger.debug(
+                            f"Pattern '{pattern}' interferes with search - directory contains searchable files"
+                        )
+                        return True
+
+        # Check for patterns that ignore entire source directories
+        source_dirs = [
+            "code",
+            "src",
+            "lib",
+            "app",
+            "main",
+            "java",
+            "python",
+            "js",
+            "ts",
+        ]
+        pattern_dir_name = pattern.rstrip("/*")
+        if pattern_dir_name in source_dirs:
+            pattern_dir = gitignore_dir / pattern_dir_name
+            if self._is_search_dir_affected_by_pattern(
+                current_search_dir, pattern_dir, gitignore_dir
+            ):
+                if pattern_dir.exists() and pattern_dir.is_dir():
+                    if self._directory_has_searchable_files(pattern_dir):
+                        logger.debug(
+                            f"Pattern '{pattern}' interferes with search - ignores source directory"
+                        )
+                        return True
+
+        return False
+
+    def _is_search_dir_affected_by_pattern(
+        self, search_dir: Path, pattern_dir: Path, gitignore_dir: Path
+    ) -> bool:
+        """Check if the search directory would be affected by a gitignore pattern"""
+        try:
+            # If search_dir is the same as pattern_dir or is a subdirectory of pattern_dir
+            search_resolved = search_dir.resolve()
+            pattern_resolved = pattern_dir.resolve()
+
+            # Check if we're searching in the directory that would be ignored
+            return search_resolved == pattern_resolved or str(
+                search_resolved
+            ).startswith(str(pattern_resolved) + os.sep)
+        except Exception:
+            # If path resolution fails, assume it could be affected
+            return True
+
+    def _directory_has_searchable_files(self, directory: Path) -> bool:
+        """Check if directory contains files that users typically want to search"""
+        searchable_extensions = {
+            ".java",
+            ".py",
+            ".js",
+            ".ts",
+            ".cpp",
+            ".c",
+            ".h",
+            ".cs",
+            ".go",
+            ".rs",
+        }
+
+        try:
+            # Quick check - look for any files with searchable extensions
+            for file_path in directory.rglob("*"):
+                if (
+                    file_path.is_file()
+                    and file_path.suffix.lower() in searchable_extensions
+                ):
+                    return True
+            return False
+        except Exception:
+            # If we can't scan, assume it might have searchable files
+            return True
+
+    def get_detection_info(
+        self, roots: list[str], project_root: str | None = None
+    ) -> dict:
+        """
+        Get detailed information about gitignore detection
+
+        Returns:
+            Dictionary with detection details for debugging/logging
+        """
+        info = {
+            "should_use_no_ignore": False,
+            "detected_gitignore_files": [],
+            "interfering_patterns": [],
+            "reason": "No interference detected",
+        }
+
+        if not (len(roots) == 1 and roots[0] in [".", "./"]):
+            info["reason"] = "Not a root directory search"
+            return info
+
+        if not project_root:
+            info["reason"] = "No project root specified"
+            return info
+
+        try:
+            project_path = Path(project_root).resolve()
+            gitignore_files = self._find_gitignore_files(project_path)
+            info["detected_gitignore_files"] = [str(f) for f in gitignore_files]
+
+            for gitignore_file in gitignore_files:
+                gitignore_dir = gitignore_file.parent
+                patterns = self._get_interfering_patterns(
+                    gitignore_file, gitignore_dir, project_path
+                )
+                if patterns:
+                    info["interfering_patterns"].extend(patterns)
+
+            if info["interfering_patterns"]:
+                info["should_use_no_ignore"] = True
+                info["reason"] = (
+                    f"Found {len(info['interfering_patterns'])} interfering patterns"
+                )
+
+        except Exception as e:
+            info["reason"] = f"Error during detection: {e}"
+
+        return info
+
+    def _get_interfering_patterns(
+        self, gitignore_file: Path, gitignore_dir: Path, current_search_dir: Path
+    ) -> list[str]:
+        """Get list of interfering patterns from a gitignore file"""
+        interfering = []
+
+        try:
+            with open(gitignore_file, encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+
+            for line in lines:
+                line = line.strip()
+                if (
+                    line
+                    and not line.startswith("#")
+                    and self._is_interfering_pattern(
+                        line, gitignore_dir, current_search_dir
+                    )
+                ):
+                    interfering.append(line)
+
+        except Exception as e:
+            logger.warning(f"Error reading .gitignore file {gitignore_file}: {e}")
+
+        return interfering
+
+
+# Global instance for easy access
+_default_detector = None
+
+
+def get_default_detector() -> GitignoreDetector:
+    """Get the default gitignore detector instance"""
+    global _default_detector
+    if _default_detector is None:
+        _default_detector = GitignoreDetector()
+    return _default_detector

tree_sitter_analyzer/mcp/utils/search_cache.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""
+Search Cache Module for MCP Tools
+
+Provides basic caching functionality for search results to improve performance
+by avoiding repeated expensive search operations.
+
+This is a simplified version focusing on core caching features for Phase 2.
+"""
+
+import logging
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class SearchCache:
+    """Thread-safe in-memory search result cache with TTL and LRU eviction"""
+
+    def __init__(self, max_size: int = 1000, ttl_seconds: int = 3600):
+        """
+        Initialize the search cache.
+
+        Args:
+            max_size: Maximum number of cached entries
+            ttl_seconds: Time-to-live for cached entries in seconds (default: 1 hour)
+        """
+        self.cache: dict[str, dict[str, Any]] = {}
+        self.max_size = max_size
+        self.ttl_seconds = ttl_seconds
+        self._lock = threading.RLock()  # Reentrant lock for thread safety
+        self._access_times: dict[str, float] = {}  # Track access times for LRU
+
+        # Statistics
+        self._hits = 0
+        self._misses = 0
+        self._evictions = 0
+
+    def _is_expired(self, timestamp: float) -> bool:
+        """Check if a cache entry is expired"""
+        return time.time() - timestamp > self.ttl_seconds
+
+    def _cleanup_expired(self) -> None:
+        """Remove expired entries (should be called with lock held)"""
+        current_time = time.time()
+        expired_keys = [
+            key
+            for key, entry in self.cache.items()
+            if current_time - entry["timestamp"] > self.ttl_seconds
+        ]
+        for key in expired_keys:
+            del self.cache[key]
+            if key in self._access_times:
+                del self._access_times[key]
+
+        if expired_keys:
+            logger.debug(f"Cleaned up {len(expired_keys)} expired cache entries")
+
+    def get(self, cache_key: str) -> Any:
+        """
+        Get cached result if valid.
+
+        Args:
+            cache_key: The cache key to look up
+
+        Returns:
+            Cached data if found and valid, None otherwise
+        """
+        with self._lock:
+            if cache_key in self.cache:
+                entry = self.cache[cache_key]
+                if not self._is_expired(entry["timestamp"]):
+                    # Update access time for LRU
+                    self._access_times[cache_key] = time.time()
+                    self._hits += 1
+                    logger.debug(f"Cache hit for key: {cache_key[:50]}...")
+                    return entry["data"]
+                else:
+                    # Remove expired entry
+                    del self.cache[cache_key]
+                    if cache_key in self._access_times:
+                        del self._access_times[cache_key]
+
+            self._misses += 1
+            return None
+
+    def get_compatible_result(self, cache_key: str, requested_format: str) -> Any:
+        """
+        Get cached result and try to derive compatible formats.
+
+        This enables smart cross-format caching where count results can be used
+        to derive file lists without additional searches.
+
+        Args:
+            cache_key: The cache key
+            requested_format: The format being requested ('file_list', 'summary', etc.)
+
+        Returns:
+            Compatible cached data if derivable, None otherwise
+        """
+        # First try direct cache hit - but only if the format matches
+        direct_result = self.get(cache_key)
+        if direct_result is not None:
+            # Check if the cached result matches the requested format
+            if self._is_format_compatible(direct_result, requested_format):
+                return direct_result
+
+        # Try to find compatible cached results for derivation
+        # Look for count_only results that can derive file lists
+        if requested_format in ["file_list", "summary", "files_only"]:
+            # Look for a count_only version of the same search
+            count_key = self._derive_count_key_from_cache_key(cache_key)
+            if count_key and count_key != cache_key:
+                count_result = self.get(count_key)
+                if count_result and self._can_derive_file_list(count_result):
+                    logger.debug(f"Deriving {requested_format} from cached count data")
+                    return self._derive_file_list_result(count_result, requested_format)
+
+        return None
+
+    def _is_format_compatible(self, cached_result: Any, requested_format: str) -> bool:
+        """
+        Check if a cached result is compatible with the requested format.
+
+        This prevents returning wrong format data (e.g., returning integer total
+        when detailed results are requested).
+        """
+        if requested_format == "total_only":
+            # total_only expects a simple integer
+            return isinstance(cached_result, int)
+        elif requested_format == "count_only":
+            # count_only expects a dict with file_counts
+            return isinstance(cached_result, dict) and (
+                "file_counts" in cached_result or "count_only" in cached_result
+            )
+        elif requested_format in ["summary", "file_list", "files_only"]:
+            # These formats expect dict results with specific structures
+            return isinstance(cached_result, dict) and cached_result.get(
+                "success", False
+            )
+        elif requested_format in ["normal", "group_by_file"]:
+            # Normal format expects dict with matches, files, or results data
+            return isinstance(cached_result, dict) and (
+                "matches" in cached_result
+                or "files" in cached_result
+                or "results" in cached_result
+            )
+        else:
+            # For unknown formats or test scenarios, allow dict results but not primitives
+            # This maintains backward compatibility while preventing the integer bug
+            return isinstance(cached_result, dict)
+
+    def _derive_count_key_from_cache_key(self, cache_key: str) -> str | None:
+        """Try to derive what the count_only cache key would be for this search."""
+        # Simple heuristic: replace summary_only with count_only_matches
+        if "summary_only" in cache_key:
+            return cache_key.replace(
+                "'summary_only': True", "'count_only_matches': True"
+            )
+        elif "count_only_matches" not in cache_key:
+            # Add count_only_matches parameter
+            return cache_key.replace("}", ", 'count_only_matches': True}")
+        return None
+
+    def _can_derive_file_list(self, count_result: dict[str, Any]) -> bool:
+        """Check if a count result contains file count data that can derive file lists."""
+        return (
+            isinstance(count_result, dict)
+            and "file_counts" in count_result
+            and isinstance(count_result["file_counts"], dict)
+        )
+
+    def _derive_file_list_result(
+        self, count_result: dict[str, Any], requested_format: str
+    ) -> dict[str, Any]:
+        """Derive file list result from count data."""
+        try:
+            from ..tools import fd_rg_utils  # Import here to avoid circular imports
+
+            file_counts = count_result.get("file_counts", {})
+            if requested_format == "summary":
+                derived_result = fd_rg_utils.create_file_summary_from_count_data(
+                    file_counts
+                )
+                derived_result["cache_derived"] = True  # Mark as derived from cache
+                return derived_result
+            elif requested_format in ["file_list", "files_only"]:
+                file_list = fd_rg_utils.extract_file_list_from_count_data(file_counts)
+                return {
+                    "success": True,
+                    "files": file_list,
+                    "file_count": len(file_list),
+                    "total_matches": file_counts.get("__total__", 0),
+                    "cache_derived": True,  # Mark as derived from cache
+                }
+        except ImportError:
+            logger.warning("Could not import fd_rg_utils for cache derivation")
+
+        return count_result
+
+    def set(self, cache_key: str, data: dict[str, Any] | Any) -> None:
+        """
+        Set cached result.
+
+        Args:
+            cache_key: The cache key
+            data: The data to cache
+        """
+        with self._lock:
+            self._cleanup_expired()
+
+            # If cache is full and this is a new key, remove LRU entry
+            if len(self.cache) >= self.max_size and cache_key not in self.cache:
+                # Remove least recently used entry
+                if self._access_times:
+                    lru_key = min(
+                        self._access_times.keys(),
+                        key=lambda k: self._access_times.get(k, 0),
+                    )
+                    del self.cache[lru_key]
+                    del self._access_times[lru_key]
+                    self._evictions += 1
+                    logger.debug(f"Cache full, removed LRU entry: {lru_key[:50]}...")
+
+            current_time = time.time()
+            self.cache[cache_key] = {"data": data, "timestamp": current_time}
+            self._access_times[cache_key] = current_time
+            logger.debug(f"Cached result for key: {cache_key[:50]}...")
+
+    def clear(self) -> None:
+        """Clear all cached results"""
+        with self._lock:
+            self.cache.clear()
+            self._access_times.clear()
+            self._hits = 0
+            self._misses = 0
+            self._evictions = 0
+        logger.info("Search cache cleared")
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get cache statistics"""
+        with self._lock:
+            total_requests = self._hits + self._misses
+            hit_rate = (self._hits / total_requests * 100) if total_requests > 0 else 0
+
+            return {
+                "size": len(self.cache),
+                "max_size": self.max_size,
+                "ttl_seconds": self.ttl_seconds,
+                "hits": self._hits,
+                "misses": self._misses,
+                "hit_rate_percent": round(hit_rate, 2),
+                "evictions": self._evictions,
+                "expired_entries": len(
+                    [
+                        key
+                        for key, entry in self.cache.items()
+                        if self._is_expired(entry["timestamp"])
+                    ]
+                ),
+            }
+
+    def create_cache_key(self, query: str, roots: list[str], **params: Any) -> str:
+        """
+        Create a deterministic cache key for search parameters.
+
+        Args:
+            query: Search query
+            roots: List of root directories
+            **params: Additional search parameters
+
+        Returns:
+            Cache key string
+        """
+        # Normalize query
+        normalized_query = query.strip().lower()
+
+        # Normalize roots - resolve paths and sort for consistency
+        normalized_roots = []
+        for r in roots:
+            try:
+                resolved = str(Path(r).resolve())
+                normalized_roots.append(resolved)
+            except Exception:
+                # If path resolution fails, use original
+                normalized_roots.append(r)
+        normalized_roots.sort()
+
+        # Only include parameters that affect search results
+        relevant_params = {
+            "case": params.get("case", "smart"),
+            "include_globs": (
+                sorted(params.get("include_globs", []))
+                if params.get("include_globs")
+                else []
+            ),
+            "exclude_globs": (
+                sorted(params.get("exclude_globs", []))
+                if params.get("exclude_globs")
+                else []
+            ),
+            "no_ignore": params.get("no_ignore", False),
+            "hidden": params.get("hidden", False),
+            "fixed_strings": params.get("fixed_strings", False),
+            "word": params.get("word", False),
+            "multiline": params.get("multiline", False),
+            "max_filesize": params.get("max_filesize", ""),
+        }
+
+        # Create deterministic key
+        key_parts = [
+            normalized_query,
+            str(normalized_roots),
+            str(sorted(relevant_params.items())),
+        ]
+        return "|".join(key_parts)
+
+
+# Global cache instance for easy access
+_default_cache = None
+
+
+def get_default_cache() -> SearchCache:
+    """Get the default search cache instance"""
+    global _default_cache
+    if _default_cache is None:
+        _default_cache = SearchCache()
+    return _default_cache
+
+
+def configure_cache(max_size: int = 1000, ttl_seconds: int = 3600) -> None:
+    """Configure the default search cache"""
+    global _default_cache
+    _default_cache = SearchCache(max_size, ttl_seconds)
+
+
+def clear_cache() -> None:
+    """Clear the default search cache"""
+    cache = get_default_cache()
+    cache.clear()

{tree_sitter_analyzer-1.2.5.dist-info → tree_sitter_analyzer-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 1.2.5
+Version: 1.3.2
 Summary: Extensible multi-language code analyzer framework using Tree-sitter with dynamic plugin architecture
 Project-URL: Homepage, https://github.com/aimasteracc/tree-sitter-analyzer
 Project-URL: Documentation, https://github.com/aimasteracc/tree-sitter-analyzer#readme
@@ -163,11 +163,11 @@ Description-Content-Type: text/markdown
 
 [![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-1564%20passed-brightgreen.svg)](#quality-assurance)
-[![Coverage](https://img.shields.io/badge/coverage-74.97%25-green.svg)](#quality-assurance)
+[![Tests](https://img.shields.io/badge/tests-1605%20passed-brightgreen.svg)](#quality-assurance)
+[![Coverage](https://img.shields.io/badge/coverage-74.36%25-green.svg)](#quality-assurance)
 [![Quality](https://img.shields.io/badge/quality-enterprise%20grade-blue.svg)](#quality-assurance)
 [![PyPI](https://img.shields.io/pypi/v/tree-sitter-analyzer.svg)](https://pypi.org/project/tree-sitter-analyzer/)
-[![Version](https://img.shields.io/badge/version-1.2.4-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
+[![Version](https://img.shields.io/badge/version-1.3.2-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
 [![GitHub Stars](https://img.shields.io/github/stars/aimasteracc/tree-sitter-analyzer.svg?style=social)](https://github.com/aimasteracc/tree-sitter-analyzer)
 
 ## 🚀 Break LLM Token Limits, Let AI Understand Code Files of Any Size
@@ -920,11 +920,11 @@ Tree-sitter Analyzer automatically detects and protects project boundaries:
 - **Zero test failures** - Fully CI/CD ready
 - **Cross-platform compatibility** - Windows, macOS, Linux
 
-### ⚡ **Latest Quality Achievements (v1.2.3)**
+### ⚡ **Latest Quality Achievements (v1.3.2)**
 - ✅ **Cross-platform path compatibility** - Fixed Windows short path names and macOS symbolic link differences
 - ✅ **Windows environment** - Implemented robust path normalization using Windows API
 - ✅ **macOS environment** - Fixed `/var` vs `/private/var` symbolic link differences
-- ✅ **Comprehensive test coverage** - 1514 tests, 74.24% coverage
+- ✅ **Comprehensive test coverage** - 1605 tests, 74.36% coverage
 - ✅ **GitFlow implementation** - Professional development/release branch strategy. See [GitFlow documentation](GITFLOW.md) for details.
 
 ### ⚙️ **Running Tests**
@@ -943,7 +943,7 @@ uv run pytest tests/test_mcp_server_initialization.py -v
 - **Language detector**: 98.41% (Excellent)
 - **CLI main entry**: 94.36% (Excellent)
 - **Query filtering system**: 96.06% (Excellent)
-- **MCP fd/rg tools**: 93.04% (Excellent) - *New in v1.2.4*
+- **MCP fd/rg tools**: 93.04% (Excellent) - *Enhanced in v1.3.2 with cache format compatibility fix*
 - **Query service**: 86.25% (Good)
 - **Error handling**: 82.76% (Good)
 
@@ -1041,9 +1041,9 @@ All AI prompts in this document have been thoroughly tested in real environments
 
 **Test Environment:**
 - Operating System: Windows 10
-- Project: tree-sitter-analyzer v1.2.4
+- Project: tree-sitter-analyzer v1.3.2
 - Test Files: BigService.java (1419 lines), sample.py (256 lines), MultiClass.java (54 lines)
-- Test Coverage: 1564 tests passed, 74.97% coverage
+- Test Coverage: 1605 tests passed, 74.36% coverage
 - Test Tools: All MCP tools (check_code_scale, analyze_code_structure, extract_code_section, query_code, list_files, search_content, find_and_grep)
 
 **🚀 Start Now** → [30-Second Quick Start](#-30-second-quick-start)

{tree_sitter_analyzer-1.2.5.dist-info → tree_sitter_analyzer-1.3.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tree_sitter_analyzer/__init__.py,sha256=11U0oXY9N6VcqA_pQvmKyA4fTW-JH-amMoJ7vRfLSFw,3067
+tree_sitter_analyzer/__init__.py,sha256=7P5MV_TiIjGznUHZWtFsRiAQxrgngbW8KlgQ5CK6qms,3067
 tree_sitter_analyzer/__main__.py,sha256=Zl79tpe4UaMu-7yeztc06tgP0CVMRnvGgas4ZQP5SCs,228
 tree_sitter_analyzer/api.py,sha256=N_bcf1pLwzXS3elPn30OySLR6ehsHdWpchXMycjl0PY,17399
 tree_sitter_analyzer/cli_main.py,sha256=jWjVJ5AgNmtf6Z7CgeK3IF-zi7yIiu9zn4Oyvzl-iNQ,10349
@@ -57,17 +57,19 @@ tree_sitter_analyzer/mcp/tools/__init__.py,sha256=9KfetZTaUhvWTeKuZPYzWb7ZomFQ8S
 tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=JyS9gey2oFoWjzsiiLjwcqTgwBYGlbY01vAK3QYUuF4,28470
 tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py,sha256=mssed7bEfGeGxW4mOf7dg8BDS1oqHLolIBNX9DaZ3DM,8997
 tree_sitter_analyzer/mcp/tools/base_tool.py,sha256=qf2My325azlnKOugNVMN_R1jtZcjXVy354sGVKzvZls,3546
-tree_sitter_analyzer/mcp/tools/fd_rg_utils.py,sha256=c7SlopnXO-td5WDiNHhQxKu9YVzAXWp73xuuaKd3LUk,16864
+tree_sitter_analyzer/mcp/tools/fd_rg_utils.py,sha256=evvnCk61OrOrWnkdQGl3LcoGYpW2iesHBYVZ6qS6FJQ,17692
 tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py,sha256=uYHat0kShQyreK1TXtvBG1e_HAL8ZsRHr49CzP7PLAo,20272
-tree_sitter_analyzer/mcp/tools/list_files_tool.py,sha256=XWzk4ZHhXvvKOhebWa5tSsW5_mY4TOmCHdHoDYs6Q8Y,11937
+tree_sitter_analyzer/mcp/tools/list_files_tool.py,sha256=TA1BRQtb-D5x1pD-IcRJYnP0WnnFfl9q7skI25MOdHk,12873
 tree_sitter_analyzer/mcp/tools/query_tool.py,sha256=1xY1ONNY2sIFJxoILlnNzBnwGVgzEF7vVJ2ccqR9auA,10879
 tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=BMAJF205hTIrYTQJG6N1-vVuKSby2CSm9nWzSMMWceI,11339
-tree_sitter_analyzer/mcp/tools/search_content_tool.py,sha256=GCJQcCXfSlGD_BaDIoiomwL3E42a-7KswSItqPqz5Vs,15380
+tree_sitter_analyzer/mcp/tools/search_content_tool.py,sha256=CmyZNtVFMXvwVHeGQdNqPdUB2miTDBgp4G_J86Cl5So,21597
 tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=NDIiCtmZSbCmaQOp7ED83jGE5DuJhx4mcUketVHrkjs,16024
 tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=-zZnqN9WcoyRTKM_16ADH859LSebzi34BGYwQL2zCOs,25084
 tree_sitter_analyzer/mcp/utils/__init__.py,sha256=TgTTKsRJAqF95g1fAp5SR_zQVDkImpc_5R0Dw529UUw,3126
 tree_sitter_analyzer/mcp/utils/error_handler.py,sha256=msrQHX67K3vhJsEc3OPRz5mmWU_yoHz55Lnxy0IZuy4,18404
+tree_sitter_analyzer/mcp/utils/gitignore_detector.py,sha256=VmO35Xj1fWiKVs4Y9aiD1gILm_8Kf1R8mhvtiF-wcfg,11027
 tree_sitter_analyzer/mcp/utils/path_resolver.py,sha256=7pZvJ1CjKnLKTGvBBOitCLxgWaHNVQo2SwQrxuyqXkI,14976
+tree_sitter_analyzer/mcp/utils/search_cache.py,sha256=ZNv84st6PeejDY1B50AKTbItpXs9HS6JrpR-Ozjyc1c,12991
 tree_sitter_analyzer/plugins/__init__.py,sha256=ITE9bTz7NO4axnn8g5Z-1_ydhSLT0RnY6Y1J9OhUP3E,10326
 tree_sitter_analyzer/plugins/base.py,sha256=FMRAOtjtDutNV8RnB6cmFgdvcjxKRAbrrzqldBBT1yk,17167
 tree_sitter_analyzer/plugins/manager.py,sha256=PyEY3jeuCBpDVqguWhaAu7nzUZM17_pI6wml2e0Hamo,12535
@@ -80,7 +82,7 @@ tree_sitter_analyzer/security/__init__.py,sha256=ZTqTt24hsljCpTXAZpJC57L7MU5lJLT
 tree_sitter_analyzer/security/boundary_manager.py,sha256=3eeENRKWtz2pyZHzd8DiVaq8fdeC6s1eVOuBylSmQPg,9347
 tree_sitter_analyzer/security/regex_checker.py,sha256=jWK6H8PTPgzbwRPfK_RZ8bBTS6rtEbgjY5vr3YWjQ_U,9616
 tree_sitter_analyzer/security/validator.py,sha256=yR4qTWEcXpR--bSFwtWvSgY0AzqujOFAqlc1Z7dlTdk,9809
-tree_sitter_analyzer-1.2.5.dist-info/METADATA,sha256=BQKloyCs0g2WpS9lkaT2Hp1VoP8q1knFy38cCSWH5E8,39669
-tree_sitter_analyzer-1.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-1.2.5.dist-info/entry_points.txt,sha256=U4tfLGXgCWubKm2PyEb3zxhQ2pm7zVotMyfyS0CodD8,486
-tree_sitter_analyzer-1.2.5.dist-info/RECORD,,
+tree_sitter_analyzer-1.3.2.dist-info/METADATA,sha256=PD6f3dx4MgWX0FhCcDgQ5bc3l8mhbEI6rVI9iSY6LVE,39710
+tree_sitter_analyzer-1.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-1.3.2.dist-info/entry_points.txt,sha256=U4tfLGXgCWubKm2PyEb3zxhQ2pm7zVotMyfyS0CodD8,486
+tree_sitter_analyzer-1.3.2.dist-info/RECORD,,