@gonzih/exam-prep-mcp 0.1.0

package/dist/tools.d.ts

@@ -0,0 +1,132 @@
+export interface SetExamInput {
+    profileId: string;
+    examType: string;
+    examDate: string;
+    currentLevel: 'beginner' | 'intermediate' | 'advanced';
+}
+export interface GetDailySessionInput {
+    profileId: string;
+}
+export interface AnswerQuestionInput {
+    profileId: string;
+    cardId: string;
+    answer: string;
+    rating?: 1 | 2 | 3 | 4;
+}
+export interface StartMockExamInput {
+    profileId: string;
+}
+export interface SubmitMockExamInput {
+    sessionId: string;
+    answers: Array<{
+        cardId: string;
+        answer: string;
+    }>;
+}
+export interface GetReadinessInput {
+    profileId: string;
+}
+export interface GetWeakAreasInput {
+    profileId: string;
+}
+export declare function setExam(input: SetExamInput): Promise<{
+    success: boolean;
+    message: string;
+    seededCards: number;
+    daysRemaining: number;
+    topicsIdentified: string[];
+    studyPlan: {
+        examType: string;
+        examDate: string;
+        daysRemaining: number;
+        weeklyGoals: string[];
+        first7Days: import("./study-plan.js").DayPlan[];
+    };
+}>;
+export declare function getDailySession(input: GetDailySessionInput): Promise<{
+    questions: {
+        cardId: string;
+        subject: string;
+        topic: string;
+        question: string;
+        type: "multiple_choice" | "short_answer" | "free_response" | "problem_solving";
+        choices: string[] | undefined;
+        difficulty: string;
+        reviewCount: number;
+    }[];
+    estimatedMinutes: number;
+    focusAreas: string[];
+    totalDue: number;
+    examType: string;
+    examDate: string;
+}>;
+export declare function answerQuestion(input: AnswerQuestionInput): Promise<{
+    correct: boolean;
+    correctAnswer: string;
+    explanation: string;
+    nextReview: string;
+    intervalDays: number;
+    rating: 1 | 2 | 3 | 4;
+    weakAreaAlert: string | undefined;
+    topic: string;
+    subject: string;
+}>;
+export declare function startMockExam(input: StartMockExamInput): Promise<{
+    sessionId: string;
+    questions: {
+        cardId: string;
+        subject: string;
+        topic: string;
+        question: string;
+        type: "multiple_choice" | "short_answer" | "free_response" | "problem_solving";
+        choices: string[] | undefined;
+    }[];
+    timeLimitMins: number;
+    totalQuestions: number;
+    examType: string;
+    instructions: string;
+}>;
+export declare function submitMockExam(input: SubmitMockExamInput): Promise<{
+    score: number;
+    correct: number;
+    total: number;
+    passingThreshold: number;
+    passed: boolean;
+    estimatedGrade: string;
+    readinessScore: number | undefined;
+    topicBreakdown: {
+        topic: string;
+        correct: number;
+        total: number;
+        accuracy: number;
+    }[];
+    strongestTopics: string[];
+    weakestTopics: string[];
+    recommendation: string | undefined;
+}>;
+export declare function getReadiness(input: GetReadinessInput): Promise<{
+    score: number;
+    strongTopics: import("./readiness.js").TopicScore[];
+    weakTopics: import("./readiness.js").TopicScore[];
+    coveragePercent: number;
+    trend: "improving" | "declining" | "stable";
+    recommendation: string;
+    estimatedGrade: string;
+    profileId: string;
+    examType: string;
+    examDate: string;
+}>;
+export interface WeakArea {
+    topic: string;
+    subject: string;
+    accuracy: number;
+    attempts: number;
+    correctAttempts: number;
+}
+export declare function getWeakAreas(input: GetWeakAreasInput): Promise<{
+    profileId: string;
+    examType: string | undefined;
+    topics: WeakArea[];
+    suggestedFocus: string;
+    totalWeakTopics: number;
+}>;

package/dist/tools.js

@@ -0,0 +1,424 @@
+import { v4 as uuidv4 } from 'uuid';
+import { insertCard, insertSession, updateSession, getSession, getCard, updateCard, getDueCards, getNewCards, getAllCardsForExam, getWeakTopics, upsertExamConfig, getExamConfig, upsertTopicStats, getTopicStats, countCardsByQuestion, } from './db.js';
+import { scheduleReview } from './fsrs.js';
+import { QUESTION_BANK } from './questions.js';
+import { generateStudyPlan, MOCK_EXAM_QUESTIONS, EXAM_TIME_LIMITS } from './study-plan.js';
+import { calculateReadiness } from './readiness.js';
+// ─── Helper Functions ─────────────────────────────────────────────────────────
+function questionTemplateToCard(template, profileId) {
+    return {
+        id: uuidv4(),
+        profile_id: profileId,
+        subject: template.subject,
+        topic: template.topic,
+        question: formatQuestion(template),
+        answer: template.answer,
+        difficulty: template.difficulty === 'easy' ? 0.2 : template.difficulty === 'medium' ? 0.4 : 0.7,
+        stability: 1.0,
+        retrievability: 1.0,
+        next_review: new Date().toISOString(),
+        review_count: 0,
+        last_rating: null,
+        created_at: new Date().toISOString(),
+    };
+}
+function formatQuestion(template) {
+    if (template.type === 'multiple_choice' && template.choices) {
+        return `${template.question}\n\n${template.choices.join('\n')}`;
+    }
+    return template.question;
+}
+function evaluateAnswer(card, studentAnswer, template) {
+    const correctAnswer = card.answer.trim().toLowerCase();
+    const studentAnswerNorm = studentAnswer.trim().toLowerCase();
+    // Multiple choice — exact match (single letter)
+    if (template?.type === 'multiple_choice') {
+        const correct = correctAnswer === studentAnswerNorm ||
+            correctAnswer.startsWith(studentAnswerNorm) ||
+            studentAnswerNorm === correctAnswer[0];
+        return {
+            correct,
+            explanation: template.explanation
+        };
+    }
+    // Problem solving — check numeric answer
+    if (template?.type === 'problem_solving') {
+        // Extract numbers from both answers
+        const correctNum = extractNumber(correctAnswer);
+        const studentNum = extractNumber(studentAnswerNorm);
+        if (correctNum !== null && studentNum !== null) {
+            const tolerance = Math.abs(correctNum) * 0.05 || 0.01;
+            const correct = Math.abs(correctNum - studentNum) <= tolerance;
+            return { correct, explanation: template?.explanation || '' };
+        }
+        // Fallback to keyword matching
+        return keywordMatch(correctAnswer, studentAnswerNorm, template?.explanation || '');
+    }
+    // Short answer / free response — keyword matching
+    return keywordMatch(correctAnswer, studentAnswerNorm, template?.explanation || '');
+}
+function extractNumber(text) {
+    const match = text.match(/-?\d+\.?\d*/);
+    if (match)
+        return parseFloat(match[0]);
+    return null;
+}
+function keywordMatch(correctAnswer, studentAnswer, explanation) {
+    // Check if student answer contains key terms from correct answer
+    const keyTerms = correctAnswer
+        .split(/[\s,;.]+/)
+        .filter(w => w.length > 3)
+        .map(w => w.toLowerCase());
+    if (keyTerms.length === 0) {
+        const correct = correctAnswer === studentAnswer;
+        return { correct, explanation };
+    }
+    let matched = 0;
+    for (const term of keyTerms) {
+        if (studentAnswer.includes(term))
+            matched++;
+    }
+    const matchRatio = matched / keyTerms.length;
+    const correct = matchRatio >= 0.5;
+    return { correct, explanation };
+}
+function findTemplate(question) {
+    // Strip choices if present
+    const questionText = question.split('\n\n')[0];
+    return QUESTION_BANK.find(t => t.question === questionText);
+}
+// ─── Tool Implementations ─────────────────────────────────────────────────────
+export async function setExam(input) {
+    const { profileId, examType, examDate, currentLevel } = input;
+    // Store exam config
+    upsertExamConfig({
+        profile_id: profileId,
+        exam_type: examType,
+        exam_date: examDate,
+        current_level: currentLevel,
+        created_at: new Date().toISOString(),
+    });
+    // Seed cards from question bank
+    const questions = QUESTION_BANK.filter(q => q.subject === examType);
+    let seeded = 0;
+    for (const template of questions) {
+        const formattedQuestion = formatQuestion(template);
+        const existing = countCardsByQuestion(profileId, formattedQuestion);
+        if (existing === 0) {
+            const card = questionTemplateToCard(template, profileId);
+            card.question = formattedQuestion;
+            insertCard(card);
+            seeded++;
+        }
+    }
+    // Generate study plan
+    const studyPlan = generateStudyPlan(examType, examDate, currentLevel);
+    const now = new Date();
+    const examDateObj = new Date(examDate);
+    const daysRemaining = Math.ceil((examDateObj.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+    return {
+        success: true,
+        message: `Exam configured: ${examType} on ${examDate}`,
+        seededCards: seeded,
+        daysRemaining,
+        topicsIdentified: studyPlan.topicsIdentified,
+        studyPlan: {
+            examType: studyPlan.examType,
+            examDate: studyPlan.examDate,
+            daysRemaining: studyPlan.daysRemaining,
+            weeklyGoals: studyPlan.weeklyGoals,
+            first7Days: studyPlan.dailySchedule.slice(0, 7),
+        }
+    };
+}
+export async function getDailySession(input) {
+    const { profileId } = input;
+    const config = getExamConfig(profileId);
+    if (!config) {
+        throw new Error('No exam configured. Use set_exam first.');
+    }
+    const now = new Date().toISOString();
+    const TARGET_QUESTIONS = 12;
+    // Get due cards
+    let dueCards = getDueCards(profileId, now, TARGET_QUESTIONS);
+    // Top up with new cards if needed
+    if (dueCards.length < 5) {
+        const newCards = getNewCards(profileId, TARGET_QUESTIONS - dueCards.length);
+        const existingIds = new Set(dueCards.map(c => c.id));
+        const uniqueNew = newCards.filter(c => !existingIds.has(c.id));
+        dueCards = [...dueCards, ...uniqueNew].slice(0, TARGET_QUESTIONS);
+    }
+    // Identify focus areas
+    const topicCounts = {};
+    for (const card of dueCards) {
+        topicCounts[card.topic] = (topicCounts[card.topic] || 0) + 1;
+    }
+    const focusAreas = Object.entries(topicCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([topic]) => topic);
+    const questions = dueCards.map(card => ({
+        cardId: card.id,
+        subject: card.subject,
+        topic: card.topic,
+        question: card.question,
+        type: findTemplate(card.question)?.type || 'short_answer',
+        choices: findTemplate(card.question)?.choices,
+        difficulty: card.difficulty < 0.35 ? 'easy' : card.difficulty < 0.55 ? 'medium' : 'hard',
+        reviewCount: card.review_count,
+    }));
+    return {
+        questions,
+        estimatedMinutes: Math.ceil(dueCards.length * 2.5),
+        focusAreas,
+        totalDue: dueCards.length,
+        examType: config.exam_type,
+        examDate: config.exam_date,
+    };
+}
+export async function answerQuestion(input) {
+    const { profileId, cardId, answer, rating } = input;
+    const card = getCard(cardId);
+    if (!card) {
+        throw new Error(`Card ${cardId} not found`);
+    }
+    if (card.profile_id !== profileId) {
+        throw new Error('Card does not belong to this profile');
+    }
+    const template = findTemplate(card.question);
+    const { correct, explanation } = evaluateAnswer(card, answer, template);
+    // Determine FSRS rating
+    let fsrsRating = rating || (correct ? 3 : 1);
+    if (!rating) {
+        fsrsRating = correct ? 3 : 1;
+    }
+    // Apply FSRS scheduling
+    const lastReview = card.next_review ? new Date(card.next_review) : undefined;
+    const fsrsResult = scheduleReview(fsrsRating, card.stability, card.difficulty, card.review_count, lastReview);
+    // Update card
+    updateCard({
+        id: card.id,
+        difficulty: fsrsResult.difficulty,
+        stability: fsrsResult.stability,
+        retrievability: fsrsResult.retrievability,
+        next_review: fsrsResult.nextReview.toISOString(),
+        review_count: card.review_count + 1,
+        last_rating: fsrsRating,
+    });
+    // Update topic stats
+    upsertTopicStats({
+        profile_id: profileId,
+        topic: card.topic,
+        subject: card.subject,
+        total_attempts: 1,
+        correct_attempts: correct ? 1 : 0,
+        last_attempt: new Date().toISOString(),
+    });
+    // Check for weak area
+    let weakAreaAlert;
+    const topicStats = getTopicStats(profileId).find(s => s.topic === card.topic);
+    if (topicStats && topicStats.total_attempts >= 5) {
+        const accuracy = topicStats.correct_attempts / topicStats.total_attempts;
+        if (accuracy < 0.6) {
+            weakAreaAlert = `Weak area detected: ${card.topic} (${Math.round(accuracy * 100)}% accuracy over ${topicStats.total_attempts} attempts). Consider extra focus on this topic.`;
+        }
+    }
+    return {
+        correct,
+        correctAnswer: card.answer,
+        explanation,
+        nextReview: fsrsResult.nextReview.toISOString(),
+        intervalDays: fsrsResult.intervalDays,
+        rating: fsrsRating,
+        weakAreaAlert,
+        topic: card.topic,
+        subject: card.subject,
+    };
+}
+export async function startMockExam(input) {
+    const { profileId } = input;
+    const config = getExamConfig(profileId);
+    if (!config) {
+        throw new Error('No exam configured. Use set_exam first.');
+    }
+    const examType = config.exam_type;
+    const questionCount = MOCK_EXAM_QUESTIONS[examType] || 60;
+    const timeLimitMins = EXAM_TIME_LIMITS[examType] || 120;
+    // Select balanced questions across topics
+    const cards = getAllCardsForExam(profileId, examType, questionCount * 2);
+    const shuffled = [...cards].sort(() => Math.random() - 0.5);
+    const selected = shuffled.slice(0, questionCount);
+    // Create session
+    const sessionId = uuidv4();
+    insertSession({
+        id: sessionId,
+        profile_id: profileId,
+        exam_type: examType,
+        started_at: new Date().toISOString(),
+        ended_at: null,
+        questions_answered: 0,
+        correct: 0,
+        readiness_score: null,
+    });
+    const questions = selected.map(card => ({
+        cardId: card.id,
+        subject: card.subject,
+        topic: card.topic,
+        question: card.question,
+        type: findTemplate(card.question)?.type || 'short_answer',
+        choices: findTemplate(card.question)?.choices,
+    }));
+    return {
+        sessionId,
+        questions,
+        timeLimitMins,
+        totalQuestions: questions.length,
+        examType,
+        instructions: `You have ${timeLimitMins} minutes to complete ${questions.length} questions. This simulates the actual ${examType} exam. Answer each question and submit when done.`,
+    };
+}
+export async function submitMockExam(input) {
+    const { sessionId, answers } = input;
+    const session = getSession(sessionId);
+    if (!session) {
+        throw new Error(`Session ${sessionId} not found`);
+    }
+    const profileId = session.profile_id;
+    const config = getExamConfig(profileId);
+    // Grade all answers
+    let correct = 0;
+    const topicBreakdown = {};
+    const gradedAnswers = [];
+    for (const submission of answers) {
+        const card = getCard(submission.cardId);
+        if (!card)
+            continue;
+        const template = findTemplate(card.question);
+        const result = evaluateAnswer(card, submission.answer, template);
+        if (result.correct)
+            correct++;
+        // Update topic stats
+        upsertTopicStats({
+            profile_id: profileId,
+            topic: card.topic,
+            subject: card.subject,
+            total_attempts: 1,
+            correct_attempts: result.correct ? 1 : 0,
+            last_attempt: new Date().toISOString(),
+        });
+        // Topic breakdown
+        if (!topicBreakdown[card.topic]) {
+            topicBreakdown[card.topic] = { correct: 0, total: 0 };
+        }
+        topicBreakdown[card.topic].total++;
+        if (result.correct)
+            topicBreakdown[card.topic].correct++;
+        gradedAnswers.push({
+            cardId: submission.cardId,
+            correct: result.correct,
+            topic: card.topic,
+        });
+    }
+    const total = answers.length;
+    const score = total > 0 ? Math.round((correct / total) * 100) : 0;
+    // Calculate readiness
+    let readinessReport = null;
+    if (config) {
+        readinessReport = calculateReadiness(profileId, config.exam_type, config.exam_date);
+    }
+    // Update session
+    updateSession({
+        id: sessionId,
+        ended_at: new Date().toISOString(),
+        questions_answered: total,
+        correct,
+        readiness_score: readinessReport?.score ?? null,
+    });
+    // Format topic breakdown
+    const topicResults = Object.entries(topicBreakdown).map(([topic, stats]) => ({
+        topic,
+        correct: stats.correct,
+        total: stats.total,
+        accuracy: Math.round((stats.correct / stats.total) * 100),
+    })).sort((a, b) => a.accuracy - b.accuracy);
+    // Determine passing threshold
+    const examType = session.exam_type;
+    let passingThreshold = 60;
+    let estimatedGrade = `${score}%`;
+    if (examType.startsWith('AP_')) {
+        passingThreshold = 55;
+        if (score >= 85)
+            estimatedGrade = 'AP Score: 5/5';
+        else if (score >= 70)
+            estimatedGrade = 'AP Score: 4/5';
+        else if (score >= 55)
+            estimatedGrade = 'AP Score: 3/5';
+        else if (score >= 40)
+            estimatedGrade = 'AP Score: 2/5';
+        else
+            estimatedGrade = 'AP Score: 1/5';
+    }
+    else if (examType === 'SAT_Math') {
+        passingThreshold = 60;
+        if (score >= 90)
+            estimatedGrade = 'SAT Math: ~760-800';
+        else if (score >= 80)
+            estimatedGrade = 'SAT Math: ~700-750';
+        else if (score >= 70)
+            estimatedGrade = 'SAT Math: ~630-690';
+        else
+            estimatedGrade = 'SAT Math: below 630';
+    }
+    return {
+        score,
+        correct,
+        total,
+        passingThreshold,
+        passed: score >= passingThreshold,
+        estimatedGrade,
+        readinessScore: readinessReport?.score,
+        topicBreakdown: topicResults,
+        strongestTopics: topicResults.filter(t => t.accuracy >= 80).map(t => t.topic),
+        weakestTopics: topicResults.filter(t => t.accuracy < 60).map(t => t.topic),
+        recommendation: readinessReport?.recommendation,
+    };
+}
+export async function getReadiness(input) {
+    const { profileId } = input;
+    const config = getExamConfig(profileId);
+    if (!config) {
+        throw new Error('No exam configured. Use set_exam first.');
+    }
+    const report = calculateReadiness(profileId, config.exam_type, config.exam_date);
+    return {
+        profileId,
+        examType: config.exam_type,
+        examDate: config.exam_date,
+        ...report,
+    };
+}
+export async function getWeakAreas(input) {
+    const { profileId } = input;
+    const config = getExamConfig(profileId);
+    const weakTopicStats = getWeakTopics(profileId, 0.6);
+    const topics = weakTopicStats.map(stats => ({
+        topic: stats.topic,
+        subject: stats.subject,
+        accuracy: Math.round((stats.correct_attempts / stats.total_attempts) * 100),
+        attempts: stats.total_attempts,
+        correctAttempts: stats.correct_attempts,
+    }));
+    // Suggest focus
+    let suggestedFocus = 'No weak areas identified yet — keep practicing!';
+    if (topics.length > 0) {
+        const top3 = topics.slice(0, 3).map(t => t.topic).join(', ');
+        suggestedFocus = `Focus intensively on: ${top3}. Aim for at least 10 practice questions per topic before your exam.`;
+    }
+    return {
+        profileId,
+        examType: config?.exam_type,
+        topics,
+        suggestedFocus,
+        totalWeakTopics: topics.length,
+    };
+}

package/llms.txt

@@ -0,0 +1,83 @@
+# exam-prep-mcp
+
+> AI-powered exam preparation with FSRS-5 spaced repetition
+
+## Description
+
+exam-prep-mcp is a Model Context Protocol server for exam preparation. It implements the FSRS-5 (Free Spaced Repetition Scheduler) algorithm to optimally schedule practice card reviews, tracks student performance in a SQLite database, generates personalized study plans, runs mock exams, and produces readiness reports with grade estimates.
+
+## Tools
+
+### set_exam
+Configure exam preparation for a student profile.
+- profileId: string (required) - unique student identifier
+- examType: string (required) - one of the supported exam types
+- examDate: string (required) - YYYY-MM-DD format
+- currentLevel: "beginner" | "intermediate" | "advanced" (required)
+- Returns: studyPlan, topicsIdentified, daysRemaining, seededCards
+
+### get_daily_session
+Get today's practice questions via FSRS-scheduled card selection.
+- profileId: string (required)
+- Returns: questions array (cardId, subject, topic, question, type, choices), estimatedMinutes, focusAreas
+
+### answer_question
+Submit student answer, evaluate correctness, apply FSRS scheduling.
+- profileId: string (required)
+- cardId: string (required)
+- answer: string (required) - "A"/"B"/"C"/"D" for multiple choice, text for others
+- rating: 1|2|3|4 (optional) - 1=Again, 2=Hard, 3=Good, 4=Easy
+- Returns: correct (bool), correctAnswer, explanation, nextReview, intervalDays, weakAreaAlert
+
+### start_mock_exam
+Begin a full-length timed practice exam.
+- profileId: string (required)
+- Returns: sessionId, questions array, timeLimitMins, totalQuestions, instructions
+
+### submit_mock_exam
+Grade a completed mock exam and update performance data.
+- sessionId: string (required)
+- answers: Array<{cardId: string, answer: string}> (required)
+- Returns: score (0-100), correct, total, estimatedGrade, readinessScore, topicBreakdown, weakestTopics, recommendation
+
+### get_readiness
+Get comprehensive readiness report with score and grade estimate.
+- profileId: string (required)
+- Returns: score (0-100), strongTopics, weakTopics, coveragePercent, trend, recommendation, estimatedGrade
+
+### get_weak_areas
+Identify topics with accuracy below 60% needing focus.
+- profileId: string (required)
+- Returns: topics array (topic, subject, accuracy, attempts), suggestedFocus
+
+## Supported Exam Types
+
+AP_Biology, AP_Chemistry, AP_US_History, AP_World_History, AP_Physics, AP_Calculus, AP_Statistics, AP_English, AP_Economics, SAT_Math, SAT_Reading, SAT_Writing, MCAT, LSAT, GRE
+
+## Question Coverage
+
+- AP Biology: Cell Structure, DNA Replication, Transcription/Translation, Cell Division, Genetics, Evolution, Ecology, Photosynthesis, Cellular Respiration
+- AP Chemistry: Atomic Structure, Chemical Bonding, Stoichiometry, Gas Laws, Thermodynamics, Equilibrium, Acids/Bases, Electrochemistry
+- AP US History: Colonial Period, Revolution, Constitutional Convention, Civil War, Reconstruction, Progressive Era, WWI, WWII, Cold War, Civil Rights
+- SAT Math: Linear Equations, Systems, Quadratics, Percentages, Statistics, Geometry, Word Problems
+
+## Grade Estimates
+
+- AP exams: 1-5 scale (5=Extremely Well Qualified, 3=Qualified)
+- SAT Math: score ranges 400-800
+- MCAT: 472-528 scale
+- LSAT: 120-180 scale
+- GRE: 130-170 per section
+
+## Algorithm
+
+FSRS-5 parameters model memory with stability (S), difficulty (D), and retrievability R(t) = e^(-0.9t/S). Cards are scheduled at the interval where predicted retrievability equals 90%. New cards use initial stability based on rating (Again=0.41d, Hard=1.18d, Good=3.13d, Easy=15.47d).
+
+## Configuration
+
+Database: EXAM_PREP_DB environment variable, default ~/.exam-prep/study.sqlite
+
+## Installation
+
+npm install -g @gonzih/exam-prep-mcp
+or: npx @gonzih/exam-prep-mcp

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@gonzih/exam-prep-mcp",
+  "version": "0.1.0",
+  "description": "AI-powered exam preparation MCP server with FSRS spaced repetition",
+  "license": "MIT",
+  "author": "Gonzih",
+  "type": "module",
+  "bin": {
+    "exam-prep-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^9.4.3",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/node": "^20.11.5",
+    "@types/uuid": "^9.0.7",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}