mcp-vector-search 0.0.3__py3-none-any.whl → 0.4.11__py3-none-any.whl

mcp_vector_search/parsers/python.py

@@ -2,7 +2,6 @@
 
 import re
 from pathlib import Path
-from typing import List, Optional
 
 from loguru import logger
 
@@ -23,19 +22,22 @@ class PythonParser(BaseParser):
     def _initialize_parser(self) -> None:
         """Initialize Tree-sitter parser for Python."""
         try:
-            # Try the tree-sitter-languages package first
-            import tree_sitter_languages
+            # Try the tree-sitter-language-pack package (maintained alternative)
+            from tree_sitter_language_pack import get_language, get_parser
 
-            self._language = tree_sitter_languages.get_language("python")
-            self._parser = tree_sitter_languages.get_parser("python")
-            logger.debug("Python Tree-sitter parser initialized via tree-sitter-languages")
+            # Get the language and parser objects
+            self._language = get_language("python")
+            self._parser = get_parser("python")
+
+            logger.debug(
+                "Python Tree-sitter parser initialized via tree-sitter-language-pack"
+            )
             return
         except Exception as e:
-            logger.debug(f"tree-sitter-languages failed: {e}")
+            logger.debug(f"tree-sitter-language-pack failed: {e}")
 
         try:
             # Fallback to manual tree-sitter setup (requires language binaries)
-            import tree_sitter
 
             # This would require language binaries to be available
             # For now, we'll skip this and rely on fallback parsing
@@ -47,19 +49,21 @@ class PythonParser(BaseParser):
             self._parser = None
             self._language = None
 
-        logger.info("Using fallback regex-based parsing for Python (Tree-sitter unavailable)")
+        logger.info(
+            "Using fallback regex-based parsing for Python (Tree-sitter unavailable)"
+        )
 
-    async def parse_file(self, file_path: Path) -> List[CodeChunk]:
+    async def parse_file(self, file_path: Path) -> list[CodeChunk]:
         """Parse a Python file and extract code chunks."""
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 content = f.read()
             return await self.parse_content(content, file_path)
         except Exception as e:
             logger.error(f"Failed to read file {file_path}: {e}")
             return []
 
-    async def parse_content(self, content: str, file_path: Path) -> List[CodeChunk]:
+    async def parse_content(self, content: str, file_path: Path) -> list[CodeChunk]:
         """Parse Python content and extract code chunks."""
         if not content.strip():
             return []
@@ -78,7 +82,7 @@ class PythonParser(BaseParser):
 
     def _extract_chunks_from_tree(
         self, tree, content: str, file_path: Path
-    ) -> List[CodeChunk]:
+    ) -> list[CodeChunk]:
         """Extract code chunks from Tree-sitter AST."""
         chunks = []
         lines = self._split_into_lines(content)
@@ -94,7 +98,7 @@ class PythonParser(BaseParser):
             elif node_type == "class_definition":
                 class_chunks = self._extract_class(node, lines, file_path)
                 chunks.extend(class_chunks)
-                
+
                 # Visit class methods with class context
                 class_name = self._get_node_name(node)
                 for child in node.children:
@@ -104,7 +108,7 @@ class PythonParser(BaseParser):
                 module_chunk = self._extract_module_chunk(node, lines, file_path)
                 if module_chunk:
                     chunks.append(module_chunk)
-                
+
                 # Visit all children
                 for child in node.children:
                     visit_node(child)
@@ -115,7 +119,7 @@ class PythonParser(BaseParser):
 
         # Start traversal from root
         visit_node(tree.root_node)
-        
+
         # If no specific chunks found, create a single chunk for the whole file
         if not chunks:
             chunks.append(
@@ -131,21 +135,21 @@ class PythonParser(BaseParser):
         return chunks
 
     def _extract_function(
-        self, node, lines: List[str], file_path: Path, class_name: Optional[str] = None
-    ) -> List[CodeChunk]:
+        self, node, lines: list[str], file_path: Path, class_name: str | None = None
+    ) -> list[CodeChunk]:
         """Extract function definition as a chunk."""
         chunks = []
-        
+
         function_name = self._get_node_name(node)
         start_line = node.start_point[0] + 1
         end_line = node.end_point[0] + 1
-        
+
         # Get function content
         content = self._get_line_range(lines, start_line, end_line)
-        
+
         # Extract docstring if present
         docstring = self._extract_docstring(node, lines)
-        
+
         chunk = self._create_chunk(
             content=content,
             file_path=file_path,
@@ -157,23 +161,25 @@ class PythonParser(BaseParser):
             docstring=docstring,
         )
         chunks.append(chunk)
-        
+
         return chunks
 
-    def _extract_class(self, node, lines: List[str], file_path: Path) -> List[CodeChunk]:
+    def _extract_class(
+        self, node, lines: list[str], file_path: Path
+    ) -> list[CodeChunk]:
         """Extract class definition as a chunk."""
         chunks = []
-        
+
         class_name = self._get_node_name(node)
         start_line = node.start_point[0] + 1
         end_line = node.end_point[0] + 1
-        
+
         # Get class content
         content = self._get_line_range(lines, start_line, end_line)
-        
+
         # Extract docstring if present
         docstring = self._extract_docstring(node, lines)
-        
+
         chunk = self._create_chunk(
             content=content,
             file_path=file_path,
@@ -184,23 +190,23 @@ class PythonParser(BaseParser):
             docstring=docstring,
         )
         chunks.append(chunk)
-        
+
         return chunks
 
     def _extract_module_chunk(
-        self, node, lines: List[str], file_path: Path
-    ) -> Optional[CodeChunk]:
+        self, node, lines: list[str], file_path: Path
+    ) -> CodeChunk | None:
         """Extract module-level code (imports, constants, etc.)."""
         # Look for module-level statements (not inside functions/classes)
         module_lines = []
-        
+
         for child in node.children:
             if child.type in ["import_statement", "import_from_statement"]:
                 start_line = child.start_point[0] + 1
                 end_line = child.end_point[0] + 1
                 import_content = self._get_line_range(lines, start_line, end_line)
                 module_lines.append(import_content.strip())
-        
+
         if module_lines:
             content = "\n".join(module_lines)
             return self._create_chunk(
@@ -210,17 +216,17 @@ class PythonParser(BaseParser):
                 end_line=len(module_lines),
                 chunk_type="imports",
             )
-        
+
         return None
 
-    def _get_node_name(self, node) -> Optional[str]:
+    def _get_node_name(self, node) -> str | None:
         """Extract name from a named node (function, class, etc.)."""
         for child in node.children:
             if child.type == "identifier":
                 return child.text.decode("utf-8")
         return None
 
-    def _extract_docstring(self, node, lines: List[str]) -> Optional[str]:
+    def _extract_docstring(self, node, lines: list[str]) -> str | None:
         """Extract docstring from a function or class node."""
         # Look for string literal as first statement in body
         for child in node.children:
@@ -232,7 +238,9 @@ class PythonParser(BaseParser):
                                 # Extract string content
                                 start_line = expr_child.start_point[0] + 1
                                 end_line = expr_child.end_point[0] + 1
-                                docstring = self._get_line_range(lines, start_line, end_line)
+                                docstring = self._get_line_range(
+                                    lines, start_line, end_line
+                                )
                                 # Clean up docstring (remove quotes)
                                 return self._clean_docstring(docstring)
         return None
@@ -244,7 +252,7 @@ class PythonParser(BaseParser):
         cleaned = re.sub(r'^["\']|["\']$', "", cleaned.strip())
         return cleaned.strip()
 
-    async def _fallback_parse(self, content: str, file_path: Path) -> List[CodeChunk]:
+    async def _fallback_parse(self, content: str, file_path: Path) -> list[CodeChunk]:
         """Fallback parsing using regex when Tree-sitter is not available."""
         chunks = []
         lines = self._split_into_lines(content)
@@ -259,13 +267,13 @@ class PythonParser(BaseParser):
         for match in import_pattern.finditer(content):
             import_line = match.group(0).strip()
             imports.append(import_line)
-        
+
         # Find functions
         for match in function_pattern.finditer(content):
             function_name = match.group(1)
             # Find the actual line with 'def' by looking for it in the match
             match_text = match.group(0)
-            def_pos_in_match = match_text.find('def')
+            def_pos_in_match = match_text.find("def")
             actual_def_pos = match.start() + def_pos_in_match
             start_line = content[:actual_def_pos].count("\n") + 1
 
@@ -289,13 +297,13 @@ class PythonParser(BaseParser):
                 )
                 chunk.imports = imports  # Add imports to chunk
                 chunks.append(chunk)
-        
+
         # Find classes
         for match in class_pattern.finditer(content):
             class_name = match.group(1)
             # Find the actual line with 'class' by looking for it in the match
             match_text = match.group(0)
-            class_pos_in_match = match_text.find('class')
+            class_pos_in_match = match_text.find("class")
             actual_class_pos = match.start() + class_pos_in_match
             start_line = content[:actual_class_pos].count("\n") + 1
 
@@ -319,7 +327,7 @@ class PythonParser(BaseParser):
                 )
                 chunk.imports = imports  # Add imports to chunk
                 chunks.append(chunk)
-        
+
         # If no functions or classes found, create chunks for the whole file
         if not chunks:
             chunks.append(
@@ -331,10 +339,10 @@ class PythonParser(BaseParser):
                     chunk_type="module",
                 )
             )
-        
+
         return chunks
 
-    def _find_function_end(self, lines: List[str], start_line: int) -> int:
+    def _find_function_end(self, lines: list[str], start_line: int) -> int:
         """Find the end line of a function using indentation."""
         if start_line > len(lines):
             return len(lines)
@@ -359,11 +367,11 @@ class PythonParser(BaseParser):
         # If we reach here, the function goes to the end of the file
         return len(lines)
 
-    def _find_class_end(self, lines: List[str], start_line: int) -> int:
+    def _find_class_end(self, lines: list[str], start_line: int) -> int:
         """Find the end line of a class using indentation."""
         return self._find_function_end(lines, start_line)
 
-    def _extract_docstring_regex(self, content: str) -> Optional[str]:
+    def _extract_docstring_regex(self, content: str) -> str | None:
         """Extract docstring using regex patterns."""
         # Look for triple-quoted strings at the beginning of the content
         # after the def/class line
@@ -397,11 +405,11 @@ class PythonParser(BaseParser):
                 return " ".join(docstring_lines).strip()
 
             # If we hit non-docstring code, stop looking
-            if line and not line.startswith('#'):
+            if line and not line.startswith("#"):
                 break
 
         return None
 
-    def get_supported_extensions(self) -> List[str]:
+    def get_supported_extensions(self) -> list[str]:
         """Get supported file extensions."""
         return [".py", ".pyw"]

mcp_vector_search/parsers/registry.py

@@ -1,13 +1,13 @@
 """Parser registry for MCP Vector Search."""
 
 from pathlib import Path
-from typing import Dict, List, Optional
 
 from loguru import logger
 
 from .base import BaseParser, FallbackParser
-from .python import PythonParser
 from .javascript import JavaScriptParser, TypeScriptParser
+from .python import PythonParser
+from .text import TextParser
 
 
 class ParserRegistry:
@@ -15,10 +15,16 @@ class ParserRegistry:
 
     def __init__(self) -> None:
         """Initialize parser registry."""
-        self._parsers: Dict[str, BaseParser] = {}
-        self._extension_map: Dict[str, str] = {}
+        self._parsers: dict[str, BaseParser] = {}
+        self._extension_map: dict[str, str] = {}
         self._fallback_parser = FallbackParser()
-        self._register_default_parsers()
+        self._initialized = False
+
+    def _ensure_initialized(self) -> None:
+        """Ensure parsers are initialized (lazy initialization)."""
+        if not self._initialized:
+            self._register_default_parsers()
+            self._initialized = True
 
     def _register_default_parsers(self) -> None:
         """Register default parsers for supported languages."""
@@ -33,72 +39,79 @@ class ParserRegistry:
         # Register TypeScript parser
         typescript_parser = TypeScriptParser()
         self.register_parser("typescript", typescript_parser)
+        
+        # Register Text parser for .txt files
+        text_parser = TextParser()
+        self.register_parser("text", text_parser)
 
     def register_parser(self, language: str, parser: BaseParser) -> None:
         """Register a parser for a specific language.
-        
+
         Args:
             language: Language name
             parser: Parser instance
         """
         self._parsers[language] = parser
-        
+
         # Map file extensions to language
         for ext in parser.get_supported_extensions():
             if ext != "*":  # Skip fallback marker
                 self._extension_map[ext.lower()] = language
-        
+
         logger.debug(f"Registered parser for {language}: {parser.__class__.__name__}")
 
     def get_parser(self, file_extension: str) -> BaseParser:
         """Get parser for a file extension.
-        
+
         Args:
             file_extension: File extension (including dot)
-            
+
         Returns:
             Parser instance (fallback parser if no specific parser found)
         """
+        self._ensure_initialized()
         language = self._extension_map.get(file_extension.lower())
         if language and language in self._parsers:
             return self._parsers[language]
-        
+
         # Return fallback parser for unsupported extensions
         return self._fallback_parser
 
     def get_parser_for_file(self, file_path: Path) -> BaseParser:
         """Get parser for a specific file.
-        
+
         Args:
             file_path: Path to the file
-            
+
         Returns:
             Parser instance
         """
         return self.get_parser(file_path.suffix)
 
-    def get_supported_languages(self) -> List[str]:
+    def get_supported_languages(self) -> list[str]:
         """Get list of supported languages.
-        
+
         Returns:
             List of language names
         """
+        self._ensure_initialized()
         return list(self._parsers.keys())
 
-    def get_supported_extensions(self) -> List[str]:
+    def get_supported_extensions(self) -> list[str]:
         """Get list of supported file extensions.
-        
+
         Returns:
             List of file extensions
         """
+        self._ensure_initialized()
         return list(self._extension_map.keys())
 
     def is_supported(self, file_extension: str) -> bool:
         """Check if a file extension is supported.
-        
+
         Args:
             file_extension: File extension to check
-            
+
         Returns:
             True if supported (always True due to fallback parser)
         """
@@ -106,37 +119,39 @@ class ParserRegistry:
 
     def get_language_for_extension(self, file_extension: str) -> str:
         """Get language name for a file extension.
-        
+
         Args:
             file_extension: File extension
-            
+
         Returns:
             Language name (or "text" for unsupported extensions)
         """
+        self._ensure_initialized()
         return self._extension_map.get(file_extension.lower(), "text")
 
-    def get_parser_info(self) -> Dict[str, Dict[str, any]]:
+    def get_parser_info(self) -> dict[str, dict[str, any]]:
         """Get information about registered parsers.
-        
+
         Returns:
             Dictionary with parser information
         """
+        self._ensure_initialized()
         info = {}
-        
+
         for language, parser in self._parsers.items():
             info[language] = {
                 "class": parser.__class__.__name__,
                 "extensions": parser.get_supported_extensions(),
                 "language": parser.language,
             }
-        
+
         # Add fallback parser info
         info["fallback"] = {
             "class": self._fallback_parser.__class__.__name__,
             "extensions": ["*"],
             "language": self._fallback_parser.language,
         }
-        
+
         return info
 
 
@@ -146,7 +161,7 @@ _registry = ParserRegistry()
 
 def get_parser_registry() -> ParserRegistry:
     """Get the global parser registry instance.
-    
+
     Returns:
         Parser registry instance
     """
@@ -155,7 +170,7 @@ def get_parser_registry() -> ParserRegistry:
 
 def register_parser(language: str, parser: BaseParser) -> None:
     """Register a parser in the global registry.
-    
+
     Args:
         language: Language name
         parser: Parser instance
@@ -165,10 +180,10 @@ def register_parser(language: str, parser: BaseParser) -> None:
 
 def get_parser(file_extension: str) -> BaseParser:
     """Get parser for a file extension from the global registry.
-    
+
     Args:
         file_extension: File extension
-        
+
     Returns:
         Parser instance
     """
@@ -177,10 +192,10 @@ def get_parser(file_extension: str) -> BaseParser:
 
 def get_parser_for_file(file_path: Path) -> BaseParser:
     """Get parser for a file from the global registry.
-    
+
     Args:
         file_path: File path
-        
+
     Returns:
         Parser instance
     """