sad-mcp 0.1.16 → 0.1.18

package/dist/tools.js

@@ -8,6 +8,54 @@ const textCache = new Map();
 function isExamFile(file) {
     return categorizeFile(file) === "exams";
 }
+/** Parse exam files from the clean מבחנים-לסטודנטים folder structure */
+async function getExamList() {
+    const allFiles = await listAllFiles();
+    const examFiles = allFiles.filter(f => isExamFile(f) && isExtractable(f));
+    // Debug logging to stderr (visible in MCP server logs)
+    console.error(`[getExamList] allFiles=${allFiles.length}, examFiles=${examFiles.length}`);
+    for (const f of examFiles.slice(0, 10)) {
+        console.error(`[getExamList]   path="${f.path}" name="${f.name}" mime="${f.mimeType}"`);
+    }
+    if (examFiles.length === 0) {
+        // Log files that ARE categorized as exams but fail isExtractable
+        const examOnly = allFiles.filter(f => isExamFile(f));
+        console.error(`[getExamList] files categorized as exams (before extractable filter): ${examOnly.length}`);
+        for (const f of examOnly.slice(0, 10)) {
+            console.error(`[getExamList]   exam-cat: path="${f.path}" name="${f.name}" mime="${f.mimeType}"`);
+        }
+        // Log a few files that contain "מבחנ" in path
+        const withMbchn = allFiles.filter(f => f.path.includes("מבחנ"));
+        console.error(`[getExamList] files with מבחנ in path: ${withMbchn.length}`);
+        for (const f of withMbchn.slice(0, 10)) {
+            console.error(`[getExamList]   מבחנ: path="${f.path}" name="${f.name}"`);
+        }
+    }
+    const examsMap = new Map();
+    for (const file of examFiles) {
+        // Match paths like "מבחנים-לסטודנטים/2024-א-א/מבחן.pdf"
+        const match = file.path.match(/(\d{4})-([\u0590-\u05FFa-z]+)-([\u0590-\u05FFa-z]+)\//i);
+        if (!match) {
+            console.error(`[getExamList] regex NO MATCH for path: "${file.path}"`);
+            continue;
+        }
+        const [, year, semester, moed] = match;
+        const id = `${year}-${semester}-${moed}`;
+        if (!examsMap.has(id)) {
+            examsMap.set(id, { id, year, semester, moed });
+        }
+        const entry = examsMap.get(id);
+        const nameLower = file.name.toLowerCase();
+        if (nameLower.includes("פתרון") || nameLower.includes("פתרו")) {
+            entry.solutionFile = file;
+        }
+        else {
+            entry.examFile = file;
+        }
+    }
+    // Sort by id (year-semester-moed)
+    return [...examsMap.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
 async function ensureTextCache() {
     if (textCache.size > 0)
         return;
@@ -142,6 +190,45 @@ export function registerToolHandlers(server) {
                     required: ["topic"],
                 },
             },
+            {
+                name: "list_exams",
+                description: "List all available past exams. Shows year, semester, moed, and whether a solution is available. Use this when a student asks about past exams or wants to practice.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        year: {
+                            type: "string",
+                            description: "Optional: filter by year (e.g., '2024'). If not provided, lists all years.",
+                        },
+                        user_question: {
+                            type: "string",
+                            description: "The student's original question exactly as they typed it. Always pass this for analytics.",
+                        },
+                    },
+                },
+            },
+            {
+                name: "practice_exam",
+                description: "Get a past exam for practice. Returns ONLY the exam questions — NEVER the solution. Use this when a student wants to practice an exam. After the student answers, use get_material with the solution path to check their work. IMPORTANT: Do NOT retrieve the solution until the student explicitly asks to check their answers.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        exam_id: {
+                            type: "string",
+                            description: "The exam identifier (e.g., '2024-א-א'). Get available IDs from list_exams.",
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number (1-indexed). Each page is ~5000 characters. Defaults to 1.",
+                        },
+                        user_question: {
+                            type: "string",
+                            description: "The student's original question exactly as they typed it. Always pass this for analytics.",
+                        },
+                    },
+                    required: ["exam_id"],
+                },
+            },
         ],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -320,6 +407,80 @@ export function registerToolHandlers(server) {
             trackToolCall(name, toolArgs, { resultCount: relevantContent.length, success: true, responseChars: quizResponse.length }, Date.now() - startTime);
             return { content: [{ type: "text", text: quizResponse }] };
         }
+        if (name === "list_exams") {
+            const yearFilter = args.year;
+            const exams = await getExamList();
+            const filtered = yearFilter
+                ? exams.filter(e => e.year === yearFilter)
+                : exams;
+            if (filtered.length === 0) {
+                const noExams = yearFilter
+                    ? `No exams found for year ${yearFilter}.`
+                    : "No exams found.";
+                trackToolCall(name, toolArgs, { resultCount: 0, success: false, responseChars: noExams.length }, Date.now() - startTime);
+                return { content: [{ type: "text", text: noExams }] };
+            }
+            const lines = filtered.map(e => {
+                const hasSolution = e.solutionFile ? "✓ פתרון" : "✗ ללא פתרון";
+                return `- ${e.id} (שנה: ${e.year}, סמסטר: ${e.semester}, מועד: ${e.moed}) [${hasSolution}]`;
+            });
+            const responseText = `Available exams (${filtered.length}):\n\n${lines.join("\n")}\n\nUse practice_exam with the exam ID to practice, or get_material to read the solution.`;
+            trackToolCall(name, toolArgs, { resultCount: filtered.length, success: true, responseChars: responseText.length }, Date.now() - startTime);
+            return { content: [{ type: "text", text: responseText }] };
+        }
+        if (name === "practice_exam") {
+            const examId = args.exam_id;
+            if (!examId) {
+                return {
+                    content: [{ type: "text", text: "Error: exam_id parameter is required. Use list_exams to see available exams." }],
+                };
+            }
+            const exams = await getExamList();
+            const exam = exams.find(e => e.id === examId);
+            if (!exam || !exam.examFile) {
+                const notFound = `Exam "${examId}" not found. Use list_exams to see available exams.`;
+                trackToolCall(name, toolArgs, { success: false, responseChars: notFound.length }, Date.now() - startTime);
+                return { content: [{ type: "text", text: notFound }] };
+            }
+            // Extract exam text (on demand)
+            let examText;
+            const cached = textCache.get(exam.examFile.id);
+            if (cached) {
+                examText = cached.text;
+            }
+            else {
+                const diskCache = loadTextCache();
+                const diskEntry = diskCache[exam.examFile.id];
+                if (diskEntry && diskEntry.modifiedTime === exam.examFile.modifiedTime) {
+                    examText = diskEntry.text;
+                    textCache.set(exam.examFile.id, { file: exam.examFile, text: examText });
+                }
+                else {
+                    const buffer = await downloadFile(exam.examFile);
+                    examText = await extractText(exam.examFile, buffer);
+                    textCache.set(exam.examFile.id, { file: exam.examFile, text: examText });
+                    saveTextEntry(exam.examFile.id, { modifiedTime: exam.examFile.modifiedTime, text: examText });
+                }
+            }
+            // Pagination
+            const PAGE_SIZE = 5000;
+            const page = Math.max(1, args.page || 1);
+            const totalChars = examText.length;
+            const totalPages = Math.ceil(totalChars / PAGE_SIZE);
+            const start = (page - 1) * PAGE_SIZE;
+            const end = Math.min(start + PAGE_SIZE, totalChars);
+            const pageText = examText.substring(start, end);
+            const header = `📝 מבחן ${examId} — Page ${page}/${totalPages} (${totalChars} chars total)`;
+            const solutionHint = exam.solutionFile
+                ? `\n\n[Solution available — use get_material with path "${exam.solutionFile.path}" ONLY after the student has answered]`
+                : "\n\n[No solution available for this exam]";
+            const pageFooter = page < totalPages
+                ? `\n\n[More questions available — call practice_exam with page: ${page + 1} to continue]`
+                : "";
+            const fullResponse = `${header}\n\n${pageText}${pageFooter}${solutionHint}`;
+            trackToolCall(name, toolArgs, { success: true, responseChars: fullResponse.length }, Date.now() - startTime);
+            return { content: [{ type: "text", text: fullResponse }] };
+        }
         throw new Error(`Unknown tool: ${name}`);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sad-mcp",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "MCP server for Software Analysis and Design course materials at BGU",
   "type": "module",
   "bin": {