Agile Development

{
  "sprint": {
    "number": 12,
    "goal": "Implement user authentication system",
    "duration": "2 weeks",
    "startDate": "2025-08-25",
    "endDate": "2025-09-08",
    "team": {
      "productOwner": "Jane Smith",
      "scrumMaster": "John Doe",
      "developers": [
        "Alice Johnson",
        "Bob Wilson",
        "Carol Brown"
      ]
    },
    "ceremonies": {
      "planning": "Monday 9:00 AM",
      "dailyScrum": "Daily 10:00 AM",
      "review": "Friday 2:00 PM",
      "retrospective": "Friday 3:30 PM"
    },
    "velocity": {
      "previousSprint": 25,
      "average": 23,
      "commitment": 24
    }
  },
  "stories": [
    {
      "id": "AUTH-1",
      "title": "User Registration",
      "description": "Implement user registration with email verification",
      "points": 8,
      "acceptance": [
        "Email validation",
        "Password strength check",
        "Duplicate email prevention",
        "Verification email sent",
        "Account activation flow"
      ]
    },
    {
      "id": "AUTH-2",
      "title": "User Login",
      "points": 5,
      "description": "Implement secure login with JWT",
      "acceptance": [
        "Email/password authentication",
        "JWT token generation",
        "Remember me functionality",
        "Failed login handling"
      ]
    }
  ]
}

# Daily Scrum - [Date]

## Team Updates

### Alice Johnson
- Yesterday:
  - Completed user registration API
  - Started email verification service
- Today:
  - Complete email verification
  - Start password reset flow
- Blockers:
  - None

### Bob Wilson
- Yesterday:
  - Finished UI mockups review
  - Started registration form implementation
- Today:
  - Complete registration form
  - Start validation logic
- Blockers:
  - Need API documentation

### Carol Brown
- Yesterday:
  - Completed test framework setup
  - Wrote integration tests
- Today:
  - Add more test coverage
  - Review PR feedback
- Blockers:
  - CI pipeline issues

board:
  name: Development Kanban
  columns:
    - name: Backlog
      limit: none
      description: Upcoming work items
      
    - name: Ready
      limit: 5
      description: Ready for development
      
    - name: In Progress
      limit: 3
      description: Currently being worked on
      
    - name: Code Review
      limit: 2
      description: Pending review
      
    - name: Testing
      limit: 2
      description: QA verification
      
    - name: Done
      limit: none
      description: Completed items

  swimlanes:
    - name: Expedite
      color: red
    - name: Standard
      color: green
    - name: Non-Critical
      color: blue

  policies:
    pull:
      - Finish current task before starting new one
      - Respect WIP limits
      - Pull from right to left
    
    done:
      - Code reviewed
      - Tests passed
      - Documentation updated
      - Deployed to staging

interface Story {
    id: string;
    title: string;
    complexity: number;
    uncertainty: number;
    effort: number;
}

class StoryPointCalculator {
    private readonly fibonacciSequence: number[] = [1, 2, 3, 5, 8, 13, 21];

    calculatePoints(story: Story): number {
        const rawPoints = this.calculateRawPoints(story);
        return this.mapToFibonacci(rawPoints);
    }

    private calculateRawPoints(story: Story): number {
        const weightedSum = 
            (story.complexity * 0.4) +
            (story.uncertainty * 0.3) +
            (story.effort * 0.3);
            
        return weightedSum * 10;
    }

    private mapToFibonacci(points: number): number {
        return this.fibonacciSequence.reduce((prev, curr) => {
            if (Math.abs(curr - points) < Math.abs(prev - points)) {
                return curr;
            }
            return prev;
        });
    }

    estimateVelocity(
        previousSprints: number[],
        sprintCount: number = 3
    ): number {
        const recentSprints = previousSprints
            .slice(-sprintCount)
            .filter(v => v > 0);

        if (recentSprints.length === 0) {
            return 0;
        }

        const sum = recentSprints.reduce((a, b) => a + b, 0);
        return Math.round(sum / recentSprints.length);
    }
}

interface SprintMetrics {
    completedPoints: number;
    committedPoints: number;
    defectsFound: number;
    defectsFixed: number;
    cycleTime: number[];
}

class AgileMetricsAnalyzer {
    calculateVelocity(sprints: SprintMetrics[]): number {
        const completedPoints = sprints.map(s => s.completedPoints);
        return this.calculateAverage(completedPoints);
    }

    calculatePredictability(sprint: SprintMetrics): number {
        return (sprint.completedPoints / sprint.committedPoints) * 100;
    }

    calculateDefectDensity(sprint: SprintMetrics): number {
        return sprint.defectsFound / sprint.completedPoints;
    }

    calculateAverageCycleTime(sprint: SprintMetrics): number {
        return this.calculateAverage(sprint.cycleTime);
    }

    generateReport(sprints: SprintMetrics[]): string {
        const velocity = this.calculateVelocity(sprints);
        const lastSprint = sprints[sprints.length - 1];
        const predictability = this.calculatePredictability(lastSprint);
        const defectDensity = this.calculateDefectDensity(lastSprint);
        const cycleTime = this.calculateAverageCycleTime(lastSprint);

        return `
Sprint Metrics Report
--------------------
Velocity (avg): ${velocity.toFixed(1)} points
Predictability: ${predictability.toFixed(1)}%
Defect Density: ${defectDensity.toFixed(2)} defects/point
Cycle Time: ${cycleTime.toFixed(1)} days
        `;
    }

    private calculateAverage(numbers: number[]): number {
        if (numbers.length === 0) return 0;
        return numbers.reduce((a, b) => a + b, 0) / numbers.length;
    }
}