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

gitflow_analytics/extractors/tickets.py

@@ -6,6 +6,13 @@ from collections import defaultdict
 from datetime import timezone
 from typing import Any, Optional, cast
 
+try:
+    from tqdm import tqdm
+
+    TQDM_AVAILABLE = True
+except ImportError:
+    TQDM_AVAILABLE = False
+
 logger = logging.getLogger(__name__)
 
 
@@ -141,7 +148,7 @@ class TicketExtractor:
         # Commit categorization patterns
         self.category_patterns = {
             "bug_fix": [
-                r"^fix:",
+                r"^fix(\([^)]*\))?:",  # Conventional commits: fix: or fix(scope):
                 r"\b(fix|bug|error|issue|problem|crash|exception|failure)\b",
                 r"\b(resolve|solve|repair|correct|corrected|address)\b",
                 r"\b(hotfix|bugfix|patch|quickfix)\b",
@@ -152,9 +159,13 @@ class TicketExtractor:
                 r"\bmissing\s+(space|field|data|property)\b",
                 r"\b(counting|allowing|episodes)\s+(was|not|issue)\b",
                 r"^fixes\s+\b(beacon|beacons|combo|issue|problem)\b",
+                r"\bfixing\b(?!\s+test)",  # "fixing" but not "fixing tests"
+                r"\bfixed?\s+(issue|problem|bug|error)\b",
+                r"\bresolve[ds]?\s+(issue|problem|bug)\b",
+                r"\brepair\b",
             ],
             "feature": [
-                r"^(feat|feature):",
+                r"^(feat|feature)(\([^)]*\))?:",  # Conventional commits: feat: or feat(scope):
                 r"\b(add|new|feature|implement|create|build)\b",
                 r"\b(introduce|enhance|extend|expand)\b",
                 r"\b(functionality|capability|support|enable)\b",
@@ -170,6 +181,7 @@ class TicketExtractor:
                 r"\b(localization)\s+(data|structure)\b",
             ],
             "refactor": [
+                r"^refactor(\([^)]*\))?:",  # Conventional commits: refactor: or refactor(scope):
                 r"\b(refactor|restructure|reorganize|cleanup|clean up)\b",
                 r"\b(optimize|improve|simplify|streamline)\b",
                 r"\b(rename|move|extract|consolidate)\b",
@@ -179,6 +191,13 @@ class TicketExtractor:
                 r"improves?\s+(performance|efficiency|structure)\b",
                 r"improves?\s+(combo|box|focus|behavior)\b",
                 r"using\s+\w+\s+instead\s+of\s+\w+\b",  # "using X instead of Y" pattern
+                r"\brenaming\b",
+                r"\brenamed?\b",
+                r"\breduce\s+code\b",
+                r"\bsimplify\b",
+                r"\bsimplified\b",
+                r"\bboilerplate\b",
+                r"\bcode\s+cleanup\b",
             ],
             "documentation": [
                 r"\b(doc|docs|documentation|readme|comment|comments)\b",
@@ -186,6 +205,9 @@ class TicketExtractor:
                 r"\b(manual|guide|tutorial|how-to|howto)\b",
                 r"\b(explain|clarify|describe)\b",
                 r"\b(changelog|notes|examples)\b",
+                r"\bupdating\s+readme\b",
+                r"\bdoc\s+update\b",
+                r"\bdocumentation\s+fix\b",
             ],
             "deployment": [
                 r"^deploy:",
@@ -283,6 +305,7 @@ class TicketExtractor:
                 r"\b(prepare\s+for\s+release|pre-release)\b",
             ],
             "maintenance": [
+                r"^chore(\([^)]*\))?:",  # Conventional commits: chore: or chore(scope):
                 r"\b(update|upgrade|bump|maintenance|maint)\b",
                 r"\b(dependency|dependencies|package|packages)\b",
                 r"\b(npm\s+update|pip\s+install|yarn\s+upgrade)\b",
@@ -301,6 +324,11 @@ class TicketExtractor:
                 r"\b(mock|stub|fixture|factory)\b",
                 r"\b(e2e|end-to-end|acceptance|smoke)\b",
                 r"\b(coverage|assert|expect|should)\b",
+                r"\bfixing\s+tests?\b",
+                r"\btest.*broke\b",
+                r"\bupdate.*test\b",
+                r"\bbroke.*test\b",
+                r"\btest\s+fix\b",
             ],
             "style": [
                 r"^style:",
@@ -380,9 +408,20 @@ class TicketExtractor:
         return dict(by_platform)
 
     def analyze_ticket_coverage(
-        self, commits: list[dict[str, Any]], prs: list[dict[str, Any]]
+        self, commits: list[dict[str, Any]], prs: list[dict[str, Any]], progress_display=None
     ) -> dict[str, Any]:
-        """Analyze ticket reference coverage across commits and PRs."""
+        """Analyze ticket reference coverage across commits and PRs.
+
+        Args:
+            commits: List of commit dictionaries to analyze
+            prs: List of PR dictionaries to analyze
+            progress_display: Optional progress display for showing analysis progress
+
+        Note:
+            This method re-extracts tickets from commit messages rather than using cached
+            'ticket_references' to ensure the analysis respects the current allowed_platforms
+            configuration. Cached data may contain tickets from all platforms from previous runs.
+        """
         ticket_platforms: defaultdict[str, int] = defaultdict(int)
         untracked_commits: list[dict[str, Any]] = []
         ticket_summary: defaultdict[str, set[str]] = defaultdict(set)
@@ -400,20 +439,36 @@ class TicketExtractor:
         # Analyze commits
         commits_analyzed = 0
         commits_with_ticket_refs = 0
+        tickets_found = 0
+
+        # Set up progress tracking for commits
+        commit_iterator = commits
+        if progress_display and hasattr(progress_display, "console"):
+            # Rich progress display available
+            commit_iterator = commits  # Rich will handle its own progress
+        elif TQDM_AVAILABLE:
+            # Fall back to tqdm for simple progress tracking
+            commit_iterator = tqdm(
+                commits, desc="🎫 Analyzing commits for tickets", unit="commits", leave=False
+            )
 
-        for commit in commits:
+        for commit in commit_iterator:
             # Debug: check if commit is actually a dictionary
             if not isinstance(commit, dict):
                 logger.error(f"Expected commit to be dict, got {type(commit)}: {commit}")
                 continue
 
             commits_analyzed += 1
-            ticket_refs = commit.get("ticket_references", [])
+            # IMPORTANT: Re-extract tickets using current allowed_platforms instead of cached values
+            # This ensures the analysis respects the current configuration
+            commit_message = commit.get("message", "")
+            ticket_refs = self.extract_from_text(commit_message)
 
             # Debug logging for the first few commits
             if commits_analyzed <= 5:
                 logger.debug(
-                    f"Commit {commits_analyzed}: hash={commit.get('hash', 'N/A')[:8]}, ticket_refs={ticket_refs}"
+                    f"Commit {commits_analyzed}: hash={commit.get('hash', 'N/A')[:8]}, "
+                    f"re-extracted ticket_refs={ticket_refs} (allowed_platforms={self.allowed_platforms})"
                 )
 
             if ticket_refs:
@@ -432,6 +487,7 @@ class TicketExtractor:
                     platform_count = ticket_platforms[platform]
                     ticket_platforms[platform] = platform_count + 1
                     ticket_summary[platform].add(ticket_id)
+                    tickets_found += 1
             else:
                 # Track untracked commits with configurable threshold and enhanced data
                 files_changed = self._get_files_changed_count(commit)
@@ -462,8 +518,30 @@ class TicketExtractor:
 
                     untracked_commits.append(commit_data)
 
+            # Update progress if using tqdm
+            if TQDM_AVAILABLE and hasattr(commit_iterator, "set_postfix"):
+                commit_iterator.set_postfix(
+                    {
+                        "tickets": tickets_found,
+                        "with_tickets": commits_with_ticket_refs,
+                        "untracked": len(untracked_commits),
+                    }
+                )
+
         # Analyze PRs
-        for pr in prs:
+        pr_tickets_found = 0
+
+        # Set up progress tracking for PRs (only if there are PRs to analyze)
+        pr_iterator = prs
+        if (
+            prs
+            and TQDM_AVAILABLE
+            and not (progress_display and hasattr(progress_display, "console"))
+        ):
+            # Only show PR progress if there are PRs and we're not using Rich
+            pr_iterator = tqdm(prs, desc="🎫 Analyzing PRs for tickets", unit="PRs", leave=False)
+
+        for pr in pr_iterator:
             # Extract tickets from PR title and description
             pr_text = f"{pr.get('title', '')} {pr.get('description', '')}"
             tickets = self.extract_from_text(pr_text)
@@ -476,6 +554,13 @@ class TicketExtractor:
                     platform_count = ticket_platforms[platform]
                     ticket_platforms[platform] = platform_count + 1
                     ticket_summary[platform].add(ticket["id"])
+                    pr_tickets_found += 1
+
+            # Update PR progress if using tqdm
+            if TQDM_AVAILABLE and hasattr(pr_iterator, "set_postfix"):
+                pr_iterator.set_postfix(
+                    {"tickets": pr_tickets_found, "with_tickets": results["prs_with_tickets"]}
+                )
 
         # Calculate coverage percentages
         total_commits = cast(int, results["total_commits"])

gitflow_analytics/integrations/jira_integration.py

@@ -202,7 +202,7 @@ class JIRAIntegration:
                 try:
                     print(f"   🔍 Fetching {len(batch)} JIRA tickets from API...")
                     response = self._session.get(
-                        f"{self.base_url}/rest/api/3/search",
+                        f"{self.base_url}/rest/api/3/search/jql",
                         params={
                             "jql": jql,
                             "fields": "*all",  # Get all fields to find story points

gitflow_analytics/integrations/orchestrator.py

@@ -1,6 +1,7 @@
 """Integration orchestrator for multiple platforms."""
 
 import json
+import os
 from datetime import datetime
 from typing import Any, Union
 
@@ -15,7 +16,9 @@ class IntegrationOrchestrator:
 
     def __init__(self, config: Any, cache: GitAnalysisCache):
         """Initialize integration orchestrator."""
-        print("   🔍 IntegrationOrchestrator.__init__ called")
+        self.debug_mode = os.getenv("GITFLOW_DEBUG", "").lower() in ("1", "true", "yes")
+        if self.debug_mode:
+            print("   🔍 IntegrationOrchestrator.__init__ called")
         self.config = config
         self.cache = cache
         self.integrations: dict[str, Union[GitHubIntegration, JIRAIntegration]] = {}
@@ -59,7 +62,8 @@ class IntegrationOrchestrator:
             and config.pm_integration
             and config.pm_integration.enabled
         ):
-            print("   🔍 PM Integration detected - building configuration...")
+            if self.debug_mode:
+                print("   🔍 PM Integration detected - building configuration...")
             try:
                 # Create PM platform configuration for the orchestrator
                 pm_config = {
@@ -93,41 +97,48 @@ class IntegrationOrchestrator:
                         }
 
                         # Special handling for JIRA - use credentials from top-level JIRA config
-                        if platform_name == "jira" and hasattr(config, "jira"):
-                            platform_settings["username"] = config.jira.access_user
-                            platform_settings["api_token"] = config.jira.access_token
+                        if platform_name == "jira" and hasattr(config, "jira") and config.jira:
+                            # Safely access JIRA config attributes
+                            if hasattr(config.jira, "access_user") and config.jira.access_user:
+                                platform_settings["username"] = config.jira.access_user
+                            if hasattr(config.jira, "access_token") and config.jira.access_token:
+                                platform_settings["api_token"] = config.jira.access_token
                             # Also ensure base_url matches if not set
                             if (
                                 not platform_settings.get("base_url")
                                 or platform_settings["base_url"] == "will_be_set_at_runtime"
-                            ):
+                            ) and hasattr(config.jira, "base_url"):
                                 platform_settings["base_url"] = config.jira.base_url
                             # Add cache directory for ticket caching (config file directory)
                             if hasattr(config, "cache") and hasattr(config.cache, "directory"):
                                 platform_settings["cache_dir"] = config.cache.directory
                             # Debug output to check credentials
-                            print(
-                                f"   🔍 JIRA config: username={platform_settings['username']}, has_token={bool(platform_settings['api_token'])}, base_url={platform_settings['base_url']}, cache_dir={platform_settings.get('cache_dir', 'not_set')}"
-                            )
+                            if self.debug_mode:
+                                print(
+                                    f"   🔍 JIRA config: username={platform_settings['username']}, has_token={bool(platform_settings['api_token'])}, base_url={platform_settings['base_url']}, cache_dir={platform_settings.get('cache_dir', 'not_set')}"
+                                )
 
                         pm_config["pm_platforms"][platform_name] = platform_settings
 
                 # Debug output - show final PM config
-                print(
-                    f"   🔍 Final PM config platforms: {list(pm_config.get('pm_platforms', {}).keys())}"
-                )
-                for plat_name, plat_config in pm_config.get("pm_platforms", {}).items():
+                if self.debug_mode:
                     print(
-                        f"   🔍 {plat_name}: enabled={plat_config.get('enabled')}, has_username={bool(plat_config.get('username'))}, has_token={bool(plat_config.get('api_token'))}"
+                        f"   🔍 Final PM config platforms: {list(pm_config.get('pm_platforms', {}).keys())}"
                     )
+                    for plat_name, plat_config in pm_config.get("pm_platforms", {}).items():
+                        print(
+                            f"   🔍 {plat_name}: enabled={plat_config.get('enabled')}, has_username={bool(plat_config.get('username'))}, has_token={bool(plat_config.get('api_token'))}"
+                        )
 
                 self.pm_orchestrator = PMFrameworkOrchestrator(pm_config)
-                print(
-                    f"📋 PM Framework initialized with {len(self.pm_orchestrator.get_active_platforms())} platforms"
-                )
+                if self.debug_mode:
+                    print(
+                        f"📋 PM Framework initialized with {len(self.pm_orchestrator.get_active_platforms())} platforms"
+                    )
 
             except Exception as e:
-                print(f"⚠️  Failed to initialize PM framework: {e}")
+                if self.debug_mode:
+                    print(f"⚠️  Failed to initialize PM framework: {e}")
                 self.pm_orchestrator = None
 
     def enrich_repository_data(
@@ -154,8 +165,11 @@ class IntegrationOrchestrator:
                 except Exception as e:
                     import traceback
 
-                    print(f"   ⚠️  GitHub enrichment failed: {e}")
-                    print(f"   Debug traceback: {traceback.format_exc()}")
+                    if self.debug_mode:
+                        print(f"   ⚠️  GitHub enrichment failed: {e}")
+                        import traceback
+
+                        print(f"   Debug traceback: {traceback.format_exc()}")
 
         # JIRA enrichment for story points
         if "jira" in self.integrations:
@@ -170,12 +184,14 @@ class IntegrationOrchestrator:
                         jira_integration.enrich_prs_with_jira_data(enrichment["prs"])
 
                 except Exception as e:
-                    print(f"   ⚠️  JIRA enrichment failed: {e}")
+                    if self.debug_mode:
+                        print(f"   ⚠️  JIRA enrichment failed: {e}")
 
         # PM Framework enrichment
         if self.pm_orchestrator and self.pm_orchestrator.is_enabled():
             try:
-                print("   📋 Collecting PM platform data...")
+                if self.debug_mode:
+                    print("   📋 Collecting PM platform data...")
 
                 # Get all issues from PM platforms
                 pm_issues = self.pm_orchestrator.get_all_issues(since=since)
@@ -194,15 +210,17 @@ class IntegrationOrchestrator:
                 enrichment["pm_data"]["metrics"] = enhanced_metrics
 
                 # Only show correlations message if there are any correlations found
-                if correlations:
-                    print(
-                        f"   ✅ PM correlations found: {len(correlations)} commits linked to issues"
-                    )
-                else:
-                    print("   📋 PM data processed (no correlations found)")
+                if self.debug_mode:
+                    if correlations:
+                        print(
+                            f"   ✅ PM correlations found: {len(correlations)} commits linked to issues"
+                        )
+                    else:
+                        print("   📋 PM data processed (no correlations found)")
 
             except Exception as e:
-                print(f"   ⚠️  PM framework enrichment failed: {e}")
+                if self.debug_mode:
+                    print(f"   ⚠️  PM framework enrichment failed: {e}")
                 enrichment["pm_data"] = {"error": str(e)}
 
         return enrichment

gitflow_analytics/metrics/branch_health.py

@@ -186,8 +186,9 @@ class BranchHealthAnalyzer:
 
             # If branch tip is in main's history, it's merged
             branch_tip = branch.commit
-            main_commits = set(repo.iter_commits(main_branch))
-            return branch_tip in main_commits
+            # Use commit hashes instead of commit objects for hashability
+            main_commit_hashes = set(commit.hexsha for commit in repo.iter_commits(main_branch))
+            return branch_tip.hexsha in main_commit_hashes
 
         except Exception:
             return False

gitflow_analytics/models/database.py

@@ -52,6 +52,9 @@ class CachedCommit(Base):
     files_changed = Column(Integer)
     insertions = Column(Integer)
     deletions = Column(Integer)
+    # Filtered metrics (after exclusions applied)
+    filtered_insertions = Column(Integer, default=0)
+    filtered_deletions = Column(Integer, default=0)
     complexity_delta = Column(Float)
 
     # Extracted data
@@ -936,6 +939,8 @@ class Database:
             # Test the connection and create tables
             Base.metadata.create_all(self.engine)
             self.SessionLocal = sessionmaker(bind=self.engine)
+            # Apply migrations for existing databases
+            self._apply_migrations()
 
             # Test that we can actually write to the database
             self._test_database_write()
@@ -972,6 +977,8 @@ class Database:
 
             Base.metadata.create_all(self.engine)
             self.SessionLocal = sessionmaker(bind=self.engine)
+            # Apply migrations for existing databases
+            self._apply_migrations()
 
             # Test write capability
             self._test_database_write()
@@ -1005,6 +1012,8 @@ class Database:
 
             Base.metadata.create_all(self.engine)
             self.SessionLocal = sessionmaker(bind=self.engine)
+            # Apply migrations for existing databases
+            self._apply_migrations()
 
             self.is_readonly_fallback = True
 
@@ -1094,5 +1103,67 @@ class Database:
         return self.SessionLocal()
 
     def init_db(self) -> None:
-        """Initialize database tables."""
+        """Initialize database tables and apply migrations."""
         Base.metadata.create_all(self.engine)
+        self._apply_migrations()
+
+    def _apply_migrations(self) -> None:
+        """Apply database migrations for backward compatibility.
+
+        This method adds new columns to existing tables without losing data.
+        """
+        try:
+            with self.engine.connect() as conn:
+                # Check if filtered columns exist in cached_commits table
+                result = conn.execute(text("PRAGMA table_info(cached_commits)"))
+                columns = {row[1] for row in result}
+
+                # Add filtered_insertions column if it doesn't exist
+                if "filtered_insertions" not in columns:
+                    logger.info("Adding filtered_insertions column to cached_commits table")
+                    try:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE cached_commits ADD COLUMN filtered_insertions INTEGER DEFAULT 0"
+                            )
+                        )
+                        conn.commit()
+                    except Exception as e:
+                        logger.debug(f"Column may already exist or database is readonly: {e}")
+
+                # Add filtered_deletions column if it doesn't exist
+                if "filtered_deletions" not in columns:
+                    logger.info("Adding filtered_deletions column to cached_commits table")
+                    try:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE cached_commits ADD COLUMN filtered_deletions INTEGER DEFAULT 0"
+                            )
+                        )
+                        conn.commit()
+                    except Exception as e:
+                        logger.debug(f"Column may already exist or database is readonly: {e}")
+
+                # Initialize filtered columns with existing values for backward compatibility
+                if "filtered_insertions" not in columns or "filtered_deletions" not in columns:
+                    logger.info("Initializing filtered columns with existing values")
+                    try:
+                        conn.execute(
+                            text(
+                                """
+                            UPDATE cached_commits
+                            SET filtered_insertions = COALESCE(filtered_insertions, insertions),
+                                filtered_deletions = COALESCE(filtered_deletions, deletions)
+                            WHERE filtered_insertions IS NULL OR filtered_deletions IS NULL
+                        """
+                            )
+                        )
+                        conn.commit()
+                    except Exception as e:
+                        logger.debug(f"Could not initialize filtered columns: {e}")
+
+        except Exception as e:
+            # Don't fail if migrations can't be applied (e.g., in-memory database)
+            logger.debug(
+                f"Could not apply migrations (may be normal for new/memory databases): {e}"
+            )

gitflow_analytics/pm_framework/adapters/jira_adapter.py

@@ -545,7 +545,13 @@ class JIRAAdapter(BasePlatformAdapter):
                 - cache_dir: Directory for ticket cache (optional, defaults to current directory)
                 - cache_ttl_hours: Cache TTL in hours (optional, default: 168 = 7 days)
         """
-        print(f"   🔍 JIRA adapter __init__ called with config keys: {list(config.keys())}")
+        import os
+
+        # Check debug mode
+        debug_mode = os.getenv("GITFLOW_DEBUG", "").lower() in ("1", "true", "yes")
+        if debug_mode:
+            print(f"   🔍 JIRA adapter __init__ called with config keys: {list(config.keys())}")
+
         super().__init__(config)
 
         # Required configuration (use defaults for capability checking)
@@ -557,9 +563,10 @@ class JIRAAdapter(BasePlatformAdapter):
         logger.info(
             f"JIRA adapter init: base_url={self.base_url}, username={self.username}, has_token={bool(self.api_token and self.api_token != 'dummy-token')}"
         )
-        print(
-            f"   🔍 JIRA adapter received: username={self.username}, has_token={bool(self.api_token and self.api_token != 'dummy-token')}, base_url={self.base_url}"
-        )
+        if debug_mode:
+            print(
+                f"   🔍 JIRA adapter received: username={self.username}, has_token={bool(self.api_token and self.api_token != 'dummy-token')}, base_url={self.base_url}"
+            )
 
         # Optional configuration with defaults
         self.story_point_fields = config.get(
@@ -945,7 +952,7 @@ class JIRAAdapter(BasePlatformAdapter):
 
                 session = self._ensure_session()
                 response = session.get(
-                    f"{self.base_url}/rest/api/3/search",
+                    f"{self.base_url}/rest/api/3/search/jql",
                     params={
                         "jql": jql,
                         "startAt": start_at,

gitflow_analytics/pm_framework/orchestrator.py

@@ -80,12 +80,17 @@ class PMFrameworkOrchestrator:
         self.temporal_window_hours = correlation_config.get("temporal_window_hours", 72)
         self.confidence_threshold = correlation_config.get("confidence_threshold", 0.8)
 
+        import os
         import traceback
 
         logger.info("PM Framework Orchestrator initialized")
-        print("   🔍 PM Framework init stack trace:")
-        for line in traceback.format_stack()[-5:-1]:
-            print("   " + line.strip())
+
+        # Only show debug messages when GITFLOW_DEBUG is set
+        debug_mode = os.getenv("GITFLOW_DEBUG", "").lower() in ("1", "true", "yes")
+        if debug_mode:
+            print("   🔍 PM Framework init stack trace:")
+            for line in traceback.format_stack()[-5:-1]:
+                print("   " + line.strip())
 
         # Initialize configured platforms if PM integration is enabled
         if self.pm_integration_enabled:

gitflow_analytics/qualitative/classifiers/llm/openai_client.py

@@ -312,11 +312,31 @@ class OpenAIClassifier(BaseLLMClassifier):
             "temperature": self.config.temperature,
         }
 
-        # Make request
+        # Make request with proper timeout handling
         url = f"{self.config.api_base_url}/chat/completions"
-        response = requests.post(
-            url, headers=headers, json=payload, timeout=self.config.timeout_seconds
-        )
+
+        # Log request details for debugging
+        logger.debug(f"Making API request to {url} with model {self.config.model}")
+        logger.debug(f"Timeout set to {self.config.timeout_seconds} seconds")
+
+        try:
+            # Use a more conservative timeout and handle both connection and read timeouts
+            # connection timeout = 10s, read timeout = config timeout
+            response = requests.post(
+                url,
+                headers=headers,
+                json=payload,
+                timeout=(10.0, self.config.timeout_seconds),  # (connection, read) timeouts
+            )
+        except requests.exceptions.Timeout as e:
+            logger.error(f"API request timed out after {self.config.timeout_seconds}s: {e}")
+            raise Exception(f"API request timed out after {self.config.timeout_seconds} seconds")
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"Connection error during API request: {e}")
+            raise Exception(f"Connection error: Unable to reach API at {url}")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request failed: {e}")
+            raise Exception(f"Request failed: {str(e)}")
 
         # Check response
         if response.status_code != 200:

gitflow_analytics/qualitative/classifiers/llm_commit_classifier.py

@@ -45,7 +45,7 @@ class LLMConfig:
     confidence_threshold: float = 0.7  # Minimum confidence for LLM predictions
     max_tokens: int = 50  # Keep responses short
     temperature: float = 0.1  # Low temperature for consistent results
-    timeout_seconds: float = 30.0  # API timeout
+    timeout_seconds: float = 5.0  # API timeout - reduced to fail fast on unresponsive APIs
 
     # Caching configuration
     cache_duration_days: int = 90  # Long cache duration for cost optimization
@@ -54,6 +54,7 @@ class LLMConfig:
     # Cost optimization
     batch_size: int = 1  # Process one at a time for simplicity
     max_daily_requests: int = 1000  # Rate limiting
+    max_retries: int = 1  # Reduce retries to fail faster on unresponsive APIs
 
     # Domain-specific terms for organization
     domain_terms: dict[str, list[str]] = None
@@ -163,6 +164,7 @@ class LLMCommitClassifier:
             max_tokens=self.config.max_tokens,
             timeout_seconds=self.config.timeout_seconds,
             max_daily_requests=self.config.max_daily_requests,
+            max_retries=getattr(self.config, "max_retries", 2),  # Use config or default to 2
             use_openrouter=True,  # Default to OpenRouter
         )