mergify-cli 0.1.1__tar.gz

mergify_cli-0.1.1/LICENSE

@@ -0,0 +1,176 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+

mergify_cli-0.1.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: mergify-cli
+Version: 0.1.1
+Summary: 
+Author: Mehdi Abaakouk
+Author-email: sileht@mergify.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: httpx (>=0.20.0)
+Requires-Dist: rich (>=10.11.0)

mergify_cli-0.1.1/mergify_cli/__init__.py

@@ -0,0 +1,651 @@
+#
+#  Copyright © 2021 Mergify SAS
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+
+import argparse
+import asyncio
+import importlib.metadata
+import os
+import re
+import shutil
+import subprocess
+import sys
+import typing
+from urllib import parse
+
+import httpx
+import rich
+import rich.console
+
+
+try:
+    VERSION = importlib.metadata.version("mrgfy")
+except ImportError:
+    # https://pyoxidizer.readthedocs.io/en/stable/oxidized_importer_behavior_and_compliance.html#importlib-metadata-compatibility
+    VERSION = "0.1"
+
+CHANGEID_RE = re.compile(r"Change-Id: (I[0-9a-z]{40})")
+READY_FOR_REVIEW_TEMPLATE = 'mutation { markPullRequestReadyForReview(input: { pullRequestId: "%s" }) { clientMutationId } }'
+DRAFT_TEMPLATE = 'mutation { convertPullRequestToDraft(input: { pullRequestId: "%s" }) { clientMutationId } }'
+console = rich.console.Console(log_path=False, log_time=False)
+
+DEBUG = False
+DRAFT = False
+
+
+def check_for_graphql_errors(response: httpx.Response) -> None:
+    data = response.json()
+    if "errors" in data:
+        console.print(f"url: {response.request.url}", style="red")
+        console.print(f"data: {response.request.content.decode()}", style="red")
+        if "errors" in data:
+            console.print(
+                "\n".join(f"* {e.get('message') or e}" for e in data["errors"]),
+                style="red",
+            )
+        sys.exit(1)
+
+
+def check_for_status(response: httpx.Response) -> None:
+    if response.status_code < 400:
+        return
+
+    if response.status_code < 500:
+        data = response.json()
+        console.print(f"url: {response.request.url}", style="red")
+        console.print(f"data: {response.request.content.decode()}", style="red")
+        console.print(
+            f"HTTPError {response.status_code}: {data['message']}", style="red"
+        )
+        if "errors" in data:
+            console.print(
+                "\n".join(f"* {e.get('message') or e}" for e in data["errors"]),
+                style="red",
+            )
+        sys.exit(1)
+
+    response.raise_for_status()
+
+
+async def git(args: str) -> str:
+    if DEBUG:
+        console.print(f"[purple]DEBUG: running: git {args} [/]")
+    proc = await asyncio.create_subprocess_shell(
+        f"git {args}",
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    stdout, _ = await proc.communicate()
+    if proc.returncode != 0:
+        console.log(f"fail to run `git {args}`:", style="red")
+        console.log(f"{stdout.decode()}", style="red")
+        sys.exit(1)
+    return stdout.decode().strip()
+
+
+def get_slug(url: str) -> tuple[str, str]:
+    parsed = parse.urlparse(url)
+    if parsed.netloc == "":
+        # Probably ssh
+        _, _, path = parsed.path.partition(":")
+    else:
+        path = parsed.path[1:].rstrip("/")
+
+    user, repo = path.split("/", 1)
+    if repo.endswith(".git"):
+        repo = repo[:-4]
+    return user, repo
+
+
+async def do_setup() -> None:
+    hooks_dir = (await git("rev-parse --git-path hooks")).strip()
+    installed_hook_file = os.path.join(hooks_dir, "commit-msg")
+
+    new_hook_file = str(
+        importlib.resources.files(__package__).joinpath("hooks/commit-msg")
+    )
+
+    if os.path.exists(installed_hook_file):
+        with open(installed_hook_file) as f:
+            data_installed = f.read()
+        with open(new_hook_file) as f:
+            data_new = f.read()
+        if data_installed != data_new:
+            console.print(
+                f"error: {installed_hook_file} differ from mergify_cli hook",
+                style="red",
+            )
+            sys.exit(1)
+
+    else:
+        console.log("Installation of git commit-msg hook")
+        shutil.copy(new_hook_file, installed_hook_file)
+        os.chmod(installed_hook_file, 0o755)
+
+
+class GitRef(typing.TypedDict):
+    ref: str
+
+
+class HeadRef(typing.TypedDict):
+    sha: str
+
+
+class PullRequest(typing.TypedDict):
+    html_url: str
+    number: str
+    title: str
+    head: HeadRef
+    state: str
+    draft: bool
+    node_id: str
+
+
+ChangeId = typing.NewType("ChangeId", str)
+KnownChangeIDs = typing.NewType("KnownChangeIDs", dict[ChangeId, PullRequest | None])
+
+
+async def get_changeid_and_pull(
+    client: httpx.AsyncClient, user: str, stack_prefix: str, ref: GitRef
+) -> tuple[ChangeId, PullRequest | None]:
+    branch = ref["ref"][len("refs/heads/") :]
+    changeid = ChangeId(branch[len(stack_prefix) + 1 :])
+    r = await client.get("pulls", params={"head": f"{user}:{branch}", "state": "open"})
+    check_for_status(r)
+    pulls = [
+        p for p in typing.cast(list[PullRequest], r.json()) if p["state"] == "open"
+    ]
+    if len(pulls) > 1:
+        raise RuntimeError(f"More than 1 pull found with this head: {branch}")
+    if pulls:
+        return changeid, pulls[0]
+    return changeid, None
+
+
+Change = typing.NewType("Change", tuple[ChangeId, str, str, str])
+
+
+async def get_local_changes(
+    commits: list[str],
+    stack_prefix: str,
+    known_changeids: KnownChangeIDs,
+) -> list[Change]:
+    changes = []
+    for commit in commits:
+        message = await git(f"log -1 --format='%b' {commit}")
+        title = await git(f"log -1 --format='%s' {commit}")
+        changeids = CHANGEID_RE.findall(message)
+        if not changeids:
+            console.print(
+                f"`Change-Id:` line is missing on commit {commit}",
+                style="red",
+            )
+            sys.exit(1)
+        changeid = ChangeId(changeids[-1])
+        changes.append(Change((changeid, commit, title, message)))
+        pull = known_changeids.get(changeid)
+        if pull is None:
+            action = "to create"
+            url = f"<{stack_prefix}/{changeid}>"
+            commit_info = commit[-7:]
+        else:
+            url = pull["html_url"]
+            head_commit = commit[-7:]
+            commit_info = head_commit
+            if DRAFT is not pull["draft"]:
+                if DRAFT:
+                    action = "ready_for_review -> draft"
+                else:
+                    action = "draft -> ready_for_review"
+            elif pull["head"]["sha"][-7:] != head_commit:
+                action = "to update"
+                commit_info = f"{pull['head']['sha'][-7:]} -> {head_commit}"
+            else:
+                action = "nothing"
+
+        console.log(
+            f"* [yellow]\\[{action}][/] '[red]{commit_info}[/] - [b]{title}[/] {url} - {changeid}"
+        )
+
+    return changes
+
+
+async def get_changeids_to_delete(
+    changes: list[Change], known_changeids: KnownChangeIDs
+) -> set[ChangeId]:
+    changeids_to_delete = set(known_changeids.keys()) - {
+        changeid for changeid, commit, title, message in changes
+    }
+    for changeid in changeids_to_delete:
+        pull = known_changeids.get(changeid)
+        if pull:
+            console.log(
+                f"* [red]\\[to delete][/] '[red]{pull['head']['sha'][-7:]}[/] - [b]{pull['title']}[/] {pull['html_url']} - {changeid}"
+            )
+        else:
+            console.log(
+                f"* [red]\\[to delete][/] '[red].......[/] - [b]<missing pull request>[/] - {changeid}"
+            )
+    return changeids_to_delete
+
+
+async def create_or_update_comments(
+    client: httpx.AsyncClient, pulls: list[PullRequest]
+) -> None:
+    first_line = "This pull request is part of a stack:\n"
+    body = first_line
+    for pull in pulls:
+        body += f"1. {pull['title']} ([#{pull['number']}]({pull['html_url']}))\n"
+
+    for pull in pulls:
+        r = await client.get(f"issues/{pull['number']}/comments")
+        check_for_status(r)
+        for comment in r.json():
+            if comment["body"].startswith(first_line):
+                if comment["body"] != body:
+                    await client.patch(comment["url"], json={"body": body})
+                break
+        else:
+            await client.post(f"issues/{pull['number']}/comments", json={"body": body})
+
+
+async def create_or_update_stack(
+    client: httpx.AsyncClient,
+    stacked_base_branch: str,
+    stacked_dest_branch: str,
+    changeid: ChangeId,
+    commit: str,
+    title: str,
+    message: str,
+    known_changeids: KnownChangeIDs,
+) -> tuple[PullRequest, str]:
+    if changeid in known_changeids:
+        pull = known_changeids.get(changeid)
+        with console.status(
+            f"* updating stacked branch `{stacked_dest_branch}` ({commit[-7:]}) - {pull['html_url'] if pull else '<stack branch without associated pull>'})"
+        ):
+            r = await client.patch(
+                f"git/refs/heads/{stacked_dest_branch}",
+                json={"sha": commit, "force": True},
+            )
+    else:
+        with console.status(
+            f"* creating stacked branch `{stacked_dest_branch}` ({commit[-7:]})"
+        ):
+            r = await client.post(
+                "git/refs",
+                json={"ref": f"refs/heads/{stacked_dest_branch}", "sha": commit},
+            )
+
+    check_for_status(r)
+
+    pull = known_changeids.get(changeid)
+    if pull and pull["head"]["sha"] == commit:
+        if DRAFT is not pull["draft"]:
+            action = await check_and_update_pull_status(client, pull)
+        else:
+            action = "nothing"
+    elif pull:
+        action = "updated"
+        with console.status(
+            f"* updating pull request `{title}` (#{pull['number']}) ({commit[-7:]})"
+        ):
+            r = await client.patch(
+                f"pulls/{pull['number']}",
+                json={
+                    "title": title,
+                    "body": message,
+                    "head": stacked_dest_branch,
+                    "base": stacked_base_branch,
+                },
+            )
+            check_for_status(r)
+            pull = typing.cast(PullRequest, r.json())
+            if DRAFT is not pull["draft"]:
+                action = await check_and_update_pull_status(client, pull)
+    else:
+        action = "created"
+        with console.status(
+            f"* creating stacked pull request `{title}` ({commit[-7:]})"
+        ):
+            r = await client.post(
+                "pulls",
+                json={
+                    "title": title,
+                    "body": message,
+                    "draft": DRAFT,
+                    "head": stacked_dest_branch,
+                    "base": stacked_base_branch,
+                },
+            )
+            check_for_status(r)
+            pull = typing.cast(PullRequest, r.json())
+    return pull, action
+
+
+async def check_and_update_pull_status(
+    client: httpx.AsyncClient, pull: PullRequest
+) -> str:
+    if DRAFT:
+        action = "draft"
+        template = DRAFT_TEMPLATE
+    else:
+        action = "ready_for_review"
+        template = READY_FOR_REVIEW_TEMPLATE
+
+    r = await client.post(
+        "https://api.github.com/graphql",
+        headers={
+            "Accept": "application/vnd.github.v4.idl",
+            "User-Agent": f"mergify_cli/{VERSION}",
+            "Authorization": client.headers["Authorization"],
+        },
+        json={"query": template % pull["node_id"]},
+    )
+    check_for_status(r)
+    check_for_graphql_errors(r)
+
+    return action
+
+
+async def delete_stack(
+    client: httpx.AsyncClient,
+    stack_prefix: str,
+    changeid: ChangeId,
+    known_changeids: KnownChangeIDs,
+) -> None:
+    r = await client.delete(
+        f"git/refs/heads/{stack_prefix}/{changeid}",
+    )
+    check_for_status(r)
+    pull = known_changeids[changeid]
+    if pull:
+        console.log(
+            f"* [red]\\[deleted][/] '[red]{pull['head']['sha'][-7:]}[/] - [b]{pull['title']}[/] {pull['html_url']} - {changeid}"
+        )
+    else:
+        console.log(
+            f"* [red]\\[deleted][/] '[red].......[/] - [b]<branch {stack_prefix}/{changeid}>[/] - {changeid}"
+        )
+
+
+async def log_httpx_request(request: httpx.Request) -> None:
+    console.print(
+        f"[purple]DEBUG: request: {request.method} {request.url} - Waiting for response[/]"
+    )
+
+
+async def log_httpx_response(response: httpx.Response) -> None:
+    request = response.request
+    console.print(
+        f"[purple]DEBUG: response: {request.method} {request.url} - Status {response.status_code}[/]"
+    )
+
+
+def get_trunk(trunk: str | None = None) -> tuple[str, str]:
+    if not trunk:
+        try:
+            trunk = (
+                subprocess.check_output(
+                    "git config --get mergify-cli.stack-trunk", shell=True
+                )
+                .decode()
+                .strip()
+            )
+        except subprocess.CalledProcessError:
+            trunk = ""
+
+    if not trunk:
+        console.log("[red] mergify-cli stack-trunk is not defined [/]")
+        console.log(
+            "[yellow] Setting it using : `git config --add mergify-cli.stack-trunk origin/branch-name` [/]"
+        )
+        console.log("[yellow] or use param : --trunk origin/branch-names [/]")
+        sys.exit(1)
+
+    result = trunk.split("/", maxsplit=1)
+    if len(result) != 2:
+        console.log(
+            "[red] mergify-cli stack-trunk is not well formated. It must be origin/branch-name [/]"
+        )
+        console.log(
+            "[yellow] Setting it using : `git config --add mergify-cli.stack-trunk origin/branch-name` [/]"
+        )
+        console.log("[yellow] or use param : --trunk origin/branch-names [/]")
+        sys.exit(1)
+
+    return result[0], result[1]
+
+
+async def main(
+    token: str,
+    next_only: bool,
+    branch_prefix: str,
+    dry_run: bool,
+    trunk: str | None = None,
+) -> None:
+    os.chdir((await git("rev-parse --show-toplevel")).strip())
+    dest_branch = await git("rev-parse --abbrev-ref HEAD")
+
+    remote, base_branch = get_trunk(trunk)
+
+    user, repo = get_slug(await git(f"config --get remote.{remote}.url"))
+
+    if base_branch == dest_branch:
+        console.log("[red] base branch and destination branch are the same [/]")
+        sys.exit(1)
+
+    stack_prefix = f"{branch_prefix}/{dest_branch}"
+
+    if not dry_run:
+        with console.status(
+            f"Rebasing branch `{dest_branch}` on `{remote}/{base_branch}`...",
+        ):
+            await git(f"pull --rebase {remote} {base_branch}")
+        console.log(f"branch `{dest_branch}` rebased on `{remote}/{base_branch}`")
+
+        with console.status(
+            f"Pushing branch `{dest_branch}` to `{remote}/{dest_branch}`...",
+        ):
+            await git(f"push -f {remote} {dest_branch}:{stack_prefix}/aio")
+        console.log(f"branch `{dest_branch}` pushed to `{remote}/{dest_branch}` ")
+
+    base_commit_sha = await git(f"merge-base --fork-point {remote}/{base_branch}")
+    if not base_commit_sha:
+        console.log(
+            f"Common commit between `{remote}/{base_branch}` and `{dest_branch}` branches not found",
+            style="red",
+        )
+        sys.exit(1)
+
+    commits = [
+        commit
+        for commit in reversed(
+            (await git(f"log --format='%H' {base_commit_sha}..{dest_branch}")).split(
+                "\n"
+            )
+        )
+        if commit.strip()
+    ]
+
+    known_changeids = KnownChangeIDs({})
+
+    if DEBUG:
+        event_hooks = {"request": [log_httpx_request], "response": [log_httpx_response]}
+    else:
+        event_hooks = {}
+
+    async with httpx.AsyncClient(
+        base_url=f"https://api.github.com/repos/{user}/{repo}/",
+        headers={
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": f"mergify_cli/{VERSION}",
+            "Authorization": f"token {token}",
+        },
+        event_hooks=event_hooks,  # type: ignore[arg-type]
+    ) as client:
+        with console.status("Retrieving latest pushed stacks"):
+            r = await client.get(f"git/matching-refs/heads/{stack_prefix}/")
+            check_for_status(r)
+            refs = typing.cast(list[GitRef], r.json())
+
+            tasks = [
+                asyncio.create_task(
+                    get_changeid_and_pull(client, user, stack_prefix, ref)
+                )
+                for ref in refs
+                if not ref["ref"].endswith("/aio")
+            ]
+            if tasks:
+                done, _ = await asyncio.wait(tasks)
+                for task in done:
+                    known_changeids.update(dict([await task]))
+
+        with console.status("Preparing stacked branches..."):
+            console.log("Stacked pull request plan:", style="green")
+            changes = await get_local_changes(commits, stack_prefix, known_changeids)
+            changeids_to_delete = await get_changeids_to_delete(
+                changes, known_changeids
+            )
+
+        if dry_run:
+            console.log("[orange]Finished (dry-run mode) :tada:[/]")
+            sys.exit(0)
+
+        console.log("New stacked pull request:", style="green")
+        stacked_base_branch = base_branch
+        pulls: list[PullRequest] = []
+        continue_create_or_update = True
+        for changeid, commit, title, message in changes:
+            depends_on = ""
+            if pulls:
+                depends_on = f"\n\nDepends-On: #{pulls[-1]['number']}"
+            stacked_dest_branch = f"{stack_prefix}/{changeid}"
+            if continue_create_or_update:
+                pull, action = await create_or_update_stack(
+                    client,
+                    stacked_base_branch,
+                    stacked_dest_branch,
+                    changeid,
+                    commit,
+                    title,
+                    message + depends_on,
+                    known_changeids,
+                )
+                pulls.append(pull)
+            else:
+                action = "skipped"
+                pull = known_changeids.get(changeid) or PullRequest(
+                    {
+                        "title": "<not yet created>",
+                        "html_url": "<no-yet-created>",
+                        "number": "-1",
+                        "node_id": "na",
+                        "draft": True,
+                        "state": "",
+                        "head": {"sha": ""},
+                    }
+                )
+
+            console.log(
+                f"* [blue]\\[{action}][/] '[red]{commit[-7:]}[/] - [b]{pull['title']}[/] {pull['html_url']} - {changeid}"
+            )
+            stacked_base_branch = stacked_dest_branch
+            if continue_create_or_update and next_only:
+                continue_create_or_update = False
+
+        with console.status("Updating comments..."):
+            await create_or_update_comments(client, pulls)
+        console.log("[green]Comments updated")
+
+        with console.status("Deleting unused branches..."):
+            delete_tasks = [
+                asyncio.create_task(
+                    delete_stack(client, stack_prefix, changeid, known_changeids)
+                )
+                for changeid in changeids_to_delete
+            ]
+            if delete_tasks:
+                await asyncio.wait(delete_tasks)
+
+        console.log("[green]Finished :tada:[/]")
+
+
+def GitHubToken(v: str) -> str:
+    if not v:
+        raise ValueError
+    return v
+
+
+def get_default_branch_prefix() -> str:
+    try:
+        result = subprocess.check_output(
+            "git config --get mergify-cli.stack-branch-prefix", shell=True
+        )
+    except subprocess.CalledProcessError:
+        result = b""
+
+    return result.decode().strip() or "mergify_cli"
+
+
+def get_default_token() -> str:
+    token = os.environ.get("GITHUB_TOKEN", "")
+    if not token:
+        token = subprocess.check_output("gh auth token", shell=True).decode().strip()
+    if DEBUG:
+        console.print(f"[purple]DEBUG: token: {token}[/]")
+    return token
+
+
+def cli() -> None:
+    global DEBUG
+    global DRAFT
+    parser = argparse.ArgumentParser(description="mrgfy")
+    parser.add_argument("--debug", action="store_true")
+    parser.add_argument("--setup", action="store_true")
+    parser.add_argument("--dry-run", "-n", action="store_true")
+    parser.add_argument("--next-only", "-x", action="store_true")
+    parser.add_argument("--draft", "-d", action="store_true")
+    parser.add_argument("--trunk", "-t")
+    parser.add_argument(
+        "--branch-prefix",
+        default=get_default_branch_prefix(),
+        help="branch prefix used to create stacked PR",
+    )
+    parser.add_argument(
+        "--token",
+        default=get_default_token(),
+        type=GitHubToken,
+        help="GitHub personal access token",
+    )
+    args = parser.parse_args()
+    if args.debug:
+        DEBUG = True
+
+    if args.draft:
+        DRAFT = True
+
+    if args.setup:
+        asyncio.run(do_setup())
+    else:
+        asyncio.run(
+            main(
+                args.token,
+                args.next_only,
+                args.branch_prefix,
+                args.dry_run,
+                args.trunk,
+            )
+        )

mergify_cli-0.1.1/mergify_cli/hooks/commit-msg

@@ -0,0 +1,63 @@
+#!/bin/sh
+# Based on Gerrit Code Review 3.1.3
+#
+# Part of Gerrit Code Review (https://www.gerritcodereview.com/)
+#
+# Copyright (C) 2009 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# avoid [[ which is not POSIX sh.
+if test "$#" != 1 ; then
+  echo "$0 requires an argument."
+  exit 1
+fi
+
+if test ! -f "$1" ; then
+  echo "file does not exist: $1"
+  exit 1
+fi
+
+# Do not create a change id if requested
+#if test "false" = "`git config --bool --get gerrit.createChangeId`" ; then
+#  exit 0
+#fi
+
+# $RANDOM will be undefined if not using bash, so don't use set -u
+random=$( (whoami ; hostname ; date; cat $1 ; echo $RANDOM) | git hash-object --stdin)
+dest="$1.tmp.${random}"
+
+trap 'rm -f "${dest}"' EXIT
+
+if ! git stripspace --strip-comments < "$1" > "${dest}" ; then
+   echo "cannot strip comments from $1"
+   exit 1
+fi
+
+if test ! -s "${dest}" ; then
+  echo "file is empty: $1"
+  exit 1
+fi
+
+# Avoid the --in-place option which only appeared in Git 2.8
+# Avoid the --if-exists option which only appeared in Git 2.15
+if ! git -c trailer.ifexists=doNothing interpret-trailers \
+      --trailer "Change-Id: I${random}" < "$1" > "${dest}" ; then
+  echo "cannot insert change-id line in $1"
+  exit 1
+fi
+
+if ! mv "${dest}" "$1" ; then
+  echo "cannot mv ${dest} to $1"
+  exit 1
+fi

mergify_cli-0.1.1/mergify_cli/tests/test_mergify_cli.py

@@ -0,0 +1,18 @@
+#
+#  Copyright © 2021 Mergify SAS
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+
+def test_noop() -> None:
+    pass

mergify_cli-0.1.1/pyproject.toml

@@ -0,0 +1,81 @@
+[tool.poetry]
+name = "mergify_cli"
+version = "0.1.1"
+description = ""
+authors = ["Mehdi Abaakouk <sileht@mergify.com>"]
+
+
+[tool.poetry.dependencies]
+python = ">=3.10"
+httpx = ">=0.20.0"
+rich = ">=10.11.0"
+
+[tool.poetry.group.dev.dependencies]
+mypy = {version = ">=0.930"}
+mypy-extensions = "^1.0.0"
+black = "^23.7.0"
+ruff = "^0.0.277"
+pytest = {version = ">=6.2.5"}
+poethepoet = "^0.21.0"
+
+[tool.poetry.scripts]
+mergify = 'mergify_cli:cli'
+
+[tool.poe]
+include = ["poe.toml"]
+
+[tool.black]
+target-version = ['py311']
+
+[tool.mypy]
+strict = true
+warn_unreachable = true
+exclude = [".venv"]
+files = ["mergify_cli"]
+show_error_codes = true
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+select = [
+ "E", "W", "F", "I", "A", "B", "Q",
+ "C4", "T10", "ISC", "ICN", "BLE",
+ "G", "RSE", "TID", "TRY", "PLE", "UP",
+ "RUF", "RET",
+ # FIXME(sileht): very interresting, but require easy manual code change
+ # "DTZ", "ARG", "TCH", "COM",
+ # FIXME(sileht): doctring/rst-docstring like
+ # "D"
+]
+
+ignore = [
+    # NOTE(sileht): line-length is up to black
+    "E501",
+    # NOTE(sileht): we prefer using exc_info=True
+    "G201", "TRY200", "TRY400",
+    # NOTE(sileht): "Unnecessary parentheses on raised exception", this breaks
+    # isinstance on exception
+    "RSE102",
+    # NOTE(sileht): No exception with message set via __init__
+    "TRY003", "TRY301",
+    # NOTE(sileht): built-in shadow, interresting but to raise an error for
+    # TypedDict/NamedTuple with key named like builtin, so it's useless
+    "A003",
+    # NOTE(sileht): This enforce usage of raise ... from ...
+    "B904",
+    # FIXME(sileht): Convert some exception -> TypeError
+    "TRY004",
+    # FIXME(sileht): very interresting, ruff BLE is far better that flake8-blind-except
+    "BLE001",
+    # NOTE(sileht): looks buggy
+    "RET508"
+]
+
+[tool.ruff.isort]
+force-single-line = true
+force-sort-within-sections = true
+lines-after-imports = 2
+known-first-party = ["mergify_cli"]
+
+[tool.ruff.flake8-tidy-imports]
+ban-relative-imports = "all"