Adaptive Learning

// From server/services/subject-recommendation.ts:157
export function updateSubjectPerformance(
  profile: LearnerProfile,
  lesson: Lesson
): Record<string, any> {
  const performances = profile.subjectPerformance || {};
  const current = performances[lesson.subject] || {
    score: 0,
    lessonCount: 0,
    lastAttempted: new Date().toISOString(),
    masteryLevel: 'beginner'
  };
  
  // Calculate new average score
  const newLessonCount = current.lessonCount + 1;
  const newScore = Math.round(
    (current.score * current.lessonCount + lesson.score) / newLessonCount
  );
  
  // Determine mastery level
  let masteryLevel = 'beginner';
  if (newScore >= 85 && newLessonCount >= 5) {
    masteryLevel = 'advanced';
  } else if (newScore >= 70 && newLessonCount >= 3) {
    masteryLevel = 'intermediate';
  }
  
  performances[lesson.subject] = {
    score: newScore,
    lessonCount: newLessonCount,
    lastAttempted: new Date().toISOString(),
    masteryLevel
  };
  
  return performances;
}

// From server/services/subject-recommendation.ts:84
export function identifyStrugglingAreas(lessonHistory: Lesson[]): string[] {
  const subjectScores: Record<string, { total: number, count: number }> = {};
  
  // Only consider completed lessons with scores
  const completedLessons = lessonHistory.filter(
    lesson => lesson.status === 'DONE' && lesson.score !== null
  );
  
  // Group scores by subject
  for (const lesson of completedLessons) {
    if (!lesson.subject || lesson.score === null) continue;
    
    if (!subjectScores[lesson.subject]) {
      subjectScores[lesson.subject] = { total: 0, count: 0 };
    }
    
    subjectScores[lesson.subject].total += lesson.score;
    subjectScores[lesson.subject].count += 1;
  }
  
  // Find subjects with average score below 70%
  const strugglingSubjects = Object.entries(subjectScores)
    .filter(([_, stats]) => (stats.total / stats.count) < 70)
    .map(([subject, _]) => subject);
  
  return strugglingSubjects;
}

// From server/services/subject-recommendation.ts:119
export function recommendSubjects(
  profile: LearnerProfile,
  lessonHistory: Lesson[]
): string[] {
  // Get appropriate subjects for the grade level
  const gradeAppropriate = getSubjectsForGradeLevel(profile.gradeLevel);
  
  // Get subjects the learner is currently using
  const currentSubjects = profile.subjects || [];
  
  // Get subjects the learner is struggling with
  const strugglingSubjects = identifyStrugglingAreas(lessonHistory);
  
  // Find subjects that are appropriate but not yet assigned
  const potentialNewSubjects = gradeAppropriate.filter(
    subject => !currentSubjects.includes(subject)
  );
  
  // Recommend up to 3 new subjects
  const recommendations = potentialNewSubjects.slice(0, 3);
  
  // Add struggling subjects to work on if there's room
  for (const subject of strugglingSubjects) {
    if (recommendations.length < 3 && !recommendations.includes(subject)) {
      recommendations.push(subject);
    }
  }
  
  return recommendations;
}