import requests
from anthropic import Anthropic

# Fetch issues from a milestone
def get_milestone_issues(owner, repo, milestone_number, token):
    url = f"https://api.github.com/repos/{owner}/{repo}/issues"
    params = {
        "milestone": milestone_number,
        "state": "open",
        "per_page": 100
    }
    headers = {"Authorization": f"token {token}"}
    response = requests.get(url, params=params, headers=headers)
    return response.json()

# Prepare issues for AI processing
issues_text = "\n\n".join([
    f"Issue #{issue['number']}: {issue['title']}\n"
    f"Labels: {', '.join([l['name'] for l in issue['labels']])}\n"
    f"Description: {issue['body'][:500] if issue['body'] else 'No description'}"
    for issue in milestone_issues
])

# Send to Claude for roadmap generation
client = Anthropic(api_key="your-api-key")
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4000,
    messages=[{
        "role": "user",
        "content": f"""Transform these GitHub issues into a structured roadmap document.
        Group them by theme, prioritize items, and write clear descriptions.

        ISSUES:
        {issues_text}

        Format the output with:
        - Executive summary
        - Themed sections with issue groups
        - Priority indicators (High/Medium/Low)
        - Timeline suggestions based on issue complexity"""
    }]
)
print(response.content[0].text)

import openai

# Generate roadmap from issue data
openai.api_key = "your-api-key"

issues_data = """
- Issue #45: Add OAuth2 authentication support (labels: enhancement, security)
- Issue #67: Improve database query performance (labels: performance, backend)
- Issue #89: Create API documentation (labels: documentation)
- Issue #102: Mobile app dark mode (labels: frontend, enhancement)
- Issue #115: Implement caching layer (labels: performance, backend)
"""

prompt = f"""Create a quarterly roadmap document from these issues.
Group by category, estimate effort, and write descriptions.

Issues:
{issues_data}

Output format:
## Q2 2026 Roadmap

### High Priority
[Grouped issues with descriptions]

### Medium Priority
[Grouped issues with descriptions]

### Nice to Have
[Grouped issues with descriptions]

Include effort estimates: S (Small), M (Medium), L (Large)
"""

response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.7
)

print(response.choices[0].message.content)

import google.generativeai as genai

genai.configure(api_key="your-api-key")

issues_summary = """
Epic: User Authentication
- #201: Implement JWT tokens
- #205: Add password reset flow
- #210: Social login integration

Epic: Performance
- #189: Optimize image loading
- #195: Reduce bundle size
- #220: Implement lazy loading
"""

model = genai.GenerativeModel('gemini-2.5-pro-preview-0325')

roadmap_prompt = f"""Create a technical roadmap document.
Structure it with:
1. Overview section
2. Epics as main sections
3. Individual items with descriptions
4. Dependencies between items
5. Suggested milestones

Issues to process:
{issues_summary}
"""

response = model.generate_content(roadmap_prompt)
print(response.text)

import requests
import json
from datetime import datetime

def generate_roadmap(owner, repo, milestone, ai_client):
    """Complete workflow for generating roadmap from milestone issues."""

    # Step 1: Fetch milestone data
    milestone_url = f"https://api.github.com/repos/{owner}/{repo}/milestones/{milestone}"
    milestone_data = requests.get(milestone_url).json()

    # Step 2: Fetch issues
    issues_url = f"https://api.github.com/repos/{owner}/{repo}/issues"
    params = {"milestone": milestone, "state": "all", "per_page": 100}
    issues = requests.get(issues_url, params=params).json()

    # Step 3: Categorize by labels
    categorized = {}
    for issue in issues:
        for label in issue.get('labels', []):
            if label['name'] not in categorized:
                categorized[label['name']] = []
            categorized[label['name']].append({
                'number': issue['number'],
                'title': issue['title'],
                'body': issue.get('body', '')[:300],
                'state': issue['state']
            })

    # Step 4: Generate roadmap with AI
    prompt = f"""Create a roadmap for {milestone_data['title']}

Milestone Description: {milestone_data.get('description', 'N/A')}

Categorized Issues:
{json.dumps(categorized, indent=2)}

Write a professional roadmap document with:
- Overview
- Categorized sections
- Issue descriptions
- Status indicators
"""

    response = ai_client.chat.completions.create(
        model="claude-sonnet-4-20250514",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

# Usage
roadmap = generate_roadmap("your-org", "your-repo", 1, openai_client)
print(roadmap)