@telebort/question-banks 2.3.0 → 2.4.0

package/dist/cli/index.js

@@ -78,6 +78,10 @@ var QuestionMetadataSchema = z.object({
   // seconds
   bloomsTaxonomy: BloomsTaxonomySchema,
   tags: z.array(z.string()),
+  conceptTags: z.array(z.string()).optional(),
+  // mastery-relevant concept tags
+  metaTags: z.array(z.string()).optional(),
+  // Bloom's types, course codes, internal
   source: z.string().default("exit-ticket"),
   version: z.string().default("1.1"),
   createdDate: z.string().optional(),
@@ -120,70 +124,17 @@ QuestionSchema.omit({
     })
   ).length(4)
 });
-var CourseDomainSchema = z.enum([
-  // AI & Data Science
-  "ai_data_science",
-  "ai_ml_cv",
-  "ai_generative",
-  "ai_advanced",
-  "ai",
-  // Prompt Engineering (general AI)
-  // Web Development
-  "web_development",
-  // Mobile Development
-  "mobile_development",
-  "mobile",
-  // Block-based Programming
-  "block_based",
-  "python_programming",
-  "design",
-  "artificial_intelligence",
-  // Block-based AI courses (BBAI)
-  // Computer Science
-  "cs_foundations",
-  // CS1-CS4 courses
-  // Foundation
-  "foundation",
-  "creative_computing",
-  // Utility / Tools
-  "tools"
-  // IDE Setup, Git, Vibe Coding
-]);
-var CourseTierSchema = z.enum([
-  "beginner",
-  // Block-based courses (BBW, BBP, BBD, BBAI)
-  "foundation",
-  "intermediate",
-  "advanced"
-]);
-var LessonSchema = z.object({
-  lessonId: z.string(),
-  // e.g., "ai-1-lesson-1"
-  lessonNumber: z.number().int().positive(),
-  lessonTitle: z.string(),
-  lessonSlug: z.string().optional(),
-  totalQuestions: z.number().int().positive().default(5),
-  questions: z.array(QuestionSchema)
-});
-var CourseSchema = z.object({
-  courseId: z.string(),
-  // e.g., "ai-1"
-  courseName: z.string(),
-  // e.g., "AI-1 Data Analysis and Data Science"
-  courseCode: z.string(),
-  // e.g., "AI1"
-  domain: CourseDomainSchema,
-  tier: CourseTierSchema,
-  difficulty: z.number().int().min(1).max(5),
-  totalLessons: z.number().int().positive(),
-  totalQuestions: z.number().int().positive(),
-  sourceFile: z.string().optional(),
-  lessons: z.array(LessonSchema)
-});
-CourseSchema.omit({ lessons: true }).extend({
-  lessons: z.array(
-    LessonSchema.omit({ questions: true })
-  ).optional()
+var AssessmentBlueprintSchema = z.object({
+  assessmentId: z.string(),
+  // e.g., "cs1-quiz-1"
+  title: z.string(),
+  // e.g., "Quiz 1"
+  description: z.string(),
+  lessonRange: z.tuple([z.number().int().positive(), z.number().int().positive()]).refine(([start2, end2]) => start2 <= end2, { message: "lessonRange start must be <= end" }),
+  questionCount: z.number().int().positive(),
+  passingScore: z.number().min(0).max(100),
+  timeLimitMinutes: z.number().int().positive().nullable(),
+  tags: z.array(z.string()).optional()
 });
 var UserResponseSchema = z.object({
   questionId: z.string(),
@@ -224,7 +175,7 @@ var MisconceptionReportSchema = z.object({
   description: z.string().optional()
 });
 z.object({
-  assessmentId: z.string().uuid(),
+  assessmentId: z.string(),
   userId: z.string().optional(),
   courseId: z.string(),
   lessonId: z.string().optional(),
@@ -260,6 +211,74 @@ z.object({
   questionCount: z.number().int(),
   answeredCount: z.number().int()
 });
+
+// src/schemas/course.ts
+var CourseDomainSchema = z.enum([
+  // AI & Data Science
+  "ai_data_science",
+  "ai_ml_cv",
+  "ai_generative",
+  "ai_advanced",
+  "ai",
+  // Prompt Engineering (general AI)
+  // Web Development
+  "web_development",
+  // Mobile Development
+  "mobile_development",
+  "mobile",
+  // Block-based Programming
+  "block_based",
+  "python_programming",
+  "design",
+  "artificial_intelligence",
+  // Block-based AI courses (BBAI)
+  // Computer Science
+  "cs_foundations",
+  // CS1-CS4 courses
+  // Foundation
+  "foundation",
+  "creative_computing",
+  // Utility / Tools
+  "tools"
+  // IDE Setup, Git, Vibe Coding
+]);
+var CourseTierSchema = z.enum([
+  "beginner",
+  // Block-based courses (BBW, BBP, BBD, BBAI)
+  "foundation",
+  "intermediate",
+  "advanced"
+]);
+var LessonSchema = z.object({
+  lessonId: z.string(),
+  // e.g., "ai-1-lesson-1"
+  lessonNumber: z.number().int().positive(),
+  lessonTitle: z.string(),
+  lessonSlug: z.string().optional(),
+  totalQuestions: z.number().int().positive().default(5),
+  questions: z.array(QuestionSchema)
+});
+var CourseSchema = z.object({
+  courseId: z.string(),
+  // e.g., "ai-1"
+  courseName: z.string(),
+  // e.g., "AI-1 Data Analysis and Data Science"
+  courseCode: z.string(),
+  // e.g., "AI1"
+  domain: CourseDomainSchema,
+  tier: CourseTierSchema,
+  difficulty: z.number().int().min(1).max(5),
+  totalLessons: z.number().int().positive(),
+  totalQuestions: z.number().int().positive(),
+  sourceFile: z.string().optional(),
+  lessons: z.array(LessonSchema),
+  assessments: z.array(AssessmentBlueprintSchema).optional()
+});
+CourseSchema.omit({ lessons: true }).extend({
+  lessons: z.array(
+    LessonSchema.omit({ questions: true })
+  ).optional()
+});
 var CertificationProjectSchema = z.object({
   projectNumber: z.number().int().positive(),
   projectName: z.string(),
@@ -547,6 +566,138 @@ ${green(bold("Valid!"))} File passed schema validation.
   }
 }
 
+// src/core/assessment.ts
+var SeededRandom = class {
+  constructor(seed) {
+    this.state = seed;
+  }
+  next() {
+    this.state = (this.state * 1103515245 + 12345) % 2147483648;
+    return this.state / 2147483648;
+  }
+  /** Fisher-Yates shuffle */
+  shuffle(array) {
+    const result = [...array];
+    for (let i3 = result.length - 1; i3 > 0; i3--) {
+      const j2 = Math.floor(this.next() * (i3 + 1));
+      const temp = result[i3];
+      result[i3] = result[j2];
+      result[j2] = temp;
+    }
+    return result;
+  }
+};
+function hashString(str) {
+  let hash = 0;
+  for (let i3 = 0; i3 < str.length; i3++) {
+    const char = str.charCodeAt(i3);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function createAssessmentModule(getCourse) {
+  return {
+    async getAssessments(courseId) {
+      const course = await getCourse(courseId);
+      return course?.assessments ?? [];
+    },
+    async buildAssessmentQuiz(courseId, assessmentId, seed) {
+      const course = await getCourse(courseId);
+      if (!course) throw new Error(`Course not found: ${courseId}`);
+      const blueprint = course.assessments?.find((a2) => a2.assessmentId === assessmentId);
+      if (!blueprint) throw new Error(`Assessment not found: ${assessmentId}`);
+      const [rangeStart, rangeEnd] = blueprint.lessonRange;
+      const pool = [];
+      for (const lesson of course.lessons) {
+        if (lesson.lessonNumber >= rangeStart && lesson.lessonNumber <= rangeEnd) {
+          pool.push(...lesson.questions);
+        }
+      }
+      if (pool.length === 0) {
+        throw new Error(`No questions found for lessons ${rangeStart}-${rangeEnd} in ${courseId}`);
+      }
+      const seedValue = seed ? hashString(seed) : Date.now();
+      const rng = new SeededRandom(seedValue);
+      const shuffled = rng.shuffle(pool);
+      return shuffled.slice(0, Math.min(blueprint.questionCount, shuffled.length));
+    },
+    async gradeAssessment(courseId, assessmentId, responses, passingScore) {
+      const course = await getCourse(courseId);
+      if (!course) throw new Error(`Course not found: ${courseId}`);
+      const blueprint = course.assessments?.find((a2) => a2.assessmentId === assessmentId);
+      if (!blueprint) throw new Error(`Assessment not found: ${assessmentId}`);
+      const threshold = passingScore ?? blueprint.passingScore;
+      const questionMap = /* @__PURE__ */ new Map();
+      for (const lesson of course.lessons) {
+        for (const q of lesson.questions) {
+          questionMap.set(q.questionId, q);
+        }
+      }
+      const gradedResponses = [];
+      let correctCount = 0;
+      for (const response of responses) {
+        const question = questionMap.get(response.questionId);
+        if (!question) continue;
+        const selectedOption = question.options.find((o2) => o2.key === response.selectedAnswer);
+        const isCorrect = selectedOption?.isCorrect ?? false;
+        if (isCorrect) correctCount++;
+        gradedResponses.push({
+          questionId: response.questionId,
+          selectedAnswer: response.selectedAnswer,
+          correctAnswer: question.correctAnswer,
+          isCorrect,
+          misconceptionId: isCorrect ? null : selectedOption?.misconceptionId ?? null,
+          feedback: selectedOption?.feedback,
+          timeSpent: response.timeSpent
+        });
+      }
+      const totalQuestions = gradedResponses.length;
+      const score = totalQuestions > 0 ? Math.round(correctCount / totalQuestions * 100) : 0;
+      const misconceptionCounts = /* @__PURE__ */ new Map();
+      for (const gr of gradedResponses) {
+        if (gr.misconceptionId) {
+          const existing = misconceptionCounts.get(gr.misconceptionId);
+          if (existing) {
+            existing.count++;
+            existing.questionIds.push(gr.questionId);
+          } else {
+            misconceptionCounts.set(gr.misconceptionId, {
+              count: 1,
+              questionIds: [gr.questionId]
+            });
+          }
+        }
+      }
+      const misconceptions = Array.from(misconceptionCounts.entries()).map(([id, data]) => ({
+        misconceptionId: id,
+        count: data.count,
+        percentage: Math.round(data.count / totalQuestions * 100),
+        questionIds: data.questionIds
+      })).sort((a2, b) => b.count - a2.count);
+      if (totalQuestions === 0) {
+        throw new Error(`No valid questions matched for assessment ${assessmentId}. All ${responses.length} response(s) referenced unknown questionIds.`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const generatedId = `grade-${courseId}-${assessmentId}-${hashString(now).toString(36)}`;
+      return {
+        assessmentId: generatedId,
+        courseId,
+        totalQuestions,
+        correctCount,
+        incorrectCount: totalQuestions - correctCount,
+        score,
+        passed: score >= threshold,
+        responses: gradedResponses,
+        misconceptions,
+        topMisconceptions: misconceptions.slice(0, 3).map((m3) => m3.misconceptionId),
+        submittedAt: now,
+        gradedAt: now
+      };
+    }
+  };
+}
+
 // src/knowledge/index.ts
 function createLogger(config) {
   return {
@@ -23288,6 +23439,7 @@ function createExitTicketsSDK(config) {
   };
   const malaysiaMath = createMalaysiaMathModule(malaysiaMathConfig);
   const malaysiaMathTaxonomy = createMalaysiaMathTaxonomyModule(malaysiaMathConfig);
+  const assessment = createAssessmentModule(data.getCourse);
   return {
     data,
     query,
@@ -23298,7 +23450,8 @@ function createExitTicketsSDK(config) {
     knowledge,
     taxonomy,
     malaysiaMath,
-    malaysiaMathTaxonomy
+    malaysiaMathTaxonomy,
+    assessment
   };
 }
 
@@ -23467,26 +23620,32 @@ async function loadCourseData(filePath) {
 }
 function extractQuestions(courseData) {
   const questions = [];
+  const pushQuestion = (q) => {
+    questions.push({
+      questionId: q.questionId || q.globalId || `${courseData.courseId || "unknown"}-unknown`,
+      prompt: q.prompt || "",
+      options: (q.options || []).map((o2) => ({
+        key: o2.key || "",
+        text: o2.text || "",
+        isCorrect: o2.isCorrect || false
+      })),
+      hasCodeBlock: q.hasCodeBlock || false,
+      codeLanguage: q.codeLanguage || null,
+      codeContent: q.codeContent || null
+    });
+  };
   if (courseData.lessons) {
     for (const lesson of courseData.lessons) {
       if (lesson.questions) {
         for (const q of lesson.questions) {
-          questions.push({
-            questionId: q.questionId || `${courseData.courseId}-unknown`,
-            prompt: q.prompt || "",
-            options: (q.options || []).map((o2) => ({
-              key: o2.key || "",
-              text: o2.text || "",
-              isCorrect: o2.isCorrect || false
-            })),
-            // CS-specific fields for enhanced analysis
-            hasCodeBlock: q.hasCodeBlock || false,
-            codeLanguage: q.codeLanguage || null,
-            codeContent: q.codeContent || null
-          });
+          pushQuestion(q);
         }
       }
     }
+  } else if (courseData.questions && Array.isArray(courseData.questions)) {
+    for (const q of courseData.questions) {
+      pushQuestion(q);
+    }
   }
   return questions;
 }