Adaptive Learning Assistant

export function buildTutorPrompt(params: {
  subject: string;
  topic: string;
  studentMastery: number; // 0-100
  previousMisconceptions: string[];
}) {
  const level =
    params.studentMastery < 30 ? "beginner" :
    params.studentMastery < 70 ? "intermediate" : "advanced";

  return `You are a patient, encouraging AI tutor
specializing in ${params.subject}.

CURRENT TOPIC: ${params.topic}
STUDENT LEVEL: ${level} (${params.studentMastery}% mastery)

TEACHING APPROACH:
- Use the Socratic method: ask guiding questions
  instead of giving answers directly
- For beginners: use simple language, concrete
  examples, and analogies from everyday life
- For intermediate: introduce formal terminology,
  ask "why" and "how" questions
- For advanced: pose challenging scenarios,
  encourage critical thinking and connections

KNOWN MISCONCEPTIONS TO ADDRESS:
${params.previousMisconceptions.map(m =>
  `- ${m}`).join("\n") || "None identified yet"}

RULES:
1. Never give the answer directly — guide the
   student to discover it
2. If the student is stuck, provide a hint, not
   the solution
3. Celebrate correct answers and gently redirect
   incorrect ones
4. After 3-4 exchanges on a concept, assess
   understanding with a targeted question
5. If mastery seems high, suggest moving to the
   next topic
6. Keep responses concise (2-3 paragraphs max)`;
}

// Simple Bayesian knowledge tracing update
export function updateMastery(
  currentMastery: number,
  wasCorrect: boolean,
  difficulty: number // 1-5
): number {
  // Learning rate varies by difficulty
  const learningRate = 0.1 + (difficulty * 0.05);

  // Slip probability (correct answer by guessing)
  const slipRate = 0.1;

  // Guess probability
  const guessRate = 0.25;

  if (wasCorrect) {
    // Bayesian update for correct answer
    const pCorrectGivenKnow = 1 - slipRate;
    const pCorrectGivenNotKnow = guessRate;
    const prior = currentMastery / 100;

    const posterior =
      (pCorrectGivenKnow * prior) /
      (pCorrectGivenKnow * prior +
       pCorrectGivenNotKnow * (1 - prior));

    // Apply learning rate
    return Math.min(
      100,
      currentMastery + (posterior * 100
        - currentMastery) * learningRate
    );
  } else {
    // Decrease mastery on incorrect answer
    return Math.max(
      0,
      currentMastery - learningRate * 15
    );
  }
}