@telebort/question-banks 1.0.0

package/dist/cli/index.cjs

@@ -0,0 +1,855 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var promises = require('fs/promises');
+var path = require('path');
+var zod = require('zod');
+
+var FeedbackSchema = zod.z.object({
+  short: zod.z.string().min(1).max(200),
+  detailed: zod.z.string().min(1).max(1e3),
+  socraticHint: zod.z.string().max(300).optional()
+});
+var OptionKeySchema = zod.z.enum(["A", "B", "C", "D"]);
+var OptionSchema = zod.z.object({
+  key: OptionKeySchema,
+  text: zod.z.string().min(1),
+  isCorrect: zod.z.boolean(),
+  // v1.1 fields - optional for backward compatibility
+  misconceptionId: zod.z.string().optional(),
+  feedback: FeedbackSchema.optional()
+});
+var QuestionTypeSchema = zod.z.enum([
+  "vocabulary",
+  "code_understanding",
+  "problem_solving",
+  "application",
+  "reflection"
+]);
+var QuestionArchetypeSchema = zod.z.enum([
+  "vocabulary",
+  "trace",
+  "bebras",
+  "blockmodel",
+  "parsons"
+]);
+var DifficultySchema = zod.z.enum(["easy", "medium", "hard", "challenge"]);
+var BloomsTaxonomySchema = zod.z.enum([
+  "remember",
+  "understand",
+  "apply",
+  "analyze",
+  "evaluate",
+  "create"
+]);
+var QuestionMetadataSchema = zod.z.object({
+  difficulty: DifficultySchema,
+  estimatedTime: zod.z.number().int().positive(),
+  // seconds
+  bloomsTaxonomy: BloomsTaxonomySchema,
+  tags: zod.z.array(zod.z.string()),
+  source: zod.z.string().default("exit-ticket"),
+  version: zod.z.string().default("1.1"),
+  createdDate: zod.z.string().optional(),
+  lastModified: zod.z.string().optional()
+});
+var QuestionSchema = zod.z.object({
+  // Identifiers
+  questionId: zod.z.string().regex(/^[a-z0-9-]+-l\d+-q\d+$/),
+  globalId: zod.z.string().regex(/^exit-ticket-\d{4}$/),
+  questionNumber: zod.z.number().int().positive().max(5),
+  // Classification
+  questionType: QuestionTypeSchema,
+  questionTypeLabel: zod.z.string(),
+  questionArchetype: QuestionArchetypeSchema.optional(),
+  // v1.1
+  // Content
+  prompt: zod.z.string().min(10),
+  hasCodeBlock: zod.z.boolean(),
+  codeLanguage: zod.z.string().nullable(),
+  codeContent: zod.z.string().nullable(),
+  // Misconception targeting (v1.1)
+  misconceptionTargets: zod.z.array(zod.z.string()).optional(),
+  // Answer options (exactly 4)
+  options: zod.z.array(OptionSchema).length(4),
+  // Correct answer
+  correctAnswer: OptionKeySchema,
+  correctAnswerText: zod.z.string(),
+  // Metadata
+  metadata: QuestionMetadataSchema
+});
+QuestionSchema.omit({
+  correctAnswer: true,
+  correctAnswerText: true
+}).extend({
+  options: zod.z.array(
+    OptionSchema.omit({
+      isCorrect: true,
+      feedback: true,
+      misconceptionId: true
+    })
+  ).length(4)
+});
+var CourseDomainSchema = zod.z.enum([
+  // AI & Data Science
+  "ai_data_science",
+  "ai_ml_cv",
+  "ai_generative",
+  "ai_advanced",
+  // Web Development
+  "web_development",
+  // Mobile Development
+  "mobile_development",
+  "mobile",
+  // Block-based Programming
+  "block_based",
+  "python_programming",
+  "design",
+  // Foundation
+  "foundation",
+  "creative_computing"
+]);
+var CourseTierSchema = zod.z.enum([
+  "foundation",
+  "intermediate",
+  "advanced"
+]);
+var LessonSchema = zod.z.object({
+  lessonId: zod.z.string(),
+  // e.g., "ai-1-lesson-1"
+  lessonNumber: zod.z.number().int().positive(),
+  lessonTitle: zod.z.string(),
+  lessonSlug: zod.z.string().optional(),
+  totalQuestions: zod.z.number().int().positive().default(5),
+  questions: zod.z.array(QuestionSchema)
+});
+var CourseSchema = zod.z.object({
+  courseId: zod.z.string(),
+  // e.g., "ai-1"
+  courseName: zod.z.string(),
+  // e.g., "AI-1 Data Analysis and Data Science"
+  courseCode: zod.z.string(),
+  // e.g., "AI1"
+  domain: CourseDomainSchema,
+  tier: CourseTierSchema,
+  difficulty: zod.z.number().int().min(1).max(5),
+  totalLessons: zod.z.number().int().positive(),
+  totalQuestions: zod.z.number().int().positive(),
+  sourceFile: zod.z.string().optional(),
+  lessons: zod.z.array(LessonSchema)
+});
+CourseSchema.omit({ lessons: true }).extend({
+  lessons: zod.z.array(
+    LessonSchema.omit({ questions: true })
+  ).optional()
+});
+var UserResponseSchema = zod.z.object({
+  questionId: zod.z.string(),
+  selectedAnswer: OptionKeySchema,
+  timeSpent: zod.z.number().int().nonnegative().optional(),
+  // milliseconds
+  submittedAt: zod.z.string().datetime().optional()
+});
+zod.z.object({
+  assessmentId: zod.z.string().uuid().optional(),
+  // Generated if not provided
+  userId: zod.z.string().optional(),
+  // For authenticated users
+  sessionId: zod.z.string().optional(),
+  // For anonymous sessions
+  courseId: zod.z.string(),
+  lessonId: zod.z.string().optional(),
+  responses: zod.z.array(UserResponseSchema).min(1),
+  submittedAt: zod.z.string().datetime(),
+  metadata: zod.z.record(zod.z.unknown()).optional()
+  // Custom metadata
+});
+var GradedResponseSchema = zod.z.object({
+  questionId: zod.z.string(),
+  selectedAnswer: OptionKeySchema,
+  correctAnswer: OptionKeySchema,
+  isCorrect: zod.z.boolean(),
+  misconceptionId: zod.z.string().nullable(),
+  // For incorrect answers
+  feedback: FeedbackSchema.optional(),
+  timeSpent: zod.z.number().int().nonnegative().optional()
+});
+var MisconceptionReportSchema = zod.z.object({
+  misconceptionId: zod.z.string(),
+  count: zod.z.number().int().positive(),
+  percentage: zod.z.number().min(0).max(100),
+  questionIds: zod.z.array(zod.z.string()),
+  description: zod.z.string().optional()
+});
+zod.z.object({
+  assessmentId: zod.z.string().uuid(),
+  userId: zod.z.string().optional(),
+  courseId: zod.z.string(),
+  lessonId: zod.z.string().optional(),
+  // Scores
+  totalQuestions: zod.z.number().int().positive(),
+  correctCount: zod.z.number().int().nonnegative(),
+  incorrectCount: zod.z.number().int().nonnegative(),
+  score: zod.z.number().min(0).max(100),
+  // Percentage
+  passed: zod.z.boolean(),
+  // Based on threshold (default 70%)
+  // Detailed results
+  responses: zod.z.array(GradedResponseSchema),
+  // Misconception analysis (v1.1 feature)
+  misconceptions: zod.z.array(MisconceptionReportSchema).optional(),
+  topMisconceptions: zod.z.array(zod.z.string()).max(3).optional(),
+  // Timing
+  totalTimeSpent: zod.z.number().int().nonnegative().optional(),
+  // milliseconds
+  averageTimePerQuestion: zod.z.number().nonnegative().optional(),
+  submittedAt: zod.z.string().datetime(),
+  gradedAt: zod.z.string().datetime()
+});
+zod.z.object({
+  valid: zod.z.boolean(),
+  errors: zod.z.array(zod.z.object({
+    path: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
+    message: zod.z.string(),
+    code: zod.z.string().optional()
+  })).optional(),
+  isComplete: zod.z.boolean(),
+  // All questions answered
+  questionCount: zod.z.number().int(),
+  answeredCount: zod.z.number().int()
+});
+
+// src/cli/utils/formatters.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function green(text) {
+  return `${colors.green}${text}${colors.reset}`;
+}
+function red(text) {
+  return `${colors.red}${text}${colors.reset}`;
+}
+function cyan(text) {
+  return `${colors.cyan}${text}${colors.reset}`;
+}
+function bold(text) {
+  return `${colors.bold}${text}${colors.reset}`;
+}
+function formatQuestion(q, index) {
+  const difficultyColors = {
+    easy: colors.green,
+    medium: colors.yellow,
+    hard: colors.red,
+    challenge: colors.magenta
+  };
+  const diffColor = difficultyColors[q.metadata.difficulty] || colors.white;
+  const diffLabel = `${diffColor}${q.metadata.difficulty}${colors.reset}`;
+  let output = `
+${colors.bold}Q${index + 1}${colors.reset} [${diffLabel}] ${q.prompt}
+`;
+  if (q.hasCodeBlock && q.codeContent) {
+    output += `${colors.dim}\u250C\u2500 ${q.codeLanguage || "code"} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${colors.reset}
+`;
+    const codeLines = q.codeContent.split("\n");
+    for (const line of codeLines) {
+      output += `${colors.dim}\u2502${colors.reset} ${line}
+`;
+    }
+    output += `${colors.dim}\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${colors.reset}
+`;
+  }
+  for (const opt of q.options) {
+    output += `  ${colors.cyan}${opt.key})${colors.reset} ${opt.text}
+`;
+  }
+  return output;
+}
+function formatStats(stats, title) {
+  let output = "\n";
+  if (title) {
+    output += `${colors.bold}${colors.cyan}${title}${colors.reset}
+`;
+    output += `${"\u2500".repeat(40)}
+
+`;
+  }
+  output += `${colors.bold}Overview${colors.reset}
+`;
+  output += `  Total Courses:     ${stats.totalCourses}
+`;
+  output += `  Total Lessons:     ${stats.totalLessons}
+`;
+  output += `  Total Questions:   ${stats.totalQuestions}
+
+`;
+  output += `${colors.bold}Questions by Difficulty${colors.reset}
+`;
+  const difficulties = ["easy", "medium", "hard", "challenge"];
+  for (const diff of difficulties) {
+    const count = stats.byDifficulty[diff] || 0;
+    const pct = stats.totalQuestions > 0 ? Math.round(count / stats.totalQuestions * 100) : 0;
+    const bar = "\u2588".repeat(Math.floor(pct / 5));
+    output += `  ${diff.padEnd(10)} ${String(count).padStart(4)}  ${colors.dim}${bar}${colors.reset} ${pct}%
+`;
+  }
+  output += "\n";
+  output += `${colors.bold}Questions by Type${colors.reset}
+`;
+  const types = Object.entries(stats.byQuestionType).sort((a, b) => b[1] - a[1]);
+  for (const [type, count] of types) {
+    output += `  ${type.padEnd(20)} ${count}
+`;
+  }
+  output += "\n";
+  output += `${colors.bold}Code Blocks${colors.reset}
+`;
+  output += `  With Code:         ${stats.withCodeBlocks}
+`;
+  output += `  Without Code:      ${stats.withoutCodeBlocks}
+`;
+  return output;
+}
+function formatValidationError(filePath, errors) {
+  let output = `
+${colors.red}\u2717${colors.reset} ${filePath}
+`;
+  for (const error of errors) {
+    const path = error.path.join(".");
+    output += `  ${colors.dim}\u2192${colors.reset} ${path}: ${error.message}
+`;
+  }
+  return output;
+}
+function formatValidationSuccess(filePath, lessonCount, questionCount) {
+  return `${colors.green}\u2713${colors.reset} ${filePath}
+  ${colors.dim}${lessonCount} lessons, ${questionCount} questions${colors.reset}
+`;
+}
+function formatSummary(passed, failed) {
+  const total = passed + failed;
+  if (failed === 0) {
+    return `
+${colors.green}${colors.bold}All ${total} files valid${colors.reset}
+`;
+  }
+  return `
+${colors.red}${colors.bold}${failed}/${total} files failed validation${colors.reset}
+`;
+}
+
+// src/cli/utils/error-handler.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  VALIDATION_ERROR: 1,
+  USAGE_ERROR: 2,
+  FATAL_ERROR: 3
+};
+function setupErrorHandlers() {
+  process.on("uncaughtException", (error) => {
+    console.error(`
+${red(bold("Uncaught Exception:"))} ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(EXIT_CODES.FATAL_ERROR);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    console.error(`
+${red(bold("Unhandled Rejection:"))} ${message}`);
+    if (process.env.DEBUG && reason instanceof Error) {
+      console.error(reason.stack);
+    }
+    process.exit(EXIT_CODES.FATAL_ERROR);
+  });
+}
+
+// src/cli/commands/validate.ts
+async function validateFile(filePath, verbose) {
+  try {
+    const content = await promises.readFile(filePath, "utf-8");
+    const data = JSON.parse(content);
+    const result = CourseSchema.safeParse(data);
+    if (result.success) {
+      const lessonCount = result.data.lessons?.length ?? 0;
+      const questionCount = result.data.lessons?.reduce(
+        (sum, l) => sum + (l.questions?.length ?? 0),
+        0
+      ) ?? 0;
+      console.log(formatValidationSuccess(path.basename(filePath), lessonCount, questionCount));
+      return true;
+    } else {
+      const errors = result.error.issues.map((issue) => ({
+        path: issue.path,
+        message: issue.message
+      }));
+      console.log(formatValidationError(path.basename(filePath), verbose ? errors : errors.slice(0, 5)));
+      if (!verbose && errors.length > 5) {
+        console.log(`  ... and ${errors.length - 5} more errors (use --verbose to see all)
+`);
+      }
+      return false;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(formatValidationError(path.basename(filePath), [
+      { path: [], message: `Parse error: ${message}` }
+    ]));
+    return false;
+  }
+}
+async function validateDirectory(dirPath, verbose) {
+  const files = await promises.readdir(dirPath);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  if (jsonFiles.length === 0) {
+    console.log(`No JSON files found in ${dirPath}`);
+    return false;
+  }
+  console.log(`
+${cyan(bold("Validating"))} ${jsonFiles.length} files in ${dirPath}
+`);
+  let passed = 0;
+  let failed = 0;
+  for (const file of jsonFiles.sort()) {
+    const filePath = path.join(dirPath, file);
+    const success = await validateFile(filePath, verbose);
+    if (success) {
+      passed++;
+    } else {
+      failed++;
+    }
+  }
+  console.log(formatSummary(passed, failed));
+  return failed === 0;
+}
+async function validateCommand(fileOrDir, options) {
+  try {
+    const stats = await promises.stat(fileOrDir);
+    if (stats.isDirectory()) {
+      const success = await validateDirectory(fileOrDir, options.verbose);
+      process.exit(success ? EXIT_CODES.SUCCESS : EXIT_CODES.VALIDATION_ERROR);
+    } else if (stats.isFile()) {
+      console.log(`
+${cyan(bold("Validating"))} ${path.basename(fileOrDir)}
+`);
+      const success = await validateFile(fileOrDir, options.verbose);
+      if (success) {
+        console.log(`
+${green(bold("Valid!"))} File passed schema validation.
+`);
+      }
+      process.exit(success ? EXIT_CODES.SUCCESS : EXIT_CODES.VALIDATION_ERROR);
+    } else {
+      console.error(`Invalid path: ${fileOrDir}`);
+      process.exit(EXIT_CODES.USAGE_ERROR);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      console.error(`File or directory not found: ${fileOrDir}`);
+      process.exit(EXIT_CODES.USAGE_ERROR);
+    }
+    throw error;
+  }
+}
+
+// src/index.ts
+function createExitTicketsSDK(config) {
+  let courses = null;
+  const questionsById = /* @__PURE__ */ new Map();
+  const questionsByGlobalId = /* @__PURE__ */ new Map();
+  async function ensureLoaded() {
+    if (courses === null) {
+      courses = await config.dataSource.loadCourses();
+      for (const course of courses) {
+        for (const lesson of course.lessons) {
+          for (const question of lesson.questions) {
+            questionsById.set(question.questionId, question);
+            questionsByGlobalId.set(question.globalId, question.questionId);
+          }
+        }
+      }
+    }
+    return courses;
+  }
+  const data = {
+    async getCourses() {
+      return ensureLoaded();
+    },
+    async getCourse(courseId) {
+      const all = await ensureLoaded();
+      return all.find((c) => c.courseId === courseId) ?? null;
+    },
+    async getLesson(courseId, lessonNumber) {
+      const course = await data.getCourse(courseId);
+      return course?.lessons.find((l) => l.lessonNumber === lessonNumber) ?? null;
+    },
+    async getQuestion(questionId) {
+      await ensureLoaded();
+      return questionsById.get(questionId) ?? null;
+    },
+    async getAllQuestions() {
+      await ensureLoaded();
+      return Array.from(questionsById.values());
+    }
+  };
+  const query = {
+    async filterQuestions(filters) {
+      const all = await data.getAllQuestions();
+      let filtered = all;
+      if (filters.courseId) {
+        filtered = filtered.filter((q) => q.questionId.startsWith(filters.courseId));
+      }
+      if (filters.lessonNumber) {
+        filtered = filtered.filter((q) => q.questionId.includes(`-l${filters.lessonNumber}-`));
+      }
+      if (filters.questionType) {
+        filtered = filtered.filter((q) => q.questionType === filters.questionType);
+      }
+      if (filters.difficulty) {
+        filtered = filtered.filter((q) => q.metadata.difficulty === filters.difficulty);
+      }
+      if (filters.hasCodeBlock !== void 0) {
+        filtered = filtered.filter((q) => q.hasCodeBlock === filters.hasCodeBlock);
+      }
+      if (filters.tags?.length) {
+        filtered = filtered.filter(
+          (q) => filters.tags.some((tag) => q.metadata.tags.includes(tag))
+        );
+      }
+      const total = filtered.length;
+      const offset = filters.offset ?? 0;
+      const limit = filters.limit ?? 20;
+      const paginated = filtered.slice(offset, offset + limit);
+      return {
+        data: paginated,
+        total,
+        limit,
+        offset,
+        hasMore: offset + limit < total
+      };
+    },
+    async getRandomQuestions(count, filters) {
+      const result = await query.filterQuestions({ ...filters, limit: 1e3 });
+      const shuffled = [...result.data].sort(() => Math.random() - 0.5);
+      return shuffled.slice(0, count);
+    }
+  };
+  const quiz = {
+    async generateQuiz(criteria) {
+      const questions = await query.getRandomQuestions(criteria.questionCount, {
+        courseId: criteria.courseIds?.[0],
+        difficulty: criteria.difficulty,
+        questionType: criteria.questionTypes?.[0],
+        hasCodeBlock: criteria.includeCodeBlocks
+      });
+      return {
+        questions,
+        metadata: {
+          distribution: questions.reduce((acc, q) => {
+            acc[q.questionType] = (acc[q.questionType] ?? 0) + 1;
+            return acc;
+          }, {}),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    },
+    async getLessonQuiz(courseId, lessonNumber) {
+      const lesson = await data.getLesson(courseId, lessonNumber);
+      return lesson?.questions ?? [];
+    }
+  };
+  const search = {
+    async search(options) {
+      const all = await data.getAllQuestions();
+      const query2 = options.query.toLowerCase();
+      const scored = all.map((q) => {
+        let score = 0;
+        if (q.prompt.toLowerCase().includes(query2)) score += 3;
+        if (q.options.some((o) => o.text.toLowerCase().includes(query2))) score += 1;
+        return { ...q, relevanceScore: score };
+      }).filter((q) => q.relevanceScore > 0).sort((a, b) => b.relevanceScore - a.relevanceScore);
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? 20;
+      return {
+        data: scored.slice(offset, offset + limit),
+        total: scored.length,
+        limit,
+        offset,
+        hasMore: offset + limit < scored.length
+      };
+    },
+    async searchByTags(tags, matchAll = false) {
+      const all = await data.getAllQuestions();
+      return all.filter((q) => {
+        if (matchAll) {
+          return tags.every((tag) => q.metadata.tags.includes(tag));
+        }
+        return tags.some((tag) => q.metadata.tags.includes(tag));
+      });
+    }
+  };
+  const analytics = {
+    async getStatistics() {
+      const all = await ensureLoaded();
+      const questions = await data.getAllQuestions();
+      const stats = {
+        totalCourses: all.length,
+        totalLessons: all.reduce((sum, c) => sum + c.lessons.length, 0),
+        totalQuestions: questions.length,
+        byDifficulty: {},
+        byQuestionType: {},
+        byBloomsTaxonomy: {},
+        withCodeBlocks: 0,
+        withoutCodeBlocks: 0
+      };
+      for (const q of questions) {
+        stats.byDifficulty[q.metadata.difficulty] = (stats.byDifficulty[q.metadata.difficulty] ?? 0) + 1;
+        stats.byQuestionType[q.questionType] = (stats.byQuestionType[q.questionType] ?? 0) + 1;
+        stats.byBloomsTaxonomy[q.metadata.bloomsTaxonomy] = (stats.byBloomsTaxonomy[q.metadata.bloomsTaxonomy] ?? 0) + 1;
+        if (q.hasCodeBlock) stats.withCodeBlocks++;
+        else stats.withoutCodeBlocks++;
+      }
+      return stats;
+    },
+    async getCourseStatistics(courseId) {
+      const course = await data.getCourse(courseId);
+      if (!course) throw new Error(`Course not found: ${courseId}`);
+      const questions = course.lessons.flatMap((l) => l.questions);
+      const stats = {
+        courseId,
+        totalCourses: 1,
+        totalLessons: course.lessons.length,
+        totalQuestions: questions.length,
+        byDifficulty: {},
+        byQuestionType: {},
+        byBloomsTaxonomy: {},
+        withCodeBlocks: 0,
+        withoutCodeBlocks: 0
+      };
+      for (const q of questions) {
+        stats.byDifficulty[q.metadata.difficulty] = (stats.byDifficulty[q.metadata.difficulty] ?? 0) + 1;
+        stats.byQuestionType[q.questionType] = (stats.byQuestionType[q.questionType] ?? 0) + 1;
+        stats.byBloomsTaxonomy[q.metadata.bloomsTaxonomy] = (stats.byBloomsTaxonomy[q.metadata.bloomsTaxonomy] ?? 0) + 1;
+        if (q.hasCodeBlock) stats.withCodeBlocks++;
+        else stats.withoutCodeBlocks++;
+      }
+      return stats;
+    }
+  };
+  const validate = {
+    async checkAnswer(questionId, answer, mode) {
+      const question = await data.getQuestion(questionId);
+      if (!question) throw new Error(`Question not found: ${questionId}`);
+      const selectedOption = question.options.find((o) => o.key === answer);
+      if (!selectedOption) throw new Error(`Invalid answer: ${answer}`);
+      const isCorrect = selectedOption.isCorrect;
+      return {
+        isCorrect,
+        feedback: selectedOption.feedback,
+        misconceptionId: !isCorrect ? selectedOption.misconceptionId : null,
+        correctAnswer: mode === "formative" ? question.correctAnswer : void 0
+      };
+    }
+  };
+  return {
+    data,
+    query,
+    quiz,
+    search,
+    analytics,
+    validate
+  };
+}
+
+// src/cli/utils/sdk-loader.ts
+var sdkCache = /* @__PURE__ */ new Map();
+async function detectDataDir() {
+  const possiblePaths = [
+    // Relative to SDK
+    "../exit-tickets-api/data/courses",
+    // Relative to current working directory
+    "./data/courses",
+    "../data/courses",
+    // Absolute common locations
+    path.join(process.cwd(), "data", "courses")
+  ];
+  for (const path$1 of possiblePaths) {
+    try {
+      const resolved = path.resolve(path$1);
+      const files = await promises.readdir(resolved);
+      const jsonFiles = files.filter((f) => f.endsWith(".json"));
+      if (jsonFiles.length > 0) {
+        return resolved;
+      }
+    } catch {
+    }
+  }
+  throw new Error(
+    "Could not find data directory. Use --data-dir to specify the path to course JSON files."
+  );
+}
+async function loadCoursesFromDir(dir) {
+  const files = await promises.readdir(dir);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  if (jsonFiles.length === 0) {
+    throw new Error(`No JSON files found in ${dir}`);
+  }
+  const courses = [];
+  for (const file of jsonFiles) {
+    try {
+      const content = await promises.readFile(path.join(dir, file), "utf-8");
+      const data = JSON.parse(content);
+      courses.push(data);
+    } catch (error) {
+      console.warn(`Warning: Could not parse ${file}`);
+    }
+  }
+  return courses;
+}
+async function loadSDK(options) {
+  const dataDir = options?.dataDir || await detectDataDir();
+  const cacheKey = path.resolve(dataDir);
+  if (sdkCache.has(cacheKey)) {
+    return sdkCache.get(cacheKey);
+  }
+  const sdk = createExitTicketsSDK({
+    dataSource: {
+      async loadCourses() {
+        return loadCoursesFromDir(dataDir);
+      }
+    }
+  });
+  sdkCache.set(cacheKey, sdk);
+  return sdk;
+}
+
+// src/cli/commands/stats.ts
+async function statsCommand(options) {
+  try {
+    const dataDir = options.dataDir || await detectDataDir();
+    const sdk = await loadSDK({ dataDir });
+    if (options.course) {
+      try {
+        const stats = await sdk.analytics.getCourseStatistics(options.course);
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          console.log(formatStats(stats, `Course: ${options.course}`));
+        }
+      } catch (error) {
+        console.error(`${red("Error:")} Course not found: ${options.course}`);
+        console.error("Use --data-dir to specify the path to course files.");
+        process.exit(EXIT_CODES.USAGE_ERROR);
+      }
+    } else {
+      const stats = await sdk.analytics.getStatistics();
+      if (options.json) {
+        console.log(JSON.stringify(stats, null, 2));
+      } else {
+        console.log(formatStats(stats, "Exit Tickets Statistics"));
+      }
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${red("Error:")} ${message}`);
+    process.exit(EXIT_CODES.FATAL_ERROR);
+  }
+}
+
+// src/cli/commands/quiz.ts
+async function quizCommand(options) {
+  try {
+    const dataDir = options.dataDir || await detectDataDir();
+    const sdk = await loadSDK({ dataDir });
+    const quiz = await sdk.quiz.generateQuiz({
+      questionCount: options.count,
+      courseIds: options.course ? [options.course] : void 0,
+      difficulty: options.difficulty,
+      questionTypes: options.type ? [options.type] : void 0
+    });
+    if (quiz.questions.length === 0) {
+      console.error(`${red("Error:")} No questions found matching criteria.`);
+      if (options.course) {
+        console.error(`Check if course "${options.course}" exists.`);
+      }
+      process.exit(EXIT_CODES.USAGE_ERROR);
+    }
+    if (options.json) {
+      const output = {
+        questions: options.showAnswers ? quiz.questions : quiz.questions.map((q) => ({
+          ...q,
+          correctAnswer: void 0,
+          correctAnswerText: void 0,
+          options: q.options.map((o) => ({
+            key: o.key,
+            text: o.text
+          }))
+        })),
+        metadata: quiz.metadata
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      const title = options.course ? `Sample Quiz (${quiz.questions.length} questions from ${options.course})` : `Sample Quiz (${quiz.questions.length} questions)`;
+      console.log(`
+${cyan(bold(title))}
+`);
+      for (let i = 0; i < quiz.questions.length; i++) {
+        const q = quiz.questions[i];
+        console.log(formatQuestion(q, i));
+        if (options.showAnswers) {
+          console.log(`  ${green("Answer:")} ${q.correctAnswer}) ${q.correctAnswerText}
+`);
+        }
+      }
+      console.log(`
+${bold("Distribution:")}`);
+      for (const [type, count] of Object.entries(quiz.metadata.distribution)) {
+        console.log(`  ${type}: ${count}`);
+      }
+      console.log();
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${red("Error:")} ${message}`);
+    process.exit(EXIT_CODES.FATAL_ERROR);
+  }
+}
+
+// src/cli/index.ts
+setupErrorHandlers();
+var program = new commander.Command();
+program.name("exit-tickets").description("CLI tools for Exit Tickets SDK").version("1.0.0");
+program.command("validate <path>").description("Validate course JSON files against schemas").option("-v, --verbose", "Show all validation errors").action(async (path, options) => {
+  await validateCommand(path, options);
+});
+program.command("stats").description("Show exit ticket statistics").option("-c, --course <id>", "Show statistics for a specific course").option("--json", "Output as JSON").option("-d, --data-dir <path>", "Path to course data directory").action(async (options) => {
+  await statsCommand(options);
+});
+program.command("quiz").description("Generate a sample quiz").option("-c, --course <id>", "Filter by course ID").option("-n, --count <number>", "Number of questions", "5").option("--difficulty <level>", "Filter by difficulty (easy, medium, hard, challenge)").option("--type <type>", "Filter by question type").option("--json", "Output as JSON").option("-a, --show-answers", "Show correct answers").option("-d, --data-dir <path>", "Path to course data directory").action(async (options) => {
+  await quizCommand({
+    ...options,
+    count: parseInt(options.count, 10)
+  });
+});
+function createCLI() {
+  return program;
+}
+async function run(argv) {
+  await program.parseAsync(argv ?? process.argv);
+}
+
+exports.createCLI = createCLI;
+exports.run = run;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map