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

tree_sitter_analyzer/cli/commands/base_command.py

@@ -15,6 +15,8 @@ from ...file_handler import read_file_partial
 from ...language_detector import detect_language_from_file, is_language_supported
 from ...models import AnalysisResult
 from ...output_manager import output_error, output_info
+from ...project_detector import detect_project_root
+from ...security import SecurityValidator
 
 
 class BaseCommand(ABC):
@@ -28,18 +30,32 @@ class BaseCommand(ABC):
     def __init__(self, args: Namespace):
         """Initialize command with parsed arguments."""
         self.args = args
-        self.analysis_engine = get_analysis_engine()
+
+        # Detect project root with priority handling
+        file_path = getattr(args, 'file_path', None)
+        explicit_root = getattr(args, 'project_root', None)
+        self.project_root = detect_project_root(file_path, explicit_root)
+
+        # Initialize components with project root
+        self.analysis_engine = get_analysis_engine(self.project_root)
+        self.security_validator = SecurityValidator(self.project_root)
 
     def validate_file(self) -> bool:
         """Validate input file exists and is accessible."""
         if not hasattr(self.args, "file_path") or not self.args.file_path:
-            output_error("ERROR: File path not specified.")
+            output_error("File path not specified.")
+            return False
+
+        # Security validation
+        is_valid, error_msg = self.security_validator.validate_file_path(self.args.file_path)
+        if not is_valid:
+            output_error(f"Invalid file path: {error_msg}")
             return False
 
         import os
 
         if not os.path.exists(self.args.file_path):
-            output_error(f"ERROR: File not found: {self.args.file_path}")
+            output_error(f"File not found: {self.args.file_path}")
             return False
 
         return True
@@ -47,7 +63,9 @@ class BaseCommand(ABC):
     def detect_language(self) -> str | None:
         """Detect or validate the target language."""
         if hasattr(self.args, "language") and self.args.language:
-            target_language = self.args.language.lower()
+            # Sanitize language input
+            sanitized_language = self.security_validator.sanitize_input(self.args.language, max_length=50)
+            target_language = sanitized_language.lower()
             if (not hasattr(self.args, "table") or not self.args.table) and (
                 not hasattr(self.args, "quiet") or not self.args.quiet
             ):
@@ -94,10 +112,10 @@ class BaseCommand(ABC):
                         end_column=getattr(self.args, "end_column", None),
                     )
                     if partial_content is None:
-                        output_error("ERROR: Failed to read file partially")
+                        output_error("Failed to read file partially")
                         return None
                 except Exception as e:
-                    output_error(f"ERROR: Failed to read file partially: {e}")
+                    output_error(f"Failed to read file partially: {e}")
                     return None
 
             request = AnalysisRequest(
@@ -114,13 +132,13 @@ class BaseCommand(ABC):
                     if analysis_result
                     else "Unknown error"
                 )
-                output_error(f"ERROR: Analysis failed: {error_msg}")
+                output_error(f"Analysis failed: {error_msg}")
                 return None
 
             return analysis_result
 
         except Exception as e:
-            output_error(f"ERROR: An error occurred during analysis: {e}")
+            output_error(f"An error occurred during analysis: {e}")
             return None
 
     def execute(self) -> int:
@@ -143,7 +161,7 @@ class BaseCommand(ABC):
         try:
             return asyncio.run(self.execute_async(language))
         except Exception as e:
-            output_error(f"ERROR: An error occurred during command execution: {e}")
+            output_error(f"An error occurred during command execution: {e}")
             return 1
 
     @abstractmethod

tree_sitter_analyzer/cli/commands/default_command.py

@@ -14,5 +14,5 @@ class DefaultCommand(BaseCommand):
 
     async def execute_async(self, language: str) -> int:
         """Execute default command - show error for missing options."""
-        output_error("ERROR: Please specify a query or --advanced option")
+        output_error("Please specify a query or --advanced option")
         return 1

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -28,7 +28,7 @@ class PartialReadCommand(BaseCommand):
         if not hasattr(self.args, "file_path") or not self.args.file_path:
             from ...output_manager import output_error
 
-            output_error("ERROR: File path not specified.")
+            output_error("File path not specified.")
             return False
 
         import os
@@ -36,7 +36,7 @@ class PartialReadCommand(BaseCommand):
         if not os.path.exists(self.args.file_path):
             from ...output_manager import output_error
 
-            output_error(f"ERROR: File not found: {self.args.file_path}")
+            output_error(f"File not found: {self.args.file_path}")
             return False
 
         return True
@@ -56,20 +56,20 @@ class PartialReadCommand(BaseCommand):
         if not self.args.start_line:
             from ...output_manager import output_error
 
-            output_error("ERROR: --start-line is required")
+            output_error("--start-line is required")
             return 1
 
         if self.args.start_line < 1:
             from ...output_manager import output_error
 
-            output_error("ERROR: --start-line must be 1 or greater")
+            output_error("--start-line must be 1 or greater")
             return 1
 
         if self.args.end_line and self.args.end_line < self.args.start_line:
             from ...output_manager import output_error
 
             output_error(
-                "ERROR: --end-line must be greater than or equal to --start-line"
+                "--end-line must be greater than or equal to --start-line"
             )
             return 1
 
@@ -86,7 +86,7 @@ class PartialReadCommand(BaseCommand):
             if partial_content is None:
                 from ...output_manager import output_error
 
-                output_error("ERROR: Failed to read file partially")
+                output_error("Failed to read file partially")
                 return 1
 
             # Output the result
@@ -96,7 +96,7 @@ class PartialReadCommand(BaseCommand):
         except Exception as e:
             from ...output_manager import output_error
 
-            output_error(f"ERROR: Failed to read file partially: {e}")
+            output_error(f"Failed to read file partially: {e}")
             return 1
 
     def _output_partial_content(self, content: str) -> None:

tree_sitter_analyzer/cli/commands/query_command.py

@@ -18,21 +18,28 @@ class QueryCommand(BaseCommand):
         query_to_execute = None
 
         if hasattr(self.args, "query_key") and self.args.query_key:
+            # Sanitize query key input
+            sanitized_query_key = self.security_validator.sanitize_input(self.args.query_key, max_length=100)
             try:
-                query_to_execute = query_loader.get_query(language, self.args.query_key)
+                query_to_execute = query_loader.get_query(language, sanitized_query_key)
                 if query_to_execute is None:
                     output_error(
-                        f"ERROR: Query '{self.args.query_key}' not found for language '{language}'"
+                        f"Query '{sanitized_query_key}' not found for language '{language}'"
                     )
                     return 1
             except ValueError as e:
-                output_error(f"ERROR: {e}")
+                output_error(f"{e}")
                 return 1
         elif hasattr(self.args, "query_string") and self.args.query_string:
+            # Security check for query string (potential regex patterns)
+            is_safe, error_msg = self.security_validator.regex_checker.validate_pattern(self.args.query_string)
+            if not is_safe:
+                output_error(f"Unsafe query pattern: {error_msg}")
+                return 1
             query_to_execute = self.args.query_string
 
         if not query_to_execute:
-            output_error("ERROR: No query specified.")
+            output_error("No query specified.")
             return 1
 
         # Perform analysis

tree_sitter_analyzer/cli/commands/table_command.py

@@ -42,7 +42,7 @@ class TableCommand(BaseCommand):
             return 0
 
         except Exception as e:
-            output_error(f"ERROR: An error occurred during table format analysis: {e}")
+            output_error(f"An error occurred during table format analysis: {e}")
             return 1
 
     def _convert_to_structure_format(

tree_sitter_analyzer/cli/info_commands.py

@@ -78,7 +78,7 @@ class DescribeQueryCommand(InfoCommand):
 
             if query_description is None or query_content is None:
                 output_error(
-                    f"ERROR: Query '{self.args.describe_query}' not found for language '{language}'"
+                    f"Query '{self.args.describe_query}' not found for language '{language}'"
                 )
                 return 1
 
@@ -87,7 +87,7 @@ class DescribeQueryCommand(InfoCommand):
             )
             output_data(f"Query content:\n{query_content}")
         except ValueError as e:
-            output_error(f"ERROR: {e}")
+            output_error(f"{e}")
             return 1
         return 0
 

tree_sitter_analyzer/cli_main.py

@@ -166,6 +166,12 @@ def create_argument_parser() -> argparse.ArgumentParser:
         help="Explicitly specify language (auto-detected from extension if omitted)",
     )
 
+    # Project options
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security validation (auto-detected if not specified)",
+    )
+
     # Logging options
     parser.add_argument(
         "--quiet",
@@ -201,25 +207,25 @@ def handle_special_commands(args: argparse.Namespace) -> int | None:
     # Validate partial read options
     if hasattr(args, "partial_read") and args.partial_read:
         if args.start_line is None:
-            output_error("ERROR: --start-line is required")
+            output_error("--start-line is required")
             return 1
 
         if args.start_line < 1:
-            output_error("ERROR: --start-line must be 1 or greater")
+            output_error("--start-line must be 1 or greater")
             return 1
 
         if args.end_line and args.end_line < args.start_line:
             output_error(
-                "ERROR: --end-line must be greater than or equal to --start-line"
+                "--end-line must be greater than or equal to --start-line"
             )
             return 1
 
         if args.start_column is not None and args.start_column < 0:
-            output_error("ERROR: --start-column must be 0 or greater")
+            output_error("--start-column must be 0 or greater")
             return 1
 
         if args.end_column is not None and args.end_column < 0:
-            output_error("ERROR: --end-column must be 0 or greater")
+            output_error("--end-column must be 0 or greater")
             return 1
 
     # Query language commands
@@ -279,9 +285,9 @@ def main() -> None:
         sys.exit(exit_code)
     else:
         if not args.file_path:
-            output_error("ERROR: File path not specified.")
+            output_error("File path not specified.")
         else:
-            output_error("ERROR: No executable command specified.")
+            output_error("No executable command specified.")
         parser.print_help()
         sys.exit(1)
 

tree_sitter_analyzer/core/analysis_engine.py

@@ -15,11 +15,12 @@ Roo Code compliance:
 import hashlib
 import threading
 from dataclasses import dataclass
-from typing import Any, Optional, Protocol
+from typing import Any, Dict, Optional, Protocol
 
 from ..models import AnalysisResult
 from ..plugins.base import LanguagePlugin as BaseLanguagePlugin
 from ..plugins.manager import PluginManager
+from ..security import SecurityValidator
 from ..utils import log_debug, log_error, log_info, log_performance
 from .cache_service import CacheService
 
@@ -204,32 +205,41 @@ class UnifiedAnalysisEngine:
         _performance_monitor: パフォーマンス監視
     """
 
-    _instance: Optional["UnifiedAnalysisEngine"] = None
+    _instances: Dict[str, "UnifiedAnalysisEngine"] = {}
     _lock: threading.Lock = threading.Lock()
 
-    def __new__(cls) -> "UnifiedAnalysisEngine":
-        """シングルトンパターンでインスタンス共有"""
-        if cls._instance is None:
+    def __new__(cls, project_root: str = None) -> "UnifiedAnalysisEngine":
+        """シングルトンパターンでインスタンス共有 (project_root aware)"""
+        # Create a key based on project_root for different instances
+        instance_key = project_root or "default"
+
+        if instance_key not in cls._instances:
             with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-        return cls._instance
+                if instance_key not in cls._instances:
+                    instance = super().__new__(cls)
+                    cls._instances[instance_key] = instance
+                    # Mark as not initialized for this instance
+                    instance._initialized = False
 
-    def __init__(self) -> None:
+        return cls._instances[instance_key]
+
+    def __init__(self, project_root: str = None) -> None:
         """初期化（一度のみ実行）"""
-        if hasattr(self, "_initialized"):
+        if hasattr(self, "_initialized") and self._initialized:
             return
 
         self._cache_service = CacheService()
         self._plugin_manager = PluginManager()
         self._performance_monitor = PerformanceMonitor()
+        self._security_validator = SecurityValidator(project_root)
+        self._project_root = project_root
 
         # プラグインを自動ロード
         self._load_plugins()
 
         self._initialized = True
 
-        log_info("UnifiedAnalysisEngine initialized")
+        log_info(f"UnifiedAnalysisEngine initialized with project root: {project_root}")
 
     def _load_plugins(self) -> None:
         """利用可能なプラグインを自動ロード"""
@@ -265,6 +275,12 @@ class UnifiedAnalysisEngine:
         """
         log_info(f"Starting analysis for {request.file_path}")
 
+        # Security validation
+        is_valid, error_msg = self._security_validator.validate_file_path(request.file_path)
+        if not is_valid:
+            log_error(f"Security validation failed for file path: {request.file_path} - {error_msg}")
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         # キャッシュチェック（CLI・MCP間で共有）
         cache_key = self._generate_cache_key(request)
         cached_result = await self._cache_service.get(cache_key)
@@ -323,6 +339,12 @@ class UnifiedAnalysisEngine:
         Returns:
             Analysis result
         """
+        # Security validation
+        is_valid, error_msg = self._security_validator.validate_file_path(file_path)
+        if not is_valid:
+            log_error(f"Security validation failed for file path: {file_path} - {error_msg}")
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         request = AnalysisRequest(
             file_path=file_path,
             language=None,  # Auto-detect
@@ -545,11 +567,14 @@ class MockLanguagePlugin:
         )
 
 
-def get_analysis_engine() -> UnifiedAnalysisEngine:
+def get_analysis_engine(project_root: str = None) -> UnifiedAnalysisEngine:
     """
     統一解析エンジンのインスタンスを取得
 
+    Args:
+        project_root: Project root directory for security validation
+
     Returns:
         統一解析エンジンのシングルトンインスタンス
     """
-    return UnifiedAnalysisEngine()
+    return UnifiedAnalysisEngine(project_root)

tree_sitter_analyzer/mcp/server.py

@@ -6,8 +6,10 @@ This module provides the main MCP server that exposes tree-sitter analyzer
 functionality through the Model Context Protocol.
 """
 
+import argparse
 import asyncio
 import json
+import os
 import sys
 from typing import Any
 
@@ -43,6 +45,8 @@ except ImportError:
 
 
 from ..core.analysis_engine import get_analysis_engine
+from ..project_detector import detect_project_root
+from ..security import SecurityValidator
 from ..utils import setup_logger
 from . import MCP_INFO
 from .resources import CodeFileResource, ProjectStatsResource
@@ -64,16 +68,21 @@ class TreeSitterAnalyzerMCPServer:
     integrating with existing analyzer components.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the MCP server with analyzer components."""
         self.server: Server | None = None
-        self.analysis_engine = get_analysis_engine()
+        self._initialization_complete = False
+
+        logger.info("Starting MCP server initialization...")
+
+        self.analysis_engine = get_analysis_engine(project_root)
+        self.security_validator = SecurityValidator(project_root)
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
 
-        # Initialize MCP tools
-        self.read_partial_tool: MCPTool = ReadPartialTool()
-        self.universal_analyze_tool: MCPTool = UniversalAnalyzeTool()
-        self.table_format_tool: MCPTool = TableFormatTool()
+        # Initialize MCP tools with security validation
+        self.read_partial_tool: MCPTool = ReadPartialTool(project_root)
+        self.universal_analyze_tool: MCPTool = UniversalAnalyzeTool(project_root)
+        self.table_format_tool: MCPTool = TableFormatTool(project_root)
 
         # Initialize MCP resources
         self.code_file_resource = CodeFileResource()
@@ -83,13 +92,24 @@ class TreeSitterAnalyzerMCPServer:
         self.name = MCP_INFO["name"]
         self.version = MCP_INFO["version"]
 
-        logger.info(f"Initializing {self.name} v{self.version}")
+        self._initialization_complete = True
+        logger.info(f"MCP server initialization complete: {self.name} v{self.version}")
+
+    def is_initialized(self) -> bool:
+        """Check if the server is fully initialized."""
+        return self._initialization_complete
+
+    def _ensure_initialized(self) -> None:
+        """Ensure the server is initialized before processing requests."""
+        if not self._initialization_complete:
+            raise RuntimeError("Server not fully initialized. Please wait for initialization to complete.")
 
     @handle_mcp_errors("analyze_code_scale")
     async def _analyze_code_scale(self, arguments: dict[str, Any]) -> dict[str, Any]:
         """
         Analyze code scale and complexity metrics by delegating to the universal_analyze_tool.
         """
+        self._ensure_initialized()
         # Delegate the execution to the already initialized tool
         return await self.universal_analyze_tool.execute(arguments)
 
@@ -161,9 +181,28 @@ class TreeSitterAnalyzerMCPServer:
         async def handle_call_tool(
             name: str, arguments: dict[str, Any]
         ) -> list[TextContent]:
-            """Handle tool calls."""
+            """Handle tool calls with security validation."""
             try:
-                if name == "analyze_code_scale":
+                # Ensure server is fully initialized
+                self._ensure_initialized()
+
+                # Security validation for tool name
+                sanitized_name = self.security_validator.sanitize_input(name, max_length=100)
+
+                # Log tool call for audit
+                logger.info(f"MCP tool call: {sanitized_name} with args: {list(arguments.keys())}")
+
+                # Validate arguments contain no malicious content
+                for key, value in arguments.items():
+                    if isinstance(value, str):
+                        # Check for potential injection attempts
+                        if len(value) > 10000:  # Prevent extremely large inputs
+                            raise ValueError(f"Input too large for parameter {key}")
+
+                        # Basic sanitization for string inputs
+                        sanitized_value = self.security_validator.sanitize_input(value, max_length=10000)
+                        arguments[key] = sanitized_value
+                if sanitized_name == "analyze_code_scale":
                     result = await self._analyze_code_scale(arguments)
                     return [
                         TextContent(
@@ -171,7 +210,7 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "read_code_partial":
+                elif sanitized_name == "read_code_partial":
                     result = await self.read_partial_tool.execute(arguments)
                     return [
                         TextContent(
@@ -179,7 +218,7 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "format_table":
+                elif sanitized_name == "format_table":
                     result = await self.table_format_tool.execute(arguments)
                     return [
                         TextContent(
@@ -187,7 +226,7 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "analyze_code_universal":
+                elif sanitized_name == "analyze_code_universal":
                     result = await self.universal_analyze_tool.execute(arguments)
                     return [
                         TextContent(
@@ -318,10 +357,51 @@ class TreeSitterAnalyzerMCPServer:
                 pass  # Silently ignore logging errors during shutdown
 
 
+def parse_mcp_args(args=None) -> argparse.Namespace:
+    """Parse command line arguments for MCP server."""
+    parser = argparse.ArgumentParser(
+        description="Tree-sitter Analyzer MCP Server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Environment Variables:
+  TREE_SITTER_PROJECT_ROOT    Project root directory (alternative to --project-root)
+
+Examples:
+  python -m tree_sitter_analyzer.mcp.server
+  python -m tree_sitter_analyzer.mcp.server --project-root /path/to/project
+        """
+    )
+
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security validation (auto-detected if not specified)"
+    )
+
+    return parser.parse_args(args)
+
+
 async def main() -> None:
     """Main entry point for the MCP server."""
     try:
-        server = TreeSitterAnalyzerMCPServer()
+        # Parse command line arguments (empty list for testing)
+        args = parse_mcp_args([])
+
+        # Determine project root with priority handling
+        project_root = None
+
+        # Priority 1: Command line argument
+        if args.project_root:
+            project_root = args.project_root
+        # Priority 2: Environment variable
+        elif os.getenv('TREE_SITTER_PROJECT_ROOT'):
+            project_root = os.getenv('TREE_SITTER_PROJECT_ROOT')
+        # Priority 3: Auto-detection from current directory
+        else:
+            project_root = detect_project_root()
+
+        logger.info(f"MCP server starting with project root: {project_root}")
+
+        server = TreeSitterAnalyzerMCPServer(project_root)
         await server.run()
     except KeyboardInterrupt:
         try:

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -13,6 +13,7 @@ from typing import Any
 
 from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file
+from ...security import SecurityValidator
 from ...utils import setup_logger
 
 # Set up logging
@@ -28,11 +29,13 @@ class AnalyzeScaleTool:
     for LLM workflow efficiency.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the analyze scale tool."""
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
-        self.analysis_engine = get_analysis_engine()
-        logger.info("AnalyzeScaleTool initialized")
+        self.project_root = project_root
+        self.analysis_engine = get_analysis_engine(project_root)
+        self.security_validator = SecurityValidator(project_root)
+        logger.info("AnalyzeScaleTool initialized with security validation")
 
     def _calculate_file_metrics(self, file_path: str) -> dict[str, Any]:
         """
@@ -251,6 +254,12 @@ class AnalyzeScaleTool:
         if total_lines > 200:
             guidance["recommended_tools"].append("read_code_partial")
 
+        # Ensure all required fields exist
+        required_fields = ["complexity_hotspots", "classes", "methods", "fields", "imports"]
+        for field in required_fields:
+            if field not in structural_overview:
+                structural_overview[field] = []
+
         if len(structural_overview["complexity_hotspots"]) > 0:
             guidance["recommended_tools"].append("format_table")
             guidance["complexity_assessment"] = (
@@ -339,6 +348,16 @@ class AnalyzeScaleTool:
         include_details = arguments.get("include_details", False)
         include_guidance = arguments.get("include_guidance", True)
 
+        # Security validation
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+        if not is_valid:
+            logger.warning(f"Security validation failed for file path: {file_path} - {error_msg}")
+            raise ValueError(f"Invalid file path: {error_msg}")
+
+        # Sanitize inputs
+        if language:
+            language = self.security_validator.sanitize_input(language, max_length=50)
+
         # Validate file exists
         if not Path(file_path).exists():
             raise FileNotFoundError(f"File not found: {file_path}")

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from typing import Any
 
 from ...file_handler import read_file_partial
+from ...security import SecurityValidator
 from ...utils import setup_logger
 
 # Set up logging
@@ -25,9 +26,10 @@ class ReadPartialTool:
     selective file content reading through the MCP protocol.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the read partial tool."""
-        logger.info("ReadPartialTool initialized")
+        self.security_validator = SecurityValidator(project_root)
+        logger.info("ReadPartialTool initialized with security validation")
 
     def get_tool_schema(self) -> dict[str, Any]:
         """
@@ -102,6 +104,12 @@ class ReadPartialTool:
         end_column = arguments.get("end_column")
         # output_format = arguments.get("format", "text")  # Not used currently
 
+        # Security validation
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+        if not is_valid:
+            logger.warning(f"Security validation failed for file path: {file_path} - {error_msg}")
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         # Validate file exists
         if not Path(file_path).exists():
             raise FileNotFoundError(f"File not found: {file_path}")