ghpr clone auto-detects current branch's PR when no spec given

Add `_detect_current_branch_pr()` which uses `gh pr view` to find the
open PR for the current branch, so `ghprc` with no args works from a
branch that has a PR.

Also fix `UnboundLocalError` for `gist_url` when `--no-gist` is used
(discovered while writing e2e tests).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ryan-williams

pyproject.toml

@@ -48,3 +48,6 @@ ghpr = ["shell/*.bash", "shell/*.fish"]
 
 [tool.pytest.ini_options]
 pythonpath = ["src"]
+markers = [
+    "e2e: end-to-end tests requiring gh CLI auth and network access",
+]

src/ghpr/commands/clone.py

@@ -15,7 +15,35 @@
 from ..config import get_pr_info_from_path
 from ..files import get_expected_description_filename, write_description_with_link_ref
 from ..gist import extract_gist_footer, add_gist_footer, create_gist, DEFAULT_GIST_REMOTE, find_gist_remote
-from ..patterns import parse_pr_spec, GIST_ID_PATTERN
+from ..patterns import parse_pr_spec, GIST_ID_PATTERN, GITHUB_ITEM_URL_PATTERN
+
+
+def _detect_current_branch_pr() -> tuple[str | None, str | None, str | None, str | None]:
+    """Try to find an open PR for the current branch.
+
+    Uses `gh pr view` which finds the PR associated with the current branch.
+
+    Returns:
+        Tuple of (owner, repo, number, item_type) or (None, None, None, None).
+    """
+    from subprocess import DEVNULL
+    try:
+        data = proc.json(
+            'gh', 'pr', 'view', '--json', 'number,url',
+            log=None, err_ok=True, stderr=DEVNULL,
+        )
+        if data and data.get('number'):
+            url = data.get('url', '')
+            match = GITHUB_ITEM_URL_PATTERN.match(url)
+            if match:
+                owner, repo, _, number = match.groups()
+                return owner, repo, number, 'pr'
+            # Fallback: use repo view for owner/repo
+            repo_data = proc.json('gh', 'repo', 'view', '--json', 'owner,name', log=None)
+            return repo_data['owner']['login'], repo_data['name'], str(data['number']), 'pr'
+    except Exception:
+        pass
+    return None, None, None, None
 
 
 def clone(
@@ -49,9 +77,12 @@ def clone(
                 err("Use owner/repo#number format.")
                 exit(1)
     else:
-        # Try to infer from current directory
-        owner, repo, number = get_pr_info_from_path()
-        item_type = None
+        # Try to detect PR for the current branch
+        owner, repo, number, item_type = _detect_current_branch_pr()
+        if not number:
+            # Fall back to inferring from directory structure
+            owner, repo, number = get_pr_info_from_path()
+            item_type = None
 
     if not all([owner, repo, number]):
         err("Error: Could not determine PR/Issue to clone")
@@ -121,9 +152,9 @@ def clone(
     proc.run('git', 'commit', '-m', f'Initial clone of {item_label} {owner}/{repo}#{number}', log=None)
 
     # Create or use existing gist unless --no-gist was specified
+    gist_url = None
     if not no_gist:
         gist_id = None
-        gist_url = None
 
         # Check if PR already has a gist in its footer
         if existing_gist_url:

tests/test_clone_e2e.py

@@ -0,0 +1,143 @@
+"""End-to-end tests for ghpr clone.
+
+These tests require `gh` CLI authentication and network access.
+Skip with: pytest -m 'not e2e'
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from shutil import which
+from tempfile import TemporaryDirectory
+
+import pytest
+
+
+def gh_authenticated() -> bool:
+    """Check if `gh` CLI is installed and authenticated."""
+    if not which('gh'):
+        return False
+    try:
+        result = subprocess.run(
+            ['gh', 'auth', 'status'],
+            capture_output=True, timeout=10,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+requires_gh = pytest.mark.skipif(
+    not gh_authenticated(),
+    reason='requires authenticated gh CLI',
+)
+e2e = pytest.mark.e2e
+
+
+@requires_gh
+@e2e
+class TestCloneE2E:
+    """End-to-end clone tests using real GitHub PRs."""
+
+    def test_clone_pr_no_gist(self):
+        """Clone a known PR with --no-gist, verify directory structure."""
+        with TemporaryDirectory() as tmpdir:
+            result = subprocess.run(
+                [
+                    'ghpr', 'clone',
+                    'https://github.com/runsascoded/ghpr/pull/6',
+                    '--no-gist',
+                    '-d', os.path.join(tmpdir, 'pr6'),
+                ],
+                capture_output=True, text=True, timeout=30,
+            )
+            assert result.returncode == 0, f"clone failed: {result.stderr}"
+
+            pr_dir = Path(tmpdir) / 'pr6'
+            assert pr_dir.is_dir()
+
+            # Should have a description file
+            desc_files = list(pr_dir.glob('*.md'))
+            assert len(desc_files) >= 1, f"No .md files in {pr_dir}"
+
+            # Description file should be repo#number.md
+            desc_names = [f.name for f in desc_files if not f.name.startswith('z')]
+            assert 'ghpr#6.md' in desc_names
+
+            # Should have git config set
+            owner = subprocess.run(
+                ['git', 'config', 'pr.owner'],
+                capture_output=True, text=True, cwd=pr_dir,
+            ).stdout.strip()
+            assert owner == 'runsascoded'
+
+            repo = subprocess.run(
+                ['git', 'config', 'pr.repo'],
+                capture_output=True, text=True, cwd=pr_dir,
+            ).stdout.strip()
+            assert repo == 'ghpr'
+
+            pr_type = subprocess.run(
+                ['git', 'config', 'pr.type'],
+                capture_output=True, text=True, cwd=pr_dir,
+            ).stdout.strip()
+            assert pr_type == 'pr'
+
+    def test_clone_pr_with_gist_reuse(self):
+        """Clone a PR that has an existing gist footer; verify gist is reused."""
+        with TemporaryDirectory() as tmpdir:
+            result = subprocess.run(
+                [
+                    'ghpr', 'clone',
+                    'https://github.com/marin-community/marin/pull/1723',
+                    '--no-comments',
+                    '-d', os.path.join(tmpdir, 'pr1723'),
+                ],
+                capture_output=True, text=True, timeout=60,
+            )
+            assert result.returncode == 0, f"clone failed: {result.stderr}"
+
+            pr_dir = Path(tmpdir) / 'pr1723'
+            assert pr_dir.is_dir()
+
+            # Should have detected and reused existing gist
+            assert 'Found existing gist' in result.stderr, (
+                f"Expected gist reuse message in stderr:\n{result.stderr}"
+            )
+
+            # Gist remote should be configured
+            gist_remote = subprocess.run(
+                ['git', 'config', 'pr.gist'],
+                capture_output=True, text=True, cwd=pr_dir,
+            ).stdout.strip()
+            assert gist_remote, "pr.gist config not set (gist not reused)"
+
+            # Gist should be added as a git remote
+            remotes = subprocess.run(
+                ['git', 'remote', '-v'],
+                capture_output=True, text=True, cwd=pr_dir,
+            ).stdout
+            assert 'gist.github.com' in remotes
+
+    def test_clone_issue_no_gist(self):
+        """Clone a known issue, verify it's detected as an issue."""
+        with TemporaryDirectory() as tmpdir:
+            result = subprocess.run(
+                [
+                    'ghpr', 'clone',
+                    'https://github.com/marin-community/marin/issues/1773',
+                    '--no-gist', '--no-comments',
+                    '-d', os.path.join(tmpdir, 'issue1773'),
+                ],
+                capture_output=True, text=True, timeout=30,
+            )
+            assert result.returncode == 0, f"clone failed: {result.stderr}"
+
+            pr_dir = Path(tmpdir) / 'issue1773'
+            assert pr_dir.is_dir()
+
+            pr_type = subprocess.run(
+                ['git', 'config', 'pr.type'],
+                capture_output=True, text=True, cwd=pr_dir,
+            ).stdout.strip()
+            assert pr_type == 'issue'

tests/test_detect_pr.py

@@ -0,0 +1,77 @@
+"""Tests for _detect_current_branch_pr."""
+
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+from ghpr.commands.clone import _detect_current_branch_pr
+
+
+class TestDetectCurrentBranchPR:
+    """Unit tests for detecting the current branch's PR."""
+
+    def test_detects_pr_from_gh_pr_view(self):
+        """When `gh pr view` returns valid data, extract owner/repo/number."""
+        mock_data = {
+            'number': 100,
+            'url': 'https://github.com/Quantum-Accelerators/electrai/pull/100',
+        }
+        with patch('ghpr.commands.clone.proc') as mock_proc:
+            mock_proc.json.return_value = mock_data
+            owner, repo, number, item_type = _detect_current_branch_pr()
+        assert owner == 'Quantum-Accelerators'
+        assert repo == 'electrai'
+        assert number == '100'
+        assert item_type == 'pr'
+
+    def test_fallback_to_repo_view_when_url_missing(self):
+        """When URL doesn't match pattern, fall back to `gh repo view`."""
+        pr_data = {'number': 42, 'url': ''}
+        repo_data = {'owner': {'login': 'someorg'}, 'name': 'somerepo'}
+        with patch('ghpr.commands.clone.proc') as mock_proc:
+            mock_proc.json.side_effect = [pr_data, repo_data]
+            owner, repo, number, item_type = _detect_current_branch_pr()
+        assert owner == 'someorg'
+        assert repo == 'somerepo'
+        assert number == '42'
+        assert item_type == 'pr'
+
+    def test_returns_none_when_no_pr(self):
+        """When `gh pr view` fails (no PR for branch), return None tuple."""
+        with patch('ghpr.commands.clone.proc') as mock_proc:
+            mock_proc.json.side_effect = Exception('no PR found')
+            result = _detect_current_branch_pr()
+        assert result == (None, None, None, None)
+
+    def test_returns_none_when_empty_response(self):
+        """When `gh pr view` returns None/empty, return None tuple."""
+        with patch('ghpr.commands.clone.proc') as mock_proc:
+            mock_proc.json.return_value = None
+            result = _detect_current_branch_pr()
+        assert result == (None, None, None, None)
+
+    def test_returns_none_when_number_missing(self):
+        """When response lacks a number field, return None tuple."""
+        with patch('ghpr.commands.clone.proc') as mock_proc:
+            mock_proc.json.return_value = {'url': 'https://github.com/a/b/pull/1'}
+            result = _detect_current_branch_pr()
+        assert result == (None, None, None, None)
+
+    def test_parses_various_url_formats(self):
+        """Verify URL parsing for different GitHub URL patterns."""
+        cases = [
+            (
+                'https://github.com/org/repo/pull/1',
+                ('org', 'repo', '1', 'pr'),
+            ),
+            (
+                'https://github.com/my-org/my-repo/pull/999',
+                ('my-org', 'my-repo', '999', 'pr'),
+            ),
+        ]
+        for url, expected in cases:
+            data = {'number': int(expected[2]), 'url': url}
+            with patch('ghpr.commands.clone.proc') as mock_proc:
+                mock_proc.json.return_value = data
+                result = _detect_current_branch_pr()
+            assert result == expected, f"Failed for URL: {url}"