PR Generation

def create_fork(repo_owner, repo_name):
    """
    Create a TEMPORARY STAGING fork of the repository for PR creation.
    
    If the user already owns the repo, returns the original repo info (no fork needed).
    If fork already exists, returns the existing fork information.
    """
    headers = {
        "Authorization": f"token {Config.GITHUB_TOKEN}",
        "Accept": "application/vnd.github.v3+json"
    }
    
    # Get authenticated user's username
    user_response = requests.get(
        "https://api.github.com/user", 
        headers=headers
    )

import uuid

# Create unique branch name
new_branch_name = f"dependify-{uuid.uuid4().hex[:8]}"
new_branch = repo.create_head(new_branch_name)
new_branch.checkout()

commit_message = """🤖 Automated code modernization by Dependify

This commit contains automated refactoring to update outdated syntax
and improve code quality using AI-powered analysis.

Generated with Dependify 2.0
"""
repo.index.commit(commit_message)

try:
    origin.push(new_branch)
    print(f"Pushed branch {new_branch_name} to remote")
except Exception as e:
    print(f"Error pushing to remote: {e}")
    raise

def generate_pr_description(file_changes: List[FileChange]) -> str:
    """
    Generate a detailed, professional PR description similar to GitButler style.
    Shows what changed, why it changed, and the impact.
    """
    total_files = len(file_changes)
    
    # Calculate accurate diff stats
    total_added = 0
    total_removed = 0
    for fc in file_changes:
        added, removed = ChangelogFormatter.calculate_diff_stats(
            fc.old_code, fc.new_code
        )
        total_added += added
        total_removed += removed
    
    pr_desc = []
    pr_desc.append("## 🤖 Automated Code Modernization\n")
    pr_desc.append("This pull request modernizes outdated code patterns and updates deprecated syntax to current best practices.\n")

def extract_key_changes(old_code: str, new_code: str, explanation: str) -> List[str]:
    key_changes = []
    
    # Look for specific patterns
    patterns = {
        'async/await': ('async', 'await'),
        'arrow functions': ('=>',),
        'const/let': ('const ', 'let '),
        'template literals': ('`',),
        'destructuring': ('{', '}'),
        'spread operator': ('...',),
        'type annotations': (': string', ': number', ': boolean'),
    }
    
    for pattern_name, keywords in patterns.items():
        if any(keyword in new_code for keyword in keywords) and \
           not any(keyword in old_code for keyword in keywords):
            key_changes.append(f"Added {pattern_name}")
    
    return key_changes[:5]  # Limit to 5 key changes

def calculate_diff_stats(old_code: str, new_code: str) -> tuple:
    """
    Calculate exact git-style diff statistics matching GitHub's display.
    """
    import difflib
    
    old_lines = old_code.split('\n') if old_code else []
    new_lines = new_code.split('\n') if new_code else []
    
    # Use difflib for accurate line-by-line comparison (same as git)
    matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
    
    added = 0
    removed = 0
    
    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
        if tag == 'replace':
            removed += (i2 - i1)
            added += (j2 - j1)
        elif tag == 'delete':
            removed += (i2 - i1)
        elif tag == 'insert':
            added += (j2 - j1)
    
    return added, removed

def create_pull_request(
    new_branch_name, 
    repo_owner, 
    repo_name, 
    base_branch, 
    head_owner, 
    is_own_repo=False, 
    changelog_markdown=None
):
    pr_title = f"🤖 Automated code modernization by Dependify"
    
    # Use provided changelog or default PR body
    if changelog_markdown:
        pr_body = changelog_markdown
    
    headers = {
        "Authorization": f"token {Config.GITHUB_TOKEN}",
        "Accept": "application/vnd.github.v3+json"
    }
    
    # If it's user's own repo, head is just the branch name
    # If it's a fork, head is "username:branch_name"
    if is_own_repo:
        head = new_branch_name
    else:
        head = f"{head_owner}:{new_branch_name}"
    
    data = {
        "title": pr_title,
        "head": head,
        "base": base_branch,
        "body": pr_body
    }
    
    url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/pulls"
    response = requests.post(url, json=data, headers=headers)

pr_desc.append("### ✅ Review Checklist\n")
pr_desc.append("- [ ] Review the changes in each file")
pr_desc.append("- [ ] Verify the modernized syntax is correct")
pr_desc.append("- [ ] Run tests to ensure no breaking changes")
pr_desc.append("- [ ] Check for any deprecated API usage\n")

if fc.confidence_score >= 80:
    badge = "🟢 HIGH CONFIDENCE"
elif fc.confidence_score >= 60:
    badge = "🟡 MEDIUM CONFIDENCE"
else:
    badge = "🔴 NEEDS REVIEW"

md.append(f"**{badge}** - Score: {fc.confidence_score}/100\n")

# 1. Create fork (or use original if user owns it)
fork_result = create_fork(repo_owner, repo_name)
is_own_repo = fork_result.get("is_own_repo", False)

# 2. Clone repository
authenticated_url = repo_url.replace(
    "https://github.com/", 
    f"https://{Config.GITHUB_TOKEN}@github.com/"
)
subprocess.run(["git", "clone", authenticated_url, staging_dir])

# 3. Load repository
repo, origin, origin_url = load_repository(staging_dir)

# 4. Apply refactored code to files
for job in refactored_jobs:
    with open(job["path"], "w") as f:
        f.write(job["new_content"])
    files_changed.append(job["path"])

# 5. Create branch and push
new_branch_name, username = create_and_push_branch(
    repo, origin, files_changed
)

# 6. Generate AI-explained changelog
if file_changes:
    pr_description = ChangelogFormatter.generate_pr_description(
        file_changes
    )

# 7. Create pull request
pr_url = create_pull_request(
    new_branch_name,
    repo_owner,
    repo_name,
    "main",
    username,
    is_own_repo,
    pr_description
)

response_data = {
    "status": "success",
    "message": "Repository updated and pull request created successfully",
    "repository": payload.repository,
    "files_analyzed": len(job_list),
    "files_updated": len(files_changed),
    "branch": new_branch_name,
    "pull_request_url": pr_url,
    "is_own_repo": is_own_repo,
    "quality_metrics": {
        "average_confidence_score": round(total_confidence, 1),
        "all_files_validated": all_valid,
        "high_confidence_files": high_confidence_count
    }
}

# Add fork information if it was forked
if not is_own_repo:
    response_data["fork_info"] = {
        "message": "A temporary staging fork was created to propose these changes",
        "fork_owner": username,
        "fork_name": repo_name,
        "can_delete": True,
        "delete_note": "You can safely delete this fork after the PR is merged or closed"
    }