ghstack 0.13.0__tar.gz → 0.15.0__tar.gz

{ghstack-0.13.0 → ghstack-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ghstack
-Version: 0.13.0
+Version: 0.15.0
 Summary: Stack diff support for GitHub
 Author: Edward Z. Yang
 Author-email: Edward Z. Yang <ezyang@mit.edu>

{ghstack-0.13.0 → ghstack-0.15.0}/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
     "flake8<8.0.0,>=7.0.0",
 ]
 name = "ghstack"
-version = "0.13.0"
+version = "0.15.0"
 description = "Stack diff support for GitHub"
 readme = "README.md"
 classifiers = [

ghstack-0.15.0/src/ghstack/checkout.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+
+import logging
+import re
+
+import ghstack.github
+import ghstack.github_utils
+import ghstack.shell
+
+
+def main(
+    pull_request: str,
+    github: ghstack.github.GitHubEndpoint,
+    sh: ghstack.shell.Shell,
+    remote_name: str,
+    same_base: bool = False,
+) -> None:
+
+    params = ghstack.github_utils.parse_pull_request(
+        pull_request, sh=sh, remote_name=remote_name
+    )
+    head_ref = github.get_head_ref(**params)
+    orig_ref = re.sub(r"/head$", "/orig", head_ref)
+    if orig_ref == head_ref:
+        logging.warning(
+            "The ref {} doesn't look like a ghstack reference".format(head_ref)
+        )
+
+    # TODO: Handle remotes correctly too (so this subsumes hub)
+
+    # If --same-base is specified, check if checkout would change the merge-base
+    if same_base:
+        # Get the default branch name from the repo
+        repo_info = ghstack.github_utils.get_github_repo_info(
+            github=github,
+            sh=sh,
+            repo_owner=params["owner"],
+            repo_name=params["name"],
+            github_url=params["github_url"],
+            remote_name=remote_name,
+        )
+        default_branch = repo_info["default_branch"]
+        default_branch_ref = f"{remote_name}/{default_branch}"
+
+        # Get current merge-base with default branch
+        current_base = sh.git("merge-base", default_branch_ref, "HEAD")
+    else:
+        current_base = None
+        default_branch_ref = None
+
+    sh.git("fetch", "--prune", remote_name)
+
+    # If --same-base is specified, check what the new merge-base would be
+    if same_base:
+        assert default_branch_ref is not None
+        assert current_base is not None
+        target_ref = remote_name + "/" + orig_ref
+        new_base = sh.git("merge-base", default_branch_ref, target_ref)
+
+        if current_base != new_base:
+            raise RuntimeError(
+                f"Checkout would change merge-base from {current_base[:8]} to {new_base[:8]}, "
+                f"aborting due to --same-base flag"
+            )
+
+    sh.git("checkout", remote_name + "/" + orig_ref)

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/cherry_pick.py

@@ -14,6 +14,7 @@ def main(
     sh: ghstack.shell.Shell,
     remote_name: str,
     stack: bool = False,
+    no_fetch: bool = False,
 ) -> None:
 
     params = ghstack.github_utils.parse_pull_request(
@@ -26,7 +27,8 @@ def main(
             "The ref {} doesn't look like a ghstack reference".format(head_ref)
         )
 
-    sh.git("fetch", "--prune", remote_name)
+    if not no_fetch:
+        sh.git("fetch", "--prune", remote_name)
 
     if stack:
         # Cherry-pick the entire stack from merge-base to the commit

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/cli.py

@@ -13,6 +13,7 @@ import ghstack.circleci_real
 import ghstack.config
 import ghstack.github_real
 import ghstack.land
+import ghstack.log
 import ghstack.logs
 import ghstack.rage
 import ghstack.status
@@ -48,22 +49,74 @@ def cli_context(
         yield shell, config, github
 
 
-@click.group(invoke_without_command=True)
+@click.group(
+    invoke_without_command=True,
+    epilog="Running ghstack with no subcommand is equivalent to ghstack submit.",
+)
 @click.pass_context
 @click.version_option(ghstack.__version__, "--version", "-V")
 @click.option("--debug", is_flag=True, help="Log debug information to stderr")
-# hidden arguments that we'll pass along to submit if no other command given
-@click.option("--message", "-m", default="Update", hidden=True)
-@click.option("--update-fields", "-u", is_flag=True, hidden=True)
-@click.option("--short", is_flag=True, hidden=True)
-@click.option("--force", is_flag=True, hidden=True)
-@click.option("--no-skip", is_flag=True, hidden=True)
-@click.option("--draft", is_flag=True, hidden=True)
+# These options are forwarded to the submit command when no subcommand is given.
+@click.option(
+    "--message",
+    "-m",
+    default="Update",
+    help="Description of change you made",
+)
+@click.option(
+    "--update-fields",
+    "-u",
+    is_flag=True,
+    help="Update GitHub pull request summary from the local commit",
+)
+@click.option(
+    "--short", is_flag=True, help="Print only the URL of the latest opened PR to stdout"
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="force push the branch even if your local branch is stale",
+)
+@click.option(
+    "--no-skip",
+    is_flag=True,
+    help="Never skip pushing commits, even if the contents didn't change",
+)
+@click.option(
+    "--draft",
+    is_flag=True,
+    help="Create the pull request in draft mode (only if it has not already been created)",
+)
+@click.option(
+    "--direct/--no-direct",
+    "direct_opt",
+    is_flag=True,
+    default=None,
+    help="Create stack that directly merges into master",
+)
+@click.option(
+    "--base",
+    "-B",
+    default=None,
+    help="Branch to base the stack off of",
+)
 @click.option(
-    "--direct/--no-direct", "direct_opt", is_flag=True, hidden=True, default=None
+    "--stack/--no-stack",
+    "-s/-S",
+    is_flag=True,
+    default=True,
+    help="Submit the entire stack of commits reachable from HEAD",
+)
+@click.option(
+    "--reviewer",
+    default=None,
+    help="Comma-separated list of GitHub usernames to add as reviewers",
+)
+@click.option(
+    "--label",
+    default=None,
+    help="Comma-separated list of labels to add to new PRs",
 )
-@click.option("--base", "-B", default=None, hidden=True)
-@click.option("--stack/--no-stack", "-s/-S", is_flag=True, default=True, hidden=True)
 def main(
     ctx: click.Context,
     debug: bool,
@@ -76,6 +129,8 @@ def main(
     draft: bool,
     base: Optional[str],
     stack: bool,
+    reviewer: Optional[str],
+    label: Optional[str],
 ) -> None:
     """
     Submit stacks of diffs to Github
@@ -100,9 +155,20 @@ def main(
             base=base,
             stack=stack,
             direct_opt=direct_opt,
+            reviewer=reviewer,
+            label=label,
         )
 
 
+@main.command("auth")
+def auth() -> None:
+    """
+    Set up GitHub authentication if not already configured.
+    """
+    with EXIT_STACK:
+        ghstack.config.read_config()
+
+
 @main.command("action")
 @click.option("--close", is_flag=True, help="Close the specified pull request")
 @click.argument("pull_request", metavar="PR")
@@ -120,8 +186,13 @@ def action(close: bool, pull_request: str) -> None:
 
 
 @main.command("checkout")
+@click.option(
+    "--same-base",
+    is_flag=True,
+    help="Only checkout if merge-base with main branch would remain the same",
+)
 @click.argument("pull_request", metavar="PR")
-def checkout(pull_request: str) -> None:
+def checkout(same_base: bool, pull_request: str) -> None:
     """
     Checkout a PR
     """
@@ -131,6 +202,7 @@ def checkout(pull_request: str) -> None:
             github=github,
             sh=shell,
             remote_name=config.remote_name,
+            same_base=same_base,
         )
 
 
@@ -141,8 +213,13 @@ def checkout(pull_request: str) -> None:
     is_flag=True,
     help="Cherry-pick all commits from the commit to the merge-base with main branch",
 )
+@click.option(
+    "--no-fetch",
+    is_flag=True,
+    help="Skip fetching from the remote before cherry-picking",
+)
 @click.argument("pull_request", metavar="PR")
-def cherry_pick(stack: bool, pull_request: str) -> None:
+def cherry_pick(stack: bool, no_fetch: bool, pull_request: str) -> None:
     """
     Cherry-pick a PR
     """
@@ -153,6 +230,7 @@ def cherry_pick(stack: bool, pull_request: str) -> None:
             sh=shell,
             remote_name=config.remote_name,
             stack=stack,
+            no_fetch=no_fetch,
         )
 
 
@@ -174,6 +252,35 @@ def land(force: bool, pull_request: str) -> None:
         )
 
 
+@main.command(
+    "log",
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
+@click.option(
+    "--pr",
+    "pull_request",
+    default=None,
+    help="Explicit PR (URL or number) to log.  If omitted, the PR is inferred "
+    "from HEAD's Pull-Request trailer, and local pending changes are shown "
+    "on top as a synthesized commit.",
+)
+@click.argument("git_log_args", nargs=-1, type=click.UNPROCESSED)
+def log(pull_request: Optional[str], git_log_args: Tuple[str, ...]) -> None:
+    """
+    Show git log for a PR, restricted to that PR's commits.
+    Extra arguments are forwarded to git log (e.g. -p).
+    """
+    with cli_context(request_github_token=False) as (shell, config, github):
+        ghstack.log.main(
+            github=github,
+            sh=shell,
+            remote_name=config.remote_name,
+            github_url=config.github_url,
+            args=list(git_log_args),
+            pull_request=pull_request,
+        )
+
+
 @main.command("rage")
 @click.option(
     "--latest",
@@ -257,6 +364,18 @@ def status(pull_request: str) -> None:
     "With --no-stack, we support only non-range identifiers, and will submit each commit "
     "listed in the command line.",
 )
+@click.option(
+    "--reviewer",
+    default=None,
+    help="Comma-separated list of GitHub usernames to add as reviewers to new PRs "
+    "(overrides .ghstackrc setting)",
+)
+@click.option(
+    "--label",
+    default=None,
+    help="Comma-separated list of labels to add to new PRs "
+    "(overrides .ghstackrc setting)",
+)
 @click.option(
     "--direct/--no-direct",
     "direct_opt",
@@ -280,6 +399,8 @@ def submit(
     base: Optional[str],
     revs: Tuple[str, ...],
     stack: bool,
+    reviewer: Optional[str],
+    label: Optional[str],
 ) -> None:
     """
     Submit or update a PR stack
@@ -301,6 +422,8 @@ def submit(
             revs=revs,
             stack=stack,
             direct_opt=direct_opt,
+            reviewer=reviewer if reviewer is not None else config.reviewer,
+            label=label if label is not None else config.label,
         )
 
 

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/config.py

@@ -5,8 +5,10 @@ import getpass
 import logging
 import os
 import re
+import shutil
+import subprocess
 from pathlib import Path
-from typing import NamedTuple, Optional
+from typing import NamedTuple, Optional, Tuple
 
 import requests
 
@@ -15,6 +17,71 @@ import ghstack.logs
 DEFAULT_GHSTACKRC_PATH = Path.home() / ".ghstackrc"
 GHSTACKRC_PATH_VAR = "GHSTACKRC_PATH"
 
+
+def is_gh_cli_available() -> bool:
+    """Check if the GitHub CLI (gh) is available in PATH."""
+    return shutil.which("gh") is not None
+
+
+def get_gh_cli_credentials(
+    github_url: str = "github.com",
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """
+    Extract credentials from the GitHub CLI if available and authenticated.
+
+    Args:
+        github_url: The GitHub host to get credentials for.
+
+    Returns:
+        A tuple of (token, username, url) or (None, None, None) if unavailable.
+    """
+    if not is_gh_cli_available():
+        return None, None, None
+
+    try:
+        # Check if gh is authenticated for this host
+        auth_status = subprocess.run(
+            ["gh", "auth", "status", "-h", github_url],
+            capture_output=True,
+            text=True,
+        )
+        if auth_status.returncode != 0:
+            logging.debug(f"gh CLI not authenticated for {github_url}")
+            return None, None, None
+
+        # Get the token
+        token_result = subprocess.run(
+            ["gh", "auth", "token", "-h", github_url],
+            capture_output=True,
+            text=True,
+        )
+        if token_result.returncode != 0:
+            logging.debug("Failed to get token from gh CLI")
+            return None, None, None
+        token = token_result.stdout.strip()
+        if not token:
+            return None, None, None
+
+        # Get the username using gh api
+        username_result = subprocess.run(
+            ["gh", "api", "user", "-q", ".login", "--hostname", github_url],
+            capture_output=True,
+            text=True,
+        )
+        username = None
+        if username_result.returncode == 0:
+            username = username_result.stdout.strip()
+
+        logging.debug(
+            f"Successfully retrieved credentials from gh CLI for {github_url}"
+        )
+        return token, username, github_url
+
+    except Exception as e:
+        logging.debug(f"Error getting credentials from gh CLI: {e}")
+        return None, None, None
+
+
 Config = NamedTuple(
     "Config",
     [
@@ -40,6 +107,10 @@ Config = NamedTuple(
         ("github_url", str),
         # Name of the upstream remote
         ("remote_name", str),
+        # Default reviewers to add to new pull requests (comma-separated usernames)
+        ("reviewer", Optional[str]),
+        # Default labels to add to new pull requests (comma-separated labels)
+        ("label", Optional[str]),
     ],
 )
 
@@ -97,6 +168,7 @@ def read_config(
     # Environment variable overrides config file
     # This envvar is legacy from ghexport days
     github_oauth = os.getenv("OAUTH_TOKEN")
+    gh_cli_username = None  # Track username from gh CLI
     if github_oauth is not None:
         logging.warning(
             "Deprecated OAUTH_TOKEN environment variable used to populate github_oauth--"
@@ -105,6 +177,17 @@ def read_config(
         )
     if github_oauth is None and config.has_option("ghstack", "github_oauth"):
         github_oauth = config.get("ghstack", "github_oauth")
+
+    # Try GitHub CLI if available and no token found yet
+    if github_oauth is None and request_github_token:
+        gh_token, gh_username, _ = get_gh_cli_credentials(github_url)
+        if gh_token is not None:
+            print(f"Using GitHub credentials from gh CLI for {github_url}")
+            github_oauth = gh_token
+            gh_cli_username = gh_username
+            # Don't save gh CLI credentials to config - they may change/expire
+
+    # Fall back to device flow if still no token
     if github_oauth is None and request_github_token:
         print("Generating GitHub access token...")
         CLIENT_ID = "89cc88ca50efbe86907a"
@@ -150,6 +233,11 @@ def read_config(
     github_username = None
     if config.has_option("ghstack", "github_username"):
         github_username = config.get("ghstack", "github_username")
+    # Use username from gh CLI if we got it
+    if github_username is None and gh_cli_username is not None:
+        github_username = gh_cli_username
+        # Don't save gh CLI username to config - it comes from gh CLI
+    # Fall back to API lookup if we have a token but no username yet
     if github_username is None and github_oauth is not None:
         request_url: str
         if github_url == "github.com":
@@ -203,6 +291,16 @@ def read_config(
     else:
         remote_name = "origin"
 
+    if config.has_option("ghstack", "reviewer"):
+        reviewer = config.get("ghstack", "reviewer")
+    else:
+        reviewer = None
+
+    if config.has_option("ghstack", "label"):
+        label = config.get("ghstack", "label")
+    else:
+        label = None
+
     if write_back:
         with open(config_path, "w") as f:
             config.write(f)
@@ -218,6 +316,8 @@ def read_config(
         default_project_dir=default_project_dir,
         github_url=github_url,
         remote_name=remote_name,
+        reviewer=reviewer,
+        label=label,
     )
     logging.debug(f"conf = {conf}")
     return conf

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/github_fake.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+import dataclasses
 import os.path
 import re
 from dataclasses import dataclass
@@ -271,6 +272,8 @@ class PullRequest(Node):
     # state: PullRequestState
     title: str
     url: str
+    reviewers: List[str] = dataclasses.field(default_factory=list)
+    labels: List[str] = dataclasses.field(default_factory=list)
 
     def repository(self, info: GraphQLResolveInfo) -> Repository:
         return github_state(info).repositories[self._repository]
@@ -460,6 +463,24 @@ class FakeGitHubEndpoint(ghstack.github.GitHubEndpoint):
             if m:
                 # For now, pretend all branches are not protected
                 raise ghstack.github.NotFoundError()
+            if m := re.match(r"^repos/([^/]+)/([^/]+)/pulls/([^/]+)$", path):
+                state = self.state
+                repo = state.repository(m.group(1), m.group(2))
+                pr = state.pull_request(repo, GitHubNumber(int(m.group(3))))
+                return {
+                    "number": pr.number,
+                    "state": "closed" if pr.closed else "open",
+                    "title": pr.title,
+                    "body": pr.body,
+                }
+            if m := re.match(r"^repos/([^/]+)/([^/]+)/issues/comments/([^/]+)$", path):
+                state = self.state
+                repo = state.repository(m.group(1), m.group(2))
+                comment = state.issue_comment(repo, int(m.group(3)))
+                return {
+                    "id": comment.fullDatabaseId,
+                    "body": comment.body,
+                }
 
         elif method == "post":
             if m := re.match(r"^repos/([^/]+)/([^/]+)/pulls$", path):
@@ -473,6 +494,24 @@ class FakeGitHubEndpoint(ghstack.github.GitHubEndpoint):
                     GitHubNumber(int(m.group(3))),
                     cast(CreateIssueCommentInput, kwargs),
                 )
+            if m := re.match(
+                r"^repos/([^/]+)/([^/]+)/pulls/([^/]+)/requested_reviewers", path
+            ):
+                # Handle adding reviewers
+                state = self.state
+                repo = state.repository(m.group(1), m.group(2))
+                pr = state.pull_request(repo, GitHubNumber(int(m.group(3))))
+                reviewers = kwargs.get("reviewers", [])
+                pr.reviewers.extend(reviewers)
+                return {}
+            if m := re.match(r"^repos/([^/]+)/([^/]+)/issues/([^/]+)/labels", path):
+                # Handle adding labels
+                state = self.state
+                repo = state.repository(m.group(1), m.group(2))
+                pr = state.pull_request(repo, GitHubNumber(int(m.group(3))))
+                labels = kwargs.get("labels", [])
+                pr.labels.extend(labels)
+                return {}
         elif method == "patch":
             if m := re.match(r"^repos/([^/]+)/([^/]+)(?:/pulls/([^/]+))?$", path):
                 owner, name, number = m.groups()

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/github_utils.py

@@ -25,7 +25,9 @@ def get_github_repo_name_with_owner(
     remote_name: str,
 ) -> GitHubRepoNameWithOwner:
     # Grovel in remotes to figure it out
-    remote_url = sh.git("remote", "get-url", remote_name)
+    # Use --push to get the push URL, which is what matters for determining
+    # where commits will actually be pushed to
+    remote_url = sh.git("remote", "get-url", "--push", remote_name)
     while True:
         match = r"^git@{github_url}:/?([^/]+)/(.+?)(?:\.git)?$".format(
             github_url=github_url
@@ -138,20 +140,32 @@ GitHubPullRequestParams = TypedDict(
 )
 
 
+def _normalize_remote_url(remote_url: str) -> str:
+    """Convert SSH remote URL to HTTPS format, strip .git suffix."""
+    # git@github.com:owner/repo.git -> https://github.com/owner/repo
+    m = re.match(r"^git@([^:]+):/?(.+?)(?:\.git)?$", remote_url)
+    if m:
+        return f"https://{m.group(1)}/{m.group(2)}"
+    return re.sub(r"\.git$", "", remote_url)
+
+
 def parse_pull_request(
     pull_request: str,
     *,
     sh: Optional[ghstack.shell.Shell] = None,
     remote_name: Optional[str] = None,
 ) -> GitHubPullRequestParams:
+    pull_request = pull_request.lstrip("#")
     m = RE_PR_URL.match(pull_request)
     if not m:
         # We can reconstruct the URL if just a PR number is passed
         if sh is not None and remote_name is not None:
-            remote_url = sh.git("remote", "get-url", remote_name)
+            remote_url = sh.git("remote", "get-url", "--push", remote_name)
             # Do not pass the shell to avoid infinite loop
             try:
-                return parse_pull_request(remote_url + "/pull/" + pull_request)
+                return parse_pull_request(
+                    _normalize_remote_url(remote_url) + "/pull/" + pull_request
+                )
             except RuntimeError:
                 # Fall back on original error message
                 pass

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/land.py

@@ -145,13 +145,41 @@ to complain to the ghstack authors."""
             stack_orig_refs.append((ref, pr_resolved))
 
         # OK, actually do the land now
-        for orig_ref, _ in stack_orig_refs:
+        for orig_ref, pr_resolved in stack_orig_refs:
             try:
                 sh.git("cherry-pick", f"{remote_name}/{orig_ref}")
             except BaseException:
                 sh.git("cherry-pick", "--abort")
                 raise
 
+            # Add PR number to commit message like GitHub does
+            commit_msg = sh.git("log", "-1", "--pretty=%B")
+            # Get the original author and committer dates to preserve the commit hash
+            author_date = sh.git("log", "-1", "--pretty=%aD")
+            committer_date = sh.git("log", "-1", "--pretty=%cD")
+            lines = commit_msg.split("\n")
+            if lines:
+                # Add PR number to the subject line (first line)
+                subject = lines[0].rstrip()
+                # Only add if not already present
+                pr_tag = f"(#{pr_resolved.number})"
+                if pr_tag not in subject:
+                    subject = f"{subject} {pr_tag}"
+                lines[0] = subject
+                new_msg = "\n".join(lines)
+                # Preserve dates to keep the commit hash consistent
+                sh.git(
+                    "commit",
+                    "--amend",
+                    "-F",
+                    "-",
+                    input=new_msg,
+                    env={
+                        "GIT_AUTHOR_DATE": author_date,
+                        "GIT_COMMITTER_DATE": committer_date,
+                    },
+                )
+
         # All good! Push!
         maybe_force_arg = []
         if needs_force:

ghstack-0.15.0/src/ghstack/log.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+import subprocess
+import sys
+from typing import List, Optional, Tuple
+
+import ghstack.diff
+import ghstack.github
+import ghstack.github_utils
+import ghstack.shell
+
+
+def _resolve_refs(
+    *,
+    github: ghstack.github.GitHubEndpoint,
+    params: ghstack.github_utils.GitHubPullRequestParams,
+) -> Tuple[str, str]:
+    pr_result = github.graphql(
+        """
+        query ($owner: String!, $name: String!, $number: Int!) {
+            repository(name: $name, owner: $owner) {
+                pullRequest(number: $number) {
+                    headRefName
+                    baseRefName
+                }
+            }
+        }
+    """,
+        **params,
+    )
+    pr = pr_result["data"]["repository"]["pullRequest"]
+    return pr["headRefName"], pr["baseRefName"]
+
+
+def main(
+    github: ghstack.github.GitHubEndpoint,
+    sh: ghstack.shell.Shell,
+    remote_name: str,
+    github_url: str,
+    args: List[str],
+    pull_request: Optional[str] = None,
+) -> None:
+    if pull_request is not None:
+        # Explicit PR: fetch from remote and show what's there.  HEAD isn't
+        # involved; no synthesized pending-changes commit.
+        params = ghstack.github_utils.parse_pull_request(
+            pull_request, sh=sh, remote_name=remote_name
+        )
+        sh.git("fetch", "--prune", remote_name)
+        show_pending = False
+    else:
+        # Infer PR from HEAD's Pull-Request trailer; show the log relative
+        # to the local understanding of the remote state (no fetch).
+        commit_msg = sh.git("log", "-1", "--format=%B", "HEAD")
+        pr = ghstack.diff.PullRequestResolved.search(commit_msg, github_url)
+        if pr is None:
+            raise RuntimeError(
+                "HEAD commit is not associated with a ghstack pull request "
+                "(no Pull-Request trailer found). Check out the commit for the "
+                "PR you want to log, or pass the PR explicitly."
+            )
+        params = {
+            "github_url": pr.github_url,
+            "owner": pr.owner,
+            "name": pr.repo,
+            "number": pr.number,
+        }
+        show_pending = True
+
+    head_ref, base_ref = _resolve_refs(github=github, params=params)
+
+    remote_head = f"{remote_name}/{head_ref}"
+    remote_base = f"{remote_name}/{base_ref}"
+
+    tip = remote_head
+    if show_pending:
+        # If the local HEAD tree differs from the remote head tree, synthesize
+        # a disposable commit on top of the remote head so pending changes
+        # show up as the newest commit in `git log`.
+        local_tree = sh.git("rev-parse", "HEAD^{tree}")
+        remote_tree = sh.git("rev-parse", f"{remote_head}^{{tree}}")
+        if local_tree != remote_tree:
+            tip = sh.git(
+                "commit-tree",
+                local_tree,
+                "-p",
+                remote_head,
+                input="Local pending changes (not yet submitted)\n",
+            )
+
+    # ^remote_base restricts the walk to the head chain (each head commit is a
+    # merge of the previous head and a base-update commit; excluding everything
+    # reachable from the base ref drops the base-update side).
+    #
+    # --diff-merges=remerge replays the merge and diffs the stored tree
+    # against the auto-merge result, which for ghstack isolates just the
+    # user's code edits from the base-update changes that got folded in.
+    # This only affects merge commits (non-merges still need -p).  Requires
+    # git 2.35+.  Users who prefer a portable alternative can pass
+    # --diff-merges=cc to override.
+    log_args = ["--diff-merges=remerge", tip]
+    if sh.git("rev-parse", "--verify", "--quiet", remote_base, exitcode=True):
+        log_args.append(f"^{remote_base}")
+    log_args.extend(args)
+
+    if sys.stdout.isatty():
+        # Let git manage its own pager.
+        subprocess.run(["git", "log", *log_args], cwd=sh.cwd, check=False)
+    else:
+        # In test/piped contexts, capture and write to sys.stdout so the
+        # caller can intercept it.
+        out = sh.git("log", *log_args)
+        if out:
+            sys.stdout.write(out)
+            if not out.endswith("\n"):
+                sys.stdout.write("\n")

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/submit.py

@@ -90,6 +90,7 @@ class PreBranchState:
 
 # Ya, sometimes we get carriage returns.  Crazy right?
 RE_STACK = re.compile(r"Stack.*:\r?\n(\* [^\r\n]+\r?\n)+")
+RE_STACK_PR_NUMBER = re.compile(r"#(\d+)")
 
 
 # NB: This regex is fuzzy because the D1234567 identifier is typically
@@ -343,6 +344,12 @@ class Submitter:
     # merged.  If None, infer whether or not the PR should be direct or not.
     direct_opt: Optional[bool] = None
 
+    # Default reviewers to add to new pull requests (comma-separated usernames)
+    reviewer: Optional[str] = None
+
+    # Default labels to add to new pull requests (comma-separated labels)
+    label: Optional[str] = None
+
     # ~~~~~~~~~~~~~~~~~~~~~~~~
     # Computed in post init
 
@@ -481,18 +488,20 @@ class Submitter:
                 d = ghstack.git.convert_header(h, self.github_url)
                 if d.pull_request_resolved is not None:
                     ed = self.elaborate_diff(d)
-                    pre_branch_state_index[h.commit_id] = PreBranchState(
-                        head_commit_id=GitCommitHash(
-                            self.sh.git(
-                                "rev-parse", f"{self.remote_name}/{ed.head_ref}"
-                            )
-                        ),
-                        base_commit_id=GitCommitHash(
-                            self.sh.git(
-                                "rev-parse", f"{self.remote_name}/{ed.base_ref}"
-                            )
-                        ),
-                    )
+                    # Skip closed PRs (e.g., after landing) where branches have been deleted
+                    if not ed.closed:
+                        pre_branch_state_index[h.commit_id] = PreBranchState(
+                            head_commit_id=GitCommitHash(
+                                self.sh.git(
+                                    "rev-parse", f"{self.remote_name}/{ed.head_ref}"
+                                )
+                            ),
+                            base_commit_id=GitCommitHash(
+                                self.sh.git(
+                                    "rev-parse", f"{self.remote_name}/{ed.base_ref}"
+                                )
+                            ),
+                        )
 
         # NB: deduplicates
         commit_index = {
@@ -510,7 +519,12 @@ class Submitter:
             for h in commits_to_submit
             if h.commit_id in diff_meta_index
         ]
-        self.push_updates(diffs_to_submit)
+        all_diffs_in_topo_order = [
+            diff_meta_index[h.commit_id]
+            for h in commits_to_rebase
+            if h.commit_id in diff_meta_index
+        ]
+        self.push_updates(diffs_to_submit, all_diffs=all_diffs_in_topo_order)
         if new_head := rebase_index.get(
             old_head := GitCommitHash(self.sh.git("rev-parse", "HEAD"))
         ):
@@ -864,21 +878,24 @@ to disassociate the commit with the pull request, and then try again.
                 "--header",
                 self.remote_name + "/" + branch_orig(username, gh_number),
             )
-        except RuntimeError as e:
+        except RuntimeError:
             if r["closed"]:
-                raise RuntimeError(
-                    f"Cannot ghstack a stack with closed PR #{number} whose branch was deleted.  "
-                    "If you were just trying to update a later PR in the stack, `git rebase` and try again.  "
-                    "Otherwise, you may have been trying to update a PR that was already closed. "
-                    "To disassociate your update from the old PR and open a new PR, "
-                    "run `ghstack unlink`, `git rebase` and then try again."
-                ) from e
-            raise
-        remote_summary = ghstack.git.split_header(rev_list)[0]
-        m_remote_source_id = RE_GHSTACK_SOURCE_ID.search(remote_summary.commit_msg)
-        remote_source_id = m_remote_source_id.group(1) if m_remote_source_id else None
-        m_comment_id = RE_GHSTACK_COMMENT_ID.search(remote_summary.commit_msg)
-        comment_id = int(m_comment_id.group(1)) if m_comment_id else None
+                # If the PR is closed and the branch is deleted (e.g., after landing),
+                # we can't get the remote source ID. Return None for it, which will
+                # signal to process_commit that this commit has been landed and should
+                # be skipped (not updated).
+                remote_source_id = None
+                comment_id = None
+            else:
+                raise
+        else:
+            remote_summary = ghstack.git.split_header(rev_list)[0]
+            m_remote_source_id = RE_GHSTACK_SOURCE_ID.search(remote_summary.commit_msg)
+            remote_source_id = (
+                m_remote_source_id.group(1) if m_remote_source_id else None
+            )
+            m_comment_id = RE_GHSTACK_COMMENT_ID.search(remote_summary.commit_msg)
+            comment_id = int(m_comment_id.group(1)) if m_comment_id else None
 
         return DiffWithGitHubMetadata(
             diff=diff,
@@ -911,6 +928,48 @@ to disassociate the commit with the pull request, and then try again.
         if elab_diff is not None and elab_diff.closed:
             if self.direct:
                 self._raise_needs_rebase()
+            # If we're trying to submit a closed commit, check if it has been modified
+            if elab_diff.remote_source_id is None:
+                # The branch was deleted (e.g., after landing). Check if the commit has been
+                # modified by comparing source_ids. If the commit is reachable from master with
+                # the same source_id (tree hash), it means it was landed and we should skip it.
+                # Otherwise, it's been modified and we should raise an error.
+                try:
+                    # Check if there's a commit on master with the same tree (source_id)
+                    master_commits = self.sh.git(
+                        "log",
+                        "--format=%H %T",
+                        f"{self.remote_name}/{self.base}",
+                        "-n",
+                        "100",  # Check last 100 commits
+                    )
+                    for line in master_commits.split("\n"):
+                        if not line.strip():
+                            continue
+                        commit_hash, tree_hash = line.split()
+                        if tree_hash == diff.source_id:
+                            # Found a commit on master with the same tree, so this commit
+                            # was landed (just with a different commit message/hash)
+                            return None
+                except Exception:
+                    pass
+                # Didn't find a matching commit on master, so this is a modified closed commit
+                raise RuntimeError(
+                    f"Cannot ghstack a stack with closed PR #{elab_diff.number} whose branch was deleted.  "
+                    "If you were just trying to update a later PR in the stack, `git rebase` and try again.  "
+                    "Otherwise, you may have been trying to update a PR that was already closed. "
+                    "To disassociate your update from the old PR and open a new PR, "
+                    "run `ghstack unlink`, `git rebase` and then try again."
+                )
+            elif diff.source_id != elab_diff.remote_source_id:
+                # The commit has been modified locally
+                raise RuntimeError(
+                    f"Cannot ghstack a stack with closed PR #{elab_diff.number} whose branch was deleted.  "
+                    "If you were just trying to update a later PR in the stack, `git rebase` and try again.  "
+                    "Otherwise, you may have been trying to update a PR that was already closed. "
+                    "To disassociate your update from the old PR and open a new PR, "
+                    "run `ghstack unlink`, `git rebase` and then try again."
+                )
             return None
 
         # Edge case: check if the commit is empty; if so skip submitting
@@ -1434,6 +1493,32 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
             )
             comment_id = rc["id"]
 
+        # Add reviewers if specified
+        if self.reviewer:
+            reviewers = [r.strip() for r in self.reviewer.split(",") if r.strip()]
+            if reviewers:
+                try:
+                    self.github.post(
+                        f"repos/{self.repo_owner}/{self.repo_name}/pulls/{number}/requested_reviewers",
+                        reviewers=reviewers,
+                    )
+                    logging.info(f"Added reviewers: {', '.join(reviewers)}")
+                except Exception as e:
+                    logging.warning(f"Failed to add reviewers: {e}")
+
+        # Add labels if specified
+        if self.label:
+            labels = [label.strip() for label in self.label.split(",") if label.strip()]
+            if labels:
+                try:
+                    self.github.post(
+                        f"repos/{self.repo_owner}/{self.repo_name}/issues/{number}/labels",
+                        labels=labels,
+                    )
+                    logging.info(f"Added labels: {', '.join(labels)}")
+                except Exception as e:
+                    logging.warning(f"Failed to add labels: {e}")
+
         logging.info("Opened PR #{}".format(number))
 
         pull_request_resolved = ghstack.diff.PullRequestResolved(
@@ -1459,7 +1544,11 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
         )
 
     def push_updates(
-        self, diffs_to_submit: List[DiffMeta], *, import_help: bool = True
+        self,
+        diffs_to_submit: List[DiffMeta],
+        *,
+        all_diffs: Optional[List[DiffMeta]] = None,
+        import_help: bool = True,
     ) -> None:
         # update pull request information, update bases as necessary
         #   preferably do this in one network call
@@ -1492,6 +1581,46 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
         if force_push_branches:
             self._git_push(force_push_branches, force=True)
 
+        # Discover orphan PR numbers from the old stack listing.
+        # We search the full local stack for old stack text, then
+        # collect open PRs that aren't being submitted — both above
+        # and below the submitted ones.  Closed PRs are filtered out.
+        submitted_numbers = {s.number for s in diffs_to_submit}
+        orphan_above: List[GitHubNumber] = []
+        orphan_below: List[GitHubNumber] = []
+        for s in all_diffs or diffs_to_submit:
+            old_stack_text: Optional[str] = None
+            if self.direct and s.elab_diff.comment_id is not None:
+                r = self.github.get(
+                    f"repos/{self.repo_owner}/{self.repo_name}/issues/comments/{s.elab_diff.comment_id}",
+                )
+                old_stack_text = r.get("body")
+            else:
+                m = RE_STACK.search(s.body)
+                if m:
+                    old_stack_text = m.group(0)
+            if old_stack_text:
+                old_pr_numbers = [
+                    GitHubNumber(int(n))
+                    for n in RE_STACK_PR_NUMBER.findall(old_stack_text)
+                ]
+                if not old_pr_numbers:
+                    continue
+                seen_submitted = False
+                for num in old_pr_numbers:
+                    if num in submitted_numbers:
+                        seen_submitted = True
+                        continue
+                    pr_info = self.github.get(
+                        f"repos/{self.repo_owner}/{self.repo_name}/pulls/{num}",
+                    )
+                    if pr_info.get("state") == "open":
+                        if seen_submitted:
+                            orphan_below.append(num)
+                        else:
+                            orphan_above.append(num)
+                break
+
         for s in reversed(diffs_to_submit):
             # NB: GraphQL API does not support modifying PRs
             assert not s.closed
@@ -1509,7 +1638,9 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
                 base_kwargs["base"] = s.base
             else:
                 assert s.base == s.elab_diff.base_ref
-            stack_desc = self._format_stack(diffs_to_submit, s.number)
+            stack_desc = self._format_stack(
+                diffs_to_submit, s.number, orphan_above, orphan_below
+            )
             self.github.patch(
                 "repos/{owner}/{repo}/pulls/{number}".format(
                     owner=self.repo_owner, repo=self.repo_name, number=s.number
@@ -1729,14 +1860,24 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
     # - want "as complete" a tree as possible; this may involve
     #   poking around the xrefs to find out all the other PRs
     #   involved in the stack
-    def _format_stack(self, diffs_to_submit: List[DiffMeta], number: int) -> str:
+    def _format_stack(
+        self,
+        diffs_to_submit: List[DiffMeta],
+        number: int,
+        orphan_above: Sequence[GitHubNumber] = (),
+        orphan_below: Sequence[GitHubNumber] = (),
+    ) -> str:
         rows = []
+        for n in orphan_above:
+            rows.append(f"* #{n}")
         # NB: top is top of stack, opposite of update order
         for s in diffs_to_submit:
             if s.number == number:
                 rows.append(f"* __->__ #{s.number}")
             else:
                 rows.append(f"* #{s.number}")
+        for n in orphan_below:
+            rows.append(f"* #{n}")
         return self.stack_header + ":\n" + "\n".join(rows) + "\n"
 
     def _default_title_and_body(

{ghstack-0.13.0 → ghstack-0.15.0}/src/ghstack/test_prelude.py

@@ -8,16 +8,18 @@ import shutil
 import stat
 import sys
 import tempfile
-from typing import Any, Callable, Iterator, List, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, Iterator, List, Optional, Sequence, Tuple, Type, Union
 
 from expecttest import assert_expected_inline
 
+import ghstack.checkout
 import ghstack.cherry_pick
 
 import ghstack.github
 import ghstack.github_fake
 import ghstack.github_utils
 import ghstack.land
+import ghstack.log
 import ghstack.shell
 import ghstack.submit
 import ghstack.unlink
@@ -32,6 +34,8 @@ __all__ = [
     "gh_land",
     "gh_unlink",
     "gh_cherry_pick",
+    "gh_checkout",
+    "gh_log",
     "GitCommitHash",
     "checkout",
     "amend",
@@ -49,6 +53,8 @@ __all__ = [
     "get_sh",
     "get_upstream_sh",
     "get_github",
+    "get_pr_reviewers",
+    "get_pr_labels",
     "tick",
     "captured_output",
 ]
@@ -192,6 +198,8 @@ def gh_submit(
     base: Optional[str] = None,
     revs: Sequence[str] = (),
     stack: bool = True,
+    reviewer: Optional[str] = None,
+    label: Optional[str] = None,
 ) -> List[ghstack.submit.DiffMeta]:
     self = CTX
     r = ghstack.submit.main(
@@ -212,6 +220,8 @@ def gh_submit(
         revs=revs,
         stack=stack,
         check_invariants=True,
+        reviewer=reviewer,
+        label=label,
     )
     self.check_global_github_invariants(self.direct)
     return r
@@ -251,6 +261,29 @@ def gh_cherry_pick(pull_request: str, stack: bool = False) -> None:
     )
 
 
+def gh_checkout(pull_request: str, same_base: bool = False) -> None:
+    self = CTX
+    return ghstack.checkout.main(
+        pull_request=pull_request,
+        github=self.github,
+        sh=self.sh,
+        remote_name="origin",
+        same_base=same_base,
+    )
+
+
+def gh_log(pull_request: Optional[str] = None, args: Sequence[str] = ()) -> None:
+    self = CTX
+    return ghstack.log.main(
+        github=self.github,
+        sh=self.sh,
+        remote_name="origin",
+        github_url="github.com",
+        args=list(args),
+        pull_request=pull_request,
+    )
+
+
 def write_file_and_add(filename: str, contents: str) -> None:
     self = CTX
     with self.sh.open(filename, "w") as f:
@@ -373,13 +406,38 @@ def is_direct() -> bool:
     return CTX.direct
 
 
+def get_github() -> "ghstack.github_fake.FakeGitHubEndpoint":
+    github = CTX.github
+    assert isinstance(github, ghstack.github_fake.FakeGitHubEndpoint)
+    return github
+
+
+def get_pr_reviewers(pr_number: int) -> List[str]:
+    """Get the reviewers for a PR number."""
+    github = get_github()
+    repo = github.state.repository("pytorch", "pytorch")
+    pr = github.state.pull_request(repo, ghstack.github_fake.GitHubNumber(pr_number))
+    return pr.reviewers
+
+
+def get_pr_labels(pr_number: int) -> List[str]:
+    """Get the labels for a PR number."""
+    github = get_github()
+    repo = github.state.repository("pytorch", "pytorch")
+    pr = github.state.pull_request(repo, ghstack.github_fake.GitHubNumber(pr_number))
+    return pr.labels
+
+
 def assert_eq(a: Any, b: Any) -> None:
     assert a == b, f"{a} != {b}"
 
 
 def assert_raises(
-    exc_type: any, callable: Callable[..., any], *args: any, **kwargs: any
-):
+    exc_type: Type[BaseException],
+    callable: Callable[..., Any],
+    *args: Any,
+    **kwargs: Any,
+) -> None:
     try:
         callable(*args, **kwargs)
     except exc_type:
@@ -388,8 +446,12 @@ def assert_raises(
 
 
 def assert_expected_raises_inline(
-    exc_type: any, callable: Callable[..., any], expect: str, *args: any, **kwargs: any
-):
+    exc_type: Type[BaseException],
+    callable: Callable[..., Any],
+    expect: str,
+    *args: Any,
+    **kwargs: Any,
+) -> None:
     try:
         callable(*args, **kwargs)
     except exc_type as e:
@@ -406,9 +468,5 @@ def get_upstream_sh() -> ghstack.shell.Shell:
     return CTX.upstream_sh
 
 
-def get_github() -> ghstack.github.GitHubEndpoint:
-    return CTX.github
-
-
 def tick() -> None:
     CTX.sh.test_tick()

ghstack-0.13.0/src/ghstack/checkout.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-
-import logging
-import re
-
-import ghstack.github
-import ghstack.github_utils
-import ghstack.shell
-
-
-def main(
-    pull_request: str,
-    github: ghstack.github.GitHubEndpoint,
-    sh: ghstack.shell.Shell,
-    remote_name: str,
-) -> None:
-
-    params = ghstack.github_utils.parse_pull_request(
-        pull_request, sh=sh, remote_name=remote_name
-    )
-    head_ref = github.get_head_ref(**params)
-    orig_ref = re.sub(r"/head$", "/orig", head_ref)
-    if orig_ref == head_ref:
-        logging.warning(
-            "The ref {} doesn't look like a ghstack reference".format(head_ref)
-        )
-
-    # TODO: Handle remotes correctly too (so this subsumes hub)
-
-    sh.git("fetch", "--prune", remote_name)
-    sh.git("checkout", remote_name + "/" + orig_ref)