@goscribe/server 1.0.7 → 1.0.9

package/dist/routers/worksheets.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
+import { aiSessionService } from '../lib/ai-session.js';
+import PusherService from '../lib/pusher.js';
 // Avoid importing Prisma enums directly; mirror values as string literals
 const ArtifactType = {
     WORKSHEET: 'WORKSHEET',
@@ -10,76 +12,171 @@ const Difficulty = {
     MEDIUM: 'MEDIUM',
     HARD: 'HARD',
 };
+const QuestionType = {
+    MULTIPLE_CHOICE: 'MULTIPLE_CHOICE',
+    TEXT: 'TEXT',
+    NUMERIC: 'NUMERIC',
+    TRUE_FALSE: 'TRUE_FALSE',
+    MATCHING: 'MATCHING',
+    FILL_IN_THE_BLANK: 'FILL_IN_THE_BLANK',
+};
 export const worksheets = router({
     // List all worksheet artifacts for a workspace
-    listSets: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid() }))
+    list: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
         .query(async ({ ctx, input }) => {
-        const workspace = await ctx.db.workspace.findFirst({
-            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-        });
-        if (!workspace)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.db.artifact.findMany({
+        const worksheets = await ctx.db.artifact.findMany({
             where: { workspaceId: input.workspaceId, type: ArtifactType.WORKSHEET },
+            include: {
+                versions: {
+                    orderBy: { version: 'desc' },
+                    take: 1, // Get only the latest version
+                },
+                questions: true,
+            },
             orderBy: { updatedAt: 'desc' },
         });
+        if (!worksheets)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        // Merge per-user progress into question.meta for compatibility with UI
+        const allQuestionIds = worksheets.flatMap(w => w.questions.map(q => q.id));
+        if (allQuestionIds.length === 0)
+            return worksheets;
+        const progress = await ctx.db.worksheetQuestionProgress.findMany({
+            where: { userId: ctx.session.user.id, worksheetQuestionId: { in: allQuestionIds } },
+        });
+        const progressByQuestionId = new Map(progress.map(p => [p.worksheetQuestionId, p]));
+        const merged = worksheets.map(w => ({
+            ...w,
+            questions: w.questions.map(q => {
+                const p = progressByQuestionId.get(q.id);
+                if (!p)
+                    return q;
+                const existingMeta = q.meta ? (typeof q.meta === 'object' ? q.meta : JSON.parse(q.meta)) : {};
+                return {
+                    ...q,
+                    meta: {
+                        ...existingMeta,
+                        completed: p.completed,
+                        userAnswer: p.userAnswer,
+                        completedAt: p.completedAt,
+                    },
+                };
+            }),
+        }));
+        return merged;
     }),
     // Create a worksheet set
-    createSet: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
+    create: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        title: z.string().min(1).max(120),
+        description: z.string().optional(),
+        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        estimatedTime: z.string().optional(),
+        problems: z.array(z.object({
+            question: z.string().min(1),
+            answer: z.string().min(1),
+            type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).default('TEXT'),
+            options: z.array(z.string()).optional(),
+        })).optional(),
+    }))
         .mutation(async ({ ctx, input }) => {
         const workspace = await ctx.db.workspace.findFirst({
             where: { id: input.workspaceId, ownerId: ctx.session.user.id },
         });
         if (!workspace)
             throw new TRPCError({ code: 'NOT_FOUND' });
+        const { problems, ...worksheetData } = input;
         return ctx.db.artifact.create({
             data: {
                 workspaceId: input.workspaceId,
                 type: ArtifactType.WORKSHEET,
                 title: input.title,
+                difficulty: input.difficulty,
+                estimatedTime: input.estimatedTime,
                 createdById: ctx.session.user.id,
+                questions: problems ? {
+                    create: problems.map((problem, index) => ({
+                        prompt: problem.question,
+                        answer: problem.answer,
+                        type: problem.type,
+                        order: index,
+                        meta: problem.options ? { options: problem.options } : undefined,
+                    })),
+                } : undefined,
+            },
+            include: {
+                questions: true,
             },
         });
     }),
     // Get a worksheet with its questions
-    getSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
+    get: authedProcedure
+        .input(z.object({ worksheetId: z.string() }))
         .query(async ({ ctx, input }) => {
-        const set = await ctx.db.artifact.findFirst({
+        const worksheet = await ctx.db.artifact.findFirst({
             where: {
-                id: input.setId,
+                id: input.worksheetId,
                 type: ArtifactType.WORKSHEET,
                 workspace: { ownerId: ctx.session.user.id },
             },
             include: { questions: true },
+            orderBy: { updatedAt: 'desc' },
         });
-        if (!set)
+        if (!worksheet)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        return set;
+        // Merge per-user progress into question.meta for compatibility with UI
+        const questionIds = worksheet.questions.map(q => q.id);
+        if (questionIds.length === 0)
+            return worksheet;
+        const progress = await ctx.db.worksheetQuestionProgress.findMany({
+            where: { userId: ctx.session.user.id, worksheetQuestionId: { in: questionIds } },
+        });
+        const progressByQuestionId = new Map(progress.map(p => [p.worksheetQuestionId, p]));
+        const merged = {
+            ...worksheet,
+            questions: worksheet.questions.map(q => {
+                const p = progressByQuestionId.get(q.id);
+                if (!p)
+                    return q;
+                const existingMeta = q.meta ? (typeof q.meta === 'object' ? q.meta : JSON.parse(q.meta)) : {};
+                return {
+                    ...q,
+                    meta: {
+                        ...existingMeta,
+                        completed: p.completed,
+                        userAnswer: p.userAnswer,
+                        completedAt: p.completedAt,
+                    },
+                };
+            }),
+        };
+        return merged;
     }),
     // Add a question to a worksheet
-    createQuestion: authedProcedure
+    createWorksheetQuestion: authedProcedure
         .input(z.object({
-        setId: z.string().uuid(),
+        worksheetId: z.string(),
         prompt: z.string().min(1),
         answer: z.string().optional(),
+        type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).optional(),
         difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
         order: z.number().int().optional(),
         meta: z.record(z.string(), z.unknown()).optional(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const set = await ctx.db.artifact.findFirst({
-            where: { id: input.setId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+        const worksheet = await ctx.db.artifact.findFirst({
+            where: { id: input.worksheetId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
         });
-        if (!set)
+        if (!worksheet)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.worksheetQuestion.create({
             data: {
-                artifactId: input.setId,
+                artifactId: input.worksheetId,
                 prompt: input.prompt,
                 answer: input.answer,
+                type: (input.type ?? QuestionType.TEXT),
                 difficulty: (input.difficulty ?? Difficulty.MEDIUM),
                 order: input.order ?? 0,
                 meta: input.meta,
@@ -87,26 +184,28 @@ export const worksheets = router({
         });
     }),
     // Update a question
-    updateQuestion: authedProcedure
+    updateWorksheetQuestion: authedProcedure
         .input(z.object({
-        questionId: z.string().uuid(),
+        worksheetQuestionId: z.string(),
         prompt: z.string().optional(),
         answer: z.string().optional(),
+        type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).optional(),
         difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
         order: z.number().int().optional(),
         meta: z.record(z.string(), z.unknown()).optional(),
     }))
         .mutation(async ({ ctx, input }) => {
         const q = await ctx.db.worksheetQuestion.findFirst({
-            where: { id: input.questionId, artifact: { type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } } },
+            where: { id: input.worksheetQuestionId, artifact: { type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } } },
         });
         if (!q)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.worksheetQuestion.update({
-            where: { id: input.questionId },
+            where: { id: input.worksheetQuestionId },
             data: {
                 prompt: input.prompt ?? q.prompt,
                 answer: input.answer ?? q.answer,
+                type: (input.type ?? q.type),
                 difficulty: (input.difficulty ?? q.difficulty),
                 order: input.order ?? q.order,
                 meta: (input.meta ?? q.meta),
@@ -114,26 +213,242 @@ export const worksheets = router({
         });
     }),
     // Delete a question
-    deleteQuestion: authedProcedure
-        .input(z.object({ questionId: z.string().uuid() }))
+    deleteWorksheetQuestion: authedProcedure
+        .input(z.object({ worksheetQuestionId: z.string() }))
         .mutation(async ({ ctx, input }) => {
         const q = await ctx.db.worksheetQuestion.findFirst({
-            where: { id: input.questionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
+            where: { id: input.worksheetQuestionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
         });
         if (!q)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        await ctx.db.worksheetQuestion.delete({ where: { id: input.questionId } });
+        await ctx.db.worksheetQuestion.delete({ where: { id: input.worksheetQuestionId } });
         return true;
     }),
+    // Update problem completion status
+    updateProblemStatus: authedProcedure
+        .input(z.object({
+        problemId: z.string(),
+        completed: z.boolean(),
+        answer: z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        // Verify question ownership through worksheet
+        const question = await ctx.db.worksheetQuestion.findFirst({
+            where: {
+                id: input.problemId,
+                artifact: {
+                    type: ArtifactType.WORKSHEET,
+                    workspace: { ownerId: ctx.session.user.id },
+                },
+            },
+        });
+        if (!question)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        // Upsert per-user progress row
+        const progress = await ctx.db.worksheetQuestionProgress.upsert({
+            where: {
+                worksheetQuestionId_userId: {
+                    worksheetQuestionId: input.problemId,
+                    userId: ctx.session.user.id,
+                },
+            },
+            create: {
+                worksheetQuestionId: input.problemId,
+                userId: ctx.session.user.id,
+                completed: input.completed,
+                userAnswer: input.answer,
+                completedAt: input.completed ? new Date() : null,
+                attempts: 1,
+            },
+            update: {
+                completed: input.completed,
+                userAnswer: input.answer,
+                completedAt: input.completed ? new Date() : null,
+                attempts: { increment: 1 },
+            },
+        });
+        return progress;
+    }),
+    // Get current user's progress for all questions in a worksheet
+    getProgress: authedProcedure
+        .input(z.object({ worksheetId: z.string() }))
+        .query(async ({ ctx, input }) => {
+        // Verify worksheet ownership
+        const worksheet = await ctx.db.artifact.findFirst({
+            where: {
+                id: input.worksheetId,
+                type: ArtifactType.WORKSHEET,
+                workspace: { ownerId: ctx.session.user.id },
+            },
+        });
+        if (!worksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const questions = await ctx.db.worksheetQuestion.findMany({
+            where: { artifactId: input.worksheetId },
+            select: { id: true },
+        });
+        const questionIds = questions.map(q => q.id);
+        const progress = await ctx.db.worksheetQuestionProgress.findMany({
+            where: {
+                userId: ctx.session.user.id,
+                worksheetQuestionId: { in: questionIds },
+            },
+        });
+        return progress;
+    }),
+    // Update a worksheet
+    update: authedProcedure
+        .input(z.object({
+        id: z.string(),
+        title: z.string().min(1).max(120).optional(),
+        description: z.string().optional(),
+        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        estimatedTime: z.string().optional(),
+        problems: z.array(z.object({
+            id: z.string().optional(),
+            question: z.string().min(1),
+            answer: z.string().min(1),
+            type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).default('TEXT'),
+            options: z.array(z.string()).optional(),
+        })).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { id, problems, ...updateData } = input;
+        // Verify worksheet ownership
+        const existingWorksheet = await ctx.db.artifact.findFirst({
+            where: {
+                id,
+                type: ArtifactType.WORKSHEET,
+                workspace: { ownerId: ctx.session.user.id },
+            },
+        });
+        if (!existingWorksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        // Handle questions update if provided
+        if (problems) {
+            // Delete existing questions and create new ones
+            await ctx.db.worksheetQuestion.deleteMany({
+                where: { artifactId: id },
+            });
+            await ctx.db.worksheetQuestion.createMany({
+                data: problems.map((problem, index) => ({
+                    artifactId: id,
+                    prompt: problem.question,
+                    answer: problem.answer,
+                    type: problem.type,
+                    order: index,
+                    meta: problem.options ? { options: problem.options } : undefined,
+                })),
+            });
+        }
+        // Process update data
+        const processedUpdateData = {
+            ...updateData,
+            difficulty: updateData.difficulty,
+        };
+        return ctx.db.artifact.update({
+            where: { id },
+            data: processedUpdateData,
+            include: {
+                questions: {
+                    orderBy: { order: 'asc' },
+                },
+            },
+        });
+    }),
     // Delete a worksheet set and its questions
-    deleteSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
+    delete: authedProcedure
+        .input(z.object({ id: z.string() }))
         .mutation(async ({ ctx, input }) => {
         const deleted = await ctx.db.artifact.deleteMany({
-            where: { id: input.setId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+            where: { id: input.id, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
         });
         if (deleted.count === 0)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return true;
     }),
+    // Generate a worksheet from a user prompt
+    generateFromPrompt: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        prompt: z.string().min(1),
+        numQuestions: z.number().int().min(1).max(20).default(8),
+        difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
+        title: z.string().optional(),
+        estimatedTime: z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const workspace = await ctx.db.workspace.findFirst({ where: { id: input.workspaceId, ownerId: ctx.session.user.id } });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_load_start', { source: 'prompt' });
+        const session = await aiSessionService.initSession(input.workspaceId);
+        await aiSessionService.setInstruction(session.id, `Create a worksheet with ${input.numQuestions} questions at ${input.difficulty} difficulty from this prompt. Return JSON.\n\nPrompt:\n${input.prompt}`);
+        await aiSessionService.startLLMSession(session.id);
+        const content = await aiSessionService.generateWorksheetQuestions(session.id, input.numQuestions, input.difficulty);
+        await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_info', { contentLength: content.length });
+        const artifact = await ctx.db.artifact.create({
+            data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.WORKSHEET,
+                title: input.title || `Worksheet - ${new Date().toLocaleString()}`,
+                createdById: ctx.session.user.id,
+                difficulty: (input.difficulty.toUpperCase()),
+                estimatedTime: input.estimatedTime,
+            },
+        });
+        try {
+            const worksheetData = JSON.parse(content);
+            let actualWorksheetData = worksheetData;
+            if (worksheetData.last_response) {
+                try {
+                    actualWorksheetData = JSON.parse(worksheetData.last_response);
+                }
+                catch { }
+            }
+            const problems = actualWorksheetData.problems || actualWorksheetData.questions || actualWorksheetData || [];
+            for (let i = 0; i < Math.min(problems.length, input.numQuestions); i++) {
+                const problem = problems[i];
+                const prompt = problem.question || problem.prompt || `Question ${i + 1}`;
+                const answer = problem.answer || problem.solution || `Answer ${i + 1}`;
+                const type = problem.type || 'TEXT';
+                const options = problem.options || [];
+                await ctx.db.worksheetQuestion.create({
+                    data: {
+                        artifactId: artifact.id,
+                        prompt,
+                        answer,
+                        difficulty: (input.difficulty.toUpperCase()),
+                        order: i,
+                        meta: {
+                            type,
+                            options: options.length > 0 ? options : undefined,
+                        },
+                    },
+                });
+            }
+        }
+        catch {
+            const lines = content.split('\n').filter(line => line.trim());
+            for (let i = 0; i < Math.min(lines.length, input.numQuestions); i++) {
+                const line = lines[i];
+                if (line.includes(' - ')) {
+                    const [q, a] = line.split(' - ');
+                    await ctx.db.worksheetQuestion.create({
+                        data: {
+                            artifactId: artifact.id,
+                            prompt: q.trim(),
+                            answer: a.trim(),
+                            difficulty: (input.difficulty.toUpperCase()),
+                            order: i,
+                            meta: { type: 'TEXT' },
+                        },
+                    });
+                }
+            }
+        }
+        await PusherService.emitWorksheetComplete(input.workspaceId, artifact);
+        aiSessionService.deleteSession(session.id);
+        return { artifact };
+    }),
 });