rootly-mcp-server 2.0.11__py3-none-any.whl → 2.0.12__py3-none-any.whl

rootly_mcp_server/__init__.py

@@ -13,7 +13,7 @@ Features:
 from .server import RootlyMCPServer
 from .client import RootlyClient
 
-__version__ = "2.0.1"
+__version__ = "2.0.12"
 __all__ = [
     'RootlyMCPServer',
     'RootlyClient',

rootly_mcp_server/smart_utils.py

@@ -13,10 +13,13 @@ from datetime import datetime
 
 # Check ML library availability
 import importlib.util
-ML_AVAILABLE = (
-    importlib.util.find_spec("sklearn.feature_extraction.text") is not None and
-    importlib.util.find_spec("sklearn.metrics.pairwise") is not None
-)
+try:
+    ML_AVAILABLE = (
+        importlib.util.find_spec("sklearn.feature_extraction.text") is not None and
+        importlib.util.find_spec("sklearn.metrics.pairwise") is not None
+    )
+except (ImportError, ModuleNotFoundError):
+    ML_AVAILABLE = False
 
 logger = logging.getLogger(__name__)
 
@@ -73,13 +76,27 @@ class TextSimilarityAnalyzer:
             r'\b(\w+)-(?:service|api|app|server|db)\b',  # service-api, auth-service
             r'\b(\w+)(?:service|api|app|server|db)\b',   # paymentapi, authservice
             r'\b(\w+)\.(?:service|api|app|com)\b',       # auth.service, api.com
+            r'\b(\w+)\s+(?:api|service|app|server|db)\b',  # payment api, auth service
+        ]
+        
+        # Known service names (exact matches)
+        known_services = [
+            'elasticsearch', 'elastic', 'kibana', 'redis', 'postgres', 'mysql', 
+            'mongodb', 'kafka', 'rabbitmq', 'nginx', 'apache', 'docker', 'kubernetes'
         ]
         
         text_lower = text.lower()
+        
+        # Extract pattern-based services
         for pattern in service_patterns:
             matches = re.findall(pattern, text_lower)
             services.extend(matches)
         
+        # Extract known services (with word boundaries to avoid false positives)
+        for service in known_services:
+            if re.search(r'\b' + re.escape(service) + r'\b', text_lower):
+                services.append(service)
+        
         # Remove duplicates while preserving order
         return list(dict.fromkeys(services))
     
@@ -128,18 +145,26 @@ class TextSimilarityAnalyzer:
         """Combine incident title, description, and other text fields."""
         text_parts = []
         
-        # Get text from incident attributes
+        # Get text from incident attributes (preferred)
         attributes = incident.get('attributes', {})
-        text_parts.append(attributes.get('title', ''))
-        text_parts.append(attributes.get('summary', ''))
-        text_parts.append(attributes.get('description', ''))
-        
-        # Also check root level for backward compatibility
-        text_parts.append(incident.get('title', ''))
-        text_parts.append(incident.get('summary', ''))
-        text_parts.append(incident.get('description', ''))
-        
-        combined = ' '.join([part for part in text_parts if part])
+        title = attributes.get('title', '')
+        summary = attributes.get('summary', '')
+        description = attributes.get('description', '')
+        
+        # Fallback to root level if attributes are empty
+        if not title:
+            title = incident.get('title', '')
+        if not summary:
+            summary = incident.get('summary', '')
+        if not description:
+            description = incident.get('description', '')
+        
+        # Add non-empty parts, avoiding duplication
+        for part in [title, summary, description]:
+            if part and part not in text_parts:
+                text_parts.append(part)
+        
+        combined = ' '.join(text_parts)
         return self.preprocess_text(combined)
     
     def _calculate_tfidf_similarity(self, incidents: List[Dict], target_incident: Dict, 
@@ -175,7 +200,15 @@ class TextSimilarityAnalyzer:
                 service_bonus = len(set(target_services) & set(incident_services)) * 0.1
                 error_bonus = len(set(target_errors) & set(incident_errors)) * 0.15
                 
-                final_score = min(1.0, similarities[i] + service_bonus + error_bonus)
+                # Exact match bonus for identical preprocessed text
+                exact_match_bonus = 0.0
+                if target_text and incident_texts[i] and target_text.strip() == incident_texts[i].strip():
+                    exact_match_bonus = 0.3  # Strong bonus for exact matches
+                
+                # Partial matching bonus using fuzzy keyword similarity
+                partial_bonus = self._calculate_partial_similarity_bonus(target_text, incident_texts[i])
+                
+                final_score = min(1.0, similarities[i] + service_bonus + error_bonus + exact_match_bonus + partial_bonus)
                 
                 results.append(IncidentSimilarity(
                     incident_id=str(incident.get('id', '')),
@@ -212,7 +245,15 @@ class TextSimilarityAnalyzer:
             service_bonus = len(set(target_services) & set(incident_services)) * 0.2
             error_bonus = len(set(target_errors) & set(incident_errors)) * 0.25
             
-            final_score = min(1.0, word_similarity + service_bonus + error_bonus)
+            # Exact match bonus for identical preprocessed text
+            exact_match_bonus = 0.0
+            if target_text and incident_text and target_text.strip() == incident_text.strip():
+                exact_match_bonus = 0.4  # Strong bonus for exact matches in keyword mode
+            
+            # Partial matching bonus using fuzzy keyword similarity
+            partial_bonus = self._calculate_partial_similarity_bonus(target_text, incident_text)
+            
+            final_score = min(1.0, word_similarity + service_bonus + error_bonus + exact_match_bonus + partial_bonus)
             
             if final_score > 0.15:  # Only include reasonable matches
                 results.append(IncidentSimilarity(
@@ -228,14 +269,94 @@ class TextSimilarityAnalyzer:
         return results
     
     def _extract_common_keywords(self, text1: str, text2: str) -> List[str]:
-        """Extract common meaningful keywords between two texts."""
+        """Extract common meaningful keywords between two texts with fuzzy matching."""
+        words1 = set(text1.split())
+        words2 = set(text2.split())
+        
+        # Exact matches
+        exact_common = words1 & words2
+        
+        # Fuzzy matches for partial similarity
+        fuzzy_common = []
+        for word1 in words1:
+            if len(word1) > 3:  # Only check longer words
+                for word2 in words2:
+                    if len(word2) > 3 and word1 != word2:
+                        # Check if words share significant substring (fuzzy matching)
+                        if self._words_similar(word1, word2):
+                            fuzzy_common.append(f"{word1}~{word2}")
+        
+        # Combine exact and fuzzy matches
+        all_matches = list(exact_common) + fuzzy_common
+        meaningful = [word for word in all_matches if len(word.split('~')[0]) > 2]
+        return meaningful[:8]  # Increased to show more matches
+    
+    def _words_similar(self, word1: str, word2: str) -> bool:
+        """Check if two words are similar enough to be considered related."""
+        # Handle common variations
+        variations = {
+            'elastic': ['elasticsearch', 'elk'],
+            'payment': ['payments', 'pay', 'billing'],
+            'database': ['db', 'postgres', 'mysql', 'mongo'],
+            'timeout': ['timeouts', 'timed-out', 'timing-out'],
+            'service': ['services', 'svc', 'api', 'app'],
+            'error': ['errors', 'err', 'failure', 'failed', 'failing'],
+            'down': ['outage', 'offline', 'unavailable']
+        }
+        
+        # Check if words are variations of each other
+        for base, variants in variations.items():
+            if (word1 == base and word2 in variants) or (word2 == base and word1 in variants):
+                return True
+            if word1 in variants and word2 in variants:
+                return True
+        
+        # Check substring similarity (at least 70% overlap for longer words)
+        if len(word1) >= 5 and len(word2) >= 5:
+            shorter = min(word1, word2, key=len)
+            longer = max(word1, word2, key=len)
+            if shorter in longer and len(shorter) / len(longer) >= 0.7:
+                return True
+        
+        # Check if one word starts with the other (for prefixed services)
+        if len(word1) >= 4 and len(word2) >= 4:
+            if word1.startswith(word2) or word2.startswith(word1):
+                return True
+                
+        return False
+    
+    def _calculate_partial_similarity_bonus(self, text1: str, text2: str) -> float:
+        """Calculate bonus for partial/fuzzy keyword matches."""
+        if not text1 or not text2:
+            return 0.0
+            
         words1 = set(text1.split())
         words2 = set(text2.split())
-        common = words1 & words2
         
-        # Filter out very short words and return top matches
-        meaningful = [word for word in common if len(word) > 2]
-        return meaningful[:5]
+        fuzzy_matches = 0
+        
+        # Count meaningful words that could be compared
+        meaningful_words1 = [w for w in words1 if len(w) > 3]
+        meaningful_words2 = [w for w in words2 if len(w) > 3]
+        
+        if not meaningful_words1 or not meaningful_words2:
+            return 0.0
+        
+        # Count fuzzy matches
+        for word1 in meaningful_words1:
+            for word2 in meaningful_words2:
+                if word1 != word2 and self._words_similar(word1, word2):
+                    fuzzy_matches += 1
+                    break  # Only count each target word once
+        
+        # Calculate bonus based on fuzzy match ratio
+        if fuzzy_matches > 0:
+            # Use the smaller meaningful word set as denominator for conservative bonus
+            total_possible_matches = min(len(meaningful_words1), len(meaningful_words2))
+            bonus_ratio = fuzzy_matches / total_possible_matches
+            return min(0.15, bonus_ratio * 0.3)  # Max 0.15 bonus for partial matches
+        
+        return 0.0
     
     def _calculate_resolution_time(self, incident: Dict) -> Optional[float]:
         """Calculate resolution time in hours if timestamps are available."""

{rootly_mcp_server-2.0.11.dist-info → rootly_mcp_server-2.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.0.11
+Version: 2.0.12
 Summary: A Model Context Protocol server for Rootly APIs using OpenAPI spec
 Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
 Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues

{rootly_mcp_server-2.0.11.dist-info → rootly_mcp_server-2.0.12.dist-info}/RECORD

@@ -1,12 +1,12 @@
-rootly_mcp_server/__init__.py,sha256=6pLh19IFyqE-Cve9zergkD-X_yApEkInREKmRa73T6s,628
+rootly_mcp_server/__init__.py,sha256=rvIuqIyuzgC7b9qSnylrdDP2zPO-7Ou9AoblR6re1co,629
 rootly_mcp_server/__main__.py,sha256=_F4p65_VjnN84RtmEdESVLLH0tO5tL9qBfb2Xdvbj2E,6480
 rootly_mcp_server/client.py,sha256=uit-YijR7OAJtysBoclqnublEDVkFfcb29wSzhpBv44,4686
 rootly_mcp_server/server.py,sha256=5NyGWUOjz1C1kFbAbu2iMNfuKo53_Sq254vF0cEUSHE,41358
-rootly_mcp_server/smart_utils.py,sha256=B0to9o55PMwQPLFT6GZAg_S_Nt4pKFRQq0AXBL-GJp8,17442
+rootly_mcp_server/smart_utils.py,sha256=lvGN9ITyJjBkm7ejpYagd8VWodLKnC6FmwECfCOcGwM,22973
 rootly_mcp_server/utils.py,sha256=NyxdcDiFGlV2a8eBO4lKgZg0D7Gxr6xUIB0YyJGgpPA,4165
 rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
-rootly_mcp_server-2.0.11.dist-info/METADATA,sha256=fGFaM6E_5DJ1gdvFfuw1yyNBeJZMLdsDM56gRnDhy38,8722
-rootly_mcp_server-2.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rootly_mcp_server-2.0.11.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
-rootly_mcp_server-2.0.11.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
-rootly_mcp_server-2.0.11.dist-info/RECORD,,
+rootly_mcp_server-2.0.12.dist-info/METADATA,sha256=UJznyguav4QbdflENbArVS2rGL5f8KZKuA0RLDuN70M,8722
+rootly_mcp_server-2.0.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rootly_mcp_server-2.0.12.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
+rootly_mcp_server-2.0.12.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
+rootly_mcp_server-2.0.12.dist-info/RECORD,,