Platform Bridge API Reference¶

__all__ = [
    "PlatformBridge",
    "detect_platform",
    "Platform",
    "PlatformDetectionError",
    "CLIToolMissingError"
]

PlatformBridge(repo_path: str = ".") -> PlatformBridge

from claude.tools.platform_bridge import PlatformBridge

# Use current directory
bridge = PlatformBridge()

# Use specific repository
bridge = PlatformBridge("/path/to/repo")

def create_issue(
    self,
    title: str,
    body: str,
    labels: Optional[List[str]] = None
) -> Dict[str, Any]

{
    "number": 42,                    # Issue/work item number
    "url": "https://...",            # Web URL to issue
    "title": "Issue title",          # Created title
    "state": "open"                  # Current state
}

issue = bridge.create_issue(
    title="Add authentication",
    body="Implement JWT authentication\n\n## Requirements\n- Token validation\n- Refresh tokens",
    labels=["enhancement", "security"]  # GitHub only
)

print(f"Created issue #{issue['number']}: {issue['url']}")

def create_draft_pr(
    self,
    title: str,
    body: str,
    source_branch: str,
    target_branch: str = "main"
) -> Dict[str, Any]

{
    "number": 123,                   # PR number
    "url": "https://...",            # Web URL to PR
    "title": "PR title",             # Created title
    "state": "draft",                # Initial state
    "source_branch": "feat/auth",    # Source branch
    "target_branch": "main"          # Target branch
}

pr = bridge.create_draft_pr(
    title="feat: Add JWT authentication",
    body="## Summary\n\nImplements JWT authentication\n\n## Test Plan\n- Unit tests\n- Integration tests",
    source_branch="feat/auth",
    target_branch="main"
)

print(f"Draft PR #{pr['number']}: {pr['url']}")

def mark_pr_ready(self, pr_number: int) -> Dict[str, Any]

{
    "number": 123,              # PR number
    "state": "open",            # New state (no longer draft)
    "success": True             # Operation succeeded
}

result = bridge.mark_pr_ready(pr_number=123)

if result['success']:
    print(f"PR #{result['number']} be ready fer review!")

def add_pr_comment(
    self,
    pr_number: int,
    comment: str
) -> Dict[str, Any]

{
    "comment_id": "456",         # Comment identifier
    "pr_number": 123,            # PR number
    "body": "Comment text",      # Created comment
    "url": "https://..."         # Web URL to comment
}

comment = bridge.add_pr_comment(
    pr_number=123,
    comment="All tests be passin'! Ready fer merge. 🚢"
)

print(f"Added comment: {comment['url']}")

def check_ci_status(self, pr_number: int) -> Dict[str, Any]

{
    "all_passing": True,           # All checks passed
    "total_checks": 5,             # Total number of checks
    "passed": 5,                   # Number passed
    "failed": 0,                   # Number failed
    "pending": 0,                  # Number still runnin'
    "checks": [                    # List of individual checks
        {
            "name": "build",
            "status": "success",
            "url": "https://..."
        },
        {
            "name": "test",
            "status": "success",
            "url": "https://..."
        }
    ]
}

status = bridge.check_ci_status(pr_number=123)

if status['all_passing']:
    print("All checks passed! Ready to merge.")
elif status['pending'] > 0:
    print(f"Waitin' on {status['pending']} checks...")
else:
    print(f"Failed checks: {status['failed']}")
    for check in status['checks']:
        if check['status'] == 'failure':
            print(f"  - {check['name']}: {check['url']}")

def detect_platform(repo_path: str = ".") -> Platform

from claude.tools.platform_bridge import detect_platform, Platform

platform = detect_platform()

if platform == Platform.GITHUB:
    print("This be a GitHub repository")
elif platform == Platform.AZDO:
    print("This be an Azure DevOps repository")

class Platform(Enum):
    GITHUB = "github"
    AZDO = "azdo"

from claude.tools.platform_bridge import Platform

if bridge.platform == Platform.GITHUB:
    print("Using GitHub operations")

from claude.tools.platform_bridge import PlatformBridge, PlatformDetectionError

try:
    bridge = PlatformBridge()
except PlatformDetectionError as e:
    print(f"Could not detect platform: {e}")
    print("Add a remote: git remote add origin <url>")

from claude.tools.platform_bridge import PlatformBridge, CLIToolMissingError

try:
    bridge = PlatformBridge()
    issue = bridge.create_issue(title="Test", body="Body")
except CLIToolMissingError as e:
    print(f"Missing: {e.tool_name}")
    print(f"Install with: {e.install_command}")

from claude.tools.platform_bridge import PRNotFoundError

try:
    bridge.mark_pr_ready(pr_number=999)
except PRNotFoundError as e:
    print(f"PR #{e.pr_number} doesn't exist")

from claude.tools.platform_bridge import BranchNotFoundError

try:
    pr = bridge.create_draft_pr(
        title="Test",
        body="Body",
        source_branch="nonexistent-branch"
    )
except BranchNotFoundError as e:
    print(f"Branch '{e.branch_name}' doesn't exist")

from typing import Dict, List, Optional, Any
from pathlib import Path

class PlatformBridge:
    def __init__(self, repo_path: str = ".") -> None: ...

    def create_issue(
        self,
        title: str,
        body: str,
        labels: Optional[List[str]] = None
    ) -> Dict[str, Any]: ...

    def create_draft_pr(
        self,
        title: str,
        body: str,
        source_branch: str,
        target_branch: str = "main"
    ) -> Dict[str, Any]: ...

# Multiple threads can check CI status simultaneously
status1 = bridge.check_ci_status(pr_number=123)
status2 = bridge.check_ci_status(pr_number=456)

# Don't create multiple PRs from different threads
# Results be unpredictable