tree-sitter-analyzer 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

tree_sitter_analyzer/utils.py

@@ -1,277 +1,277 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Utilities for Tree-sitter Analyzer
-
-Provides logging, debugging, and common utility functions.
-"""
-
-import logging
-import sys
-import atexit
-from functools import wraps
-from typing import Any, Optional
-
-
-# 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
-    
-    # 環境変数からログレベルを取得
-    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):
-        """
-        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():
-    """
-    Setup safe logging shutdown to prevent I/O errors
-    """
-    def cleanup_logging():
-        """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:
-                        pass
-        except:
-            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:
-                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: Optional[int] = None
-
-    def __enter__(self) -> "QuietMode":
-        if self.enabled:
-            self.old_level = logger.level
-            logger.setLevel(logging.ERROR)
-        return self  # type: ignore
-
-    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: Optional[float] = None,
-    details: Optional[dict] = 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: Optional[int] = None):
-        self.enabled = enabled
-        self.level = level
-        self.old_level: Optional[int] = 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  # type: ignore
-
-    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
+
+    # 環境変数からログレベルを取得
+    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):
+        """
+        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():
+    """
+    Setup safe logging shutdown to prevent I/O errors
+    """
+
+    def cleanup_logging():
+        """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  # type: ignore
+
+    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 | 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  # type: ignore
+
+    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.2.0.dist-info → tree_sitter_analyzer-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.2.0
+Version: 0.3.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
@@ -51,7 +51,6 @@ Provides-Extra: cpp
 Requires-Dist: tree-sitter-cpp>=0.23.4; extra == 'cpp'
 Provides-Extra: dev
 Requires-Dist: black>=24.0.0; extra == 'dev'
-Requires-Dist: flake8>=7.0.0; extra == 'dev'
 Requires-Dist: isort>=5.13.0; extra == 'dev'
 Requires-Dist: memory-profiler>=0.61.0; extra == 'dev'
 Requires-Dist: mypy>=1.17.0; extra == 'dev'
@@ -61,11 +60,11 @@ Requires-Dist: pytest-asyncio>=1.1.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
 Requires-Dist: pytest-mock>=3.14.1; extra == 'dev'
 Requires-Dist: pytest>=8.4.1; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Requires-Dist: types-psutil>=5.9.0; extra == 'dev'
 Provides-Extra: full
 Requires-Dist: anyio>=4.9.0; extra == 'full'
 Requires-Dist: black>=24.0.0; extra == 'full'
-Requires-Dist: flake8>=7.0.0; extra == 'full'
 Requires-Dist: httpx>=0.28.1; extra == 'full'
 Requires-Dist: isort>=5.13.0; extra == 'full'
 Requires-Dist: mcp>=1.12.2; extra == 'full'
@@ -79,6 +78,7 @@ Requires-Dist: pytest-asyncio>=1.1.0; extra == 'full'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'full'
 Requires-Dist: pytest-mock>=3.14.1; extra == 'full'
 Requires-Dist: pytest>=8.4.1; extra == 'full'
+Requires-Dist: ruff>=0.1.0; extra == 'full'
 Requires-Dist: tree-sitter-c>=0.20.0; extra == 'full'
 Requires-Dist: tree-sitter-cpp>=0.23.4; extra == 'full'
 Requires-Dist: tree-sitter-go>=0.20.0; extra == 'full'
@@ -198,7 +198,7 @@ Add to your Claude Desktop config file:
 uv add "tree-sitter-analyzer[popular]"
 
 # Step 1: Check file scale
-uv run python -m tree_sitter_analyzer examples/Sample.java --advanced
+uv run python -m tree_sitter_analyzer examples/Sample.java --advanced --output-format=text
 
 # Step 2: Analyze structure (for large files)
 uv run python -m tree_sitter_analyzer examples/Sample.java --table=full
@@ -252,7 +252,7 @@ Four powerful MCP tools for AI assistants:
 
 **Step 1: Basic analysis (Check file scale):**
 ```bash
-uv run python -m tree_sitter_analyzer examples/Sample.java --advanced
+uv run python -m tree_sitter_analyzer examples/Sample.java --advanced --output-format=text
 ```
 
 **Step 2: Structure analysis (For large files that exceed LLM limits):**
@@ -268,7 +268,7 @@ uv run python -m tree_sitter_analyzer examples/Sample.java --partial-read --star
 **Additional Options:**
 ```bash
 # Quiet mode (suppress INFO messages, show only errors)
-uv run python -m tree_sitter_analyzer examples/Sample.java --advanced --quiet
+uv run python -m tree_sitter_analyzer examples/Sample.java --advanced --output-format=text --quiet
 
 # Table output with quiet mode
 uv run python -m tree_sitter_analyzer examples/Sample.java --table=full --quiet
@@ -326,6 +326,21 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
 
+### 🤖 AI/LLM Collaboration
+
+This project supports AI-assisted development with specialized quality controls:
+
+```bash
+# For AI systems - run before generating code
+python check_quality.py --new-code-only
+python llm_code_checker.py --check-all
+
+# For AI-generated code review
+python llm_code_checker.py path/to/new_file.py
+```
+
+📖 **See our [AI Collaboration Guide](AI_COLLABORATION_GUIDE.md) and [LLM Coding Guidelines](LLM_CODING_GUIDELINES.md) for detailed instructions on working with AI systems.**
+
 ---
 
 **Made with ❤️ for developers who work with large codebases and AI assistants.**