tree-sitter-analyzer 0.6.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

tree_sitter_analyzer/utils.py

@@ -1,277 +1,277 @@
-#!/usr/bin/env python3
-"""
-Utilities for Tree-sitter Analyzer
-
-Provides logging, debugging, and common utility functions.
-"""
-
-import atexit
-import logging
-import sys
-from functools import wraps
-from typing import Any
-
-
-# Configure global logger
-def setup_logger(
-    name: str = "tree_sitter_analyzer", level: int = logging.INFO
-) -> logging.Logger:
-    """Setup unified logger for the project"""
-    import os
-
-    # Get log level from environment variable
-    env_level = os.environ.get("LOG_LEVEL", "").upper()
-    if env_level == "DEBUG":
-        level = logging.DEBUG
-    elif env_level == "INFO":
-        level = logging.INFO
-    elif env_level == "WARNING":
-        level = logging.WARNING
-    elif env_level == "ERROR":
-        level = logging.ERROR
-
-    logger = logging.getLogger(name)
-
-    if not logger.handlers:  # Avoid duplicate handlers
-        # Create a safe handler that won't fail on closed streams
-        handler = SafeStreamHandler(sys.stdout)
-        formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-        logger.setLevel(level)
-
-    return logger
-
-
-class SafeStreamHandler(logging.StreamHandler):
-    """
-    A StreamHandler that safely handles closed streams
-    """
-
-    def emit(self, record: Any) -> None:
-        """
-        Emit a record, safely handling closed streams
-        """
-        try:
-            # Check if stream is closed before writing
-            if hasattr(self.stream, "closed") and self.stream.closed:
-                return
-
-            # Check if we can write to the stream
-            if not hasattr(self.stream, "write"):
-                return
-
-            super().emit(record)
-        except (ValueError, OSError, AttributeError):
-            # Silently ignore I/O errors during shutdown
-            pass
-        except Exception:
-            # For any other unexpected errors, use handleError
-            self.handleError(record)
-
-
-def setup_safe_logging_shutdown() -> None:
-    """
-    Setup safe logging shutdown to prevent I/O errors
-    """
-
-    def cleanup_logging() -> None:
-        """Clean up logging handlers safely"""
-        try:
-            # Get all loggers
-            loggers = [logging.getLogger()] + [
-                logging.getLogger(name) for name in logging.Logger.manager.loggerDict
-            ]
-
-            for logger in loggers:
-                for handler in logger.handlers[:]:
-                    try:
-                        handler.close()
-                        logger.removeHandler(handler)
-                    except Exception:
-                        pass
-        except Exception:
-            pass
-
-    # Register cleanup function
-    atexit.register(cleanup_logging)
-
-
-# Setup safe shutdown on import
-setup_safe_logging_shutdown()
-
-
-# Global logger instance
-logger = setup_logger()
-
-
-def log_info(message: str, *args: Any, **kwargs: Any) -> None:
-    """Log info message"""
-    try:
-        logger.info(message, *args, **kwargs)
-    except (ValueError, OSError):
-        pass  # Silently ignore I/O errors
-
-
-def log_warning(message: str, *args: Any, **kwargs: Any) -> None:
-    """Log warning message"""
-    try:
-        logger.warning(message, *args, **kwargs)
-    except (ValueError, OSError):
-        pass  # Silently ignore I/O errors
-
-
-def log_error(message: str, *args: Any, **kwargs: Any) -> None:
-    """Log error message"""
-    try:
-        logger.error(message, *args, **kwargs)
-    except (ValueError, OSError):
-        pass  # Silently ignore I/O errors
-
-
-def log_debug(message: str, *args: Any, **kwargs: Any) -> None:
-    """Log debug message"""
-    try:
-        logger.debug(message, *args, **kwargs)
-    except (ValueError, OSError):
-        pass  # Silently ignore I/O errors
-
-
-def suppress_output(func: Any) -> Any:
-    """Decorator to suppress print statements in production"""
-
-    @wraps(func)
-    def wrapper(*args: Any, **kwargs: Any) -> Any:
-        # Check if we're in test/debug mode
-        if getattr(sys, "_testing", False):
-            return func(*args, **kwargs)
-
-        # Redirect stdout to suppress prints
-        old_stdout = sys.stdout
-        try:
-            sys.stdout = (
-                open("/dev/null", "w") if sys.platform != "win32" else open("nul", "w")
-            )
-            result = func(*args, **kwargs)
-        finally:
-            try:
-                sys.stdout.close()
-            except Exception:
-                pass
-            sys.stdout = old_stdout
-
-        return result
-
-    return wrapper
-
-
-class QuietMode:
-    """Context manager for quiet execution"""
-
-    def __init__(self, enabled: bool = True):
-        self.enabled = enabled
-        self.old_level: int | None = None
-
-    def __enter__(self) -> "QuietMode":
-        if self.enabled:
-            self.old_level = logger.level
-            logger.setLevel(logging.ERROR)
-        return self
-
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        if self.enabled and self.old_level is not None:
-            logger.setLevel(self.old_level)
-
-
-def safe_print(message: str, level: str = "info", quiet: bool = False) -> None:
-    """Safe print function that can be controlled"""
-    if quiet:
-        return
-
-    level_map = {
-        "info": log_info,
-        "warning": log_warning,
-        "error": log_error,
-        "debug": log_debug,
-    }
-
-    log_func = level_map.get(level.lower(), log_info)
-    log_func(message)
-
-
-def create_performance_logger(name: str) -> logging.Logger:
-    """Create performance-focused logger"""
-    perf_logger = logging.getLogger(f"{name}.performance")
-
-    if not perf_logger.handlers:
-        handler = SafeStreamHandler()
-        formatter = logging.Formatter("%(asctime)s - PERF - %(message)s")
-        handler.setFormatter(formatter)
-        perf_logger.addHandler(handler)
-        perf_logger.setLevel(logging.INFO)
-
-    return perf_logger
-
-
-# Performance logger instance
-perf_logger = create_performance_logger("tree_sitter_analyzer")
-
-
-def log_performance(
-    operation: str,
-    execution_time: float | None = None,
-    details: dict[Any, Any] | str | None = None,
-) -> None:
-    """Log performance metrics"""
-    try:
-        message = f"{operation}"
-        if execution_time is not None:
-            message += f": {execution_time:.4f}s"
-        if details:
-            if isinstance(details, dict):
-                detail_str = ", ".join([f"{k}: {v}" for k, v in details.items()])
-            else:
-                detail_str = str(details)
-            message += f" - {detail_str}"
-        perf_logger.info(message)
-    except (ValueError, OSError):
-        pass  # Silently ignore I/O errors
-
-
-def setup_performance_logger() -> logging.Logger:
-    """Set up performance logging"""
-    perf_logger = logging.getLogger("performance")
-
-    # Add handler if not already configured
-    if not perf_logger.handlers:
-        handler = SafeStreamHandler()
-        formatter = logging.Formatter("%(asctime)s - Performance - %(message)s")
-        handler.setFormatter(formatter)
-        perf_logger.addHandler(handler)
-        perf_logger.setLevel(logging.INFO)
-
-    return perf_logger
-
-
-class LoggingContext:
-    """Context manager for controlling logging behavior"""
-
-    def __init__(self, enabled: bool = True, level: int | None = None):
-        self.enabled = enabled
-        self.level = level
-        self.old_level: int | None = None
-        self.target_logger = (
-            logging.getLogger()
-        )  # Use root logger for compatibility with tests
-
-    def __enter__(self) -> "LoggingContext":
-        if self.enabled and self.level is not None:
-            self.old_level = self.target_logger.level
-            self.target_logger.setLevel(self.level)
-        return self
-
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        if self.enabled and self.old_level is not None:
-            self.target_logger.setLevel(self.old_level)
+#!/usr/bin/env python3
+"""
+Utilities for Tree-sitter Analyzer
+
+Provides logging, debugging, and common utility functions.
+"""
+
+import atexit
+import logging
+import sys
+from functools import wraps
+from typing import Any
+
+
+# Configure global logger
+def setup_logger(
+    name: str = "tree_sitter_analyzer", level: int = logging.INFO
+) -> logging.Logger:
+    """Setup unified logger for the project"""
+    import os
+
+    # Get log level from environment variable
+    env_level = os.environ.get("LOG_LEVEL", "").upper()
+    if env_level == "DEBUG":
+        level = logging.DEBUG
+    elif env_level == "INFO":
+        level = logging.INFO
+    elif env_level == "WARNING":
+        level = logging.WARNING
+    elif env_level == "ERROR":
+        level = logging.ERROR
+
+    logger = logging.getLogger(name)
+
+    if not logger.handlers:  # Avoid duplicate handlers
+        # Create a safe handler that won't fail on closed streams
+        handler = SafeStreamHandler(sys.stdout)
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.setLevel(level)
+
+    return logger
+
+
+class SafeStreamHandler(logging.StreamHandler):
+    """
+    A StreamHandler that safely handles closed streams
+    """
+
+    def emit(self, record: Any) -> None:
+        """
+        Emit a record, safely handling closed streams
+        """
+        try:
+            # Check if stream is closed before writing
+            if hasattr(self.stream, "closed") and self.stream.closed:
+                return
+
+            # Check if we can write to the stream
+            if not hasattr(self.stream, "write"):
+                return
+
+            super().emit(record)
+        except (ValueError, OSError, AttributeError):
+            # Silently ignore I/O errors during shutdown
+            pass
+        except Exception:
+            # For any other unexpected errors, use handleError
+            self.handleError(record)
+
+
+def setup_safe_logging_shutdown() -> None:
+    """
+    Setup safe logging shutdown to prevent I/O errors
+    """
+
+    def cleanup_logging() -> None:
+        """Clean up logging handlers safely"""
+        try:
+            # Get all loggers
+            loggers = [logging.getLogger()] + [
+                logging.getLogger(name) for name in logging.Logger.manager.loggerDict
+            ]
+
+            for logger in loggers:
+                for handler in logger.handlers[:]:
+                    try:
+                        handler.close()
+                        logger.removeHandler(handler)
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+
+    # Register cleanup function
+    atexit.register(cleanup_logging)
+
+
+# Setup safe shutdown on import
+setup_safe_logging_shutdown()
+
+
+# Global logger instance
+logger = setup_logger()
+
+
+def log_info(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log info message"""
+    try:
+        logger.info(message, *args, **kwargs)
+    except (ValueError, OSError):
+        pass  # Silently ignore I/O errors
+
+
+def log_warning(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log warning message"""
+    try:
+        logger.warning(message, *args, **kwargs)
+    except (ValueError, OSError):
+        pass  # Silently ignore I/O errors
+
+
+def log_error(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log error message"""
+    try:
+        logger.error(message, *args, **kwargs)
+    except (ValueError, OSError):
+        pass  # Silently ignore I/O errors
+
+
+def log_debug(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log debug message"""
+    try:
+        logger.debug(message, *args, **kwargs)
+    except (ValueError, OSError):
+        pass  # Silently ignore I/O errors
+
+
+def suppress_output(func: Any) -> Any:
+    """Decorator to suppress print statements in production"""
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Check if we're in test/debug mode
+        if getattr(sys, "_testing", False):
+            return func(*args, **kwargs)
+
+        # Redirect stdout to suppress prints
+        old_stdout = sys.stdout
+        try:
+            sys.stdout = (
+                open("/dev/null", "w") if sys.platform != "win32" else open("nul", "w")
+            )
+            result = func(*args, **kwargs)
+        finally:
+            try:
+                sys.stdout.close()
+            except Exception:
+                pass
+            sys.stdout = old_stdout
+
+        return result
+
+    return wrapper
+
+
+class QuietMode:
+    """Context manager for quiet execution"""
+
+    def __init__(self, enabled: bool = True):
+        self.enabled = enabled
+        self.old_level: int | None = None
+
+    def __enter__(self) -> "QuietMode":
+        if self.enabled:
+            self.old_level = logger.level
+            logger.setLevel(logging.ERROR)
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        if self.enabled and self.old_level is not None:
+            logger.setLevel(self.old_level)
+
+
+def safe_print(message: str, level: str = "info", quiet: bool = False) -> None:
+    """Safe print function that can be controlled"""
+    if quiet:
+        return
+
+    level_map = {
+        "info": log_info,
+        "warning": log_warning,
+        "error": log_error,
+        "debug": log_debug,
+    }
+
+    log_func = level_map.get(level.lower(), log_info)
+    log_func(message)
+
+
+def create_performance_logger(name: str) -> logging.Logger:
+    """Create performance-focused logger"""
+    perf_logger = logging.getLogger(f"{name}.performance")
+
+    if not perf_logger.handlers:
+        handler = SafeStreamHandler()
+        formatter = logging.Formatter("%(asctime)s - PERF - %(message)s")
+        handler.setFormatter(formatter)
+        perf_logger.addHandler(handler)
+        perf_logger.setLevel(logging.INFO)
+
+    return perf_logger
+
+
+# Performance logger instance
+perf_logger = create_performance_logger("tree_sitter_analyzer")
+
+
+def log_performance(
+    operation: str,
+    execution_time: float | None = None,
+    details: dict[Any, Any] | str | None = None,
+) -> None:
+    """Log performance metrics"""
+    try:
+        message = f"{operation}"
+        if execution_time is not None:
+            message += f": {execution_time:.4f}s"
+        if details:
+            if isinstance(details, dict):
+                detail_str = ", ".join([f"{k}: {v}" for k, v in details.items()])
+            else:
+                detail_str = str(details)
+            message += f" - {detail_str}"
+        perf_logger.info(message)
+    except (ValueError, OSError):
+        pass  # Silently ignore I/O errors
+
+
+def setup_performance_logger() -> logging.Logger:
+    """Set up performance logging"""
+    perf_logger = logging.getLogger("performance")
+
+    # Add handler if not already configured
+    if not perf_logger.handlers:
+        handler = SafeStreamHandler()
+        formatter = logging.Formatter("%(asctime)s - Performance - %(message)s")
+        handler.setFormatter(formatter)
+        perf_logger.addHandler(handler)
+        perf_logger.setLevel(logging.INFO)
+
+    return perf_logger
+
+
+class LoggingContext:
+    """Context manager for controlling logging behavior"""
+
+    def __init__(self, enabled: bool = True, level: int | None = None):
+        self.enabled = enabled
+        self.level = level
+        self.old_level: int | None = None
+        self.target_logger = (
+            logging.getLogger()
+        )  # Use root logger for compatibility with tests
+
+    def __enter__(self) -> "LoggingContext":
+        if self.enabled and self.level is not None:
+            self.old_level = self.target_logger.level
+            self.target_logger.setLevel(self.level)
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        if self.enabled and self.old_level is not None:
+            self.target_logger.setLevel(self.old_level)

{tree_sitter_analyzer-0.6.2.dist-info → tree_sitter_analyzer-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.6.2
+Version: 0.8.0
 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
@@ -33,8 +33,11 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: cachetools>=5.0.0
 Requires-Dist: chardet>=5.0.0
+Requires-Dist: mcp>=1.12.3
 Requires-Dist: tree-sitter-cpp>=0.23.4
 Requires-Dist: tree-sitter-java>=0.23.5
+Requires-Dist: tree-sitter-javascript>=0.23.1
+Requires-Dist: tree-sitter-python>=0.23.6
 Requires-Dist: tree-sitter==0.24.0
 Provides-Extra: all-languages
 Requires-Dist: tree-sitter-c>=0.20.0; extra == 'all-languages'

tree_sitter_analyzer-0.8.0.dist-info/RECORD

@@ -0,0 +1,76 @@
+tree_sitter_analyzer/__init__.py,sha256=T8urKvmHQaqEoh_-jKgNJOb2Snz2ySjMqYWE53vLKKA,3199
+tree_sitter_analyzer/__main__.py,sha256=ilhMPpn_ar28oelzxLfQcX6WH_UbQ2euxiSoV3z_yCg,239
+tree_sitter_analyzer/api.py,sha256=_94HoE1LKGELSE6FpZ6pEqm2R7qfoPokyfpGSjawliQ,17487
+tree_sitter_analyzer/cli_main.py,sha256=bJP7CUHMSSgbPrze7PmOYsVXJ1z1jfhaP0nIVkU7dRw,9581
+tree_sitter_analyzer/encoding_utils.py,sha256=C5DpH2-qkAKfsJeSGNHbhOCy4bmn46X6rUw5xPpki34,14938
+tree_sitter_analyzer/exceptions.py,sha256=xO_U6JuJ4QPkmZoXL_3nmV9QUbTa7-hrI05VAuo5r-Y,12093
+tree_sitter_analyzer/file_handler.py,sha256=vl4bGx-OgC6Lq63FEZNu2XCXNM0iDTmpNCRTK2msP3U,7104
+tree_sitter_analyzer/language_detector.py,sha256=IjkYF1E7_TtWlwYjz780ZUJAyPltL2aZVzo-doTbAug,12540
+tree_sitter_analyzer/language_loader.py,sha256=gdLxkSoajm-q7c1vcvFONtBf5XJRgasUVI4L0wMzra0,8124
+tree_sitter_analyzer/models.py,sha256=z0aqdZOVA8rYWF0143TSAUoCvncVRLZ1O70eAjV87gU,16564
+tree_sitter_analyzer/output_manager.py,sha256=eiBOSL2vUUQi1ghYBr4gwT7aOYC2WTgIoISBZlXkzPo,8399
+tree_sitter_analyzer/query_loader.py,sha256=NilC2XmmhYrBL6ONlzRGlehGa23C_4V6nDVap6YG8v0,10120
+tree_sitter_analyzer/table_formatter.py,sha256=BfrAouAr3r6MD9xY9yhHw_PwD0aJ4BQo5p1UFhorT5k,27284
+tree_sitter_analyzer/utils.py,sha256=Pq_2vlDPul8jean0PwlQ_XC-RDjkuaUbwoXp2ls7dV8,8268
+tree_sitter_analyzer/cli/__init__.py,sha256=swCjWlrPEVIKGznqM_BPxbNvd_0Qz5r1_RmZ-j6EWIU,910
+tree_sitter_analyzer/cli/__main__.py,sha256=xgCuvLv5NNeEsxKM40pF_7b1apgj3DZ4ECa-xcbLKWc,230
+tree_sitter_analyzer/cli/info_commands.py,sha256=z6JhXO1Sm983dHj0uxNVzycWBYz1JIGVCOi0ukSAyTM,4419
+tree_sitter_analyzer/cli/commands/__init__.py,sha256=qLtJ7rRge-Reu4aZbczn_jmUHQNQ4lEAsve9BZYHYd0,697
+tree_sitter_analyzer/cli/commands/advanced_command.py,sha256=YJGrFBEqFPpS0VB-o28Un89Cjwr-eTirNdcFLP4rlN8,3512
+tree_sitter_analyzer/cli/commands/base_command.py,sha256=LNRTNYMpAuSAwyxM7rtA1oZcvWPMaAHXsBdv--FOGgw,5947
+tree_sitter_analyzer/cli/commands/default_command.py,sha256=-bJJC3Klie7EU3B3n_YXUYKAUSBzC2XUHP3XOnwENvQ,549
+tree_sitter_analyzer/cli/commands/partial_read_command.py,sha256=D8dY3CUaNn5EEPgrJNR4e7IClfJal7zenlbWxZcHwPQ,4825
+tree_sitter_analyzer/cli/commands/query_command.py,sha256=5SsxwJQInS0YQz9W6ZD_P88-wekfl7VKN_Utlm47YTk,3200
+tree_sitter_analyzer/cli/commands/structure_command.py,sha256=u-NKm06CLgx4srdK5bVo7WtcV4dArA7WYWQWmeXcWMs,5358
+tree_sitter_analyzer/cli/commands/summary_command.py,sha256=X3pLK7t2ma4SDlG7yYsaFX6bQ4OVUrHv8OWDfgTMNMw,3703
+tree_sitter_analyzer/cli/commands/table_command.py,sha256=LuQWeWqCxOArrINcDY9fnXnFyWtESKpffwg_oMQByGw,9683
+tree_sitter_analyzer/core/__init__.py,sha256=Um_BRFICWihZybxoAR6Ck32gJ42ZatkBoZR18XGl9FQ,455
+tree_sitter_analyzer/core/analysis_engine.py,sha256=pWyvdYOlTHyLTBcV90yg-yaWQRRi7MWbXTGhoylpzQ0,19122
+tree_sitter_analyzer/core/cache_service.py,sha256=lTFhGsmuGWgEauxtk2pz_1h5Z945456CaQILfreS5Rw,9944
+tree_sitter_analyzer/core/engine.py,sha256=6NRPBlN1GvFDtSh8hDJ8udKLC7IOjvoCPetuM7MPrnw,19287
+tree_sitter_analyzer/core/parser.py,sha256=07vL-mESeMsaIrQqAg-3sr9MLWYVdzT5RyBDO1AkBh0,9586
+tree_sitter_analyzer/core/query.py,sha256=fmuPMLsU4XUnMViaQADPRPoiZ-MzeE2k_e9N35VBNSA,16899
+tree_sitter_analyzer/formatters/__init__.py,sha256=0YJGj4VxZRB5b29zlOKWN4UG74C5EWlljYBx0HWI9sg,32
+tree_sitter_analyzer/formatters/base_formatter.py,sha256=bFthHalpKOSIP76MpKc9ga-GEkgowR7aI5aWNv9UYpw,5930
+tree_sitter_analyzer/formatters/formatter_factory.py,sha256=fRlgm6Z3Wf9mTLegBrRCvbA-TmX23nF93vjsT5bf8KY,2147
+tree_sitter_analyzer/formatters/java_formatter.py,sha256=MKssGZwvOXxARq-P9DT0ksclAYC3YpVQuY3c-oiKQhI,11622
+tree_sitter_analyzer/formatters/python_formatter.py,sha256=HkkUu5O7pGvw2e5SSsQTSUJWkS84pg6uuIkiG0lDxkQ,10275
+tree_sitter_analyzer/interfaces/__init__.py,sha256=qS0b_9AzhwX-5olNChVh-NUINpohCuVWHxegiqEnXYA,280
+tree_sitter_analyzer/interfaces/cli.py,sha256=KW-OJxYoiRsushiGNN0uF_gDDzlyfRTP7OHnie_Mt_k,17368
+tree_sitter_analyzer/interfaces/cli_adapter.py,sha256=H50tbqfs_3UueQPhq5_9s6I1ZwoCKr2vZXXGAMl3L3c,11535
+tree_sitter_analyzer/interfaces/mcp_adapter.py,sha256=q94pFJgO1434Dngdbob6c4UQn-Z6BmxVwLND4pp32P8,7317
+tree_sitter_analyzer/interfaces/mcp_server.py,sha256=-vOxiDEJqPaMbRiPr5n0fGtIXOkTM-GxkxKovE2tsB4,16934
+tree_sitter_analyzer/languages/__init__.py,sha256=D-b1wReVcu3XRBvbeWgO80i29naGJ6u1uP5bOfFKbiY,350
+tree_sitter_analyzer/languages/java_plugin.py,sha256=o_9F_anKCemnUDV6hq28RatRmBm3e0nchcQZ-v0nDv4,48454
+tree_sitter_analyzer/languages/javascript_plugin.py,sha256=9al0ScXmM5Y8Xl82oNp7cUaU9P59eNCJCPXSlfea4u8,16290
+tree_sitter_analyzer/languages/python_plugin.py,sha256=nlVxDx6thOB5o6QfQzGbD7gph3_YuM32YYzqYZoHlMw,29899
+tree_sitter_analyzer/mcp/__init__.py,sha256=mL_XjEks3tJOGAl9ULs_09KQOH1BWi92yvXpBidwmlI,752
+tree_sitter_analyzer/mcp/server.py,sha256=uXV4hUroFRnHTP8_axkKWh2OkN3o6OwNxS-BjlrKMfA,12937
+tree_sitter_analyzer/mcp/resources/__init__.py,sha256=PHDvZyHZawoToDQVqrepsmcTk00ZlaTsu6uxwVjoa4A,1433
+tree_sitter_analyzer/mcp/resources/code_file_resource.py,sha256=MDHvJl6akElHtcxlN6eCcY5WYSjQEQFCyhAVGiPGk9s,6462
+tree_sitter_analyzer/mcp/resources/project_stats_resource.py,sha256=lZF9TGxjKvTwPyuWE_o3I3V4LK0zEj3lab4L0Iq-hho,19758
+tree_sitter_analyzer/mcp/tools/__init__.py,sha256=RMvJOzfZMVe24WUNWJJ-pdygc1RbEVrhW5NZwpykDoQ,792
+tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=ZVNEghqKFOcLNZKsv9cJI19t8ZqcgcPp_bXiNkfoWps,26997
+tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py,sha256=Ie1yeGTFNxuEeTLgXVnKEdKktoMEV27ychIMVkStRY8,9244
+tree_sitter_analyzer/mcp/tools/base_tool.py,sha256=szW84sSYejzRyBlFbskOARQbsfc2JLwHmjZ6rJZ8SQA,1264
+tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=aWBfJXDbjUpiu9xx_-89Js_GebB468mUyupAwT8oA5E,11035
+tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=O9bxfwGNNjTNpBN5HJ5iTgKALoMTZ2HSYRryBZxaQu0,14623
+tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=1UslG_OpB9r1upX1xPYUSquRLYSVzglV8XgO3V2RJjs,21328
+tree_sitter_analyzer/mcp/utils/__init__.py,sha256=F_qFFC2gvGNdgRWGLxIh4Amd0dPhZv0Ni1ZbCbaYLlI,3063
+tree_sitter_analyzer/mcp/utils/error_handler.py,sha256=n9ME2U5L1o65Vewnv8kD2O8dVI1CiEGm1pLWdnpnyqM,17972
+tree_sitter_analyzer/plugins/__init__.py,sha256=MfSW8P9GLaL_9XgLISdlpIUY4quqapk0avPLIpBdMTg,10606
+tree_sitter_analyzer/plugins/base.py,sha256=or-p0ZkXxVPuXEsysRbOcBGo2r-Di-BgnN3e0fnN44Q,17696
+tree_sitter_analyzer/plugins/manager.py,sha256=DTe1kGNzElOKXjlcKuHkA-SOOpInBeFCeT6rSdxR3AI,12914
+tree_sitter_analyzer/queries/__init__.py,sha256=3jKMxFXiGUhI8V_tGRNGjlZfXYW7iguVTZut6OS9N6Y,722
+tree_sitter_analyzer/queries/java.py,sha256=guHrEQD2PvzUvY7dVxIXpul2KmIJMLefq7G7qSyxQN4,12640
+tree_sitter_analyzer/queries/javascript.py,sha256=wIv5k-l48e1_sW_vqNUBkdNKO97CBs-L8IZcQIQeZh0,4110
+tree_sitter_analyzer/queries/python.py,sha256=tl72D3JTOSNIG-1lXww0YKQ41AgMKB5iBUkNBaqfkiI,7855
+tree_sitter_analyzer/queries/typescript.py,sha256=I1ndwPjAMGOIa1frSK3ewLqEkeDAJuAE9qzD9seEGf4,6937
+tree_sitter_analyzer/security/__init__.py,sha256=zVpzS5jtECwgYnhKL4YoMfnIdkJABnVeziTBB4IOTyU,624
+tree_sitter_analyzer/security/boundary_manager.py,sha256=e4iOJTygHLqlImkOntjLhfTpCvqCfb2LTpYwGpYmVQg,8051
+tree_sitter_analyzer/security/regex_checker.py,sha256=Qvldh-TiVYqtcYQbD80wk0eHUvhALYtWTWBy_bGmJUk,10025
+tree_sitter_analyzer/security/validator.py,sha256=RRGyacxCjJ2CbfvGzpZCvza8YxqSrOiO2JWY49oFMh8,8187
+tree_sitter_analyzer-0.8.0.dist-info/METADATA,sha256=JtFjrCj-g9vPbMvYKurXQXB8I8Ogxo_DGB_lATblvIk,13525
+tree_sitter_analyzer-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-0.8.0.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
+tree_sitter_analyzer-0.8.0.dist-info/RECORD,,