@torus-engineering/tas-kit 1.13.0 → 2.1.0

package/.tas/tools/tas-github.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+TAS GitHub Integration Script
+GitHub PR operations for tas-review-pr command.
+
+Usage: python tools/tas-github.py <command> [arguments]
+
+Commands:
+  pr-get    <pr-id>
+  pr-diff   <pr-id>
+  pr-comment <pr-id> --comment <text>
+  pr-inline  <pr-id> --file <path> --line <n> --comment <text>
+  pr-vote    <pr-id> --vote <approve|reject|wait-for-author|reset>
+
+Prerequisites:
+  - GitHub CLI (gh) installed and authenticated: gh auth login
+  - Python 3.8+
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+# --- Helpers ---
+
+def find_repo_root():
+    path = Path.cwd()
+    while path != path.parent:
+        if (path / ".git").exists():
+            return path
+        path = path.parent
+    print("ERROR: Not inside a git repository.")
+    sys.exit(1)
+
+
+def get_remote_url(root):
+    result = subprocess.run(
+        ["git", "remote", "get-url", "origin"],
+        capture_output=True,
+        cwd=str(root),
+    )
+    if result.returncode != 0:
+        print("ERROR: Cannot get git remote URL. Run inside a git repo with 'origin' remote.")
+        sys.exit(1)
+    return result.stdout.decode("utf-8").strip()
+
+
+def parse_owner_repo(remote_url):
+    """Extract owner/repo from GitHub remote URL (https or ssh)."""
+    # ssh: git@github.com:owner/repo.git
+    m = re.search(r"github\.com[:/](.+?)(?:\.git)?$", remote_url)
+    if m:
+        return m.group(1).rstrip("/")
+    print(f"ERROR: Cannot parse owner/repo from remote URL: {remote_url}")
+    sys.exit(1)
+
+
+def get_github_token():
+    result = subprocess.run(
+        ["gh", "auth", "token"],
+        capture_output=True,
+    )
+    if result.returncode != 0:
+        print("ERROR: gh CLI not authenticated. Run: gh auth login")
+        sys.exit(1)
+    return result.stdout.decode("utf-8").strip()
+
+
+def gh_cmd(args):
+    """Run gh CLI command and return parsed JSON output."""
+    cmd = ["gh"] + args + ["--output", "json"] if "--output" not in args else ["gh"] + args
+    result = subprocess.run(cmd, capture_output=True)
+
+    def _decode(b):
+        try:
+            return (b or b"").decode("utf-8")
+        except UnicodeDecodeError:
+            return (b or b"").decode("cp1252", errors="replace")
+
+    if result.returncode != 0:
+        print(f"ERROR: gh command failed:\n{_decode(result.stderr)}")
+        sys.exit(1)
+    stdout = _decode(result.stdout).strip()
+    if not stdout:
+        return {}
+    json_start = re.search(r"[{\[]", stdout)
+    if json_start:
+        try:
+            return json.loads(stdout[json_start.start():])
+        except json.JSONDecodeError:
+            return {}
+    return {}
+
+
+def github_rest(method, path, data, token):
+    """Call GitHub REST API using token auth."""
+    import base64
+    url = f"https://api.github.com{path}"
+    bearer = f"Bearer {token}"
+    body = json.dumps(data).encode("utf-8")
+    req = urllib.request.Request(url, data=body, method=method)
+    req.add_header("Authorization", bearer)
+    req.add_header("Content-Type", "application/json")
+    req.add_header("Accept", "application/vnd.github+json")
+    req.add_header("X-GitHub-Api-Version", "2022-11-28")
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        err_body = e.read().decode("utf-8")
+        print(f"ERROR: GitHub REST API {method} {path} failed ({e.code}): {err_body}")
+        sys.exit(1)
+
+
+# --- PR Commands ---
+
+def cmd_pr_get(args):
+    root = find_repo_root()
+    remote_url = get_remote_url(root)
+    owner_repo = parse_owner_repo(remote_url)
+
+    result = gh_cmd([
+        "pr", "view", str(args.pr_id),
+        "--repo", owner_repo,
+        "--json", "number,title,body,headRefName,baseRefName,author,state,headRefOid,url",
+    ])
+
+    print(f"PR_ID: {result.get('number', args.pr_id)}")
+    print(f"TITLE: {result.get('title', '')}")
+    print(f"DESCRIPTION: {result.get('body', '')}")
+    print(f"SOURCE_BRANCH: {result.get('headRefName', '')}")
+    print(f"TARGET_BRANCH: {result.get('baseRefName', '')}")
+    author = result.get("author", {})
+    print(f"CREATOR: {author.get('login', '') if isinstance(author, dict) else str(author)}")
+    print(f"STATUS: {result.get('state', '')}")
+    print(f"REPO_ID: {owner_repo}")
+    print(f"REPO_NAME: {owner_repo.split('/')[-1]}")
+    print(f"HEAD_COMMIT: {result.get('headRefOid', '')}")
+    print(f"WORK_ITEMS: ")  # GitHub has no native work item link (use PR body parsing if needed)
+
+
+def cmd_pr_diff(args):
+    root = find_repo_root()
+    remote_url = get_remote_url(root)
+    owner_repo = parse_owner_repo(remote_url)
+
+    result = gh_cmd([
+        "pr", "view", str(args.pr_id),
+        "--repo", owner_repo,
+        "--json", "headRefName,baseRefName,headRefOid",
+    ])
+
+    source_branch = result.get("headRefName", "")
+    target_branch = result.get("baseRefName", "")
+    fetch_head = result.get("headRefOid", "")
+
+    print(f"SOURCE_BRANCH: {source_branch}")
+    print(f"TARGET_BRANCH: {target_branch}")
+
+    fetch_result = subprocess.run(
+        ["git", "fetch", "origin", source_branch],
+        capture_output=True,
+        cwd=str(root),
+    )
+    if fetch_result.returncode != 0:
+        warn = (fetch_result.stderr or b"").decode("utf-8", errors="replace")
+        print(f"WARNING: git fetch failed: {warn}")
+
+    if not fetch_head:
+        head_result = subprocess.run(
+            ["git", "rev-parse", "FETCH_HEAD"],
+            capture_output=True,
+            cwd=str(root),
+        )
+        fetch_head = head_result.stdout.decode("utf-8").strip() if head_result.returncode == 0 else ""
+
+    print(f"FETCH_HEAD: {fetch_head}")
+
+    diff_result = subprocess.run(
+        ["git", "diff", "--name-status", f"origin/{target_branch}...FETCH_HEAD"],
+        capture_output=True,
+        cwd=str(root),
+    )
+    if diff_result.returncode == 0:
+        print("CHANGED_FILES:")
+        print(diff_result.stdout.decode("utf-8", errors="replace").strip())
+    else:
+        warn = (diff_result.stderr or b"").decode("utf-8", errors="replace")
+        print(f"WARNING: git diff failed: {warn}")
+
+
+def cmd_pr_comment(args):
+    root = find_repo_root()
+    remote_url = get_remote_url(root)
+    owner_repo = parse_owner_repo(remote_url)
+
+    tmp = tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8")
+    tmp.write(args.comment)
+    tmp.close()
+    try:
+        result = subprocess.run(
+            ["gh", "pr", "comment", str(args.pr_id),
+             "--repo", owner_repo,
+             "--body-file", tmp.name],
+            capture_output=True,
+        )
+        if result.returncode != 0:
+            err = (result.stderr or b"").decode("utf-8", errors="replace")
+            print(f"ERROR: gh pr comment failed: {err}")
+            sys.exit(1)
+        print(f"Posted comment on PR #{args.pr_id}")
+    finally:
+        try:
+            os.unlink(tmp.name)
+        except OSError:
+            pass
+
+
+def cmd_pr_inline(args):
+    root = find_repo_root()
+    remote_url = get_remote_url(root)
+    owner_repo = parse_owner_repo(remote_url)
+    token = get_github_token()
+
+    # Get HEAD commit for the PR (required by GitHub inline comment API)
+    result = gh_cmd([
+        "pr", "view", str(args.pr_id),
+        "--repo", owner_repo,
+        "--json", "headRefOid",
+    ])
+    commit_id = result.get("headRefOid", "")
+    if not commit_id:
+        print("ERROR: Could not get PR head commit ID")
+        sys.exit(1)
+
+    file_path = args.file_path.replace("\\", "/").lstrip("/")
+
+    data = {
+        "body": args.comment,
+        "commit_id": commit_id,
+        "path": file_path,
+        "line": args.line,
+        "side": "RIGHT",
+    }
+    resp = github_rest("POST", f"/repos/{owner_repo}/pulls/{args.pr_id}/comments", data, token)
+    comment_id = resp.get("id", "")
+    print(f"Posted inline comment on {file_path}:{args.line} (comment #{comment_id})")
+
+
+def cmd_pr_vote(args):
+    root = find_repo_root()
+    remote_url = get_remote_url(root)
+    owner_repo = parse_owner_repo(remote_url)
+
+    vote = args.vote.lower()
+    if vote == "approve":
+        gh_args = ["pr", "review", str(args.pr_id), "--repo", owner_repo, "--approve"]
+        gh_cmd(gh_args)
+        print(f"Approved PR #{args.pr_id}")
+    elif vote == "reject":
+        gh_args = [
+            "pr", "review", str(args.pr_id), "--repo", owner_repo,
+            "--request-changes",
+            "--body", "AI review found Critical or High severity issues. See inline comments for details.",
+        ]
+        gh_cmd(gh_args)
+        print(f"Requested changes on PR #{args.pr_id}")
+    elif vote in ("wait-for-author", "wait"):
+        gh_args = [
+            "pr", "review", str(args.pr_id), "--repo", owner_repo,
+            "--comment",
+            "--body", "AI review: waiting for author to address review comments.",
+        ]
+        gh_cmd(gh_args)
+        print(f"Posted 'waiting for author' comment on PR #{args.pr_id}")
+    elif vote == "reset":
+        print(f"INFO: GitHub does not support vote reset. No action taken for PR #{args.pr_id}")
+    else:
+        print(f"ERROR: Unknown vote '{vote}'. Use: approve|reject|wait-for-author|reset")
+        sys.exit(1)
+
+
+# --- Main ---
+
+def main():
+    parser = argparse.ArgumentParser(description="TAS GitHub PR Integration")
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    p = subparsers.add_parser("pr-get", help="Get PR metadata")
+    p.add_argument("pr_id", type=int, help="Pull Request number")
+
+    p = subparsers.add_parser("pr-diff", help="Fetch PR branch and list changed files")
+    p.add_argument("pr_id", type=int, help="Pull Request number")
+
+    p = subparsers.add_parser("pr-comment", help="Post summary comment on PR")
+    p.add_argument("pr_id", type=int, help="Pull Request number")
+    p.add_argument("--comment", required=True, help="Comment text (markdown supported)")
+
+    p = subparsers.add_parser("pr-inline", help="Post inline comment on PR diff")
+    p.add_argument("pr_id", type=int, help="Pull Request number")
+    p.add_argument("--file", dest="file_path", required=True, help="File path (e.g. src/api/users.ts)")
+    p.add_argument("--line", type=int, required=True, help="Line number")
+    p.add_argument("--comment", required=True, help="Inline comment text")
+
+    p = subparsers.add_parser("pr-vote", help="Set vote on PR")
+    p.add_argument("pr_id", type=int, help="Pull Request number")
+    p.add_argument("--vote", required=True,
+                   choices=["approve", "reject", "wait-for-author", "reset"],
+                   help="Vote to cast")
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "pr-get":
+        cmd_pr_get(args)
+    elif args.command == "pr-diff":
+        cmd_pr_diff(args)
+    elif args.command == "pr-comment":
+        cmd_pr_comment(args)
+    elif args.command == "pr-inline":
+        cmd_pr_inline(args)
+    elif args.command == "pr-vote":
+        cmd_pr_vote(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()