github2gerrit 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

github2gerrit/duplicate_detection.py

@@ -10,16 +10,19 @@ submissions from automated tools like Dependabot.
 """
 
 import hashlib
+import json
 import logging
 import os
 import re
 import urllib.parse
 import urllib.request
+from collections.abc import Iterable
 from datetime import UTC
 from datetime import datetime
 from datetime import timedelta
 from pathlib import Path
 
+from .gerrit_urls import create_gerrit_url_builder
 from .github_api import GhPullRequest
 from .github_api import GhRepository
 from .github_api import build_client
@@ -57,9 +60,7 @@ class DuplicateChangeError(Exception):
 class ChangeFingerprint:
     """Represents a fingerprint of a change for duplicate detection."""
 
-    def __init__(
-        self, title: str, body: str = "", files_changed: list[str] | None = None
-    ):
+    def __init__(self, title: str, body: str = "", files_changed: list[str] | None = None):
         self.title = title.strip()
         self.body = (body or "").strip()
         self.files_changed = sorted(files_changed or [])
@@ -100,15 +101,10 @@ class ChangeFingerprint:
 
     def _compute_content_hash(self) -> str:
         """Compute a hash of the change content."""
-        content = (
-            f"{self._normalized_title}\n{self.body}\n"
-            f"{','.join(self.files_changed)}"
-        )
+        content = f"{self._normalized_title}\n{self.body}\n{','.join(self.files_changed)}"
         return hashlib.sha256(content.encode("utf-8")).hexdigest()[:16]
 
-    def is_similar_to(
-        self, other: "ChangeFingerprint", similarity_threshold: float = 0.8
-    ) -> bool:
+    def is_similar_to(self, other: "ChangeFingerprint", similarity_threshold: float = 0.8) -> bool:
         """Check if this fingerprint is similar to another."""
         # Exact normalized title match
         if self._normalized_title == other._normalized_title:
@@ -131,9 +127,7 @@ class ChangeFingerprint:
         # Check title similarity even without file changes
         return self._titles_similar(other, similarity_threshold)
 
-    def _titles_similar(
-        self, other: "ChangeFingerprint", threshold: float
-    ) -> bool:
+    def _titles_similar(self, other: "ChangeFingerprint", threshold: float) -> bool:
         """Check if titles are similar using simple string similarity."""
         title1 = self._normalized_title
         title2 = other._normalized_title
@@ -154,28 +148,29 @@ class ChangeFingerprint:
         return (intersection / union) >= threshold
 
     def __str__(self) -> str:
-        return (
-            f"ChangeFingerprint(title='{self.title[:50]}...', "
-            f"hash={self._content_hash})"
-        )
+        return f"ChangeFingerprint(title='{self.title[:50]}...', hash={self._content_hash})"
 
 
 class DuplicateDetector:
     """Detects duplicate Gerrit changes for GitHub pull requests."""
 
-    def __init__(self, repo: GhRepository, lookback_days: int = 7):
+    def __init__(
+        self,
+        repo: GhRepository,
+        lookback_days: int = 7,
+        duplicates_filter: str = "open",
+    ):
         self.repo = repo
         self.lookback_days = lookback_days
         self._cutoff_date = datetime.now(UTC) - timedelta(days=lookback_days)
+        self.duplicates_filter = duplicates_filter
 
     def _match_first_group(self, pattern: str, text: str) -> str:
         """Extract first regex group match from text."""
         match = re.search(pattern, text)
         return match.group(1) if match else ""
 
-    def _resolve_gerrit_info_from_env_or_gitreview(
-        self, gh: GitHubContext
-    ) -> tuple[str, str] | None:
+    def _resolve_gerrit_info_from_env_or_gitreview(self, gh: GitHubContext) -> tuple[str, str] | None:
         """Resolve Gerrit host and project from environment or .gitreview file.
 
         Returns:
@@ -198,6 +193,8 @@ class DuplicateDetector:
                 if host and proj:
                     project = proj.removesuffix(".git")
                     return (host.strip(), project.strip())
+                if host and not proj:
+                    return (host.strip(), "")
             except Exception as exc:
                 log.debug("Failed to read local .gitreview: %s", exc)
 
@@ -219,38 +216,28 @@ class DuplicateDetector:
                 if not branch:
                     continue
 
-                url = (
-                    f"https://raw.githubusercontent.com/"
-                    f"{repo_full}/refs/heads/{branch}/.gitreview"
-                )
+                url = f"https://raw.githubusercontent.com/{repo_full}/{branch}/.gitreview"
 
                 parsed = urllib.parse.urlparse(url)
-                if (
-                    parsed.scheme != "https"
-                    or parsed.netloc != "raw.githubusercontent.com"
-                ):
+                if parsed.scheme != "https" or parsed.netloc != "raw.githubusercontent.com":
                     continue
 
                 try:
                     log.debug("Fetching .gitreview from: %s", url)
-                    with urllib.request.urlopen(url, timeout=5) as resp:  # noqa: S310
+                    with urllib.request.urlopen(url, timeout=5) as resp:
                         text_remote = resp.read().decode("utf-8")
 
-                    host = self._match_first_group(
-                        r"(?m)^host=(.+)$", text_remote
-                    )
-                    proj = self._match_first_group(
-                        r"(?m)^project=(.+)$", text_remote
-                    )
+                    host = self._match_first_group(r"(?m)^host=(.+)$", text_remote)
+                    proj = self._match_first_group(r"(?m)^project=(.+)$", text_remote)
 
                     if host and proj:
                         project = proj.removesuffix(".git")
                         return (host.strip(), project.strip())
+                    if host and not proj:
+                        return (host.strip(), "")
 
                 except Exception as exc:
-                    log.debug(
-                        "Failed to fetch .gitreview from %s: %s", url, exc
-                    )
+                    log.debug("Failed to fetch .gitreview from %s: %s", url, exc)
                     continue
 
         except Exception as exc:
@@ -261,22 +248,14 @@ class DuplicateDetector:
     def _build_gerrit_rest_client(self, gerrit_host: str) -> object | None:
         """Build a Gerrit REST API client if pygerrit2 is available."""
         if GerritRestAPI is None:
-            log.debug(
-                "pygerrit2 not available, skipping Gerrit duplicate check"
-            )
+            log.debug("pygerrit2 not available, skipping Gerrit duplicate check")
             return None
 
-        base_path = os.getenv("GERRIT_HTTP_BASE_PATH", "").strip().strip("/")
-        base_url = (
-            f"https://{gerrit_host}/"
-            if not base_path
-            else f"https://{gerrit_host}/{base_path}/"
-        )
+        # Create centralized URL builder
+        url_builder = create_gerrit_url_builder(gerrit_host)
+        base_url = url_builder.api_url()
 
-        http_user = (
-            os.getenv("GERRIT_HTTP_USER", "").strip()
-            or os.getenv("GERRIT_SSH_USER_G2G", "").strip()
-        )
+        http_user = os.getenv("GERRIT_HTTP_USER", "").strip() or os.getenv("GERRIT_SSH_USER_G2G", "").strip()
         http_pass = os.getenv("GERRIT_HTTP_PASSWORD", "").strip()
 
         try:
@@ -295,18 +274,16 @@ class DuplicateDetector:
             log.debug("Failed to create Gerrit REST client: %s", exc)
             return None
 
-    def _build_gerrit_rest_client_with_r_path(
-        self, gerrit_host: str
-    ) -> object | None:
+    def _build_gerrit_rest_client_with_r_path(self, gerrit_host: str) -> object | None:
         """Build a Gerrit REST API client with /r/ base path for fallback."""
         if GerritRestAPI is None:
             return None
 
-        fallback_url = f"https://{gerrit_host}/r/"
-        http_user = (
-            os.getenv("GERRIT_HTTP_USER", "").strip()
-            or os.getenv("GERRIT_SSH_USER_G2G", "").strip()
-        )
+        # Create centralized URL builder with /r/ base path override
+        url_builder = create_gerrit_url_builder(gerrit_host, "r")
+        fallback_url = url_builder.api_url()
+
+        http_user = os.getenv("GERRIT_HTTP_USER", "").strip() or os.getenv("GERRIT_SSH_USER_G2G", "").strip()
         http_pass = os.getenv("GERRIT_HTTP_PASSWORD", "").strip()
 
         try:
@@ -321,114 +298,17 @@ class DuplicateDetector:
                 # Type ignore needed for dynamic import returning Any
                 return GerritRestAPI(url=fallback_url)  # type: ignore[no-any-return]
         except Exception as exc:
-            log.debug(
-                "Failed to create Gerrit REST client with /r/ path: %s", exc
-            )
+            log.debug("Failed to create Gerrit REST client with /r/ path: %s", exc)
             return None
 
     def check_gerrit_for_existing_change(self, gh: GitHubContext) -> bool:
-        """Check if a Gerrit change already exists for the given GitHub PR.
-
-        Args:
-            gh: GitHub context containing PR and repository information
+        """Deprecated: GitHub-Hash/Gerrit REST based duplicate detection disabled.
 
-        Returns:
-            True if a Gerrit change already exists for this PR, False otherwise
+        Always returns False. Scoring-based duplicate detection will be implemented
+        in check_for_duplicates.
         """
-        if not gh.pr_number:
-            return False
-
-        # Resolve Gerrit host and project
-        gerrit_info = self._resolve_gerrit_info_from_env_or_gitreview(gh)
-        if not gerrit_info:
-            log.debug(
-                "Cannot resolve Gerrit host/project, "
-                "skipping Gerrit duplicate check"
-            )
-            return False
-
-        gerrit_host, gerrit_project = gerrit_info
-
-        rest = self._build_gerrit_rest_client(gerrit_host)
-        if rest is None:
-            log.debug(
-                "Cannot check Gerrit for duplicates, REST client unavailable"
-            )
-            return False
-
-        # Generate the GitHub change hash for this PR
-        github_hash = DuplicateDetector._generate_github_change_hash(gh)
-
-        try:
-            # Search for changes that contain the GitHub hash in commit messages
-            # This is more reliable than comment-based searches
-            query = (
-                f'project:{gerrit_project} message:"GitHub-Hash: {github_hash}"'
-            )
-            path = f"/changes/?q={query}&n=10"
-
-            log.debug(
-                "Searching Gerrit for existing changes with GitHub hash %s, "
-                "query: %s",
-                github_hash,
-                query,
-            )
-            # Use getattr for dynamic method access to avoid type checking
-            changes = rest.get(path)  # type: ignore[attr-defined]
-
-            if changes:
-                log.info(
-                    "Found %d existing Gerrit change(s) for GitHub PR #%d: %s",
-                    len(changes),
-                    gh.pr_number,
-                    [f"{c.get('_number', '?')}" for c in changes],
-                )
-                return True
-            else:
-                log.debug(
-                    "No existing Gerrit changes found for GitHub PR #%d",
-                    gh.pr_number,
-                )
-                return False
-
-        except Exception as exc:
-            # Check if this is a 404 error and try /r/ fallback
-            status = getattr(
-                getattr(exc, "response", None), "status_code", None
-            )
-            if status == 404:
-                try:
-                    log.debug("Trying /r/ fallback for Gerrit API")
-                    fallback_rest = self._build_gerrit_rest_client_with_r_path(
-                        gerrit_host
-                    )
-                    if fallback_rest:
-                        changes = fallback_rest.get(path)  # type: ignore[attr-defined]
-                        if changes:
-                            log.info(
-                                "Found %d existing Gerrit change(s) for PR #%d "
-                                "via /r/ fallback: %s",
-                                len(changes),
-                                gh.pr_number,
-                                [f"{c.get('_number', '?')}" for c in changes],
-                            )
-                            return True
-                        else:
-                            log.debug(
-                                "No existing Gerrit changes found for PR #%d "
-                                "via /r/ fallback",
-                                gh.pr_number,
-                            )
-                            return False
-                except Exception as exc2:
-                    log.warning(
-                        "Failed to query Gerrit via /r/ fallback: %s", exc2
-                    )
-                    return False
-
-            log.warning("Failed to query Gerrit for existing changes: %s", exc)
-            # If we can't check Gerrit, err on the side of caution
-            return False
+        log.debug("Gerrit REST duplicate check disabled")
+        return False
 
     @staticmethod
     def _generate_github_change_hash(gh: GitHubContext) -> str:
@@ -454,9 +334,7 @@ class DuplicateDetector:
         hash_bytes = hashlib.sha256(hash_input.encode("utf-8")).digest()
         hash_hex = hash_bytes.hex()[:16]
 
-        log.debug(
-            "Generated GitHub change hash for %s: %s", hash_input, hash_hex
-        )
+        log.debug("Generated GitHub change hash for %s: %s", hash_input, hash_hex)
         return hash_hex
 
     def check_for_duplicates(
@@ -465,37 +343,341 @@ class DuplicateDetector:
         allow_duplicates: bool = False,
         gh: GitHubContext | None = None,
     ) -> None:
-        """Check if the target PR is a duplicate in Gerrit.
-
-        Args:
-            target_pr: The PR to check for duplicates
-            allow_duplicates: If True, only log warnings; if False, raise error
-            gh: GitHub context for Gerrit duplicate checking
+        """Check if the target PR is a duplicate via subject equality against Gerrit.
 
-        Raises:
-            DuplicateChangeError: If duplicates found and allow_duplicates=False
+        Implements a robust, dependency-free subject-first duplicate check:
+        - Resolve Gerrit host/project from env or .gitreview
+        - Query Gerrit changes updated within the lookback window (excluding abandoned)
+        - Compare normalized subjects (first line) for exact equality
+        - If any match, treat as duplicate and either warn or raise
         """
         pr_number = getattr(target_pr, "number", 0)
+        pr_title = (getattr(target_pr, "title", "") or "").strip()
 
-        log.debug("Checking PR #%d for Gerrit duplicates", pr_number)
+        log.debug(
+            "Checking PR #%d for duplicates via subject equality against Gerrit",
+            pr_number,
+        )
 
-        # Check if this PR already has a corresponding Gerrit change
-        if gh and self.check_gerrit_for_existing_change(gh):
-            full_message = (
-                f"PR #{pr_number} already has an existing Gerrit change. "
-                f"Skipping duplicate submission. "
-                f"Target PR title: '{getattr(target_pr, 'title', '')[:100]}'"
+        if not pr_title:
+            log.debug("PR #%d has empty title; skipping duplicate check", pr_number)
+            return
+        if gh is None:
+            log.debug("No GitHub context provided; skipping duplicate check")
+            return
+
+        # Resolve Gerrit target (host/project)
+        gerrit_info = self._resolve_gerrit_info_from_env_or_gitreview(gh)
+        if not gerrit_info:
+            log.debug("Unable to resolve Gerrit host/project; skipping duplicate check")
+            return
+        gerrit_host, gerrit_project = gerrit_info
+
+        # Helper: normalize subject like our existing title normalization
+        def _normalize_subject(title: str) -> str:
+            normalized = title.strip()
+            normalized = re.sub(
+                r"^(feat|fix|docs|style|refactor|test|chore|ci|build|perf)(\(.+?\))?: ",
+                "",
+                normalized,
+                flags=re.IGNORECASE,
             )
+            normalized = re.sub(r"[*_`]", "", normalized)
+            normalized = re.sub(r"\bv\d+(\.\d+)*(-\w+)?\b", "vx.y.z", normalized)
+            normalized = re.sub(r"\b\d+(\.\d+)+(-\w+)?\b", "x.y.z", normalized)
+            normalized = re.sub(r"\b\d+\.\d+\b", "x.y.z", normalized)
+            normalized = re.sub(r"\b[a-f0-9]{7,40}\b", "commit_hash", normalized)
+            normalized = re.sub(r"\s+", " ", normalized).strip()
+            return normalized.lower()
+
+        normalized_pr_subject = _normalize_subject(pr_title)
+        log.debug(
+            "Normalized PR subject for duplicate check: %s",
+            normalized_pr_subject,
+        )
 
-            if allow_duplicates:
-                log.warning(
-                    "GERRIT DUPLICATE DETECTED (allowed): %s", full_message
+        # Build Gerrit REST URL using centralized URL builder
+        url_builder = create_gerrit_url_builder(gerrit_host)
+        api_base = url_builder.api_url().rstrip("/")
+
+        # Track which base path actually works for constructing display URLs
+        successful_base_path = url_builder.base_path
+
+        # Build query: limit to recent changes, exclude abandoned; prefer open
+        cutoff_date = self._cutoff_date.date().isoformat()
+        q_parts = []
+        if gerrit_project:
+            q_parts.append(f"project:{gerrit_project}")
+        # Build status clause from DUPLICATES filter (default: open)
+        dup_filter = (self.duplicates_filter or "open").strip().lower()
+        selected = [s.strip() for s in dup_filter.split(",") if s.strip()]
+        valid = {
+            "open": "status:open",
+            "merged": "status:merged",
+            "abandoned": "status:abandoned",
+        }
+        status_terms = [valid[s] for s in selected if s in valid]
+        if not status_terms:
+            status_clause = "status:open"
+        elif len(status_terms) == 1:
+            status_clause = status_terms[0]
+        else:
+            status_clause = "(" + " OR ".join(status_terms) + ")"
+        q_parts.append(status_clause)
+        q_parts.append(f"after:{cutoff_date}")
+        query = " ".join(q_parts)
+        encoded_q = urllib.parse.quote(query, safe="")
+
+        # Request current commit metadata so we get 'subject'
+        # Use a modest page size
+        url = f"{api_base}/changes/?q={encoded_q}&n=50&o=CURRENT_COMMIT&o=CURRENT_FILES"
+
+        def _load_gerrit_json(url_: str) -> list[dict[str, object]]:
+            try:
+                log.debug("Querying Gerrit for duplicates: %s", url_)
+                # Ensure we only fetch over HTTPS to avoid unsafe schemes
+                parsed = urllib.parse.urlparse(url_)
+                if parsed.scheme != "https":
+                    log.debug("Skipping non-HTTPS URL for Gerrit query: %s", url_)
+                    return []
+                headers: dict[str, str] = {}
+                http_user = os.getenv("GERRIT_HTTP_USER", "").strip()
+                http_pass = os.getenv("GERRIT_HTTP_PASSWORD", "").strip()
+                if http_user and http_pass:
+                    import base64 as _b64  # localized import to avoid global import edit
+
+                    basic = _b64.b64encode(f"{http_user}:{http_pass}".encode()).decode("ascii")
+                    headers["Authorization"] = f"Basic {basic}"
+                req = urllib.request.Request(url_, headers=headers)
+                with urllib.request.urlopen(req, timeout=8) as resp:
+                    raw = resp.read().decode("utf-8", errors="replace")
+                # Strip Gerrit's XSSI prefix if present
+                if raw.startswith(")]}'"):
+                    raw = raw.split("\n", 1)[1] if "\n" in raw else ""
+                data = json.loads(raw or "[]")
+                if isinstance(data, list):
+                    return data
+                else:
+                    return []
+            except urllib.error.HTTPError as exc:
+                if exc.code == 404:
+                    # Try with /r/ base path fallback using centralized URL builder
+                    fallback_builder = create_gerrit_url_builder(gerrit_host, "r")
+                    fallback_api_base = fallback_builder.api_url().rstrip("/")
+                    fallback_url = url_.replace(api_base, fallback_api_base)
+                    if fallback_url != url_:
+                        log.debug(
+                            "Trying Gerrit query with /r/ base path: %s",
+                            fallback_url,
+                        )
+                        try:
+                            req_fallback = urllib.request.Request(fallback_url, headers=headers)
+                            with urllib.request.urlopen(req_fallback, timeout=8) as resp:
+                                raw = resp.read().decode("utf-8", errors="replace")
+                            # Strip Gerrit's XSSI prefix if present
+                            if raw.startswith(")]}'"):
+                                raw = raw.split("\n", 1)[1] if "\n" in raw else ""
+                            data = json.loads(raw or "[]")
+                            if isinstance(data, list):
+                                # Update successful base path for display URL construction
+                                nonlocal successful_base_path
+                                successful_base_path = "r"
+                                return data
+                            else:
+                                return []
+                        except Exception as fallback_exc:
+                            log.debug(
+                                "Gerrit fallback query also failed for %s: %s",
+                                fallback_url,
+                                fallback_exc,
+                            )
+                log.debug("Gerrit query failed for %s: %s", url_, exc)
+                return []
+            except Exception as exc:
+                log.debug("Gerrit query failed for %s: %s", url_, exc)
+                return []
+
+        log.debug(
+            "Gerrit duplicate query: host=%s project=%s filter=%s cutoff=%s url=%s",
+            gerrit_host,
+            gerrit_project or "(any)",
+            dup_filter,
+            cutoff_date,
+            url,
+        )
+        changes = _load_gerrit_json(url)
+        log.debug(
+            "Gerrit query returned %d change(s) for project=%s filter=%s after=%s",
+            len(changes),
+            gerrit_project or "(any)",
+            dup_filter,
+            cutoff_date,
+        )
+        if changes:
+            sample_subjects = ", ".join(str(c.get("subject") or "")[:60] for c in changes[:5])
+            log.debug("Sample subjects: %s", sample_subjects)
+
+        # Compare normalized subjects for exact equality
+        matched: list[tuple[int, str]] = []
+        for c in changes:
+            subj = str(c.get("subject") or "").strip()
+            if not subj:
+                continue
+            if _normalize_subject(subj) == normalized_pr_subject:
+                num = c.get("_number")
+                proj = str(c.get("project") or gerrit_project or "")
+                if isinstance(num, int):
+                    matched.append((num, proj))
+
+        if not matched:
+            # No exact subject match; proceed with similarity scoring across candidates
+            log.debug("No exact-subject matches found; entering similarity scoring")
+            from .similarity import ScoringConfig
+            from .similarity import aggregate_scores
+            from .similarity import remove_commit_trailers
+            from .similarity import score_bodies
+            from .similarity import score_files
+            from .similarity import score_subjects
+
+            config = ScoringConfig()
+            # Source features from the PR
+            src_subjects = [pr_title]
+            src_body = str(getattr(target_pr, "body", "") or "")
+            src_files: list[str] = []
+            try:
+                get_files = getattr(target_pr, "get_files", None)
+                if callable(get_files):
+                    files_obj = get_files()
+                    if isinstance(files_obj, Iterable):
+                        for f in files_obj:
+                            fname = getattr(f, "filename", None)
+                            if fname:
+                                src_files.append(str(fname))
+            except Exception as exc:
+                # Best-effort; if files cannot be retrieved, proceed without them
+                log.debug("Failed to retrieve PR files for scoring: %s", exc)
+
+            best_score = 0.0
+            best_reasons: list[str] = []
+            hits: list[tuple[float, str, int | None]] = []
+            all_nums: list[int] = []
+            for c in changes:
+                subj = str(c.get("subject") or "").strip()
+                if not subj:
+                    continue
+                # Extract commit message and files from revisions (CURRENT_COMMIT, CURRENT_FILES)
+                rev = str(c.get("current_revision") or "")
+                revs_obj = c.get("revisions")
+                revs = revs_obj if isinstance(revs_obj, dict) else {}
+                cur_obj = revs.get(rev)
+                cur = cur_obj if isinstance(cur_obj, dict) else {}
+                commit = cur.get("commit") or {}
+                msg = str(commit.get("message") or "")
+                cand_body_raw = ""
+                if "\n" in msg:
+                    cand_body_raw = msg.split("\n", 1)[1]
+                cand_body = remove_commit_trailers(cand_body_raw)
+                files_dict = cur.get("files") or {}
+                cand_files = [p for p in files_dict if isinstance(p, str) and not p.startswith("/")]
+
+                # Compute component scores
+                s_res = score_subjects(src_subjects, subj)
+                f_res = score_files(
+                    src_files,
+                    cand_files,
+                    workflow_min_floor=config.workflow_min_floor,
+                )
+                b_res = score_bodies(src_body, cand_body)
+
+                # Aggregate
+                agg = aggregate_scores(s_res.score, f_res.score, b_res.score, config=config)
+                log.debug(
+                    "Aggregate score computed: %.2f (s=%.2f f=%.2f b=%.2f)",
+                    agg,
+                    s_res.score,
+                    f_res.score,
+                    b_res.score,
                 )
-                return
+
+                # Build candidate reference and number using successful base path
+                num_obj = c.get("_number")
+                num = int(num_obj) if isinstance(num_obj, int) else None
+                proj = str(c.get("project") or gerrit_project or "")
+
+                # Use the base path that actually worked for API calls
+                display_url_builder = create_gerrit_url_builder(gerrit_host, successful_base_path)
+                ref = (
+                    display_url_builder.change_url(proj, num)
+                    if proj and isinstance(num, int)
+                    else (f"change {num}" if isinstance(num, int) else "")
+                )
+                log.debug(
+                    "Scoring candidate: ref=%s agg=%.2f (s=%.2f f=%.2f b=%.2f) subj='%s'",
+                    ref or "(none)",
+                    agg,
+                    s_res.score,
+                    f_res.score,
+                    b_res.score,
+                    subj[:200],
+                )
+
+                # Track best (for reasons)
+                if agg > best_score:
+                    best_score = agg
+                    # Deduplicate reasons preserving order
+                    best_reasons = list(dict.fromkeys(s_res.reasons + f_res.reasons + b_res.reasons))
+
+                # Collect all candidates above threshold
+                if agg >= config.similarity_threshold and ref:
+                    hits.append((agg, ref, num))
+                    if isinstance(num, int):
+                        all_nums.append(num)
+
+            log.debug(
+                "Similarity scoring found %d hit(s) (threshold=%.2f)",
+                len(hits),
+                config.similarity_threshold,
+            )
+            if hits:
+                hits_sorted = sorted(hits, key=lambda t: t[0], reverse=True)
+
+                # Log each matching change individually
+                for s, u, _ in hits_sorted:
+                    if u:
+                        log.info("Score: %.2f  URL: %s", s, u)
+                msg = f"Similar Gerrit change(s) detected [≥ {config.similarity_threshold:.2f}]"
+                if best_reasons:
+                    msg += f" (Reasons: {', '.join(best_reasons)})"
+                if allow_duplicates:
+                    log.warning("GERRIT DUPLICATE DETECTED (allowed): %s", msg)
+                    return
+                raise DuplicateChangeError(msg, all_nums)
+
+        # Construct human-friendly references for logs
+        matching_numbers: list[int] = []
+        match_lines: list[str] = []
+        for n, proj in matched:
+            if proj:
+                # Use the base path that actually worked for API calls
+                display_url_builder = create_gerrit_url_builder(gerrit_host, successful_base_path)
+                url = display_url_builder.change_url(proj, n)
+                match_lines.append(f"Score: 1.0  URL: {url}")
+                log.info("Score: 1.0  URL: %s", url)
             else:
-                raise DuplicateChangeError(full_message, [])
+                match_lines.append(f"Score: 1.0  URL: change {n}")
+                log.info("Score: 1.0  URL: change %s", n)
+            matching_numbers.append(n)
 
-        log.debug("No existing Gerrit change found for PR #%d", pr_number)
+        if not matched:
+            log.debug("No exact subject matches and no similarity matches; duplicate check passes")
+            return
+
+        # Remove PR number from message since cli.py already includes it
+        full_message = "subject matches existing Gerrit change(s)"
+        if allow_duplicates:
+            log.warning("GERRIT DUPLICATE DETECTED (allowed): %s", full_message)
+            return
+        raise DuplicateChangeError(full_message, matching_numbers)
 
 
 def check_for_duplicates(
@@ -525,10 +707,12 @@ def check_for_duplicates(
         target_pr = repo.get_pull(gh.pr_number)
 
         # Create detector and check
-        detector = DuplicateDetector(repo, lookback_days=lookback_days)
-        detector.check_for_duplicates(
-            target_pr, allow_duplicates=allow_duplicates, gh=gh
+        detector = DuplicateDetector(
+            repo,
+            lookback_days=lookback_days,
+            duplicates_filter=os.getenv("DUPLICATES", "open"),
         )
+        detector.check_for_duplicates(target_pr, allow_duplicates=allow_duplicates, gh=gh)
 
         log.info("Duplicate check completed for PR #%d", gh.pr_number)
 
@@ -536,7 +720,5 @@ def check_for_duplicates(
         # Re-raise duplicate errors
         raise
     except Exception as exc:
-        log.warning(
-            "Duplicate detection failed for PR #%d: %s", gh.pr_number, exc
-        )
+        log.warning("Duplicate detection failed for PR #%d: %s", gh.pr_number, exc)
         # Don't fail the entire process if duplicate detection has issues