🦈 GitHub Pull Shark Automation

---

⚠️ Educational Purpose Only

This tool is designed for educational purposes to understand GitHub automation, CI/CD workflows, and API integration. Use responsibly and in accordance with GitHub's Terms of Service.

---

🏆 Earn Your Pull Shark Badge

Default 2 PRs

Bronze 16 PRs

Silver 128 PRs

Gold 1024 PRs

Automate PR creation and merging to unlock all achievement tiers!

🎯 What Is Pull Shark Automation?

A powerful Python automation framework that streamlines GitHub Pull Request workflows at scale. Perfect for developers who want to:

📑 Table of Contents

🌟 Features

🎯 Core Capabilities ✅ Automated PR Creation └─ Generate 100-10,000+ PRs ✅ Smart Auto-Merge └─ Intelligent PR merging ✅ Dual Execution Modes └─ Sequential & Parallel ✅ State Management └─ Resume from interruptions ✅ Dry Run Mode └─ Test without commits

🔧 Advanced Features ✅ Multi-Token Rotation └─ Automatic token switching ✅ Proxy Management └─ Built-in scraping & rotation ✅ Real-Time Notifications └─ Discord & Slack webhooks ✅ Rate Limit Handling └─ Smart API throttling ✅ Exponential Backoff └─ Intelligent retry logic

🎬 How It Works

%%{init: {'theme':'dark','themeVariables': {'primaryColor':'#ff6b6b','primaryTextColor':'#fff','primaryBorderColor':'#ff6b6b','lineColor':'#4ecdc4','secondaryColor':'#ffe66d','tertiaryColor':'#a8dadc'}}}%%
graph TB
    Start([🚀 Start Automation]) --> Config[📋 Load Configuration]
    Config --> Mode{🔀 Choose Mode}

    Mode -->|Sequential| Seq[📝 main.py<br/>Single Thread]
    Mode -->|Parallel| Par[⚡ parallel_automation.py<br/>Multi-Thread]

    Seq --> Git[🔧 Git Operations]
    Par --> Git

    Git --> Branch[🌿 Create Branch]
    Branch --> Commit[💾 Commit Changes]
    Commit --> Push[📤 Push to Remote]
    Push --> PR[🎯 Create PR]

    PR --> AutoMerge{🤖 Auto-merge?}
    AutoMerge -->|Yes| Merge[✅ Merge PR]
    AutoMerge -->|No| Next{📊 More PRs?}
    Merge --> Next

    Next -->|Yes| Git
    Next -->|No| Notify[📢 Send Notifications]
    Notify --> End([🎉 Complete!])

    style Start fill:#2ecc71,stroke:#27ae60,stroke-width:3px,color:#fff
    style End fill:#e74c3c,stroke:#c0392b,stroke-width:3px,color:#fff
    style PR fill:#3498db,stroke:#2980b9,stroke-width:2px,color:#fff
    style Merge fill:#f39c12,stroke:#e67e22,stroke-width:2px,color:#fff

🏗️ Architecture

System Design Overview

┌─────────────────────────────────────────────────────────────────┐
│                    🦈 Pull Shark Automation                      │
│                     Core Orchestration Layer                     │
└─────────────────────────────────────────────────────────────────┘
                                │
                ┌───────────────┴───────────────┐
                │                               │
        ┌───────▼────────┐            ┌────────▼───────┐
        │  📝 Sequential │            │  ⚡ Parallel   │
        │    main.py     │            │ parallel_*.py  │
        │   Reliable     │            │   Fast & Async │
        └───────┬────────┘            └────────┬───────┘
                │                              │
                └──────────────┬───────────────┘
                               │
        ┌──────────────────────┼──────────────────────┐
        │                      │                      │
   ┌────▼─────┐         ┌─────▼────┐         ┌──────▼─────┐
   │ 🔧 Git   │         │ 🐙 GitHub│         │ 🔑 Token   │
   │ Manager  │         │   Tool   │         │  Manager   │
   │ Ops      │         │ API Wrap │         │  Rotation  │
   └────┬─────┘         └─────┬────┘         └──────┬─────┘
        │                     │                      │
        └─────────────────────┼──────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        │                     │                     │
   ┌────▼─────┐         ┌────▼─────┐         ┌────▼─────┐
   │ 🌐 Proxy │         │ 📢 Notify│         │ 📝 Logger│
   │ Rotation │         │ Webhooks │         │  System  │
   └──────────┘         └──────────┘         └──────────┘

🔑 Component Matrix

📦 Installation

🚀 Quick Start Guide

Prerequisites Checklist

✅ Python 3.8 or higher
✅ Git 2.0 or higher
✅ GitHub CLI (gh)
✅ Active GitHub account
✅ Write access to target repository

Step 1️⃣: Clone Repository

# Clone via HTTPS
git clone https://github.com/itxashancode/Pull-Shark-Automation.git

# Or clone via SSH
git clone [email protected]:itxashancode/Pull-Shark-Automation.git

# Navigate to directory
cd Pull-Shark-Automation

Step 2️⃣: Install Dependencies

# Install all required packages
pip install -r requirements.txt

# Or use pip3 on some systems
pip3 install -r requirements.txt

Step 3️⃣: Install GitHub CLI

# Using Homebrew
brew install gh

# Verify installation
gh --version

# Debian/Ubuntu
curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | \
  sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | \
  sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null

sudo apt update
sudo apt install gh -y

# Fedora/RHEL/CentOS
sudo dnf install gh -y

# Arch Linux
sudo pacman -S github-cli

# Verify installation
gh --version

# Using winget
winget install --id GitHub.cli

# Or using Chocolatey
choco install gh

# Or using Scoop
scoop install gh

# Verify installation
gh --version

Step 4️⃣: Authenticate GitHub

# Start authentication
gh auth login

# Follow the interactive prompts:
# 1. Choose: GitHub.com
# 2. Protocol: HTTPS
# 3. Authenticate Git: Yes
# 4. Method: Login with a web browser

# Verify authentication
gh auth status

✓ Logged in to github.com as YourUsername
✓ Git operations for github.com configured to use https protocol.
✓ Token: *******************

✅ Installation Complete!

Ready to configure? Proceed to ⚙️ Configuration

⚙️ Configuration

🎛️ Setup Your Automation

📋 File 1: Main Config (config.json)

{
  "repo_path": ".",
  "base_branch": "main",
  "readme_file": "README.md",
  "pr_count": 2000,
  "delay_seconds": 30,
  "auto_merge": true,
  "dry_run": false,
  "max_retries": 3,
  "use_free_proxies": true,
  "max_concurrent": 10,
  "discord_webhook": "https://discord.com/api/webhooks/YOUR_WEBHOOK_HERE",
  "slack_webhook": "https://hooks.slack.com/services/YOUR_WEBHOOK_HERE"
}

🔑 File 2: GitHub Tokens (github_tokens.json)

{
  "tokens": [
    {
      "name": "Primary Token",
      "token": "github_pat_11XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    },
    {
      "name": "Secondary Token",
      "token": "github_pat_11XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    },
    {
      "name": "Backup Token",
      "token": "github_pat_11XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    }
  ]
}

🌐 File 3: Proxies (proxies.txt)

# Free HTTPS proxies (ip:port format)
8.219.97.248:9090
47.91.34.69:3128
161.35.70.249:8080
165.227.196.37:3128
64.225.4.5:9999

# Authenticated proxies (protocol://user:pass@ip:port)
http://username:[email protected]:8080
socks5://admin:[email protected]:1080

# Test single proxy
curl -x http://8.219.97.248:9090 https://api.github.com/

# Test with timeout
curl -x http://proxy:port --max-time 5 https://api.github.com/

🔔 Optional: Webhook Setup

https://discord.com/api/webhooks/1234567890/ABCDEFGHIJKLMNOPQRSTUVWXYZ

curl -X POST "YOUR_WEBHOOK_URL" \
  -H "Content-Type: application/json" \
  -d '{"content": "Test message from Pull Shark!"}'

https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXX

curl -X POST "YOUR_WEBHOOK_URL" \
  -H "Content-Type: application/json" \
  -d '{"text": "Test from Pull Shark!"}'

✅ Configuration Complete!

Next: 🚀 Usage Guide

🚀 Usage

🎮 Command Center

🏁 Quick Start Commands

# 1️⃣ Basic sequential run
python main.py

# 2️⃣ Fast parallel mode (recommended)
python parallel_automation.py --count 100 --concurrent 10

# 3️⃣ Test without creating PRs
python main.py --dry-run

# 4️⃣ Custom PR count
python main.py --count 500

# 5️⃣ Resume after interruption
python main.py  # Auto-resumes from state.json

📘 Sequential Mode (main.py)

python main.py [OPTIONS]

⭐ Best For: Reliability, debugging, small batches (<500 PRs)

📊 Example Output:

🚀 Starting from PR #1
⏱️  Delay: 30 seconds

🔹 Processing PR #1
  ├─ 🌿 Created branch: automation-1-a1b2c3d4
  ├─ 💾 Committed changes
  ├─ 📤 Pushed to remote
  └─ ✅ PR #12345 created successfully

✅ PR #12345 merged successfully
⏱️  Waiting 30 seconds...

🔹 Processing PR #2
...

⚡ Parallel Mode (parallel_automation.py)

python parallel_automation.py [OPTIONS]

⭐ Best For: Speed, large batches (500-10,000 PRs)

📊 Example Output:

🚀 Initializing parallel automation...
📋 Loaded 3 GitHub tokens
🔍 Fetching proxies...
  📦 Total unique proxies collected: 342
  ✅ Working proxies: 87

🚀 Starting parallel automation

📈 Progress: 134/200 PRs
   ✓ Success: 130
   ✗ Failed: 4
   ⚡ Speed: 45.2 PRs/min

🎉 Automation Complete!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total: 200 PRs
✅ Success: 196 (98%)
❌ Failed: 4 (2%)
⚡ Speed: 43.8 PRs/min
⏱️ Time: 4 minutes 34 seconds
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📚 Usage Examples

# Test with dry run first
python main.py --count 20 --dry-run

# Run actual automation
python main.py --count 20 --delay 15

# Expected time: ~5 minutes

🚀 Starting from PR #1
⏱️  Delay: 15 seconds

✅ PR #1-20 created successfully
🎉 Bronze Pull Shark Badge unlocked!

# High-speed parallel mode
python parallel_automation.py --count 150 --concurrent 15

# Expected time: ~3-5 minutes

🚀 Starting parallel automation

📈 150/150 ✓ 147 ✗ 3 ⚡ 42.5 PRs/min

🎉 Silver Pull Shark Badge unlocked!
⏱️ Completed in 3 minutes 32 seconds

# Ultra-fast mode with 20 workers
python parallel_automation.py \
  --count 1024 \
  --concurrent 20

# Expected time: ~16-20 minutes with 3 tokens

🚀 Initializing parallel automation...
📋 Loaded 3 tokens
🌐 Working proxies: 87

📈 1024/1024 ✓ 982 ✗ 42 ⚡ 62.5 PRs/min

🎉🎉🎉 GOLD PULL SHARK UNLOCKED! 🎉🎉🎉
⏱️ Completed in 16 minutes 23 seconds

# Check current state
cat state.json
# Output: {"last_completed_pr": 350}

# Resume from PR #351
python main.py --count 500
# Automatically continues from #351

🔄 Resuming from PR #351 (found state.json)
⏱️  Remaining: 150 PRs

🔹 Processing PR #351
...

python main.py --count 5 --dry-run

🔍 DRY RUN MODE - No actual commits

🔹 PR #1 Simulation
  📝 Would create branch: automation-1-abc123
  📝 Would modify: README.md
  📝 Would commit: "Automated update #1"
  📝 Would push to: origin/automation-1-abc123
  📝 Would create PR with title: "Automated PR #1"
  ✅ Simulation successful

🔹 PR #2 Simulation
...

✅ All 5 PRs simulated successfully

🔧 Components Deep Dive

🏗️ System Architecture Breakdown

1️⃣ GitManager (git_manager.py)

🎯 Purpose: Handle all Git operations with retry logic and internet connectivity checks

🔑 Key Methods:

class GitManager:
    def __init__(self, base_branch: str, max_retries: int, logger)

    def wait_for_internet(self, timeout: int = 10) -> bool:
        """Wait for stable internet connection"""

    def run(self, command: List[str]) -> subprocess.CompletedProcess:
        """Execute git command with exponential backoff retry"""

    def sync_base(self) -> bool:
        """Sync base branch with remote"""

    def create_branch(self, name: str) -> bool:
        """Create and checkout new branch"""

    def commit(self, file: str, message: str) -> bool:
        """Stage and commit changes"""

    def push(self, branch: str) -> bool:
        """Push branch to remote"""

✨ Features:

2️⃣ GitHubTool (github_tool.py)

🎯 Purpose: Wrap GitHub CLI with rate limit management and PR operations

🔑 Key Methods:

class GitHubTool:
    def check_rate_limit(self) -> Dict:
        """Query GitHub API rate limit status"""

    def create_pr(self, title: str, body: str, head: str) -> Optional[str]:
        """Create pull request via GitHub CLI"""

    def merge_pr(self, branch: str) -> bool:
        """Auto-merge pull request"""

📊 Rate Limit Flow:

%%{init: {'theme':'dark'}}%%
graph LR
    A[Check Rate Limit] --> B{Remaining > 100?}
    B -->|Yes| C[Proceed]
    B -->|No| D[Calculate Wait Time]
    D --> E[Sleep Until Reset]
    E --> A

    style A fill:#3498db
    style C fill:#2ecc71
    style D fill:#f39c12

3️⃣ TokenManager (token_manager.py)

🎯 Purpose: Manage multiple GitHub tokens with automatic rotation

🔄 Rotation Algorithm:

def get_best_token():
    """
    1. Filter active tokens ✅
    2. Sort by remaining requests (descending) ⬇️
    3. Return token with highest limit ⭐
    4. Update last_used timestamp 🕐
    5. Decrement remaining count ➖
    """

📊 Token Statistics Example:

📋 Token Status Dashboard
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Token 1 (Primary):    4,850 / 5,000 ⚡
Token 2 (Secondary):  5,000 / 5,000 ✅
Token 3 (Backup):     4,920 / 5,000 ⚡
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total Available: 14,770 requests
Next Reset: 42 minutes
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

4️⃣ ProxyManager (proxy_manager.py)

🎯 Purpose: Rotate proxies to distribute requests

🔄 Rotation Strategy:

# Round-robin with queue
proxy1 → proxy2 → proxy3 → proxy1 → ...

# Get proxy (auto-rotates)
proxy = proxy_queue.get()    # Returns proxy1
proxy_queue.put(proxy)       # Re-add to end

# Next: proxy2, then proxy3, then proxy1...

📊 Supported Formats:

# Simple proxies
"8.219.97.248:9090"
"http://47.91.34.69:3128"

# Authenticated proxies
"http://user:[email protected]:8080"
"socks5://admin:[email protected]:1080"

5️⃣ Notifier (notifier.py)

🎯 Purpose: Send real-time notifications

🎨 Notification Types:

📨 Example Notifications:

# Success
notifier.send(
    "✅ PR #123 created successfully\n"
    "Branch: automation-123-abc\n"
    "PR Number: #456",
    "success"
)

# Progress
notifier.send(
    "📊 Progress: 50/100 PRs\n"
    "Speed: 12.5 PRs/min",
    "info"
)

# Error
notifier.send(
    "❌ PR #75 failed\n"
    "Error: Network timeout",
    "error"
)

6️⃣ Logger (logger.py)

🎯 Purpose: Dual-output logging system

📝 Log Levels:

logger.info("✅ PR #123 created")       # General info
logger.warning("⚠️ Rate limit low")     # Warnings
logger.error("❌ Failed to push")       # Errors
logger.debug("🔍 Token: abc...")        # Debug info

📄 Sample Log Output:

2026-02-15 10:22:11 - INFO - Starting automation from PR #1
2026-02-15 10:22:15 - INFO - Created branch automation-1-abc123
2026-02-15 10:22:18 - INFO - Committed changes to README.md
2026-02-15 10:22:22 - INFO - Pushed branch automation-1-abc123
2026-02-15 10:22:25 - INFO - Created PR #12345
2026-02-15 10:22:28 - INFO - Merged PR #12345
2026-02-15 10:22:28 - WARNING - Rate limit: 4850 remaining

⚡ High-Performance Modules

🚀 Turbocharged Async Implementation

The high_performance package provides async-first implementations for maximum throughput and parallel processing. Fully Windows-compatible with proper event loop policies.

📁 Module Structure

high_performance/
├── __init__.py              # 📦 Package exports
├── git_manager.py          # 🔧 Async Git operations
├── github_tool.py          # 🐙 Async GitHub API
├── token_manager.py        # 🔑 Async token rotation
├── proxy_manager.py        # 🌐 Async proxy scraping
└── proxy_refresher.py      # 🔄 Background maintenance

🚀 Performance Comparison

📊 Real-World Performance

Test: 1000 PRs with High-Performance Modules

python parallel_automation.py --count 1000 --concurrent 20

Results:

⏱️  Time: 16 minutes (vs 8+ hours sequential)
✅ Success Rate: 94%
📈 Speed: 62.5 PRs/min
🔄 Token Rotation: 3 tokens cycled automatically
🌐 Proxies Used: 87 working proxies
💾 Memory: ~720 MB peak

⚡1️⃣ HighPerformanceGitManager

🎯 Key Features:

# Windows-compatible async Git operations
async def sync_base(self) -> bool:
    """Fast sync with depth=1 optimization"""

async def create_branch(self, name: str) -> bool:
    """Async branch creation"""

async def commit(self, file: str, message: str, content: str) -> bool:
    """Single-operation async commit"""

async def push(self, branch: str) -> bool:
    """Non-blocking push"""

🪟 Windows Optimization:

# Thread pool prevents blocking
self.executor = ThreadPoolExecutor(max_workers=10)

# Run git ops in executor
loop = asyncio.get_event_loop()
result = await loop.run_in_executor(
    self.executor,
    lambda: git_operation()
)

⚡2️⃣ HighPerformanceGitHubTool

🎯 Key Features:

• Semaphore Control: Limit concurrent API calls
• Smart Token Selection: Auto-switch on rate limits
• Proxy Integration: Built-in proxy support

# Concurrency control
self.semaphore = asyncio.Semaphore(50)  # Max 50 concurrent

async with self.semaphore:
    process = await asyncio.create_subprocess_exec(...)

⚡3️⃣ HighPerformanceTokenManager

🎯 Key Features:

• Real-Time Rate Limits: Live API checks every 5 minutes
• Fair Distribution: Shuffle tokens for balanced usage
• Auto-Refresh: Update stale token status

# Live rate limit check
async def check_token_rate_limit_async(self, token):
    headers = {'Authorization': f"token {token['token']}"}
    async with session.get('https://api.github.com/rate_limit', headers=headers):
        # Get real-time remaining count
        return remaining, reset_time

⚡4️⃣ HighPerformanceProxyManager

🎯 Proxy Sources:

sources = [
    # HTML Table Sources
    'https://free-proxy-list.net/',
    'https://www.sslproxies.org/',

    # API/Raw Sources (More Reliable)
    'https://api.proxyscrape.com/v2/',
    'https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt',
    'https://raw.githubusercontent.com/clarketm/proxy-list/master/proxy-list-raw.txt'
]

🧪 Concurrent Testing:

# Test 50 proxies simultaneously
semaphore = asyncio.Semaphore(50)

async def limited_test(proxy):
    async with semaphore:
        return await self.test_proxy(proxy)

# Parallel execution
results = await asyncio.gather(*[limited_test(p) for p in proxies])

⚡ Latency-Based Sorting:

# Sort by speed (fastest first)
working_proxies.sort(key=lambda x: x.get("latency", 999))

⚡5️⃣ ProxyRefresher

🎯 Background Service

# Run in separate terminal
python -m high_performance.proxy_refresher

Output:

🔄 Proxy Refresher Started
⏰ Will refresh proxies every 30 minutes

[10:00:00] Refreshing proxies...
  🔎 Fetching from free-proxy-list...
  🔎 Fetching from proxyscrape...
  📦 Collected: 342 unique proxies
  📦 Testing: 342 proxies...
  ✅ Working: 87 proxies

[10:30:00] Refreshing proxies...
...

🔐 Security & Best Practices

🛡️ Keep Your Tokens Safe

🔒 Token Security Checklist

🛡️ API Rate Limits

GitHub Limits:

📊 Rate Limit Strategies:

# 1️⃣ Token Rotation
token = token_manager.get_best_token()

# 2️⃣ Monitor Limits
rate_info = gh.check_rate_limit()
if rate_info["remaining"] < 100:
    time.sleep(wait_time)

# 3️⃣ Exponential Backoff
for attempt in range(max_retries):
    try:
        result = api_call()
        break
    except RateLimitError:
        time.sleep(2 ** attempt)

🌐 Proxy Best Practices

🐛 Troubleshooting

🔧 Common Issues & Solutions

❌ Issue 1: "gh: command not found"

# macOS
brew install gh

# Linux (Debian/Ubuntu)
sudo apt update && sudo apt install gh -y

# Windows
winget install --id GitHub.cli

# Verify
gh --version

❌ Issue 2: "Authentication failed"

# Re-authenticate
gh auth login

# Or use token directly
echo "YOUR_TOKEN" | gh auth login --with-token

# Verify authentication
gh auth status

❌ Issue 3: "API rate limit exceeded"

{
  "tokens": [
    {"name": "Token 1", "token": "ghp_xxx1"},
    {"name": "Token 2", "token": "ghp_xxx2"},
    {"name": "Token 3", "token": "ghp_xxx3"}
  ]
}

gh api rate_limit

# Output shows:
# - Remaining requests
# - Reset time

{
  "delay_seconds": 60
}

❌ Issue 4: "Failed to push branch"

ping github.com

gh repo view --web
# Verify you have write access

gh api repos/OWNER/REPO/branches/main/protection

gh auth refresh

❌ Issue 5: "No changes to commit"

python main.py --reset

{
  "readme_file": "CONTRIBUTING.md"
}

🔍 Enable Debug Mode

# Set environment variable
export LOG_LEVEL=DEBUG

# Run with debug logging
python main.py

# Or edit logger.py
logger.setLevel(logging.DEBUG)

Debug Output Example:

DEBUG - Token selected: primary (4850 remaining)
DEBUG - Proxy selected: http://8.219.97.248:9090
DEBUG - Executing: git push origin automation-1-abc123
DEBUG - Command output: [SUCCESS]
DEBUG - API response: {"pr_number": 12345}

📈 Performance Tips

⚡ Maximize Your Speed

🚀 Speed Optimization Matrix

💾 Resource Optimization

Optimal Settings by Hardware:

📊 Monitor Resources:

# CPU & Memory Usage
top -p $(pgrep -f parallel_automation)

# Disk I/O
iotop -p $(pgrep -f parallel_automation)

# Network Stats
nethogs

📊 Benchmarks

{
  "pr_count": 100,
  "delay_seconds": 30,
  "auto_merge": true
}

⏱️  Time: 52 minutes
✅ Success: 98 PRs (98%)
❌ Failed: 2 PRs (2%)
🔁 Retries: 3 operations
💾 Memory: ~50 MB
📈 Speed: 1.9 PRs/min

python parallel_automation.py --count 1000 --concurrent 10

⏱️  Time: 28 minutes
✅ Success: 960 PRs (96%)
❌ Failed: 40 PRs (4%)
🔁 Retries: 42 operations
💾 Memory: ~380 MB
📈 Speed: 35.7 PRs/min

python parallel_automation.py --count 1000 --concurrent 20

⏱️  Time: 16 minutes
✅ Success: 940 PRs (94%)
❌ Failed: 60 PRs (6%)
🔁 Retries: 68 operations
💾 Memory: ~720 MB
📈 Speed: 62.5 PRs/min
🔄 Tokens: 3 rotated
🌐 Proxies: 87 used

🤝 Contributing

💪 Join the Community

🚀 How to Contribute

# 1️⃣ Fork the repository
gh repo fork itxashancode/Pull-Shark-Automation

# 2️⃣ Clone your fork
git clone https://github.com/YOUR_USERNAME/Pull-Shark-Automation.git
cd Pull-Shark-Automation

# 3️⃣ Create feature branch
git checkout -b feature/amazing-feature

# 4️⃣ Make your changes
# ... edit files ...

# 5️⃣ Commit with conventional commits
git commit -m "feat: add amazing feature"

# 6️⃣ Push to your fork
git push origin feature/amazing-feature

# 7️⃣ Create Pull Request
gh pr create --title "Add amazing feature" --body "Description..."

📝 Code Style Guide

# ✅ Good - Clear, documented, typed
def create_pull_request(title: str, body: str, head: str) -> Optional[str]:
    """
    Create a pull request via GitHub CLI.

    Args:
        title: PR title
        body: PR description
        head: Source branch name

    Returns:
        PR number as string, or None if failed
    """
    try:
        result = gh_tool.create_pr(title, body, head)
        return result
    except Exception as e:
        logger.error(f"Failed to create PR: {e}")
        return None

# ❌ Bad - Unclear, no types, no docs
def createPR(t,b,h):
    result=gh_tool.create_pr(t,b,h)
    return result

🎨 Formatting Tools:

# Auto-format with black
black *.py

# Check style with flake8
flake8 *.py

# Type checking with mypy
mypy *.py

🐛 Reporting Bugs

Found a bug? Help us fix it!

Steps:

1. Check existing issues
2. Create new issue with template
3. Include:
   • OS & Python version
   • Full error message
   • Steps to reproduce
   • Expected vs actual behavior

💡 Suggesting Features

Have an idea? We'd love to hear it!

Steps:

1. Check existing discussions
2. Open feature request
3. Describe:
   • Use case
   • Proposed solution
   • Alternatives considered

📄 License

MIT License

MIT License

Copyright (c) 2026 Pull Shark Automation

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

🙏 Acknowledgments

🌟 Built With Amazing Tools

---

💖 Special Thanks

• GitHub - For excellent CLI and API
• Python Community - For amazing async libraries
• Contributors - Everyone who improved this project
• You - For using Pull Shark Automation!

---

📞 Support & Community

---

⭐ Star History

---

🎉 Final Words

🦈 Unleash the Pull Shark! 🦈

If this tool helped you earn your Pull Shark badge, please ⭐ star the repository!

Made with ❤️ by developers, for developers

⬆️ Back to Top

---

⚠️ Remember: This tool is for educational purposes. Use responsibly and follow GitHub's Terms of Service.