mcp-vector-search 0.9.3__py3-none-any.whl → 0.12.1__py3-none-any.whl

mcp_vector_search/core/project.py

@@ -236,9 +236,12 @@ class ProjectManager:
                 count += 1
         return count
 
-    def get_project_info(self) -> ProjectInfo:
+    def get_project_info(self, file_count: int | None = None) -> ProjectInfo:
         """Get comprehensive project information.
 
+        Args:
+            file_count: Optional pre-computed file count (avoids expensive filesystem scan)
+
         Returns:
             Project information
         """
@@ -247,13 +250,19 @@ class ProjectManager:
 
         is_initialized = self.is_initialized()
         languages = []
-        file_count = 0
+        computed_file_count = 0
 
         if is_initialized:
             try:
                 config = self.config
                 languages = config.languages
-                file_count = self.count_indexable_files(config.file_extensions)
+                # Use provided file_count if available to avoid filesystem scan
+                if file_count is not None:
+                    computed_file_count = file_count
+                else:
+                    computed_file_count = self.count_indexable_files(
+                        config.file_extensions
+                    )
             except Exception:
                 # Ignore errors when getting detailed info
                 pass
@@ -265,7 +274,7 @@ class ProjectManager:
             index_path=index_path,
             is_initialized=is_initialized,
             languages=languages,
-            file_count=file_count,
+            file_count=computed_file_count,
         )
 
     def _iter_source_files(self) -> list[Path]:
@@ -301,7 +310,9 @@ class ProjectManager:
         """
         # First check gitignore rules if available
         # PERFORMANCE: Pass is_directory hint to avoid redundant stat() calls
-        if self.gitignore_parser and self.gitignore_parser.is_ignored(path, is_directory=is_directory):
+        if self.gitignore_parser and self.gitignore_parser.is_ignored(
+            path, is_directory=is_directory
+        ):
             return True
 
         # Check if any parent directory is in ignore patterns

mcp_vector_search/parsers/base.py

@@ -79,7 +79,7 @@ class BaseParser(ABC):
         if language is None:
             language = self.language
 
-        if not hasattr(node, 'children'):
+        if not hasattr(node, "children"):
             return 1.0
 
         complexity = 1.0  # Base complexity
@@ -87,39 +87,75 @@ class BaseParser(ABC):
         # Language-specific decision node types
         decision_nodes = {
             "python": {
-                "if_statement", "elif_clause", "while_statement", "for_statement",
-                "except_clause", "with_statement", "conditional_expression",
-                "boolean_operator"  # and, or
+                "if_statement",
+                "elif_clause",
+                "while_statement",
+                "for_statement",
+                "except_clause",
+                "with_statement",
+                "conditional_expression",
+                "boolean_operator",  # and, or
             },
             "javascript": {
-                "if_statement", "while_statement", "for_statement", "for_in_statement",
-                "switch_case", "catch_clause", "conditional_expression", "ternary_expression"
+                "if_statement",
+                "while_statement",
+                "for_statement",
+                "for_in_statement",
+                "switch_case",
+                "catch_clause",
+                "conditional_expression",
+                "ternary_expression",
             },
             "typescript": {
-                "if_statement", "while_statement", "for_statement", "for_in_statement",
-                "switch_case", "catch_clause", "conditional_expression", "ternary_expression"
+                "if_statement",
+                "while_statement",
+                "for_statement",
+                "for_in_statement",
+                "switch_case",
+                "catch_clause",
+                "conditional_expression",
+                "ternary_expression",
             },
             "dart": {
-                "if_statement", "while_statement", "for_statement", "for_in_statement",
-                "switch_case", "catch_clause", "conditional_expression"
+                "if_statement",
+                "while_statement",
+                "for_statement",
+                "for_in_statement",
+                "switch_case",
+                "catch_clause",
+                "conditional_expression",
             },
             "php": {
-                "if_statement", "elseif_clause", "while_statement", "foreach_statement",
-                "for_statement", "switch_case", "catch_clause", "ternary_expression"
+                "if_statement",
+                "elseif_clause",
+                "while_statement",
+                "foreach_statement",
+                "for_statement",
+                "switch_case",
+                "catch_clause",
+                "ternary_expression",
             },
             "ruby": {
-                "if", "unless", "while", "until", "for", "case", "rescue",
-                "conditional"
-            }
+                "if",
+                "unless",
+                "while",
+                "until",
+                "for",
+                "case",
+                "rescue",
+                "conditional",
+            },
         }
 
-        nodes_to_count = decision_nodes.get(language, decision_nodes.get("python", set()))
+        nodes_to_count = decision_nodes.get(
+            language, decision_nodes.get("python", set())
+        )
 
         def count_decision_points(n):
             nonlocal complexity
-            if hasattr(n, 'type') and n.type in nodes_to_count:
+            if hasattr(n, "type") and n.type in nodes_to_count:
                 complexity += 1
-            if hasattr(n, 'children'):
+            if hasattr(n, "children"):
                 for child in n.children:
                     count_decision_points(child)
 

mcp_vector_search/parsers/javascript.py

@@ -54,7 +54,7 @@ class JavaScriptParser(BaseParser):
 
         if self._use_tree_sitter:
             try:
-                tree = self._parser.parse(content.encode('utf-8'))
+                tree = self._parser.parse(content.encode("utf-8"))
                 return self._extract_chunks_from_tree(tree, content, file_path)
             except Exception as e:
                 logger.warning(f"Tree-sitter parsing failed for {file_path}: {e}")
@@ -77,10 +77,14 @@ class JavaScriptParser(BaseParser):
             extracted = False
 
             if node_type == "function_declaration":
-                chunks.extend(self._extract_function(node, lines, file_path, current_class))
+                chunks.extend(
+                    self._extract_function(node, lines, file_path, current_class)
+                )
                 extracted = True
             elif node_type == "arrow_function":
-                chunks.extend(self._extract_arrow_function(node, lines, file_path, current_class))
+                chunks.extend(
+                    self._extract_arrow_function(node, lines, file_path, current_class)
+                )
                 extracted = True
             elif node_type == "class_declaration":
                 class_chunks = self._extract_class(node, lines, file_path)
@@ -92,18 +96,22 @@ class JavaScriptParser(BaseParser):
                     visit_node(child, class_name)
                 extracted = True
             elif node_type == "method_definition":
-                chunks.extend(self._extract_method(node, lines, file_path, current_class))
+                chunks.extend(
+                    self._extract_method(node, lines, file_path, current_class)
+                )
                 extracted = True
             elif node_type == "lexical_declaration":
                 # const/let declarations might be arrow functions
-                extracted_chunks = self._extract_variable_function(node, lines, file_path, current_class)
+                extracted_chunks = self._extract_variable_function(
+                    node, lines, file_path, current_class
+                )
                 if extracted_chunks:
                     chunks.extend(extracted_chunks)
                     extracted = True
 
             # Only recurse into children if we didn't extract this node
             # This prevents double-extraction of arrow functions in variable declarations
-            if not extracted and hasattr(node, 'children'):
+            if not extracted and hasattr(node, "children"):
                 for child in node.children:
                     visit_node(child, current_class)
 
@@ -163,7 +171,7 @@ class JavaScriptParser(BaseParser):
     ) -> list[CodeChunk]:
         """Extract arrow function from AST."""
         # Arrow functions often don't have explicit names, try to get from parent
-        parent = getattr(node, 'parent', None)
+        parent = getattr(node, "parent", None)
         function_name = None
 
         if parent and parent.type == "variable_declarator":
@@ -219,7 +227,9 @@ class JavaScriptParser(BaseParser):
                             docstring = self._extract_jsdoc_from_node(child, lines)
 
                             # Calculate complexity
-                            complexity = self._calculate_complexity(subchild, "javascript")
+                            complexity = self._calculate_complexity(
+                                subchild, "javascript"
+                            )
 
                             # Extract parameters
                             parameters = self._extract_js_parameters(subchild)
@@ -319,8 +329,8 @@ class JavaScriptParser(BaseParser):
 
     def _get_node_text(self, node) -> str:
         """Get text content of a node."""
-        if hasattr(node, 'text'):
-            return node.text.decode('utf-8')
+        if hasattr(node, "text"):
+            return node.text.decode("utf-8")
         return ""
 
     def _extract_js_parameters(self, node) -> list[dict]:
@@ -330,12 +340,13 @@ class JavaScriptParser(BaseParser):
         for child in node.children:
             if child.type == "formal_parameters":
                 for param_node in child.children:
-                    if param_node.type in ("identifier", "required_parameter", "optional_parameter", "rest_parameter"):
-                        param_info = {
-                            "name": None,
-                            "type": None,
-                            "default": None
-                        }
+                    if param_node.type in (
+                        "identifier",
+                        "required_parameter",
+                        "optional_parameter",
+                        "rest_parameter",
+                    ):
+                        param_info = {"name": None, "type": None, "default": None}
 
                         # Extract parameter details
                         if param_node.type == "identifier":
@@ -347,10 +358,20 @@ class JavaScriptParser(BaseParser):
                                     param_info["name"] = self._get_node_text(subchild)
                                 elif subchild.type == "type_annotation":
                                     param_info["type"] = self._get_node_text(subchild)
-                                elif "default" in subchild.type or subchild.type == "number":
-                                    param_info["default"] = self._get_node_text(subchild)
-
-                        if param_info["name"] and param_info["name"] not in ("(", ")", ",", "..."):
+                                elif (
+                                    "default" in subchild.type
+                                    or subchild.type == "number"
+                                ):
+                                    param_info["default"] = self._get_node_text(
+                                        subchild
+                                    )
+
+                        if param_info["name"] and param_info["name"] not in (
+                            "(",
+                            ")",
+                            ",",
+                            "...",
+                        ):
                             # Clean up rest parameters
                             if param_info["name"].startswith("..."):
                                 param_info["name"] = param_info["name"][3:]

mcp_vector_search/parsers/python.py

@@ -452,12 +452,12 @@ class PythonParser(BaseParser):
         for child in node.children:
             if child.type == "parameters":
                 for param_node in child.children:
-                    if param_node.type in ("identifier", "typed_parameter", "default_parameter"):
-                        param_info = {
-                            "name": None,
-                            "type": None,
-                            "default": None
-                        }
+                    if param_node.type in (
+                        "identifier",
+                        "typed_parameter",
+                        "default_parameter",
+                    ):
+                        param_info = {"name": None, "type": None, "default": None}
 
                         # Extract parameter name
                         if param_node.type == "identifier":
@@ -470,9 +470,17 @@ class PythonParser(BaseParser):
                                 elif subchild.type == "type":
                                     param_info["type"] = self._get_node_text(subchild)
                                 elif "default" in subchild.type:
-                                    param_info["default"] = self._get_node_text(subchild)
-
-                        if param_info["name"] and param_info["name"] not in ("self", "cls", "(", ")", ","):
+                                    param_info["default"] = self._get_node_text(
+                                        subchild
+                                    )
+
+                        if param_info["name"] and param_info["name"] not in (
+                            "self",
+                            "cls",
+                            "(",
+                            ")",
+                            ",",
+                        ):
                             parameters.append(param_info)
         return parameters
 
@@ -485,8 +493,8 @@ class PythonParser(BaseParser):
 
     def _get_node_text(self, node) -> str:
         """Get text content of a node."""
-        if hasattr(node, 'text'):
-            return node.text.decode('utf-8')
+        if hasattr(node, "text"):
+            return node.text.decode("utf-8")
         return ""
 
     def get_supported_extensions(self) -> list[str]:

mcp_vector_search/parsers/registry.py

@@ -162,14 +162,15 @@ class ParserRegistry:
             info[language] = {
                 "class": parser.__class__.__name__,
                 "extensions": parser.get_supported_extensions(),
-                "language": parser.language,
+                "language": getattr(parser, "language", None) or language,
             }
 
         # Add fallback parser info
+        fallback_lang = getattr(self._fallback_parser, "language", None) or "unknown"
         info["fallback"] = {
             "class": self._fallback_parser.__class__.__name__,
             "extensions": ["*"],
-            "language": self._fallback_parser.language,
+            "language": fallback_lang,
         }
 
         return info

mcp_vector_search/utils/gitignore.py

@@ -51,14 +51,24 @@ class GitignorePattern:
         Returns:
             True if the pattern matches
         """
-        # Directory-only patterns only match directories
-        if self.is_directory_only and not is_directory:
-            return False
-
         # Convert path separators for consistent matching
         path = path.replace("\\", "/")
         pattern = self.pattern.replace("\\", "/")
 
+        # For directory-only patterns, check if any parent directory matches
+        # This implements Git's behavior where "dir/" excludes both the directory
+        # AND all files within it recursively
+        if self.is_directory_only:
+            path_parts = path.split("/")
+            # Check each parent directory component
+            for i in range(1, len(path_parts) + 1):
+                parent = "/".join(path_parts[:i])
+                if fnmatch.fnmatch(parent, pattern):
+                    return True
+            # If no parent matches and this is not a directory, don't exclude
+            if not is_directory:
+                return False
+
         # Try exact match first
         if fnmatch.fnmatch(path, pattern):
             return True
@@ -223,7 +233,9 @@ def create_gitignore_parser(project_root: Path) -> GitignoreParser:
     return GitignoreParser(project_root)
 
 
-def is_path_gitignored(path: Path, project_root: Path, is_directory: bool | None = None) -> bool:
+def is_path_gitignored(
+    path: Path, project_root: Path, is_directory: bool | None = None
+) -> bool:
     """Quick function to check if a path is gitignored.
 
     Args: