bepo 0.2.0__tar.gz

bepo-0.2.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.eggs/
+*.egg
+.venv/
+venv/

bepo-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrew Park
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bepo-0.2.0/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: bepo
+Version: 0.2.0
+Summary: Detect duplicate PRs in GitHub repos
+Project-URL: Homepage, https://github.com/aardpark/bepo
+Project-URL: Repository, https://github.com/aardpark/bepo
+Author: Andrew Park
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,detection,duplicate,github,pull-request
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# bepo
+
+Detect duplicate pull requests in GitHub repos.
+
+No ML, no embeddings, no API keys. Just static analysis of diffs.
+
+A maintainer with 100 open PRs can run `bepo check --repo foo/bar` and in 5 minutes get a ranked list of "you should look at these pairs." That saves hours of manual review.
+
+## The Problem
+
+Large repos waste engineering time on duplicate PRs. When multiple contributors fix the same bug independently, only one PR gets merged — the rest is wasted effort.
+
+**This actually happens.** We analyzed 100 PRs from [OpenClaw](https://github.com/openclaw/openclaw) and found:
+
+| Cluster | PRs | What happened |
+|---------|-----|---------------|
+| Matrix startup bug | **4 PRs** | 4 engineers independently fixed `startupGraceMs = 0` → `5000` |
+| Media token regex | 2 PRs | Identical fix submitted twice |
+| Feishu bitable config | 2 PRs | Same multi-account config fix |
+
+**8 duplicate PRs across 3 bug fixes.** That's real engineering time wasted.
+
+## Proof: OpenClaw Analysis
+
+We ran bepo on OpenClaw's open PRs. Here's what it found:
+
+```
+$ bepo check --repo openclaw/openclaw --limit 100
+
+#20025 <-> #19973
+  Similarity: 86%
+  Reason: Both fix #19843      ← Same issue!
+
+#19868 <-> #19855
+  Similarity: 81%
+  Reason: Same files: parse.ts, pi-embedded-subscribe.tools.ts
+
+#19871 <-> #19853
+  Similarity: 100%
+  Reason: Same files: bitable.ts, config-schema.ts, tools-config.ts
+```
+
+**Verified manually:**
+
+| PR Pair | Similarity | Verdict |
+|---------|------------|---------|
+| #20025 ↔ #19973 (Matrix) | 86% | ✅ TRUE DUPLICATE — both change `startupGraceMs` from 0 to 5000 |
+| #19868 ↔ #19855 (regex) | 81% | ✅ TRUE DUPLICATE — identical PR titles |
+| #19871 ↔ #19853 (Feishu) | 100% | ✅ TRUE DUPLICATE — same files, same fix |
+| #19996 ↔ #19993 (unrelated) | 20% | ✅ Correctly NOT flagged |
+
+**Precision: 80%** (4/5 flagged clusters were true duplicates)
+
+## More Examples
+
+**VSCode** — Found PRs touching same files for same feature:
+```
+#295823 <-> #295822
+  Similarity: 77%
+  Reason: Same files: chatModel.ts, chatForkActions.ts
+
+  Both: "Use metadata flag for fork detection"
+```
+
+**Next.js** — Found related test updates:
+```
+#90121 <-> #90120
+  Similarity: 86%
+  Reason: Same files: test/
+```
+
+## Install
+
+```bash
+pip install bepo
+```
+
+Requires [GitHub CLI](https://cli.github.com/) (`gh`) to be installed and authenticated.
+
+## Usage
+
+```bash
+# Check a repo for duplicate PRs
+bepo check --repo owner/repo
+
+# Adjust sensitivity (default: 0.4, higher = stricter)
+bepo check --repo owner/repo --threshold 0.5
+
+# Check more PRs
+bepo check --repo owner/repo --limit 100
+
+# JSON output for CI
+bepo check --repo owner/repo --json
+```
+
+## How It Works
+
+bepo fingerprints each PR by extracting:
+
+| Signal | Weight | What it catches |
+|--------|--------|-----------------|
+| Same issue ref (#123) | 10.0 | Definite duplicate |
+| Same code changes | 8.0 | Identical lines added/removed |
+| Same files touched | 6.0 | PRs modifying same code |
+| Same feature domain | 3.0 | auth, messaging, database, etc. |
+| Same imports | 1.0 | Similar dependencies |
+
+Then computes pairwise Jaccard similarity.
+
+**That's it.** No embeddings, no LLM calls. Just:
+- Parse `+++ b/path` from diffs
+- Regex for `#\d+` issue refs
+- Compare actual code changes
+- Set intersection for similarity
+
+~300 lines of Python.
+
+## As a Library
+
+```python
+from bepo import fingerprint_pr, find_duplicates
+
+# Fingerprint PRs
+fp1 = fingerprint_pr("#123", diff1, title="Fix auth", body="Fixes #456")
+fp2 = fingerprint_pr("#124", diff2, title="Auth fix", body="Fixes #456")
+
+# Find duplicates
+dups = find_duplicates([fp1, fp2], threshold=0.4)
+for d in dups:
+    print(f"{d.pr_a} ↔ {d.pr_b}: {d.similarity:.0%}")
+    print(f"  Shared issues: {d.shared_issues}")
+    print(f"  Shared files: {d.shared_files}")
+```
+
+## GitHub Action
+
+```yaml
+name: PR Duplicate Check
+on: [pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install bepo
+      - run: bepo check --repo ${{ github.repository }} --json
+        env:
+          GH_TOKEN: ${{ github.token }}
+```
+
+## Why This Works
+
+Duplicates share obvious signals:
+- **Same code** = Identical changes (639 shared lines caught SoundChain duplicates)
+- **Same issue ref** = Same bug report (#19843 appeared in 4 Matrix PRs)
+- **Same files** = Same bug location (100% overlap for Feishu cluster)
+
+Code overlap and issue refs catch most duplicates. Simple works.
+
+## Origin Story
+
+This tool was vibe-coded in a single session with Claude.
+
+We tried a few approaches and kept finding that simpler signals outperformed fancier ones. File overlap and issue refs catch most duplicates. Sometimes the obvious solution is the right one.
+
+## License
+
+MIT

bepo-0.2.0/README.md

@@ -0,0 +1,172 @@
+# bepo
+
+Detect duplicate pull requests in GitHub repos.
+
+No ML, no embeddings, no API keys. Just static analysis of diffs.
+
+A maintainer with 100 open PRs can run `bepo check --repo foo/bar` and in 5 minutes get a ranked list of "you should look at these pairs." That saves hours of manual review.
+
+## The Problem
+
+Large repos waste engineering time on duplicate PRs. When multiple contributors fix the same bug independently, only one PR gets merged — the rest is wasted effort.
+
+**This actually happens.** We analyzed 100 PRs from [OpenClaw](https://github.com/openclaw/openclaw) and found:
+
+| Cluster | PRs | What happened |
+|---------|-----|---------------|
+| Matrix startup bug | **4 PRs** | 4 engineers independently fixed `startupGraceMs = 0` → `5000` |
+| Media token regex | 2 PRs | Identical fix submitted twice |
+| Feishu bitable config | 2 PRs | Same multi-account config fix |
+
+**8 duplicate PRs across 3 bug fixes.** That's real engineering time wasted.
+
+## Proof: OpenClaw Analysis
+
+We ran bepo on OpenClaw's open PRs. Here's what it found:
+
+```
+$ bepo check --repo openclaw/openclaw --limit 100
+
+#20025 <-> #19973
+  Similarity: 86%
+  Reason: Both fix #19843      ← Same issue!
+
+#19868 <-> #19855
+  Similarity: 81%
+  Reason: Same files: parse.ts, pi-embedded-subscribe.tools.ts
+
+#19871 <-> #19853
+  Similarity: 100%
+  Reason: Same files: bitable.ts, config-schema.ts, tools-config.ts
+```
+
+**Verified manually:**
+
+| PR Pair | Similarity | Verdict |
+|---------|------------|---------|
+| #20025 ↔ #19973 (Matrix) | 86% | ✅ TRUE DUPLICATE — both change `startupGraceMs` from 0 to 5000 |
+| #19868 ↔ #19855 (regex) | 81% | ✅ TRUE DUPLICATE — identical PR titles |
+| #19871 ↔ #19853 (Feishu) | 100% | ✅ TRUE DUPLICATE — same files, same fix |
+| #19996 ↔ #19993 (unrelated) | 20% | ✅ Correctly NOT flagged |
+
+**Precision: 80%** (4/5 flagged clusters were true duplicates)
+
+## More Examples
+
+**VSCode** — Found PRs touching same files for same feature:
+```
+#295823 <-> #295822
+  Similarity: 77%
+  Reason: Same files: chatModel.ts, chatForkActions.ts
+
+  Both: "Use metadata flag for fork detection"
+```
+
+**Next.js** — Found related test updates:
+```
+#90121 <-> #90120
+  Similarity: 86%
+  Reason: Same files: test/
+```
+
+## Install
+
+```bash
+pip install bepo
+```
+
+Requires [GitHub CLI](https://cli.github.com/) (`gh`) to be installed and authenticated.
+
+## Usage
+
+```bash
+# Check a repo for duplicate PRs
+bepo check --repo owner/repo
+
+# Adjust sensitivity (default: 0.4, higher = stricter)
+bepo check --repo owner/repo --threshold 0.5
+
+# Check more PRs
+bepo check --repo owner/repo --limit 100
+
+# JSON output for CI
+bepo check --repo owner/repo --json
+```
+
+## How It Works
+
+bepo fingerprints each PR by extracting:
+
+| Signal | Weight | What it catches |
+|--------|--------|-----------------|
+| Same issue ref (#123) | 10.0 | Definite duplicate |
+| Same code changes | 8.0 | Identical lines added/removed |
+| Same files touched | 6.0 | PRs modifying same code |
+| Same feature domain | 3.0 | auth, messaging, database, etc. |
+| Same imports | 1.0 | Similar dependencies |
+
+Then computes pairwise Jaccard similarity.
+
+**That's it.** No embeddings, no LLM calls. Just:
+- Parse `+++ b/path` from diffs
+- Regex for `#\d+` issue refs
+- Compare actual code changes
+- Set intersection for similarity
+
+~300 lines of Python.
+
+## As a Library
+
+```python
+from bepo import fingerprint_pr, find_duplicates
+
+# Fingerprint PRs
+fp1 = fingerprint_pr("#123", diff1, title="Fix auth", body="Fixes #456")
+fp2 = fingerprint_pr("#124", diff2, title="Auth fix", body="Fixes #456")
+
+# Find duplicates
+dups = find_duplicates([fp1, fp2], threshold=0.4)
+for d in dups:
+    print(f"{d.pr_a} ↔ {d.pr_b}: {d.similarity:.0%}")
+    print(f"  Shared issues: {d.shared_issues}")
+    print(f"  Shared files: {d.shared_files}")
+```
+
+## GitHub Action
+
+```yaml
+name: PR Duplicate Check
+on: [pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install bepo
+      - run: bepo check --repo ${{ github.repository }} --json
+        env:
+          GH_TOKEN: ${{ github.token }}
+```
+
+## Why This Works
+
+Duplicates share obvious signals:
+- **Same code** = Identical changes (639 shared lines caught SoundChain duplicates)
+- **Same issue ref** = Same bug report (#19843 appeared in 4 Matrix PRs)
+- **Same files** = Same bug location (100% overlap for Feishu cluster)
+
+Code overlap and issue refs catch most duplicates. Simple works.
+
+## Origin Story
+
+This tool was vibe-coded in a single session with Claude.
+
+We tried a few approaches and kept finding that simpler signals outperformed fancier ones. File overlap and issue refs catch most duplicates. Sometimes the obvious solution is the right one.
+
+## License
+
+MIT

bepo-0.2.0/bepo/__init__.py

@@ -0,0 +1,21 @@
+"""bepo - PR duplicate detection for GitHub repos.
+
+Detects duplicate and related pull requests using static analysis.
+No ML, no embeddings, just smart diff parsing.
+"""
+
+__version__ = "0.2.0"
+
+from .fingerprint import (
+    fingerprint_pr,
+    find_duplicates,
+    Fingerprint,
+    Duplicate,
+)
+
+__all__ = [
+    "fingerprint_pr",
+    "find_duplicates",
+    "Fingerprint",
+    "Duplicate",
+]

bepo-0.2.0/bepo/cli.py

@@ -0,0 +1,227 @@
+"""CLI for bepo."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from .fingerprint import fingerprint_pr, find_duplicates
+
+
+# ANSI color codes
+class Colors:
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    CYAN = '\033[96m'
+    RESET = '\033[0m'
+
+    @classmethod
+    def disable(cls):
+        cls.BOLD = cls.DIM = cls.GREEN = cls.YELLOW = ''
+        cls.RED = cls.CYAN = cls.RESET = ''
+
+
+def get_cache_dir() -> Path:
+    """Get cache directory, creating if needed."""
+    cache_dir = Path.home() / '.cache' / 'bepo'
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def get_cache_key(repo: str, pr_num: int) -> str:
+    """Generate cache key for a PR diff."""
+    return hashlib.md5(f"{repo}:{pr_num}".encode()).hexdigest()[:12]
+
+
+def load_cached_diff(repo: str, pr_num: int) -> str | None:
+    """Load diff from cache if exists and fresh (< 1 hour)."""
+    cache_file = get_cache_dir() / f"{get_cache_key(repo, pr_num)}.diff"
+    if cache_file.exists():
+        # Check if cache is fresh (< 1 hour)
+        age = time.time() - cache_file.stat().st_mtime
+        if age < 3600:
+            return cache_file.read_text()
+    return None
+
+
+def save_cached_diff(repo: str, pr_num: int, diff: str):
+    """Save diff to cache."""
+    cache_file = get_cache_dir() / f"{get_cache_key(repo, pr_num)}.diff"
+    cache_file.write_text(diff)
+
+
+def fetch_prs(repo: str, limit: int = 50) -> list[dict]:
+    """Fetch open PRs from GitHub."""
+    result = subprocess.run(
+        ['gh', 'pr', 'list', '--repo', repo, '--state', 'open',
+         '--limit', str(limit), '--json', 'number,title,body'],
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        print(f"{Colors.RED}Error fetching PRs: {result.stderr}{Colors.RESET}", file=sys.stderr)
+        sys.exit(1)
+    return json.loads(result.stdout)
+
+
+def fetch_diff(repo: str, pr_num: int, use_cache: bool = True) -> str:
+    """Fetch diff for a PR, using cache if available."""
+    if use_cache:
+        cached = load_cached_diff(repo, pr_num)
+        if cached is not None:
+            return cached
+
+    result = subprocess.run(
+        ['gh', 'pr', 'diff', str(pr_num), '--repo', repo],
+        capture_output=True, text=True
+    )
+    diff = result.stdout if result.returncode == 0 else ""
+
+    if diff and use_cache:
+        save_cached_diff(repo, pr_num, diff)
+
+    return diff
+
+
+def print_progress(current: int, total: int, pr_num: int, cached: bool = False):
+    """Print progress indicator."""
+    bar_width = 20
+    filled = int(bar_width * current / total)
+    bar = '█' * filled + '░' * (bar_width - filled)
+    cache_indicator = f" {Colors.DIM}(cached){Colors.RESET}" if cached else ""
+    print(f"\r  {Colors.DIM}[{bar}]{Colors.RESET} {current}/{total} PR#{pr_num}{cache_indicator}    ",
+          end='', file=sys.stderr, flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='bepo - detect duplicate PRs',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  bepo check --repo owner/repo
+  bepo check --repo owner/repo --threshold 0.5
+  bepo check --repo owner/repo --json
+  bepo check --repo owner/repo --no-cache
+        '''
+    )
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    # check command
+    check = subparsers.add_parser('check', help='Check repo for duplicate PRs')
+    check.add_argument('--repo', '-r', required=True, help='GitHub repo (owner/repo)')
+    check.add_argument('--threshold', '-t', type=float, default=0.4,
+                       help='Similarity threshold (default: 0.4)')
+    check.add_argument('--limit', '-l', type=int, default=50,
+                       help='Max PRs to check (default: 50)')
+    check.add_argument('--json', action='store_true', help='Output JSON')
+    check.add_argument('--no-cache', action='store_true', help='Disable diff caching')
+    check.add_argument('--no-color', action='store_true', help='Disable colored output')
+
+    # clear-cache command
+    clear = subparsers.add_parser('clear-cache', help='Clear cached diffs')
+
+    args = parser.parse_args()
+
+    if args.command == 'clear-cache':
+        run_clear_cache()
+    elif args.command == 'check':
+        if args.no_color or not sys.stderr.isatty():
+            Colors.disable()
+        run_check(args)
+
+
+def run_clear_cache():
+    """Clear the diff cache."""
+    cache_dir = get_cache_dir()
+    count = 0
+    for f in cache_dir.glob('*.diff'):
+        f.unlink()
+        count += 1
+    print(f"Cleared {count} cached diffs.")
+
+
+def run_check(args):
+    """Run duplicate check on a repo."""
+    use_cache = not args.no_cache
+
+    print(f"{Colors.BOLD}Fetching PRs from {args.repo}...{Colors.RESET}", file=sys.stderr)
+    prs = fetch_prs(args.repo, args.limit)
+    print(f"Found {Colors.CYAN}{len(prs)}{Colors.RESET} open PRs\n", file=sys.stderr)
+
+    # Fingerprint each PR
+    fingerprints = []
+    cache_hits = 0
+    start_time = time.time()
+
+    for i, pr in enumerate(prs, 1):
+        pr_num = pr['number']
+        cached = load_cached_diff(args.repo, pr_num) is not None if use_cache else False
+        if cached:
+            cache_hits += 1
+        print_progress(i, len(prs), pr_num, cached)
+
+        diff = fetch_diff(args.repo, pr_num, use_cache=use_cache)
+        if diff:
+            fp = fingerprint_pr(
+                f"#{pr_num}",
+                diff,
+                title=pr.get('title', ''),
+                body=pr.get('body', '') or '',
+            )
+            fingerprints.append(fp)
+
+    elapsed = time.time() - start_time
+    print(f"\r{' ' * 60}\r", end='', file=sys.stderr)  # Clear progress line
+
+    if use_cache and cache_hits > 0:
+        print(f"{Colors.DIM}Analyzed {len(prs)} PRs in {elapsed:.1f}s ({cache_hits} cached){Colors.RESET}\n",
+              file=sys.stderr)
+    else:
+        print(f"{Colors.DIM}Analyzed {len(prs)} PRs in {elapsed:.1f}s{Colors.RESET}\n", file=sys.stderr)
+
+    # Find duplicates
+    duplicates = find_duplicates(fingerprints, threshold=args.threshold)
+
+    if args.json:
+        output = [
+            {
+                'pr_a': d.pr_a,
+                'pr_b': d.pr_b,
+                'similarity': round(d.similarity, 3),
+                'shared_issues': d.shared_issues,
+                'shared_files': d.shared_files,
+                'shared_code_lines': d.shared_code_lines,
+                'reason': d.reason,
+            }
+            for d in duplicates
+        ]
+        print(json.dumps(output, indent=2))
+    else:
+        if not duplicates:
+            print(f"{Colors.GREEN}No duplicates found.{Colors.RESET}")
+        else:
+            print(f"{Colors.BOLD}Found {len(duplicates)} potential duplicates:{Colors.RESET}\n")
+            for d in duplicates:
+                # Color code by similarity
+                if d.similarity >= 0.8:
+                    sim_color = Colors.RED
+                elif d.similarity >= 0.6:
+                    sim_color = Colors.YELLOW
+                else:
+                    sim_color = Colors.RESET
+
+                print(f"{Colors.BOLD}{d.pr_a} <-> {d.pr_b}{Colors.RESET}")
+                print(f"  {sim_color}Similarity: {d.similarity:.0%}{Colors.RESET}")
+                print(f"  {Colors.DIM}Reason: {d.reason}{Colors.RESET}")
+                print()
+
+
+if __name__ == '__main__':
+    main()

bepo-0.2.0/bepo/fingerprint.py

@@ -0,0 +1,289 @@
+"""PR fingerprinting and duplicate detection."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Fingerprint:
+    """Fingerprint of a PR's changes."""
+    pr_id: str
+    files_touched: list[str] = field(default_factory=list)
+    domains: list[str] = field(default_factory=list)
+    issue_refs: list[str] = field(default_factory=list)
+    imports: list[str] = field(default_factory=list)
+    code_lines: list[str] = field(default_factory=list)  # normalized changed lines
+
+    def similarity(self, other: "Fingerprint") -> float:
+        """Compute similarity score between two fingerprints.
+
+        Weights:
+        - Issue ref overlap (10.0): Same issue = definite duplicate
+        - Code content overlap (8.0): Same changes = definite duplicate
+        - File path overlap (5.0): Same files = likely related
+        - Domain overlap (3.0): Same feature area
+        - Imports (1.0): Similar dependencies
+        """
+        scores = []
+        weights = []
+
+        # Issue reference overlap - strongest signal
+        if self.issue_refs and other.issue_refs:
+            r1, r2 = set(self.issue_refs), set(other.issue_refs)
+            if r1 & r2:
+                scores.append(1.0)
+                weights.append(10.0)
+
+        # Code content similarity - what actually changed
+        code_sim = 0.0
+        if self.code_lines and other.code_lines:
+            c1, c2 = set(self.code_lines), set(other.code_lines)
+            if c1 | c2:
+                code_sim = len(c1 & c2) / len(c1 | c2)
+                if code_sim > 0.1:  # only count if meaningful overlap
+                    scores.append(code_sim)
+                    weights.append(8.0)
+
+        # Exact file overlap (strongest file signal)
+        exact_files_a = set(self.files_touched)
+        exact_files_b = set(other.files_touched)
+        exact_overlap = exact_files_a & exact_files_b
+        if exact_overlap:
+            # Same exact files + code overlap = very likely duplicate
+            file_sim = len(exact_overlap) / len(exact_files_a | exact_files_b)
+            if code_sim > 0.2:
+                # Files AND code match - boost significantly
+                scores.append(file_sim)
+                weights.append(6.0)
+            else:
+                # Same files but different code - lower weight
+                scores.append(file_sim)
+                weights.append(3.0)
+        else:
+            # Directory level similarity (weaker signal)
+            def get_dirs(files):
+                dirs = set()
+                for f in files:
+                    parts = f.split('/')
+                    if len(parts) >= 2:
+                        dirs.add('/'.join(parts[:-1]))
+                return dirs
+            f1, f2 = get_dirs(self.files_touched), get_dirs(other.files_touched)
+            if f1 | f2:
+                scores.append(len(f1 & f2) / len(f1 | f2))
+                weights.append(2.0)  # lower weight for dir-only match
+
+        # Domain similarity
+        if self.domains or other.domains:
+            d1, d2 = set(self.domains), set(other.domains)
+            if d1 | d2:
+                scores.append(len(d1 & d2) / len(d1 | d2))
+                weights.append(3.0)
+
+        # Import similarity
+        if self.imports or other.imports:
+            i1, i2 = set(self.imports), set(other.imports)
+            if i1 | i2:
+                scores.append(len(i1 & i2) / len(i1 | i2))
+                weights.append(1.0)
+
+        if not scores:
+            return 0.0
+        return sum(s * w for s, w in zip(scores, weights)) / sum(weights)
+
+
+@dataclass
+class Duplicate:
+    """A pair of similar PRs."""
+    pr_a: str
+    pr_b: str
+    similarity: float
+    shared_issues: list[str]
+    shared_files: list[str]
+    shared_domains: list[str]
+    shared_code_lines: int  # count of overlapping code lines
+    reason: str
+
+
+# Domain keywords for categorizing PRs
+DOMAINS = {
+    # Messaging
+    "telegram": "messaging", "whatsapp": "messaging", "discord": "messaging",
+    "slack": "messaging", "matrix": "messaging", "twilio": "messaging",
+    # Auth
+    "auth": "auth", "login": "auth", "oauth": "auth", "jwt": "auth",
+    "session": "auth", "token": "auth",
+    # Data
+    "cache": "cache", "redis": "cache", "database": "database", "db": "database",
+    "postgres": "database", "mysql": "database", "mongo": "database",
+    # API
+    "api": "api", "endpoint": "api", "route": "api", "graphql": "api", "webhook": "api",
+    # Scheduling
+    "cron": "scheduling", "schedule": "scheduling", "job": "scheduling", "queue": "scheduling",
+    # AI
+    "llm": "ai", "model": "ai", "embedding": "ai", "openai": "ai", "anthropic": "ai",
+    # Media
+    "media": "media", "image": "media", "video": "media", "upload": "media",
+    # Config
+    "config": "config", "setting": "config", "env": "config",
+    # Observability
+    "log": "observability", "trace": "observability", "metric": "observability",
+    # Plugins
+    "plugin": "plugin", "extension": "plugin",
+}
+
+
+def _extract_files(diff: str) -> list[str]:
+    """Extract file paths from diff."""
+    files = []
+    for line in diff.split('\n'):
+        if line.startswith('+++ b/'):
+            files.append(line[6:])
+    return list(set(files))
+
+
+def _extract_issues(text: str) -> list[str]:
+    """Extract issue references (#123)."""
+    return list(set(m.group(1) for m in re.finditer(r'#(\d+)', text)))
+
+
+def _extract_domains(files: list[str], code: str) -> list[str]:
+    """Extract domains from file paths and code."""
+    domains = set()
+    text = ' '.join(files).lower() + ' ' + code.lower()
+    for keyword, domain in DOMAINS.items():
+        if keyword in text:
+            domains.add(domain)
+    return list(domains)
+
+
+def _extract_imports(diff: str) -> list[str]:
+    """Extract imports from diff."""
+    imports = []
+    for line in diff.split('\n'):
+        if line.startswith('+') and not line.startswith('+++'):
+            line = line[1:]
+            m = re.search(r'import\s+.*\s+from\s+["\']([^"\']+)["\']', line)
+            if m:
+                imports.append(m.group(1))
+            m = re.search(r'require\s*\(\s*["\']([^"\']+)["\']', line)
+            if m:
+                imports.append(m.group(1))
+    return list(set(imports))
+
+
+def _extract_new_code(diff: str) -> str:
+    """Extract added lines from diff."""
+    lines = []
+    for line in diff.split('\n'):
+        if line.startswith('+') and not line.startswith('+++'):
+            lines.append(line[1:])
+    return '\n'.join(lines)
+
+
+def _extract_code_lines(diff: str) -> list[str]:
+    """Extract normalized code lines from diff for content comparison.
+
+    Normalizes lines by stripping whitespace and filtering noise.
+    Returns unique meaningful lines that represent actual code changes.
+    """
+    lines = set()
+    for line in diff.split('\n'):
+        # Get added and removed lines (both matter for comparison)
+        if line.startswith('+') and not line.startswith('+++'):
+            code = line[1:].strip()
+        elif line.startswith('-') and not line.startswith('---'):
+            code = line[1:].strip()
+        else:
+            continue
+
+        # Skip empty lines and trivial changes
+        if not code:
+            continue
+        if len(code) < 4:  # skip tiny fragments
+            continue
+        if code.startswith('//') or code.startswith('#') or code.startswith('*'):
+            continue  # skip comments
+        if code in ('{', '}', '(', ')', '[', ']', 'else', 'return', 'break', 'continue'):
+            continue  # skip trivial syntax
+
+        lines.add(code)
+
+    return list(lines)
+
+
+def fingerprint_pr(
+    pr_id: str,
+    diff: str,
+    title: str = "",
+    body: str = "",
+) -> Fingerprint:
+    """Create a fingerprint from a PR diff."""
+    new_code = _extract_new_code(diff)
+    files = _extract_files(diff)
+
+    return Fingerprint(
+        pr_id=pr_id,
+        files_touched=files,
+        domains=_extract_domains(files, new_code),
+        issue_refs=_extract_issues(f"{title} {body} {diff}"),
+        imports=_extract_imports(diff),
+        code_lines=_extract_code_lines(diff),
+    )
+
+
+def find_duplicates(
+    fingerprints: list[Fingerprint],
+    threshold: float = 0.4,
+) -> list[Duplicate]:
+    """Find duplicate PRs from a list of fingerprints."""
+    duplicates = []
+
+    for i, fp_a in enumerate(fingerprints):
+        for j, fp_b in enumerate(fingerprints):
+            if i >= j:
+                continue
+
+            sim = fp_a.similarity(fp_b)
+            if sim < threshold:
+                continue
+
+            shared_issues = list(set(fp_a.issue_refs) & set(fp_b.issue_refs))
+            shared_domains = list(set(fp_a.domains) & set(fp_b.domains))
+            shared_code = set(fp_a.code_lines) & set(fp_b.code_lines)
+            shared_code_count = len(shared_code)
+
+            def get_dirs(files):
+                return set('/'.join(f.split('/')[:-1]) for f in files if '/' in f)
+            shared_files = list(get_dirs(fp_a.files_touched) & get_dirs(fp_b.files_touched))
+
+            # Determine reason - prioritize strongest signals
+            if shared_issues:
+                reason = f"Both fix #{', #'.join(shared_issues[:2])}"
+            elif shared_code_count >= 3:
+                # Show a sample of shared code
+                sample = list(shared_code)[:1][0]
+                if len(sample) > 40:
+                    sample = sample[:40] + "..."
+                reason = f"Same code: {shared_code_count} lines overlap"
+            elif shared_files:
+                reason = f"Same files: {', '.join(f.split('/')[-1] for f in shared_files[:2])}"
+            elif shared_domains:
+                reason = f"Same domain: {', '.join(shared_domains[:2])}"
+            else:
+                reason = f"Similar ({sim:.0%})"
+
+            duplicates.append(Duplicate(
+                pr_a=fp_a.pr_id,
+                pr_b=fp_b.pr_id,
+                similarity=sim,
+                shared_issues=shared_issues,
+                shared_files=shared_files,
+                shared_domains=shared_domains,
+                shared_code_lines=shared_code_count,
+                reason=reason,
+            ))
+
+    duplicates.sort(key=lambda d: d.similarity, reverse=True)
+    return duplicates

bepo-0.2.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bepo"
+version = "0.2.0"
+description = "Detect duplicate PRs in GitHub repos"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Andrew Park" }]
+keywords = ["github", "pull-request", "duplicate", "detection", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+[project.scripts]
+bepo = "bepo.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/aardpark/bepo"
+Repository = "https://github.com/aardpark/bepo"

bepo-0.2.0/tests/test_fingerprint.py

@@ -0,0 +1,71 @@
+"""Tests for bepo fingerprinting."""
+from bepo import fingerprint_pr, find_duplicates
+
+
+def test_fingerprint_extracts_files():
+    diff = """+++ b/src/auth/login.ts
+- old code
++ new code
++++ b/src/auth/logout.ts
++ more code
+"""
+    fp = fingerprint_pr("#1", diff)
+    assert "src/auth/login.ts" in fp.files_touched
+    assert "src/auth/logout.ts" in fp.files_touched
+
+
+def test_fingerprint_extracts_issues():
+    fp = fingerprint_pr("#1", "", title="Fix bug", body="Fixes #123 and #456")
+    assert "123" in fp.issue_refs
+    assert "456" in fp.issue_refs
+
+
+def test_fingerprint_extracts_domains():
+    diff = "+++ b/src/telegram/handler.ts\n+ code"
+    fp = fingerprint_pr("#1", diff)
+    assert "messaging" in fp.domains
+
+
+def test_similar_prs_detected():
+    diff1 = "+++ b/src/auth/login.ts\n+ code"
+    diff2 = "+++ b/src/auth/login.ts\n+ other code"
+
+    fp1 = fingerprint_pr("#1", diff1, body="Fixes #100")
+    fp2 = fingerprint_pr("#2", diff2, body="Fixes #100")
+
+    dups = find_duplicates([fp1, fp2], threshold=0.3)
+    assert len(dups) == 1
+    assert dups[0].similarity > 0.5
+    assert "100" in dups[0].shared_issues
+
+
+def test_different_prs_not_flagged():
+    diff1 = "+++ b/src/auth/login.ts\n+ const user = await authenticate(token)"
+    diff2 = "+++ b/src/payments/stripe.ts\n+ const charge = await stripe.charges.create(amount)"
+
+    fp1 = fingerprint_pr("#1", diff1)
+    fp2 = fingerprint_pr("#2", diff2)
+
+    dups = find_duplicates([fp1, fp2], threshold=0.5)
+    assert len(dups) == 0
+
+
+def test_same_code_detected():
+    """PRs with identical code changes should be flagged."""
+    diff1 = """+++ b/src/config.ts
++ startupGraceMs = 5000
++ retryCount = 3
++ timeout = 30000
+"""
+    diff2 = """+++ b/src/config.ts
++ startupGraceMs = 5000
++ retryCount = 3
++ timeout = 30000
+"""
+    fp1 = fingerprint_pr("#1", diff1)
+    fp2 = fingerprint_pr("#2", diff2)
+
+    dups = find_duplicates([fp1, fp2], threshold=0.3)
+    assert len(dups) == 1
+    assert dups[0].shared_code_lines >= 3
+    assert "code" in dups[0].reason.lower() or dups[0].similarity > 0.8