code2flow-toon 0.2.4__py3-none-any.whl

code2flow/nlp/entity_resolution.py

@@ -0,0 +1,326 @@
+"""Entity Resolution - Steps 3a-3e.
+
+3a. Entity types to extract (function, class, module, variable, file)
+3b. Name matching threshold
+3c. Context-aware disambiguation
+3d. Hierarchical resolution (class.method -> method)
+3e. Alias resolution (short names -> qualified names)
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Set, Tuple
+from difflib import SequenceMatcher
+
+from .config import EntityResolutionConfig
+
+
+@dataclass
+class Entity:
+    """Resolved entity."""
+    name: str
+    qualified_name: str
+    entity_type: str  # function, class, module, variable, file
+    confidence: float
+    source_file: Optional[str] = None
+    line_number: Optional[int] = None
+    context: Optional[str] = None
+    aliases: List[str] = field(default_factory=list)
+
+
+@dataclass
+class EntityResolutionResult:
+    """Result of entity resolution."""
+    query: str
+    entities: List[Entity] = field(default_factory=list)
+    primary_entity: Optional[Entity] = None
+    disambiguation_needed: bool = False
+    
+    def get_by_type(self, entity_type: str) -> List[Entity]:
+        """Get entities of specific type."""
+        return [e for e in self.entities if e.entity_type == entity_type]
+    
+    def get_best_match(self) -> Optional[Entity]:
+        """Get highest confidence entity."""
+        if not self.entities:
+            return None
+        return max(self.entities, key=lambda e: e.confidence)
+
+
+class EntityResolver:
+    """Resolve entities (functions, classes, etc.) from queries."""
+    
+    def __init__(
+        self,
+        config: Optional[EntityResolutionConfig] = None,
+        codebase_entities: Optional[Dict[str, List[Entity]]] = None
+    ):
+        self.config = config or EntityResolutionConfig()
+        # Initialize with empty dict, populate from codebase analysis
+        self.codebase_entities = codebase_entities or {}
+    
+    def resolve(
+        self,
+        query: str,
+        context: Optional[str] = None,
+        expected_types: Optional[List[str]] = None
+    ) -> EntityResolutionResult:
+        """Resolve entities from query (steps 3a-3e)."""
+        result = EntityResolutionResult(query=query)
+        
+        # Determine expected entity types
+        if expected_types is None:
+            expected_types = self.config.entity_types
+        
+        # 3a. Extract candidate entities by type
+        candidates = []
+        for entity_type in expected_types:
+            type_candidates = self._extract_candidates(query, entity_type)
+            candidates.extend(type_candidates)
+        
+        # 3b. Match with threshold
+        threshold = self.config.name_match_threshold
+        matches = [c for c in candidates if c.confidence >= threshold]
+        
+        # 3c. Context-aware disambiguation
+        if context and self.config.context_disambiguation:
+            matches = self._disambiguate(matches, context)
+        
+        # 3d. Hierarchical resolution
+        if self.config.hierarchical_resolution:
+            matches = self._resolve_hierarchical(matches)
+        
+        # 3e. Alias resolution
+        if self.config.alias_resolution:
+            matches = self._resolve_aliases(matches)
+        
+        result.entities = matches
+        
+        # Determine if disambiguation needed
+        if len(matches) > 1:
+            top_confidences = [m.confidence for m in matches[:2]]
+            if abs(top_confidences[0] - top_confidences[1]) < 0.1:
+                result.disambiguation_needed = True
+        
+        # Set primary entity
+        if matches:
+            result.primary_entity = matches[0]
+        
+        return result
+    
+    def _extract_candidates(self, query: str, entity_type: str) -> List[Entity]:
+        """3a. Extract candidate entities of given type from query."""
+        candidates = []
+        
+        # Get entities from codebase
+        type_entities = self.codebase_entities.get(entity_type, [])
+        
+        for entity in type_entities:
+            # Calculate name similarity
+            similarity = self._name_similarity(query, entity.name)
+            
+            if similarity > 0.5:  # Minimum threshold for candidacy
+                candidate = Entity(
+                    name=entity.name,
+                    qualified_name=entity.qualified_name,
+                    entity_type=entity_type,
+                    confidence=similarity,
+                    source_file=entity.source_file,
+                    line_number=entity.line_number,
+                )
+                candidates.append(candidate)
+        
+        # Also extract potential entities from query patterns
+        pattern_matches = self._extract_from_patterns(query, entity_type)
+        candidates.extend(pattern_matches)
+        
+        return candidates
+    
+    def _extract_from_patterns(self, query: str, entity_type: str) -> List[Entity]:
+        """Extract entities using regex patterns."""
+        candidates = []
+        
+        if entity_type == "function":
+            # Match patterns like: function_name(), call function_name, etc.
+            patterns = [
+                r'\b(\w+)\s*\(',  # function_name(
+                r'function\s+(\w+)',
+                r'call\s+(\w+)',
+                r'wywołaj\s+(\w+)',  # Polish
+            ]
+        elif entity_type == "class":
+            patterns = [
+                r'class\s+(\w+)',
+                r'klasa\s+(\w+)',
+                r'(\w+)\s*\.\s*\w+\s*\(',  # ClassName.method()
+            ]
+        elif entity_type == "file":
+            patterns = [
+                r'(\w+\.py)\b',
+                r'file\s+(\w+)',
+                r'plik\s+(\w+)',
+            ]
+        else:
+            patterns = [r'\b(\w+)\b']
+        
+        for pattern in patterns:
+            matches = re.finditer(pattern, query, re.IGNORECASE)
+            for match in matches:
+                name = match.group(1)
+                candidates.append(Entity(
+                    name=name,
+                    qualified_name=name,
+                    entity_type=entity_type,
+                    confidence=0.7,  # Pattern-based confidence
+                ))
+        
+        return candidates
+    
+    def _disambiguate(
+        self,
+        candidates: List[Entity],
+        context: str
+    ) -> List[Entity]:
+        """3c. Disambiguate entities using context."""
+        if not candidates:
+            return candidates
+        
+        context_lower = context.lower()
+        
+        # Boost confidence for entities mentioned in context
+        for candidate in candidates:
+            # Check if entity name or related terms appear in context
+            if candidate.name.lower() in context_lower:
+                candidate.confidence = min(1.0, candidate.confidence + 0.15)
+            
+            # Check if source file is mentioned in context
+            if candidate.source_file:
+                file_name = candidate.source_file.split('/')[-1].lower()
+                if file_name in context_lower:
+                    candidate.confidence = min(1.0, candidate.confidence + 0.1)
+        
+        # Re-sort by updated confidence
+        return sorted(candidates, key=lambda e: e.confidence, reverse=True)
+    
+    def _resolve_hierarchical(self, candidates: List[Entity]) -> List[Entity]:
+        """3d. Resolve hierarchical names (Class.method -> method)."""
+        resolved = []
+        
+        for candidate in candidates:
+            # Check if name contains hierarchy separator
+            if '.' in candidate.name:
+                parts = candidate.name.split('.')
+                
+                # Create resolved entity with short name
+                short_name = parts[-1]
+                resolved_entity = Entity(
+                    name=short_name,
+                    qualified_name=candidate.qualified_name,
+                    entity_type=candidate.entity_type,
+                    confidence=candidate.confidence,
+                    source_file=candidate.source_file,
+                    line_number=candidate.line_number,
+                    context=candidate.context,
+                    aliases=candidate.aliases + [candidate.name]
+                )
+                resolved.append(resolved_entity)
+                
+                # Also keep original
+                resolved.append(candidate)
+            else:
+                resolved.append(candidate)
+        
+        return resolved
+    
+    def _resolve_aliases(self, candidates: List[Entity]) -> List[Entity]:
+        """3e. Resolve aliases to canonical names."""
+        resolved = []
+        
+        for candidate in candidates:
+            # Check for known aliases
+            if candidate.aliases:
+                # Prefer qualified name as canonical
+                if len(candidate.qualified_name) > len(candidate.name):
+                    candidate.aliases.append(candidate.name)
+                    candidate.name = candidate.qualified_name
+            
+            resolved.append(candidate)
+        
+        return resolved
+    
+    def _name_similarity(self, query: str, name: str) -> float:
+        """Calculate similarity between query and entity name."""
+        # Direct match
+        if name.lower() in query.lower():
+            return 0.95
+        
+        if query.lower() in name.lower():
+            return 0.9
+        
+        # Fuzzy match
+        return SequenceMatcher(None, query.lower(), name.lower()).ratio()
+    
+    def load_from_analysis(self, analysis_result) -> None:
+        """Load entities from code analysis result."""
+        self.codebase_entities = {
+            "function": [],
+            "class": [],
+            "module": [],
+        }
+        
+        # Load functions
+        for func_name, func_info in analysis_result.functions.items():
+            entity = Entity(
+                name=func_info.name,
+                qualified_name=func_info.qualified_name,
+                entity_type="function",
+                confidence=1.0,
+                source_file=func_info.file,
+                line_number=func_info.line,
+            )
+            self.codebase_entities["function"].append(entity)
+        
+        # Load classes
+        for class_name, class_info in analysis_result.classes.items():
+            entity = Entity(
+                name=class_info.name,
+                qualified_name=class_info.qualified_name,
+                entity_type="class",
+                confidence=1.0,
+                source_file=class_info.file,
+                line_number=class_info.line,
+            )
+            self.codebase_entities["class"].append(entity)
+        
+        # Load modules
+        for mod_name, mod_info in analysis_result.modules.items():
+            entity = Entity(
+                name=mod_info.name,
+                qualified_name=mod_info.name,
+                entity_type="module",
+                confidence=1.0,
+                source_file=mod_info.file,
+            )
+            self.codebase_entities["module"].append(entity)
+    
+    # Individual step methods
+    def step_3a_extract_entities(self, query: str, entity_type: str) -> List[Entity]:
+        """Step 3a: Extract entities by type."""
+        return self._extract_candidates(query, entity_type)
+    
+    def step_3b_match_threshold(self, candidates: List[Entity]) -> List[Entity]:
+        """Step 3b: Apply name matching threshold."""
+        threshold = self.config.name_match_threshold
+        return [c for c in candidates if c.confidence >= threshold]
+    
+    def step_3c_disambiguate(self, candidates: List[Entity], context: str) -> List[Entity]:
+        """Step 3c: Context-aware disambiguation."""
+        return self._disambiguate(candidates, context)
+    
+    def step_3d_hierarchical_resolve(self, candidates: List[Entity]) -> List[Entity]:
+        """Step 3d: Resolve hierarchical names."""
+        return self._resolve_hierarchical(candidates)
+    
+    def step_3e_alias_resolve(self, candidates: List[Entity]) -> List[Entity]:
+        """Step 3e: Resolve aliases."""
+        return self._resolve_aliases(candidates)

code2flow/nlp/intent_matching.py

@@ -0,0 +1,297 @@
+"""Intent Matching - Steps 2a-2e.
+
+2a. Fuzzy matching threshold (0.0-1.0)
+2b. Semantic similarity threshold
+2c. Keyword matching weight
+2d. Context window size
+2e. Multi-intent resolution strategy
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+from difflib import SequenceMatcher
+
+from .config import IntentMatchingConfig
+
+
+@dataclass
+class IntentMatch:
+    """Single intent match result."""
+    intent: str
+    confidence: float
+    matched_phrase: str
+    match_type: str  # exact, fuzzy, keyword, semantic
+    context_score: float = 0.0
+
+
+@dataclass
+class IntentMatchingResult:
+    """Result of intent matching."""
+    query: str
+    primary_intent: Optional[IntentMatch] = None
+    all_matches: List[IntentMatch] = field(default_factory=list)
+    strategy_used: str = "best_match"
+    
+    def get_best_intent(self) -> Optional[str]:
+        """Get the best matching intent name."""
+        if self.primary_intent:
+            return self.primary_intent.intent
+        return None
+    
+    def get_confidence(self) -> float:
+        """Get confidence of best match."""
+        if self.primary_intent:
+            return self.primary_intent.confidence
+        return 0.0
+
+
+class IntentMatcher:
+    """Match queries to intents using fuzzy and keyword matching."""
+    
+    # Predefined intent patterns
+    DEFAULT_INTENTS = {
+        "find_function": [
+            "find function", "lookup function", "search function",
+            "znajdź funkcję", "szukaj funkcji", "gdzie jest funkcja"
+        ],
+        "find_class": [
+            "find class", "lookup class", "search class",
+            "znajdź klasę", "szukaj klasy", "gdzie jest klasa"
+        ],
+        "analyze_flow": [
+            "analyze flow", "show flow", "trace flow",
+            "analizuj przepływ", "pokaż przepływ", "śledź przepływ"
+        ],
+        "show_call_graph": [
+            "show call graph", "display call graph", "call graph",
+            "pokaż graf wywołań", "graf wywołań"
+        ],
+        "find_dependencies": [
+            "find dependencies", "show dependencies", "what depends on",
+            "znajdź zależności", "pokaż zależności"
+        ],
+        "explain_code": [
+            "explain code", "explain function", "what does",
+            "wyjaśnij kod", "wyjaśnij funkcję", "co robi"
+        ],
+    }
+    
+    def __init__(
+        self,
+        config: Optional[IntentMatchingConfig] = None,
+        intents: Optional[Dict[str, List[str]]] = None
+    ):
+        self.config = config or IntentMatchingConfig()
+        self.intents = intents or self.DEFAULT_INTENTS
+    
+    def match(
+        self,
+        query: str,
+        context: Optional[List[str]] = None
+    ) -> IntentMatchingResult:
+        """Match query to intents (steps 2a-2e)."""
+        result = IntentMatchingResult(query=query)
+        
+        # 2a. Fuzzy matching
+        fuzzy_matches = self._fuzzy_match(query)
+        
+        # 2c. Keyword matching
+        keyword_matches = self._keyword_match(query)
+        
+        # 2d. Context scoring
+        if context:
+            self._apply_context(query, fuzzy_matches + keyword_matches, context)
+        
+        # Combine and deduplicate
+        all_matches = self._combine_matches(fuzzy_matches + keyword_matches)
+        result.all_matches = all_matches
+        
+        # 2e. Multi-intent resolution
+        result.primary_intent = self._resolve_multi_intent(all_matches)
+        result.strategy_used = self.config.multi_intent_strategy
+        
+        return result
+    
+    def _fuzzy_match(self, query: str) -> List[IntentMatch]:
+        """2a. Fuzzy matching with configurable threshold."""
+        matches = []
+        threshold = self.config.fuzzy_threshold
+        
+        for intent, phrases in self.intents.items():
+            for phrase in phrases:
+                similarity = self._calculate_similarity(query, phrase)
+                if similarity >= threshold:
+                    matches.append(IntentMatch(
+                        intent=intent,
+                        confidence=similarity,
+                        matched_phrase=phrase,
+                        match_type="fuzzy"
+                    ))
+        
+        return matches
+    
+    def _keyword_match(self, query: str) -> List[IntentMatch]:
+        """2c. Keyword matching with configurable weight."""
+        matches = []
+        query_words = set(query.lower().split())
+        
+        for intent, phrases in self.intents.items():
+            best_score = 0.0
+            best_phrase = ""
+            
+            for phrase in phrases:
+                phrase_words = set(phrase.lower().split())
+                
+                # Calculate Jaccard similarity
+                intersection = len(query_words & phrase_words)
+                union = len(query_words | phrase_words)
+                
+                if union > 0:
+                    score = intersection / union
+                    if score > best_score:
+                        best_score = score
+                        best_phrase = phrase
+            
+            # Apply keyword weight
+            weighted_score = best_score * self.config.keyword_weight
+            
+            if weighted_score > 0:
+                matches.append(IntentMatch(
+                    intent=intent,
+                    confidence=weighted_score,
+                    matched_phrase=best_phrase,
+                    match_type="keyword"
+                ))
+        
+        return matches
+    
+    def _apply_context(
+        self,
+        query: str,
+        matches: List[IntentMatch],
+        context: List[str]
+    ) -> None:
+        """2d. Apply context window scoring."""
+        window_size = self.config.context_window
+        context_text = ' '.join(context[-window_size:]).lower()
+        
+        for match in matches:
+            # Boost confidence if intent keywords appear in context
+            intent_phrases = self.intents.get(match.intent, [])
+            context_score = 0.0
+            
+            for phrase in intent_phrases:
+                phrase_words = phrase.lower().split()
+                for word in phrase_words:
+                    if word in context_text:
+                        context_score += 0.1
+            
+            match.context_score = min(context_score, 0.5)  # Cap at 0.5
+            match.confidence = min(1.0, match.confidence + match.context_score)
+    
+    def _combine_matches(self, matches: List[IntentMatch]) -> List[IntentMatch]:
+        """Combine and deduplicate matches, keeping highest confidence per intent."""
+        best_by_intent: Dict[str, IntentMatch] = {}
+        
+        for match in matches:
+            if match.intent not in best_by_intent:
+                best_by_intent[match.intent] = match
+            elif match.confidence > best_by_intent[match.intent].confidence:
+                best_by_intent[match.intent] = match
+        
+        # Sort by confidence descending
+        return sorted(best_by_intent.values(), key=lambda m: m.confidence, reverse=True)
+    
+    def _resolve_multi_intent(self, matches: List[IntentMatch]) -> Optional[IntentMatch]:
+        """2e. Multi-intent resolution strategy."""
+        if not matches:
+            return None
+        
+        strategy = self.config.multi_intent_strategy
+        
+        if strategy == "best_match":
+            return matches[0]
+        
+        elif strategy == "combine":
+            # Combine top matches if close in confidence
+            if len(matches) >= 2:
+                gap = matches[0].confidence - matches[1].confidence
+                if gap < 0.1:  # Within 0.1 confidence
+                    # Return combined intent
+                    combined = IntentMatch(
+                        intent=f"{matches[0].intent}+{matches[1].intent}",
+                        confidence=(matches[0].confidence + matches[1].confidence) / 2,
+                        matched_phrase=f"{matches[0].matched_phrase} | {matches[1].matched_phrase}",
+                        match_type="combined"
+                    )
+                    return combined
+            return matches[0]
+        
+        elif strategy == "sequential":
+            # Return list of intents to process sequentially
+            return matches[0]  # For now, just return best
+        
+        return matches[0]
+    
+    def _calculate_similarity(self, a: str, b: str) -> float:
+        """Calculate string similarity using configured algorithm."""
+        algorithm = self.config.fuzzy_algorithm
+        
+        if algorithm == "ratio":
+            return SequenceMatcher(None, a.lower(), b.lower()).ratio()
+        
+        elif algorithm == "partial_ratio":
+            # Check if one is substring of other
+            a_lower = a.lower()
+            b_lower = b.lower()
+            
+            if a_lower in b_lower or b_lower in a_lower:
+                return 0.9  # High score for partial match
+            
+            return SequenceMatcher(None, a_lower, b_lower).ratio()
+        
+        elif algorithm == "token_sort_ratio":
+            # Sort tokens and compare
+            a_sorted = ' '.join(sorted(a.lower().split()))
+            b_sorted = ' '.join(sorted(b.lower().split()))
+            return SequenceMatcher(None, a_sorted, b_sorted).ratio()
+        
+        return SequenceMatcher(None, a.lower(), b.lower()).ratio()
+    
+    # Individual step methods
+    def step_2a_fuzzy_match(self, query: str, phrase: str) -> float:
+        """Step 2a: Calculate fuzzy match score."""
+        return self._calculate_similarity(query, phrase)
+    
+    def step_2b_semantic_match(self, query: str, phrase: str) -> float:
+        """Step 2b: Semantic similarity (placeholder for embeddings)."""
+        # Placeholder - would use sentence embeddings in production
+        return self._calculate_similarity(query, phrase)
+    
+    def step_2c_keyword_match(self, query: str, phrase: str) -> float:
+        """Step 2c: Keyword matching score."""
+        query_words = set(query.lower().split())
+        phrase_words = set(phrase.lower().split())
+        
+        if not phrase_words:
+            return 0.0
+        
+        intersection = len(query_words & phrase_words)
+        return intersection / len(phrase_words)
+    
+    def step_2d_context_score(self, query: str, context: List[str]) -> float:
+        """Step 2d: Calculate context relevance score."""
+        window = ' '.join(context[-self.config.context_window:]).lower()
+        query_words = query.lower().split()
+        
+        score = 0.0
+        for word in query_words:
+            if word in window:
+                score += 0.1
+        
+        return min(score, 0.5)
+    
+    def step_2e_resolve_intents(self, matches: List[IntentMatch]) -> Optional[IntentMatch]:
+        """Step 2e: Resolve multiple intent matches."""
+        return self._resolve_multi_intent(matches)