Generating prerequisite practice questions

# Step 1: Find the target standard by statement code
curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/search?statementCode=6.NS.B.4&jurisdiction=Multi-State"

# Step 2: Get prerequisites using the caseIdentifierUUID from Step 1
curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/YOUR_UUID/prerequisites"

# Get learning components for a prerequisite standard
# Replace PREREQ_UUID with each prerequisite's caseIdentifierUUID
curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/PREREQ_UUID/learning-components"

function packageContextData(targetStandard, prerequisiteLearningComponents) {
  /* Package the standards and learning components data for text generation
   * This creates a structured context that can be used for generating practice questions
   */

  const standardsMap = new Map();

  // Group learning components by standard for context
  for (const row of prerequisiteLearningComponents) {
    if (!standardsMap.has(row.caseIdentifierUUID)) {
      standardsMap.set(row.caseIdentifierUUID, {
        statementCode: row.statementCode,
        description: row.standardDescription || '(no statement)',
        supportingLearningComponents: []
      });
    }

    standardsMap.get(row.caseIdentifierUUID).supportingLearningComponents.push({
      description: row.learningComponentDescription || '(no description)'
    });
  }

  const fullStandardsContext = {
    targetStandard: {
      statementCode: targetStandard.statementCode,
      description: targetStandard.description || '(no statement)'
    },
    prereqStandards: Array.from(standardsMap.values())
  };
  
  return fullStandardsContext;
}

const OpenAI = require('openai');

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const OPENAI_MODEL = 'gpt-4';
const OPENAI_TEMPERATURE = 0.7;

async function generatePractice(fullStandardsContext) {
  console.log(`🔄 Generating practice questions for ${fullStandardsContext.targetStandard.statementCode}...`);

  try {
    // Build prompt inline
    let prerequisiteText = '';
    for (const prereq of fullStandardsContext.prereqStandards) {
      prerequisiteText += `- ${prereq.statementCode}: ${prereq.description}\n`;
      prerequisiteText += '  Supporting Learning Components:\n';
      for (const lc of prereq.supportingLearningComponents) {
        prerequisiteText += `    • ${lc.description}\n`;
      }
    }

    const prompt = `You are a math tutor helping middle school students. Based on the following information, generate 3 practice questions for the target standard. Questions should help reinforce the key concept and build on prerequisite knowledge.

Target Standard:
- ${fullStandardsContext.targetStandard.statementCode}: ${fullStandardsContext.targetStandard.description}

Prerequisite Standards & Supporting Learning Components:
${prerequisiteText}`;

    const response = await openai.chat.completions.create({
      model: OPENAI_MODEL,
      messages: [
        { role: 'system', content: 'You are an expert middle school math tutor.' },
        { role: 'user', content: prompt }
      ],
      temperature: OPENAI_TEMPERATURE
    });

    const practiceQuestions = response.choices[0].message.content.trim();

    console.log(`✅ Generated practice questions:\n`);
    console.log(practiceQuestions);

    return {
      aiGenerated: practiceQuestions,
      targetStandard: fullStandardsContext.targetStandard.statementCode,
      prerequisiteCount: fullStandardsContext.prereqStandards.length
    };
  } catch (err) {
    console.error('❌ Error generating practice questions:', err.message);
    throw err;
  }
}