ghstack 0.14.0__tar.gz → 0.16.0__tar.gz

{ghstack-0.14.0 → ghstack-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ghstack
-Version: 0.14.0
+Version: 0.16.0
 Summary: Stack diff support for GitHub
 Author: Edward Z. Yang
 Author-email: Edward Z. Yang <ezyang@mit.edu>
@@ -28,7 +28,7 @@ uv tool install ghstack
 ```
 
 ghstack is tested with 
-[several different Python versions](https://github.com/ezyang/ghstack/blob/master/.github/workflows/test.yml#L13). 
+[several different Python versions](https://github.com/ezyang/ghstack/blob/main/.github/workflows/test.yml#L13). 
 It requires at least Python 3.9.1.
 
 ## How to setup
@@ -43,13 +43,30 @@ github_url = github.com
 github_oauth = [your_own_token]
 github_username = [your_username]
 remote_name = upstream [if remote is called upstream and not origin]
+automsg = claude [optional; also supports codex]
 ```
 
+You can toggle generated change descriptions with:
+
+```
+ghstack config automsg claude
+ghstack config automsg codex
+ghstack config automsg codex --model gpt-5.4
+ghstack config --unset automsg
+```
+
+If `automsg` is set to `claude` or `codex`, ghstack writes
+PR context (the local commit message and current PR description) to a temporary
+file and invokes the agent with a prompt to summarize the specific update.  The
+patch update itself is included directly in the prompt.  For existing PRs the
+patch update is an interdiff against the previously submitted PR patch, not the
+whole PR patch.  Explicit `ghstack -m MESSAGE` still overrides this.
+
 ## How to use
 
 Make sure you have write permission to the repo you're opening PR with.
 
-Prepare a series of commits on top of master, then run `ghstack`.  This
+Prepare a series of commits on top of main, then run `ghstack`.  This
 tool will push and create pull requests for each commit on the stack.
 
 **How do I stack another PR on top of an existing one?** Assuming
@@ -61,17 +78,22 @@ run `ghstack` again.  If the commit is at the top of your stack,
 you can edit it with `git commit --amend`; otherwise, you'll have
 to use `git rebase -i` to edit the commit directly.
 
-**How do I rebase?**  The obvious way: `git rebase origin/master`.
+**How do I rebase?**  The obvious way: `git rebase origin/main`.
 Don't do a `git merge`; `ghstack` will throw a hissy fit if you
 do that.  (There's also a more fundamental reason why this
 won't work: since each commit is a separate PR, you have to
 resolve conflicts in *each* PR, not just for the entire stack.)
 
-**How do I start a new feature?**  Just checkout master on a new
+**What if the repository default branch changed?**  ghstack caches
+repository metadata in `.git/ghstack-repo-info.json` for the local
+checkout.  If ghstack is still using an old default branch name,
+delete that file and rerun ghstack; it will query GitHub again.
+
+**How do I start a new feature?**  Just checkout main on a new
 branch, and start working on a fresh branch.
 
 **How do I merge my changes?**  Warning: You will NOT be able to merge these 
-commits using the normal GitHub UI, as their branch bases won't be master.  
+commits using the normal GitHub UI, as their branch bases won't be main.
 Use `ghstack land $PR_URL` (or alternatively `ghstack land #PR_NUM`) to land
 a ghstack'ed pull request.
 
@@ -84,10 +106,10 @@ is an end-to-end example of how to do this.
 Every commit in your local commit stack gets submitted into a separate
 pull request and pushes commits onto three branches:
 
-* `gh/username/1/base` - think of this like "master": it's the base
+* `gh/username/1/base` - think of this like "main": it's the base
   branch that your commit was based upon.  It is never force pushed;
   whenever you rebase your local stack, we add merge commits on top of
-  base from the true upstream master.
+  base from the true upstream main.
 
 * `gh/username/1/head` - this branch is your change, on top of the base
   branch.  Like base, it is never force pushed.  We open a pull request

{ghstack-0.14.0 → ghstack-0.16.0}/README.md

@@ -7,7 +7,7 @@ uv tool install ghstack
 ```
 
 ghstack is tested with 
-[several different Python versions](https://github.com/ezyang/ghstack/blob/master/.github/workflows/test.yml#L13). 
+[several different Python versions](https://github.com/ezyang/ghstack/blob/main/.github/workflows/test.yml#L13). 
 It requires at least Python 3.9.1.
 
 ## How to setup
@@ -22,13 +22,30 @@ github_url = github.com
 github_oauth = [your_own_token]
 github_username = [your_username]
 remote_name = upstream [if remote is called upstream and not origin]
+automsg = claude [optional; also supports codex]
 ```
 
+You can toggle generated change descriptions with:
+
+```
+ghstack config automsg claude
+ghstack config automsg codex
+ghstack config automsg codex --model gpt-5.4
+ghstack config --unset automsg
+```
+
+If `automsg` is set to `claude` or `codex`, ghstack writes
+PR context (the local commit message and current PR description) to a temporary
+file and invokes the agent with a prompt to summarize the specific update.  The
+patch update itself is included directly in the prompt.  For existing PRs the
+patch update is an interdiff against the previously submitted PR patch, not the
+whole PR patch.  Explicit `ghstack -m MESSAGE` still overrides this.
+
 ## How to use
 
 Make sure you have write permission to the repo you're opening PR with.
 
-Prepare a series of commits on top of master, then run `ghstack`.  This
+Prepare a series of commits on top of main, then run `ghstack`.  This
 tool will push and create pull requests for each commit on the stack.
 
 **How do I stack another PR on top of an existing one?** Assuming
@@ -40,17 +57,22 @@ run `ghstack` again.  If the commit is at the top of your stack,
 you can edit it with `git commit --amend`; otherwise, you'll have
 to use `git rebase -i` to edit the commit directly.
 
-**How do I rebase?**  The obvious way: `git rebase origin/master`.
+**How do I rebase?**  The obvious way: `git rebase origin/main`.
 Don't do a `git merge`; `ghstack` will throw a hissy fit if you
 do that.  (There's also a more fundamental reason why this
 won't work: since each commit is a separate PR, you have to
 resolve conflicts in *each* PR, not just for the entire stack.)
 
-**How do I start a new feature?**  Just checkout master on a new
+**What if the repository default branch changed?**  ghstack caches
+repository metadata in `.git/ghstack-repo-info.json` for the local
+checkout.  If ghstack is still using an old default branch name,
+delete that file and rerun ghstack; it will query GitHub again.
+
+**How do I start a new feature?**  Just checkout main on a new
 branch, and start working on a fresh branch.
 
 **How do I merge my changes?**  Warning: You will NOT be able to merge these 
-commits using the normal GitHub UI, as their branch bases won't be master.  
+commits using the normal GitHub UI, as their branch bases won't be main.
 Use `ghstack land $PR_URL` (or alternatively `ghstack land #PR_NUM`) to land
 a ghstack'ed pull request.
 
@@ -63,10 +85,10 @@ is an end-to-end example of how to do this.
 Every commit in your local commit stack gets submitted into a separate
 pull request and pushes commits onto three branches:
 
-* `gh/username/1/base` - think of this like "master": it's the base
+* `gh/username/1/base` - think of this like "main": it's the base
   branch that your commit was based upon.  It is never force pushed;
   whenever you rebase your local stack, we add merge commits on top of
-  base from the true upstream master.
+  base from the true upstream main.
 
 * `gh/username/1/head` - this branch is your change, on top of the base
   branch.  Like base, it is never force pushed.  We open a pull request

{ghstack-0.14.0 → ghstack-0.16.0}/pyproject.toml

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

{ghstack-0.14.0 → ghstack-0.16.0}/src/ghstack/action.py

@@ -8,15 +8,15 @@ import ghstack.github_utils
 import ghstack.shell
 
 
-def main(
+async def main(
     pull_request: str,
     github: ghstack.github.GitHubEndpoint,
     sh: Optional[ghstack.shell.Shell] = None,
     close: bool = False,
 ) -> None:
 
-    params = ghstack.github_utils.parse_pull_request(pull_request)
-    pr_result = github.graphql(
+    params = await ghstack.github_utils.parse_pull_request(pull_request)
+    pr_result = await github.graphql(
         """
         query ($owner: String!, $name: String!, $number: Int!) {
             repository(name: $name, owner: $owner) {
@@ -32,7 +32,7 @@ def main(
 
     if close:
         logging.info("Closing {owner}/{name}#{number}".format(**params))
-        github.graphql(
+        await github.graphql(
             """
             mutation ($input: ClosePullRequestInput!) {
                 closePullRequest(input: $input) {

ghstack-0.16.0/src/ghstack/async_script.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+import argparse
+import ast
+import asyncio
+import inspect
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence
+
+
+async def run_path(
+    path: str,
+    *,
+    argv: Optional[Sequence[str]] = None,
+    globals_: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    script_path = str(Path(path))
+    script_argv = [script_path, *(argv or ())]
+    old_argv = sys.argv
+    sys.argv = script_argv
+    try:
+        source = Path(script_path).read_text()
+        namespace: Dict[str, Any] = {
+            "__file__": script_path,
+            "__name__": "__main__",
+            "__package__": None,
+            "__builtins__": __builtins__,
+        }
+        if globals_ is not None:
+            namespace.update(globals_)
+        code = compile(
+            source,
+            script_path,
+            "exec",
+            flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT,
+        )
+        result = eval(code, namespace)
+        if inspect.isawaitable(result):
+            await result
+        return namespace
+    finally:
+        sys.argv = old_argv
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    parser = argparse.ArgumentParser(
+        description="Run a Python script with top-level await support."
+    )
+    parser.add_argument("script")
+    parser.add_argument("args", nargs=argparse.REMAINDER)
+    ns = parser.parse_args(argv)
+    asyncio.run(run_path(ns.script, argv=ns.args))
+
+
+if __name__ == "__main__":
+    main()

ghstack-0.16.0/src/ghstack/checkout.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+
+import asyncio
+import logging
+import re
+from typing import Iterable
+
+import ghstack.github
+import ghstack.github_utils
+import ghstack.shell
+
+
+async def _fetch_refs(
+    sh: ghstack.shell.Shell, *, remote_name: str, refs: Iterable[str]
+) -> None:
+    refspecs = [
+        f"+refs/heads/{ref}:refs/remotes/{remote_name}/{ref}"
+        for ref in sorted(set(refs))
+    ]
+    await sh.agit("fetch", "--prune", remote_name, *refspecs)
+
+
+async def main(
+    pull_request: str,
+    github: ghstack.github.GitHubEndpoint,
+    sh: ghstack.shell.Shell,
+    remote_name: str,
+    same_base: bool = False,
+) -> None:
+
+    params = await ghstack.github_utils.parse_pull_request(
+        pull_request, sh=sh, remote_name=remote_name
+    )
+    head_ref_task = asyncio.ensure_future(github.get_head_ref(**params))
+
+    if same_base:
+        repo_info_task = asyncio.ensure_future(
+            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,
+            )
+        )
+        head_ref, repo_info = await asyncio.gather(head_ref_task, repo_info_task)
+    else:
+        head_ref = await head_ref_task
+        repo_info = None
+
+    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; "
+            "delegating to gh pr checkout".format(head_ref)
+        )
+        await sh.ash("gh", "pr", "checkout", pull_request.lstrip("#"))
+        return
+
+    # 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:
+        assert repo_info is not None
+        default_branch = repo_info["default_branch"]
+        default_branch_ref = f"{remote_name}/{default_branch}"
+
+        # Get current merge-base with default branch
+        current_base = await sh.agit("merge-base", default_branch_ref, "HEAD")
+    else:
+        current_base = None
+        default_branch_ref = None
+
+    refs_to_fetch = [orig_ref]
+    if same_base:
+        assert repo_info is not None
+        refs_to_fetch.append(repo_info["default_branch"])
+    await _fetch_refs(sh, remote_name=remote_name, refs=refs_to_fetch)
+
+    # 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 = await sh.agit("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"
+            )
+
+    await sh.agit("checkout", remote_name + "/" + orig_ref)

{ghstack-0.14.0 → ghstack-0.16.0}/src/ghstack/cherry_pick.py

@@ -8,32 +8,34 @@ import ghstack.github_utils
 import ghstack.shell
 
 
-def main(
+async def main(
     pull_request: str,
     github: ghstack.github.GitHubEndpoint,
     sh: ghstack.shell.Shell,
     remote_name: str,
     stack: bool = False,
+    no_fetch: bool = False,
 ) -> None:
 
-    params = ghstack.github_utils.parse_pull_request(
+    params = await ghstack.github_utils.parse_pull_request(
         pull_request, sh=sh, remote_name=remote_name
     )
-    head_ref = github.get_head_ref(**params)
+    head_ref = await 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)
         )
 
-    sh.git("fetch", "--prune", remote_name)
+    if not no_fetch:
+        await sh.agit("fetch", "--prune", remote_name)
 
     if stack:
         # Cherry-pick the entire stack from merge-base to the commit
         remote_orig_ref = remote_name + "/" + orig_ref
 
         # Find the merge-base with the main branch
-        repo_info = ghstack.github_utils.get_github_repo_info(
+        repo_info = await ghstack.github_utils.get_github_repo_info(
             github=github,
             sh=sh,
             github_url=params["github_url"],
@@ -42,11 +44,11 @@ def main(
         main_branch = f"{remote_name}/{repo_info['default_branch']}"
 
         # Get merge-base between the commit and main branch
-        merge_base = sh.git("merge-base", main_branch, remote_orig_ref).strip()
+        merge_base = (await sh.agit("merge-base", main_branch, remote_orig_ref)).strip()
 
         # Get all commits from merge-base to the target commit
         commit_list = (
-            sh.git("rev-list", "--reverse", f"{merge_base}..{remote_orig_ref}")
+            (await sh.agit("rev-list", "--reverse", f"{merge_base}..{remote_orig_ref}"))
             .strip()
             .split("\n")
         )
@@ -56,10 +58,10 @@ def main(
 
         logging.info(f"Cherry-picking {len(commit_list)} commits from stack")
         for commit in commit_list:
-            sh.git("cherry-pick", commit)
+            await sh.agit("cherry-pick", commit)
             logging.info(f"Cherry-picked {commit}")
     else:
         # Cherry-pick just the single commit
         remote_orig_ref = remote_name + "/" + orig_ref
-        sh.git("cherry-pick", remote_orig_ref)
+        await sh.agit("cherry-pick", remote_orig_ref)
         logging.info(f"Cherry-picked {orig_ref}")