{
  "velocity_analysis": {
    "summary": {
      "total_sprints": 6,
      "velocity_stats": {
        "mean": 20.17,
        "median": 20.0,
        "min": 17,
        "max": 24,
        "total_points": 121
      },
      "commitment_analysis": {
        "average_commitment_ratio": 0.908,
        "commitment_consistency": 0.179,
        "sprints_under_committed": 3,
        "sprints_over_committed": 2
      },
      "volatility": {
        "volatility": "low",
        "coefficient_of_variation": 0.127
      }
    },
    "trend_analysis": {
      "trend": "stable",
      "confidence": 0.15,
      "relative_slope": -0.013
    },
    "forecasting": {
      "expected_total": 121.0,
      "forecasted_totals": {
        "50%": 115,
        "70%": 125,
        "85%": 135,
        "95%": 148
      }
    },
    "anomalies": [
      {
        "sprint_number": 5,
        "velocity": 17,
        "anomaly_type": "outlier",
        "deviation_percentage": -15.7
      }
    ]
  },
  "sprint_health": {
    "overall_score": 78.3,
    "health_grade": "good",
    "dimension_scores": {
      "commitment_reliability": {
        "score": 96.8,
        "grade": "excellent"
      },
      "scope_stability": {
        "score": 54.8,
        "grade": "poor"
      },
      "blocker_resolution": {
        "score": 51.7,
        "grade": "poor"
      },
      "ceremony_engagement": {
        "score": 92.3,
        "grade": "excellent"
      },
      "story_completion_distribution": {
        "score": 93.3,
        "grade": "excellent"
      },
      "velocity_predictability": {
        "score": 80.5,
        "grade": "good"
      }
    }
  },
  "retrospective_analysis": {
    "summary": {
      "total_retrospectives": 6,
      "average_duration": 74,
      "average_attendance": 0.933
    },
    "action_item_analysis": {
      "total_action_items": 15,
      "completion_rate": 0.467,
      "overdue_rate": 0.533,
      "priority_analysis": {
        "high": {"completion_rate": 0.50},
        "medium": {"completion_rate": 0.33},
        "low": {"completion_rate": 0.67}
      }
    },
    "theme_analysis": {
      "recurring_themes": {
        "process": {"frequency": 1.0, "trend": {"direction": "decreasing"}},
        "team_dynamics": {"frequency": 1.0, "trend": {"direction": "increasing"}},
        "technical": {"frequency": 0.83, "trend": {"direction": "increasing"}},
        "communication": {"frequency": 0.67, "trend": {"direction": "decreasing"}}
      }
    },
    "improvement_trends": {
      "team_maturity_score": {
        "score": 75.6,
        "level": "performing"
      },
      "improvement_velocity": {
        "velocity": "moderate",
        "velocity_score": 0.62
      }
    }
  },
  "interpretation": {
    "strengths": [
      "Excellent commitment reliability - team consistently delivers what they commit to",
      "High ceremony engagement - team actively participates in scrum events",
      "Good story completion distribution - stories are finished rather than left partially done",
      "Low velocity volatility - predictable delivery capability"
    ],
    "areas_for_improvement": [
      "Scope instability - too much mid-sprint change (22.6% average)",
      "Blocker resolution time - 4.7 days average is too long",
      "Action item completion rate - only 46.7% completed",
      "High overdue rate - 53.3% of action items become overdue"
    ],
    "recommended_actions": [
      "Strengthen backlog refinement to reduce scope changes",
      "Implement faster blocker escalation process",
      "Reduce number of retrospective action items and focus on follow-through",
      "Create external dependency register to proactively manage blockers"
    ]
  }
}

{
  "summary": {
    "total_sprints": 6,
    "velocity_stats": {
      "mean": 20.166666666666668,
      "median": 20.0,
      "min": 17,
      "max": 24,
      "total_points": 121
    },
    "commitment_analysis": {
      "average_commitment_ratio": 0.9075307422046552,
      "commitment_consistency": 0.17889820455801825,
      "sprints_under_committed": 3,
      "sprints_over_committed": 2
    },
    "scope_change_analysis": {
      "average_scope_change": 0.22586752619361317,
      "scope_change_volatility": 0.1828476660567787
    },
    "rolling_averages": {
      "3": [
        null,
        null,
        19.333333333333332,
        20.666666666666668,
        19.333333333333332,
        21.0
      ],
      "5": [
        null,
        null,
        19.333333333333332,
        20.0,
        19.4,
        20.6
      ],
      "8": [
        null,
        null,
        19.333333333333332,
        20.0,
        19.4,
        20.166666666666668
      ]
    },
    "volatility": {
      "volatility": "low",
      "coefficient_of_variation": 0.13088153980052333,
      "standard_deviation": 2.6394443859772205,
      "mean_velocity": 20.166666666666668,
      "velocity_range": 7,
      "range_ratio": 0.3471074380165289,
      "min_velocity": 17,
      "max_velocity": 24
    }
  },
  "trend_analysis": {
    "trend": "stable",
    "slope": 0.6,
    "relative_slope": 0.029752066115702476,
    "correlation": 0.42527784332026836,
    "confidence": 0.42527784332026836,
    "recent_sprints_analyzed": 6,
    "average_velocity": 20.166666666666668
  },
  "forecasting": {
    "sprints_ahead": 6,
    "historical_sprints_used": 6,
    "mean_velocity": 20.166666666666668,
    "velocity_std_dev": 2.6394443859772205,
    "forecasted_totals": {
      "50%": 121.00756172377734,
      "70%": 124.35398229685968,
      "85%": 127.68925669583572,
      "95%": 131.66775744677182
    },
    "average_per_sprint": 20.166666666666668,
    "expected_total": 121.0
  },
  "anomalies": [],
  "recommendations": [
    "Good velocity stability. Continue current practices."
  ]
}

{
  "team_info": {
    "name": "Phoenix Development Team",
    "size": 5,
    "scrum_master": "Sarah Chen",
    "product_owner": "Mike Rodriguez"
  },
  "sprints": [
    {
      "sprint_number": 1,
      "sprint_name": "Sprint Alpha",
      "start_date": "2024-01-08",
      "end_date": "2024-01-19",
      "planned_points": 23,
      "completed_points": 18,
      "added_points": 3,
      "removed_points": 2,
      "carry_over_points": 5,
      "team_capacity": 40,
      "working_days": 10,
      "team_size": 5,
      "stories": [
        {
          "id": "US-101",
          "title": "User authentication system",
          "points": 8,
          "status": "completed",
          "assigned_to": "John Doe",
          "created_date": "2024-01-08",
          "completed_date": "2024-01-16",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-102", 
          "title": "Dashboard layout implementation",
          "points": 5,
          "status": "completed",
          "assigned_to": "Jane Smith",
          "created_date": "2024-01-08",
          "completed_date": "2024-01-18",
          "blocked_days": 1,
          "priority": "medium"
        },
        {
          "id": "US-103",
          "title": "API integration for user data",
          "points": 5,
          "status": "completed", 
          "assigned_to": "Bob Wilson",
          "created_date": "2024-01-08",
          "completed_date": "2024-01-19",
          "blocked_days": 0,
          "priority": "medium"
        },
        {
          "id": "US-104",
          "title": "Advanced filtering options",
          "points": 5,
          "status": "in_progress",
          "assigned_to": "Alice Brown",
          "created_date": "2024-01-08",
          "blocked_days": 2,
          "priority": "low"
        }
      ],
      "blockers": [
        {
          "id": "B-001",
          "description": "Third-party API documentation incomplete",
          "created_date": "2024-01-10",
          "resolved_date": "2024-01-12",
          "resolution_days": 2,
          "affected_stories": ["US-103"],
          "category": "external"
        }
      ],
      "ceremonies": {
        "daily_standup": {
          "attendance_rate": 0.92,
          "engagement_score": 0.85
        },
        "sprint_planning": {
          "attendance_rate": 1.0,
          "engagement_score": 0.90
        },
        "sprint_review": {
          "attendance_rate": 0.96,
          "engagement_score": 0.88
        },
        "retrospective": {
          "attendance_rate": 1.0,
          "engagement_score": 0.95
        }
      }
    },
    {
      "sprint_number": 2,
      "sprint_name": "Sprint Beta",
      "start_date": "2024-01-22",
      "end_date": "2024-02-02",
      "planned_points": 21,
      "completed_points": 21,
      "added_points": 1,
      "removed_points": 1,
      "carry_over_points": 3,
      "team_capacity": 38,
      "working_days": 9,
      "team_size": 5,
      "stories": [
        {
          "id": "US-105",
          "title": "Email notification system",
          "points": 8,
          "status": "completed",
          "assigned_to": "John Doe",
          "created_date": "2024-01-22",
          "completed_date": "2024-01-30",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-106",
          "title": "User profile management",
          "points": 5,
          "status": "completed",
          "assigned_to": "Jane Smith",
          "created_date": "2024-01-22",
          "completed_date": "2024-02-01",
          "blocked_days": 0,
          "priority": "medium"
        },
        {
          "id": "US-107",
          "title": "Data export functionality",
          "points": 3,
          "status": "completed",
          "assigned_to": "Bob Wilson",
          "created_date": "2024-01-22",
          "completed_date": "2024-01-31",
          "blocked_days": 0,
          "priority": "medium"
        },
        {
          "id": "US-104",
          "title": "Advanced filtering options",
          "points": 5,
          "status": "completed",
          "assigned_to": "Alice Brown",
          "created_date": "2024-01-08",
          "completed_date": "2024-02-02",
          "blocked_days": 0,
          "priority": "low"
        }
      ],
      "blockers": [],
      "ceremonies": {
        "daily_standup": {
          "attendance_rate": 0.94,
          "engagement_score": 0.88
        },
        "sprint_planning": {
          "attendance_rate": 1.0,
          "engagement_score": 0.92
        },
        "sprint_review": {
          "attendance_rate": 1.0,
          "engagement_score": 0.90
        },
        "retrospective": {
          "attendance_rate": 1.0,
          "engagement_score": 0.93
        }
      }
    },
    {
      "sprint_number": 3,
      "sprint_name": "Sprint Gamma",
      "start_date": "2024-02-05",
      "end_date": "2024-02-16",
      "planned_points": 24,
      "completed_points": 19,
      "added_points": 4,
      "removed_points": 3,
      "carry_over_points": 5,
      "team_capacity": 42,
      "working_days": 10,
      "team_size": 5,
      "stories": [
        {
          "id": "US-108",
          "title": "Real-time chat implementation",
          "points": 13,
          "status": "in_progress",
          "assigned_to": "John Doe",
          "created_date": "2024-02-05",
          "blocked_days": 3,
          "priority": "high"
        },
        {
          "id": "US-109",
          "title": "Mobile responsive design",
          "points": 8,
          "status": "completed",
          "assigned_to": "Jane Smith",
          "created_date": "2024-02-05",
          "completed_date": "2024-02-14",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-110",
          "title": "Performance optimization",
          "points": 3,
          "status": "completed",
          "assigned_to": "Bob Wilson",
          "created_date": "2024-02-05",
          "completed_date": "2024-02-13",
          "blocked_days": 1,
          "priority": "medium"
        }
      ],
      "blockers": [
        {
          "id": "B-002",
          "description": "WebSocket library compatibility issue",
          "created_date": "2024-02-07",
          "resolved_date": "2024-02-11",
          "resolution_days": 4,
          "affected_stories": ["US-108"],
          "category": "technical"
        },
        {
          "id": "B-003",
          "description": "Database migration pending approval",
          "created_date": "2024-02-09",
          "resolution_days": 0,
          "affected_stories": ["US-110"],
          "category": "process"
        }
      ],
      "ceremonies": {
        "daily_standup": {
          "attendance_rate": 0.88,
          "engagement_score": 0.82
        },
        "sprint_planning": {
          "attendance_rate": 0.96,
          "engagement_score": 0.85
        },
        "sprint_review": {
          "attendance_rate": 0.92,
          "engagement_score": 0.83
        },
        "retrospective": {
          "attendance_rate": 1.0,
          "engagement_score": 0.87
        }
      }
    },
    {
      "sprint_number": 4,
      "sprint_name": "Sprint Delta", 
      "start_date": "2024-02-19",
      "end_date": "2024-03-01",
      "planned_points": 20,
      "completed_points": 22,
      "added_points": 2,
      "removed_points": 0,
      "carry_over_points": 2,
      "team_capacity": 40,
      "working_days": 10,
      "team_size": 5,
      "stories": [
        {
          "id": "US-108",
          "title": "Real-time chat implementation",
          "points": 13,
          "status": "completed",
          "assigned_to": "John Doe",
          "created_date": "2024-02-05",
          "completed_date": "2024-02-28",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-111",
          "title": "Search functionality enhancement",
          "points": 5,
          "status": "completed",
          "assigned_to": "Alice Brown",
          "created_date": "2024-02-19",
          "completed_date": "2024-02-26",
          "blocked_days": 0,
          "priority": "medium"
        },
        {
          "id": "US-112",
          "title": "Unit test coverage improvement",
          "points": 3,
          "status": "completed",
          "assigned_to": "Bob Wilson",
          "created_date": "2024-02-19",
          "completed_date": "2024-02-27",
          "blocked_days": 0,
          "priority": "low"
        },
        {
          "id": "US-113",
          "title": "Error handling improvements",
          "points": 1,
          "status": "completed",
          "assigned_to": "Jane Smith",
          "created_date": "2024-02-25",
          "completed_date": "2024-03-01",
          "blocked_days": 0,
          "priority": "medium"
        }
      ],
      "blockers": [],
      "ceremonies": {
        "daily_standup": {
          "attendance_rate": 0.96,
          "engagement_score": 0.90
        },
        "sprint_planning": {
          "attendance_rate": 1.0,
          "engagement_score": 0.94
        },
        "sprint_review": {
          "attendance_rate": 1.0,
          "engagement_score": 0.92
        },
        "retrospective": {
          "attendance_rate": 1.0,
          "engagement_score": 0.95
        }
      }
    },
    {
      "sprint_number": 5,
      "sprint_name": "Sprint Epsilon",
      "start_date": "2024-03-04",
      "end_date": "2024-03-15",
      "planned_points": 25,
      "completed_points": 17,
      "added_points": 6,
      "removed_points": 8,
      "carry_over_points": 8,
      "team_capacity": 35,
      "working_days": 9,
      "team_size": 4,
      "stories": [
        {
          "id": "US-114",
          "title": "Advanced analytics dashboard",
          "points": 13,
          "status": "blocked",
          "assigned_to": "John Doe",
          "created_date": "2024-03-04",
          "blocked_days": 7,
          "priority": "high"
        },
        {
          "id": "US-115",
          "title": "User permissions system",
          "points": 8,
          "status": "in_progress",
          "assigned_to": "Alice Brown",
          "created_date": "2024-03-04",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-116",
          "title": "API rate limiting",
          "points": 2,
          "status": "completed",
          "assigned_to": "Bob Wilson",
          "created_date": "2024-03-04",
          "completed_date": "2024-03-08",
          "blocked_days": 0,
          "priority": "medium"
        },
        {
          "id": "US-117",
          "title": "Documentation updates",
          "points": 2,
          "status": "completed",
          "assigned_to": "Jane Smith",
          "created_date": "2024-03-04", 
          "completed_date": "2024-03-10",
          "blocked_days": 0,
          "priority": "low"
        }
      ],
      "blockers": [
        {
          "id": "B-004",
          "description": "Analytics service downtime",
          "created_date": "2024-03-05",
          "resolution_days": 0,
          "affected_stories": ["US-114"],
          "category": "external"
        },
        {
          "id": "B-005",
          "description": "Team member on sick leave",
          "created_date": "2024-03-07",
          "resolved_date": "2024-03-15",
          "resolution_days": 8,
          "affected_stories": ["US-115"],
          "category": "team"
        }
      ],
      "ceremonies": {
        "daily_standup": {
          "attendance_rate": 0.75,
          "engagement_score": 0.70
        },
        "sprint_planning": {
          "attendance_rate": 0.80,
          "engagement_score": 0.75
        },
        "sprint_review": {
          "attendance_rate": 0.85,
          "engagement_score": 0.78
        },
        "retrospective": {
          "attendance_rate": 0.95,
          "engagement_score": 0.88
        }
      }
    },
    {
      "sprint_number": 6,
      "sprint_name": "Sprint Zeta",
      "start_date": "2024-03-18",
      "end_date": "2024-03-29",
      "planned_points": 22,
      "completed_points": 24,
      "added_points": 2,
      "removed_points": 0,
      "carry_over_points": 6,
      "team_capacity": 45,
      "working_days": 10,
      "team_size": 5,
      "stories": [
        {
          "id": "US-115",
          "title": "User permissions system",
          "points": 8,
          "status": "completed",
          "assigned_to": "Alice Brown",
          "created_date": "2024-03-04",
          "completed_date": "2024-03-25",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-118",
          "title": "Backup and recovery system",
          "points": 8,
          "status": "completed",
          "assigned_to": "John Doe",
          "created_date": "2024-03-18",
          "completed_date": "2024-03-28",
          "blocked_days": 0,
          "priority": "high"
        },
        {
          "id": "US-119",
          "title": "UI theme customization",
          "points": 5,
          "status": "completed",
          "assigned_to": "Jane Smith",
          "created_date": "2024-03-18",
          "completed_date": "2024-03-26",
          "blocked_days": 0,
          "priority": "medium"
        },
        {
          "id": "US-120",
          "title": "Performance monitoring",
          "points": 3,
          "status": "completed",
          "assigned_to": "Bob Wilson",
          "created_date": "2024-03-18",
          "completed_date": "2024-03-24",
          "blocked_days": 0,
          "priority": "low"
        }
      ],
      "blockers": [],
      "ceremonies": {
        "daily_standup": {
          "attendance_rate": 0.98,
          "engagement_score": 0.93
        },
        "sprint_planning": {
          "attendance_rate": 1.0,
          "engagement_score": 0.96
        },
        "sprint_review": {
          "attendance_rate": 1.0,
          "engagement_score": 0.94
        },
        "retrospective": {
          "attendance_rate": 1.0,
          "engagement_score": 0.97
        }
      }
    }
  ],
  "retrospectives": [
    {
      "sprint_number": 1,
      "date": "2024-01-19",
      "facilitator": "Sarah Chen",
      "attendees": ["John Doe", "Jane Smith", "Bob Wilson", "Alice Brown", "Sarah Chen"],
      "duration_minutes": 75,
      "went_well": [
        "Team collaboration was excellent during planning",
        "Daily standups were efficient and focused", 
        "Good technical problem-solving on authentication system",
        "New team member integrated well",
        "Clear user story definitions"
      ],
      "to_improve": [
        "Story estimation accuracy needs work",
        "Too many blockers appeared mid-sprint",
        "API documentation was incomplete at start",
        "Need better communication with external teams"
      ],
      "action_items": [
        {
          "id": "AI-001",
          "description": "Schedule estimation workshop for next sprint planning",
          "owner": "Sarah Chen",
          "priority": "high",
          "due_date": "2024-01-26",
          "status": "completed",
          "created_sprint": 1,
          "completed_sprint": 2,
          "category": "process",
          "effort_estimate": "medium"
        },
        {
          "id": "AI-002", 
          "description": "Establish direct communication channel with API team",
          "owner": "Bob Wilson",
          "priority": "medium",
          "due_date": "2024-01-30",
          "status": "completed",
          "created_sprint": 1,
          "completed_sprint": 2,
          "category": "communication",
          "effort_estimate": "low"
        },
        {
          "id": "AI-003",
          "description": "Create blocker escalation process documentation",
          "owner": "Sarah Chen",
          "priority": "medium",
          "due_date": "2024-02-02",
          "status": "in_progress",
          "created_sprint": 1,
          "category": "process",
          "effort_estimate": "low"
        }
      ]
    },
    {
      "sprint_number": 2,
      "date": "2024-02-02",
      "facilitator": "Sarah Chen",
      "attendees": ["John Doe", "Jane Smith", "Bob Wilson", "Alice Brown", "Sarah Chen"],
      "duration_minutes": 60,
      "went_well": [
        "Perfect sprint execution - completed all planned work",
        "No blockers encountered",
        "Estimation workshop improved accuracy significantly",
        "Team velocity is stabilizing",
        "Good ceremony attendance and engagement"
      ],
      "to_improve": [
        "Could have taken on more work given the smooth execution",
        "Need to celebrate successes more",
        "Sprint review could be more interactive",
        "Documentation still lagging behind development"
      ],
      "action_items": [
        {
          "id": "AI-004",
          "description": "Implement team celebration ritual for successful sprints",
          "owner": "Jane Smith",
          "priority": "low",
          "due_date": "2024-02-09",
          "status": "completed",
          "created_sprint": 2,
          "completed_sprint": 3,
          "category": "team_dynamics",
          "effort_estimate": "low"
        },
        {
          "id": "AI-005",
          "description": "Create documentation sprint for next iteration",
          "owner": "Alice Brown",
          "priority": "medium",
          "due_date": "2024-02-16",
          "status": "cancelled",
          "created_sprint": 2,
          "category": "process",
          "effort_estimate": "high"
        }
      ]
    },
    {
      "sprint_number": 3,
      "date": "2024-02-16",
      "facilitator": "John Doe",
      "attendees": ["John Doe", "Jane Smith", "Bob Wilson", "Alice Brown"],
      "duration_minutes": 90,
      "went_well": [
        "Good adaptation when faced with technical challenges",
        "Team helped each other overcome blockers",
        "Mobile design work exceeded expectations",
        "Performance improvements had measurable impact"
      ],
      "to_improve": [
        "WebSocket integration took longer than expected",
        "Too much scope change during the sprint",
        "Daily standup attendance dropped",
        "Need better technical spike planning",
        "Database migration process is too slow"
      ],
      "action_items": [
        {
          "id": "AI-006",
          "description": "Schedule technical spike for complex integrations",
          "owner": "John Doe",
          "priority": "high",
          "due_date": "2024-02-23",
          "status": "completed",
          "created_sprint": 3,
          "completed_sprint": 4,
          "category": "technical",
          "effort_estimate": "medium"
        },
        {
          "id": "AI-007",
          "description": "Review scope change process with Product Owner",
          "owner": "Sarah Chen",
          "priority": "medium",
          "due_date": "2024-02-26",
          "status": "completed",
          "created_sprint": 3,
          "completed_sprint": 4,
          "category": "process",
          "effort_estimate": "low"
        },
        {
          "id": "AI-008",
          "description": "Improve database migration approval workflow",
          "owner": "Bob Wilson",
          "priority": "medium",
          "due_date": "2024-03-08",
          "status": "blocked",
          "created_sprint": 3,
          "category": "process",
          "effort_estimate": "high"
        }
      ]
    },
    {
      "sprint_number": 4,
      "date": "2024-03-01",
      "facilitator": "Sarah Chen", 
      "attendees": ["John Doe", "Jane Smith", "Bob Wilson", "Alice Brown", "Sarah Chen"],
      "duration_minutes": 45,
      "went_well": [
        "Exceeded sprint goal by completing extra work",
        "Real-time chat finally delivered with high quality",
        "Technical spikes prevented major blockers",
        "Team ceremonies back to full engagement",
        "Search functionality delivered ahead of schedule"
      ],
      "to_improve": [
        "Sprint retrospective was rushed due to time constraints",
        "Need better capacity planning for variable team sizes",
        "Unit test coverage still below target"
      ],
      "action_items": [
        {
          "id": "AI-009",
          "description": "Block more time for retrospectives in calendar",
          "owner": "Sarah Chen",
          "priority": "low",
          "due_date": "2024-03-08",
          "status": "completed",
          "created_sprint": 4,
          "completed_sprint": 5,
          "category": "process",
          "effort_estimate": "low"
        },
        {
          "id": "AI-010",
          "description": "Establish unit test coverage gates in CI/CD",
          "owner": "Bob Wilson",
          "priority": "high",
          "due_date": "2024-03-15",
          "status": "in_progress",
          "created_sprint": 4,
          "category": "technical",
          "effort_estimate": "medium"
        }
      ]
    },
    {
      "sprint_number": 5,
      "date": "2024-03-15",
      "facilitator": "Alice Brown",
      "attendees": ["John Doe", "Jane Smith", "Bob Wilson", "Alice Brown"],
      "duration_minutes": 105,
      "went_well": [
        "Team adapted well to reduced capacity",
        "Good support for team member on sick leave",
        "Documentation work was delivered on time",
        "Rate limiting implementation was smooth"
      ],
      "to_improve": [
        "External service dependencies caused major delays",
        "Too much scope change again - need better discipline",
        "Team capacity planning needs improvement",
        "Daily standup attendance dropped significantly",
        "Analytics service reliability is a recurring issue"
      ],
      "action_items": [
        {
          "id": "AI-011",
          "description": "Create external service dependency register",
          "owner": "John Doe",
          "priority": "high",
          "due_date": "2024-03-22",
          "status": "not_started",
          "created_sprint": 5,
          "category": "process",
          "effort_estimate": "medium"
        },
        {
          "id": "AI-012",
          "description": "Escalate analytics service reliability issues",
          "owner": "Sarah Chen",
          "priority": "high",
          "due_date": "2024-03-18",
          "status": "completed",
          "created_sprint": 5,
          "completed_sprint": 6,
          "category": "external",
          "effort_estimate": "low"
        },
        {
          "id": "AI-013",
          "description": "Implement capacity planning buffer for sick leave",
          "owner": "Sarah Chen",
          "priority": "medium",
          "due_date": "2024-03-29",
          "status": "in_progress",
          "created_sprint": 5,
          "category": "process",
          "effort_estimate": "medium"
        }
      ]
    },
    {
      "sprint_number": 6,
      "date": "2024-03-29",
      "facilitator": "Sarah Chen",
      "attendees": ["John Doe", "Jane Smith", "Bob Wilson", "Alice Brown", "Sarah Chen"],
      "duration_minutes": 70,
      "went_well": [
        "Excellent sprint execution with team back to full capacity",
        "Delivered more points than planned",
        "No blockers encountered",
        "Strong ceremony engagement across all events",
        "Backup system implementation was flawless",
        "Team morale has improved significantly"
      ],
      "to_improve": [
        "Need to maintain this momentum",
        "Could optimize sprint planning efficiency",
        "Theme customization feature needs user feedback",
        "Performance monitoring setup could be automated"
      ],
      "action_items": [
        {
          "id": "AI-014",
          "description": "Gather user feedback on theme customization",
          "owner": "Jane Smith",
          "priority": "medium",
          "due_date": "2024-04-05",
          "status": "not_started",
          "created_sprint": 6,
          "category": "external",
          "effort_estimate": "low"
        },
        {
          "id": "AI-015",
          "description": "Automate performance monitoring setup",
          "owner": "Bob Wilson",
          "priority": "low",
          "due_date": "2024-04-12",
          "status": "not_started",
          "created_sprint": 6,
          "category": "technical",
          "effort_estimate": "medium"
        }
      ]
    }
  ]
}

#!/usr/bin/env python3
"""
Retrospective Analyzer

Processes retrospective data to track action item completion rates, identify
recurring themes, measure improvement trends, and generate insights for
continuous team improvement.

Usage:
    python retrospective_analyzer.py retro_data.json
    python retrospective_analyzer.py retro_data.json --format json
"""

import argparse
import json
import re
import statistics
import sys
from collections import Counter, defaultdict
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional, Set, Tuple


# ---------------------------------------------------------------------------
# Configuration and Constants
# ---------------------------------------------------------------------------

SENTIMENT_KEYWORDS = {
    "positive": [
        "good", "great", "excellent", "awesome", "fantastic", "wonderful",
        "improved", "better", "success", "achievement", "celebration",
        "working well", "effective", "efficient", "smooth", "pleased",
        "happy", "satisfied", "proud", "accomplished", "breakthrough"
    ],
    "negative": [
        "bad", "terrible", "awful", "horrible", "frustrating", "annoying",
        "problem", "issue", "blocker", "impediment", "concern", "worry",
        "difficult", "challenging", "struggling", "failing", "broken",
        "slow", "delayed", "confused", "unclear", "chaos", "stressed"
    ],
    "neutral": [
        "okay", "average", "normal", "standard", "typical", "usual",
        "process", "procedure", "meeting", "discussion", "review",
        "update", "status", "information", "data", "report"
    ]
}

THEME_CATEGORIES = {
    "communication": [
        "communication", "meeting", "standup", "discussion", "feedback",
        "information", "clarity", "understanding", "alignment", "sync",
        "reporting", "updates", "transparency", "visibility"
    ],
    "process": [
        "process", "procedure", "workflow", "methodology", "framework",
        "scrum", "agile", "ceremony", "planning", "retrospective",
        "review", "estimation", "refinement", "definition of done"
    ],
    "technical": [
        "technical", "code", "development", "bug", "testing", "deployment",
        "architecture", "infrastructure", "tools", "technology",
        "performance", "quality", "automation", "ci/cd", "devops"
    ],
    "team_dynamics": [
        "team", "collaboration", "cooperation", "support", "morale",
        "motivation", "engagement", "culture", "relationship", "trust",
        "conflict", "personality", "workload", "capacity", "burnout"
    ],
    "external": [
        "customer", "stakeholder", "management", "product owner", "business",
        "requirement", "priority", "deadline", "budget", "resource",
        "dependency", "vendor", "third party", "integration"
    ]
}

ACTION_PRIORITY_KEYWORDS = {
    "high": ["urgent", "critical", "asap", "immediately", "blocker", "must"],
    "medium": ["important", "should", "needed", "required", "significant"],
    "low": ["nice to have", "consider", "explore", "investigate", "eventually"]
}

COMPLETION_STATUS_MAPPING = {
    "completed": ["done", "completed", "finished", "resolved", "closed", "achieved"],
    "in_progress": ["in progress", "ongoing", "working on", "started", "partial"],
    "blocked": ["blocked", "stuck", "waiting", "dependent", "impediment"],
    "cancelled": ["cancelled", "dropped", "abandoned", "not needed", "deprioritized"],
    "not_started": ["not started", "pending", "todo", "planned", "upcoming"]
}


# ---------------------------------------------------------------------------
# Data Models
# ---------------------------------------------------------------------------

class ActionItem:
    """Represents a single action item from a retrospective."""
    
    def __init__(self, data: Dict[str, Any]):
        self.id: str = data.get("id", "")
        self.description: str = data.get("description", "")
        self.owner: str = data.get("owner", "")
        self.priority: str = data.get("priority", "medium").lower()
        self.due_date: Optional[str] = data.get("due_date")
        self.status: str = data.get("status", "not_started").lower()
        self.created_sprint: int = data.get("created_sprint", 0)
        self.completed_sprint: Optional[int] = data.get("completed_sprint")
        self.category: str = data.get("category", "")
        self.effort_estimate: str = data.get("effort_estimate", "medium")
        
        # Normalize status
        self.normalized_status = self._normalize_status(self.status)
        
        # Infer priority from description if not explicitly set
        if self.priority == "medium":
            self.inferred_priority = self._infer_priority(self.description)
        else:
            self.inferred_priority = self.priority
    
    def _normalize_status(self, status: str) -> str:
        """Normalize status to standard categories."""
        status_lower = status.lower().strip()
        
        for category, statuses in COMPLETION_STATUS_MAPPING.items():
            if any(s in status_lower for s in statuses):
                return category
        
        return "not_started"
    
    def _infer_priority(self, description: str) -> str:
        """Infer priority from description text."""
        description_lower = description.lower()
        
        for priority, keywords in ACTION_PRIORITY_KEYWORDS.items():
            if any(keyword in description_lower for keyword in keywords):
                return priority
        
        return "medium"
    
    @property
    def is_completed(self) -> bool:
        return self.normalized_status == "completed"
    
    @property
    def is_overdue(self) -> bool:
        if not self.due_date:
            return False
        
        try:
            due_date = datetime.strptime(self.due_date, "%Y-%m-%d")
            return datetime.now() > due_date and not self.is_completed
        except ValueError:
            return False


class RetrospectiveData:
    """Represents data from a single retrospective session."""
    
    def __init__(self, data: Dict[str, Any]):
        self.sprint_number: int = data.get("sprint_number", 0)
        self.date: str = data.get("date", "")
        self.facilitator: str = data.get("facilitator", "")
        self.attendees: List[str] = data.get("attendees", [])
        self.duration_minutes: int = data.get("duration_minutes", 0)
        
        # Retrospective categories
        self.went_well: List[str] = data.get("went_well", [])
        self.to_improve: List[str] = data.get("to_improve", [])
        self.action_items_data: List[Dict[str, Any]] = data.get("action_items", [])
        
        # Create action items
        self.action_items: List[ActionItem] = [
            ActionItem({**item, "created_sprint": self.sprint_number})
            for item in self.action_items_data
        ]
        
        # Calculate metrics
        self._calculate_metrics()
    
    def _calculate_metrics(self):
        """Calculate retrospective session metrics."""
        self.total_items = len(self.went_well) + len(self.to_improve)
        self.action_items_count = len(self.action_items)
        self.attendance_rate = len(self.attendees) / max(1, 5)  # Assume team of 5
        
        # Sentiment analysis
        self.sentiment_scores = self._analyze_sentiment()
        
        # Theme analysis
        self.themes = self._extract_themes()
    
    def _analyze_sentiment(self) -> Dict[str, float]:
        """Analyze sentiment of retrospective items."""
        all_text = " ".join(self.went_well + self.to_improve).lower()
        
        sentiment_scores = {}
        for sentiment, keywords in SENTIMENT_KEYWORDS.items():
            count = sum(1 for keyword in keywords if keyword in all_text)
            sentiment_scores[sentiment] = count
        
        # Normalize to percentages
        total_sentiment = sum(sentiment_scores.values())
        if total_sentiment > 0:
            for sentiment in sentiment_scores:
                sentiment_scores[sentiment] = sentiment_scores[sentiment] / total_sentiment
        
        return sentiment_scores
    
    def _extract_themes(self) -> Dict[str, int]:
        """Extract themes from retrospective items."""
        all_text = " ".join(self.went_well + self.to_improve).lower()
        
        theme_counts = {}
        for theme, keywords in THEME_CATEGORIES.items():
            count = sum(1 for keyword in keywords if keyword in all_text)
            if count > 0:
                theme_counts[theme] = count
        
        return theme_counts


class RetroAnalysisResult:
    """Complete retrospective analysis results."""
    
    def __init__(self):
        self.summary: Dict[str, Any] = {}
        self.action_item_analysis: Dict[str, Any] = {}
        self.theme_analysis: Dict[str, Any] = {}
        self.improvement_trends: Dict[str, Any] = {}
        self.recommendations: List[str] = []


# ---------------------------------------------------------------------------
# Analysis Functions
# ---------------------------------------------------------------------------

def analyze_action_item_completion(retros: List[RetrospectiveData]) -> Dict[str, Any]:
    """Analyze action item completion rates and patterns."""
    all_action_items = []
    for retro in retros:
        all_action_items.extend(retro.action_items)
    
    if not all_action_items:
        return {
            "total_action_items": 0,
            "completion_rate": 0.0,
            "average_completion_time": 0.0
        }
    
    # Overall completion statistics
    completed_items = [item for item in all_action_items if item.is_completed]
    completion_rate = len(completed_items) / len(all_action_items)
    
    # Completion time analysis
    completion_times = []
    for item in completed_items:
        if item.completed_sprint and item.created_sprint:
            completion_time = item.completed_sprint - item.created_sprint
            if completion_time >= 0:
                completion_times.append(completion_time)
    
    avg_completion_time = statistics.mean(completion_times) if completion_times else 0.0
    
    # Status distribution
    status_counts = Counter(item.normalized_status for item in all_action_items)
    
    # Priority analysis
    priority_completion = {}
    for priority in ["high", "medium", "low"]:
        priority_items = [item for item in all_action_items if item.inferred_priority == priority]
        if priority_items:
            priority_completed = sum(1 for item in priority_items if item.is_completed)
            priority_completion[priority] = {
                "total": len(priority_items),
                "completed": priority_completed,
                "completion_rate": priority_completed / len(priority_items)
            }
    
    # Owner analysis
    owner_performance = defaultdict(lambda: {"total": 0, "completed": 0})
    for item in all_action_items:
        if item.owner:
            owner_performance[item.owner]["total"] += 1
            if item.is_completed:
                owner_performance[item.owner]["completed"] += 1
    
    for owner in owner_performance:
        owner_data = owner_performance[owner]
        owner_data["completion_rate"] = owner_data["completed"] / owner_data["total"]
    
    # Overdue items
    overdue_items = [item for item in all_action_items if item.is_overdue]
    
    return {
        "total_action_items": len(all_action_items),
        "completion_rate": completion_rate,
        "completed_items": len(completed_items),
        "average_completion_time": avg_completion_time,
        "status_distribution": dict(status_counts),
        "priority_analysis": priority_completion,
        "owner_performance": dict(owner_performance),
        "overdue_items": len(overdue_items),
        "overdue_rate": len(overdue_items) / len(all_action_items) if all_action_items else 0.0
    }


def analyze_recurring_themes(retros: List[RetrospectiveData]) -> Dict[str, Any]:
    """Identify recurring themes across retrospectives."""
    theme_evolution = defaultdict(list)
    sentiment_evolution = defaultdict(list)
    
    # Track themes over time
    for retro in retros:
        sprint = retro.sprint_number
        
        # Theme tracking
        for theme, count in retro.themes.items():
            theme_evolution[theme].append((sprint, count))
        
        # Sentiment tracking
        for sentiment, score in retro.sentiment_scores.items():
            sentiment_evolution[sentiment].append((sprint, score))
    
    # Identify recurring themes (appear in >50% of retros)
    recurring_threshold = len(retros) * 0.5
    recurring_themes = {}
    
    for theme, occurrences in theme_evolution.items():
        if len(occurrences) >= recurring_threshold:
            sprints, counts = zip(*occurrences)
            recurring_themes[theme] = {
                "frequency": len(occurrences) / len(retros),
                "average_mentions": statistics.mean(counts),
                "trend": _calculate_trend(list(counts)),
                "first_appearance": min(sprints),
                "last_appearance": max(sprints),
                "total_mentions": sum(counts)
            }
    
    # Sentiment trend analysis
    sentiment_trends = {}
    for sentiment, scores_by_sprint in sentiment_evolution.items():
        if len(scores_by_sprint) >= 3:  # Need at least 3 data points
            _, scores = zip(*scores_by_sprint)
            sentiment_trends[sentiment] = {
                "average_score": statistics.mean(scores),
                "trend": _calculate_trend(list(scores)),
                "volatility": statistics.stdev(scores) if len(scores) > 1 else 0.0
            }
    
    # Identify persistent issues (negative themes that recur)
    persistent_issues = []
    for theme, data in recurring_themes.items():
        if theme in ["technical", "process", "external"] and data["frequency"] > 0.6:
            if data["trend"]["direction"] in ["stable", "increasing"]:
                persistent_issues.append({
                    "theme": theme,
                    "frequency": data["frequency"],
                    "severity": data["average_mentions"],
                    "trend": data["trend"]["direction"]
                })
    
    return {
        "recurring_themes": recurring_themes,
        "sentiment_trends": sentiment_trends,
        "persistent_issues": persistent_issues,
        "total_themes_identified": len(theme_evolution),
        "themes_per_retro": sum(len(r.themes) for r in retros) / len(retros) if retros else 0
    }


def analyze_improvement_trends(retros: List[RetrospectiveData]) -> Dict[str, Any]:
    """Analyze improvement trends across retrospectives."""
    if len(retros) < 3:
        return {"error": "Need at least 3 retrospectives for trend analysis"}
    
    # Sort retrospectives by sprint number
    sorted_retros = sorted(retros, key=lambda r: r.sprint_number)
    
    # Track various metrics over time
    metrics_over_time = {
        "action_items_per_retro": [len(r.action_items) for r in sorted_retros],
        "attendance_rate": [r.attendance_rate for r in sorted_retros],
        "duration": [r.duration_minutes for r in sorted_retros],
        "positive_sentiment": [r.sentiment_scores.get("positive", 0) for r in sorted_retros],
        "negative_sentiment": [r.sentiment_scores.get("negative", 0) for r in sorted_retros],
        "total_items_discussed": [r.total_items for r in sorted_retros]
    }
    
    # Calculate trends for each metric
    trend_analysis = {}
    for metric_name, values in metrics_over_time.items():
        if len(values) >= 3:
            trend_analysis[metric_name] = {
                "values": values,
                "trend": _calculate_trend(values),
                "average": statistics.mean(values),
                "latest": values[-1],
                "change_from_first": ((values[-1] - values[0]) / values[0]) if values[0] != 0 else 0
            }
    
    # Action item completion trend
    completion_rates_by_sprint = []
    for i, retro in enumerate(sorted_retros):
        if i > 0:  # Skip first retro as it has no previous action items to complete
            prev_retro = sorted_retros[i-1]
            if prev_retro.action_items:
                completed_count = sum(1 for item in prev_retro.action_items 
                                    if item.is_completed and item.completed_sprint == retro.sprint_number)
                completion_rate = completed_count / len(prev_retro.action_items)
                completion_rates_by_sprint.append(completion_rate)
    
    if completion_rates_by_sprint:
        trend_analysis["action_item_completion"] = {
            "values": completion_rates_by_sprint,
            "trend": _calculate_trend(completion_rates_by_sprint),
            "average": statistics.mean(completion_rates_by_sprint),
            "latest": completion_rates_by_sprint[-1] if completion_rates_by_sprint else 0
        }
    
    # Team maturity indicators
    maturity_score = _calculate_team_maturity(sorted_retros)
    
    return {
        "trend_analysis": trend_analysis,
        "team_maturity_score": maturity_score,
        "retrospective_quality_trend": _assess_retrospective_quality_trend(sorted_retros),
        "improvement_velocity": _calculate_improvement_velocity(sorted_retros)
    }


def _calculate_trend(values: List[float]) -> Dict[str, Any]:
    """Calculate trend direction and strength for a series of values."""
    if len(values) < 2:
        return {"direction": "insufficient_data", "strength": 0.0}
    
    # Simple linear regression
    n = len(values)
    x_values = list(range(n))
    x_mean = sum(x_values) / n
    y_mean = sum(values) / n
    
    numerator = sum((x - x_mean) * (y - y_mean) for x, y in zip(x_values, values))
    denominator = sum((x - x_mean) ** 2 for x in x_values)
    
    if denominator == 0:
        slope = 0
    else:
        slope = numerator / denominator
    
    # Calculate correlation coefficient for trend strength
    try:
        correlation = statistics.correlation(x_values, values) if n > 2 else 0.0
    except statistics.StatisticsError:
        correlation = 0.0
    
    # Determine trend direction
    if abs(slope) < 0.01:  # Practically no change
        direction = "stable"
    elif slope > 0:
        direction = "increasing"
    else:
        direction = "decreasing"
    
    return {
        "direction": direction,
        "slope": slope,
        "strength": abs(correlation),
        "correlation": correlation
    }


def _calculate_team_maturity(retros: List[RetrospectiveData]) -> Dict[str, Any]:
    """Calculate team maturity based on retrospective patterns."""
    if len(retros) < 3:
        return {"score": 50, "level": "developing"}
    
    maturity_indicators = {
        "action_item_focus": 0,      # Fewer but higher quality action items
        "sentiment_balance": 0,      # Balanced positive/negative sentiment
        "theme_consistency": 0,      # Consistent themes without chaos
        "participation": 0,          # High attendance rates
        "follow_through": 0          # Good action item completion
    }
    
    # Action item focus (quality over quantity)
    avg_action_items = sum(len(r.action_items) for r in retros) / len(retros)
    if 2 <= avg_action_items <= 5:  # Sweet spot
        maturity_indicators["action_item_focus"] = 100
    elif avg_action_items < 2 or avg_action_items > 8:
        maturity_indicators["action_item_focus"] = 30
    else:
        maturity_indicators["action_item_focus"] = 70
    
    # Sentiment balance
    avg_positive = sum(r.sentiment_scores.get("positive", 0) for r in retros) / len(retros)
    avg_negative = sum(r.sentiment_scores.get("negative", 0) for r in retros) / len(retros)
    
    if 0.3 <= avg_positive <= 0.6 and 0.2 <= avg_negative <= 0.4:
        maturity_indicators["sentiment_balance"] = 100
    else:
        maturity_indicators["sentiment_balance"] = 50
    
    # Participation
    avg_attendance = sum(r.attendance_rate for r in retros) / len(retros)
    maturity_indicators["participation"] = min(100, avg_attendance * 100)
    
    # Theme consistency (not too chaotic, not too narrow)
    avg_themes = sum(len(r.themes) for r in retros) / len(retros)
    if 2 <= avg_themes <= 4:
        maturity_indicators["theme_consistency"] = 100
    else:
        maturity_indicators["theme_consistency"] = 70
    
    # Follow-through (estimated from action item patterns)
    # This is simplified - in reality would track actual completion
    recent_retros = retros[-3:] if len(retros) >= 3 else retros
    avg_recent_actions = sum(len(r.action_items) for r in recent_retros) / len(recent_retros)
    
    if avg_recent_actions <= 3:  # Fewer action items might indicate better follow-through
        maturity_indicators["follow_through"] = 80
    else:
        maturity_indicators["follow_through"] = 60
    
    # Calculate overall maturity score
    overall_score = sum(maturity_indicators.values()) / len(maturity_indicators)
    
    if overall_score >= 85:
        level = "high_performing"
    elif overall_score >= 70:
        level = "performing"
    elif overall_score >= 55:
        level = "developing"
    else:
        level = "forming"
    
    return {
        "score": overall_score,
        "level": level,
        "indicators": maturity_indicators
    }


def _assess_retrospective_quality_trend(retros: List[RetrospectiveData]) -> Dict[str, Any]:
    """Assess the quality trend of retrospectives over time."""
    quality_scores = []
    
    for retro in retros:
        score = 0
        
        # Duration appropriateness (60-90 minutes is ideal)
        if 60 <= retro.duration_minutes <= 90:
            score += 25
        elif 45 <= retro.duration_minutes <= 120:
            score += 15
        else:
            score += 5
        
        # Participation
        score += min(25, retro.attendance_rate * 25)
        
        # Balance of content
        went_well_count = len(retro.went_well)
        to_improve_count = len(retro.to_improve)
        total_items = went_well_count + to_improve_count
        
        if total_items > 0:
            balance = min(went_well_count, to_improve_count) / total_items
            score += balance * 25
        
        # Action items quality (not too many, not too few)
        action_count = len(retro.action_items)
        if 2 <= action_count <= 5:
            score += 25
        elif 1 <= action_count <= 7:
            score += 15
        else:
            score += 5
        
        quality_scores.append(score)
    
    if len(quality_scores) >= 2:
        trend = _calculate_trend(quality_scores)
    else:
        trend = {"direction": "insufficient_data", "strength": 0.0}
    
    return {
        "quality_scores": quality_scores,
        "average_quality": statistics.mean(quality_scores),
        "trend": trend,
        "latest_quality": quality_scores[-1] if quality_scores else 0
    }


def _calculate_improvement_velocity(retros: List[RetrospectiveData]) -> Dict[str, Any]:
    """Calculate how quickly the team improves based on retrospective patterns."""
    if len(retros) < 4:
        return {"velocity": "insufficient_data"}
    
    # Look at theme evolution - are persistent issues being resolved?
    theme_counts = defaultdict(list)
    for retro in retros:
        for theme, count in retro.themes.items():
            theme_counts[theme].append(count)
    
    resolved_themes = 0
    persistent_themes = 0
    
    for theme, counts in theme_counts.items():
        if len(counts) >= 3:
            recent_avg = statistics.mean(counts[-2:])
            early_avg = statistics.mean(counts[:2])
            
            if recent_avg < early_avg * 0.7:  # 30% reduction
                resolved_themes += 1
            elif recent_avg > early_avg * 0.9:  # Still persistent
                persistent_themes += 1
    
    total_themes = resolved_themes + persistent_themes
    if total_themes > 0:
        resolution_rate = resolved_themes / total_themes
    else:
        resolution_rate = 0.5  # Neutral if no data
    
    # Action item completion trends
    if len(retros) >= 4:
        recent_action_density = sum(len(r.action_items) for r in retros[-2:]) / 2
        early_action_density = sum(len(r.action_items) for r in retros[:2]) / 2
        
        action_efficiency = 1.0
        if early_action_density > 0:
            action_efficiency = min(1.0, early_action_density / max(recent_action_density, 1))
    else:
        action_efficiency = 0.5
    
    # Overall velocity score
    velocity_score = (resolution_rate * 0.6) + (action_efficiency * 0.4)
    
    if velocity_score >= 0.8:
        velocity = "high"
    elif velocity_score >= 0.6:
        velocity = "moderate"
    elif velocity_score >= 0.4:
        velocity = "low"
    else:
        velocity = "stagnant"
    
    return {
        "velocity": velocity,
        "velocity_score": velocity_score,
        "theme_resolution_rate": resolution_rate,
        "action_efficiency": action_efficiency,
        "resolved_themes": resolved_themes,
        "persistent_themes": persistent_themes
    }


def generate_recommendations(result: RetroAnalysisResult) -> List[str]:
    """Generate actionable recommendations based on retrospective analysis."""
    recommendations = []
    
    # Action item recommendations
    action_analysis = result.action_item_analysis
    completion_rate = action_analysis.get("completion_rate", 0)
    
    if completion_rate < 0.5:
        recommendations.append("CRITICAL: Low action item completion rate (<50%). Reduce action items per retro and focus on realistic, achievable goals.")
    elif completion_rate < 0.7:
        recommendations.append("Improve action item follow-through. Consider assigning owners and due dates more systematically.")
    elif completion_rate > 0.9:
        recommendations.append("Excellent action item completion! Consider taking on more ambitious improvement initiatives.")
    
    overdue_rate = action_analysis.get("overdue_rate", 0)
    if overdue_rate > 0.3:
        recommendations.append("High overdue rate suggests unrealistic timelines. Review estimation and prioritization process.")
    
    # Theme recommendations
    theme_analysis = result.theme_analysis
    persistent_issues = theme_analysis.get("persistent_issues", [])
    if len(persistent_issues) >= 2:
        recommendations.append(f"Address {len(persistent_issues)} persistent issues that keep recurring across retrospectives.")
        for issue in persistent_issues[:2]:  # Top 2 issues
            recommendations.append(f"Focus on resolving recurring {issue['theme']} issues (appears in {issue['frequency']:.0%} of retros).")
    
    # Trend-based recommendations
    improvement_trends = result.improvement_trends
    if "team_maturity_score" in improvement_trends:
        maturity = improvement_trends["team_maturity_score"]
        level = maturity.get("level", "forming")
        
        if level == "forming":
            recommendations.append("Team is in forming stage. Focus on establishing basic retrospective disciplines and psychological safety.")
        elif level == "developing":
            recommendations.append("Team is developing. Work on action item follow-through and deeper root cause analysis.")
        elif level == "performing":
            recommendations.append("Good team maturity. Consider advanced techniques like continuous improvement tracking.")
        elif level == "high_performing":
            recommendations.append("Excellent retrospective maturity! Share practices with other teams and focus on innovation.")
    
    # Quality recommendations
    if "retrospective_quality_trend" in improvement_trends:
        quality_trend = improvement_trends["retrospective_quality_trend"]
        avg_quality = quality_trend.get("average_quality", 50)
        
        if avg_quality < 60:
            recommendations.append("Retrospective quality is below average. Review facilitation techniques and engagement strategies.")
        
        trend_direction = quality_trend.get("trend", {}).get("direction", "stable")
        if trend_direction == "decreasing":
            recommendations.append("Retrospective quality is declining. Consider changing facilitation approach or addressing team engagement issues.")
    
    return recommendations


# ---------------------------------------------------------------------------
# Main Analysis Function
# ---------------------------------------------------------------------------

def analyze_retrospectives(data: Dict[str, Any]) -> RetroAnalysisResult:
    """Perform comprehensive retrospective analysis."""
    result = RetroAnalysisResult()
    
    try:
        # Parse retrospective data
        retro_records = data.get("retrospectives", [])
        retros = [RetrospectiveData(record) for record in retro_records]
        
        if not retros:
            raise ValueError("No retrospective data found")
        
        # Sort by sprint number
        retros.sort(key=lambda r: r.sprint_number)
        
        # Basic summary
        result.summary = {
            "total_retrospectives": len(retros),
            "date_range": {
                "first": retros[0].date if retros else "",
                "last": retros[-1].date if retros else "",
                "span_sprints": retros[-1].sprint_number - retros[0].sprint_number + 1 if retros else 0
            },
            "average_duration": statistics.mean([r.duration_minutes for r in retros if r.duration_minutes > 0]),
            "average_attendance": statistics.mean([r.attendance_rate for r in retros]),
        }
        
        # Action item analysis
        result.action_item_analysis = analyze_action_item_completion(retros)
        
        # Theme analysis
        result.theme_analysis = analyze_recurring_themes(retros)
        
        # Improvement trends
        result.improvement_trends = analyze_improvement_trends(retros)
        
        # Generate recommendations
        result.recommendations = generate_recommendations(result)
        
    except Exception as e:
        result.summary = {"error": str(e)}
    
    return result


# ---------------------------------------------------------------------------
# Output Formatting
# ---------------------------------------------------------------------------

def format_text_output(result: RetroAnalysisResult) -> str:
    """Format analysis results as readable text report."""
    lines = []
    lines.append("="*60)
    lines.append("RETROSPECTIVE ANALYSIS REPORT")
    lines.append("="*60)
    lines.append("")
    
    if "error" in result.summary:
        lines.append(f"ERROR: {result.summary['error']}")
        return "\n".join(lines)
    
    # Summary section
    summary = result.summary
    lines.append("RETROSPECTIVE SUMMARY")
    lines.append("-"*30)
    lines.append(f"Total Retrospectives: {summary['total_retrospectives']}")
    lines.append(f"Sprint Range: {summary['date_range']['span_sprints']} sprints")
    lines.append(f"Average Duration: {summary.get('average_duration', 0):.0f} minutes")
    lines.append(f"Average Attendance: {summary.get('average_attendance', 0):.1%}")
    lines.append("")
    
    # Action item analysis
    action_analysis = result.action_item_analysis
    lines.append("ACTION ITEM ANALYSIS")
    lines.append("-"*30)
    lines.append(f"Total Action Items: {action_analysis.get('total_action_items', 0)}")
    lines.append(f"Completion Rate: {action_analysis.get('completion_rate', 0):.1%}")
    lines.append(f"Average Completion Time: {action_analysis.get('average_completion_time', 0):.1f} sprints")
    lines.append(f"Overdue Items: {action_analysis.get('overdue_items', 0)} ({action_analysis.get('overdue_rate', 0):.1%})")
    
    priority_analysis = action_analysis.get('priority_analysis', {})
    if priority_analysis:
        lines.append("Priority-based completion rates:")
        for priority, data in priority_analysis.items():
            lines.append(f"  {priority.title()}: {data['completion_rate']:.1%} ({data['completed']}/{data['total']})")
    lines.append("")
    
    # Theme analysis
    theme_analysis = result.theme_analysis
    lines.append("THEME ANALYSIS")
    lines.append("-"*30)
    recurring_themes = theme_analysis.get("recurring_themes", {})
    if recurring_themes:
        lines.append("Top recurring themes:")
        sorted_themes = sorted(recurring_themes.items(), key=lambda x: x[1]['frequency'], reverse=True)
        for theme, data in sorted_themes[:5]:
            lines.append(f"  {theme.replace('_', ' ').title()}: {data['frequency']:.1%} frequency, {data['trend']['direction']} trend")
    
    persistent_issues = theme_analysis.get("persistent_issues", [])
    if persistent_issues:
        lines.append("Persistent issues requiring attention:")
        for issue in persistent_issues:
            lines.append(f"  {issue['theme'].replace('_', ' ').title()}: {issue['frequency']:.1%} frequency")
    lines.append("")
    
    # Improvement trends
    improvement_trends = result.improvement_trends
    if "team_maturity_score" in improvement_trends:
        maturity = improvement_trends["team_maturity_score"]
        lines.append("TEAM MATURITY")
        lines.append("-"*30)
        lines.append(f"Maturity Level: {maturity['level'].replace('_', ' ').title()}")
        lines.append(f"Maturity Score: {maturity['score']:.0f}/100")
        lines.append("")
    
    if "improvement_velocity" in improvement_trends:
        velocity = improvement_trends["improvement_velocity"]
        lines.append("IMPROVEMENT VELOCITY")
        lines.append("-"*30)
        lines.append(f"Velocity: {velocity['velocity'].title()}")
        lines.append(f"Theme Resolution Rate: {velocity.get('theme_resolution_rate', 0):.1%}")
        lines.append("")
    
    # Recommendations
    if result.recommendations:
        lines.append("RECOMMENDATIONS")
        lines.append("-"*30)
        for i, rec in enumerate(result.recommendations, 1):
            lines.append(f"{i}. {rec}")
    
    return "\n".join(lines)


def format_json_output(result: RetroAnalysisResult) -> Dict[str, Any]:
    """Format analysis results as JSON."""
    return {
        "summary": result.summary,
        "action_item_analysis": result.action_item_analysis,
        "theme_analysis": result.theme_analysis,
        "improvement_trends": result.improvement_trends,
        "recommendations": result.recommendations,
    }


# ---------------------------------------------------------------------------
# CLI Interface
# ---------------------------------------------------------------------------

def main() -> int:
    """Main CLI entry point."""
    parser = argparse.ArgumentParser(
        description="Analyze retrospective data for continuous improvement insights"
    )
    parser.add_argument(
        "data_file", 
        help="JSON file containing retrospective data"
    )
    parser.add_argument(
        "--format", 
        choices=["text", "json"], 
        default="text",
        help="Output format (default: text)"
    )
    
    args = parser.parse_args()
    
    try:
        # Load and validate data
        with open(args.data_file, 'r') as f:
            data = json.load(f)
        
        # Perform analysis
        result = analyze_retrospectives(data)
        
        # Output results
        if args.format == "json":
            output = format_json_output(result)
            print(json.dumps(output, indent=2))
        else:
            output = format_text_output(result)
            print(output)
        
        return 0
        
    except FileNotFoundError:
        print(f"Error: File '{args.data_file}' not found", file=sys.stderr)
        return 1
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON in '{args.data_file}': {e}", file=sys.stderr)
        return 1
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    sys.exit(main())