gitflow-analytics 3.13.21__tar.gz → 3.13.23__tar.gz

{gitflow_analytics-3.13.21/src/gitflow_analytics.egg-info → gitflow_analytics-3.13.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitflow-analytics
-Version: 3.13.21
+Version: 3.13.23
 Summary: Analyze Git repositories for developer productivity insights
 Author-email: Bob Matyas <bobmatnyc@gmail.com>
 License: MIT

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/_version.py

@@ -1,4 +1,4 @@
 """Version information for gitflow-analytics."""
 
-__version__ = "3.13.21"
+__version__ = "3.13.23"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/config/loader.py

@@ -32,6 +32,7 @@ from .schema import (
     LLMClassificationConfig,
     MLCategorization,
     RepositoryConfig,
+    TicketDetectionConfig,
 )
 from .validator import ConfigValidator
 
@@ -730,6 +731,17 @@ class ConfigLoader(ConfigLoaderSectionsMixin):
             strip_suffixes=list(identity_raw.get("strip_suffixes", [])),
         )
 
+        # Build TicketDetectionConfig from optional analysis.ticket_detection sub-section.
+        _td_raw: dict[str, Any] = analysis_data.get("ticket_detection") or {}
+        _td_defaults = TicketDetectionConfig()
+        ticket_detection_config = TicketDetectionConfig(
+            commit_filter=_td_raw.get("commit_filter", _td_defaults.commit_filter),
+            target_branches=list(_td_raw.get("target_branches", _td_defaults.target_branches)),
+            position=_td_raw.get("position", _td_defaults.position),
+            patterns=dict(_td_raw.get("patterns", _td_defaults.patterns)),
+            exclude_patterns=list(_td_raw.get("exclude_patterns", _td_defaults.exclude_patterns)),
+        )
+
         return AnalysisConfig(
             story_point_patterns=analysis_data.get(
                 "story_point_patterns",
@@ -751,6 +763,7 @@ class ConfigLoader(ConfigLoaderSectionsMixin):
             default_ticket_platform=analysis_data.get("default_ticket_platform"),
             branch_mapping_rules=analysis_data.get("branch_mapping_rules", {}),
             ticket_platforms=analysis_data.get("ticket_platforms"),
+            ticket_detection=ticket_detection_config,
             auto_identity_analysis=identity_raw.get("auto_analysis", True),
             branch_patterns=analysis_data.get("branch_patterns"),
             branch_analysis=branch_analysis_config,

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/config/schema.py

@@ -338,6 +338,66 @@ class IdentityConfig:
     strip_suffixes: list[str] = field(default_factory=list)
 
 
+@dataclass
+class TicketDetectionConfig:
+    """Configurable ticket detection settings.
+
+    Controls which commits are scanned for ticket references, how pattern
+    matching is anchored, which patterns are used, and which matches to
+    exclude post-extraction.
+
+    YAML example::
+
+        analysis:
+          ticket_detection:
+            commit_filter: "squash_merges_only"
+            target_branches: ["develop", "main"]
+            position: "start"
+            patterns:
+              jira: "([A-Z]{2,10}-\\d+)"
+              github: "(?:closes|fixes|resolves)\\s+#(\\d+)"
+            exclude_patterns:
+              - "CVE-\\d+"
+              - "CWE-\\d+"
+              - "\\d{8,}"
+    """
+
+    # Which commits to scan.
+    # "all"               – every commit (current/default behaviour)
+    # "squash_merges_only"– only single-parent commits on target_branches
+    # "merge_commits"     – only commits with >1 parent
+    commit_filter: str = "all"
+
+    # Branches considered as "integration" branches for squash-merge detection.
+    target_branches: list[str] = field(default_factory=lambda: ["develop", "main", "master"])
+
+    # Where in the commit message to match ticket patterns.
+    # "anywhere" – search the whole message (current behaviour)
+    # "start"    – anchor patterns with ^ (match only at message start)
+    position: str = "anywhere"
+
+    # Regex patterns keyed by platform name.  These REPLACE the built-in
+    # defaults when non-empty; when empty the extractor falls back to its
+    # hard-coded patterns.
+    patterns: dict[str, str] = field(
+        default_factory=lambda: {
+            "jira": r"([A-Z]{2,10}-\d+)",
+            "github": r"(?:closes|fixes|resolves)\s+#(\d+)",
+        }
+    )
+
+    # Regex patterns whose matches should be removed after extraction.
+    # Any extracted ticket ID that fully matches one of these patterns is
+    # discarded (e.g. CVE numbers, date-like strings).
+    exclude_patterns: list[str] = field(
+        default_factory=lambda: [
+            r"CVE-\d+",
+            r"CWE-\d+",
+            r"\d{8,}",  # long digit strings (dates, IDs)
+        ]
+    )
+
+
 @dataclass
 class AnalysisConfig:
     """Analysis-specific configuration."""
@@ -353,6 +413,7 @@ class AnalysisConfig:
     default_ticket_platform: Optional[str] = None
     branch_mapping_rules: dict[str, list[str]] = field(default_factory=dict)
     ticket_platforms: Optional[list[str]] = None
+    ticket_detection: TicketDetectionConfig = field(default_factory=TicketDetectionConfig)
     auto_identity_analysis: bool = True  # Enable automatic identity analysis by default
     branch_patterns: Optional[list[str]] = (
         None  # Branch patterns to analyze (e.g., ["*"] for all branches)

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/core/analysis_components.py

@@ -13,12 +13,15 @@ receive fully-constructed objects and can substitute mocks or subclasses.
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from ..extractors.story_points import StoryPointExtractor
 from ..extractors.tickets import TicketExtractor
 from .branch_mapper import BranchToProjectMapper
 
+if TYPE_CHECKING:
+    from ..config.schema import TicketDetectionConfig
+
 # Import ML extractor with graceful fallback
 try:
     from ..extractors.ml_tickets import MLTicketExtractor
@@ -50,6 +53,7 @@ def build_ticket_extractor(
     ml_config: dict[str, Any] | None = None,
     llm_config: dict[str, Any] | None = None,
     cache_dir: Any | None = None,
+    ticket_detection_config: TicketDetectionConfig | None = None,
 ) -> TicketExtractor:
     """Create the appropriate TicketExtractor based on configuration.
 
@@ -64,6 +68,9 @@ def build_ticket_extractor(
                    is returned.
         llm_config: LLM classification configuration dict.
         cache_dir: Cache directory for ML prediction persistence.
+        ticket_detection_config: Optional :class:`~gitflow_analytics.config.schema.TicketDetectionConfig`
+                                 controlling commit filtering, position anchoring, custom
+                                 patterns, and exclude-pattern post-filtering.
 
     Returns:
         TicketExtractor (or MLTicketExtractor subclass) instance.
@@ -80,6 +87,7 @@ def build_ticket_extractor(
             cache_dir=cache_dir,
             enable_ml=True,
             enable_llm=enable_llm,
+            ticket_detection_config=ticket_detection_config,
         )
 
     # Log why ML is not used
@@ -94,7 +102,10 @@ def build_ticket_extractor(
     else:
         logger.debug("Using standard ticket extractor")
 
-    return TicketExtractor(allowed_platforms=allowed_platforms)
+    return TicketExtractor(
+        allowed_platforms=allowed_platforms,
+        ticket_detection_config=ticket_detection_config,
+    )
 
 
 def build_branch_mapper(

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/core/analyze_pipeline.py

@@ -15,11 +15,10 @@ from __future__ import annotations
 
 import contextlib
 import logging
-import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 
 logger = logging.getLogger(__name__)
 
@@ -97,7 +96,7 @@ class QualitativeResult:
     """Output of the qualitative-analysis stage."""
 
     results: list[Any]
-    cost_stats: Optional[dict[str, Any]]
+    cost_stats: dict[str, Any] | None
     commits_for_qual: list[dict[str, Any]]  # kept for JSON export
 
 
@@ -106,7 +105,7 @@ class ReportResult:
     """Output of the report-generation stage."""
 
     generated_reports: list[str]
-    dora_metrics: Optional[dict[str, Any]]
+    dora_metrics: dict[str, Any] | None
     pr_metrics: dict[str, Any]
 
 
@@ -228,7 +227,7 @@ def calculate_date_range(weeks: int) -> DateRangeResult:
 def discover_repositories(
     cfg: Any,
     config_path: Path,
-    progress_callback: Optional[Callable[[str, int], None]] = None,
+    progress_callback: Callable[[str, int], None] | None = None,
 ) -> list[Any]:
     """Discover repositories from a GitHub organisation if configured.
 
@@ -262,8 +261,8 @@ def fetch_repositories_batch(
     weeks: int,
     config_hash: str,
     force_fetch: bool,
-    progress_callback: Optional[Callable[[str], None]] = None,
-    repo_progress_callback: Optional[Callable[[str, str, dict[str, Any]], None]] = None,
+    progress_callback: Callable[[str], None] | None = None,
+    repo_progress_callback: Callable[[str, str, dict[str, Any]], None] | None = None,
 ) -> FetchResult:
     """Fetch raw git data for all repositories that need analysis.
 
@@ -281,6 +280,7 @@ def fetch_repositories_batch(
         ),
         exclude_paths=getattr(cfg.analysis, "exclude_paths", None),
         exclude_merge_commits=cfg.analysis.exclude_merge_commits,
+        ticket_detection_config=getattr(cfg.analysis, "ticket_detection", None),
     )
 
     orchestrator = IntegrationOrchestrator(cfg, cache)
@@ -335,7 +335,7 @@ def fetch_repositories_batch(
                     logger.warning("Repository not found: %s", repo_path)
                     continue
 
-            branch_patterns: Optional[list[str]] = None
+            branch_patterns: list[str] | None = None
             if hasattr(cfg.analysis, "branch_patterns"):
                 branch_patterns = cfg.analysis.branch_patterns
             elif cfg.github.organization:
@@ -538,9 +538,7 @@ def classify_commits_batch(
         fallback_enabled=True,
     )
 
-    project_keys = [
-        repo.project_key or repo.name for repo in repositories
-    ]
+    project_keys = [repo.project_key or repo.name for repo in repositories]
 
     result = batch_classifier.classify_date_range(
         start_date=start_date,
@@ -578,9 +576,7 @@ def load_commits_from_db(
                 and_(
                     CachedCommit.timestamp >= start_date,
                     CachedCommit.timestamp <= end_date,
-                    CachedCommit.repo_path.in_(
-                        [str(Path(repo.path)) for repo in repositories]
-                    ),
+                    CachedCommit.repo_path.in_([str(Path(repo.path)) for repo in repositories]),
                 )
             )
             .order_by(CachedCommit.timestamp.desc())
@@ -594,9 +590,7 @@ def load_commits_from_db(
                 repo_path = Path(cc.repo_path)
                 for repo_config in repositories:
                     if repo_config.path == repo_path:
-                        commit_dict["project_key"] = (
-                            repo_config.project_key or repo_config.name
-                        )
+                        commit_dict["project_key"] = repo_config.project_key or repo_config.name
                         break
                 else:
                     commit_dict["project_key"] = repo_path.name
@@ -623,9 +617,7 @@ def resolve_developer_identities(
 ) -> IdentityResult:
     """Update identity resolver with commit stats and compute developer stats."""
     identity_resolver.update_commit_stats(all_commits)
-    developer_ticket_coverage = ticket_extractor.calculate_developer_ticket_coverage(
-        all_commits
-    )
+    developer_ticket_coverage = ticket_extractor.calculate_developer_ticket_coverage(all_commits)
     developer_stats = identity_resolver.get_developer_stats(
         ticket_coverage=developer_ticket_coverage
     )
@@ -693,9 +685,7 @@ def analyze_tickets_and_store_metrics(
                 elif isinstance(commit_date, str):
                     from datetime import datetime as dt
 
-                    commit_date = dt.fromisoformat(
-                        commit_date.replace("Z", "+00:00")
-                    ).date()
+                    commit_date = dt.fromisoformat(commit_date.replace("Z", "+00:00")).date()
                 daily_commits.setdefault(commit_date, []).append(commit)
 
         total_records = 0
@@ -721,7 +711,6 @@ def analyze_tickets_and_store_metrics(
 # ---------------------------------------------------------------------------
 
 
-
 # Backward-compatible re-exports from reports sub-module
 from .analyze_pipeline_reports import (  # noqa: E402
     aggregate_pm_data,
@@ -730,12 +719,26 @@ from .analyze_pipeline_reports import (  # noqa: E402
 )
 
 __all__ = [
-    "load_and_validate_config", "check_github_auth", "calculate_date_range",
-    "discover_repositories", "fetch_repositories_batch", "validate_batch_state",
-    "classify_commits_batch", "load_commits_from_db", "resolve_developer_identities",
-    "analyze_tickets_and_store_metrics", "run_qualitative_analysis",
-    "aggregate_pm_data", "generate_all_reports",
-    "ConfigResult", "DateRangeResult", "FetchResult", "ClassificationResult",
-    "CommitLoadResult", "IdentityResult", "TicketResult",
-    "QualitativeResult", "ReportResult",
+    "load_and_validate_config",
+    "check_github_auth",
+    "calculate_date_range",
+    "discover_repositories",
+    "fetch_repositories_batch",
+    "validate_batch_state",
+    "classify_commits_batch",
+    "load_commits_from_db",
+    "resolve_developer_identities",
+    "analyze_tickets_and_store_metrics",
+    "run_qualitative_analysis",
+    "aggregate_pm_data",
+    "generate_all_reports",
+    "ConfigResult",
+    "DateRangeResult",
+    "FetchResult",
+    "ClassificationResult",
+    "CommitLoadResult",
+    "IdentityResult",
+    "TicketResult",
+    "QualitativeResult",
+    "ReportResult",
 ]

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/core/data_fetcher.py

@@ -6,42 +6,34 @@ without performing any LLM-based classification.
 """
 
 import logging
-import os
-import subprocess
 import threading
-import time
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
-import git
-from sqlalchemy import case, func
-from sqlalchemy.orm import Session
+from sqlalchemy import func
 
 from ..constants import BatchSizes, Timeouts
 from ..integrations.jira_integration import JIRAIntegration
 from ..models.database import (
-    CachedCommit,
-    CommitTicketCorrelation,
     DailyCommitBatch,
-    DetailedTicketData,
 )
-from ..types import CommitStats
-from ..utils.commit_utils import is_merge_commit
-from ..utils.glob_matcher import match_recursive_pattern as _match_recursive_pattern_fn
-from ..utils.glob_matcher import matches_glob_pattern as _matches_glob_pattern_fn
-from ..utils.glob_matcher import should_exclude_file as _should_exclude_file_fn
 from .analysis_components import (
     build_branch_mapper,
     build_story_point_extractor,
     build_ticket_extractor,
 )
 from .cache import GitAnalysisCache
-from .git_timeout_wrapper import GitOperationTimeout, GitTimeoutWrapper, HeartbeatLogger
+from .data_fetcher_git import GitFetcherMixin
+from .data_fetcher_parallel import ParallelFetcherMixin
+from .data_fetcher_processing import ProcessingMixin
+from .git_timeout_wrapper import GitTimeoutWrapper
 from .identity import DeveloperIdentityResolver
 from .progress import get_progress_service
 
+if TYPE_CHECKING:
+    from ..config.schema import TicketDetectionConfig
+
 logger = logging.getLogger(__name__)
 
 # THREAD SAFETY: Module-level thread-local storage for repository instances
@@ -50,11 +42,6 @@ logger = logging.getLogger(__name__)
 _thread_local = threading.local()
 
 
-from .data_fetcher_git import GitFetcherMixin
-from .data_fetcher_processing import ProcessingMixin
-from .data_fetcher_parallel import ParallelFetcherMixin
-
-
 class GitDataFetcher(GitFetcherMixin, ProcessingMixin, ParallelFetcherMixin):
     """Fetches raw Git commit data and organizes it by day for efficient batch processing.
 
@@ -74,6 +61,7 @@ class GitDataFetcher(GitFetcherMixin, ProcessingMixin, ParallelFetcherMixin):
         exclude_paths: Optional[list[str]] = None,
         skip_remote_fetch: bool = False,
         exclude_merge_commits: bool = False,
+        ticket_detection_config: Optional["TicketDetectionConfig"] = None,
     ) -> None:
         """Initialize the data fetcher.
 
@@ -84,6 +72,7 @@ class GitDataFetcher(GitFetcherMixin, ProcessingMixin, ParallelFetcherMixin):
             exclude_paths: List of file paths to exclude from analysis
             skip_remote_fetch: If True, skip git fetch/pull operations
             exclude_merge_commits: Exclude merge commits from filtered line count calculations
+            ticket_detection_config: Optional configurable ticket detection settings.
         """
         self.cache = cache
         self.skip_remote_fetch = skip_remote_fetch
@@ -92,7 +81,10 @@ class GitDataFetcher(GitFetcherMixin, ProcessingMixin, ParallelFetcherMixin):
         # CRITICAL FIX: Use the same database instance as the cache to avoid session conflicts
         self.database = cache.db
         self.story_point_extractor = build_story_point_extractor()
-        self.ticket_extractor = build_ticket_extractor(allowed_platforms=allowed_ticket_platforms)
+        self.ticket_extractor = build_ticket_extractor(
+            allowed_platforms=allowed_ticket_platforms,
+            ticket_detection_config=ticket_detection_config,
+        )
         self.branch_mapper = build_branch_mapper(branch_mapping_rules)
         self.exclude_paths = exclude_paths or []
 
@@ -485,4 +477,3 @@ class GitDataFetcher(GitFetcherMixin, ProcessingMixin, ParallelFetcherMixin):
             return 0
         finally:
             session.close()
-

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/extractors/ml_tickets.py

@@ -23,7 +23,6 @@ PERFORMANCE: Designed to handle large repositories efficiently with:
 
 import logging
 import time
-from collections import defaultdict
 from pathlib import Path
 from typing import Any, Optional
 
@@ -78,6 +77,7 @@ class MLTicketExtractor(MLTicketAnalysisMixin, TicketExtractor):
         cache_dir: Optional[Path] = None,
         enable_ml: bool = True,
         enable_llm: bool = False,
+        ticket_detection_config: Optional[Any] = None,
     ) -> None:
         """Initialize ML-enhanced ticket extractor.
 
@@ -89,9 +89,12 @@ class MLTicketExtractor(MLTicketAnalysisMixin, TicketExtractor):
             cache_dir: Directory for caching ML predictions
             enable_ml: Whether to enable ML features (fallback to rule-based if False)
             enable_llm: Whether to enable LLM classification (fallback to ML/rules if False)
+            ticket_detection_config: Optional TicketDetectionConfig passed through to
+                                    the base TicketExtractor for commit filtering,
+                                    position anchoring, and exclude-pattern filtering.
         """
-        # Initialize parent class
-        super().__init__(allowed_platforms, untracked_file_threshold)
+        # Initialize parent class (passes ticket_detection_config through)
+        super().__init__(allowed_platforms, untracked_file_threshold, ticket_detection_config)
 
         self.enable_ml = enable_ml and SPACY_AVAILABLE
         self.enable_llm = enable_llm
@@ -672,4 +675,3 @@ class MLTicketExtractor(MLTicketAnalysisMixin, TicketExtractor):
         }
 
         return mapping.get(ml_category, "other")
-

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/extractors/tickets.py

@@ -4,9 +4,15 @@ Core extraction and categorization live here.  Coverage analysis and untracked-
 commit pattern analysis live in tickets_analysis.py (TicketAnalysisMixin).
 """
 
+from __future__ import annotations
+
 import logging
 import re
-from typing import Any, Optional
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..config.schema import TicketDetectionConfig
 
 logger = logging.getLogger(__name__)
 
@@ -101,7 +107,10 @@ class TicketExtractor(TicketAnalysisMixin):
     """
 
     def __init__(
-        self, allowed_platforms: Optional[list[str]] = None, untracked_file_threshold: int = 1
+        self,
+        allowed_platforms: list[str] | None = None,
+        untracked_file_threshold: int = 1,
+        ticket_detection_config: TicketDetectionConfig | None = None,
     ) -> None:
         """Initialize with patterns for different platforms.
 
@@ -111,10 +120,46 @@ class TicketExtractor(TicketAnalysisMixin):
             untracked_file_threshold: Minimum number of files changed to consider
                                     a commit as 'significant' for untracked analysis.
                                     Default is 1 (all commits), previously was 3.
+            ticket_detection_config: Optional configurable detection settings.
+                                    When None the extractor uses backward-compatible
+                                    defaults (all commits, full-message scan, no excludes).
         """
         self.allowed_platforms = allowed_platforms
         self.untracked_file_threshold = untracked_file_threshold
-        self.patterns = {
+
+        # Store detection config (may be None – all code below handles that gracefully)
+        self._detection_config = ticket_detection_config
+
+        # Build commit_filter / target_branches / position from config or defaults
+        self._commit_filter: str = (
+            ticket_detection_config.commit_filter if ticket_detection_config else "all"
+        )
+        self._target_branches: list[str] = (
+            list(ticket_detection_config.target_branches)
+            if ticket_detection_config
+            else ["develop", "main", "master"]
+        )
+        self._position: str = (
+            ticket_detection_config.position if ticket_detection_config else "anywhere"
+        )
+
+        # Compile exclude patterns (post-extraction filter)
+        raw_excludes: list[str] = (
+            list(ticket_detection_config.exclude_patterns) if ticket_detection_config else []
+        )
+        self._compiled_excludes: list[re.Pattern[str]] = [re.compile(p) for p in raw_excludes]
+
+        # If config supplies custom per-platform patterns, use them; otherwise fall back
+        # to the built-in defaults.  The config patterns dict maps platform -> single
+        # pattern string; the built-in defaults use lists.
+        config_patterns: dict[str, str] = (
+            dict(ticket_detection_config.patterns)
+            if ticket_detection_config and ticket_detection_config.patterns
+            else {}
+        )
+
+        # Built-in defaults (always present as fallback)
+        default_patterns: dict[str, list[str]] = {
             "jira": [
                 r"([A-Z]{2,10}-\d+)",  # Standard JIRA format: PROJ-123
             ],
@@ -133,16 +178,26 @@ class TicketExtractor(TicketAnalysisMixin):
             ],
         }
 
+        # Merge: config patterns override defaults for their platform
+        self.patterns: dict[str, list[str]] = {}
+        for platform, patterns in default_patterns.items():
+            if platform in config_patterns:
+                # Config supplies a single pattern string; wrap in a list
+                self.patterns[platform] = [config_patterns[platform]]
+            else:
+                self.patterns[platform] = list(patterns)
+
         # Compile patterns only for allowed platforms
-        self.compiled_patterns = {}
+        self.compiled_patterns: dict[str, list[re.Pattern[str]]] = {}
         for platform, patterns in self.patterns.items():
             # Skip platforms not in allowed list
             if self.allowed_platforms and platform not in self.allowed_platforms:
                 continue
-            self.compiled_patterns[platform] = [
-                re.compile(pattern, re.IGNORECASE if platform != "jira" else 0)
-                for pattern in patterns
-            ]
+            compiled: list[re.Pattern[str]] = []
+            for pattern in patterns:
+                anchored = f"^{pattern}" if self._position == "start" else pattern
+                compiled.append(re.compile(anchored, re.IGNORECASE if platform != "jira" else 0))
+            self.compiled_patterns[platform] = compiled
 
         # Commit categorization patterns
         self.category_patterns = {
@@ -368,8 +423,72 @@ class TicketExtractor(TicketAnalysisMixin):
                 re.compile(pattern, re.IGNORECASE) for pattern in patterns
             ]
 
+    def should_skip_commit(self, commit: Any) -> bool:
+        """Decide whether a commit should be skipped during ticket extraction.
+
+        Uses the ``commit_filter`` setting from :class:`TicketDetectionConfig`.
+
+        * ``"all"`` – never skip (backward-compatible default).
+        * ``"squash_merges_only"`` – skip commits that are NOT squash merges.
+          Heuristic: a squash merge has exactly one parent AND is on a target
+          branch (or its branch metadata indicates so).
+        * ``"merge_commits"`` – skip commits that do NOT have >1 parent.
+
+        The *commit* argument is expected to be a dict with at least:
+        ``{"parents": [...], "branch": str}`` or a ``git.Commit`` object with
+        ``.parents`` and optionally a ``.branch`` attribute.  If the commit
+        object does not expose branch information the filter degrades gracefully.
+
+        Args:
+            commit: A dict or object representing a single commit.
+
+        Returns:
+            True when the commit should be skipped, False when it should be
+            processed normally.
+        """
+        if self._commit_filter == "all":
+            return False
+
+        # Normalise: support both dict and object access
+        if isinstance(commit, dict):
+            parents = commit.get("parents", [])
+            branch = commit.get("branch", "")
+        else:
+            parents = getattr(commit, "parents", [])
+            branch = getattr(commit, "branch", "")
+
+        parent_count = len(parents)
+
+        if self._commit_filter == "squash_merges_only":
+            # A squash merge is a single-parent commit on an integration branch.
+            on_target = any(
+                branch == tb or (branch or "").endswith(f"/{tb}") for tb in self._target_branches
+            )
+            is_squash = parent_count == 1 and on_target
+            return not is_squash
+
+        if self._commit_filter == "merge_commits":
+            return parent_count <= 1
+
+        # Unknown filter value – default to not skipping
+        return False
+
+    def _is_excluded(self, ticket_id: str) -> bool:
+        """Return True if *ticket_id* matches any configured exclude pattern.
+
+        Args:
+            ticket_id: The raw ticket identifier string (e.g. ``"CVE-2026-1234"``).
+
+        Returns:
+            True when the ticket should be discarded.
+        """
+        return any(pattern.fullmatch(ticket_id) for pattern in self._compiled_excludes)
+
     def extract_from_text(self, text: str) -> list[dict[str, str]]:
-        """Extract all ticket references from text."""
+        """Extract all ticket references from text.
+
+        Applies exclude-pattern filtering before returning results.
+        """
         if not text:
             return []
 
@@ -386,6 +505,11 @@ class TicketExtractor(TicketAnalysisMixin):
                     if platform == "jira" or platform == "linear":
                         ticket_id = ticket_id.upper()
 
+                    # Post-extraction exclude-pattern filter
+                    if self._is_excluded(ticket_id):
+                        logger.debug("Discarding ticket %r: matches an exclude pattern", ticket_id)
+                        continue
+
                     # Create unique key
                     key = f"{platform}:{ticket_id}"
                     if key not in seen:

{gitflow_analytics-3.13.21 → gitflow_analytics-3.13.23}/src/gitflow_analytics/pipeline_collect.py

@@ -67,6 +67,7 @@ def run_collect(
         ),
         exclude_paths=getattr(cfg.analysis, "exclude_paths", None),
         exclude_merge_commits=cfg.analysis.exclude_merge_commits,
+        ticket_detection_config=getattr(cfg.analysis, "ticket_detection", None),
     )
     orchestrator = IntegrationOrchestrator(cfg, cache)
     jira_integration = orchestrator.integrations.get("jira")