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

mcp_vector_search/parsers/base.py

@@ -2,7 +2,6 @@
 
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import List, Optional
 
 from ..core.models import CodeChunk
 
@@ -12,32 +11,32 @@ class BaseParser(ABC):
 
     def __init__(self, language: str) -> None:
         """Initialize parser for a specific language.
-        
+
         Args:
             language: Programming language name
         """
         self.language = language
 
     @abstractmethod
-    async def parse_file(self, file_path: Path) -> List[CodeChunk]:
+    async def parse_file(self, file_path: Path) -> list[CodeChunk]:
         """Parse a file and extract code chunks.
-        
+
         Args:
             file_path: Path to the file to parse
-            
+
         Returns:
             List of code chunks extracted from the file
         """
         ...
 
     @abstractmethod
-    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 content and extract code chunks.
-        
+
         Args:
             content: File content to parse
             file_path: Path to the source file (for metadata)
-            
+
         Returns:
             List of code chunks extracted from the content
         """
@@ -45,19 +44,19 @@ class BaseParser(ABC):
 
     def supports_file(self, file_path: Path) -> bool:
         """Check if this parser supports the given file.
-        
+
         Args:
             file_path: Path to check
-            
+
         Returns:
             True if this parser can handle the file
         """
         return file_path.suffix.lower() in self.get_supported_extensions()
 
     @abstractmethod
-    def get_supported_extensions(self) -> List[str]:
+    def get_supported_extensions(self) -> list[str]:
         """Get list of file extensions supported by this parser.
-        
+
         Returns:
             List of file extensions (including the dot)
         """
@@ -70,12 +69,12 @@ class BaseParser(ABC):
         start_line: int,
         end_line: int,
         chunk_type: str = "code",
-        function_name: Optional[str] = None,
-        class_name: Optional[str] = None,
-        docstring: Optional[str] = None,
+        function_name: str | None = None,
+        class_name: str | None = None,
+        docstring: str | None = None,
     ) -> CodeChunk:
         """Create a code chunk with metadata.
-        
+
         Args:
             content: Code content
             file_path: Source file path
@@ -85,7 +84,7 @@ class BaseParser(ABC):
             function_name: Function name if applicable
             class_name: Class name if applicable
             docstring: Docstring if applicable
-            
+
         Returns:
             CodeChunk instance
         """
@@ -101,32 +100,32 @@ class BaseParser(ABC):
             docstring=docstring,
         )
 
-    def _split_into_lines(self, content: str) -> List[str]:
+    def _split_into_lines(self, content: str) -> list[str]:
         """Split content into lines, preserving line endings.
-        
+
         Args:
             content: Content to split
-            
+
         Returns:
             List of lines
         """
         return content.splitlines(keepends=True)
 
-    def _get_line_range(self, lines: List[str], start_line: int, end_line: int) -> str:
+    def _get_line_range(self, lines: list[str], start_line: int, end_line: int) -> str:
         """Extract a range of lines from content.
-        
+
         Args:
             lines: List of lines
             start_line: Starting line number (1-based)
             end_line: Ending line number (1-based)
-            
+
         Returns:
             Content for the specified line range
         """
         # Convert to 0-based indexing
         start_idx = max(0, start_line - 1)
         end_idx = min(len(lines), end_line)
-        
+
         return "".join(lines[start_idx:end_idx])
 
 
@@ -137,32 +136,32 @@ class FallbackParser(BaseParser):
         """Initialize fallback parser."""
         super().__init__(language)
 
-    async def parse_file(self, file_path: Path) -> List[CodeChunk]:
+    async def parse_file(self, file_path: Path) -> list[CodeChunk]:
         """Parse file using simple text chunking."""
         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:
             # Return empty list if file can't be read
             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 content using simple text chunking."""
         if not content.strip():
             return []
 
         lines = self._split_into_lines(content)
         chunks = []
-        
+
         # Simple chunking: split into chunks of ~50 lines
         chunk_size = 50
         for i in range(0, len(lines), chunk_size):
             start_line = i + 1
             end_line = min(i + chunk_size, len(lines))
-            
+
             chunk_content = self._get_line_range(lines, start_line, end_line)
-            
+
             if chunk_content.strip():
                 chunk = self._create_chunk(
                     content=chunk_content,
@@ -175,6 +174,6 @@ class FallbackParser(BaseParser):
 
         return chunks
 
-    def get_supported_extensions(self) -> List[str]:
+    def get_supported_extensions(self) -> list[str]:
         """Fallback parser supports all extensions."""
         return ["*"]  # Special marker for "all extensions"

mcp_vector_search/parsers/javascript.py

@@ -2,7 +2,6 @@
 
 import re
 from pathlib import Path
-from typing import List, Optional
 
 from loguru import logger
 
@@ -17,24 +16,24 @@ class JavaScriptParser(BaseParser):
         """Initialize JavaScript parser."""
         super().__init__(language)
 
-    async def parse_file(self, file_path: Path) -> List[CodeChunk]:
+    async def parse_file(self, file_path: Path) -> list[CodeChunk]:
         """Parse a JavaScript/TypeScript 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 JavaScript/TypeScript content and extract code chunks."""
         if not content.strip():
             return []
 
         return await self._regex_parse(content, file_path)
 
-    async def _regex_parse(self, content: str, file_path: Path) -> List[CodeChunk]:
+    async def _regex_parse(self, content: str, file_path: Path) -> list[CodeChunk]:
         """Parse JavaScript/TypeScript using regex patterns."""
         chunks = []
         lines = self._split_into_lines(content)
@@ -42,25 +41,43 @@ class JavaScriptParser(BaseParser):
         # JavaScript/TypeScript patterns
         function_patterns = [
             re.compile(r"^\s*function\s+(\w+)\s*\(", re.MULTILINE),  # function name()
-            re.compile(r"^\s*const\s+(\w+)\s*=\s*\([^)]*\)\s*=>\s*{", re.MULTILINE),  # const name = () => {
-            re.compile(r"^\s*const\s+(\w+)\s*=\s*function\s*\(", re.MULTILINE),  # const name = function(
-            re.compile(r"^\s*(\w+)\s*:\s*function\s*\(", re.MULTILINE),  # name: function(
+            re.compile(
+                r"^\s*const\s+(\w+)\s*=\s*\([^)]*\)\s*=>\s*{", re.MULTILINE
+            ),  # const name = () => {
+            re.compile(
+                r"^\s*const\s+(\w+)\s*=\s*function\s*\(", re.MULTILINE
+            ),  # const name = function(
+            re.compile(
+                r"^\s*(\w+)\s*:\s*function\s*\(", re.MULTILINE
+            ),  # name: function(
             re.compile(r"^\s*(\w+)\s*\([^)]*\)\s*{", re.MULTILINE),  # name() { (method)
-            re.compile(r"^\s*async\s+function\s+(\w+)\s*\(", re.MULTILINE),  # async function name()
-            re.compile(r"^\s*async\s+(\w+)\s*\([^)]*\)\s*{", re.MULTILINE),  # async name() {
+            re.compile(
+                r"^\s*async\s+function\s+(\w+)\s*\(", re.MULTILINE
+            ),  # async function name()
+            re.compile(
+                r"^\s*async\s+(\w+)\s*\([^)]*\)\s*{", re.MULTILINE
+            ),  # async name() {
         ]
-        
+
         class_patterns = [
             re.compile(r"^\s*class\s+(\w+)", re.MULTILINE),  # class Name
-            re.compile(r"^\s*export\s+class\s+(\w+)", re.MULTILINE),  # export class Name
-            re.compile(r"^\s*export\s+default\s+class\s+(\w+)", re.MULTILINE),  # export default class Name
+            re.compile(
+                r"^\s*export\s+class\s+(\w+)", re.MULTILINE
+            ),  # export class Name
+            re.compile(
+                r"^\s*export\s+default\s+class\s+(\w+)", re.MULTILINE
+            ),  # export default class Name
         ]
-        
+
         interface_patterns = [
-            re.compile(r"^\s*interface\s+(\w+)", re.MULTILINE),  # interface Name (TypeScript)
-            re.compile(r"^\s*export\s+interface\s+(\w+)", re.MULTILINE),  # export interface Name
+            re.compile(
+                r"^\s*interface\s+(\w+)", re.MULTILINE
+            ),  # interface Name (TypeScript)
+            re.compile(
+                r"^\s*export\s+interface\s+(\w+)", re.MULTILINE
+            ),  # export interface Name
         ]
-        
+
         import_pattern = re.compile(r"^\s*(import|export).*", re.MULTILINE)
 
         # Extract imports
@@ -73,17 +90,17 @@ class JavaScriptParser(BaseParser):
         for pattern in function_patterns:
             for match in pattern.finditer(content):
                 function_name = match.group(1)
-                start_line = content[:match.start()].count("\n") + 1
-                
+                start_line = content[: match.start()].count("\n") + 1
+
                 # Find end of function
                 end_line = self._find_block_end(lines, start_line, "{", "}")
-                
+
                 func_content = self._get_line_range(lines, start_line, end_line)
-                
+
                 if func_content.strip():
                     # Extract JSDoc comment
                     jsdoc = self._extract_jsdoc(lines, start_line)
-                    
+
                     chunk = self._create_chunk(
                         content=func_content,
                         file_path=file_path,
@@ -100,17 +117,17 @@ class JavaScriptParser(BaseParser):
         for pattern in class_patterns:
             for match in pattern.finditer(content):
                 class_name = match.group(1)
-                start_line = content[:match.start()].count("\n") + 1
-                
+                start_line = content[: match.start()].count("\n") + 1
+
                 # Find end of class
                 end_line = self._find_block_end(lines, start_line, "{", "}")
-                
+
                 class_content = self._get_line_range(lines, start_line, end_line)
-                
+
                 if class_content.strip():
                     # Extract JSDoc comment
                     jsdoc = self._extract_jsdoc(lines, start_line)
-                    
+
                     chunk = self._create_chunk(
                         content=class_content,
                         file_path=file_path,
@@ -128,17 +145,19 @@ class JavaScriptParser(BaseParser):
             for pattern in interface_patterns:
                 for match in pattern.finditer(content):
                     interface_name = match.group(1)
-                    start_line = content[:match.start()].count("\n") + 1
-                    
+                    start_line = content[: match.start()].count("\n") + 1
+
                     # Find end of interface
                     end_line = self._find_block_end(lines, start_line, "{", "}")
-                    
-                    interface_content = self._get_line_range(lines, start_line, end_line)
-                    
+
+                    interface_content = self._get_line_range(
+                        lines, start_line, end_line
+                    )
+
                     if interface_content.strip():
                         # Extract JSDoc comment
                         jsdoc = self._extract_jsdoc(lines, start_line)
-                        
+
                         chunk = self._create_chunk(
                             content=interface_content,
                             file_path=file_path,
@@ -165,64 +184,71 @@ class JavaScriptParser(BaseParser):
 
         return chunks
 
-    def _find_block_end(self, lines: List[str], start_line: int, open_char: str, close_char: str) -> int:
+    def _find_block_end(
+        self, lines: list[str], start_line: int, open_char: str, close_char: str
+    ) -> int:
         """Find the end of a block by matching braces."""
         if start_line > len(lines):
             return len(lines)
-        
+
         brace_count = 0
         found_opening = False
-        
+
         for i in range(start_line - 1, len(lines)):
             line = lines[i]
-            
+
             for char in line:
                 if char == open_char:
                     brace_count += 1
                     found_opening = True
                 elif char == close_char:
                     brace_count -= 1
-                    
+
                     if found_opening and brace_count == 0:
                         return i + 1  # Return 1-based line number
-        
+
         return len(lines)
 
-    def _extract_jsdoc(self, lines: List[str], start_line: int) -> Optional[str]:
+    def _extract_jsdoc(self, lines: list[str], start_line: int) -> str | None:
         """Extract JSDoc comment before a function/class."""
         if start_line <= 1:
             return None
-        
+
         # Look backwards for JSDoc comment
         for i in range(start_line - 2, max(-1, start_line - 10), -1):
             line = lines[i].strip()
-            
+
             if line.endswith("*/"):
                 # Found end of JSDoc, collect the comment
                 jsdoc_lines = []
                 for j in range(i, -1, -1):
                     comment_line = lines[j].strip()
                     jsdoc_lines.insert(0, comment_line)
-                    
+
                     if comment_line.startswith("/**"):
                         # Found start of JSDoc
                         # Clean up the comment
                         cleaned_lines = []
                         for line in jsdoc_lines:
                             # Remove /** */ and * prefixes
-                            cleaned = line.replace("/**", "").replace("*/", "").replace("*", "").strip()
+                            cleaned = (
+                                line.replace("/**", "")
+                                .replace("*/", "")
+                                .replace("*", "")
+                                .strip()
+                            )
                             if cleaned:
                                 cleaned_lines.append(cleaned)
-                        
+
                         return " ".join(cleaned_lines) if cleaned_lines else None
-            
+
             # If we hit non-comment code, stop looking
             elif line and not line.startswith("//") 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."""
         if self.language == "typescript":
             return [".ts", ".tsx"]