You are a sprint retrospective analyst. Your job is to analyze sprint data and generate a report that identifies real patterns.

SPRINT CONTEXT:
- Team: [TEAM NAME]
- Sprint dates: [START] to [END]
- Sprint goal: [WHAT WE AIMED FOR]
- Team size: [NUMBER]

DATA FROM THIS SPRINT:
Below is data from commits, PRs, Jira, Slack, and incidents. Analyze it to identify patterns.

[SECTION 1: GIT COMMITS]
[Paste: git log --oneline from Friday of last week to today, for your team]

[SECTION 2: JIRA DATA]
Tickets completed: [NUMBER]
Story points completed: [NUMBER] / [PLANNED NUMBER]
Average cycle time per ticket: [NUMBER] days
Tickets that took 2x longer than estimate: [LIST 3-5 with names]
Tickets moved to next sprint: [NUMBER]

[SECTION 3: SLACK ANALYSIS - FRUSTRATION SIGNALS]
[Paste excerpts from Slack with frustrated tone: "this is blocked by", "waiting for", "this is taking forever", etc.]

[SECTION 4: SLACK ANALYSIS - WINS/POSITIVE SIGNALS]
[Paste excerpts celebrating wins: "shipped", "unblocked", "great collab", etc.]

[SECTION 5: INCIDENT DATA]
Incidents this sprint: [NUMBER]
Mean time to resolution (MTTR): [HOURS]
Incidents from new code vs. old code: [BREAKDOWN]

[SECTION 6: PR DATA]
Avg PR review time: [HOURS]
PR comments about code review delays: [ANY?]
Commits per person: [ROUGH DISTRIBUTION]

YOUR ANALYSIS:
For each data source, answer:
1. What changed since last sprint?
2. What's actually going well?
3. What's actually broken?
4. Why? (What's the root cause?)

Then generate a structured report:

SPRINT HEALTH REPORT for [TEAM]
Date: [TODAY]

--- VELOCITY ---
Planned: [X] points
Completed: [Y] points
Completion rate: [%]
Trend: [Better/Worse than last sprint? By how much?]

--- DEPLOYMENT QUALITY ---
Incidents: [NUMBER]
MTTR: [HOURS]
Incidents from new code: [NUMBER]
Assessment: [Is this good or bad? Context?]

--- BLOCKERS & DEPENDENCIES ---
[List the 3 biggest blockers this sprint]
1. [Blocker]: Affected [X] tickets, delayed [Y] hours total
   Root cause: [WHY?]
   Who was blocked: [PEOPLE/TEAMS]

2. [Blocker]
   ...

3. [Blocker]
   ...

--- CYCLE TIME ANALYSIS ---
Avg cycle time: [X] days
Slowest tickets: [NAMES OF 3 TICKETS THAT TOOK 2X+ THEIR ESTIMATE]
Common reason for delays:
- [Reason 1]: [X tickets affected]
- [Reason 2]: [X tickets affected]
- [Reason 3]: [X tickets affected]

--- TEAM SENTIMENT ---
Positive signals: [NUMBER]
Frustrated signals: [NUMBER]
Key frustrations:
- [Quote]: "..." [WHO SAID THIS]
- [Quote]: "..." [WHO]
Celebrations:
- [WHAT THE TEAM WAS HAPPY ABOUT]

--- TOP PATTERNS ---
The ONE most important pattern to discuss in retro:
[WHAT IT IS, WHY IT MATTERS, SUPPORTED BY DATA]

Secondary patterns:
- [Pattern]: [Impact]
- [Pattern]: [Impact]

--- STANDOUT CONTRIBUTORS ---
People who unblocked others / shipped the most:
- [Name]: [What they did]
- [Name]: [What they did]

--- RECOMMENDED DISCUSSION POINTS ---
If you had 15 minutes in retro, focus on these (in order of impact):
1. [Pattern + why it matters]
2. [Pattern + why it matters]
3. [Pattern + why it matters]

---

Be specific. Use actual data. Use quotes from Slack. Reference ticket names. The goal is that when the team sees this report, they immediately recognize it as true and useful.

Return the report as markdown.

import requests
import os
import json
from datetime import datetime, timedelta

# Configuration
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
JIRA_API_KEY = os.getenv("JIRA_API_KEY")
SLACK_WEBHOOK = os.getenv("SLACK_WEBHOOK")
CLAUDE_API_KEY = os.getenv("CLAUDE_API_KEY")

TEAM_NAME = "Backend"
TEAM_GITHUB_USERNAMES = ["alice", "bob", "charlie"]

def get_sprint_dates():
    """Get current sprint dates (Monday to Friday)"""
    today = datetime.now()
    monday = today - timedelta(days=today.weekday())
    friday = monday + timedelta(days=4)
    return monday, friday

def fetch_github_commits():
    """Get commits from this sprint"""
    monday, friday = get_sprint_dates()
    commits = []

    for username in TEAM_GITHUB_USERNAMES:
        url = "https://api.github.com/repos/YOUR_ORG/YOUR_REPO/commits"
        params = {
            "author": username,
            "since": monday.isoformat(),
            "until": friday.isoformat()
        }
        headers = {"Authorization": f"token {GITHUB_TOKEN}"}

        response = requests.get(url, params=params, headers=headers)
        data = response.json()

        for commit in data:
            commits.append({
                "author": username,
                "message": commit['commit']['message'].split('\n')[0],
                "date": commit['commit']['author']['date']
            })

    return commits

def fetch_jira_data():
    """Get ticket data from this sprint"""
    # Assumes you're using Jira Cloud with a sprint board
    url = f"https://your-domain.atlassian.net/rest/api/3/search"
    params = {
        "jql": "sprint = SPRINT_NAME AND resolved >= -7d",
        "fields": ["key", "summary", "status", "created", "updated", "customfield_10016"]  # 10016 is story points
    }
    headers = {
        "Authorization": f"Bearer {JIRA_API_KEY}",
        "Accept": "application/json"
    }

    response = requests.get(url, params=params, headers=headers)
    return response.json()['issues']

def fetch_slack_signals():
    """Get Slack messages from engineering channels"""
    # Requires Slack SDK
    from slack_sdk import WebClient

    client = WebClient(token=os.getenv("SLACK_TOKEN"))
    monday, friday = get_sprint_dates()
    monday_ts = int(monday.timestamp())

    # Get messages from #engineering or your team channel
    messages = client.conversations_history(
        channel="C123456",  # your channel ID
        oldest=monday_ts
    )

    frustration_keywords = ["blocked", "waiting", "slow", "frustrated", "stuck", "problem"]
    positive_keywords = ["shipped", "unblocked", "great", "celebrate", "win", "done"]

    frustrated = []
    positive = []

    for msg in messages['messages']:
        text = msg['text'].lower()
        if any(kw in text for kw in frustration_keywords):
            frustrated.append(msg['text'][:200])
        if any(kw in text for kw in positive_keywords):
            positive.append(msg['text'][:200])

    return {"frustrated": frustrated, "positive": positive}

def compile_sprint_data():
    """Gather all sprint data"""
    commits = fetch_github_commits()
    jira = fetch_jira_data()
    slack = fetch_slack_signals()

    # Format for Claude
    data_text = f"""
    GIT COMMITS:
    {chr(10).join([f"- {c['author']}: {c['message']}" for c in commits[:20]])}

    JIRA DATA:
    Tickets: {len(jira)}
    {chr(10).join([f"- {t['key']}: {t['fields']['summary']}" for t in jira[:10]])}

    SLACK SIGNALS - Frustrated:
    {chr(10).join([f"- {s}" for s in slack['frustrated'][:5]])}

    SLACK SIGNALS - Positive:
    {chr(10).join([f"- {s}" for s in slack['positive'][:5]])}
    """

    return data_text

def generate_report(sprint_data):
    """Call Claude to generate report"""
    prompt = f"""[USE THE PROMPT FROM STEP 2]

    SPRINT DATA:
    {sprint_data}

    Generate the sprint health report now."""

    response = requests.post(
        "https://api.anthropic.com/v1/messages",
        headers={
            "x-api-key": CLAUDE_API_KEY,
            "Content-Type": "application/json"
        },
        json={
            "model": "claude-3-5-sonnet-20241022",
            "max_tokens": 2048,
            "messages": [{"role": "user", "content": prompt}]
        }
    )

    return response.json()['content'][0]['text']

def send_to_slack(report):
    """Post report to Slack"""
    requests.post(SLACK_WEBHOOK, json={"text": f"📊 Sprint Health Report:\n{report}"})

if __name__ == "__main__":
    data = compile_sprint_data()
    report = generate_report(data)
    send_to_slack(report)
    print("Report generated and sent to Slack")

0 16 * * 5 python /path/to/sprint_report.py

📊 SPRINT HEALTH REPORT - Backend Team
Sprint: Mar 24-Apr 4 | Report generated: Mar 28, 4 PM

--- VELOCITY ---
Planned: 34 points
Completed: 28 points
Completion rate: 82%
Trend: ↓ Down from 92% last sprint (6 points lower)

--- DEPLOYMENT QUALITY ---
Incidents: 1
MTTR: 2.5 hours
Incidents from new code: 1 (async job timeout)
Assessment: Solid. Single incident was edge case, fixed quickly.

--- BLOCKERS & DEPENDENCIES ---
1. Design review delays (2 days avg)
   Affected: 3 tickets (FEAT-142, FEAT-144, FEAT-149)
   Total delay: 8 points worth of work
   Root cause: Design was overloaded with other requests
   Impact: Design bottleneck is our constraint

2. Database migration dependency
   Affected: API refactor ticket
   Delay: 2 days (waiting for migration PR review)
   Root cause: Single code owner, was on PTO

3. Third-party API rate limits
   Affected: Integration tests
   Delay: 6 hours (flaky test runs)
   Root cause: Rate limit not caught in staging

--- CYCLE TIME ANALYSIS ---
Avg cycle time: 3.2 days
Slowest tickets:
- FEAT-142: 6 days (design review delay)
- DEVOPS-54: 5 days (waiting for infrastructure setup)
- FEAT-144: 4.5 days (blocked on design)

Common reasons for delays:
- Design review: 3 tickets, 8 points
- External dependencies: 2 tickets, 5 points
- Flaky tests: 1 ticket, 3 points

--- TEAM SENTIMENT ---
Positive signals: 12
Frustrated signals: 7
Key frustrations:
- "blocked on design feedback for 2 days" - Alice
- "rate limiting is killing our tests" - Bob
- "migration is a blocker for api work" - Charlie
Celebrations:
- Shipped async job optimization (shipped in 1 day)
- Fixed critical auth bug (great debugging by Alice)
- Unblocked three teammates on dependency issues

--- STANDOUT CONTRIBUTORS ---
- Alice: Unblocked 3 people on database issues, shipped 2 features
- Bob: Optimized test suite, reduced flakiness by 40%
- Charlie: Great code reviews this week, fast feedback

--- RECOMMENDED DISCUSSION POINTS ---
1. Design review is a blocker (8 points delayed). Solution: Establish 24-hour design review SLA next sprint. Consider placeholder designs to unblock dev work.
2. Single points of failure (DB migration, external API setup). Solution: Pair another person on these critical paths.
3. Celebrate Alice for unblocking the team. Good peer support.

---

PROPOSED ACTION ITEMS FOR NEXT SPRINT:
1. Design: Respond to review requests within 24 hours (or provide placeholder)
2. Team: Pair on critical dependencies so knowledge isn't single-threaded
3. Infrastructure: Rate limit tests in staging to catch issues early

See you Monday at 2 PM for retro!