agentic-devtools 0.2.53__tar.gz → 0.2.55__tar.gz

{agentic_devtools-0.2.53 → agentic_devtools-0.2.55}/.github/copilot-instructions.md

@@ -149,6 +149,8 @@ Using raw commands (e.g., `git`, raw REST API calls, `pytest`) bypasses:
 | Raw Azure DevOps REST API calls | `agdt-create-pull-request`, `agdt-add-pull-request-comment`, etc. |
 | Raw Jira REST API calls | `agdt-add-jira-comment`, `agdt-get-jira-issue`, etc. |
 | `gh issue create` (for this repo) | `agdt-create-agdt-feature-issue`, `agdt-create-agdt-bug-issue`, etc. |
+| `gh pr view ... --json` | `agdt-gh-pr-state` |
+| `gh pr checks` + `gh api check-suites` | `agdt-gh-pr-checks-status` |
 
 #### Exceptions — Raw Commands Still Required
 
@@ -160,6 +162,28 @@ Using raw commands (e.g., `git`, raw REST API calls, `pytest`) bypasses:
 | `gh pr review`, `gh pr comment` for external repos | No agdt support yet for general GitHub PR reviews |
 | Other `gh` operations not listed in the command mapping above | No agdt equivalent exists |
 
+### GitHub PR Actions (Synchronous)
+
+| Command | Purpose | Required State / CLI Args |
+|---------|---------|---------------------------|
+| `agdt-gh-pr-state` | Fetch structured GitHub PR state | `--pr` (int) and optionally `--repo` (owner/repo); falls back to `github.pull_request_number` and `github.repo` state keys or git remote auto-detection |
+
+**State keys written by `agdt-gh-pr-state`:**
+`github.pull_request_number`, `github.repo`, `github.pr_state`,
+`github.head_ref_oid`, `github.head_ref_oid_short`, `github.mergeable`,
+`github.merge_state_status`, `github.is_draft`, `github.is_terminal`
+
+**Usage:**
+
+```bash
+# With explicit args
+agdt-gh-pr-state --pr 1115 --repo ayaiayorg/agentic-devtools
+
+# With state (repo auto-detected from git remote)
+agdt-set github.pull_request_number 1115
+agdt-gh-pr-state
+```
+
 ## 2. Package Structure
 
 ```text
@@ -243,6 +267,8 @@ agentic_devtools/
 | `github/state_helpers.py` | `get_issue_value()` and `set_issue_value()` for the `issue.*` state namespace |
 | `github/issue_commands.py` | Sync implementations: `create_agdt_issue`, `create_agdt_bug_issue`, `create_agdt_feature_issue`, `create_agdt_documentation_issue`, `create_agdt_task_issue` |
 | `github/async_commands.py` | Async wrappers (background tasks) and argparse CLI entry points for all `agdt-create-agdt-*` commands |
+| `github/repo_resolution.py` | `resolve_github_repo()` for resolving `owner/repo` from CLI args or git remote |
+| `github/pr_checks_status.py` | Dual-source CI check verification: `get_pr_checks_status()`, `pr_checks_status_command()` |
 | `prompts/loader.py` | Template loading, variable extraction, validation, substitution, and output saving |
 | `cli/workflows/base.py` | Base workflow utilities: `validate_required_state`, `initiate_workflow`, `advance_workflow_step` |
 | `cli/workflows/commands.py` | Workflow initiation CLI commands for each workflow type |
@@ -454,6 +480,29 @@ All file review commands automatically:
 3. Update the hierarchical review threads in Azure DevOps via PATCH requests (file, folder, and overall summary threads), then save the refreshed state to `review-state.json`
 4. Print next steps (continue with next file or advance to summary step)
 
+### GitHub PR Actions (Synchronous)
+
+These commands interact with GitHub PRs via the `gh` CLI and return results directly (not background tasks).
+
+| Command | Purpose | Required State / CLI Args |
+|---------|---------|---------------------------|
+| `agdt-gh-pr-checks-status` | Dual-source CI check verification | `--pr` or `github.pull_request_number`; `--repo` or git remote; optional `--head-sha` or `github.head_ref_oid` |
+
+**`agdt-gh-pr-checks-status`** performs dual verification:
+
+1. Fetches structured check results via `gh pr checks --json`
+2. Verifies check-suite completion via `gh api` check-suites endpoint (when `head_sha` is available)
+
+State keys written: `github.pr_checks_status`, `github.pr_checks_failed`, `github.pr_checks_pending`.
+
+```bash
+# With CLI parameters
+agdt-gh-pr-checks-status --pr 1115 --repo ayaiayorg/agentic-devtools --head-sha abc123
+
+# Using state (set via agdt-set)
+agdt-gh-pr-checks-status
+```
+
 ### Git Workflow Actions (Background Tasks)
 
 All Git workflow commands spawn background tasks:

{agentic_devtools-0.2.53 → agentic_devtools-0.2.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.53
+Version: 0.2.55
 Summary: Agentic devtools integrate Jira, DevOps & more
 Author: ayaiayorg
 License-Expression: MIT

{agentic_devtools-0.2.53 → agentic_devtools-0.2.55}/agentic_devtools/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.53'
-__version_tuple__ = version_tuple = (0, 2, 53)
+__version__ = version = '0.2.55'
+__version_tuple__ = version_tuple = (0, 2, 55)
 
 __commit_id__ = commit_id = None

{agentic_devtools-0.2.53 → agentic_devtools-0.2.55}/agentic_devtools/cli/copilot/auto_start.py

@@ -494,3 +494,145 @@ def copilot_auto_start_cmd(argv: list[str] | None = None) -> None:
 
     _cleanup_pending_auto_start_marker(worktree_path)
     sys.exit(0)
+
+
+def retry_autostart_cmd(argv: list[str] | None = None) -> None:
+    """Entry point for the ``agdt-retry-autostart`` CLI command.
+
+    Reads the ``pending-auto-start.json`` marker file from the target
+    worktree's ``.vscode/`` directory and re-invokes
+    :func:`copilot_auto_start_cmd` with the stored parameters, providing
+    a simple single-command retry path when the primary autostart
+    mechanisms fail.
+
+    Steps
+    -----
+    1. Parse ``--worktree-path`` (default: CWD) and ``--force``.
+    2. Read and validate ``<worktree_path>/.vscode/pending-auto-start.json``.
+    3. Unless ``--force``, check the marker's ``run_id`` against the
+       current ``agdt_run_id`` in state; exit 1 on mismatch.
+    4. Call ``_unmark_run_triggered`` to clear the deduplication guard.
+    5. Delegate to ``copilot_auto_start_cmd`` with the stored parameters.
+    """
+    from agentic_devtools.cli.workflows.worktree_setup import (
+        _PENDING_AUTO_START_FILENAME,
+        _resolve_state_context_in_worktree,
+    )
+
+    parser = argparse.ArgumentParser(
+        prog="agdt-retry-autostart",
+        description="Retry a failed Copilot autostart using the pending marker file.",
+    )
+    parser.add_argument(
+        "--worktree-path",
+        default=None,
+        help="Path to the worktree directory (default: current working directory).",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Skip stale-marker check and proceed with retry regardless.",
+    )
+
+    args = parser.parse_args(argv if argv is not None else sys.argv[1:])
+
+    worktree_path: str = args.worktree_path if args.worktree_path else os.getcwd()
+    force: bool = args.force
+
+    # --- Read the marker file ------------------------------------------------
+    marker_path = os.path.join(worktree_path, ".vscode", _PENDING_AUTO_START_FILENAME)
+
+    if not os.path.isfile(marker_path):
+        print(
+            f"agdt-retry-autostart: error: no pending auto-start marker found at {marker_path}. No autostart to retry.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        with open(marker_path, encoding="utf-8") as fh:
+            marker = json.load(fh)
+    except (json.JSONDecodeError, ValueError) as exc:
+        print(
+            f"agdt-retry-autostart: error: could not parse pending auto-start marker at {marker_path}: {exc}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    except OSError as exc:
+        print(
+            f"agdt-retry-autostart: error: could not read pending auto-start marker at {marker_path}: {exc}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if not isinstance(marker, dict):
+        print(
+            f"agdt-retry-autostart: error: pending auto-start marker at {marker_path} "
+            f"has invalid format (expected JSON object).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # --- Validate required fields -------------------------------------------
+    for field in ("run_id", "start_prompt"):
+        value = marker.get(field)
+        if not isinstance(value, str) or not value.strip():
+            print(
+                f"agdt-retry-autostart: error: pending auto-start marker at "
+                f"{marker_path} is missing required field '{field}'.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+    # --- Validate worktree_path from marker ----------------------------------
+    marker_wt = marker.get("worktree_path", "")
+    effective_wt = args.worktree_path if args.worktree_path else marker_wt
+    if not isinstance(effective_wt, str) or not effective_wt or not os.path.isdir(effective_wt):
+        print(
+            f"agdt-retry-autostart: error: worktree path does not exist or is not a directory: {effective_wt!r}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    run_id: str = marker["run_id"]
+
+    # --- Stale-marker check (unless --force) ---------------------------------
+    state_file_path: Path | None = None
+    if not force:
+        state_file_path, state_run_id = _resolve_state_context_in_worktree(effective_wt, include_run_id=True)
+        if state_file_path is None:
+            # State unreadable — warn but proceed (lenient approach per spec).
+            print(
+                "agdt-retry-autostart: warning: could not read state in worktree; skipping stale-marker check.",
+                file=sys.stderr,
+            )
+        elif state_run_id and state_run_id != run_id:
+            print(
+                f"agdt-retry-autostart: error: marker run_id ({run_id}) does not "
+                f"match current state run_id ({state_run_id}). Use --force to retry "
+                f"anyway.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+    # --- Resolve state file for _unmark_run_triggered ------------------------
+    if state_file_path is None:
+        state_file_path, _ = _resolve_state_context_in_worktree(effective_wt)
+    if state_file_path is not None:
+        _unmark_run_triggered(state_file_path, run_id)
+
+    # --- Delegate to copilot_auto_start_cmd ----------------------------------
+    constructed_argv: list[str] = [
+        "--worktree-path",
+        effective_wt,
+        "--start-prompt",
+        marker["start_prompt"],
+        "--run-id",
+        run_id,
+    ]
+
+    model = marker.get("model")
+    if isinstance(model, str) and model.strip():
+        constructed_argv.extend(["--model", model])
+
+    copilot_auto_start_cmd(argv=constructed_argv)

{agentic_devtools-0.2.53 → agentic_devtools-0.2.55}/agentic_devtools/cli/github/__init__.py

@@ -20,6 +20,9 @@ from .issue_commands import (
     create_agdt_issue,
     create_agdt_task_issue,
 )
+from .pr_checks_status import get_pr_checks_status, pr_checks_status_command
+from .pr_state import get_pr_state, pr_state_command
+from .repo_resolution import resolve_github_repo
 from .state_helpers import (
     GITHUB_ISSUE_STATE_NAMESPACE,
     get_issue_value,
@@ -45,5 +48,10 @@ __all__ = [
     "create_agdt_task_issue_async",
     "create_agdt_task_issue_async_cli",
     "get_issue_value",
+    "get_pr_checks_status",
+    "get_pr_state",
+    "pr_checks_status_command",
+    "pr_state_command",
+    "resolve_github_repo",
     "set_issue_value",
 ]

agentic_devtools-0.2.55/agentic_devtools/cli/github/pr_checks_status.py

@@ -0,0 +1,396 @@
+"""
+PR CI/status check verification via dual-source: ``gh pr checks`` + check-suites API.
+
+Provides ``get_pr_checks_status()`` for programmatic use and
+``pr_checks_status_command()`` as the CLI entry point for
+``agdt-gh-pr-checks-status``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+
+from ...state import get_value, set_value
+from ..subprocess_utils import run_safe
+from .repo_resolution import resolve_github_repo
+
+_GH_PR_CHECKS_JSON_FIELDS = "name,state,bucket,workflow,completedAt,description"
+_CHECK_SUITE_GREEN_CONCLUSIONS = frozenset(["success", "neutral", "skipped"])
+_MAX_RETRIES = 2
+_RETRY_DELAY_SECONDS = 10.0
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _fetch_pr_checks(pr_number: int, repo: str) -> list[dict]:
+    """Fetch structured check results via ``gh pr checks --json``.
+
+    Retries up to *_MAX_RETRIES* times on failure.  Calls ``sys.exit(1)``
+    when all retries are exhausted.
+    """
+    cmd = [
+        "gh",
+        "pr",
+        "checks",
+        str(pr_number),
+        "--repo",
+        repo,
+        "--json",
+        _GH_PR_CHECKS_JSON_FIELDS,
+    ]
+
+    last_error = ""
+    for attempt in range(_MAX_RETRIES + 1):
+        try:
+            result = run_safe(cmd, capture_output=True, text=True, shell=False)
+        except FileNotFoundError:
+            print(
+                "Error: 'gh' CLI is not installed or not on PATH. "
+                "Install from https://cli.github.com/",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        if result.returncode == 0:
+            try:
+                data = json.loads(result.stdout)
+                if isinstance(data, list):
+                    return data
+                last_error = f"Unexpected JSON type: {type(data).__name__}"
+            except json.JSONDecodeError as exc:
+                last_error = f"JSON parse error: {exc}"
+        else:
+            last_error = (result.stderr or "").strip() or f"exit code {result.returncode}"
+
+        if attempt < _MAX_RETRIES:
+            print(
+                f"Warning: gh pr checks failed (attempt {attempt + 1}/{_MAX_RETRIES + 1}): "
+                f"{last_error}. Retrying in {_RETRY_DELAY_SECONDS}s …",
+                file=sys.stderr,
+            )
+            time.sleep(_RETRY_DELAY_SECONDS)
+
+    print(
+        f"Error: gh pr checks failed after {_MAX_RETRIES + 1} attempts: {last_error}",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+def _classify_checks(checks: list[dict]) -> dict:
+    """Classify checks by their ``bucket`` field.
+
+    Returns a dict with counts and lists of failed/pending check names.
+    """
+    passed = 0
+    failed = 0
+    pending = 0
+    skipped = 0
+    cancelled = 0
+    failed_checks: list[str] = []
+    pending_checks: list[str] = []
+
+    for check in checks:
+        bucket = check.get("bucket", "")
+        name = check.get("name", "unknown")
+        if bucket == "pass":
+            passed += 1
+        elif bucket == "fail":
+            failed += 1
+            failed_checks.append(name)
+        elif bucket == "pending":
+            pending += 1
+            pending_checks.append(name)
+        elif bucket == "skipping":
+            skipped += 1
+        elif bucket == "cancel":
+            cancelled += 1
+        # Unknown bucket values are silently ignored (not counted)
+
+    return {
+        "passed": passed,
+        "failed": failed,
+        "pending": pending,
+        "skipped": skipped,
+        "cancelled": cancelled,
+        "total": len(checks),
+        "failedChecks": failed_checks,
+        "pendingChecks": pending_checks,
+    }
+
+
+def _normalize_repo(repo: str) -> str:
+    """Validate and normalize a *owner/repo* string.
+
+    Strips whitespace and a trailing ``.git`` suffix, then verifies the
+    value contains exactly one ``/`` separator.  Calls ``sys.exit(1)``
+    with a user-facing message when the format is invalid.
+    """
+    repo = repo.strip()
+    if repo.endswith(".git"):
+        repo = repo[: -len(".git")]
+    if "/" not in repo or repo.count("/") != 1:
+        print(
+            f"Error: invalid repo format '{repo}'. Expected 'owner/repo' "
+            "(for example: agdt-set github.repo myorg/myrepo).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    owner, name = repo.split("/", 1)
+    if not owner or not name:
+        print(
+            f"Error: invalid repo format '{repo}'. Both owner and repo name "
+            "must be non-empty (for example: agdt-set github.repo myorg/myrepo).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    return repo
+
+
+def _fetch_check_suites(repo: str, head_sha: str) -> list[dict]:
+    """Fetch check-suite data via ``gh api`` with pagination.
+
+    Returns an empty list on persistent failure (graceful degradation).
+    """
+    owner, repo_name = repo.split("/", 1)
+    cmd = [
+        "gh",
+        "api",
+        f"repos/{owner}/{repo_name}/commits/{head_sha}/check-suites?per_page=100",
+        "--paginate",
+        "--jq",
+        ".check_suites[]",
+    ]
+
+    last_error = ""
+    for attempt in range(_MAX_RETRIES + 1):
+        try:
+            result = run_safe(cmd, capture_output=True, text=True, shell=False)
+        except FileNotFoundError:
+            print(
+                "Warning: 'gh' CLI is not installed or not on PATH. "
+                "Skipping check-suite verification. "
+                "Install from https://cli.github.com/",
+                file=sys.stderr,
+            )
+            return []
+        if result.returncode == 0:
+            stdout = result.stdout.strip()
+            if not stdout:
+                return []
+            try:
+                suites = [json.loads(line) for line in stdout.splitlines() if line.strip()]
+                return suites
+            except json.JSONDecodeError as exc:
+                last_error = f"JSON parse error: {exc}"
+        else:
+            last_error = (result.stderr or "").strip() or f"exit code {result.returncode}"
+
+        if attempt < _MAX_RETRIES:
+            print(
+                f"Warning: check-suites API failed (attempt {attempt + 1}/{_MAX_RETRIES + 1}): "
+                f"{last_error}. Retrying in {_RETRY_DELAY_SECONDS}s …",
+                file=sys.stderr,
+            )
+            time.sleep(_RETRY_DELAY_SECONDS)
+
+    print(
+        f"Warning: check-suites API failed after {_MAX_RETRIES + 1} attempts: {last_error}. "
+        "Skipping check-suite verification.",
+        file=sys.stderr,
+    )
+    return []
+
+
+def _verify_check_suites(suites: list[dict]) -> tuple[bool, list[dict]]:
+    """Verify that all check suites are green.
+
+    Returns ``(all_verified, discrepancies)`` where each discrepancy is a
+    dict with ``suiteId``, ``app``, ``status``, and ``conclusion``.
+    """
+    discrepancies: list[dict] = []
+    for suite in suites:
+        status = suite.get("status", "")
+        conclusion = suite.get("conclusion") or ""
+        app_raw = suite.get("app")
+        if isinstance(app_raw, dict):
+            app_slug = app_raw.get("slug", "unknown")
+        else:
+            app_slug = str(app_raw) if app_raw else "unknown"
+
+        if status != "completed" or conclusion not in _CHECK_SUITE_GREEN_CONCLUSIONS:
+            discrepancies.append(
+                {
+                    "suiteId": suite.get("id"),
+                    "app": app_slug,
+                    "status": status,
+                    "conclusion": conclusion,
+                }
+            )
+    return (len(discrepancies) == 0, discrepancies)
+
+
+def _reconcile_results(
+    classification: dict,
+    suites_verified: bool,
+    discrepancies: list[dict],
+    head_sha_available: bool,
+) -> dict:
+    """Determine final status and build output dict."""
+    # Base status from classification
+    if classification["pending"] > 0:
+        status = "pending"
+    elif classification["failed"] > 0:
+        status = "failed"
+    elif classification["cancelled"] > 0:
+        status = "cancelled"
+    else:
+        status = "all-pass"
+
+    check_suites_verified = False
+
+    if head_sha_available:
+        if status == "all-pass" and not suites_verified:
+            # Override based on discrepancies
+            for d in discrepancies:
+                if d.get("status") != "completed":
+                    status = "pending"
+                    break
+                # Any completed suite with a non-green conclusion
+                # (cancelled, timed_out, action_required, etc.) is a failure.
+                if d.get("conclusion") not in _CHECK_SUITE_GREEN_CONCLUSIONS:
+                    status = "failed"
+                    break
+        check_suites_verified = suites_verified
+    # else: head_sha not available → checkSuitesVerified stays False
+
+    return {
+        "status": status,
+        "totalChecks": classification["total"],
+        "passed": classification["passed"],
+        "failed": classification["failed"],
+        "pending": classification["pending"],
+        "skipped": classification["skipped"],
+        "cancelled": classification["cancelled"],
+        "failedChecks": classification["failedChecks"],
+        "pendingChecks": classification["pendingChecks"],
+        "checkSuitesVerified": check_suites_verified,
+        "checkSuiteDiscrepancies": discrepancies if head_sha_available else [],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def get_pr_checks_status(
+    pr_number: int,
+    repo: str,
+    head_sha: str | None = None,
+) -> dict:
+    """Fetch, classify, verify, and reconcile PR check status.
+
+    Writes ``github.pr_checks_status``, ``github.pr_checks_failed``, and
+    ``github.pr_checks_pending`` to state.
+
+    Returns the full structured result dict.
+    """
+    repo = _normalize_repo(repo)
+    checks = _fetch_pr_checks(pr_number, repo)
+    classification = _classify_checks(checks)
+
+    if head_sha is not None:
+        suites = _fetch_check_suites(repo, head_sha)
+        if suites:
+            suites_verified, discrepancies = _verify_check_suites(suites)
+        else:
+            suites_verified = False
+            discrepancies = []
+        head_sha_available = True
+    else:
+        suites_verified = False
+        discrepancies = []
+        head_sha_available = False
+
+    result = _reconcile_results(classification, suites_verified, discrepancies, head_sha_available)
+    result["prNumber"] = pr_number
+    result["repo"] = repo
+
+    # Persist to state for downstream commands
+    set_value("github.pr_checks_status", result["status"])
+    set_value("github.pr_checks_failed", result["failedChecks"])
+    set_value("github.pr_checks_pending", result["pendingChecks"])
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+
+def pr_checks_status_command() -> None:
+    """CLI entry point for ``agdt-gh-pr-checks-status``."""
+    parser = argparse.ArgumentParser(
+        description="Check CI/status check results for a GitHub PR.",
+    )
+    parser.add_argument("--pr", type=int, default=None, help="Pull request number")
+    parser.add_argument(
+        "--repo",
+        type=str,
+        default=None,
+        help="Repository in owner/repo format",
+    )
+    parser.add_argument(
+        "--head-sha",
+        type=str,
+        default=None,
+        help="Head commit SHA for check-suite verification",
+    )
+    args = parser.parse_args()
+
+    # Resolve PR number
+    pr_number = args.pr
+    if pr_number is None:
+        pr_number = get_value("github.pull_request_number")
+    if pr_number is None:
+        print(
+            "Error: PR number required. Provide --pr or set github.pull_request_number in state (via agdt-set).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    try:
+        pr_number = int(pr_number)
+    except (TypeError, ValueError):
+        print(
+            "Error: PR number must be an integer. Provide --pr <number> or set "
+            "github.pull_request_number to a valid integer (for example: "
+            "agdt-set github.pull_request_number 123).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Resolve repo
+    repo = resolve_github_repo(args.repo)
+
+    # Resolve head SHA (optional — graceful degradation)
+    head_sha = args.head_sha
+    if head_sha is None:
+        head_sha = get_value("github.head_ref_oid")
+        if head_sha is not None:
+            head_sha = str(head_sha)
+    if head_sha is None:
+        print(
+            "Notice: head_ref_oid not available — skipping check-suite verification. "
+            "Provide --head-sha or set github.head_ref_oid in state for dual verification.",
+            file=sys.stderr,
+        )
+
+    result = get_pr_checks_status(pr_number, repo, head_sha)
+    print(json.dumps(result, indent=2))