gitflow-analytics 1.0.3__py3-none-any.whl → 1.3.6__py3-none-any.whl

gitflow_analytics/qualitative/classifiers/intent_analyzer.py

@@ -1,24 +1,25 @@
 """Intent analyzer for extracting developer intent and urgency from commits."""
 
+import importlib.util
 import logging
 import re
-from typing import Dict, List, Any, Set
 from collections import defaultdict
+from typing import Any
 
 from ..models.schemas import IntentConfig
 
-try:
-    import spacy
+# Check if spacy is available without importing it
+SPACY_AVAILABLE = importlib.util.find_spec("spacy") is not None
+
+if SPACY_AVAILABLE:
     from spacy.tokens import Doc
-    SPACY_AVAILABLE = True
-except ImportError:
-    SPACY_AVAILABLE = False
+else:
     Doc = Any
 
 
 class IntentAnalyzer:
     """Analyze commit messages to extract developer intent and urgency signals.
-    
+
     This analyzer identifies:
     - Urgency level (critical, important, routine)
     - Intent confidence (how clear the intent is)
@@ -26,124 +27,236 @@ class IntentAnalyzer:
     - Planning signals (TODO, FIXME, temporary fixes)
     - Collaboration signals (pair programming, code review)
     """
-    
+
     def __init__(self, config: IntentConfig):
         """Initialize intent analyzer.
-        
+
         Args:
             config: Configuration for intent analysis
         """
         self.config = config
         self.logger = logging.getLogger(__name__)
-        
+
         # Urgency keyword patterns from config
         self.urgency_keywords = config.urgency_keywords
-        
+
         # Confidence indicators
         self.confidence_indicators = {
-            'high_confidence': {
-                'definitely', 'clearly', 'obviously', 'certainly', 'confirmed',
-                'verified', 'tested', 'working', 'complete', 'finished',
-                'implement', 'solution', 'resolve'
+            "high_confidence": {
+                "definitely",
+                "clearly",
+                "obviously",
+                "certainly",
+                "confirmed",
+                "verified",
+                "tested",
+                "working",
+                "complete",
+                "finished",
+                "implement",
+                "solution",
+                "resolve",
             },
-            'low_confidence': {
-                'maybe', 'perhaps', 'possibly', 'might', 'could', 'should',
-                'try', 'attempt', 'experiment', 'test', 'temporary', 'quick',
-                'hack', 'workaround', 'temp'
+            "low_confidence": {
+                "maybe",
+                "perhaps",
+                "possibly",
+                "might",
+                "could",
+                "should",
+                "try",
+                "attempt",
+                "experiment",
+                "test",
+                "temporary",
+                "quick",
+                "hack",
+                "workaround",
+                "temp",
+            },
+            "uncertain": {
+                "not sure",
+                "unclear",
+                "confusing",
+                "weird",
+                "strange",
+                "unexpected",
+                "unsure",
+                "investigation",
+                "debug",
+                "investigate",
             },
-            'uncertain': {
-                'not sure', 'unclear', 'confusing', 'weird', 'strange',
-                'unexpected', 'unsure', 'investigation', 'debug', 'investigate'
-            }
         }
-        
+
         # Emotional tone indicators
         self.tone_indicators = {
-            'frustrated': {
-                'annoying', 'frustrating', 'stupid', 'broken', 'terrible',
-                'awful', 'hate', 'annoyed', 'ugh', 'argh', 'damn', 'wtf'
+            "frustrated": {
+                "annoying",
+                "frustrating",
+                "stupid",
+                "broken",
+                "terrible",
+                "awful",
+                "hate",
+                "annoyed",
+                "ugh",
+                "argh",
+                "damn",
+                "wtf",
             },
-            'confident': {
-                'great', 'excellent', 'perfect', 'awesome', 'clean', 'elegant',
-                'nice', 'good', 'better', 'improved', 'optimized'
+            "confident": {
+                "great",
+                "excellent",
+                "perfect",
+                "awesome",
+                "clean",
+                "elegant",
+                "nice",
+                "good",
+                "better",
+                "improved",
+                "optimized",
+            },
+            "cautious": {
+                "careful",
+                "cautious",
+                "gentle",
+                "safe",
+                "conservative",
+                "minimal",
+                "small",
+                "incremental",
+                "gradual",
             },
-            'cautious': {
-                'careful', 'cautious', 'gentle', 'safe', 'conservative',
-                'minimal', 'small', 'incremental', 'gradual'
-            }
         }
-        
+
         # Planning and TODO indicators
         self.planning_indicators = {
-            'todo': {
-                'todo', 'fixme', 'hack', 'temporary', 'temp', 'later',
-                'placeholder', 'stub', 'incomplete', 'wip'
+            "todo": {
+                "todo",
+                "fixme",
+                "hack",
+                "temporary",
+                "temp",
+                "later",
+                "placeholder",
+                "stub",
+                "incomplete",
+                "wip",
             },
-            'future_work': {
-                'future', 'later', 'eventually', 'someday', 'next',
-                'upcoming', 'planned', 'roadmap'
+            "future_work": {
+                "future",
+                "later",
+                "eventually",
+                "someday",
+                "next",
+                "upcoming",
+                "planned",
+                "roadmap",
+            },
+            "immediate": {
+                "now",
+                "immediate",
+                "urgent",
+                "asap",
+                "quickly",
+                "fast",
+                "emergency",
+                "critical",
+                "hotfix",
             },
-            'immediate': {
-                'now', 'immediate', 'urgent', 'asap', 'quickly', 'fast',
-                'emergency', 'critical', 'hotfix'
-            }
         }
-        
+
         # Collaboration indicators
         self.collaboration_indicators = {
-            'pair_programming': {
-                'pair', 'pairing', 'together', 'with', 'collaborative',
-                'co-authored', 'mob', 'mobbing'
+            "pair_programming": {
+                "pair",
+                "pairing",
+                "together",
+                "with",
+                "collaborative",
+                "co-authored",
+                "mob",
+                "mobbing",
             },
-            'code_review': {
-                'review', 'feedback', 'suggestion', 'requested', 'comment',
-                'pr', 'pull request', 'merge request'
+            "code_review": {
+                "review",
+                "feedback",
+                "suggestion",
+                "requested",
+                "comment",
+                "pr",
+                "pull request",
+                "merge request",
+            },
+            "help_seeking": {
+                "help",
+                "assistance",
+                "advice",
+                "guidance",
+                "input",
+                "thoughts",
+                "opinions",
+                "feedback",
             },
-            'help_seeking': {
-                'help', 'assistance', 'advice', 'guidance', 'input',
-                'thoughts', 'opinions', 'feedback'
-            }
         }
-        
+
         # Technical complexity indicators
         self.complexity_indicators = {
-            'simple': {
-                'simple', 'easy', 'quick', 'minor', 'small', 'tiny',
-                'straightforward', 'basic'
+            "simple": {
+                "simple",
+                "easy",
+                "quick",
+                "minor",
+                "small",
+                "tiny",
+                "straightforward",
+                "basic",
             },
-            'complex': {
-                'complex', 'complicated', 'difficult', 'challenging',
-                'major', 'significant', 'substantial', 'extensive'
+            "complex": {
+                "complex",
+                "complicated",
+                "difficult",
+                "challenging",
+                "major",
+                "significant",
+                "substantial",
+                "extensive",
+            },
+            "refactoring": {
+                "refactor",
+                "restructure",
+                "reorganize",
+                "cleanup",
+                "simplify",
+                "optimize",
+                "improve",
             },
-            'refactoring': {
-                'refactor', 'restructure', 'reorganize', 'cleanup',
-                'simplify', 'optimize', 'improve'
-            }
         }
-        
-    def analyze(self, message: str, doc: Doc) -> Dict[str, Any]:
+
+    def analyze(self, message: str, doc: Doc) -> dict[str, Any]:
         """Analyze commit message for intent signals.
-        
+
         Args:
             message: Commit message
             doc: spaCy processed document (may be None)
-            
+
         Returns:
             Dictionary with intent analysis results
         """
         if not message:
             return {
-                'urgency': 'routine',
-                'confidence': 0.0,
-                'tone': 'neutral',
-                'planning_stage': 'implementation',
-                'collaboration_signals': [],
-                'complexity': 'moderate',
-                'signals': []
+                "urgency": "routine",
+                "confidence": 0.0,
+                "tone": "neutral",
+                "planning_stage": "implementation",
+                "collaboration_signals": [],
+                "complexity": "moderate",
+                "signals": [],
             }
-            
+
         message_lower = message.lower()
-        
+
         # Extract all signals
         urgency = self._analyze_urgency(message_lower)
         confidence_info = self._analyze_confidence(message_lower, doc)
@@ -151,105 +264,101 @@ class IntentAnalyzer:
         planning = self._analyze_planning_stage(message_lower)
         collaboration = self._analyze_collaboration(message_lower)
         complexity = self._analyze_complexity(message_lower)
-        
+
         # Collect all detected signals
         all_signals = []
-        all_signals.extend(urgency.get('signals', []))
-        all_signals.extend(confidence_info.get('signals', []))
-        all_signals.extend(tone.get('signals', []))
-        all_signals.extend(planning.get('signals', []))
-        all_signals.extend(collaboration.get('signals', []))
-        all_signals.extend(complexity.get('signals', []))
-        
+        all_signals.extend(urgency.get("signals", []))
+        all_signals.extend(confidence_info.get("signals", []))
+        all_signals.extend(tone.get("signals", []))
+        all_signals.extend(planning.get("signals", []))
+        all_signals.extend(collaboration.get("signals", []))
+        all_signals.extend(complexity.get("signals", []))
+
         return {
-            'urgency': urgency['level'],
-            'confidence': confidence_info['score'],
-            'tone': tone['dominant_tone'],
-            'planning_stage': planning['stage'],
-            'collaboration_signals': collaboration['types'],
-            'complexity': complexity['level'],
-            'signals': all_signals,
-            'detailed_analysis': {
-                'urgency_breakdown': urgency,
-                'confidence_breakdown': confidence_info,
-                'tone_breakdown': tone,
-                'planning_breakdown': planning,
-                'collaboration_breakdown': collaboration,
-                'complexity_breakdown': complexity
-            }
+            "urgency": urgency["level"],
+            "confidence": confidence_info["score"],
+            "tone": tone["dominant_tone"],
+            "planning_stage": planning["stage"],
+            "collaboration_signals": collaboration["types"],
+            "complexity": complexity["level"],
+            "signals": all_signals,
+            "detailed_analysis": {
+                "urgency_breakdown": urgency,
+                "confidence_breakdown": confidence_info,
+                "tone_breakdown": tone,
+                "planning_breakdown": planning,
+                "collaboration_breakdown": collaboration,
+                "complexity_breakdown": complexity,
+            },
         }
-        
-    def _analyze_urgency(self, message: str) -> Dict[str, Any]:
+
+    def _analyze_urgency(self, message: str) -> dict[str, Any]:
         """Analyze urgency level from message content.
-        
+
         Args:
             message: Lowercase commit message
-            
+
         Returns:
             Dictionary with urgency analysis
         """
         signals = []
         urgency_scores = defaultdict(float)
-        
+
         # Check configured urgency keywords
         for urgency_level, keywords in self.urgency_keywords.items():
             for keyword in keywords:
                 if keyword.lower() in message:
                     signals.append(f"urgency:{urgency_level}:{keyword}")
                     urgency_scores[urgency_level] += 1.0
-                    
+
         # Additional urgency patterns
         urgent_patterns = [
-            (r'\b(urgent|critical|emergency|asap|immediate)\b', 'critical', 2.0),
-            (r'\b(important|priority|needed|required)\b', 'important', 1.5),
-            (r'\b(hotfix|quickfix|patch)\b', 'critical', 2.0),
-            (r'\b(breaking|major)\b', 'important', 1.5),
-            (r'\b(minor|small|tiny)\b', 'routine', 0.5),
+            (r"\b(urgent|critical|emergency|asap|immediate)\b", "critical", 2.0),
+            (r"\b(important|priority|needed|required)\b", "important", 1.5),
+            (r"\b(hotfix|quickfix|patch)\b", "critical", 2.0),
+            (r"\b(breaking|major)\b", "important", 1.5),
+            (r"\b(minor|small|tiny)\b", "routine", 0.5),
         ]
-        
+
         for pattern, level, weight in urgent_patterns:
             if re.search(pattern, message):
                 signals.append(f"urgency_pattern:{level}:{pattern}")
                 urgency_scores[level] += weight
-                
+
         # Determine dominant urgency level
         if urgency_scores:
             dominant_urgency = max(urgency_scores.keys(), key=lambda k: urgency_scores[k])
         else:
-            dominant_urgency = 'routine'
-            
-        return {
-            'level': dominant_urgency,
-            'scores': dict(urgency_scores),
-            'signals': signals
-        }
-        
-    def _analyze_confidence(self, message: str, doc: Doc) -> Dict[str, Any]:
+            dominant_urgency = "routine"
+
+        return {"level": dominant_urgency, "scores": dict(urgency_scores), "signals": signals}
+
+    def _analyze_confidence(self, message: str, doc: Doc) -> dict[str, Any]:
         """Analyze confidence level in the commit.
-        
+
         Args:
             message: Lowercase commit message
             doc: spaCy processed document
-            
+
         Returns:
             Dictionary with confidence analysis
         """
         signals = []
         confidence_score = 0.5  # Start with neutral confidence
-        
+
         # Check confidence indicators
         for confidence_type, keywords in self.confidence_indicators.items():
             matches = sum(1 for keyword in keywords if keyword in message)
             if matches > 0:
                 signals.append(f"confidence:{confidence_type}:{matches}")
-                
-                if confidence_type == 'high_confidence':
+
+                if confidence_type == "high_confidence":
                     confidence_score += matches * 0.2
-                elif confidence_type == 'low_confidence':
+                elif confidence_type == "low_confidence":
                     confidence_score -= matches * 0.15
-                elif confidence_type == 'uncertain':
+                elif confidence_type == "uncertain":
                     confidence_score -= matches * 0.25
-                    
+
         # Check message structure and completeness
         if len(message.split()) >= 5:  # Detailed message
             confidence_score += 0.1
@@ -257,180 +366,170 @@ class IntentAnalyzer:
         elif len(message.split()) <= 2:  # Very brief message
             confidence_score -= 0.1
             signals.append("confidence:brief_message")
-            
+
         # Check for question marks (uncertainty)
-        if '?' in message:
+        if "?" in message:
             confidence_score -= 0.2
             signals.append("confidence:contains_question")
-            
+
         # Check for ellipsis or incomplete thoughts
-        if '...' in message or message.endswith('.'):
+        if "..." in message or message.endswith("."):
             confidence_score -= 0.1
             signals.append("confidence:incomplete_thought")
-            
+
         # Normalize confidence score
         confidence_score = max(0.0, min(1.0, confidence_score))
-        
+
         return {
-            'score': confidence_score,
-            'level': 'high' if confidence_score > 0.7 else 'medium' if confidence_score > 0.4 else 'low',
-            'signals': signals
+            "score": confidence_score,
+            "level": (
+                "high" if confidence_score > 0.7 else "medium" if confidence_score > 0.4 else "low"
+            ),
+            "signals": signals,
         }
-        
-    def _analyze_tone(self, message: str) -> Dict[str, Any]:
+
+    def _analyze_tone(self, message: str) -> dict[str, Any]:
         """Analyze emotional tone of the commit message.
-        
+
         Args:
             message: Lowercase commit message
-            
+
         Returns:
             Dictionary with tone analysis
         """
         signals = []
         tone_scores = defaultdict(float)
-        
+
         # Check tone indicators
         for tone_type, keywords in self.tone_indicators.items():
             matches = sum(1 for keyword in keywords if keyword in message)
             if matches > 0:
                 signals.append(f"tone:{tone_type}:{matches}")
                 tone_scores[tone_type] += matches
-                
+
         # Check punctuation for tone
-        if '!' in message:
-            tone_scores['confident'] += 0.5
+        if "!" in message:
+            tone_scores["confident"] += 0.5
             signals.append("tone:exclamation_mark")
-        elif '...' in message:
-            tone_scores['cautious'] += 0.5
+        elif "..." in message:
+            tone_scores["cautious"] += 0.5
             signals.append("tone:ellipsis")
-            
+
         # Determine dominant tone
         if tone_scores:
             dominant_tone = max(tone_scores.keys(), key=lambda k: tone_scores[k])
         else:
-            dominant_tone = 'neutral'
-            
-        return {
-            'dominant_tone': dominant_tone,
-            'scores': dict(tone_scores),
-            'signals': signals
-        }
-        
-    def _analyze_planning_stage(self, message: str) -> Dict[str, Any]:
+            dominant_tone = "neutral"
+
+        return {"dominant_tone": dominant_tone, "scores": dict(tone_scores), "signals": signals}
+
+    def _analyze_planning_stage(self, message: str) -> dict[str, Any]:
         """Analyze what stage of planning/development this commit represents.
-        
+
         Args:
             message: Lowercase commit message
-            
+
         Returns:
             Dictionary with planning stage analysis
         """
         signals = []
         stage_scores = defaultdict(float)
-        
+
         # Check planning indicators
         for stage_type, keywords in self.planning_indicators.items():
             matches = sum(1 for keyword in keywords if keyword in message)
             if matches > 0:
                 signals.append(f"planning:{stage_type}:{matches}")
                 stage_scores[stage_type] += matches
-                
+
         # Additional stage indicators
-        if any(word in message for word in ['start', 'initial', 'begin', 'setup']):
-            stage_scores['initial'] = stage_scores.get('initial', 0) + 1
+        if any(word in message for word in ["start", "initial", "begin", "setup"]):
+            stage_scores["initial"] = stage_scores.get("initial", 0) + 1
             signals.append("planning:initial_stage")
-            
-        if any(word in message for word in ['complete', 'finish', 'done', 'final']):
-            stage_scores['completion'] = stage_scores.get('completion', 0) + 1
+
+        if any(word in message for word in ["complete", "finish", "done", "final"]):
+            stage_scores["completion"] = stage_scores.get("completion", 0) + 1
             signals.append("planning:completion_stage")
-            
+
         # Determine stage
         if stage_scores:
-            if 'immediate' in stage_scores:
-                stage = 'immediate'
-            elif 'todo' in stage_scores:
-                stage = 'planning'
-            elif 'future_work' in stage_scores:
-                stage = 'future_planning'
-            elif 'completion' in stage_scores:
-                stage = 'completion'
-            elif 'initial' in stage_scores:
-                stage = 'initiation'
+            if "immediate" in stage_scores:
+                stage = "immediate"
+            elif "todo" in stage_scores:
+                stage = "planning"
+            elif "future_work" in stage_scores:
+                stage = "future_planning"
+            elif "completion" in stage_scores:
+                stage = "completion"
+            elif "initial" in stage_scores:
+                stage = "initiation"
             else:
-                stage = 'implementation'
+                stage = "implementation"
         else:
-            stage = 'implementation'
-            
-        return {
-            'stage': stage,
-            'scores': dict(stage_scores),
-            'signals': signals
-        }
-        
-    def _analyze_collaboration(self, message: str) -> Dict[str, Any]:
+            stage = "implementation"
+
+        return {"stage": stage, "scores": dict(stage_scores), "signals": signals}
+
+    def _analyze_collaboration(self, message: str) -> dict[str, Any]:
         """Analyze collaboration signals in the commit message.
-        
+
         Args:
             message: Lowercase commit message
-            
+
         Returns:
             Dictionary with collaboration analysis
         """
         signals = []
         collaboration_types = []
-        
+
         # Check collaboration indicators
         for collab_type, keywords in self.collaboration_indicators.items():
             matches = [keyword for keyword in keywords if keyword in message]
             if matches:
                 signals.extend([f"collaboration:{collab_type}:{match}" for match in matches])
                 collaboration_types.append(collab_type)
-                
+
         # Check for co-author patterns
-        if 'co-authored-by:' in message or 'with @' in message:
-            collaboration_types.append('co_authored')
+        if "co-authored-by:" in message or "with @" in message:
+            collaboration_types.append("co_authored")
             signals.append("collaboration:co_authored")
-            
+
         return {
-            'types': collaboration_types,
-            'signals': signals,
-            'is_collaborative': len(collaboration_types) > 0
+            "types": collaboration_types,
+            "signals": signals,
+            "is_collaborative": len(collaboration_types) > 0,
         }
-        
-    def _analyze_complexity(self, message: str) -> Dict[str, Any]:
+
+    def _analyze_complexity(self, message: str) -> dict[str, Any]:
         """Analyze technical complexity signals in the commit message.
-        
+
         Args:
             message: Lowercase commit message
-            
+
         Returns:
             Dictionary with complexity analysis
         """
         signals = []
         complexity_scores = defaultdict(float)
-        
+
         # Check complexity indicators
         for complexity_type, keywords in self.complexity_indicators.items():
             matches = sum(1 for keyword in keywords if keyword in message)
             if matches > 0:
                 signals.append(f"complexity:{complexity_type}:{matches}")
                 complexity_scores[complexity_type] += matches
-                
+
         # Determine complexity level
         if complexity_scores:
-            if complexity_scores.get('complex', 0) > complexity_scores.get('simple', 0):
-                level = 'complex'
-            elif complexity_scores.get('simple', 0) > 0:
-                level = 'simple'
-            elif complexity_scores.get('refactoring', 0) > 0:
-                level = 'moderate'  # Refactoring is usually moderate complexity
+            if complexity_scores.get("complex", 0) > complexity_scores.get("simple", 0):
+                level = "complex"
+            elif complexity_scores.get("simple", 0) > 0:
+                level = "simple"
+            elif complexity_scores.get("refactoring", 0) > 0:
+                level = "moderate"  # Refactoring is usually moderate complexity
             else:
-                level = 'moderate'
+                level = "moderate"
         else:
-            level = 'moderate'
-            
-        return {
-            'level': level,
-            'scores': dict(complexity_scores),
-            'signals': signals
-        }
+            level = "moderate"
+
+        return {"level": level, "scores": dict(complexity_scores), "signals": signals}