mcp-vector-search 0.12.6__py3-none-any.whl → 1.0.3__py3-none-any.whl

mcp_vector_search/config/thresholds.py

@@ -0,0 +1,185 @@
+"""Threshold configuration for code quality metrics."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass
+class ComplexityThresholds:
+    """Thresholds for complexity metrics."""
+
+    # Cognitive complexity thresholds for grades
+    cognitive_a: int = 5  # A grade: 0-5
+    cognitive_b: int = 10  # B grade: 6-10
+    cognitive_c: int = 20  # C grade: 11-20
+    cognitive_d: int = 30  # D grade: 21-30
+    # F grade: 31+
+
+    # Cyclomatic complexity thresholds
+    cyclomatic_low: int = 4  # Low complexity
+    cyclomatic_moderate: int = 10  # Moderate
+    cyclomatic_high: int = 20  # High (needs attention)
+    # Very high: 21+
+
+    # Nesting depth thresholds
+    nesting_warning: int = 3  # Warning level
+    nesting_error: int = 5  # Error level
+
+    # Parameter count thresholds
+    parameters_warning: int = 4  # Warning level
+    parameters_error: int = 7  # Error level
+
+    # Method count thresholds
+    methods_warning: int = 10  # Warning level
+    methods_error: int = 20  # Error level
+
+
+@dataclass
+class SmellThresholds:
+    """Thresholds for code smell detection."""
+
+    # Long method threshold (lines of code)
+    long_method_lines: int = 50
+
+    # Too many parameters
+    too_many_parameters: int = 5
+
+    # Deep nesting
+    deep_nesting_depth: int = 4
+
+    # High complexity
+    high_complexity: int = 15
+
+    # God class (too many methods)
+    god_class_methods: int = 20
+
+    # Feature envy (placeholder for future)
+    feature_envy_external_calls: int = 5
+
+
+@dataclass
+class ThresholdConfig:
+    """Complete threshold configuration."""
+
+    complexity: ComplexityThresholds = field(default_factory=ComplexityThresholds)
+    smells: SmellThresholds = field(default_factory=SmellThresholds)
+
+    # Quality gate settings
+    fail_on_f_grade: bool = True
+    fail_on_smell_count: int = 10  # Fail if more than N smells
+    warn_on_d_grade: bool = True
+
+    @classmethod
+    def load(cls, path: Path) -> ThresholdConfig:
+        """Load configuration from YAML file.
+
+        Args:
+            path: Path to YAML configuration file
+
+        Returns:
+            ThresholdConfig instance
+        """
+        if not path.exists():
+            return cls()
+
+        with open(path) as f:
+            data = yaml.safe_load(f) or {}
+
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ThresholdConfig:
+        """Create config from dictionary.
+
+        Args:
+            data: Configuration dictionary
+
+        Returns:
+            ThresholdConfig instance
+        """
+        complexity_data = data.get("complexity", {})
+        smells_data = data.get("smells", {})
+
+        return cls(
+            complexity=(
+                ComplexityThresholds(**complexity_data)
+                if complexity_data
+                else ComplexityThresholds()
+            ),
+            smells=(
+                SmellThresholds(**smells_data) if smells_data else SmellThresholds()
+            ),
+            fail_on_f_grade=data.get("fail_on_f_grade", True),
+            fail_on_smell_count=data.get("fail_on_smell_count", 10),
+            warn_on_d_grade=data.get("warn_on_d_grade", True),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization.
+
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "complexity": {
+                "cognitive_a": self.complexity.cognitive_a,
+                "cognitive_b": self.complexity.cognitive_b,
+                "cognitive_c": self.complexity.cognitive_c,
+                "cognitive_d": self.complexity.cognitive_d,
+                "cyclomatic_low": self.complexity.cyclomatic_low,
+                "cyclomatic_moderate": self.complexity.cyclomatic_moderate,
+                "cyclomatic_high": self.complexity.cyclomatic_high,
+                "nesting_warning": self.complexity.nesting_warning,
+                "nesting_error": self.complexity.nesting_error,
+                "parameters_warning": self.complexity.parameters_warning,
+                "parameters_error": self.complexity.parameters_error,
+                "methods_warning": self.complexity.methods_warning,
+                "methods_error": self.complexity.methods_error,
+            },
+            "smells": {
+                "long_method_lines": self.smells.long_method_lines,
+                "too_many_parameters": self.smells.too_many_parameters,
+                "deep_nesting_depth": self.smells.deep_nesting_depth,
+                "high_complexity": self.smells.high_complexity,
+                "god_class_methods": self.smells.god_class_methods,
+                "feature_envy_external_calls": self.smells.feature_envy_external_calls,
+            },
+            "fail_on_f_grade": self.fail_on_f_grade,
+            "fail_on_smell_count": self.fail_on_smell_count,
+            "warn_on_d_grade": self.warn_on_d_grade,
+        }
+
+    def save(self, path: Path) -> None:
+        """Save configuration to YAML file.
+
+        Args:
+            path: Path to save configuration
+        """
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            yaml.dump(self.to_dict(), f, default_flow_style=False, sort_keys=False)
+
+    def get_grade(self, cognitive_complexity: int) -> str:
+        """Get complexity grade based on cognitive complexity.
+
+        Args:
+            cognitive_complexity: Cognitive complexity value
+
+        Returns:
+            Grade from A to F
+        """
+        if cognitive_complexity <= self.complexity.cognitive_a:
+            return "A"
+        elif cognitive_complexity <= self.complexity.cognitive_b:
+            return "B"
+        elif cognitive_complexity <= self.complexity.cognitive_c:
+            return "C"
+        elif cognitive_complexity <= self.complexity.cognitive_d:
+            return "D"
+        else:
+            return "F"

mcp_vector_search/core/auto_indexer.py

@@ -192,9 +192,9 @@ class AutoIndexer:
                 "staleness_seconds": staleness_seconds,
                 "is_stale": staleness_seconds > self.staleness_threshold,
                 "newest_file_time": newest_file_time,
-                "oldest_index_time": oldest_index_time
-                if oldest_index_time != float("inf")
-                else 0,
+                "oldest_index_time": (
+                    oldest_index_time if oldest_index_time != float("inf") else 0
+                ),
             }
 
         except Exception as e:

mcp_vector_search/core/boilerplate.py

@@ -0,0 +1,186 @@
+"""Boilerplate filtering for semantic search results.
+
+This module provides language-specific filtering to penalize common boilerplate
+code patterns (constructors, lifecycle methods, etc.) in search results while
+still preserving them when explicitly queried.
+"""
+
+from typing import Final
+
+# Language-specific boilerplate function/method names
+# Using frozensets for O(1) lookup performance
+_PYTHON_BOILERPLATE: Final[frozenset[str]] = frozenset(
+    {
+        "__init__",
+        "__str__",
+        "__repr__",
+        "__eq__",
+        "__hash__",
+        "__len__",
+        "__iter__",
+        "__next__",
+        "__enter__",
+        "__exit__",
+        "main",
+        "setUp",
+        "tearDown",
+        "setUpClass",
+        "tearDownClass",
+    }
+)
+
+_JAVASCRIPT_TYPESCRIPT_BOILERPLATE: Final[frozenset[str]] = frozenset(
+    {
+        "constructor",
+        "render",
+        "componentDidMount",
+        "componentWillUnmount",
+        "componentDidUpdate",
+        "useState",
+        "useEffect",
+        "index",
+        "main",
+        "default",
+    }
+)
+
+_DART_BOILERPLATE: Final[frozenset[str]] = frozenset(
+    {
+        "build",
+        "dispose",
+        "initState",
+        "didChangeDependencies",
+        "main",
+        "createState",
+    }
+)
+
+_PHP_BOILERPLATE: Final[frozenset[str]] = frozenset(
+    {
+        "__construct",
+        "__destruct",
+        "__toString",
+        "__get",
+        "__set",
+        "__call",
+        "__callStatic",
+        "index",
+        "main",
+    }
+)
+
+_RUBY_BOILERPLATE: Final[frozenset[str]] = frozenset(
+    {
+        "initialize",
+        "to_s",
+        "to_h",
+        "to_a",
+        "inspect",
+        "main",
+        "setup",
+        "teardown",
+    }
+)
+
+
+class BoilerplateFilter:
+    """Filter for identifying and penalizing boilerplate code patterns.
+
+    This filter applies language-specific penalties to common boilerplate
+    patterns (constructors, lifecycle methods, etc.) to improve search
+    result relevance. It avoids filtering when the user explicitly searches
+    for a boilerplate pattern.
+
+    Example:
+        filter = BoilerplateFilter()
+
+        # Returns penalty for __init__ in Python
+        penalty = filter.get_penalty("__init__", "python", "search classes")
+
+        # Returns 0.0 when explicitly searching for __init__
+        penalty = filter.get_penalty("__init__", "python", "find __init__ methods")
+    """
+
+    # Default penalty for boilerplate patterns
+    DEFAULT_PENALTY: Final[float] = -0.15
+
+    # Mapping of language identifiers to boilerplate sets
+    _LANGUAGE_BOILERPLATE: Final[dict[str, frozenset[str]]] = {
+        "python": _PYTHON_BOILERPLATE,
+        "javascript": _JAVASCRIPT_TYPESCRIPT_BOILERPLATE,
+        "typescript": _JAVASCRIPT_TYPESCRIPT_BOILERPLATE,
+        "jsx": _JAVASCRIPT_TYPESCRIPT_BOILERPLATE,
+        "tsx": _JAVASCRIPT_TYPESCRIPT_BOILERPLATE,
+        "dart": _DART_BOILERPLATE,
+        "php": _PHP_BOILERPLATE,
+        "ruby": _RUBY_BOILERPLATE,
+    }
+
+    def is_boilerplate(self, name: str, language: str, query: str) -> bool:
+        """Check if a function/method name is considered boilerplate.
+
+        Args:
+            name: Function or method name to check
+            language: Programming language (e.g., "python", "javascript")
+            query: Original search query
+
+        Returns:
+            True if the name is boilerplate AND not explicitly in the query
+
+        Example:
+            >>> filter = BoilerplateFilter()
+            >>> filter.is_boilerplate("__init__", "python", "find classes")
+            True
+            >>> filter.is_boilerplate("__init__", "python", "show __init__ methods")
+            False
+        """
+        if not name:
+            return False
+
+        # Don't filter if user explicitly searched for this boilerplate
+        query_lower = query.lower()
+        name_lower = name.lower()
+        if name_lower in query_lower:
+            return False
+
+        # Check if name is in language's boilerplate set
+        language_lower = language.lower()
+        boilerplate_set = self._LANGUAGE_BOILERPLATE.get(language_lower)
+
+        if boilerplate_set is None:
+            # Unknown language - no filtering
+            return False
+
+        # Exact match (case-sensitive for languages like Python)
+        return name in boilerplate_set
+
+    def get_penalty(
+        self,
+        name: str,
+        language: str,
+        query: str = "",
+        penalty: float | None = None,
+    ) -> float:
+        """Calculate penalty for a potentially boilerplate name.
+
+        Args:
+            name: Function or method name to check
+            language: Programming language (e.g., "python", "javascript")
+            query: Original search query (default: "")
+            penalty: Custom penalty value (default: uses DEFAULT_PENALTY)
+
+        Returns:
+            Penalty value (negative float) if boilerplate, 0.0 otherwise
+
+        Example:
+            >>> filter = BoilerplateFilter()
+            >>> filter.get_penalty("__init__", "python", "search classes")
+            -0.15
+            >>> filter.get_penalty("__init__", "python", "find __init__")
+            0.0
+            >>> filter.get_penalty("custom_method", "python", "search")
+            0.0
+        """
+        if self.is_boilerplate(name, language, query):
+            return penalty if penalty is not None else self.DEFAULT_PENALTY
+        return 0.0